thodg/cgminer/knc-asic.c

• Show log

  Commit

• Hash : 013c7087
  Author :
  Date : 2014-06-30T21:18:05
  

  Update to current knc-asic library for KNC_IS_ERROR()
  

Download

• knc-asic.c

• /*
   * library for KnCminer devices
   *
   * Copyright 2014 KnCminer
   *
   * 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 <stdlib.h>
  #include <assert.h>
  #include <fcntl.h>
  #include <limits.h>
  #include <unistd.h>
  #include <sys/ioctl.h>
  #include <linux/types.h>
  #include <linux/spi/spidev.h>
  #include <stdint.h>
  #include <string.h>
  
  #include <zlib.h>
  
  #include "miner.h"
  #include "logging.h"
  
  #include "knc-transport.h"
  
  #include "knc-asic.h"
  
  /* Control Commands
   *
   * SPI command on channel. 1-
   *   1'b1 3'channel 12'msglen_in_bits SPI message data
   * Sends the supplied message on selected SPI bus
   *
   * Communication test
   *   16'h1 16'x
   * Simple test of SPI communication
   *
   * LED control
   *   4'h1 4'red 4'green 4'blue
   * Sets led colour
   *
   * Clock frequency
   *   4'h2 12'msglen_in_bits 4'channel 4'die 16'MHz 512'x
   * Configures the hashing clock rate
   */
  
  /* ASIC Command structure
   * command      8 bits
   * chip         8 bits
   * core         16 bits
   * data         [command dependent]
   * CRC32        32 bits (Neptune)
   *
   * ASIC response starts immediately after core address bits.
   *
   * response data
   * CRC32        32 bits (Neptune)
   * STATUS       8 bits   1 0 ~CRC_OK 0 0 ACCEPTED_WORK 0 1 (Neptune)
   *
   * Requests
   *
   * SETWORK (Jupiter)
   * midstate     256 bits
   * data         96 bits
   *
   * SETWORK/SETWORK_CLEAN (Neptune)
   * slot | 0xf0  8 bits
   * precalc_midstate  192 bits
   * precalc_data 96 bits
   * midstate     256 bits
   *
   * Returns REPORT response on Neptune
   *
   * Responses
   *
   * GETINFO
   *
   * (core field unused)
   *
   * cores        16 bits
   * version      16 bits
   * reserved     60 bits         (Neptune)
   * die_status    4 bits		(Neptune)
   *               1' pll_locked
   *               1' hash_reset_n	1 if cores have been reset since last report
   *               1' pll_reset_n		1 if PLL have been reset since last report
   *               1' pll_power_down
   * core_status  cores * 2 bits  (Neptune) rounded up to bytes
   *                              1' want_work 
   *				1' has_report (unreliable)
   *
   * REPORT
   *
   * reserved     2 bits
   * next_state   1 bit   next work state loaded
   * state        1 bit   hashing  (0 on Jupiter)
   * next_slot    4 bit   slot id of next work state (0 on Jupiter)
   * progress     8 bits  upper 8 bits of nonce counter
   * active_slot  4 bits  slot id of current work state
   * nonce_slot   4 bits  slot id of found nonce
   * nonce        32 bits
   * 
   * reserved     4 bits
   * nonce_slot   4 bits
   * nonce        32 bits
   *
   * repeat for 5 nonce entries in total on Neptune
   * Jupiter only has first nonce entry
   */
  
  // Precalculate first 3 rounds of SHA256 - as much as possible	
  // Macro routines copied from sha2.c
  static void knc_prepare_neptune_work(unsigned char *out, struct work *work) {
          const uint8_t *midstate = work->midstate;
          const uint8_t *data = work->data + 16*4;
  
  #ifndef GET_ULONG_BE
  #define GET_ULONG_BE(b,i)                             \
  		(( (uint32_t) (b)[(i)    ] << 24 )	\
                  | ( (uint32_t) (b)[(i) + 1] << 16 )	\
                  | ( (uint32_t) (b)[(i) + 2] <<  8 )	\
                  | ( (uint32_t) (b)[(i) + 3]       ))
  #endif
  
  #ifndef GET_ULONG_LE
  #define GET_ULONG_LE(b,i)                             \
  		(( (uint32_t) (b)[(i) + 3] << 24 )	\
                  | ( (uint32_t) (b)[(i) + 2] << 16 )	\
                  | ( (uint32_t) (b)[(i) + 1] <<  8 )	\
                  | ( (uint32_t) (b)[(i) + 0]       ))
  #endif
  
  #ifndef PUT_ULONG_BE
  #define PUT_ULONG_BE(n,b,i)                             \
  	{						\
  		(b)[(i)    ] = (unsigned char) ( (n) >> 24 );	\
  		(b)[(i) + 1] = (unsigned char) ( (n) >> 16 );	\
  		(b)[(i) + 2] = (unsigned char) ( (n) >>  8 );	\
  		(b)[(i) + 3] = (unsigned char) ( (n)       );	\
  	}
  #endif
  
  #ifndef PUT_ULONG_LE
  #define PUT_ULONG_LE(n,b,i)                             \
  	{						\
  		(b)[(i) + 3] = (unsigned char) ( (n) >> 24 );	\
  		(b)[(i) + 2] = (unsigned char) ( (n) >> 16 );	\
  		(b)[(i) + 1] = (unsigned char) ( (n) >>  8 );	\
  		(b)[(i) + 0] = (unsigned char) ( (n)       );	\
  	}
  #endif
  
  #define  SHR(x,n) ((x & 0xFFFFFFFF) >> n)
  #define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
  
  #define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^  SHR(x, 3))
  #define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^  SHR(x,10))
  
  #define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
  #define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
  
  #define F0(x,y,z) ((x & y) | (z & (x | y)))
  #define F1(x,y,z) (z ^ (x & (y ^ z)))
  
  #define R(t)                                    \
  (                                               \
      W[t] = S1(W[t -  2]) + W[t -  7] +          \
             S0(W[t - 15]) + W[t - 16]            \
  )
  
  #define P(a,b,c,d,e,f,g,h,x,K)                  \
  	{					\
  		temp1 = h + S3(e) + F1(e,f,g) + K + x;	\
  		temp2 = S2(a) + F0(a,b,c);		\
  		d += temp1; h = temp1 + temp2;		\
  	}
  
      uint32_t temp1, temp2, W[16+3];
      uint32_t A, B, C, D, E, F, G, H;
  
      W[0] = GET_ULONG_LE(data,  0*4 );
      W[1] = GET_ULONG_LE(data,  1*4 );
      W[2] = GET_ULONG_LE(data,  2*4 );
      W[3] = 0;                 // since S0(0)==0, this must be 0. S0(nonce) is added in hardware.
      W[4] = 0x80000000;
      W[5] = 0;
      W[6] = 0;
      W[7] = 0;
      W[8] = 0;
      W[9] = 0;
      W[10] = 0;
      W[11] = 0;
      W[12] = 0;
      W[13] = 0;
      W[14] = 0;
      W[15] = 0x00000280;
      R(16);  // Expand W 14, 9, 1, 0
      R(17);  //          15, 10, 2, 1
      R(18);  //          16, 11, 3, 2
  
      A = GET_ULONG_LE(midstate, 0*4 );
      B = GET_ULONG_LE(midstate, 1*4 );
      C = GET_ULONG_LE(midstate, 2*4 );
      D = GET_ULONG_LE(midstate, 3*4 );
      E = GET_ULONG_LE(midstate, 4*4 );
      F = GET_ULONG_LE(midstate, 5*4 );
      G = GET_ULONG_LE(midstate, 6*4 );
      H = GET_ULONG_LE(midstate, 7*4 );
  
      uint32_t D_ = D, H_ = H;
      P( A, B, C, D_, E, F, G, H_, W[ 0], 0x428A2F98 );
      uint32_t C_ = C, G_ = G;
      P( H_, A, B, C_, D_, E, F, G_, W[ 1], 0x71374491 );
      uint32_t B_ = B, F_ = F;
      P( G_, H_, A, B_, C_, D_, E, F_, W[ 2], 0xB5C0FBCF );
  
      PUT_ULONG_BE( D_, out, 0*4 );
      PUT_ULONG_BE( C_, out, 1*4 );
      PUT_ULONG_BE( B_, out, 2*4 );
      PUT_ULONG_BE( H_, out, 3*4 );
      PUT_ULONG_BE( G_, out, 4*4 );
      PUT_ULONG_BE( F_, out, 5*4 );
      PUT_ULONG_BE( W[18], out, 6*4 );  // This is partial S0(nonce) added by hardware
      PUT_ULONG_BE( W[17], out, 7*4 );
      PUT_ULONG_BE( W[16], out, 8*4 );
      PUT_ULONG_BE( H, out, 9*4 );
      PUT_ULONG_BE( G, out, 10*4 );
      PUT_ULONG_BE( F, out, 11*4 );
      PUT_ULONG_BE( E, out, 12*4 );
      PUT_ULONG_BE( D, out, 13*4 );
      PUT_ULONG_BE( C, out, 14*4 );
      PUT_ULONG_BE( B, out, 15*4 );
      PUT_ULONG_BE( A, out, 16*4 );
  }
  
  static void knc_prepare_jupiter_work(unsigned char *out, struct work *work) {
          int i;
          for (i = 0; i < 8 * 4; i++)
                  out[i] = work->midstate[8 * 4 - i - 1];
          for (i = 0; i < 3 * 4; i++)
                  out[8 * 4 + i] = work->data[16 * 4 + 3 * 4 - i - 1];
  }
  
  static void knc_prepare_core_command(uint8_t *request, int command, int die, int core)
  {
  	request[0] = command;
  	request[1] = die;
  	request[2] = core >> 8;
  	request[3] = core & 0xff;
  }
  
  int knc_prepare_report(uint8_t *request, int die, int core)
  {
  	knc_prepare_core_command(request, KNC_ASIC_CMD_REPORT, die, core);
  	return 4;
  }
  
  int knc_prepare_info(uint8_t *request, int die, struct knc_die_info *die_info, int *response_size)
  {
  	request[0] = KNC_ASIC_CMD_GETINFO;
  	request[1] = die;
  	request[2] = 0;
  	request[3] = 0;
  	switch (die_info->version) {
  	case KNC_VERSION_JUPITER:
  		*response_size = 4;
  		break;
  	default:
  		*response_size = 12 + (KNC_MAX_CORES_PER_DIE*2 + 7) / 8;
  		break;
  	case KNC_VERSION_NEPTUNE:
  		*response_size = 12 + (die_info->cores*2 + 7) / 8;
  		break;
  	}
  	return 4;
  }
  
  int knc_prepare_neptune_setwork(uint8_t *request, int die, int core, int slot, struct work *work, int clean)
  {
  	if (!clean)
  		knc_prepare_core_command(request, KNC_ASIC_CMD_SETWORK, die, core);
  	else
  		knc_prepare_core_command(request, KNC_ASIC_CMD_SETWORK_CLEAN, die, core);
  	request[4] = slot | 0xf0;
  	if (work)
  		knc_prepare_neptune_work(request + 4 + 1, work);
  	else
  		memset(request + 4 + 1, 0, 6*4 + 3*4 + 8*4);
  	return 4 + 1 + 6*4 + 3*4 + 8*4;
  }
  
  int knc_prepare_jupiter_setwork(uint8_t *request, int die, int core, int slot, struct work *work)
  {
  	knc_prepare_core_command(request, KNC_ASIC_CMD_SETWORK, die, core);
  	request[4] = slot | 0xf0;
  	if (work)
  		knc_prepare_jupiter_work(request + 4 + 1, work);
  	else
  		memset(request + 4 + 1, 0, 8*4 + 3*4);
  	return 4 + 1 + 8*4 + 3*4;
  }
  
  int knc_prepare_jupiter_halt(uint8_t *request, int die, int core)
  {
  	knc_prepare_core_command(request, KNC_ASIC_CMD_HALT, die, core);
  	return 4;
  }
  
  int knc_prepare_neptune_halt(uint8_t *request, int die, int core)
  {
  	knc_prepare_core_command(request, KNC_ASIC_CMD_HALT, die, core);
  	request[4] = 0 | 0xf0;
  	memset(request + 4 + 1, 0, 6*4 + 3*4 + 8*4);
  	return 4 + 1 + 6*4 + 3*4 + 8*4;
  }
  
  void knc_prepare_neptune_message(int request_length, const uint8_t *request, uint8_t *buffer)
  {
      uint32_t crc;
      memcpy(buffer, request, request_length);
      buffer += request_length;
      crc = crc32(0, Z_NULL, 0);
      crc = crc32(crc, request, request_length);
      PUT_ULONG_BE(crc, buffer, 0);
  }
  
  int knc_transfer_length(int request_length, int response_length)
  {
  	/* FPGA control, request header, request body/response, CRC(4), ACK(1), EXTRA(3) */
  	return 2 + MAX(request_length, 4 + response_length ) + 4 + 1 + 3;
  }
  
  int knc_prepare_transfer(uint8_t *txbuf, int offset, int size, int channel, int request_length, const uint8_t *request, int response_length)
  {
  	/* FPGA control, request header, request body/response, CRC(4), ACK(1), EXTRA(3) */
          int msglen = MAX(request_length, 4 + response_length ) + 4 + 1 + 3;
          int len = 2 + msglen;
  	txbuf += offset;
  
  	if (len + offset > size) {
  		applog(LOG_DEBUG, "KnC SPI buffer full");
  		return -1;
  	}
  	txbuf[0] = 1 << 7 | (channel+1) << 4 | (msglen * 8) >> 8;
  	txbuf[1] = (msglen * 8);
  	knc_prepare_neptune_message(request_length, request, txbuf+2);
  
  	return offset + len;
  }
  
  /* red, green, blue valid range 0 - 15 */
  int knc_prepare_led(uint8_t *txbuf, int offset, int size, int red, int green, int blue)
  {
  	/* 4'h1 4'red 4'green 4'blue */
          int len = 2;
  	txbuf += offset;
  
  	if (len + offset > size) {
  		applog(LOG_DEBUG, "KnC SPI buffer full");
  		return -1;
  	}
  	txbuf[0] = 1 << 4 | red;
  	txbuf[1] = green << 4 | blue;
  
  	return offset + len;
  	
  }
  
  /* reset controller */
  int knc_prepare_reset(uint8_t *txbuf, int offset, int size)
  {
  	/* 16'h0002 16'unused */
          int len = 4;
  	txbuf += offset;
  
  	if (len + offset > size) {
  		applog(LOG_DEBUG, "KnC SPI buffer full");
  		return -1;
  	}
  	txbuf[0] = (0x0002) >> 8;
  	txbuf[1] = (0x0002) & 0xff;
  	txbuf[2] = 0;
  	txbuf[3] = 0;
  
  	return offset + len;
  }
  
  /* request_length = 0 disables communication checks, i.e. Jupiter protocol */
  int knc_decode_response(uint8_t *rxbuf, int request_length, uint8_t **response, int response_length)
  {
      int ret = 0;
      int len = knc_transfer_length(request_length, response_length);
      if (request_length > 0 && response_length > 0) {
          uint32_t crc, recv_crc;
  	crc = crc32(0, Z_NULL, 0);
          crc = crc32(crc, rxbuf + 2 + 4, response_length);
  	recv_crc = GET_ULONG_BE(rxbuf + 2 + 4, response_length);
  	if (crc != recv_crc)
                  ret |= KNC_ERR_CRC;
      }
  
      if (response) {
  	if (response_length > 0) {
  	    *response = rxbuf + 2 + 4;
  	} else {
  	    *response = NULL;
  	}
      }
        
      if (response_length == 0)
  	return 0;
  
      uint8_t ack = rxbuf[len - 4];
  
      if ((ack & KNC_ASIC_ACK_MASK) != KNC_ASIC_ACK_MATCH)
          ret |= KNC_ERR_ACK;
      if ((ack & KNC_ASIC_ACK_CRC))
          ret |= KNC_ERR_CRCACK;
      if ((ack & KNC_ASIC_ACK_ACCEPT))
          ret |= KNC_ACCEPTED;
      if (ret && memcmp(&rxbuf[len-4], "\377\377\377\377", 4) == 0)
  	ret = KNC_ERR_UNAVAIL;
      return ret;
  }
  
  int knc_syncronous_transfer(void *ctx, int channel, int request_length, const uint8_t *request, int response_length, uint8_t *response)
  {
      int len = knc_transfer_length(request_length, response_length);
      uint8_t txbuf[len];
      uint8_t rxbuf[len];
      memset(txbuf, 0, len);
      knc_prepare_transfer(txbuf, 0, len, channel, request_length, request, response_length);
      knc_trnsp_transfer(ctx, txbuf, rxbuf, len);
  
      uint8_t *response_buf;
      int rc = knc_decode_response(rxbuf, request_length, &response_buf, response_length);
      if (response)
  	memcpy(response, response_buf, response_length);
      return rc;
  }
  
  int knc_decode_info(uint8_t *response, struct knc_die_info *die_info)
  {
  	int cores_in_die = response[0]<<8 | response[1];
  	int version = response[2]<<8 | response[3];
  	if (version == KNC_ASIC_VERSION_JUPITER && cores_in_die <= 48) {
  		die_info->version = KNC_VERSION_JUPITER;
  		die_info->cores = cores_in_die;
  		memset(die_info->want_work, -1, cores_in_die);
  		die_info->pll_power_down = -1;
  		die_info->pll_reset_n = -1;
  		die_info->hash_reset_n = -1;
  		die_info->pll_locked = -1;
  		return 0;
  	} else if (version == KNC_ASIC_VERSION_NEPTUNE && cores_in_die <= KNC_MAX_CORES_PER_DIE) {
  		die_info->version = KNC_VERSION_NEPTUNE;
  		die_info->cores = cores_in_die;
  		int core;
  		for (core = 0; core < cores_in_die; core++)
  			die_info->want_work[core] = ((response[12 + core/4] >> ((3-(core % 4)) * 2)) >> 1) & 1;
  		int die_status = response[11] & 0xf;
  		die_info->pll_power_down = (die_status >> 0) & 1;
  		die_info->pll_reset_n = (die_status >> 1) & 1;
  		die_info->hash_reset_n = (die_status >> 2) & 1;
  		die_info->pll_locked = (die_status >> 3) & 1;
  		return 0;
  	} else {
  		return -1;
  	}
  }
  
  int knc_decode_report(uint8_t *response, struct knc_report *report, int version)
  {
  /*
   * reserved     2 bits
   * next_state   1 bit   next work state loaded
   * state        1 bit   hashing  (0 on Jupiter)
   * next_slot    4 bit   slot id of next work state (0 on Jupiter)
   * progress     8 bits  upper 8 bits of nonce counter
   * active_slot  4 bits  slot id of current work state
   * nonce_slot   4 bits  slot id of found nonce
   * nonce        32 bits
   * 
   * reserved     4 bits
   * nonce_slot   4 bits
   * nonce        32 bits
   */
  	report->next_state = (response[0] >> 5) & 1;
  	if (version != KNC_VERSION_JUPITER) {
  		report->state = (response[0] >> 4) & 1;
  		report->next_slot = response[0] & ((1<<4)-1);
  	} else {
  		report->state = -1;
  		report->next_slot = -1;
  	}
  	report->progress = (uint32_t)response[1] << 24;
  	report->active_slot = (response[2] >> 4) & ((1<<4)-1);
  	int n;
  	int n_nonces = version == KNC_VERSION_JUPITER ? 1 : 5;
  	for (n = 0; n < n_nonces; n++) {
  		report->nonce[n].slot = response[2+n*5] & ((1<<4)-1);
  		report->nonce[n].nonce =
  				(uint32_t)response[3+n*5] << 24 |
  				(uint32_t)response[4+n*5] << 16 |
  				(uint32_t)response[5+n*5] << 8 |
  				(uint32_t)response[6+n*5] << 0 |
  				0;
  	}
  	for (; n < KNC_NONCES_PER_REPORT; n++) {
  		report->nonce[n].slot = -1;
  		report->nonce[n].nonce = 0;
  	}
  	return 0;
  }
  
  int knc_detect_die(void *ctx, int channel, int die, struct knc_die_info *die_info)
  {
  	uint8_t request[4];
  	int response_len = 2 + 2 + 4 + 4 + (KNC_MAX_CORES_PER_DIE*2 + 7) / 8;
  	uint8_t response[response_len];
  
  	int request_len = knc_prepare_info(request, die, die_info, &response_len);
  	int status = knc_syncronous_transfer(ctx, channel, request_len, request, response_len, response);
  
  	/* Workaround for pre-ASIC version */
  	int cores_in_die = response[0]<<8 | response[1];
  	int version = response[2]<<8 | response[3];
  	if (version == KNC_ASIC_VERSION_NEPTUNE && cores_in_die < KNC_MAX_CORES_PER_DIE) {
  		applog(LOG_DEBUG, "KnC %d-%d: Looks like a NEPTUNE die with %d cores", channel, die, cores_in_die);
  		/* Try again with right response size */
  		response_len = 2 + 2 + 4 + 4 + (cores_in_die*2 + 7) / 8;
  		status = knc_syncronous_transfer(ctx, channel, request_len, request, response_len, response);
  	}
  	int rc = -1;
  	if (version == KNC_ASIC_VERSION_JUPITER || status == 0)
  		rc = knc_decode_info(response, die_info);
  	if (rc == 0)
  		applog(LOG_INFO, "KnC %d-%d: Found %s die with %d cores", channel, die,
  			die_info->version == KNC_VERSION_NEPTUNE ? "NEPTUNE" : 
  			die_info->version == KNC_VERSION_JUPITER ? "JUPITER" : 
  			"UNKNOWN",
  			cores_in_die);
  	else
  		applog(LOG_DEBUG, "KnC %d-%d: No KnC chip found", channel, die);
  	return rc;
  }
  
  

Download