Raspberry PI DAQ system

From my driver:
* In the async command mode transfers can be handled in HUNK mode by creating a SPI message
* of many conversion sequences into one message, this allows for close to native driver wire-speed
* An optimized DMA driver is in the works
* https://github.com/msperl/spi-bcm2835/wiki
* (the current interrupt driven kernel driver is limited to a 12 to 64 byte FIFO and no DMA) HUNK_LEN data samples
* into the Comedi read buffer with a special mix_mode for sampling both ADC devices in an alt sequence for
* programs like xoscope at full speed. The transfer array is currently static but can easily be made into
* a config size parameter runtime value if needed with kmalloc for the required space

// lets talk to the device in a blast on the wire

#define HUNK_LEN   1024
struct comedi_control {
   u8 *tx_buff;
   u8 *rx_buff;
   struct spi_transfer t[HUNK_LEN];
   struct mutex daqgert_platform_lock;
};

...
static unsigned int daqgert_ai_get_sample(struct comedi_device *dev,
   struct comedi_subdevice *s)
{
...
  struct spi_param_type *spi_data = s->private;
  u8 *tx_buff, *rx_buff;
...
    memset(&pdata->t, 0, sizeof(pdata->t)); // clear the transfer array
     if (devpriv->ai_hunk) { /* for single channel command scans with pre-formatted tx_buffer*/
       if (spi_data->device_type == MCP3002) { // 10 bit adc data
         len = 2;
       } else {
         len = 3;
       }
       tx_buff = pdata->tx_buff;
       rx_buff = pdata->rx_buff;
       for (i = 0; i < HUNK_LEN; i++) { /* be sure we toggle CS between ADC commands */
         pdata->t[i].cs_change = 1;
         pdata->t[i].len = len;
         pdata->t[i].tx_buf = tx_buff;
         pdata->t[i].rx_buf = rx_buff;
         tx_buff += len; /* move the buffer ptr to the next transfer slot in the buffer memory */
         rx_buff += len;
       }
       spi_message_init_with_transfers(&m, &pdata->t[0], HUNK_LEN); // make the proper message with the transfers
...
    spi_sync(spi_data->spi, &m); // exchange SPI data
...
}

...[B]First it creates a command to submit to the driver:[/B]
  cmd.subdev = options.subdevice;
  cmd.flags = CMDF_WRITE;
  cmd.start_src = TRIG_INT;
  cmd.start_arg = 0;
  cmd.scan_begin_src = TRIG_TIMER;
  cmd.scan_begin_arg = 1e9 / options.freq;
  cmd.convert_src = TRIG_NOW;
  cmd.convert_arg = 0;
  cmd.scan_end_src = TRIG_COUNT;
  cmd.scan_end_arg = options.n_chan;
  cmd.stop_src = TRIG_NONE;
  cmd.stop_arg = 0;

  cmd.chanlist = chanlist;
  cmd.chanlist_len = options.n_chan;

... [B]sends it to the driver[/B]

