thodg/cgminer/driver-hashfast.c

• Show log

  Commit

• Hash : 9a036bc8
  Author :
  Date : 2013-11-11T18:05:57
  

  Only retry 3 times in hfa_reset.

Download

• driver-hashfast.c

• /*
   * Copyright 2013 Con Kolivas <kernel@kolivas.org>
   * Copyright 2013 Hashfast Inc.
   *
   * 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.
   */
  
  #include "config.h"
  
  #include <stdbool.h>
  
  #include "miner.h"
  #include "usbutils.h"
  
  #include "driver-hashfast.h"
  
  ////////////////////////////////////////////////////////////////////////////////
  // Support for the CRC's used in header (CRC-8) and packet body (CRC-32)
  ////////////////////////////////////////////////////////////////////////////////
  
  #define GP8  0x107   /* x^8 + x^2 + x + 1 */
  #define DI8  0x07
  
  static unsigned char crc8_table[256];	/* CRC-8 table */
  
  static void hfa_init_crc8(void)
  {
  	int i,j;
  	unsigned char crc;
  
  	for (i = 0; i < 256; i++) {
  		crc = i;
  		for (j = 0; j < 8; j++)
  			crc = (crc << 1) ^ ((crc & 0x80) ? DI8 : 0);
  		crc8_table[i] = crc & 0xFF;
  	}
  }
  
  static unsigned char hfa_crc8(unsigned char *h)
  {
  	int i;
  	unsigned char crc;
  
  	h++;	// Preamble not included
  	for (i = 1, crc = 0xff; i < 7; i++)
  		crc = crc8_table[crc ^ *h++];
  
  	return crc;
  }
  
  struct hfa_cmd {
  	uint8_t cmd;
  	char *cmd_name;
  	enum usb_cmds usb_cmd;
  };
  
  /* Entries in this array need to align with the actual op values specified
   * in hf_protocol.h */
  #define C_NULL C_MAX
  static const struct hfa_cmd hfa_cmds[] = {
  	{OP_NULL, "OP_NULL", C_NULL},				// 0
  	{OP_ROOT, "OP_ROOT", C_NULL},
  	{OP_RESET, "OP_RESET", C_HF_RESET},
  	{OP_PLL_CONFIG, "OP_PLL_CONFIG", C_HF_PLL_CONFIG},
  	{OP_ADDRESS, "OP_ADDRESS", C_HF_ADDRESS},
  	{OP_READDRESS, "OP_READDRESS", C_NULL},
  	{OP_HIGHEST, "OP_HIGHEST", C_NULL},
  	{OP_BAUD, "OP_BAUD", C_HF_BAUD},
  	{OP_UNROOT, "OP_UNROOT", C_NULL},			// 8
  	{OP_HASH, "OP_HASH", C_HF_HASH},
  	{OP_NONCE, "OP_NONCE", C_HF_NONCE},
  	{OP_ABORT, "OP_ABORT", C_HF_ABORT},
  	{OP_STATUS, "OP_STATUS", C_HF_STATUS},
  	{OP_GPIO, "OP_GPIO", C_NULL},
  	{OP_CONFIG, "OP_CONFIG", C_HF_CONFIG},
  	{OP_STATISTICS, "OP_STATISTICS", C_HF_STATISTICS},
  	{OP_GROUP, "OP_GROUP", C_NULL},				// 16
  	{OP_CLOCKGATE, "OP_CLOCKGATE", C_HF_CLOCKGATE},
  
  	{OP_USB_INIT, "OP_USB_INIT", C_HF_USB_INIT},		// 18
  	{OP_GET_TRACE, "OP_GET_TRACE", C_NULL},
  	{OP_LOOPBACK_USB, "OP_LOOPBACK_USB", C_NULL},
  	{OP_LOOPBACK_UART, "OP_LOOPBACK_UART", C_NULL},
  	{OP_DFU, "OP_DFU", C_NULL},
  	{OP_USB_SHUTDOWN, "OP_USB_SHUTDOWN", C_NULL},
  	{OP_DIE_STATUS, "OP_DIE_STATUS", C_HF_DIE_STATUS},	// 24
  	{OP_GWQ_STATUS, "OP_GWQ_STATUS", C_HF_GWQ_STATUS},
  	{OP_WORK_RESTART, "OP_WORK_RESTART", C_HF_WORK_RESTART},
  	{OP_USB_STATS1, "OP_USB_STATS1", C_NULL},
  	{OP_USB_GWQSTATS, "OP_USB_GWQSTATS", C_HF_GWQSTATS}
  };
  
  #define HF_USB_CMD_OFFSET (128 - 18)
  #define HF_USB_CMD(X) (X - HF_USB_CMD_OFFSET)
  
  /* Send an arbitrary frame, consisting of an 8 byte header and an optional
   * packet body. */
  
  static bool hfa_send_frame(struct cgpu_info *hashfast, uint8_t opcode, uint16_t hdata,
  			   uint8_t *data, int len)
  {
  	int tx_length, ret, amount, id = hashfast->device_id;
  	uint8_t packet[256];
  	struct hf_header *p = (struct hf_header *)packet;
  
  	p->preamble = HF_PREAMBLE;
  	p->operation_code = hfa_cmds[opcode].cmd;
  	p->chip_address = HF_GWQ_ADDRESS;
  	p->core_address = 0;
  	p->hdata = htole16(hdata);
  	p->data_length = len / 4;
  	p->crc8 = hfa_crc8(packet);
  
  	if (len)
  		memcpy(&packet[sizeof(struct hf_header)], data, len);
  	tx_length = sizeof(struct hf_header) + len;
  
  	ret = usb_write(hashfast, (char *)packet, tx_length, &amount,
  			hfa_cmds[opcode].usb_cmd);
  	if (unlikely(ret < 0 || amount != tx_length)) {
  		applog(LOG_ERR, "HFA %d: hfa_send_frame: USB Send error, ret %d amount %d vs. tx_length %d",
  		       id, ret, amount, tx_length);
  		return false;
  	}
  	return true;
  }
  
  /* Send an already assembled packet, consisting of an 8 byte header which may
   * or may not be followed by a packet body. */
  
  static bool hfa_send_packet(struct cgpu_info *hashfast, struct hf_header *h, int cmd)
  {
  	int amount, ret, len;
  
  	len = sizeof(*h) + h->data_length * 4;
  	ret = usb_write(hashfast, (char *)h, len, &amount, hfa_cmds[cmd].usb_cmd);
  	if (ret < 0 || amount != len) {
  		applog(LOG_WARNING, "HFA%d: send_packet: %s USB Send error, ret %d amount %d vs. length %d",
  		       hashfast->device_id, hfa_cmds[cmd].cmd_name, ret, amount, len);
  		return false;
  	}
  	return true;
  }
  
  static bool hfa_get_header(struct cgpu_info *hashfast, struct hf_header *h, uint8_t *computed_crc)
  {
  	int amount, ret, orig_len, len, ofs = 0, reads = 0;
  	char buf[512];
  	char *header;
  
  	/* Read for up to 200ms till we find the first occurrence of HF_PREAMBLE
  	 * though it should be the first byte unless we get woefully out of
  	 * sync. */
  	orig_len = len = sizeof(*h);
  	do {
  
  		if (++reads > 20)
  			return false;
  
  		ret = usb_read_timeout(hashfast, buf + ofs, len, &amount, 10, C_HF_GETHEADER);
  		if (unlikely(ret && ret != LIBUSB_ERROR_TIMEOUT))
  			return false;
  		ofs += amount;
  		header = memchr(buf, HF_PREAMBLE, ofs);
  		if (header)
  			len -= ofs - (header - buf);
  	} while (len);
  
  	memcpy(h, header, orig_len);
  	*computed_crc = hfa_crc8((uint8_t *)h);
  
  	return true;
  }
  
  static bool hfa_get_data(struct cgpu_info *hashfast, char *buf, int len4)
  {
  	int amount, ret, len = len4 * 4;
  
  	ret = usb_read(hashfast, buf, len, &amount, C_HF_GETDATA);
  	if (ret)
  		return false;
  	if (amount != len) {
  		applog(LOG_WARNING, "HFA %d: get_data: Strange amount returned %d vs. expected %d",
  		       hashfast->device_id, amount, len);
  		return false;
  	}
  	return true;
  }
  
  static const char *hf_usb_init_errors[] = {
  	"Success",
  	"Reset timeout",
  	"Address cycle timeout",
  	"Clockgate operation timeout",
  	"Configuration operation timeout",
  	"Excessive core failures",
  	"All cores failed diagnostics",
  	"Too many groups configured - increase ntime roll amount"
  };
  
  static bool hfa_reset(struct cgpu_info *hashfast, struct hashfast_info *info)
  {
  	struct hf_usb_init_header usb_init, *hu = &usb_init;
  	struct hf_usb_init_base *db;
          struct hf_usb_init_options *ho;
  	int retries = 0, i;
  	char buf[1024];
  	struct hf_header *h = (struct hf_header *)buf;
  	uint8_t hcrc;
  	bool ret;
  
          // XXX Following items need to be defaults with command-line overrides
  	info->hash_clock_rate = 550;	// Hash clock rate in Mhz
  	info->group_ntime_roll = 1;
  	info->core_ntime_roll = 1;
  
  	// Assemble the USB_INIT request
  	memset(hu, 0, sizeof(*hu));
  	hu->preamble = HF_PREAMBLE;
  	hu->operation_code = OP_USB_INIT;
  	hu->protocol = PROTOCOL_GLOBAL_WORK_QUEUE;	// Protocol to use
  	hu->hash_clock = info->hash_clock_rate;		// Hash clock rate in Mhz
  	if (info->group_ntime_roll > 1 && info->core_ntime_roll) {
  		ho = (struct hf_usb_init_options *)(hu + 1);
  		memset(ho, 0, sizeof(*ho));
  		ho->group_ntime_roll = info->group_ntime_roll;
  		ho->core_ntime_roll = info->core_ntime_roll;
  		hu->data_length = sizeof(*ho) / 4;
  	}
  	hu->crc8 = hfa_crc8((uint8_t *)hu);
  	applog(LOG_INFO, "HFA%d: Sending OP_USB_INIT with GWQ protocol specified",
  	       hashfast->device_id);
  
  	if (!hfa_send_packet(hashfast, (struct hf_header *)hu, HF_USB_CMD(OP_USB_INIT)))
  		return false;
  
  	// Check for the correct response.
  	// We extend the normal timeout - a complete device initialization, including
  	// bringing power supplies up from standby, etc., can take over a second.
  tryagain:
  	for (i = 0; i < 30; i++) {
  		ret = hfa_get_header(hashfast, h, &hcrc);
  		if (ret)
  			break;
  	}
  	if (!ret) {
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed!", hashfast->device_id);
  		return false;
  	}
  	if (h->crc8 != hcrc) {
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! CRC mismatch", hashfast->device_id);
  		return false;
  	}
  	if (h->operation_code != OP_USB_INIT) {
  		// This can happen if valid packet(s) were in transit *before* the OP_USB_INIT arrived
  		// at the device, so we just toss the packets and keep looking for the response.
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT: Tossing packet, valid but unexpected type %d",
                          hashfast->device_id, h->operation_code);
  		hfa_get_data(hashfast, buf, h->data_length);
  		if (retries++ < 3)
  			goto tryagain;
  		return false;
  	}
  
  	applog(LOG_DEBUG, "HFA %d: Good reply to OP_USB_INIT", hashfast->device_id);
  	applog(LOG_DEBUG, "HFA %d: OP_USB_INIT: %d die in chain, %d cores, device_type %d, refclk %d Mhz",
  	       hashfast->device_id, h->chip_address, h->core_address, h->hdata & 0xff, (h->hdata >> 8) & 0xff);
  
  	// Save device configuration
  	info->asic_count = h->chip_address;
  	info->core_count = h->core_address;
  	info->device_type = (uint8_t)h->hdata;
  	info->ref_frequency = (uint8_t)(h->hdata >> 8);
  	info->hash_sequence_head = 0;
  	info->hash_sequence_tail = 0;
  	info->device_sequence_tail = 0;
  
  	// Size in bytes of the core bitmap in bytes
  	info->core_bitmap_size = (((info->asic_count * info->core_count) + 31) / 32) * 4;
  
  	// Get the usb_init_base structure
  	if (!hfa_get_data(hashfast, (char *)&info->usb_init_base, U32SIZE(info->usb_init_base))) {
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get usb_init_base data",
  		       hashfast->device_id);
  		return false;
  	}
  	db = &info->usb_init_base;
  	applog(LOG_INFO, "HFA %d:      firmware_rev:    %d.%d", hashfast->device_id,
  	       (db->firmware_rev >> 8) & 0xff, db->firmware_rev & 0xff);
  	applog(LOG_INFO, "HFA %d:      hardware_rev:    %d.%d", hashfast->device_id,
  	       (db->hardware_rev >> 8) & 0xff, db->hardware_rev & 0xff);
  	applog(LOG_INFO, "HFA %d:      serial number:   %d", hashfast->device_id,
  	       db->serial_number);
  	applog(LOG_INFO, "HFA %d:      hash clockrate:  %d Mhz", hashfast->device_id,
  	       db->hash_clockrate);
  	applog(LOG_INFO, "HFA %d:      inflight_target: %d", hashfast->device_id,
  	       db->inflight_target);
  	applog(LOG_INFO, "HFA %d:      sequence_modulus: %d", hashfast->device_id,
  	       db->sequence_modulus);
  	info->num_sequence = db->sequence_modulus;
  
  	// Now a copy of the config data used
  	if (!hfa_get_data(hashfast, (char *)&info->config_data, U32SIZE(info->config_data))) {
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get config_data",
  		       hashfast->device_id);
  		return false;
  	}
  
  	// Now the core bitmap
  	info->core_bitmap = malloc(info->core_bitmap_size);
  	if (!info->core_bitmap)
  		quit(1, "Failed to malloc info core bitmap in hfa_reset");
  	if (!hfa_get_data(hashfast, (char *)info->core_bitmap, info->core_bitmap_size / 4)) {
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get core_bitmap", hashfast->device_id);
  		return false;
  	}
  
  	// See if the initialization suceeded
  	if (db->operation_status) {
  		applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Operation status %d (%s)",
  			hashfast->device_id, db->operation_status,
  			(db->operation_status < sizeof(hf_usb_init_errors)/sizeof(hf_usb_init_errors[0])) ?
  			hf_usb_init_errors[db->operation_status] : "Unknown error code");
  		return false;
  	}
  
  	return true;
  }
  
  static void hfa_send_shutdown(struct cgpu_info *hashfast)
  {
  	hfa_send_frame(hashfast, HF_USB_CMD(OP_USB_SHUTDOWN), 0, NULL, 0);
  }
  
  static void hfa_clear_readbuf(struct cgpu_info *hashfast)
  {
  	int amount, ret;
  	char buf[512];
  
  	do {
  		ret = usb_read(hashfast, buf, 512, &amount, C_HF_CLEAR_READ);
  	} while (!ret || amount);
  }
  
  static bool hfa_detect_common(struct cgpu_info *hashfast)
  {
  	struct hashfast_info *info;
  	bool ret;
  
  	info = calloc(sizeof(struct hashfast_info), 1);
  	if (!info)
  		quit(1, "Failed to calloc hashfast_info in hfa_detect_common");
  	hashfast->device_data = info;
  	/* hashfast_reset should fill in details for info */
  	ret = hfa_reset(hashfast, info);
  	if (!ret) {
  		hfa_send_shutdown(hashfast);
  		hfa_clear_readbuf(hashfast);
  		free(info);
  		hashfast->device_data = NULL;
  		return false;
  	}
  
  	// The per-die status array
  	info->die_status = calloc(info->asic_count, sizeof(struct hf_g1_die_data));
  	if (unlikely(!(info->die_status)))
  		quit(1, "Failed to calloc die_status");
  
  	// The per-die statistics array
  	info->die_statistics = calloc(info->asic_count, sizeof(struct hf_long_statistics));
  	if (unlikely(!(info->die_statistics)))
  		quit(1, "Failed to calloc die_statistics");
  
  	info->works = calloc(sizeof(struct work *), info->num_sequence);
  	if (!info->works)
  		quit(1, "Failed to calloc info works in hfa_detect_common");
  
  	return true;
  }
  
  static bool hfa_initialise(struct cgpu_info *hashfast)
  {
  	int err;
  
  	if (hashfast->usbinfo.nodev)
  		return false;
  
  	hfa_clear_readbuf(hashfast);
  
  	err = usb_transfer(hashfast, 0, 9, 1, 0, C_ATMEL_RESET);
  	if (!err)
  		err = usb_transfer(hashfast, 0x21, 0x22, 0, 0, C_ATMEL_OPEN);
  	if (!err) {
  		uint32_t buf[2];
  
  		/* Magic sequence to reset device only really needed for windows
  		 * but harmless on linux. */
  		buf[0] = 0x80250000;
  		buf[1] = 0x00000800;
  		err = usb_transfer_data(hashfast, 0x21, 0x20, 0x0000, 0, buf,
  					7, C_ATMEL_INIT);
  	}
  	if (err < 0) {
  		applog(LOG_INFO, "HFA %d: Failed to open with error %s",
  		       hashfast->device_id, libusb_error_name(err));
  	}
  	/* Must have transmitted init sequence sized buffer */
  	return (err == 7);
  }
  
  static bool hfa_detect_one_usb(libusb_device *dev, struct usb_find_devices *found)
  {
  	struct cgpu_info *hashfast;
  
  	hashfast = usb_alloc_cgpu(&hashfast_drv, HASHFAST_MINER_THREADS);
  	if (!hashfast)
  		quit(1, "Failed to usb_alloc_cgpu hashfast");
  
  	if (!usb_init(hashfast, dev, found)) {
  		hashfast = usb_free_cgpu(hashfast);
  		return false;
  	}
  
  	hashfast->usbdev->usb_type = USB_TYPE_STD;
  
  	if (!hfa_initialise(hashfast)) {
  		hashfast = usb_free_cgpu(hashfast);
  		return false;
  	}
  
  	if (!hfa_detect_common(hashfast)) {
  		usb_uninit(hashfast);
  		hashfast = usb_free_cgpu(hashfast);
  		return false;
  	}
  	if (!add_cgpu(hashfast))
  		return false;
  
  	return true;
  }
  
  static void hfa_detect(bool hotplug)
  {
  	/* Set up the CRC tables only once. */
  	if (!hotplug)
  		hfa_init_crc8();
  	usb_detect(&hashfast_drv, hfa_detect_one_usb);
  }
  
  static bool hfa_get_packet(struct cgpu_info *hashfast, struct hf_header *h)
  {
  	uint8_t hcrc;
  	bool ret;
  
  	ret = hfa_get_header(hashfast, h, &hcrc);
  	if (unlikely(!ret))
  		goto out;
  	if (unlikely(h->crc8 != hcrc)) {
  		applog(LOG_WARNING, "HFA %d: Bad CRC %d vs %d, attempting to process anyway",
  		       hashfast->device_id, h->crc8, hcrc);
  	}
  	if (h->data_length > 0)
  		ret = hfa_get_data(hashfast, (char *)(h + 1), h->data_length);
  	if (unlikely(!ret)) {
  		applog(LOG_WARNING, "HFA %d: Failed to get data associated with header",
  		       hashfast->device_id);
  	}
  
  out:
  	return ret;
  }
  
  static void hfa_parse_gwq_status(struct cgpu_info *hashfast, struct hashfast_info *info,
  				 struct hf_header *h)
  {
  	struct hf_gwq_data *g = (struct hf_gwq_data *)(h + 1);
  	struct work *work;
  
  	applog(LOG_DEBUG, "HFA %d: OP_GWQ_STATUS, device_head %4d tail %4d my tail %4d shed %3d inflight %4d",
  		hashfast->device_id, g->sequence_head, g->sequence_tail, info->hash_sequence_tail,
  		g->shed_count, HF_SEQUENCE_DISTANCE(info->hash_sequence_head,g->sequence_tail));
  
  	mutex_lock(&info->lock);
  	info->hash_count += g->hash_count;
  	info->device_sequence_head = g->sequence_head;
  	info->device_sequence_tail = g->sequence_tail;
  	info->shed_count = g->shed_count;
  	/* Free any work that is no longer required */
  	while (info->device_sequence_tail != info->hash_sequence_tail) {
  		if (++info->hash_sequence_tail >= info->num_sequence)
  			info->hash_sequence_tail = 0;
  		if (unlikely(!(work = info->works[info->hash_sequence_tail]))) {
  			applog(LOG_ERR, "HFA %d: Bad work sequence tail",
  			       hashfast->device_id);
  			hashfast->shutdown = true;
  			break;
  		}
  		applog(LOG_DEBUG, "HFA %d: Completing work on hash_sequence_tail %d",
  		       hashfast->device_id, info->hash_sequence_tail);
  		free_work(work);
  		info->works[info->hash_sequence_tail] = NULL;
  	}
  	mutex_unlock(&info->lock);
  }
  
  static void hfa_update_die_status(struct cgpu_info *hashfast, struct hashfast_info *info,
  				  struct hf_header *h)
  {
  	struct hf_g1_die_data *d = (struct hf_g1_die_data *)(h + 1), *ds;
  	int num_included = (h->data_length * 4) / sizeof(struct hf_g1_die_data);
  	int i, j;
  
  	float die_temperature;
  	float core_voltage[6];
  
  	if (info->device_type == HFD_G1) {
  		// Copy in the data. They're numbered sequentially from the starting point
  		ds = info->die_status + h->chip_address;
  		for (i = 0; i < num_included; i++)
  			memcpy(ds++, d++, sizeof(struct hf_g1_die_data));
  
  		for (i = 0, d = &info->die_status[h->chip_address]; i < num_included; i++, d++) {
  			die_temperature = GN_DIE_TEMPERATURE(d->die.die_temperature);
  			for (j = 0; j < 6; j++)
  				core_voltage[j] = GN_CORE_VOLTAGE(d->die.core_voltage[j]);
  
  			applog(LOG_DEBUG, "HFA %d: die %2d: OP_DIE_STATUS Die temp %.2fC vdd's %.2f %.2f %.2f %.2f %.2f %.2f",
  			       hashfast->device_id, h->chip_address + i, die_temperature,
  			       core_voltage[0], core_voltage[1], core_voltage[2],
  			       core_voltage[3], core_voltage[4], core_voltage[5]);
  			// XXX Convert board phase currents, voltage, temperature
  		}
  	}
  }
  
  static void search_for_extra_nonce(struct thr_info *thr, struct work *work,
  				   struct hf_candidate_nonce *n)
  {
  	uint32_t nonce = n->nonce;
  	int i;
  
  	/* No function to test with ntime offsets yet */
  	if (n->ntime & HF_NTIME_MASK)
  		return;
  	for (i = 0; i < 128; i++, nonce++) {
  		/* We could break out of this early if nonce wraps or if we
  		 * find one correct nonce since the chance of more is extremely
  		 * low but this function will be hit so infrequently we may as
  		 * well test the entire range with the least code. */
  		if (test_nonce(work, nonce))
  			submit_tested_work(thr, work);
  	}
  }
  
  static void hfa_parse_nonce(struct thr_info *thr, struct cgpu_info *hashfast,
  			    struct hashfast_info *info, struct hf_header *h)
  {
  	struct hf_candidate_nonce *n = (struct hf_candidate_nonce *)(h + 1);
  	int i, num_nonces = h->data_length / U32SIZE(sizeof(struct hf_candidate_nonce));
  
  	applog(LOG_DEBUG, "HFA %d: OP_NONCE: %2d:, num_nonces %d hdata 0x%04x",
  	       hashfast->device_id, h->chip_address, num_nonces, h->hdata);
  	for (i = 0; i < num_nonces; i++, n++) {
  		struct work *work;
  
  		applog(LOG_DEBUG, "HFA %d: OP_NONCE: %2d: %2d: ntime %2d sequence %4d nonce 0x%08x",
  		       hashfast->device_id, h->chip_address, i, n->ntime & HF_NTIME_MASK, n->sequence, n->nonce);
  
  		// Find the job from the sequence number
  		mutex_lock(&info->lock);
  		work = info->works[n->sequence];
  		mutex_unlock(&info->lock);
  
  		if (unlikely(!work)) {
  			info->no_matching_work++;
  			applog(LOG_INFO, "HFA %d: No matching work!", hashfast->device_id);
  		} else {
  			applog(LOG_DEBUG, "HFA %d: OP_NONCE: sequence %d: submitting nonce 0x%08x ntime %d",
  			       hashfast->device_id, n->sequence, n->nonce, n->ntime & HF_NTIME_MASK);
  			if ((n->nonce & 0xffff0000) == 0x42420000)		// XXX REMOVE THIS
  				break;						// XXX PHONEY EMULATOR NONCE
  			submit_noffset_nonce(thr, work, n->nonce, n->ntime & HF_NTIME_MASK);	// XXX Return value from submit_nonce is error if set
  			if (unlikely(n->ntime & HF_NONCE_SEARCH)) {
  				/* This tells us there is another share in the
  				 * next 128 nonces */
  				applog(LOG_DEBUG, "HFA %d: OP_NONCE: SEARCH PROXIMITY EVENT FOUND",
  				       hashfast->device_id);
  				search_for_extra_nonce(thr, work, n);
  			}
  		}
  	}
  }
  
  static void hfa_update_die_statistics(struct hashfast_info *info, struct hf_header *h)
  {
  	struct hf_statistics *s = (struct hf_statistics *)(h + 1);
  	struct hf_long_statistics *l;
  
  	// Accumulate the data
  	l = info->die_statistics + h->chip_address;
  
  	l->rx_header_crc += s->rx_header_crc;
  	l->rx_body_crc += s->rx_body_crc;
  	l->rx_header_timeouts += s->rx_header_timeouts;
  	l->rx_body_timeouts += s->rx_body_timeouts;
  	l->core_nonce_fifo_full += s->core_nonce_fifo_full;
  	l->array_nonce_fifo_full += s->array_nonce_fifo_full;
  	l->stats_overrun += s->stats_overrun;
  }
  
  static void hfa_update_stats1(struct cgpu_info *hashfast, struct hashfast_info *info,
  			      struct hf_header *h)
  {
  	struct hf_long_usb_stats1 *s1 = &info->stats1;
  	struct hf_usb_stats1 *sd = (struct hf_usb_stats1 *)(h + 1);
  
  	s1->usb_rx_preambles += sd->usb_rx_preambles;
  	s1->usb_rx_receive_byte_errors += sd->usb_rx_receive_byte_errors;
  	s1->usb_rx_bad_hcrc += sd->usb_rx_bad_hcrc;
  
  	s1->usb_tx_attempts += sd->usb_tx_attempts;
  	s1->usb_tx_packets += sd->usb_tx_packets;
  	s1->usb_tx_timeouts += sd->usb_tx_timeouts;
  	s1->usb_tx_incompletes += sd->usb_tx_incompletes;
  	s1->usb_tx_endpointstalled += sd->usb_tx_endpointstalled;
  	s1->usb_tx_disconnected += sd->usb_tx_disconnected;
  	s1->usb_tx_suspended += sd->usb_tx_suspended;
  #if 0
  	/* We don't care about UART stats so they're not in our struct */
  	s1->uart_tx_queue_dma += sd->uart_tx_queue_dma;
  	s1->uart_tx_interrupts += sd->uart_tx_interrupts;
  
  	s1->uart_rx_preamble_ints += sd->uart_rx_preamble_ints;
  	s1->uart_rx_missed_preamble_ints += sd->uart_rx_missed_preamble_ints;
  	s1->uart_rx_header_done += sd->uart_rx_header_done;
  	s1->uart_rx_data_done += sd->uart_rx_data_done;
  	s1->uart_rx_bad_hcrc += sd->uart_rx_bad_hcrc;
  	s1->uart_rx_bad_dma += sd->uart_rx_bad_dma;
  	s1->uart_rx_short_dma += sd->uart_rx_short_dma;
  	s1->uart_rx_buffers_full += sd->uart_rx_buffers_full;
  #endif
  	if (sd->max_tx_buffers >  s1->max_tx_buffers)
  		s1->max_tx_buffers = sd->max_tx_buffers;
  	if (sd->max_rx_buffers >  s1->max_rx_buffers)
  		s1->max_rx_buffers = sd->max_rx_buffers;
  
  	applog(LOG_DEBUG, "HFA %d: OP_USB_STATS1:", hashfast->device_id);
  	applog(LOG_DEBUG, "      usb_rx_preambles:             %6d", sd->usb_rx_preambles);
  	applog(LOG_DEBUG, "      usb_rx_receive_byte_errors:   %6d", sd->usb_rx_receive_byte_errors);
  	applog(LOG_DEBUG, "      usb_rx_bad_hcrc:              %6d", sd->usb_rx_bad_hcrc);
  
  	applog(LOG_DEBUG, "      usb_tx_attempts:              %6d", sd->usb_tx_attempts);
  	applog(LOG_DEBUG, "      usb_tx_packets:               %6d", sd->usb_tx_packets);
  	applog(LOG_DEBUG, "      usb_tx_timeouts:              %6d", sd->usb_tx_timeouts);
  	applog(LOG_DEBUG, "      usb_tx_incompletes:           %6d", sd->usb_tx_incompletes);
  	applog(LOG_DEBUG, "      usb_tx_endpointstalled:       %6d", sd->usb_tx_endpointstalled);
  	applog(LOG_DEBUG, "      usb_tx_disconnected:          %6d", sd->usb_tx_disconnected);
  	applog(LOG_DEBUG, "      usb_tx_suspended:             %6d", sd->usb_tx_suspended);
  #if 0
  	applog(LOG_DEBUG, "      uart_tx_queue_dma:            %6d", sd->uart_tx_queue_dma);
  	applog(LOG_DEBUG, "      uart_tx_interrupts:           %6d", sd->uart_tx_interrupts);
  
  	applog(LOG_DEBUG, "      uart_rx_preamble_ints:        %6d", sd->uart_rx_preamble_ints);
  	applog(LOG_DEBUG, "      uart_rx_missed_preamble_ints: %6d", sd->uart_rx_missed_preamble_ints);
  	applog(LOG_DEBUG, "      uart_rx_header_done:          %6d", sd->uart_rx_header_done);
  	applog(LOG_DEBUG, "      uart_rx_data_done:            %6d", sd->uart_rx_data_done);
  	applog(LOG_DEBUG, "      uart_rx_bad_hcrc:             %6d", sd->uart_rx_bad_hcrc);
  	applog(LOG_DEBUG, "      uart_rx_bad_dma:              %6d", sd->uart_rx_bad_dma);
  	applog(LOG_DEBUG, "      uart_rx_short_dma:            %6d", sd->uart_rx_short_dma);
  	applog(LOG_DEBUG, "      uart_rx_buffers_full:         %6d", sd->uart_rx_buffers_full);
  #endif
  	applog(LOG_DEBUG, "      max_tx_buffers:               %6d", sd->max_tx_buffers);
  	applog(LOG_DEBUG, "      max_rx_buffers:               %6d", sd->max_rx_buffers);
  
      }
  
  static void *hfa_read(void *arg)
  {
  	struct thr_info *thr = (struct thr_info *)arg;
  	struct cgpu_info *hashfast = thr->cgpu;
  	struct hashfast_info *info = hashfast->device_data;
  	char threadname[24];
  
  	snprintf(threadname, 24, "hfa_read/%d", hashfast->device_id);
  	RenameThread(threadname);
  
  	while (likely(!hashfast->shutdown)) {
  		char buf[512];
  		struct hf_header *h = (struct hf_header *)buf;
  		bool ret = hfa_get_packet(hashfast, h);
  
  		if (unlikely(!ret))
  			continue;
  
  		switch (h->operation_code) {
  			case OP_GWQ_STATUS:
  				hfa_parse_gwq_status(hashfast, info, h);
  				break;
  			case OP_DIE_STATUS:
  				hfa_update_die_status(hashfast, info, h);
  				break;
  			case OP_NONCE:
  				hfa_parse_nonce(thr, hashfast, info, h);
  				break;
  			case OP_STATISTICS:
  				hfa_update_die_statistics(info, h);
  				break;
  			case OP_USB_STATS1:
  				hfa_update_stats1(hashfast, info, h);
  				break;
  			default:
  				applog(LOG_WARNING, "HFA %d: Unhandled operation code %d",
  				       hashfast->device_id, h->operation_code);
  				break;
  		}
  	}
  
  	return NULL;
  }
  
  static bool hfa_prepare(struct thr_info *thr)
  {
  	struct cgpu_info *hashfast = thr->cgpu;
  	struct hashfast_info *info = hashfast->device_data;
  	struct timeval now;
  
  	mutex_init(&info->lock);
  	if (pthread_create(&info->read_thr, NULL, hfa_read, (void *)thr))
  		quit(1, "Failed to pthread_create read thr in hfa_prepare");
  
  	cgtime(&now);
  	get_datestamp(hashfast->init, sizeof(hashfast->init), &now);
  
  	return true;
  }
  
  /* Figure out how many jobs to send. */
  static int hfa_jobs(struct hashfast_info *info)
  {
  	int ret;
  
  	mutex_lock(&info->lock);
  	ret = info->usb_init_base.inflight_target - HF_SEQUENCE_DISTANCE(info->hash_sequence_head, info->device_sequence_tail);
  	/* Place an upper limit on how many jobs to queue to prevent sending
  	 * more  work than the device can use after a period of outage. */
  	if (ret > info->usb_init_base.inflight_target)
  		ret = info->usb_init_base.inflight_target;
  	mutex_unlock(&info->lock);
  
  	return ret;
  }
  
  static int64_t hfa_scanwork(struct thr_info *thr)
  {
  	struct cgpu_info *hashfast = thr->cgpu;
  	struct hashfast_info *info = hashfast->device_data;
  	int64_t hashes;
  	int jobs, ret;
  
  	if (unlikely(hashfast->usbinfo.nodev)) {
  		applog(LOG_WARNING, "HFA %d: device disappeared, disabling",
  		       hashfast->device_id);
  		return -1;
  	}
  
  	if (unlikely(thr->work_restart)) {
  restart:
  		ret = hfa_send_frame(hashfast, HF_USB_CMD(OP_WORK_RESTART), 0, (uint8_t *)NULL, 0);
  		if (unlikely(!ret)) {
  			ret = hfa_reset(hashfast, info);
  			if (unlikely(!ret)) {
  				applog(LOG_ERR, "HFA %d: Failed to reset after write failure, disabling",
  				hashfast->device_id);
  				return -1;
  			}
  		}
  	}
  
  	jobs = hfa_jobs(info);
  
  	if (!jobs) {
  		ret = restart_wait(thr, 100);
  		if (unlikely(!ret))
  			goto restart;
  		jobs = hfa_jobs(info);
  	}
  
  	while (jobs-- > 0) {
  		struct hf_hash_usb op_hash_data;
  		struct work *work;
  		uint64_t intdiff;
  		int i, sequence;
  		uint32_t *p;
  
  		/* This is a blocking function if there's no work */
  		work = get_work(thr, thr->id);
  
  		/* Assemble the data frame and send the OP_HASH packet */
  		memcpy(op_hash_data.midstate, work->midstate, sizeof(op_hash_data.midstate));
  		memcpy(op_hash_data.merkle_residual, work->data + 64, 4);
  		p = (uint32_t *)(work->data + 64 + 4);
  		op_hash_data.timestamp = *p++;
  		op_hash_data.bits = *p++;
  		op_hash_data.nonce_loops = 0;
  
  		/* Set the number of leading zeroes to look for based on diff.
  		 * Diff 1 = 32, Diff 2 = 33, Diff 4 = 34 etc. */
  		intdiff = (uint64_t)work->device_diff;
  		for (i = 31; intdiff; i++, intdiff >>= 1);
  		op_hash_data.search_difficulty = i;
  		if ((sequence = info->hash_sequence_head + 1) >= info->num_sequence)
  			sequence = 0;
  		ret = hfa_send_frame(hashfast, OP_HASH, sequence, (uint8_t *)&op_hash_data, sizeof(op_hash_data));
  		if (unlikely(!ret)) {
  			ret = hfa_reset(hashfast, info);
  			if (unlikely(!ret)) {
  				applog(LOG_ERR, "HFA %d: Failed to reset after write failure, disabling",
  				       hashfast->device_id);
  				return -1;
  			}
  		}
  
  		mutex_lock(&info->lock);
  		info->hash_sequence_head = sequence;
  		info->works[info->hash_sequence_head] = work;
  		mutex_unlock(&info->lock);
  
  		applog(LOG_DEBUG, "HFA %d: OP_HASH sequence %d search_difficulty %d work_difficulty %g",
  		       hashfast->device_id, info->hash_sequence_head, op_hash_data.search_difficulty, work->work_difficulty);
  	}
  
  	mutex_lock(&info->lock);
  	hashes = info->hash_count;
  	info->hash_count = 0;
  	mutex_unlock(&info->lock);
  
  	return hashes;
  }
  
  static struct api_data *hfa_api_stats(struct cgpu_info *cgpu)
  {
  	struct hashfast_info *info = cgpu->device_data;
  	struct hf_long_usb_stats1 *s1;
  	struct api_data *root = NULL;
  	struct hf_usb_init_base *db;
  	int varint, i;
  	char buf[64];
  
  	root = api_add_int(root, "asic count", &info->asic_count, false);
  	root = api_add_int(root, "core count", &info->core_count, false);
  
  	db = &info->usb_init_base;
  	sprintf(buf, "%d.%d", (db->firmware_rev >> 8) & 0xff, db->firmware_rev & 0xff);
  	root = api_add_string(root, "firmware rev", buf, true);
  	sprintf(buf, "%d.%d", (db->hardware_rev >> 8) & 0xff, db->hardware_rev & 0xff);
  	root = api_add_string(root, "hardware rev", buf, true);
  	varint = db->serial_number;
  	root = api_add_int(root, "serial number", &varint, true);
  	varint = db->hash_clockrate;
  	root = api_add_int(root, "hash clockrate", &varint, true);
  	varint = db->inflight_target;
  	root = api_add_int(root, "inflight target", &varint, true);
  	varint = db->sequence_modulus;
  	root = api_add_int(root, "sequence modules", &varint, true);
  
  	s1 = &info->stats1;
  	root = api_add_uint64(root, "rx preambles", &s1->usb_rx_preambles, false);
  	root = api_add_uint64(root, "rx rcv byte err", &s1->usb_rx_receive_byte_errors, false);
  	root = api_add_uint64(root, "rx bad hcrc", &s1->usb_rx_bad_hcrc, false);
  	root = api_add_uint64(root, "tx attempts", &s1->usb_tx_attempts, false);
  	root = api_add_uint64(root, "tx packets", &s1->usb_tx_packets, false);
  	root = api_add_uint64(root, "tx incompletes", &s1->usb_tx_incompletes, false);
  	root = api_add_uint64(root, "tx ep stalled", &s1->usb_tx_endpointstalled, false);
  	root = api_add_uint64(root, "tx disconnect", &s1->usb_tx_disconnected, false);
  	root = api_add_uint64(root, "tx suspend", &s1->usb_tx_suspended, false);
  	varint = s1->max_tx_buffers;
  	root = api_add_int(root, "max tx buf", &varint, true);
  	varint = s1->max_rx_buffers;
  	root = api_add_int(root, "max rx buf", &varint, true);
  
  	for (i = 0; i < info->asic_count; i++) {
  		struct hf_long_statistics *l = &info->die_statistics[i];
  		struct hf_g1_die_data *d = &info->die_status[i];
  		double die_temp, core_voltage;
  		int j;
  
  		root = api_add_int(root, "Core", &i, true);
  		die_temp = GN_DIE_TEMPERATURE(d->die.die_temperature);
  		root = api_add_double(root, "die temperature", &die_temp, true);
  		for (j = 0; j < 6; j++) {
  			core_voltage = GN_CORE_VOLTAGE(d->die.core_voltage[j]);
  			sprintf(buf, "%d: %.2f", j, core_voltage);
  			root = api_add_string(root, "core voltage", buf, true);
  		}
  		root = api_add_uint64(root, "rx header crc", &l->rx_header_crc, false);
  		root = api_add_uint64(root, "rx body crc", &l->rx_body_crc, false);
  		root = api_add_uint64(root, "rx header to", &l->rx_header_timeouts, false);
  		root = api_add_uint64(root, "rx body to", &l->rx_body_timeouts, false);
  		root = api_add_uint64(root, "cn fifo full", &l->core_nonce_fifo_full, false);
  		root = api_add_uint64(root, "an fifo full", &l->array_nonce_fifo_full, false);
  		root = api_add_uint64(root, "stats overrun", &l->stats_overrun, false);
  	}
  
  	return root;
  }
  
  static void hfa_statline_before(char *buf, size_t bufsiz, struct cgpu_info *hashfast)
  {
  	struct hashfast_info *info = hashfast->device_data;
  	double max_temp, max_volt;
  	struct hf_g1_die_data *d;
  	int i;
  
  	max_temp = max_volt = 0.0;
  
  	for (i = 0; i < info->asic_count; i++) {
  		double temp;
  		int j;
  
  		d = &info->die_status[i];
  		temp = GN_DIE_TEMPERATURE(d->die.die_temperature);
  		if (temp > max_temp)
  			max_temp = temp;
  		for (j = 0; j < 6; j++) {
  			double volt = GN_CORE_VOLTAGE(d->die.core_voltage[j]);
  
  			if (volt > max_volt)
  				max_volt = volt;
  		}
  	}
  
  	tailsprintf(buf, bufsiz, " max%3.0fC %3.2fV | ", max_temp, max_volt);
  }
  
  static void hfa_init(struct cgpu_info __maybe_unused *hashfast)
  {
  }
  
  static void hfa_free_all_work(struct hashfast_info *info)
  {
  	while (info->device_sequence_tail != info->hash_sequence_head) {
  		struct work *work;
  
  		if (++info->hash_sequence_tail >= info->num_sequence)
  			info->hash_sequence_tail = 0;
  		if (unlikely(!(work = info->works[info->hash_sequence_tail])))
  			break;
  		free_work(work);
  		info->works[info->hash_sequence_tail] = NULL;
  	}
  }
  
  static void hfa_shutdown(struct thr_info *thr)
  {
  	struct cgpu_info *hashfast = thr->cgpu;
  	struct hashfast_info *info = hashfast->device_data;
  
  	hfa_send_shutdown(hashfast);
  	pthread_join(info->read_thr, NULL);
  	hfa_free_all_work(info);
  	hfa_clear_readbuf(hashfast);
  	free(info->works);
  	free(info->die_statistics);
  	free(info->die_status);
  	free(info);
  }
  
  struct device_drv hashfast_drv = {
  	.drv_id = DRIVER_hashfast,
  	.dname = "Hashfast",
  	.name = "HFA",
  	.max_diff = 256.0, // Limit max diff to get some nonces back regardless
  	.drv_detect = hfa_detect,
  	.thread_prepare = hfa_prepare,
  	.hash_work = &hash_driver_work,
  	.scanwork = hfa_scanwork,
  	.get_api_stats = hfa_api_stats,
  	.get_statline_before = hfa_statline_before,
  	.reinit_device = hfa_init,
  	.thread_shutdown = hfa_shutdown,
  };
  

Download