thodg/cgminer/knc-transport-spi.c

• Show log

  Commit

• Hash : c104366f
  Author :
  Date : 2014-06-18T16:41:03
  

  KnCMiner driver generation 2
  
  Note: Requires generation 2 code in the FPGA controller.
  

Download

• knc-transport-spi.c

• /*
   * Direct SPI transport layer for KnCminer Jupiters
   *
   * 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 <unistd.h>
  #include <fcntl.h>
  #include <sys/ioctl.h>
  #include <linux/spi/spidev.h>
  
  #include "logging.h"
  #include "miner.h"
  #include "hexdump.c"
  #include "knc-transport.h"
  
  #define SPI_DEVICE_TEMPLATE	"/dev/spidev%d.%d"
  #define SPI_MODE		(SPI_CPHA | SPI_CPOL | SPI_CS_HIGH)
  #define SPI_BITS_PER_WORD	8
  #define SPI_MAX_SPEED		3000000
  #define SPI_DELAY_USECS		0
  
  struct spidev_context {
  	int fd;
  	uint32_t speed;
  	uint16_t delay;
  	uint8_t mode;
  	uint8_t bits;
  };
  
  /* Init SPI transport */
  void *knc_trnsp_new(int dev_idx)
  {
  	struct spidev_context *ctx;
  	char dev_name[PATH_MAX];
  
  	if (NULL == (ctx = malloc(sizeof(struct spidev_context)))) {
  		applog(LOG_ERR, "KnC transport: Out of memory");
  		goto l_exit_error;
  	}
  	ctx->mode = SPI_MODE;
  	ctx->bits = SPI_BITS_PER_WORD;
  	ctx->speed = SPI_MAX_SPEED;
  	ctx->delay = SPI_DELAY_USECS;
  
  	ctx->fd = -1;
  	sprintf(dev_name, SPI_DEVICE_TEMPLATE,
  		dev_idx + 1, /* bus */
  		0    /* chipselect */
  	       );
  	if (0 > (ctx->fd = open(dev_name, O_RDWR))) {
  		applog(LOG_ERR, "KnC transport: Can not open SPI device %s: %m",
  		       dev_name);
  		goto l_free_exit_error;
  	}
  
  	/*
  	 * spi mode
  	 */
  	if (0 > ioctl(ctx->fd, SPI_IOC_WR_MODE, &ctx->mode))
  		goto l_ioctl_error;
  	if (0 > ioctl(ctx->fd, SPI_IOC_RD_MODE, &ctx->mode))
  		goto l_ioctl_error;
  
  	/*
  	 * bits per word
  	 */
  	if (0 > ioctl(ctx->fd, SPI_IOC_WR_BITS_PER_WORD, &ctx->bits))
  		goto l_ioctl_error;
  	if (0 > ioctl(ctx->fd, SPI_IOC_RD_BITS_PER_WORD, &ctx->bits))
  		goto l_ioctl_error;
  
  	/*
  	 * max speed hz
  	 */
  	if (0 > ioctl(ctx->fd, SPI_IOC_WR_MAX_SPEED_HZ, &ctx->speed))
  		goto l_ioctl_error;
  	if (0 > ioctl(ctx->fd, SPI_IOC_RD_MAX_SPEED_HZ, &ctx->speed))
  		goto l_ioctl_error;
  
  	applog(LOG_INFO, "KnC transport: SPI device %s uses mode %hhu, bits %hhu, speed %u",
  	       dev_name, ctx->mode, ctx->bits, ctx->speed);
  
  	return ctx;
  
  l_ioctl_error:
  	applog(LOG_ERR, "KnC transport: ioctl error on SPI device %s: %m", dev_name);
  	close(ctx->fd);
  l_free_exit_error:
  	free(ctx);
  l_exit_error:
  	return NULL;
  }
  
  void knc_trnsp_free(void *opaque_ctx)
  {
  	struct spidev_context *ctx = opaque_ctx;
  
  	if (NULL == ctx)
  		return;
  
  	close(ctx->fd);
  	free(ctx);
  }
  
  int knc_trnsp_transfer(void *opaque_ctx, uint8_t *txbuf, uint8_t *rxbuf, int len)
  {
  	struct spidev_context *ctx = opaque_ctx;
  	struct spi_ioc_transfer xfr;
  	int ret;
  
  	memset(rxbuf, 0xff, len);
  
  	ret = len;
  
  	xfr.tx_buf = (unsigned long)txbuf;
  	xfr.rx_buf = (unsigned long)rxbuf;
  	xfr.len = len;
  	xfr.speed_hz = ctx->speed;
  	xfr.delay_usecs = ctx->delay;
  	xfr.bits_per_word = ctx->bits;
  	xfr.cs_change = 0;
  	xfr.pad = 0;
  
          applog(LOG_DEBUG, "KnC spi:");
          hexdump(txbuf, len);
  	if (1 > (ret = ioctl(ctx->fd, SPI_IOC_MESSAGE(1), &xfr)))
  		applog(LOG_ERR, "KnC spi xfer: ioctl error on SPI device: %m");
          hexdump(rxbuf, len);
  
  	return ret;
  }
  
  bool knc_trnsp_asic_detect(void *opaque_ctx, int chip_id)
  {
  	return true;
  }
  
  void knc_trnsp_periodic_check(void *opaque_ctx)
  {
  	return;
  }
  
  

Download