driver-spondoolies-sp30.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482
  1. /*
  2. * Copyright 2014 Con Kolivas <kernel@kolivas.org>
  3. * Copyright 2014 Zvi (Zvisha) Shteingart - Spondoolies-tech.com
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms of the GNU General Public License as published by the Free
  7. * Software Foundation; either version 3 of the License, or (at your option)
  8. * any later version. See COPYING for more details.
  9. */
  10. /*
  11. This driver communicates the job requests via Unix socket to the minergate
  12. process, that is responsible for controlling the Spondoolies Dawson SP10 miner.
  13. The jobs sent each with unique ID and returned asynchronously in one of the next
  14. transactions. REQUEST_PERIOD and REQUEST_SIZE define the communication rate with minergate.
  15. */
  16. #include <float.h>
  17. #include <limits.h>
  18. #include <pthread.h>
  19. #include <stdint.h>
  20. #include <stdio.h>
  21. #include <strings.h>
  22. #include <sys/time.h>
  23. #include <unistd.h>
  24. #include <assert.h>
  25. #include <time.h>
  26. #include <sys/socket.h>
  27. #include <sys/un.h>
  28. #include <unistd.h>
  29. #include <string.h>
  30. #include <math.h>
  31. #include "config.h"
  32. #include "compat.h"
  33. #include "miner.h"
  34. #include "driver-spondoolies-sp30-p.h"
  35. #include "driver-spondoolies-sp30.h"
  36. #ifdef WORDS_BIGENDIAN
  37. # define swap32tobe(out, in, sz) ((out == in) ? (void)0 : memmove(out, in, sz))
  38. # define LOCAL_swap32be(type, var, sz) ;
  39. # define swap32tole(out, in, sz) swap32yes(out, in, sz)
  40. # define LOCAL_swap32le(type, var, sz) LOCAL_swap32(type, var, sz)
  41. #else
  42. # define swap32tobe(out, in, sz) swap32yes(out, in, sz)
  43. # define LOCAL_swap32be(type, var, sz) LOCAL_swap32(type, var, sz)
  44. # define swap32tole(out, in, sz) ((out == in) ? (void)0 : memmove(out, in, sz))
  45. # define LOCAL_swap32le(type, var, sz) ;
  46. #endif
  47. static inline void swap32yes(void *out, const void *in, size_t sz)
  48. {
  49. size_t swapcounter;
  50. for (swapcounter = 0; swapcounter < sz; ++swapcounter)
  51. (((uint32_t*)out)[swapcounter]) = swab32(((uint32_t*)in)[swapcounter]);
  52. }
  53. static void send_minergate_pkt(const minergate_req_packet_sp30* mp_req, minergate_rsp_packet_sp30* mp_rsp,
  54. int socket_fd)
  55. {
  56. int nbytes, nwrote, nread;
  57. nbytes = sizeof(minergate_req_packet_sp30);
  58. nwrote = write(socket_fd, (const void *)mp_req, nbytes);
  59. if (unlikely(nwrote != nbytes))
  60. _quit(-1);
  61. nbytes = sizeof(minergate_rsp_packet_sp30);
  62. nread = read(socket_fd, (void *)mp_rsp, nbytes);
  63. if (unlikely(nread != nbytes))
  64. _quit(-1);
  65. assert(mp_rsp->magic == 0xcaf4);
  66. }
  67. static bool spondoolies_prepare_sp30(struct thr_info *thr)
  68. {
  69. struct cgpu_info *spondoolies_sp30 = thr->cgpu;
  70. struct timeval now;
  71. assert(spondoolies_sp30);
  72. cgtime(&now);
  73. /* FIXME: Vladik */
  74. #if NEED_FIX
  75. get_datestamp(spondoolies_sp30->init, &now);
  76. #endif
  77. return true;
  78. }
  79. static int init_socket(void)
  80. {
  81. int socket_fd;
  82. struct sockaddr_un address;
  83. socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
  84. if (socket_fd < 0) {
  85. applog(LOG_ERR, "SP30: socket error: %s", strerror(errno));
  86. return 0;
  87. }
  88. /* start with a clean address structure */
  89. memset(&address, 0, sizeof(struct sockaddr_un));
  90. address.sun_family = AF_UNIX;
  91. sprintf(address.sun_path, MINERGATE_SOCKET_FILE_SP30);
  92. if (connect(socket_fd, (struct sockaddr *) &address, sizeof(struct sockaddr_un))) {
  93. applog(LOG_ERR, "SP30: socket connect error: %s", strerror(errno));
  94. return 0;
  95. }
  96. return socket_fd;
  97. }
  98. static bool spondoolies_flush_queue(struct spond_adapter* a, bool flush_queue)
  99. {
  100. if (!a->parse_resp) {
  101. static int i = 0;
  102. if (i++ % 10 == 0 && a->works_in_minergate_and_pending_tx + a->works_pending_tx != a->works_in_driver)
  103. applog(LOG_DEBUG, "SP30: %d + %d != %d", a->works_in_minergate_and_pending_tx, a->works_pending_tx,a->works_in_driver);
  104. assert(a->works_in_minergate_and_pending_tx + a->works_pending_tx == a->works_in_driver);
  105. send_minergate_pkt(a->mp_next_req, a->mp_last_rsp, a->socket_fd);
  106. if (flush_queue) {
  107. applog(LOG_DEBUG, "SP30: FLUSH!");
  108. a->mp_next_req->mask |= 0x02;
  109. } else {
  110. a->mp_next_req->mask &= ~0x02;
  111. }
  112. a->mp_next_req->req_count = 0;
  113. a->parse_resp = 1;
  114. a->works_in_minergate_and_pending_tx += a->works_pending_tx;
  115. a->works_pending_tx = 0;
  116. }
  117. return true;
  118. }
  119. static void spondoolies_detect_sp30(__maybe_unused bool hotplug)
  120. {
  121. struct cgpu_info *cgpu = calloc(1, sizeof(*cgpu));
  122. struct device_drv *drv = &sp30_drv;
  123. struct spond_adapter *a;
  124. #if NEED_FIX
  125. nDevs = 1;
  126. #endif
  127. assert(cgpu);
  128. cgpu->drv = drv;
  129. cgpu->deven = DEV_ENABLED;
  130. cgpu->threads = 1;
  131. cgpu->device_data = calloc(sizeof(struct spond_adapter), 1);
  132. if (unlikely(!(cgpu->device_data)))
  133. quit(1, "Failed to calloc cgpu_info data");
  134. a = cgpu->device_data;
  135. a->cgpu = (void *)cgpu;
  136. a->adapter_state = ADAPTER_STATE_OPERATIONAL;
  137. a->mp_next_req = allocate_minergate_packet_req_sp30(0xca, 0xfe);
  138. a->mp_last_rsp = allocate_minergate_packet_rsp_sp30(0xca, 0xfe);
  139. pthread_mutex_init(&a->lock, NULL);
  140. a->socket_fd = init_socket();
  141. if (a->socket_fd < 1) {
  142. applog(LOG_ERR, "SP30: Failed to connect to minergate server");
  143. _quit(-1);
  144. }
  145. assert(add_cgpu(cgpu));
  146. // Clean MG socket
  147. spondoolies_flush_queue(a, true);
  148. spondoolies_flush_queue(a, true);
  149. spondoolies_flush_queue(a, true);
  150. applog(LOG_DEBUG, "SP30: SPOND spondoolies_detect_sp30 done");
  151. }
  152. static struct api_data *spondoolies_api_stats_sp30(struct cgpu_info *cgpu)
  153. {
  154. struct spond_adapter *a = cgpu->device_data;
  155. struct api_data *root = NULL;
  156. root = api_add_int(root, "ASICs total rate", &a->temp_rate, false);
  157. root = api_add_int(root, "Temperature front", &a->front_temp, false);
  158. root = api_add_int(root, "Temperature rear top", &a->rear_temp_top, false);
  159. root = api_add_int(root, "Temperature rear bot", &a->rear_temp_bot, false);
  160. return root;
  161. }
  162. #if 0
  163. static unsigned char get_leading_zeroes(const unsigned char *target)
  164. {
  165. unsigned char leading = 0;
  166. int first_non_zero_chr;
  167. uint8_t m;
  168. for (first_non_zero_chr = 31; first_non_zero_chr >= 0; first_non_zero_chr--) {
  169. if (target[first_non_zero_chr] == 0)
  170. leading += 8;
  171. else
  172. break;
  173. }
  174. // j = first non-zero
  175. m = target[first_non_zero_chr];
  176. while ((m & 0x80) == 0) {
  177. leading++;
  178. m = m << 1;
  179. }
  180. return leading;
  181. }
  182. #endif
  183. static void spondoolies_shutdown_sp30(__maybe_unused struct thr_info *thr)
  184. {
  185. }
  186. static void fill_minergate_request(minergate_do_job_req_sp30* work, struct work *cg_work, int max_offset)
  187. {
  188. uint32_t x[64 / 4];
  189. uint64_t wd;
  190. memset(work, 0, sizeof(minergate_do_job_req_sp30));
  191. //work->
  192. LOCAL_swap32le(unsigned char, cg_work->midstate, 32 / 4)
  193. LOCAL_swap32le(unsigned char, cg_work->data + 64, 64 / 4)
  194. swap32yes(x, cg_work->data + 64, 64 / 4);
  195. memcpy(work->midstate, cg_work->midstate, 32);
  196. work->mrkle_root = ntohl(x[0]);
  197. work->timestamp = ntohl(x[1]);
  198. work->difficulty = ntohl(x[2]);
  199. //work->leading_zeroes = get_leading_zeroes(cg_work->target);
  200. // Is there no better way to get leading zeroes?
  201. work->leading_zeroes = 31;
  202. wd = round(cg_work->device_diff);
  203. while (wd) {
  204. work->leading_zeroes++;
  205. wd = wd >> 1;
  206. }
  207. //printf("%d %d\n",work->leading_zeroes, (int)round(cg_work->work_difficulty));
  208. work->work_id_in_sw = cg_work->subid;
  209. work->ntime_limit = max_offset;
  210. //printf("ID:%d, TS:%x\n",work->work_id_in_sw,work->timestamp);
  211. //work->ntime_offset = ntime_offset;
  212. }
  213. // returns true if queue full.
  214. static struct timeval last_force_queue;
  215. unsigned long usec_stamp(void)
  216. {
  217. static unsigned long long int first_usec = 0;
  218. struct timeval tv;
  219. unsigned long long int curr_usec;
  220. cgtime(&tv);
  221. curr_usec = tv.tv_sec * 1000000 + tv.tv_usec;
  222. if (first_usec == 0) {
  223. first_usec = curr_usec;
  224. curr_usec = 0;
  225. } else
  226. curr_usec -= first_usec;
  227. return curr_usec;
  228. }
  229. static bool spondoolies_queue_full_sp30(struct cgpu_info *cgpu)
  230. {
  231. struct spond_adapter* a = cgpu->device_data;
  232. #if 0
  233. static int bla = 0;
  234. if (!((bla++)%500)) {
  235. printf("FAKE TEST FLUSH T:%d!\n",usec_stamp());
  236. a->reset_mg_queue = 3;
  237. }
  238. #endif
  239. // Only once every 1/10 second do work.
  240. bool ret = false, do_sleep = false;
  241. int next_job_id;
  242. struct timeval tv;
  243. struct work *work;
  244. unsigned int usec;
  245. mutex_lock(&a->lock);
  246. assert(a->works_pending_tx <= REQUEST_SIZE);
  247. gettimeofday(&tv, NULL);
  248. usec = (tv.tv_sec-last_force_queue.tv_sec) * 1000000;
  249. usec += (tv.tv_usec-last_force_queue.tv_usec);
  250. if ((usec >= REQUEST_PERIOD) ||
  251. (a->reset_mg_queue == 3) || // push flush
  252. ((a->reset_mg_queue == 2)) || // Fast pull
  253. ((a->reset_mg_queue == 1) && (a->works_pending_tx == REQUEST_SIZE))) { // Fast push after flush
  254. spondoolies_flush_queue(a, (a->reset_mg_queue == 3));
  255. if (a->reset_mg_queue) {
  256. //printf("FLUSH(%d) %d T:%d\n",a->reset_mg_queue , a->works_pending_tx, usec_stamp());
  257. if (a->works_pending_tx || (a->reset_mg_queue == 3)) {
  258. a->reset_mg_queue--;
  259. }
  260. }
  261. last_force_queue = tv;
  262. }
  263. // see if we have enough jobs
  264. if (a->works_pending_tx == REQUEST_SIZE) {
  265. ret = true;
  266. goto return_unlock;
  267. }
  268. // see if can take 1 more job.
  269. // Must be smaller to prevent overflow.
  270. assert(MAX_JOBS_PENDING_IN_MINERGATE_SP30 < MINERGATE_ADAPTER_QUEUE_SP30);
  271. next_job_id = (a->current_job_id + 1) % MAX_JOBS_PENDING_IN_MINERGATE_SP30;
  272. if (a->my_jobs[next_job_id].cgminer_work) {
  273. ret = true;
  274. goto return_unlock;
  275. }
  276. work = get_queued(cgpu);
  277. if (unlikely(!work)) {
  278. do_sleep = true;
  279. goto return_unlock;
  280. }
  281. work->thr = cgpu->thr[0];
  282. work->thr_id = cgpu->thr[0]->id;
  283. assert(work->thr);
  284. a->current_job_id = next_job_id;
  285. work->subid = a->current_job_id;
  286. // Get pointer for the request
  287. a->my_jobs[a->current_job_id].cgminer_work = work;
  288. a->my_jobs[a->current_job_id].state = SPONDWORK_STATE_IN_BUSY;
  289. //printf("Push: %d\n", a->current_job_id);
  290. int max_ntime_roll = (work->drv_rolllimit < MAX_NROLES) ? work->drv_rolllimit : MAX_NROLES;
  291. minergate_do_job_req_sp30* pkt_job = &a->mp_next_req->req[a->works_pending_tx];
  292. fill_minergate_request(pkt_job, work, max_ntime_roll);
  293. a->works_in_driver++;
  294. a->works_pending_tx++;
  295. a->mp_next_req->req_count++;
  296. a->my_jobs[a->current_job_id].merkle_root = pkt_job->mrkle_root;
  297. return_unlock:
  298. //printf("D:P.TX:%d inD:%d\n", a->works_pending_tx, a->works_in_driver);
  299. mutex_unlock(&a->lock);
  300. if (do_sleep)
  301. cgsleep_ms(10);
  302. return ret;
  303. }
  304. static void spond_poll_stats(struct cgpu_info *spond, struct spond_adapter *a)
  305. {
  306. FILE *fp = fopen("/var/run/mg_rate_temp", "r");
  307. if (!fp) {
  308. applog(LOG_DEBUG, "SP30: SPOND unable to open mg_rate_temp");
  309. a->temp_rate = a->front_temp = a->rear_temp_top = a->rear_temp_bot = 0;
  310. } else {
  311. int ret = fscanf(fp, "%d %d %d %d", &a->temp_rate, &a->front_temp , &a->rear_temp_top , &a->rear_temp_bot);
  312. if (ret != 4)
  313. a->temp_rate = a->front_temp = a->rear_temp_top = a->rear_temp_bot = 0;
  314. fclose(fp);
  315. }
  316. applog(LOG_DEBUG, "SP30: SPOND poll_stats rate: %d front: %d rear(T/B): %d/%d",
  317. a->temp_rate, a->front_temp , a->rear_temp_top, a->rear_temp_bot);
  318. /* Use the rear temperature as the dev temperature for now */
  319. spond->temp = (a->rear_temp_top + a->rear_temp_bot)/2;
  320. }
  321. // Return completed work to submit_nonce() and work_completed()
  322. // struct timeval last_force_queue = {0};
  323. static int64_t spond_scanhash_sp30(struct thr_info *thr)
  324. {
  325. struct cgpu_info *cgpu = thr->cgpu;
  326. struct spond_adapter *a = cgpu->device_data;
  327. int64_t ghashes = 0;
  328. cgtimer_t cgt;
  329. time_t now_t;
  330. cgsleep_prepare_r(&cgt);
  331. now_t = time(NULL);
  332. /* Poll stats only once per second */
  333. if (now_t != a->last_stats) {
  334. a->last_stats = now_t;
  335. spond_poll_stats(cgpu, a);
  336. }
  337. if (a->parse_resp) {
  338. int array_size, i;
  339. mutex_lock(&a->lock);
  340. //ghashes = (a->mp_last_rsp->gh_div_50_rate);
  341. //ghashes = ghashes * 50000 * REQUEST_PERIOD;
  342. array_size = a->mp_last_rsp->rsp_count;
  343. for (i = 0; i < array_size; i++) { // walk the jobs
  344. int job_id;
  345. minergate_do_job_rsp_sp30* work = a->mp_last_rsp->rsp + i;
  346. job_id = work->work_id_in_sw;
  347. if ((a->my_jobs[job_id].cgminer_work)) {
  348. if (a->my_jobs[job_id].merkle_root == work->mrkle_root) {
  349. assert(a->my_jobs[job_id].state == SPONDWORK_STATE_IN_BUSY);
  350. if (work->winner_nonce) {
  351. struct work *cg_work = a->my_jobs[job_id].cgminer_work;
  352. bool ok;
  353. ok = submit_noffset_nonce(cg_work->thr, cg_work, work->winner_nonce, work->ntime_offset);
  354. if (ok)
  355. ghashes += 0xffffffffull * cg_work->device_diff;
  356. /*printf("WIn on %d (+%d), none=%x = %d\n",
  357. * work->work_id_in_sw, work->ntime_offset, htole32(work->winner_nonce), ok);*/
  358. a->wins++;
  359. }
  360. //printf("%d ntime_clones = %d\n",job_id,a->my_jobs[job_id].ntime_clones);
  361. //printf("Done with %d\n", job_id);
  362. if (work->job_complete) {
  363. //printf("Complete %d\n", job_id);
  364. work_completed(a->cgpu, a->my_jobs[job_id].cgminer_work);
  365. a->good++;
  366. a->my_jobs[job_id].cgminer_work = NULL;
  367. a->my_jobs[job_id].state = SPONDWORK_STATE_EMPTY;
  368. a->works_in_minergate_and_pending_tx--;
  369. a->works_in_driver--;
  370. }
  371. } else {
  372. a->bad++;
  373. applog(LOG_DEBUG, "SP30: Dropping minergate old job id=%d mrkl=%x my-mrkl=%x",
  374. job_id, a->my_jobs[job_id].merkle_root, work->mrkle_root);
  375. }
  376. } else {
  377. a->empty++;
  378. applog(LOG_DEBUG, "SP30: No cgminer job (id:%d res:%d)!",job_id, work->res);
  379. }
  380. }
  381. mutex_unlock(&a->lock);
  382. a->parse_resp = 0;
  383. }
  384. cgsleep_ms_r(&cgt, 40);
  385. return ghashes;
  386. }
  387. // Remove all work from queue
  388. static void spond_flush_work_sp30(struct cgpu_info *cgpu)
  389. {
  390. struct spond_adapter *a = cgpu->device_data;
  391. //printf("GOT FLUSH!%d\n");
  392. mutex_lock(&a->lock);
  393. a->reset_mg_queue = 3;
  394. mutex_unlock(&a->lock);
  395. }
  396. struct device_drv sp30_drv = {
  397. .drv_id = DRIVER_sp30,
  398. .dname = "Sp30",
  399. .name = "S30",
  400. .min_diff = 16,
  401. .max_diff = 1024.0, // Limit max diff to get some nonces back regardless
  402. .drv_detect = spondoolies_detect_sp30,
  403. .get_api_stats = spondoolies_api_stats_sp30,
  404. .thread_prepare = spondoolies_prepare_sp30,
  405. .thread_shutdown = spondoolies_shutdown_sp30,
  406. .hash_work = hash_queued_work,
  407. .queue_full = spondoolies_queue_full_sp30,
  408. .scanwork = spond_scanhash_sp30,
  409. .flush_work = spond_flush_work_sp30,
  410. };