driver-bitforce.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752
  1. /*
  2. * Copyright 2012-2013 Andrew Smith
  3. * Copyright 2012 Luke Dashjr
  4. * Copyright 2012 Con Kolivas
  5. *
  6. * This program is free software; you can redistribute it and/or modify it
  7. * under the terms of the GNU General Public License as published by the Free
  8. * Software Foundation; either version 3 of the License, or (at your option)
  9. * any later version. See COPYING for more details.
  10. */
  11. #include "config.h"
  12. #include <limits.h>
  13. #include <pthread.h>
  14. #include <stdint.h>
  15. #include <stdio.h>
  16. #include <strings.h>
  17. #include <sys/time.h>
  18. #include <unistd.h>
  19. #include "compat.h"
  20. #include "miner.h"
  21. #include "usbutils.h"
  22. #include "util.h"
  23. #ifdef WIN32
  24. #include <windows.h>
  25. #endif /* WIN32 */
  26. #define BITFORCE_IDENTIFY "ZGX"
  27. #define BITFORCE_IDENTIFY_LEN (sizeof(BITFORCE_IDENTIFY)-1)
  28. #define BITFORCE_FLASH "ZMX"
  29. #define BITFORCE_FLASH_LEN (sizeof(BITFORCE_FLASH)-1)
  30. #define BITFORCE_TEMPERATURE "ZLX"
  31. #define BITFORCE_TEMPERATURE_LEN (sizeof(BITFORCE_TEMPERATURE)-1)
  32. #define BITFORCE_SENDRANGE "ZPX"
  33. #define BITFORCE_SENDRANGE_LEN (sizeof(BITFORCE_SENDRANGE)-1)
  34. #define BITFORCE_SENDWORK "ZDX"
  35. #define BITFORCE_SENDWORK_LEN (sizeof(BITFORCE_SENDWORK)-1)
  36. #define BITFORCE_WORKSTATUS "ZFX"
  37. #define BITFORCE_WORKSTATUS_LEN (sizeof(BITFORCE_WORKSTATUS)-1)
  38. // Either of Nonce or No-nonce start with:
  39. #define BITFORCE_EITHER "N"
  40. #define BITFORCE_EITHER_LEN 1
  41. #define BITFORCE_NONCE "NONCE-FOUND"
  42. #define BITFORCE_NONCE_LEN (sizeof(BITFORCE_NONCE)-1)
  43. #define BITFORCE_NO_NONCE "NO-NONCE"
  44. #define BITFORCE_NO_NONCE_MATCH 3
  45. #define BITFORCE_IDLE "IDLE"
  46. #define BITFORCE_IDLE_MATCH 1
  47. #define BITFORCE_SLEEP_MS 500
  48. #define BITFORCE_TIMEOUT_S 7
  49. #define BITFORCE_TIMEOUT_MS (BITFORCE_TIMEOUT_S * 1000)
  50. #define BITFORCE_LONG_TIMEOUT_S 30
  51. #define BITFORCE_LONG_TIMEOUT_MS (BITFORCE_LONG_TIMEOUT_S * 1000)
  52. #define BITFORCE_CHECK_INTERVAL_MS 10
  53. #define WORK_CHECK_INTERVAL_MS 50
  54. #define MAX_START_DELAY_MS 100
  55. #define tv_to_ms(tval) (tval.tv_sec * 1000 + tval.tv_usec / 1000)
  56. #define TIME_AVG_CONSTANT 8
  57. #define KNAME_WORK "full work"
  58. #define KNAME_RANGE "nonce range"
  59. #define BITFORCE_BUFSIZ (0x200)
  60. // If initialisation fails the first time,
  61. // sleep this amount (ms) and try again
  62. #define REINIT_TIME_FIRST_MS 100
  63. // Max ms per sleep
  64. #define REINIT_TIME_MAX_MS 800
  65. // Keep trying up to this many us
  66. #define REINIT_TIME_MAX 3000000
  67. static const char *blank = "";
  68. static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
  69. {
  70. int err, interface;
  71. if (lock)
  72. mutex_lock(&bitforce->device_mutex);
  73. if (bitforce->usbinfo.nodev)
  74. goto failed;
  75. interface = usb_interface(bitforce);
  76. // Reset
  77. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
  78. FTDI_VALUE_RESET, interface, C_RESET);
  79. if (opt_debug)
  80. applog(LOG_DEBUG, "%s%i: reset got err %d",
  81. bitforce->drv->name, bitforce->device_id, err);
  82. if (bitforce->usbinfo.nodev)
  83. goto failed;
  84. // Set data control
  85. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
  86. FTDI_VALUE_DATA_BFL, interface, C_SETDATA);
  87. if (opt_debug)
  88. applog(LOG_DEBUG, "%s%i: setdata got err %d",
  89. bitforce->drv->name, bitforce->device_id, err);
  90. if (bitforce->usbinfo.nodev)
  91. goto failed;
  92. // Set the baud
  93. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD_BFL,
  94. (FTDI_INDEX_BAUD_BFL & 0xff00) | interface,
  95. C_SETBAUD);
  96. if (opt_debug)
  97. applog(LOG_DEBUG, "%s%i: setbaud got err %d",
  98. bitforce->drv->name, bitforce->device_id, err);
  99. if (bitforce->usbinfo.nodev)
  100. goto failed;
  101. // Set Flow Control
  102. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
  103. FTDI_VALUE_FLOW, interface, C_SETFLOW);
  104. if (opt_debug)
  105. applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
  106. bitforce->drv->name, bitforce->device_id, err);
  107. if (bitforce->usbinfo.nodev)
  108. goto failed;
  109. // Set Modem Control
  110. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
  111. FTDI_VALUE_MODEM, interface, C_SETMODEM);
  112. if (opt_debug)
  113. applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
  114. bitforce->drv->name, bitforce->device_id, err);
  115. if (bitforce->usbinfo.nodev)
  116. goto failed;
  117. // Clear any sent data
  118. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
  119. FTDI_VALUE_PURGE_TX, interface, C_PURGETX);
  120. if (opt_debug)
  121. applog(LOG_DEBUG, "%s%i: purgetx got err %d",
  122. bitforce->drv->name, bitforce->device_id, err);
  123. if (bitforce->usbinfo.nodev)
  124. goto failed;
  125. // Clear any received data
  126. err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
  127. FTDI_VALUE_PURGE_RX, interface, C_PURGERX);
  128. if (opt_debug)
  129. applog(LOG_DEBUG, "%s%i: purgerx got err %d",
  130. bitforce->drv->name, bitforce->device_id, err);
  131. failed:
  132. if (lock)
  133. mutex_unlock(&bitforce->device_mutex);
  134. }
  135. static struct cgpu_info *bitforce_detect_one(struct libusb_device *dev, struct usb_find_devices *found)
  136. {
  137. char buf[BITFORCE_BUFSIZ+1];
  138. int err, amount;
  139. char *s;
  140. struct timeval init_start, init_now;
  141. int init_sleep, init_count;
  142. bool ident_first;
  143. struct cgpu_info *bitforce = usb_alloc_cgpu(&bitforce_drv, 1);
  144. if (!usb_init(bitforce, dev, found))
  145. goto shin;
  146. // Allow 2 complete attempts if the 1st time returns an unrecognised reply
  147. ident_first = true;
  148. retry:
  149. init_count = 0;
  150. init_sleep = REINIT_TIME_FIRST_MS;
  151. cgtime(&init_start);
  152. reinit:
  153. bitforce_initialise(bitforce, false);
  154. if ((err = usb_write(bitforce, BITFORCE_IDENTIFY, BITFORCE_IDENTIFY_LEN, &amount, C_REQUESTIDENTIFY)) < 0 || amount != BITFORCE_IDENTIFY_LEN) {
  155. applog(LOG_ERR, "%s detect (%s) send identify request failed (%d:%d)",
  156. bitforce->drv->dname, bitforce->device_path, amount, err);
  157. goto unshin;
  158. }
  159. if ((err = usb_read_nl(bitforce, buf, sizeof(buf)-1, &amount, C_GETIDENTIFY)) < 0 || amount < 1) {
  160. init_count++;
  161. cgtime(&init_now);
  162. if (us_tdiff(&init_now, &init_start) <= REINIT_TIME_MAX) {
  163. if (init_count == 2) {
  164. applog(LOG_WARNING, "%s detect (%s) 2nd init failed (%d:%d) - retrying",
  165. bitforce->drv->dname, bitforce->device_path, amount, err);
  166. }
  167. cgsleep_ms(init_sleep);
  168. if ((init_sleep * 2) <= REINIT_TIME_MAX_MS)
  169. init_sleep *= 2;
  170. goto reinit;
  171. }
  172. if (init_count > 0)
  173. applog(LOG_WARNING, "%s detect (%s) init failed %d times %.2fs",
  174. bitforce->drv->dname, bitforce->device_path, init_count, tdiff(&init_now, &init_start));
  175. if (err < 0) {
  176. applog(LOG_ERR, "%s detect (%s) error identify reply (%d:%d)",
  177. bitforce->drv->dname, bitforce->device_path, amount, err);
  178. } else {
  179. applog(LOG_ERR, "%s detect (%s) empty identify reply (%d)",
  180. bitforce->drv->dname, bitforce->device_path, amount);
  181. }
  182. goto unshin;
  183. }
  184. buf[amount] = '\0';
  185. if (unlikely(!strstr(buf, "SHA256"))) {
  186. if (ident_first) {
  187. applog(LOG_WARNING, "%s detect (%s) didn't recognise '%s' trying again ...",
  188. bitforce->drv->dname, bitforce->device_path, buf);
  189. ident_first = false;
  190. goto retry;
  191. }
  192. applog(LOG_ERR, "%s detect (%s) didn't recognise '%s' on 2nd attempt",
  193. bitforce->drv->dname, bitforce->device_path, buf);
  194. goto unshin;
  195. }
  196. if (strstr(buf, "SHA256 SC")) {
  197. #ifdef USE_BFLSC
  198. applog(LOG_DEBUG, "SC device detected, will defer to BFLSC driver");
  199. #else
  200. applog(LOG_WARNING, "SC device detected but no BFLSC support compiled in!");
  201. #endif
  202. goto unshin;
  203. }
  204. if (likely((!memcmp(buf, ">>>ID: ", 7)) && (s = strstr(buf + 3, ">>>")))) {
  205. s[0] = '\0';
  206. bitforce->name = strdup(buf + 7);
  207. } else {
  208. bitforce->name = (char *)blank;
  209. }
  210. // We have a real BitForce!
  211. applog(LOG_DEBUG, "%s (%s) identified as: '%s'",
  212. bitforce->drv->dname, bitforce->device_path, bitforce->name);
  213. /* Initially enable support for nonce range and disable it later if it
  214. * fails */
  215. if (opt_bfl_noncerange) {
  216. bitforce->nonce_range = true;
  217. bitforce->sleep_ms = BITFORCE_SLEEP_MS;
  218. bitforce->kname = KNAME_RANGE;
  219. } else {
  220. bitforce->sleep_ms = BITFORCE_SLEEP_MS * 5;
  221. bitforce->kname = KNAME_WORK;
  222. }
  223. if (!add_cgpu(bitforce))
  224. goto unshin;
  225. update_usb_stats(bitforce);
  226. mutex_init(&bitforce->device_mutex);
  227. return bitforce;
  228. unshin:
  229. usb_uninit(bitforce);
  230. shin:
  231. if (bitforce->name != blank) {
  232. free(bitforce->name);
  233. bitforce->name = NULL;
  234. }
  235. bitforce = usb_free_cgpu(bitforce);
  236. return NULL;
  237. }
  238. static void bitforce_detect(bool __maybe_unused hotplug)
  239. {
  240. usb_detect(&bitforce_drv, bitforce_detect_one);
  241. }
  242. static void get_bitforce_statline_before(char *buf, size_t bufsiz, struct cgpu_info *bitforce)
  243. {
  244. float gt = bitforce->temp;
  245. if (gt > 0)
  246. tailsprintf(buf, bufsiz, "%5.1fC", gt);
  247. }
  248. static bool bitforce_thread_prepare(__maybe_unused struct thr_info *thr)
  249. {
  250. // struct cgpu_info *bitforce = thr->cgpu;
  251. return true;
  252. }
  253. static void bitforce_flash_led(struct cgpu_info *bitforce)
  254. {
  255. int err, amount;
  256. /* Do not try to flash the led if we're polling for a result to
  257. * minimise the chance of interleaved results */
  258. if (bitforce->polling)
  259. return;
  260. /* It is not critical flashing the led so don't get stuck if we
  261. * can't grab the mutex now */
  262. if (mutex_trylock(&bitforce->device_mutex))
  263. return;
  264. if ((err = usb_write(bitforce, BITFORCE_FLASH, BITFORCE_FLASH_LEN, &amount, C_REQUESTFLASH)) < 0 || amount != BITFORCE_FLASH_LEN) {
  265. applog(LOG_ERR, "%s%i: flash request failed (%d:%d)",
  266. bitforce->drv->name, bitforce->device_id, amount, err);
  267. } else {
  268. /* However, this stops anything else getting a reply
  269. * So best to delay any other access to the BFL */
  270. cgsleep_ms(4000);
  271. }
  272. /* Once we've tried - don't do it until told to again */
  273. bitforce->flash_led = false;
  274. mutex_unlock(&bitforce->device_mutex);
  275. return; // nothing is returned by the BFL
  276. }
  277. static bool bitforce_get_temp(struct cgpu_info *bitforce)
  278. {
  279. char buf[BITFORCE_BUFSIZ+1];
  280. int err, amount;
  281. char *s;
  282. // Device is gone
  283. if (bitforce->usbinfo.nodev)
  284. return false;
  285. /* Do not try to get the temperature if we're polling for a result to
  286. * minimise the chance of interleaved results */
  287. if (bitforce->polling)
  288. return true;
  289. // Flash instead of Temp - doing both can be too slow
  290. if (bitforce->flash_led) {
  291. bitforce_flash_led(bitforce);
  292. return true;
  293. }
  294. /* It is not critical getting temperature so don't get stuck if we
  295. * can't grab the mutex here */
  296. if (mutex_trylock(&bitforce->device_mutex))
  297. return false;
  298. if ((err = usb_write(bitforce, BITFORCE_TEMPERATURE, BITFORCE_TEMPERATURE_LEN, &amount, C_REQUESTTEMPERATURE)) < 0 || amount != BITFORCE_TEMPERATURE_LEN) {
  299. mutex_unlock(&bitforce->device_mutex);
  300. applog(LOG_ERR, "%s%i: Error: Request temp invalid/timed out (%d:%d)",
  301. bitforce->drv->name, bitforce->device_id, amount, err);
  302. bitforce->hw_errors++;
  303. return false;
  304. }
  305. if ((err = usb_read_nl(bitforce, buf, sizeof(buf)-1, &amount, C_GETTEMPERATURE)) < 0 || amount < 1) {
  306. mutex_unlock(&bitforce->device_mutex);
  307. if (err < 0) {
  308. applog(LOG_ERR, "%s%i: Error: Get temp return invalid/timed out (%d:%d)",
  309. bitforce->drv->name, bitforce->device_id, amount, err);
  310. } else {
  311. applog(LOG_ERR, "%s%i: Error: Get temp returned nothing (%d:%d)",
  312. bitforce->drv->name, bitforce->device_id, amount, err);
  313. }
  314. bitforce->hw_errors++;
  315. return false;
  316. }
  317. mutex_unlock(&bitforce->device_mutex);
  318. if ((!strncasecmp(buf, "TEMP", 4)) && (s = strchr(buf + 4, ':'))) {
  319. float temp = strtof(s + 1, NULL);
  320. /* Cope with older software that breaks and reads nonsense
  321. * values */
  322. if (temp > 100)
  323. temp = strtod(s + 1, NULL);
  324. if (temp > 0) {
  325. bitforce->temp = temp;
  326. if (unlikely(bitforce->cutofftemp > 0 && temp > bitforce->cutofftemp)) {
  327. applog(LOG_WARNING, "%s%i: Hit thermal cutoff limit, disabling!",
  328. bitforce->drv->name, bitforce->device_id);
  329. bitforce->deven = DEV_RECOVER;
  330. dev_error(bitforce, REASON_DEV_THERMAL_CUTOFF);
  331. }
  332. }
  333. } else {
  334. /* Use the temperature monitor as a kind of watchdog for when
  335. * our responses are out of sync and flush the buffer to
  336. * hopefully recover */
  337. applog(LOG_WARNING, "%s%i: Garbled response probably throttling, clearing buffer",
  338. bitforce->drv->name, bitforce->device_id);
  339. dev_error(bitforce, REASON_DEV_THROTTLE);
  340. /* Count throttling episodes as hardware errors */
  341. bitforce->hw_errors++;
  342. bitforce_initialise(bitforce, true);
  343. return false;
  344. }
  345. return true;
  346. }
  347. static bool bitforce_send_work(struct thr_info *thr, struct work *work)
  348. {
  349. struct cgpu_info *bitforce = thr->cgpu;
  350. unsigned char ob[70];
  351. char buf[BITFORCE_BUFSIZ+1];
  352. int err, amount;
  353. char *s;
  354. char *cmd;
  355. int len;
  356. re_send:
  357. if (bitforce->nonce_range) {
  358. cmd = BITFORCE_SENDRANGE;
  359. len = BITFORCE_SENDRANGE_LEN;
  360. } else {
  361. cmd = BITFORCE_SENDWORK;
  362. len = BITFORCE_SENDWORK_LEN;
  363. }
  364. mutex_lock(&bitforce->device_mutex);
  365. if ((err = usb_write(bitforce, cmd, len, &amount, C_REQUESTSENDWORK)) < 0 || amount != len) {
  366. mutex_unlock(&bitforce->device_mutex);
  367. applog(LOG_ERR, "%s%i: request send work failed (%d:%d)",
  368. bitforce->drv->name, bitforce->device_id, amount, err);
  369. return false;
  370. }
  371. if ((err = usb_read_nl(bitforce, buf, sizeof(buf)-1, &amount, C_REQUESTSENDWORKSTATUS)) < 0) {
  372. mutex_unlock(&bitforce->device_mutex);
  373. applog(LOG_ERR, "%s%d: read request send work status failed (%d:%d)",
  374. bitforce->drv->name, bitforce->device_id, amount, err);
  375. return false;
  376. }
  377. if (amount == 0 || !buf[0] || !strncasecmp(buf, "B", 1)) {
  378. mutex_unlock(&bitforce->device_mutex);
  379. cgsleep_ms(WORK_CHECK_INTERVAL_MS);
  380. goto re_send;
  381. } else if (unlikely(strncasecmp(buf, "OK", 2))) {
  382. mutex_unlock(&bitforce->device_mutex);
  383. if (bitforce->nonce_range) {
  384. applog(LOG_WARNING, "%s%i: Does not support nonce range, disabling",
  385. bitforce->drv->name, bitforce->device_id);
  386. bitforce->nonce_range = false;
  387. bitforce->sleep_ms *= 5;
  388. bitforce->kname = KNAME_WORK;
  389. goto re_send;
  390. }
  391. applog(LOG_ERR, "%s%i: Error: Send work reports: %s",
  392. bitforce->drv->name, bitforce->device_id, buf);
  393. return false;
  394. }
  395. sprintf((char *)ob, ">>>>>>>>");
  396. memcpy(ob + 8, work->midstate, 32);
  397. memcpy(ob + 8 + 32, work->data + 64, 12);
  398. if (!bitforce->nonce_range) {
  399. sprintf((char *)ob + 8 + 32 + 12, ">>>>>>>>");
  400. work->nonce = bitforce->nonces = 0xffffffff;
  401. len = 60;
  402. } else {
  403. uint32_t *nonce;
  404. nonce = (uint32_t *)(ob + 8 + 32 + 12);
  405. *nonce = htobe32(work->nonce);
  406. nonce = (uint32_t *)(ob + 8 + 32 + 12 + 4);
  407. /* Split work up into 1/5th nonce ranges */
  408. bitforce->nonces = 0x33333332;
  409. *nonce = htobe32(work->nonce + bitforce->nonces);
  410. work->nonce += bitforce->nonces + 1;
  411. sprintf((char *)ob + 8 + 32 + 12 + 8, ">>>>>>>>");
  412. len = 68;
  413. }
  414. if ((err = usb_write(bitforce, (char *)ob, len, &amount, C_SENDWORK)) < 0 || amount != len) {
  415. mutex_unlock(&bitforce->device_mutex);
  416. applog(LOG_ERR, "%s%i: send work failed (%d:%d)",
  417. bitforce->drv->name, bitforce->device_id, amount, err);
  418. return false;
  419. }
  420. if ((err = usb_read_nl(bitforce, buf, sizeof(buf)-1, &amount, C_SENDWORKSTATUS)) < 0) {
  421. mutex_unlock(&bitforce->device_mutex);
  422. applog(LOG_ERR, "%s%d: read send work status failed (%d:%d)",
  423. bitforce->drv->name, bitforce->device_id, amount, err);
  424. return false;
  425. }
  426. mutex_unlock(&bitforce->device_mutex);
  427. if (opt_debug) {
  428. s = bin2hex(ob + 8, 44);
  429. applog(LOG_DEBUG, "%s%i: block data: %s",
  430. bitforce->drv->name, bitforce->device_id, s);
  431. free(s);
  432. }
  433. if (amount == 0 || !buf[0]) {
  434. applog(LOG_ERR, "%s%i: Error: Send block data returned empty string/timed out",
  435. bitforce->drv->name, bitforce->device_id);
  436. return false;
  437. }
  438. if (unlikely(strncasecmp(buf, "OK", 2))) {
  439. applog(LOG_ERR, "%s%i: Error: Send block data reports: %s",
  440. bitforce->drv->name, bitforce->device_id, buf);
  441. return false;
  442. }
  443. cgtime(&bitforce->work_start_tv);
  444. return true;
  445. }
  446. static int64_t bitforce_get_result(struct thr_info *thr, struct work *work)
  447. {
  448. struct cgpu_info *bitforce = thr->cgpu;
  449. unsigned int delay_time_ms;
  450. struct timeval elapsed;
  451. struct timeval now;
  452. char buf[BITFORCE_BUFSIZ+1];
  453. int amount;
  454. char *pnoncebuf;
  455. uint32_t nonce;
  456. while (1) {
  457. if (unlikely(thr->work_restart))
  458. return 0;
  459. mutex_lock(&bitforce->device_mutex);
  460. usb_write(bitforce, BITFORCE_WORKSTATUS, BITFORCE_WORKSTATUS_LEN, &amount, C_REQUESTWORKSTATUS);
  461. usb_read_nl(bitforce, buf, sizeof(buf)-1, &amount, C_GETWORKSTATUS);
  462. mutex_unlock(&bitforce->device_mutex);
  463. cgtime(&now);
  464. timersub(&now, &bitforce->work_start_tv, &elapsed);
  465. if (elapsed.tv_sec >= BITFORCE_LONG_TIMEOUT_S) {
  466. applog(LOG_ERR, "%s%i: took %ldms - longer than %dms",
  467. bitforce->drv->name, bitforce->device_id,
  468. tv_to_ms(elapsed), BITFORCE_LONG_TIMEOUT_MS);
  469. return 0;
  470. }
  471. if (amount > 0 && buf[0] && strncasecmp(buf, "B", 1)) /* BFL does not respond during throttling */
  472. break;
  473. /* if BFL is throttling, no point checking so quickly */
  474. delay_time_ms = (buf[0] ? BITFORCE_CHECK_INTERVAL_MS : 2 * WORK_CHECK_INTERVAL_MS);
  475. cgsleep_ms(delay_time_ms);
  476. bitforce->wait_ms += delay_time_ms;
  477. }
  478. if (elapsed.tv_sec > BITFORCE_TIMEOUT_S) {
  479. applog(LOG_ERR, "%s%i: took %ldms - longer than %dms",
  480. bitforce->drv->name, bitforce->device_id,
  481. tv_to_ms(elapsed), BITFORCE_TIMEOUT_MS);
  482. dev_error(bitforce, REASON_DEV_OVER_HEAT);
  483. /* Only return if we got nothing after timeout - there still may be results */
  484. if (amount == 0)
  485. return 0;
  486. } else if (!strncasecmp(buf, BITFORCE_EITHER, BITFORCE_EITHER_LEN)) {
  487. /* Simple timing adjustment. Allow a few polls to cope with
  488. * OS timer delays being variably reliable. wait_ms will
  489. * always equal sleep_ms when we've waited greater than or
  490. * equal to the result return time.*/
  491. delay_time_ms = bitforce->sleep_ms;
  492. if (bitforce->wait_ms > bitforce->sleep_ms + (WORK_CHECK_INTERVAL_MS * 2))
  493. bitforce->sleep_ms += (bitforce->wait_ms - bitforce->sleep_ms) / 2;
  494. else if (bitforce->wait_ms == bitforce->sleep_ms) {
  495. if (bitforce->sleep_ms > WORK_CHECK_INTERVAL_MS)
  496. bitforce->sleep_ms -= WORK_CHECK_INTERVAL_MS;
  497. else if (bitforce->sleep_ms > BITFORCE_CHECK_INTERVAL_MS)
  498. bitforce->sleep_ms -= BITFORCE_CHECK_INTERVAL_MS;
  499. }
  500. if (delay_time_ms != bitforce->sleep_ms)
  501. applog(LOG_DEBUG, "%s%i: Wait time changed to: %d, waited %u",
  502. bitforce->drv->name, bitforce->device_id,
  503. bitforce->sleep_ms, bitforce->wait_ms);
  504. /* Work out the average time taken. Float for calculation, uint for display */
  505. bitforce->avg_wait_f += (tv_to_ms(elapsed) - bitforce->avg_wait_f) / TIME_AVG_CONSTANT;
  506. bitforce->avg_wait_d = (unsigned int) (bitforce->avg_wait_f + 0.5);
  507. }
  508. applog(LOG_DEBUG, "%s%i: waited %dms until %s",
  509. bitforce->drv->name, bitforce->device_id,
  510. bitforce->wait_ms, buf);
  511. if (!strncasecmp(buf, BITFORCE_NO_NONCE, BITFORCE_NO_NONCE_MATCH))
  512. return bitforce->nonces; /* No valid nonce found */
  513. else if (!strncasecmp(buf, BITFORCE_IDLE, BITFORCE_IDLE_MATCH))
  514. return 0; /* Device idle */
  515. else if (strncasecmp(buf, BITFORCE_NONCE, BITFORCE_NONCE_LEN)) {
  516. bitforce->hw_errors++;
  517. applog(LOG_WARNING, "%s%i: Error: Get result reports: %s",
  518. bitforce->drv->name, bitforce->device_id, buf);
  519. bitforce_initialise(bitforce, true);
  520. return 0;
  521. }
  522. pnoncebuf = &buf[12];
  523. while (1) {
  524. hex2bin((void*)&nonce, pnoncebuf, 4);
  525. #ifndef __BIG_ENDIAN__
  526. nonce = swab32(nonce);
  527. #endif
  528. if (unlikely(bitforce->nonce_range && (nonce >= work->nonce ||
  529. (work->nonce > 0 && nonce < work->nonce - bitforce->nonces - 1)))) {
  530. applog(LOG_WARNING, "%s%i: Disabling broken nonce range support",
  531. bitforce->drv->name, bitforce->device_id);
  532. bitforce->nonce_range = false;
  533. work->nonce = 0xffffffff;
  534. bitforce->sleep_ms *= 5;
  535. bitforce->kname = KNAME_WORK;
  536. }
  537. submit_nonce(thr, work, nonce);
  538. if (strncmp(&pnoncebuf[8], ",", 1))
  539. break;
  540. pnoncebuf += 9;
  541. }
  542. return bitforce->nonces;
  543. }
  544. static void bitforce_shutdown(__maybe_unused struct thr_info *thr)
  545. {
  546. // struct cgpu_info *bitforce = thr->cgpu;
  547. }
  548. static void biforce_thread_enable(struct thr_info *thr)
  549. {
  550. struct cgpu_info *bitforce = thr->cgpu;
  551. bitforce_initialise(bitforce, true);
  552. }
  553. static int64_t bitforce_scanhash(struct thr_info *thr, struct work *work, int64_t __maybe_unused max_nonce)
  554. {
  555. struct cgpu_info *bitforce = thr->cgpu;
  556. bool send_ret;
  557. int64_t ret;
  558. // Device is gone
  559. if (bitforce->usbinfo.nodev)
  560. return -1;
  561. send_ret = bitforce_send_work(thr, work);
  562. if (!restart_wait(thr, bitforce->sleep_ms))
  563. return 0;
  564. bitforce->wait_ms = bitforce->sleep_ms;
  565. if (send_ret) {
  566. bitforce->polling = true;
  567. ret = bitforce_get_result(thr, work);
  568. bitforce->polling = false;
  569. } else
  570. ret = -1;
  571. if (ret == -1) {
  572. ret = 0;
  573. applog(LOG_ERR, "%s%i: Comms error", bitforce->drv->name, bitforce->device_id);
  574. dev_error(bitforce, REASON_DEV_COMMS_ERROR);
  575. bitforce->hw_errors++;
  576. /* empty read buffer */
  577. bitforce_initialise(bitforce, true);
  578. }
  579. return ret;
  580. }
  581. static bool bitforce_get_stats(struct cgpu_info *bitforce)
  582. {
  583. return bitforce_get_temp(bitforce);
  584. }
  585. static void bitforce_identify(struct cgpu_info *bitforce)
  586. {
  587. bitforce->flash_led = true;
  588. }
  589. static bool bitforce_thread_init(struct thr_info *thr)
  590. {
  591. struct cgpu_info *bitforce = thr->cgpu;
  592. unsigned int wait;
  593. /* Pause each new thread at least 100ms between initialising
  594. * so the devices aren't making calls all at the same time. */
  595. wait = thr->id * MAX_START_DELAY_MS;
  596. applog(LOG_DEBUG, "%s%d: Delaying start by %dms",
  597. bitforce->drv->name, bitforce->device_id, wait / 1000);
  598. cgsleep_ms(wait);
  599. return true;
  600. }
  601. static struct api_data *bitforce_api_stats(struct cgpu_info *cgpu)
  602. {
  603. struct api_data *root = NULL;
  604. // Warning, access to these is not locked - but we don't really
  605. // care since hashing performance is way more important than
  606. // locking access to displaying API debug 'stats'
  607. // If locking becomes an issue for any of them, use copy_data=true also
  608. root = api_add_uint(root, "Sleep Time", &(cgpu->sleep_ms), false);
  609. root = api_add_uint(root, "Avg Wait", &(cgpu->avg_wait_d), false);
  610. return root;
  611. }
  612. struct device_drv bitforce_drv = {
  613. .drv_id = DRIVER_bitforce,
  614. .dname = "BitForce",
  615. .name = "BFL",
  616. .drv_detect = bitforce_detect,
  617. .get_api_stats = bitforce_api_stats,
  618. .get_statline_before = get_bitforce_statline_before,
  619. .get_stats = bitforce_get_stats,
  620. .identify_device = bitforce_identify,
  621. .thread_prepare = bitforce_thread_prepare,
  622. .thread_init = bitforce_thread_init,
  623. .scanhash = bitforce_scanhash,
  624. .thread_shutdown = bitforce_shutdown,
  625. .thread_enable = biforce_thread_enable
  626. };