forked from wareck/cgminer-gekko
-
Notifications
You must be signed in to change notification settings - Fork 0
/
driver-bitmain.h
598 lines (543 loc) · 14.5 KB
/
driver-bitmain.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
/*
* Copyright 2013 BitMain project
* Copyright 2013 BitMain <[email protected]>
* Copyright 2014-2015 Andrew Smith
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 3 of the License, or (at your option)
* any later version. See COPYING for more details.
*/
#ifndef BITMAIN_H
#define BITMAIN_H
// S3 is a USB S2 with other minor changes (search for USE_ANT_S3)
#if defined(USE_ANT_S3)
#define USE_ANT_S2 1
#endif
#if (defined(USE_ANT_S1) || defined(USE_ANT_S2))
#include "util.h"
#include "klist.h"
#define BITMAIN_RESET_FAULT_DECISECONDS 1
#define BITMAIN_MINER_THREADS 1
#define BITMAIN_IO_SPEED 115200
#define BITMAIN_HASH_TIME_FACTOR ((float)1.67/0x32)
#define BITMAIN_RESET_PITCH (300*1000*1000)
#define BITMAIN_TOKEN_TYPE_TXCONFIG 0x51
#define BITMAIN_TOKEN_TYPE_TXTASK 0x52
#define BITMAIN_TOKEN_TYPE_RXSTATUS 0x53
#define BITMAIN_DATA_TYPE_RXSTATUS 0xa1
#define BITMAIN_DATA_TYPE_RXNONCE 0xa2
#define BITMAIN_FAN_FACTOR 60
#define BITMAIN_PWM_MAX 0xA0
#define BITMAIN_DEFAULT_FAN_MIN 20
#define BITMAIN_DEFAULT_FAN_MAX 100
#define BITMAIN_DEFAULT_FAN_MAX_PWM 0xA0 /* 100% */
#define BITMAIN_DEFAULT_FAN_MIN_PWM 0x20 /* 20% */
#define BITMAIN_TEMP_TARGET 50
#define BITMAIN_TEMP_HYSTERESIS 3
#define BITMAIN_TEMP_OVERHEAT 75
#define BITMAIN_DEFAULT_TIMEOUT 0x2D
#define BITMAIN_MIN_FREQUENCY 10
#define BITMAIN_MAX_FREQUENCY 1000000
#define BITMAIN_TIMEOUT_FACTOR 12690
#define BITMAIN_DEFAULT_FREQUENCY 282
#define BITMAIN_DEFAULT_CHAIN_NUM 8
#define BITMAIN_DEFAULT_ASIC_NUM 32
#define BITMAIN_DEFAULT_REG_DATA 0
#define BITMAIN_AUTO_CYCLE 1024
#ifdef USE_ANT_S1
#define BITMAIN_FTDI_READSIZE 510
#define BITMAIN_DEFAULT_VOLTAGE 5
#define BITMAIN_WORK_DELAY 1
#else // S2 or S3
#ifdef USE_ANT_S3 // S3
#define BITMAIN_FTDI_READSIZE 510
#define BITMAIN_VOLTAGE_DEF "0000"
#define BITMAIN_VOLTAGE0_DEF 0x00
#define BITMAIN_VOLTAGE1_DEF 0x00
#define BITMAIN_WORK_DELAY 1
#else // S2
#define BITMAIN_FTDI_READSIZE 2048
#define BITMAIN_VOLTAGE_DEF "0725"
#define BITMAIN_VOLTAGE0_DEF 0x07
#define BITMAIN_VOLTAGE1_DEF 0x25
#define BITMAIN_WORK_DELAY 1
#endif
#endif
#define BITMAIN_USB_PACKETSIZE 512
#define BITMAIN_SENDBUF_SIZE 8192
#define BITMAIN_READBUF_SIZE 8192
#define BITMAIN_RESET_TIMEOUT 100
#define BITMAIN_LATENCY 1
#ifdef USE_ANT_S1
#define BITMAIN_READ_TIMEOUT 18 /* Enough to only half fill the buffer */
#define BITMAIN_MAX_WORK_NUM 8
#define BITMAIN_MAX_WORK_QUEUE_NUM 64
#define BITMAIN_MAX_DEAL_QUEUE_NUM 1
#define BITMAIN_MAX_NONCE_NUM 8
#define BITMAIN_MAX_CHAIN_NUM 8
#else // S2 or S3
#ifdef USE_ANT_S3
#define BITMAIN_READ_TIMEOUT 100
#define BITMAIN_MAX_WORK_NUM 8
#define BITMAIN_MAX_WORK_QUEUE_NUM 1024
#define BITMAIN_MAX_DEAL_QUEUE_NUM 2
#define BITMAIN_MAX_NONCE_NUM 128
#define BITMAIN_MAX_CHAIN_NUM 8
#else // S2
#define BITMAIN_READ_TIMEOUT 0 // Ignored
#define BITMAIN_MAX_WORK_NUM 64
#define BITMAIN_MAX_WORK_QUEUE_NUM 4096
#define BITMAIN_MAX_DEAL_QUEUE_NUM 32
#define BITMAIN_MAX_NONCE_NUM 128
#define BITMAIN_MAX_CHAIN_NUM 16
#endif
#endif
#define BITMAIN_MAX_TEMP_NUM 32
#define BITMAIN_MAX_FAN_NUM 32
#ifdef USE_ANT_S1
#define BITMAIN_SEND_STATUS_TIME 10 //s
#define BITMAIN_SEND_FULL_SPACE 128
#else // S2 or S3
#define BITMAIN_SEND_STATUS_TIME 15 //s
#ifdef USE_ANT_S3
#define BITMAIN_SEND_FULL_SPACE 256
#else
#define BITMAIN_SEND_FULL_SPACE 512
#endif
#endif
#define BITMAIN_OVERHEAT_SLEEP_MS_MAX 10000
#define BITMAIN_OVERHEAT_SLEEP_MS_MIN 200
#define BITMAIN_OVERHEAT_SLEEP_MS_DEF 600
#define BITMAIN_OVERHEAT_SLEEP_MS_STEP 200
#ifdef USE_ANT_S2
struct bitmain_packet_head {
uint8_t token_type;
uint8_t version;
uint16_t length;
} __attribute__((packed, aligned(4)));
#endif
struct bitmain_txconfig_token {
uint8_t token_type;
#ifdef USE_ANT_S1
uint8_t length;
#else // S2
uint8_t version;
uint16_t length;
#endif
uint8_t reset :1;
uint8_t fan_eft :1;
uint8_t timeout_eft :1;
uint8_t frequency_eft :1;
uint8_t voltage_eft :1;
uint8_t chain_check_time_eft :1;
uint8_t chip_config_eft :1;
uint8_t hw_error_eft :1;
uint8_t beeper_ctrl :1;
uint8_t temp_over_ctrl :1;
uint8_t fan_home_mode :1;
uint8_t reserved1 :5;
#ifndef USE_ANT_S1
uint8_t chain_check_time;
uint8_t reserved2;
#endif
uint8_t chain_num;
uint8_t asic_num;
uint8_t fan_pwm_data;
uint8_t timeout_data;
uint16_t frequency;
#ifdef USE_ANT_S1
uint8_t voltage;
uint8_t chain_check_time;
#else
uint8_t voltage[2];
#endif
uint8_t reg_data[4];
uint8_t chip_address;
uint8_t reg_address;
uint16_t crc;
} __attribute__((packed, aligned(4)));
struct bitmain_txtask_work {
uint32_t work_id;
uint8_t midstate[32];
uint8_t data2[12];
} __attribute__((packed, aligned(4)));
struct bitmain_txtask_token {
#ifdef USE_ANT_S1
uint8_t token_type;
uint8_t reserved1;
uint16_t length;
uint8_t new_block :1;
uint8_t reserved2 :7;
uint8_t reserved3[3];
struct bitmain_txtask_work works[BITMAIN_MAX_WORK_NUM];
uint16_t crc;
#else // S2
uint8_t token_type;
uint8_t version;
uint16_t length;
uint8_t new_block :1;
uint8_t reserved1 :7;
uint8_t diff;
uint8_t reserved2[2];
struct bitmain_txtask_work works[BITMAIN_MAX_WORK_NUM];
uint16_t crc;
#endif
} __attribute__((packed, aligned(4)));
struct bitmain_rxstatus_token {
#ifdef USE_ANT_S1
uint8_t token_type;
uint8_t length;
uint8_t chip_status_eft :1;
uint8_t detect_get :1;
uint8_t reserved1 :6;
uint8_t reserved2;
uint8_t chip_address;
uint8_t reg_address;
uint16_t crc;
#else // S2
uint8_t token_type;
uint8_t version;
uint16_t length;
uint8_t chip_status_eft :1;
uint8_t detect_get :1;
uint8_t reserved1 :6;
uint8_t reserved2[3];
uint8_t chip_address;
uint8_t reg_address;
uint16_t crc;
#endif
} __attribute__((packed, aligned(4)));
struct bitmain_rxstatus_data {
#ifdef USE_ANT_S1
uint8_t data_type;
uint8_t length;
uint8_t chip_value_eft :1;
uint8_t reserved1 :7;
uint8_t version;
uint32_t fifo_space;
uint32_t reg_value;
uint32_t nonce_error;
uint8_t chain_num;
uint8_t temp_num;
uint8_t fan_num;
uint8_t reserved2;
uint32_t chain_asic_status[BITMAIN_MAX_CHAIN_NUM];
uint8_t chain_asic_num[BITMAIN_MAX_CHAIN_NUM];
uint8_t temp[BITMAIN_MAX_TEMP_NUM];
uint8_t fan[BITMAIN_MAX_FAN_NUM];
uint16_t crc;
#else // S2
uint8_t data_type;
uint8_t version;
uint16_t length;
uint8_t chip_value_eft :1;
uint8_t reserved1 :7;
uint8_t chain_num;
uint16_t fifo_space;
uint8_t hw_version[4];
uint8_t fan_num;
uint8_t temp_num;
uint16_t fan_exist;
uint32_t temp_exist;
uint32_t nonce_error;
uint32_t reg_value;
uint32_t chain_asic_exist[BITMAIN_MAX_CHAIN_NUM*8];
uint32_t chain_asic_status[BITMAIN_MAX_CHAIN_NUM*8];
uint8_t chain_asic_num[BITMAIN_MAX_CHAIN_NUM];
uint8_t temp[BITMAIN_MAX_TEMP_NUM];
uint8_t fan[BITMAIN_MAX_FAN_NUM];
uint16_t crc;
#endif
} __attribute__((packed, aligned(4)));
struct bitmain_rxnonce_nonce {
uint32_t work_id;
uint32_t nonce;
} __attribute__((packed, aligned(4)));
struct bitmain_rxnonce_data {
#ifdef USE_ANT_S1
uint8_t data_type;
uint8_t length;
uint8_t fifo_space;
uint8_t nonce_num;
struct bitmain_rxnonce_nonce nonces[BITMAIN_MAX_NONCE_NUM];
uint16_t crc;
#else
uint8_t data_type;
uint8_t version;
uint16_t length;
uint16_t fifo_space;
uint16_t diff;
uint64_t total_nonce_num;
struct bitmain_rxnonce_nonce nonces[BITMAIN_MAX_NONCE_NUM];
uint16_t crc;
#endif
} __attribute__((packed, aligned(4)));
/* how many usec stats ranges
* [0] for a call that didn't process
* [1] to [PROFILE_STATS] for less than NxPROFILE_STEP_USEC
* [PROFILE_STATS+1] for > PROFILE_STATSxPROFILE_STEP_USEC */
#define PROFILE_STATS 10
#define PROFILE_STEP_USEC 200
// set to 0/1 to disable/enable updating the stats
#if 1
#define PROFILE_START(_stt) cgtime(&(_stt))
#define PROFILE_ZERO(_ranges) (_ranges)[0]++
#define PROFILE_FINISH(_stt, _count, _total, _ranges) do { \
struct timeval _fin; \
int64_t _tot, _range; \
cgtime(&(_fin)); \
(_count)++; \
_tot = _fin.tv_usec - (_stt).tv_usec; \
_tot += ((_fin.tv_sec - (_stt).tv_sec) * 1000000); \
(_total) += _tot; \
_range = _tot / PROFILE_STEP_USEC; \
if (_range < 0) \
_range = 0; \
else if (_range > PROFILE_STATS) \
_range = PROFILE_STATS; \
(_ranges)[(int)(_range+1)]++; \
} while(0)
#define PROFILE_FINISH2(_stt, _count, _total, _total2, _ranges, _ranges2, _delta) do { \
struct timeval _fin; \
int64_t _tot, _range; \
cgtime(&(_fin)); \
(_count)++; \
_tot = _fin.tv_usec - (_stt).tv_usec; \
_tot += ((_fin.tv_sec - (_stt).tv_sec) * 1000000); \
(_total) += _tot; \
_range = _tot / PROFILE_STEP_USEC; \
if (_range < 0) \
_range = 0; \
else if (_range > PROFILE_STATS) \
_range = PROFILE_STATS; \
(_ranges)[(int)(_range+1)]++; \
_tot -= _delta; \
(_total2) += _tot; \
_range = _tot / PROFILE_STEP_USEC; \
if (_range < 0) \
_range = 0; \
else if (_range > PROFILE_STATS) \
_range = PROFILE_STATS; \
(_ranges2)[(int)(_range+1)]++; \
} while(0)
#else
// Avoid gcc warnings
#define PROFILE_START(_stt) do { \
if ((_stt).tv_sec != 0L) \
(_stt).tv_sec = 0L; \
} while (0)
#define PROFILE_ZERO(_ranges) (_ranges)[0] = 0L
#define PROFILE_FINISH(_stt, _count, _total, _ranges) _count = 0L
#define PROFILE_FINISH2(_stt, _count, _total, _total2, _ranges, _ranges2, _delta) _count = 0L
#endif
struct bitmain_info {
int queued;
int results;
#ifdef USE_ANT_S1
int baud;
int chain_num;
int asic_num;
int chain_asic_num[BITMAIN_MAX_CHAIN_NUM];
uint32_t chain_asic_status[BITMAIN_MAX_CHAIN_NUM];
char chain_asic_status_t[BITMAIN_MAX_CHAIN_NUM][40];
#else // S2 or S3
#ifndef USE_ANT_S3
int device_fd;
#endif
int baud;
int chain_num;
int asic_num;
int chain_asic_num[BITMAIN_MAX_CHAIN_NUM];
uint32_t chain_asic_exist[BITMAIN_MAX_CHAIN_NUM*8];
uint32_t chain_asic_status[BITMAIN_MAX_CHAIN_NUM*8];
char chain_asic_status_t[BITMAIN_MAX_CHAIN_NUM][320];
#endif
int timeout;
int errorcount;
uint32_t nonce_error;
uint32_t last_nonce_error;
uint8_t reg_data[4];
int fan_num;
int fan[BITMAIN_MAX_FAN_NUM];
int temp_num;
int temp[BITMAIN_MAX_TEMP_NUM];
int temp_max;
int temp_avg;
int temp_history_count;
int temp_history_index;
int temp_sum;
int fan_pwm;
int frequency;
int temp_hi;
#ifdef USE_ANT_S1
int voltage;
#else
uint8_t voltage[2];
uint64_t total_nonce_num;
int diff;
#endif
int no_matching_work;
//int matching_work[BITMAIN_DEFAULT_CHAIN_NUM];
struct thr_info *thr;
pthread_t read_thr;
pthread_t write_thr;
pthread_mutex_t lock;
pthread_mutex_t qlock;
pthread_cond_t qcond;
cgsem_t write_sem;
int nonces;
int fifo_space;
unsigned int last_work_block;
struct timeval last_status_time;
int send_full_space;
#ifdef USE_ANT_S2
int hw_version[4];
#endif
int auto_queued;
int auto_hw;
int idle;
bool reset;
bool optimal;
#ifdef USE_ANT_S1
bool overheat;
int overheat_temp;
uint32_t overheat_count;
uint32_t overheat_sleep_ms;
uint32_t overheat_sleeps;
uint32_t overheat_slept;
uint64_t overheat_total_sleep;
uint32_t overheat_recovers;
#endif
// Work
K_LIST *work_list;
K_STORE *work_ready;
#ifdef USE_ANT_S2
K_STORE *wbuild;
#endif
uint32_t last_wid;
uint64_t work_search;
uint64_t tot_search;
uint64_t min_search;
uint64_t max_search;
uint64_t failed_search;
uint64_t tot_failed;
uint64_t min_failed;
uint64_t max_failed;
uint64_t fill_calls;
uint64_t fill_loop_count[BITMAIN_MAX_WORK_NUM+1];
int64_t fill_usec_count;
int64_t fill_usec;
int64_t fill_usec_ranges[PROFILE_STATS+2];
uint64_t fill_nospace;
uint64_t fifo_checks;
uint64_t fill_neededless;
uint64_t fill_totalneeded;
uint64_t fill_need[BITMAIN_MAX_WORK_NUM+1];
uint64_t fill_want;
bool got_work;
uint64_t fill_start_nowork;
uint64_t fill_nowork;
uint64_t fill_roll;
int fill_rollmin;
int fill_rollmax;
uint64_t fill_rolltot;
uint64_t fill_rolllimit;
uint64_t fill_toosmall;
uint64_t fill_less;
uint64_t fill_sends;
uint64_t fill_totalsend;
uint64_t fill_send[BITMAIN_MAX_WORK_NUM+1];
uint64_t fill_sendless[BITMAIN_MAX_WORK_NUM+1];
uint64_t fill_seterr;
uint64_t fill_senderr;
uint64_t fill_sleepsa;
uint64_t fill_sleepsb;
uint64_t need_over;
uint64_t need_nowork[BITMAIN_MAX_WORK_NUM+1];
uint64_t fill_sendstatus;
int64_t fill_stat_usec_count;
int64_t fill_stat_usec;
int64_t fill_stat_usec_ranges[PROFILE_STATS+2];
uint64_t read_good;
uint64_t read_size;
uint64_t read_0s;
uint64_t read_18s;
int read_sizemin;
int read_sizemax;
uint64_t read_bad;
uint64_t readbuf_over;
uint64_t get_results;
uint64_t get_sleepsa;
uint64_t get_sleepsb;
uint64_t get_sleepsc;
int64_t get_usec_count;
int64_t get_usec;
int64_t get_usec_ranges[PROFILE_STATS+2];
int64_t get_usec2;
int64_t get_usec2_ranges[PROFILE_STATS+2];
};
// Work
typedef struct witem {
struct work *work;
uint32_t wid;
} WITEM;
#ifdef USE_ANT_S1
#define ALLOC_WITEMS 4096
#else
#ifdef USE_ANT_S3
#define ALLOC_WITEMS 4096
#else // S2
#define ALLOC_WITEMS 32768
#endif
#endif
/*
* The limit doesn't matter since we simply take the tail item
* every time, optionally free it, and then put it on the head
*/
#define LIMIT_WITEMS ALLOC_WITEMS
#define DATAW(_item) ((WITEM *)(_item->data))
#define BITMAIN_READ_SIZE 12
#ifdef USE_ANT_S2
#define BITMAIN_ARRAY_SIZE 16384
#endif
#define BTM_GETS_ERROR -1
#define BTM_GETS_OK 0
#define BTM_SEND_ERROR -1
#define BTM_SEND_OK 0
#define BITMAIN_READ_TIME(baud) ((double)BITMAIN_READ_SIZE * (double)8.0 / (double)(baud))
#define ASSERT1(condition) __maybe_unused static char sizeof_uint32_t_must_be_4[(condition)?1:-1]
ASSERT1(sizeof(uint32_t) == 4);
// All command options
extern char *opt_bitmain_options;
extern char *opt_set_bitmain_fan;
extern char *opt_bitmain_freq;
// Ignored
extern bool opt_bitmain_nobeeper;
extern bool opt_bitmain_notempoverctrl;
#ifdef USE_ANT_S2
extern bool opt_bitmain_checkall;
extern bool opt_bitmain_checkn2diff;
#ifndef USE_ANT_S3
extern char *opt_bitmain_dev;
#endif
extern char *opt_bitmain_voltage;
#endif
extern struct bitmain_info **bitmain_info;
extern bool opt_bitmain_hwerror;
#ifdef USE_ANT_S2
extern bool opt_bitmain_checkall;
extern bool opt_bitmain_checkn2diff;
#endif
extern bool opt_bitmain_beeper;
extern bool opt_bitmain_tempoverctrl;
extern bool opt_bitmain_homemode;
extern int opt_bitmain_temp;
extern int opt_bitmain_workdelay;
extern int opt_bitmain_overheat;
extern int opt_bitmain_fan_min;
extern int opt_bitmain_fan_max;
extern bool opt_bitmain_auto;
extern char *set_bitmain_fan(char *arg);
#endif /* USE_ANT_S1 || USE_ANT_S2 */
#endif /* BITMAIN_H */