  if ((err = comedi_command(dev, &cmd)) < 0) {
  comedi_perror("comedi_command");
  exit(1);

... [B]preloads the buffer some data to size check[/B]

  dds_output(data,BUF_LEN);
  n = BUF_LEN * sizeof(sampl_t);
  m = write(comedi_fileno(dev), (void *)data, n);
  if(m < 0){
  perror("write");
  exit(1);
  }else if(m < n)
  {
  fprintf(stderr, "failed to preload output buffer with %i bytes, is it too small?\n"
  "See the --write-buffer option of comedi_config\n", n);
  exit(1);
  }
  if (options.verbose)
  printf("m=%d\n",m);

...[B] triggers the command to start[/B]

  ret = comedi_internal_trigger(dev, options.subdevice, 0);
  if(ret < 0){
  perror("comedi_internal_trigger\n");
  exit(1);
  }

...[B]writes more data[/B]

  while(1){
  dds_output(data,BUF_LEN);
  n=BUF_LEN*sizeof(sampl_t);
  while(n>0){
  m=write(comedi_fileno(dev),(void *)data+(BUF_LEN*sizeof(sampl_t)-n),n);
  if(m<0){
  perror("write");
  exit(0);
  }
  if (options.verbose)
  printf("m=%d\n",m);
  n-=m;
  }
  total+=BUF_LEN;
  //printf("%d\n",total);
  }

  }

#ifdef CONFIG_BCM2708_SPIDEV
static struct spi_board_info bcm2708_spi_devices[] = {
#ifdef CONFIG_SPI_SPIDEV
  {
  .modalias = "spidev",
  .max_speed_hz = 500000,
  .bus_num = 0,
  .chip_select = 0,
  .mode = SPI_MODE_0,
  }, {
  .modalias = "spidev",
  .max_speed_hz = 500000,
  .bus_num = 0,
  .chip_select = 1,
  .mode = SPI_MODE_0,
  }
#endif
#ifdef CONFIG_SPI_COMEDI
  {
  .modalias = "spigert",
  .max_speed_hz = 500000,
  .bus_num = 0,
  .chip_select = 0,
  .mode = SPI_MODE_0,
  }, {
  .modalias = "spigert",
  .max_speed_hz = 500000,
  .bus_num = 0,
  .chip_select = 1,
  .mode = SPI_MODE_0,
  }
#endif
};
#endif

/*
* Do only two chip selects for the Gertboard
*/
if (spi->chip_select == CSnA) {
/*
* get a copy of the slave device 0 to share with comedi
* we need a device to talk to the ADC
*/
INIT_LIST_HEAD(&pdata->device_entry); /* create entry into the Comedi device list */
pdata->slave.spi = spi;
list_add_tail(&pdata->device_entry, &device_list); /* put entry into the Comedi device list */
}
if (spi->chip_select == CSnB) {
/*
* we need a device to talk to the DAC
*/
INIT_LIST_HEAD(&pdata->device_entry);
pdata->slave.spi = spi;
list_add_tail(&pdata->device_entry, &device_list);
}

if (gert_autoload)
ret = comedi_auto_config(&slave_spi->spi->master->dev, &daqgert_driver, 0);

static const struct daqgert_board daqgert_boards[] = {
{
.name = "Gertboard",
.board_type = 0,
.n_aichan = 2,
.n_aochan = 2,
.ai_ns_min = 50000, /* values plus software overhead */
.ai_ns_min_calc = 35000,
.ai_rate_min = 20000,
.ao_ns_min = 5000,
.ao_ns_min_calc = 4500,
.ao_rate_min = 10000,
.ai_cs = 0,
.ao_cs = 1,
.ai_max_speed_hz = 1000000,
.ao_max_speed_hz = 8000000,
},
....
static int32_t daqgert_auto_attach(struct comedi_device *dev, unsigned long unused_context)
{
const struct daqgert_board *thisboard = &daqgert_boards[gert_type];
struct comedi_subdevice *s;
int32_t ret, i;
int32_t num_ai_chan, num_ao_chan, num_dio_chan = NUM_DIO_CHAN;
struct daqgert_private *devpriv;
struct comedi_spigert *pdata;
struct spi_param_type *slave_spi_adc=NULL, *slave_spi_dac=NULL;
....
/*
* loop the spi device queue for needed devices
*/
if (list_empty(&device_list))
return -ENODEV;

list_for_each_entry(pdata, &device_list, device_entry)
{
if (pdata->slave.spi->chip_select == thisboard->ai_cs) {
slave_spi_adc = &pdata->slave;
pdata->slave.spi->max_speed_hz = thisboard->ai_max_speed_hz;
spi_setup(pdata->slave.spi);
dev_info(dev->class_dev, "setup: spi cd %d: %d Hz: assigned to adc devices\n",
pdata->slave.spi->chip_select, pdata->slave.spi->max_speed_hz);
} else {
slave_spi_dac = &pdata->slave;
pdata->slave.spi->max_speed_hz = thisboard->ao_max_speed_hz;
spi_setup(pdata->slave.spi);
dev_info(dev->class_dev, "setup: spi cd %d: %d Hz: assigned to dac devices\n",
pdata->slave.spi->chip_select, pdata->slave.spi->max_speed_hz);
}
}
/*
* check for possible bad spigert table entry
*/
if (!slave_spi_adc || !slave_spi_dac)
return -ENODEV;

... added node information
static const struct daqgert_board daqgert_boards[] = {
   {
     .name = "Gertboard",
     .board_type = 0,
     ....
     .ai_node = 3,
     .ao_node = 2,
   },
.....
  /*
    * setup kthreads on other cores if possible
    */
   cpu_nodes = num_online_cpus();
   dev_info(dev->class_dev, "%d cpu(s) online for threads\n", cpu_nodes);
   if (cpu_nodes >= 4) {
     devpriv->ai_node = thisboard->ai_node;
     devpriv->ao_node = thisboard->ao_node;
   }

/*
* make two threads for the i/o streams
*/
static int32_t daqgert_create_thread(struct comedi_device *dev, struct daqgert_private *devpriv)
{
   const char hunk_thread_name[] = "daqgerth", thread_name[] = "daqgert";
   const char *name_ptr;

   if (devpriv->hunk)
     name_ptr = hunk_thread_name;
   else
     name_ptr = thread_name;

   devpriv->ai_spi->daqgert_task = kthread_create_on_node(&daqgert_ai_thread_function, (void *) dev,
     cpu_to_node(devpriv->ai_node), "%s_a/%d", name_ptr, devpriv->ai_node);
   if (!IS_ERR(devpriv->ai_spi->daqgert_task)) {
     kthread_bind(devpriv->ai_spi->daqgert_task, devpriv->ai_node);
     wake_up_process(devpriv->ai_spi->daqgert_task);
   } else
     return PTR_ERR(devpriv->ai_spi->daqgert_task);

   devpriv->ao_spi->daqgert_task = kthread_create_on_node(&daqgert_ao_thread_function, (void *) dev,
     cpu_to_node(devpriv->ao_node), "%s_d/%d", name_ptr, devpriv->ao_node);
   if (!IS_ERR(devpriv->ao_spi->daqgert_task)) {
     kthread_bind(devpriv->ao_spi->daqgert_task, devpriv->ao_node);
     wake_up_process(devpriv->ao_spi->daqgert_task);
   } else
     return PTR_ERR(devpriv->ao_spi->daqgert_task);

   return 0;
}

       smp_mb__before_atomic();
       set_bit(SPI_AO_RUN, &devpriv->state_bits);
       smp_mb__after_atomic();

      __set_current_state(TASK_UNINTERRUPTIBLE);
       pdata->kmin = ktime_set(0, pdata->delay_nsecs);
       schedule_hrtimeout_range(&pdata->kmin, 0, HRTIMER_MODE_REL_PINNED);

/*
* Device Tree overlay for the spigert module used by Comedi daq_gert analog devices
*
*/

/dts-v1/;
/plugin/;

/ {
  compatible = "brcm,bcm2835", "brcm,bcm2708", "brcm,bcm2709";
  /* disable spi-dev for spi0.0 & spi0.1 */
  fragment@0 {
   target = <&spi0>;
   __overlay__ {
     status = "okay";

     spidev@0{
       status = "disabled";
     };
     spidev@1{
       status = "disabled";
     };
   };
  };

  fragment@1 {
   target = <&gpio>;
   __overlay__ {
  spi0_pins: spi0_pins {
  brcm,pins = <7 8 9 10 11>;
  brcm,function = <4>; /* alt0 */
  };
   };
  };

  fragment@2 {
   target = <&spi0>;
   __overlay__ {
  #address-cells = <1>;
  #size-cells = <0>;
  pinctrl-names = "default";
  pinctrl-0 = <&spi0_pins>;

  spigert@0 {
  compatible = "spigert";
  reg = <0>;  /* CE0 */
  spi-max-frequency = <500000>;
     status = "okay";
  };

  spigert@1 {
  compatible = "spigert";
  reg = <1>;  /* CE1 */
  spi-max-frequency = <500000>;
     status = "okay";
  };
   };
  };
};

  spi@7e204000 {
  reg = <0x7e204000 0x1000>;
  dmas = <0x3 0x6 0x3 0x7>;
  interrupts = <0x2 0x16>;
  pinctrl-0 = <0x27>;
  compatible = "brcm,bcm2835-spi";
  cs-gpios = <0x0 0x0>;
  clocks = <0x7>;
  status = "okay";
  #address-cells = <0x1>;
  phandle = <0x13>;
  #size-cells = <0x0>;
  dma-names = "tx", "rx";
  pinctrl-names = "default";
  linux,phandle = <0x13>;

  spidev@0 {
  reg = <0x0>;
  compatible = "spidev";
  spi-max-frequency = <0x7a120>;
  status = "disabled";
  #address-cells = <0x1>;
  #size-cells = <0x0>;
  };

  spidev@1 {
  reg = <0x1>;
  compatible = "spidev";
  spi-max-frequency = <0x7a120>;
  status = "disabled";
  #address-cells = <0x1>;
  #size-cells = <0x0>;
  };

  spigert@0 {
  reg = <0x0>;
  compatible = "spigert";
  spi-max-frequency = <0x7a120>;
  status = "okay";
  };

  spigert@1 {
  reg = <0x1>;
  compatible = "spigert";
  spi-max-frequency = <0x7a120>;
  status = "okay";
  };
  };

[35090.568221] daq_gert: module is from the staging directory, the quality is unknown, you have been warned.
[35090.570027] spigert spi0.1: setup: cd 1: bpw 8, mode 0x3
[35090.570260] spigert spi0.0: setup: cd 0: bpw 8, mode 0x3
[35090.571456] comedi comedi0: setup: spi cd 1: 8000000 Hz: assigned to dac devices
[35090.571488] comedi comedi0: setup: spi cd 0: 1000000 Hz: assigned to adc devices
[35090.571821] comedi comedi0: Gertboard WiringPi pins setup
[35090.571845] comedi comedi0: RPi new scheme rev a21041, serial 00000000f3083d7a, new rev 1
[35090.571863] comedi comedi0: driver gpio board rev 3
[35090.571885] comedi comedi0: Gertboard WPi pins set [0..7] to outputs
[35090.571901] comedi comedi0: Gertboard spi slave device detection started
[35090.572242] comedi comedi0: Gertboard adc board pre detect code 0, daqgert_conf option value 1
[35090.572400] comedi comedi0: Gertboard adc chip board detected, 2 channels, range code 0, device code 0, PIC code 0, detect code 0
[35090.572452] comedi comedi0: 4 cpu(s) online for threads
[35090.572987] comedi comedi0: daq_gert attached: gpio iobase 0x3f200000, ioremaps 0xbe5e0000  0xf3003000, io pins 0x0, 1Mhz timer value 0x8:0x2badae9c
[35090.580193] comedi comedi0: driver 'daq_gert' has successfully auto-configured 'Gertboard'.