u8 uart_count_to_probe;
};
-/*
+
struct neuronspi_gpio_port {
struct spi_device* spi;
struct gpio_chip gpio_c;
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;
}
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);
}
}
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);
}
}
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];
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];
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];
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);
+
+}
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_ */
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;
+}
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_ */
} 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;
}
}
}
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;
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",
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);
}
#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;
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;
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]);
- }
+ }*/
}
}
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);
}
{
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);
{
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);
{
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);
{
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);
{
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);
{
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);
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);
{
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);
{
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);
{
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);
{
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);
{
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);
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);
{
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);
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);
{
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);
{
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);
{
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);
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);
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);
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);
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
git.graph-it.com / graphit / unipi-kernel.git / commitdiff