From: Miroslav Ondra Date: Tue, 4 Sep 2018 17:08:03 +0000 (+0200) Subject: refactor iio initialization X-Git-Url: http://git.graph-it.com/?a=commitdiff_plain;h=ed1ff1dd6f17ac3684f0cfbe1f21fe79bff05340;p=graphit%2Funipi-kernel.git refactor iio initialization --- diff --git a/modules/unipi/src/unipi_common.h b/modules/unipi/src/unipi_common.h index 1bb90ec..d2db5dd 100644 --- a/modules/unipi/src/unipi_common.h +++ b/modules/unipi/src/unipi_common.h @@ -217,7 +217,7 @@ struct neuronspi_driver_data u8 uart_count_to_probe; }; -/* + struct neuronspi_gpio_port { struct spi_device* spi; struct gpio_chip gpio_c; @@ -227,16 +227,16 @@ struct neuronspi_gpio_port { struct neuronspi_gpio_driver { int count; - struct neuronspi_gpio_port* ports; -} - */ + struct neuronspi_gpio_port ports[1]; +}; +/* struct neuronspi_gpio_driver { struct spi_device* spi; struct gpio_chip gpio_c; struct platform_device *plat_dev; u8 io_index; }; - +*/ /*struct neuronspi_do_driver { struct spi_device* spi; diff --git a/modules/unipi/src/unipi_gpio.c b/modules/unipi/src/unipi_gpio.c index 9c6c8d4..ad2ad72 100644 --- a/modules/unipi/src/unipi_gpio.c +++ b/modules/unipi/src/unipi_gpio.c @@ -78,7 +78,7 @@ int neuronspi_gpio_di_direction_output(struct gpio_chip *chip, unsigned offset, } int neuronspi_gpio_di_get(struct gpio_chip *chip, unsigned offset) { - struct neuronspi_gpio_driver *n_di = gpiochip_get_data(chip); + struct neuronspi_gpio_port *n_di = gpiochip_get_data(chip); struct spi_device *spi = n_di->spi; return neuronspi_spi_gpio_di_get(spi, n_di->io_index); } @@ -88,7 +88,7 @@ int neuronspi_gpio_do_direction_output(struct gpio_chip *chip, unsigned offset, } void neuronspi_gpio_do_set(struct gpio_chip *chip, unsigned offset, int value) { - struct neuronspi_gpio_driver *n_do = gpiochip_get_data(chip); + struct neuronspi_gpio_port *n_do = gpiochip_get_data(chip); struct spi_device *spi = n_do->spi; neuronspi_spi_gpio_do_set(spi, n_do->io_index, value); } @@ -98,29 +98,25 @@ int neuronspi_gpio_ro_direction_output(struct gpio_chip *chip, unsigned offset, } void neuronspi_gpio_ro_set(struct gpio_chip *chip, unsigned offset, int value) { - struct neuronspi_gpio_driver *n_ro = gpiochip_get_data(chip); + struct neuronspi_gpio_port *n_ro = gpiochip_get_data(chip); struct spi_device *spi = n_ro->spi; neuronspi_spi_gpio_ro_set(spi, n_ro->io_index, value); } -struct neuronspi_gpio_driver * neuronspi_di_probe(int di_count, int neuron_index, struct platform_device *board_device) +struct neuronspi_gpio_driver * neuronspi_di_probe(int io_count, int neuron_index, struct platform_device *board_device) { - struct neuronspi_gpio_driver* di_driver_arr; - struct neuronspi_gpio_driver* pdi_driver; + struct neuronspi_gpio_driver* di_driver; + struct neuronspi_gpio_port* pdi_driver; int i; char buf[20]; - if (di_count <= 0) return NULL; + if (io_count <= 0) return NULL; - di_driver_arr = kzalloc(sizeof(struct neuronspi_gpio_driver) * di_count, GFP_ATOMIC); - for (i = 0; i < di_count; i++) { - pdi_driver = di_driver_arr + i; + di_driver = kzalloc(sizeof(struct neuronspi_gpio_driver) + (sizeof(struct neuronspi_gpio_port)) * (io_count-1), GFP_ATOMIC); + for (i = 0; i < io_count; i++) { + pdi_driver = di_driver->ports + i; scnprintf(buf, 20, "di_%d_%02d", neuron_index+1, i+1); - /*strcpy(pdi_driver->name, "di_0_00"); - pdi_driver->name[3] = neuron_index + '1'; - pdi_driver->name[5] = ((i + 1) / 10) + '0'; - pdi_driver->name[6] = ((i + 1) % 10) + '0';*/ pdi_driver->io_index = i; pdi_driver->spi = neuronspi_s_dev[neuron_index]; @@ -141,27 +137,24 @@ struct neuronspi_gpio_driver * neuronspi_di_probe(int di_count, int neuron_index pdi_driver->gpio_c.get = neuronspi_gpio_di_get; gpiochip_add_data(&pdi_driver->gpio_c, pdi_driver); } - return di_driver_arr; + di_driver->count = io_count; + return di_driver; } -struct neuronspi_gpio_driver * neuronspi_ro_probe(int ro_count, int neuron_index, struct platform_device *board_device) +struct neuronspi_gpio_driver * neuronspi_ro_probe(int io_count, int neuron_index, struct platform_device *board_device) { - struct neuronspi_gpio_driver* ro_driver_arr; - struct neuronspi_gpio_driver* pro_driver; + struct neuronspi_gpio_driver* ro_driver; + struct neuronspi_gpio_port* pro_driver; int i; char buf[20]; - if (ro_count <= 0) return NULL; + if (io_count <= 0) return NULL; - ro_driver_arr = kzalloc(sizeof(struct neuronspi_gpio_driver) * ro_count, GFP_ATOMIC); - for (i = 0; i < ro_count; i++) { - pro_driver = ro_driver_arr + i; + ro_driver = kzalloc(sizeof(struct neuronspi_gpio_driver) + (sizeof(struct neuronspi_gpio_port)) * (io_count-1), GFP_ATOMIC); + for (i = 0; i < io_count; i++) { + pro_driver = ro_driver->ports + i; scnprintf(buf, 20, "ro_%d_%02d", neuron_index+1, i+1); - /*strcpy(pro_driver->name, "ro_0_00"); - pro_driver->name[3] = neuron_index + '1'; - pro_driver->name[5] = ((i + 1) / 10) + '0'; - pro_driver->name[6] = ((i + 1) % 10) + '0';*/ pro_driver->io_index = i; pro_driver->spi = neuronspi_s_dev[neuron_index]; @@ -183,27 +176,24 @@ struct neuronspi_gpio_driver * neuronspi_ro_probe(int ro_count, int neuron_index gpiochip_add_data(&pro_driver->gpio_c, pro_driver); } - return ro_driver_arr; + ro_driver->count = io_count; + return ro_driver; } -struct neuronspi_gpio_driver * neuronspi_do_probe(int do_count, int neuron_index, struct platform_device *board_device) +struct neuronspi_gpio_driver * neuronspi_do_probe(int io_count, int neuron_index, struct platform_device *board_device) { - struct neuronspi_gpio_driver* do_driver_arr; - struct neuronspi_gpio_driver* pdo_driver; + struct neuronspi_gpio_driver* do_driver; + struct neuronspi_gpio_port* pdo_driver; int i; char buf[20]; - if (do_count <= 0) return NULL; + if (io_count <= 0) return NULL; - do_driver_arr = kzalloc(sizeof(struct neuronspi_gpio_driver) * do_count, GFP_ATOMIC); - for (i = 0; i < do_count; i++) { - pdo_driver = do_driver_arr + i; + do_driver = kzalloc(sizeof(struct neuronspi_gpio_driver) + (sizeof(struct neuronspi_gpio_port)) * (io_count-1), GFP_ATOMIC); + for (i = 0; i < io_count; i++) { + pdo_driver = do_driver->ports + i; scnprintf(buf, 20, "do_%d_%02d", neuron_index+1, i+1); - /*strcpy(pdo_driver->name, "do_0_00"); - pdo_driver->name[3] = neuron_index + '1'; - pdo_driver->name[5] = ((i + 1) / 10) + '0'; - pdo_driver->name[6] = ((i + 1) % 10) + '0';*/ pdo_driver->io_index = i; pdo_driver->spi = neuronspi_s_dev[neuron_index]; @@ -225,6 +215,18 @@ struct neuronspi_gpio_driver * neuronspi_do_probe(int do_count, int neuron_index gpiochip_add_data(&pdo_driver->gpio_c, pdo_driver); } - return do_driver_arr; + do_driver->count = io_count; + return do_driver; } +void neuronspi_gpio_remove(struct neuronspi_gpio_driver * gpio_driver) +{ + int i; + for (i = 0; i < gpio_driver->count; i++) { + gpiochip_remove(&gpio_driver->ports[i].gpio_c); + platform_set_drvdata(gpio_driver->ports[i].plat_dev, 0); + platform_device_unregister(gpio_driver->ports[i].plat_dev); + } + kfree(gpio_driver); + +} diff --git a/modules/unipi/src/unipi_gpio.h b/modules/unipi/src/unipi_gpio.h index e80dc18..4a1f129 100644 --- a/modules/unipi/src/unipi_gpio.h +++ b/modules/unipi/src/unipi_gpio.h @@ -38,5 +38,6 @@ void neuronspi_gpio_ro_set(struct gpio_chip *chip, unsigned offset, int value); struct neuronspi_gpio_driver * neuronspi_di_probe(int di_count, int neuron_index, struct platform_device *board_device); struct neuronspi_gpio_driver * neuronspi_ro_probe(int ro_count, int neuron_index, struct platform_device *board_device); struct neuronspi_gpio_driver * neuronspi_do_probe(int do_count, int neuron_index, struct platform_device *board_device); +void neuronspi_gpio_remove(struct neuronspi_gpio_driver * gpio_driver); #endif /* MODULES_NEURON_SPI_SRC_UNIPI_GPIO_H_ */ diff --git a/modules/unipi/src/unipi_iio.c b/modules/unipi/src/unipi_iio.c index a22cee3..2ff053f 100644 --- a/modules/unipi/src/unipi_iio.c +++ b/modules/unipi/src/unipi_iio.c @@ -392,3 +392,90 @@ int neuronspi_iio_sec_ao_write_raw(struct iio_dev *indio_dev, struct iio_chan_sp return -EINVAL; } } + + +struct iio_dev* neuronspi_stm_ai_probe(int io_count, int neuron_index, struct platform_device *board_device) +{ + struct spi_device *spi = neuronspi_s_dev[neuron_index]; + struct iio_dev *iio_driver = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); + + ((struct neuronspi_analog_data*)iio_priv(iio_driver))->parent = spi; + ((struct neuronspi_analog_data*)iio_priv(iio_driver))->index = 0; + iio_driver->modes = INDIO_DIRECT_MODE; + iio_driver->currentmode = INDIO_DIRECT_MODE; + iio_driver->name = "ai_type_a"; + iio_driver->dev.parent = &(board_device->dev); + dev_set_name(&iio_driver->dev, "ai_%d_1", neuron_index + 1); + iio_driver->num_channels = 2; + iio_driver->channels = neuronspi_stm_ai_chan_spec; + iio_driver->info = &neuronspi_stm_ai_info; + iio_device_register(iio_driver); + + return iio_driver; +} + +struct iio_dev* neuronspi_stm_ao_probe(int io_count, int neuron_index, struct platform_device *board_device) +{ + struct spi_device *spi = neuronspi_s_dev[neuron_index]; + struct iio_dev *iio_driver = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); + + ((struct neuronspi_analog_data*)iio_priv(iio_driver))->parent = spi; + ((struct neuronspi_analog_data*)iio_priv(iio_driver))->index = 0; + iio_driver->modes = INDIO_DIRECT_MODE; + iio_driver->currentmode = INDIO_DIRECT_MODE; + iio_driver->name = "ao_type_a"; + iio_driver->dev.parent = &(board_device->dev); + dev_set_name(&iio_driver->dev, "ao_%d_1", neuron_index + 1); + iio_driver->num_channels = 3; + iio_driver->channels = neuronspi_stm_ao_chan_spec; + iio_driver->info = &neuronspi_stm_ao_info; + iio_device_register(iio_driver); + + return iio_driver; +} + +struct iio_dev** neuronspi_sec_ai_probe(int io_count, int neuron_index, struct platform_device *board_device) +{ + struct iio_dev **iio_driver_arr = kzalloc(sizeof(struct neuronspi_analog_data*) * io_count, GFP_ATOMIC); + struct spi_device *spi = neuronspi_s_dev[neuron_index]; + int i; + + for (i = 0; i < io_count; i++) { + iio_driver_arr[i] = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); + ((struct neuronspi_analog_data*)iio_priv(iio_driver_arr[i]))->parent = spi; + ((struct neuronspi_analog_data*)iio_priv(iio_driver_arr[i]))->index = i; + iio_driver_arr[i]->modes = INDIO_DIRECT_MODE; + iio_driver_arr[i]->currentmode = INDIO_DIRECT_MODE; + iio_driver_arr[i]->name = "ai_type_b"; + iio_driver_arr[i]->dev.parent = &(board_device->dev); + dev_set_name(&iio_driver_arr[i]->dev, "ai_%d_%d", neuron_index + 1, i + 1); + iio_driver_arr[i]->num_channels = 3; + iio_driver_arr[i]->channels = neuronspi_sec_ai_chan_spec; + iio_driver_arr[i]->info = &neuronspi_sec_ai_info; + iio_device_register(iio_driver_arr[i]); + } + return iio_driver_arr; +} + +struct iio_dev** neuronspi_sec_ao_probe(int io_count, int neuron_index, struct platform_device *board_device) +{ + struct iio_dev **iio_driver_arr = kzalloc(sizeof(struct neuronspi_analog_data*) * io_count, GFP_ATOMIC); + struct spi_device *spi = neuronspi_s_dev[neuron_index]; + int i; + + for (i = 0; i < io_count; i++) { + iio_driver_arr[i] = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); + ((struct neuronspi_analog_data*)iio_priv(iio_driver_arr[i]))->parent = spi; + ((struct neuronspi_analog_data*)iio_priv(iio_driver_arr[i]))->index = i; + iio_driver_arr[i]->modes = INDIO_DIRECT_MODE; + iio_driver_arr[i]->currentmode = INDIO_DIRECT_MODE; + iio_driver_arr[i]->name = "ao_type_b"; + iio_driver_arr[i]->dev.parent = &(board_device->dev); + dev_set_name(&iio_driver_arr[i]->dev, "ao_%d_%d", neuron_index + 1, i + 1); + iio_driver_arr[i]->num_channels = 1; + iio_driver_arr[i]->channels = neuronspi_sec_ao_chan_spec; + iio_driver_arr[i]->info = &neuronspi_sec_ao_info; + iio_device_register(iio_driver_arr[i]); + } + return iio_driver_arr; +} diff --git a/modules/unipi/src/unipi_iio.h b/modules/unipi/src/unipi_iio.h index 90111b7..86c77ae 100644 --- a/modules/unipi/src/unipi_iio.h +++ b/modules/unipi/src/unipi_iio.h @@ -31,4 +31,9 @@ int neuronspi_iio_stm_ao_write_raw(struct iio_dev *indio_dev, struct iio_chan_sp int neuronspi_iio_sec_ai_read_raw(struct iio_dev *iio_dev, struct iio_chan_spec const *ch, int *val, int *val2, long mask); int neuronspi_iio_sec_ao_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int val, int val2, long mask); +struct iio_dev* neuronspi_stm_ai_probe(int io_count, int neuron_index, struct platform_device *board_device); +struct iio_dev* neuronspi_stm_ao_probe(int io_count, int neuron_index, struct platform_device *board_device); +struct iio_dev** neuronspi_sec_ai_probe(int io_count, int neuron_index, struct platform_device *board_device); +struct iio_dev** neuronspi_sec_ao_probe(int io_count, int neuron_index, struct platform_device *board_device); + #endif /* MODULES_NEURON_SPI_SRC_UNIPI_IIO_H_ */ diff --git a/modules/unipi/src/unipi_spi.c b/modules/unipi/src/unipi_spi.c index 453e5e6..a09ed56 100644 --- a/modules/unipi/src/unipi_spi.c +++ b/modules/unipi/src/unipi_spi.c @@ -863,17 +863,19 @@ s32 neuronspi_spi_probe(struct spi_device *spi) } while (n_spi->first_probe_reply[0] == 0 && i < 5); if (n_spi->first_probe_reply[0] != 0) { // CRC error sets the first byte to 0 - uart_count = n_spi->first_probe_reply[14-6] & 0x0f; + uart_count = n_spi->first_probe_reply[8] & 0x0f; + //lower_board_id = n_spi->first_probe_reply[13]; + for (i = 0; i < NEURONSPI_BOARDTABLE_LEN; i++) { - if (n_spi->first_probe_reply[19-6] == NEURONSPI_BOARDTABLE[i].lower_board_id) { + if (n_spi->first_probe_reply[13] == NEURONSPI_BOARDTABLE[i].lower_board_id) { if (n_spi->combination_id == 0xFF && NEURONSPI_BOARDTABLE[i].upper_board_id == 0) { n_spi->combination_id = NEURONSPI_BOARDTABLE[i].index; } if (n_spi->lower_board_id == 0xFF) { - n_spi->lower_board_id = n_spi->first_probe_reply[17-6]; + n_spi->lower_board_id = n_spi->first_probe_reply[11]; } - if (n_spi->first_probe_reply[17-6] == NEURONSPI_BOARDTABLE[i].index) { - n_spi->combination_id = n_spi->first_probe_reply[17-6]; + if (n_spi->first_probe_reply[11] == NEURONSPI_BOARDTABLE[i].index) { + n_spi->combination_id = n_spi->first_probe_reply[11]; n_spi->upper_board_id = NEURONSPI_BOARDTABLE[i].upper_board_id; } } @@ -890,7 +892,6 @@ s32 neuronspi_spi_probe(struct spi_device *spi) } if (n_spi->lower_board_id != 0xFF && n_spi->combination_id != 0xFF) { - //n_spi->features = kzalloc(sizeof(struct neuronspi_board_features), GFP_ATOMIC); n_spi->features = &(NEURONSPI_BOARDTABLE[n_spi->combination_id].definition->features); } else { n_spi->features = NULL; @@ -898,30 +899,24 @@ s32 neuronspi_spi_probe(struct spi_device *spi) n_spi->ideal_frequency = NEURONSPI_COMMON_FREQ; for (i = 0; i < NEURONSPI_SLOWER_MODELS_LEN; i++) { - if (NEURONSPI_SLOWER_MODELS[i] == (n_spi->first_probe_reply[19-6] << 8 | n_spi->first_probe_reply[18-6])) { + if (NEURONSPI_SLOWER_MODELS[i] == (n_spi->first_probe_reply[13] << 8 | n_spi->first_probe_reply[12])) { n_spi->ideal_frequency = NEURONSPI_SLOWER_FREQ; } } if (n_spi->lower_board_id != 0xFF && n_spi->combination_id != 0xFF) { - printk(KERN_INFO "UNIPISPI: Probe detected UniPi Board %s (L:%x U:%x C:%x) Fw: v%d.%d at CS%d (id=%d)\n\t\tUarts:%d, reg1000-4: %10ph\n", + printk(KERN_INFO "UNIPISPI: Probe detected UniPi Board %s (L:%x U:%x C:%x) Fw: v%d.%d at CS%d (id=%d)\n\\t\tUarts:%d, reg1000-4: %10ph\n", NEURONSPI_BOARDTABLE[n_spi->combination_id].definition->combination_name, n_spi->lower_board_id, n_spi->upper_board_id, n_spi->combination_id, n_spi->first_probe_reply[5], n_spi->first_probe_reply[4], spi->chip_select, n_spi->neuron_index, uart_count, n_spi->first_probe_reply +4) ; } else if (n_spi->lower_board_id != 0xFF) { - printk(KERN_INFO "UNIPISPI: Probe detected UniPi Board L:%x C:??? Index: %d Fw: v%d.%d at CS%d, Uart count: %d - reg1000: %x, \ -reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", - n_spi->lower_board_id, n_spi->neuron_index, n_spi->first_probe_reply[11-6], n_spi->first_probe_reply[10-6], - spi->chip_select, uart_count, n_spi->first_probe_reply[11-6] << 8 | n_spi->first_probe_reply[10-6], - n_spi->first_probe_reply[13-6] << 8 | n_spi->first_probe_reply[12-6], n_spi->first_probe_reply[15-6] << 8 | n_spi->first_probe_reply[14-6], - n_spi->first_probe_reply[17-6] << 8 | n_spi->first_probe_reply[16-6], n_spi->first_probe_reply[19-6] << 8 | n_spi->first_probe_reply[18-6]); + printk(KERN_INFO "UNIPISPI: Probe detected UniPi Board (L:%x C:???) Fw: v%d.%d at CS%d (id=%d)\n\\t\tUarts:%d, reg1000-4: %10ph\n", + n_spi->lower_board_id, n_spi->first_probe_reply[5], n_spi->first_probe_reply[4], + spi->chip_select, n_spi->neuron_index, uart_count, n_spi->first_probe_reply +4) ; } else { - printk(KERN_INFO "UNIPISPI: Probe detected UniPi Board L:??? C:??? Index: %d Fw: v%d.%d on CS%d, Uart count: %d - reg1000: %x, \ -reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", - n_spi->neuron_index, n_spi->first_probe_reply[11-6], n_spi->first_probe_reply[10-6], spi->chip_select, uart_count, - n_spi->first_probe_reply[11-6] << 8 | n_spi->first_probe_reply[10-6], n_spi->first_probe_reply[13-6] << 8 | n_spi->first_probe_reply[12-6], - n_spi->first_probe_reply[15-6] << 8 | n_spi->first_probe_reply[14-6], n_spi->first_probe_reply[17-6] << 8 | n_spi->first_probe_reply[16-6], - n_spi->first_probe_reply[19-6] << 8 | n_spi->first_probe_reply[18-6]); + printk(KERN_INFO "UNIPISPI: Probe detected UniPi Board (L:??? C:???) Fw: v%d.%d at CS%d (id=%d)\n\\t\tUarts:%d, reg1000-4: %10ph\n", + n_spi->first_probe_reply[5], n_spi->first_probe_reply[4], + spi->chip_select, n_spi->neuron_index, uart_count, n_spi->first_probe_reply +4) ; } if (n_spi->combination_id != 0xFF) { printk(KERN_INFO "UNIPISPI: UniPi device %s at CS%d uses SPI communication freq. %d Hz\n", @@ -962,17 +957,6 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", n_spi->board_device = neuronspi_board_device_probe(n_spi); - /*strcpy(n_spi->platform_name, "io_group0"); - n_spi->platform_name[8] = n_spi->neuron_index + '1'; - n_spi->board_device = platform_device_alloc(n_spi->platform_name, -1); - n_spi->board_device->dev.parent = &(neuron_plc_dev->dev); - if (n_spi->combination_id != 0xFF) { - n_spi->board_device->dev.groups = neuron_board_attr_groups; - } - n_spi->board_device->dev.driver = &neuronspi_spi_driver.driver; - platform_device_add(n_spi->board_device); - platform_set_drvdata(n_spi->board_device, n_spi);*/ - if (n_spi->features) { if (n_spi->features->led_count) { printk(KERN_INFO "UNIPISPI: LED: %d User leds detected at CS%d\n", n_spi->features->led_count, spi->chip_select); @@ -991,35 +975,14 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", } #endif if (n_spi->features->stm_ai_count) { - n_spi->stm_ai_driver = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); - ((struct neuronspi_analog_data*)iio_priv(n_spi->stm_ai_driver))->parent = spi; - ((struct neuronspi_analog_data*)iio_priv(n_spi->stm_ai_driver))->index = 0; - n_spi->stm_ai_driver->modes = INDIO_DIRECT_MODE; - n_spi->stm_ai_driver->currentmode = INDIO_DIRECT_MODE; - n_spi->stm_ai_driver->name = "ai_type_a"; - n_spi->stm_ai_driver->dev.parent = &(n_spi->board_device->dev); - dev_set_name(&n_spi->stm_ai_driver->dev, "ai_%d_1", (int)n_spi->neuron_index + 1); - n_spi->stm_ai_driver->num_channels = 2; - n_spi->stm_ai_driver->channels = neuronspi_stm_ai_chan_spec; - n_spi->stm_ai_driver->info = &neuronspi_stm_ai_info; - iio_device_register(n_spi->stm_ai_driver); + n_spi->stm_ai_driver = neuronspi_stm_ai_probe(n_spi->features->stm_ai_count, n_spi->neuron_index, n_spi->board_device); } if (n_spi->features->stm_ao_count) { - n_spi->stm_ao_driver = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); - ((struct neuronspi_analog_data*)iio_priv(n_spi->stm_ao_driver))->parent = spi; - ((struct neuronspi_analog_data*)iio_priv(n_spi->stm_ao_driver))->index = 0; - n_spi->stm_ao_driver->modes = INDIO_DIRECT_MODE; - n_spi->stm_ao_driver->currentmode = INDIO_DIRECT_MODE; - n_spi->stm_ao_driver->name = "ao_type_a"; - n_spi->stm_ao_driver->dev.parent = &(n_spi->board_device->dev); - dev_set_name(&n_spi->stm_ao_driver->dev, "ao_%d_1", (int)n_spi->neuron_index + 1); - n_spi->stm_ao_driver->num_channels = 3; - n_spi->stm_ao_driver->channels = neuronspi_stm_ao_chan_spec; - n_spi->stm_ao_driver->info = &neuronspi_stm_ao_info; - iio_device_register(n_spi->stm_ao_driver); + n_spi->stm_ao_driver = neuronspi_stm_ao_probe(n_spi->features->stm_ao_count, n_spi->neuron_index, n_spi->board_device); } if (n_spi->features->sec_ai_count) { - n_spi->sec_ai_driver = kzalloc(sizeof(struct neuronspi_analog_data*) * n_spi->features->sec_ai_count, GFP_ATOMIC); + n_spi->sec_ai_driver = neuronspi_sec_ai_probe(n_spi->features->sec_ai_count, n_spi->neuron_index, n_spi->board_device); + /* kzalloc(sizeof(struct neuronspi_analog_data*) * n_spi->features->sec_ai_count, GFP_ATOMIC); for (i = 0; i < n_spi->features->sec_ai_count; i++) { n_spi->sec_ai_driver[i] = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); ((struct neuronspi_analog_data*)iio_priv(n_spi->sec_ai_driver[i]))->parent = spi; @@ -1033,10 +996,11 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", n_spi->sec_ai_driver[i]->channels = neuronspi_sec_ai_chan_spec; n_spi->sec_ai_driver[i]->info = &neuronspi_sec_ai_info; iio_device_register(n_spi->sec_ai_driver[i]); - } + }*/ } if (n_spi->features->sec_ao_count) { - n_spi->sec_ao_driver = kzalloc(sizeof(struct neuronspi_analog_data*) * n_spi->features->sec_ao_count, GFP_ATOMIC); + n_spi->sec_ao_driver = neuronspi_sec_ao_probe(n_spi->features->sec_ao_count, n_spi->neuron_index, n_spi->board_device); + /*n_spi->sec_ao_driver = kzalloc(sizeof(struct neuronspi_analog_data*) * n_spi->features->sec_ao_count, GFP_ATOMIC); for (i = 0; i < n_spi->features->sec_ao_count; i++) { n_spi->sec_ao_driver[i] = devm_iio_device_alloc(&(spi->dev), sizeof(struct neuronspi_analog_data)); ((struct neuronspi_analog_data*)iio_priv(n_spi->sec_ao_driver[i]))->parent = spi; @@ -1050,7 +1014,7 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", n_spi->sec_ao_driver[i]->channels = neuronspi_sec_ao_chan_spec; n_spi->sec_ao_driver[i]->info = &neuronspi_sec_ao_info; iio_device_register(n_spi->sec_ao_driver[i]); - } + }*/ } } @@ -1092,40 +1056,23 @@ s32 neuronspi_spi_remove(struct spi_device *spi) int i; struct neuronspi_driver_data *n_spi = spi_get_drvdata(spi); if (n_spi) { + + kthread_flush_worker(&n_spi->primary_worker); + if (n_spi->led_driver) { for (i = 0; i < n_spi->features->led_count; i++) { led_classdev_unregister(&(n_spi->led_driver[i].ldev)); } - kthread_flush_worker(&n_spi->primary_worker); kfree(n_spi->led_driver); n_spi->led_driver = NULL; } printk(KERN_INFO "UNIPISPI: LED DRIVER UNREGISTERED\n"); - if (n_spi->di_driver) { - for (i = 0; i < n_spi->features->di_count; i++) { - gpiochip_remove(&n_spi->di_driver[i].gpio_c); - platform_set_drvdata(n_spi->di_driver[i].plat_dev, 0); - platform_device_unregister(n_spi->di_driver[i].plat_dev); - } - kfree(n_spi->di_driver); - } - if (n_spi->do_driver) { - for (i = 0; i < n_spi->features->do_count; i++) { - gpiochip_remove(&n_spi->do_driver[i].gpio_c); - platform_set_drvdata(n_spi->do_driver[i].plat_dev, 0); - platform_device_unregister(n_spi->do_driver[i].plat_dev); - } - kfree(n_spi->do_driver); - } - if (n_spi->ro_driver) { - for (i = 0; i < n_spi->features->ro_count; i++) { - gpiochip_remove(&n_spi->ro_driver[i].gpio_c); - platform_set_drvdata(n_spi->ro_driver[i].plat_dev, 0); - platform_device_unregister(n_spi->ro_driver[i].plat_dev); - } - kfree(n_spi->ro_driver); - } + + if (n_spi->di_driver) { neuronspi_gpio_remove(n_spi->di_driver); } + if (n_spi->do_driver) { neuronspi_gpio_remove(n_spi->do_driver); } + if (n_spi->ro_driver) { neuronspi_gpio_remove(n_spi->ro_driver); } printk(KERN_INFO "UNIPISPI: GPIO DRIVER UNREGISTERED\n"); + if (n_spi->stm_ai_driver) { iio_device_unregister(n_spi->stm_ai_driver); } diff --git a/modules/unipi/src/unipi_sysfs.c b/modules/unipi/src/unipi_sysfs.c index 3398b71..4961e89 100644 --- a/modules/unipi/src/unipi_sysfs.c +++ b/modules/unipi/src/unipi_sysfs.c @@ -341,7 +341,7 @@ static ssize_t neuronspi_spi_gpio_show_pwm_presc(struct device *dev, struct devi { ssize_t ret = 0; u32 val = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -357,7 +357,7 @@ static ssize_t neuronspi_spi_gpio_store_pwm_presc(struct device *dev, struct dev { ssize_t err = 0; unsigned int val = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -375,7 +375,7 @@ static ssize_t neuronspi_spi_gpio_show_pwm_freq(struct device *dev, struct devic { ssize_t ret = 0; u32 val = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -391,7 +391,7 @@ static ssize_t neuronspi_spi_gpio_store_pwm_freq(struct device *dev, struct devi { ssize_t err = 0; unsigned int val = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -409,7 +409,7 @@ static ssize_t neuronspi_spi_gpio_show_pwm_cycle(struct device *dev, struct devi { ssize_t ret = 0; u32 val = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -425,7 +425,7 @@ static ssize_t neuronspi_spi_gpio_store_pwm_cycle(struct device *dev, struct dev { ssize_t err = 0; unsigned int val = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -444,7 +444,7 @@ static ssize_t neuronspi_spi_gpio_di_show_counter(struct device *dev, struct dev ssize_t ret = 0; u32 val = 0; u32 val_upper = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -462,7 +462,7 @@ static ssize_t neuronspi_spi_gpio_di_store_counter(struct device *dev, struct de { ssize_t err = 0; unsigned int val = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -481,7 +481,7 @@ static ssize_t neuronspi_spi_gpio_di_show_debounce(struct device *dev, struct de { ssize_t ret = 0; u32 val = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -497,7 +497,7 @@ static ssize_t neuronspi_spi_gpio_di_store_debounce(struct device *dev, struct d { ssize_t err = 0; unsigned int val = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -515,7 +515,7 @@ static ssize_t neuronspi_spi_gpio_di_show_value(struct device *dev, struct devic { ssize_t ret = 0; int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -533,7 +533,7 @@ static ssize_t neuronspi_spi_gpio_do_show_value(struct device *dev, struct devic { ssize_t ret = 0; int val; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -552,7 +552,7 @@ static ssize_t neuronspi_spi_gpio_do_store_value(struct device *dev, struct devi ssize_t err = 0; int inp = 0; unsigned int val; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -576,7 +576,7 @@ static ssize_t neuronspi_spi_gpio_ro_show_value(struct device *dev, struct devic { ssize_t ret = 0; int val; - struct neuronspi_gpio_driver *n_ro; + struct neuronspi_gpio_port *n_ro; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_ro = platform_get_drvdata(plat); @@ -595,7 +595,7 @@ static ssize_t neuronspi_spi_gpio_ro_store_value(struct device *dev, struct devi ssize_t err = 0; int inp = 0; unsigned int val; - struct neuronspi_gpio_driver *n_ro; + struct neuronspi_gpio_port *n_ro; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_ro = platform_get_drvdata(plat); @@ -620,7 +620,7 @@ static ssize_t neuronspi_spi_gpio_show_ds_enable(struct device *dev, struct devi { ssize_t ret = 0; int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -638,7 +638,7 @@ static ssize_t neuronspi_spi_gpio_show_ds_toggle(struct device *dev, struct devi { ssize_t ret = 0; int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -656,7 +656,7 @@ static ssize_t neuronspi_spi_gpio_show_ds_polarity(struct device *dev, struct de { ssize_t ret = 0; int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -675,7 +675,7 @@ static ssize_t neuronspi_spi_gpio_store_ds_enable(struct device *dev, struct dev ssize_t err = 0; int inp = 0; unsigned int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -700,7 +700,7 @@ static ssize_t neuronspi_spi_gpio_store_ds_toggle(struct device *dev, struct dev ssize_t err = 0; int inp = 0; unsigned int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -725,7 +725,7 @@ static ssize_t neuronspi_spi_gpio_store_ds_polarity(struct device *dev, struct d ssize_t err = 0; int inp = 0; unsigned int val; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -923,13 +923,13 @@ static ssize_t neuronspi_spi_show_uboard_id(struct device *dev, struct device_at static ssize_t neuronspi_spi_gpio_show_do_prefix(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_do->spi); if (n_spi->features && n_spi->features->do_count > 0 && n_spi->do_driver) { - ret = scnprintf(buf, 255, "%s_%d\n", n_spi->do_driver[n_do->io_index].gpio_c.label, n_spi->neuron_index + 1); + ret = scnprintf(buf, 255, "%s_%d\n", n_do->gpio_c.label, n_spi->neuron_index + 1); } return ret; } @@ -937,13 +937,13 @@ static ssize_t neuronspi_spi_gpio_show_do_prefix(struct device *dev, struct devi static ssize_t neuronspi_spi_gpio_show_di_prefix(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_di->spi); if (n_spi->features && n_spi->features->di_count > 0 && n_spi->di_driver) { - ret = scnprintf(buf, 255, "%s_%d\n", n_spi->di_driver[n_di->io_index].gpio_c.label, n_spi->neuron_index + 1); + ret = scnprintf(buf, 255, "%s_%d\n", n_di->gpio_c.label, n_spi->neuron_index + 1); } return ret; } @@ -951,13 +951,13 @@ static ssize_t neuronspi_spi_gpio_show_di_prefix(struct device *dev, struct devi static ssize_t neuronspi_spi_gpio_show_ro_prefix(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_ro; + struct neuronspi_gpio_port *n_ro; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_ro = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_ro->spi); if (n_spi->features && n_spi->features->ro_count > 0 && n_spi->ro_driver) { - ret = scnprintf(buf, 255, "%s_%d\n", n_spi->ro_driver[n_ro->io_index].gpio_c.label, n_spi->neuron_index + 1); + ret = scnprintf(buf, 255, "%s_%d\n", n_ro->gpio_c.label, n_spi->neuron_index + 1); } return ret; } @@ -965,13 +965,13 @@ static ssize_t neuronspi_spi_gpio_show_ro_prefix(struct device *dev, struct devi static ssize_t neuronspi_spi_gpio_show_do_base(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_do->spi); if (n_spi->features && n_spi->features->do_count > 0 && n_spi->do_driver) { - ret = scnprintf(buf, 255, "%d\n", n_spi->do_driver[n_do->io_index].gpio_c.base); + ret = scnprintf(buf, 255, "%d\n", n_do->gpio_c.base); } return ret; } @@ -979,13 +979,13 @@ static ssize_t neuronspi_spi_gpio_show_do_base(struct device *dev, struct device static ssize_t neuronspi_spi_gpio_show_di_base(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_di->spi); if (n_spi->features && n_spi->features->di_count > 0 && n_spi->di_driver) { - ret = scnprintf(buf, 255, "%d\n", n_spi->di_driver[n_di->io_index].gpio_c.base); + ret = scnprintf(buf, 255, "%d\n", n_di->gpio_c.base); } return ret; } @@ -993,13 +993,13 @@ static ssize_t neuronspi_spi_gpio_show_di_base(struct device *dev, struct device static ssize_t neuronspi_spi_gpio_show_ro_base(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_ro; + struct neuronspi_gpio_port *n_ro; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_ro = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_ro->spi); if (n_spi->features && n_spi->features->ro_count > 0 && n_spi->ro_driver) { - ret = scnprintf(buf, 255, "%d\n", n_spi->ro_driver[n_ro->io_index].gpio_c.base); + ret = scnprintf(buf, 255, "%d\n", n_ro->gpio_c.base); } return ret; } @@ -1007,13 +1007,13 @@ static ssize_t neuronspi_spi_gpio_show_ro_base(struct device *dev, struct device static ssize_t neuronspi_spi_gpio_show_do_count(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_do; + struct neuronspi_gpio_port *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_do->spi); if (n_spi->features && n_spi->features->do_count > 0 && n_spi->do_driver) { - ret = scnprintf(buf, 255, "%d\n", n_spi->do_driver[n_do->io_index].gpio_c.ngpio); + ret = scnprintf(buf, 255, "%d\n", n_do->gpio_c.ngpio); } return ret; } @@ -1021,13 +1021,13 @@ static ssize_t neuronspi_spi_gpio_show_do_count(struct device *dev, struct devic static ssize_t neuronspi_spi_gpio_show_di_count(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_di; + struct neuronspi_gpio_port *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_di->spi); if (n_spi->features && n_spi->features->di_count > 0 && n_spi->di_driver) { - ret = scnprintf(buf, 255, "%d\n", n_spi->di_driver[n_di->io_index].gpio_c.ngpio); + ret = scnprintf(buf, 255, "%d\n", n_di->gpio_c.ngpio); } return ret; } @@ -1035,13 +1035,13 @@ static ssize_t neuronspi_spi_gpio_show_di_count(struct device *dev, struct devic static ssize_t neuronspi_spi_gpio_show_ro_count(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret = 0; - struct neuronspi_gpio_driver *n_ro; + struct neuronspi_gpio_port *n_ro; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_ro = platform_get_drvdata(plat); n_spi = spi_get_drvdata(n_ro->spi); if (n_spi->features && n_spi->features->ro_count > 0 && n_spi->ro_driver) { - ret = scnprintf(buf, 255, "%d\n", n_spi->ro_driver[n_ro->io_index].gpio_c.ngpio); + ret = scnprintf(buf, 255, "%d\n", n_ro->gpio_c.ngpio); } return ret; }