From: Miroslav Ondra Date: Tue, 4 Sep 2018 12:14:01 +0000 (+0200) Subject: refactor platform, led, sysfs initialization X-Git-Url: http://git.graph-it.com/?a=commitdiff_plain;h=ca00eb0c2c1b8092c8388ad4755fe47fa448c7b1;p=graphit%2Funipi-kernel.git refactor platform, led, sysfs initialization --- diff --git a/modules/unipi/src/unipi_common.h b/modules/unipi/src/unipi_common.h index 514e3b4..1bb90ec 100644 --- a/modules/unipi/src/unipi_common.h +++ b/modules/unipi/src/unipi_common.h @@ -69,7 +69,7 @@ #define NEURONSPI_MAX_BAUD 115200 #define NEURONSPI_FIFO_SIZE 256 #define NEURONSPI_FIFO_MIN_CONTINUOUS 50 -#define NEURONSPI_DETAILED_DEBUG 0 +#define NEURONSPI_DETAILED_DEBUG 2 #define NEURONSPI_LAST_TRANSFER_DELAY 40 #define MAX_RX_QUEUE_LEN 16 @@ -175,14 +175,14 @@ struct neuronspi_char_driver // Instantiated once per SPI device struct neuronspi_driver_data { - struct spi_driver *spi_driver; - struct neuronspi_char_driver *char_driver; + //struct spi_driver *spi_driver; + //struct neuronspi_char_driver *char_driver; //struct uart_driver *serial_driver; -- this is global variable neuronspi_uart_driver_global //struct neuronspi_uart_data *uart_data; -- this global var neuronspi_uar_data_global struct neuronspi_led_driver *led_driver; - struct neuronspi_di_driver **di_driver; - struct neuronspi_do_driver **do_driver; - struct neuronspi_ro_driver **ro_driver; + struct neuronspi_gpio_driver *di_driver; + struct neuronspi_gpio_driver *do_driver; + struct neuronspi_gpio_driver *ro_driver; struct platform_device *board_device; struct iio_dev *stm_ai_driver; struct iio_dev *stm_ao_driver; @@ -196,7 +196,7 @@ struct neuronspi_driver_data struct neuronspi_board_features *features; struct neuronspi_board_regstart_table *regstart_table; struct spinlock sysfs_regmap_lock; - char platform_name[sizeof("io_group0")]; + //char platform_name[sizeof("io_group0")]; u32 probe_always_succeeds; u32 always_create_uart; @@ -204,9 +204,7 @@ struct neuronspi_driver_data u8 reserved_device; int uart_count; int uart_pindex; - //u8 uart_read; - //u8 *uart_buf; - //u8 slower_model; + u8 no_irq; u8 lower_board_id; u8 upper_board_id; @@ -219,15 +217,27 @@ struct neuronspi_driver_data u8 uart_count_to_probe; }; -struct neuronspi_di_driver { +/* +struct neuronspi_gpio_port { + struct spi_device* spi; + struct gpio_chip gpio_c; + struct platform_device *plat_dev; + u8 io_index; +}; + +struct neuronspi_gpio_driver { + int count; + struct neuronspi_gpio_port* ports; +} + */ +struct neuronspi_gpio_driver { struct spi_device* spi; struct gpio_chip gpio_c; struct platform_device *plat_dev; - u8 di_index; - char name[sizeof("di_0_00")]; + u8 io_index; }; -struct neuronspi_do_driver +/*struct neuronspi_do_driver { struct spi_device* spi; struct gpio_chip gpio_c; @@ -244,6 +254,7 @@ struct neuronspi_ro_driver u8 ro_index; char name[sizeof("ro_0_00")]; }; +*/ struct neuronspi_sec_ai_driver { diff --git a/modules/unipi/src/unipi_gpio.c b/modules/unipi/src/unipi_gpio.c index 3cfab5b..9c6c8d4 100644 --- a/modules/unipi/src/unipi_gpio.c +++ b/modules/unipi/src/unipi_gpio.c @@ -78,9 +78,9 @@ 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_di_driver *n_di = gpiochip_get_data(chip); + struct neuronspi_gpio_driver *n_di = gpiochip_get_data(chip); struct spi_device *spi = n_di->spi; - return neuronspi_spi_gpio_di_get(spi, n_di->di_index); + return neuronspi_spi_gpio_di_get(spi, n_di->io_index); } int neuronspi_gpio_do_direction_output(struct gpio_chip *chip, unsigned offset, int value) { @@ -88,9 +88,9 @@ 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_do_driver *n_do = gpiochip_get_data(chip); + struct neuronspi_gpio_driver *n_do = gpiochip_get_data(chip); struct spi_device *spi = n_do->spi; - neuronspi_spi_gpio_do_set(spi, n_do->do_index, value); + neuronspi_spi_gpio_do_set(spi, n_do->io_index, value); } int neuronspi_gpio_ro_direction_output(struct gpio_chip *chip, unsigned offset, int value) { @@ -98,8 +98,133 @@ 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_ro_driver *n_ro = gpiochip_get_data(chip); + struct neuronspi_gpio_driver *n_ro = gpiochip_get_data(chip); struct spi_device *spi = n_ro->spi; - neuronspi_spi_gpio_ro_set(spi, n_ro->ro_index, value); + 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* di_driver_arr; + struct neuronspi_gpio_driver* pdi_driver; + int i; + char buf[20]; + + if (di_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; + 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->plat_dev = platform_device_alloc(buf, -1); + pdi_driver->plat_dev->dev.parent = &(board_device->dev); + pdi_driver->plat_dev->dev.groups = neuron_gpio_di_attr_groups; + pdi_driver->plat_dev->dev.driver = &neuronspi_spi_driver.driver; + platform_device_add(pdi_driver->plat_dev); + + platform_set_drvdata(pdi_driver->plat_dev, pdi_driver); + pdi_driver->gpio_c.owner = THIS_MODULE; + pdi_driver->gpio_c.parent = &(pdi_driver->plat_dev->dev); + pdi_driver->gpio_c.label = "neuron_di"; + pdi_driver->gpio_c.can_sleep = 1; + pdi_driver->gpio_c.ngpio = 1; + pdi_driver->gpio_c.base = -1; + pdi_driver->gpio_c.direction_input = neuronspi_gpio_di_direction_input; + pdi_driver->gpio_c.get = neuronspi_gpio_di_get; + gpiochip_add_data(&pdi_driver->gpio_c, pdi_driver); + } + return di_driver_arr; +} + +struct neuronspi_gpio_driver * neuronspi_ro_probe(int ro_count, int neuron_index, struct platform_device *board_device) +{ + struct neuronspi_gpio_driver* ro_driver_arr; + struct neuronspi_gpio_driver* pro_driver; + int i; + char buf[20]; + + if (ro_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; + + 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]; + + pro_driver->plat_dev = platform_device_alloc(buf, -1); + pro_driver->plat_dev->dev.parent = &(board_device->dev); + pro_driver->plat_dev->dev.groups = neuron_gpio_ro_attr_groups; + pro_driver->plat_dev->dev.driver = &neuronspi_spi_driver.driver; + platform_device_add(pro_driver->plat_dev); + + platform_set_drvdata(pro_driver->plat_dev, pro_driver); + pro_driver->gpio_c.owner = THIS_MODULE; + pro_driver->gpio_c.parent = &(pro_driver->plat_dev->dev); + pro_driver->gpio_c.label = "neuron_ro"; + pro_driver->gpio_c.can_sleep = 1; + pro_driver->gpio_c.ngpio = 1; + pro_driver->gpio_c.base = -1; + pro_driver->gpio_c.direction_output = neuronspi_gpio_ro_direction_output; + pro_driver->gpio_c.set = neuronspi_gpio_ro_set; + gpiochip_add_data(&pro_driver->gpio_c, pro_driver); + + } + return ro_driver_arr; +} + +struct neuronspi_gpio_driver * neuronspi_do_probe(int do_count, int neuron_index, struct platform_device *board_device) +{ + struct neuronspi_gpio_driver* do_driver_arr; + struct neuronspi_gpio_driver* pdo_driver; + int i; + char buf[20]; + + if (do_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; + + 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]; + + pdo_driver->plat_dev = platform_device_alloc(buf, -1); + pdo_driver->plat_dev->dev.parent = &(board_device->dev); + pdo_driver->plat_dev->dev.groups = neuron_gpio_do_attr_groups; + pdo_driver->plat_dev->dev.driver = &neuronspi_spi_driver.driver; + platform_device_add(pdo_driver->plat_dev); + + platform_set_drvdata(pdo_driver->plat_dev, pdo_driver); + pdo_driver->gpio_c.owner = THIS_MODULE; + pdo_driver->gpio_c.parent = &(pdo_driver->plat_dev->dev); + pdo_driver->gpio_c.label = "neuron_do"; + pdo_driver->gpio_c.can_sleep = 1; + pdo_driver->gpio_c.ngpio = 1; + pdo_driver->gpio_c.base = -1; + pdo_driver->gpio_c.direction_output = neuronspi_gpio_do_direction_output; + pdo_driver->gpio_c.set = neuronspi_gpio_do_set; + gpiochip_add_data(&pdo_driver->gpio_c, pdo_driver); + + } + return do_driver_arr; } diff --git a/modules/unipi/src/unipi_gpio.h b/modules/unipi/src/unipi_gpio.h index 05f5760..e80dc18 100644 --- a/modules/unipi/src/unipi_gpio.h +++ b/modules/unipi/src/unipi_gpio.h @@ -35,4 +35,8 @@ int neuronspi_gpio_ro_direction_input(struct gpio_chip *chip, unsigned offset); int neuronspi_gpio_ro_direction_output(struct gpio_chip *chip, unsigned offset, int value); 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); + #endif /* MODULES_NEURON_SPI_SRC_UNIPI_GPIO_H_ */ diff --git a/modules/unipi/src/unipi_misc.c b/modules/unipi/src/unipi_misc.c index 0168712..1d6a75f 100644 --- a/modules/unipi/src/unipi_misc.c +++ b/modules/unipi/src/unipi_misc.c @@ -56,3 +56,32 @@ void neuronspi_led_set_brightness(struct led_classdev *ldev, enum led_brightness kthread_queue_work(&n_spi->primary_worker, &led->led_work); spin_unlock_irqrestore(&led->lock, flags); } + + +struct neuronspi_led_driver * neuronspi_led_probe(int led_count, int neuron_index, struct platform_device *board_device) +{ + struct neuronspi_led_driver * led_driver = kzalloc(sizeof(struct neuronspi_led_driver) * led_count, GFP_ATOMIC); + int i; + + for (i = 0; i < led_count; i++) { + scnprintf(led_driver[i].name, sizeof(led_driver[i].name), "unipi:green:uled-x%x", i); + /*strcpy(led_driver[i].name, "unipi:green:uled-x1"); + if (i < 9) { + led_driver[i].name[18] = i + '1'; + } else { + led_driver[i].name[18] = i - 9 + 'a'; + }*/ + // Initialise the rest of the structure + led_driver[i].id = i; + led_driver[i].brightness = LED_OFF; + led_driver[i].spi = neuronspi_s_dev[neuron_index]; + + spin_lock_init(&led_driver[i].lock); + led_driver[i].ldev.name = led_driver[i].name; + led_driver[i].ldev.brightness = led_driver[i].brightness; + led_driver[i].ldev.brightness_set = neuronspi_led_set_brightness; + led_classdev_register(&(board_device->dev), &(led_driver[i].ldev)); + kthread_init_work(&(led_driver[i].led_work), neuronspi_led_proc); + } + return led_driver; +} \ No newline at end of file diff --git a/modules/unipi/src/unipi_misc.h b/modules/unipi/src/unipi_misc.h index 514ea1e..c70c4f3 100644 --- a/modules/unipi/src/unipi_misc.h +++ b/modules/unipi/src/unipi_misc.h @@ -27,5 +27,6 @@ void neuronspi_led_proc(struct kthread_work *ws); void neuronspi_led_set_brightness(struct led_classdev *ldev, enum led_brightness brightness); +struct neuronspi_led_driver * neuronspi_led_probe(int led_count, int neuron_index, struct platform_device *board_device); #endif /* MODULES_NEURON_SPI_SRC_UNIPI_MISC_H_ */ diff --git a/modules/unipi/src/unipi_platform.c b/modules/unipi/src/unipi_platform.c index ce1fc0d..94d2ca6 100644 --- a/modules/unipi/src/unipi_platform.c +++ b/modules/unipi/src/unipi_platform.c @@ -2008,3 +2008,26 @@ s32 neuronspi_find_model_id(u32 probe_count) } +struct platform_device * neuronspi_board_device_probe(struct neuronspi_driver_data *n_spi) +{ + char buf[20]; + struct platform_device * board_device; + scnprintf(buf, 20, "io_group%d", n_spi->neuron_index+1); + + //strcpy(n_spi->platform_name, "io_group0"); + //n_spi->platform_name[8] = n_spi->neuron_index + '1'; + + board_device = platform_device_alloc(buf, -1); + board_device->dev.parent = &(neuron_plc_dev->dev); + + if (n_spi->combination_id != 0xFF) { + board_device->dev.groups = neuron_board_attr_groups; + } + + board_device->dev.driver = &neuronspi_spi_driver.driver; + platform_device_add(board_device); + platform_set_drvdata(board_device, n_spi); + + return board_device; +} + diff --git a/modules/unipi/src/unipi_platform.h b/modules/unipi/src/unipi_platform.h index 353d58e..464eb87 100644 --- a/modules/unipi/src/unipi_platform.h +++ b/modules/unipi/src/unipi_platform.h @@ -357,4 +357,6 @@ int neuronspi_create_reg_starts(struct neuronspi_board_regstart_table *out_table s32 neuronspi_find_reg_start(struct neuronspi_board_combination *board, u16 regfun); s32 neuronspi_find_model_id(u32 probe_count); +struct platform_device * neuronspi_board_device_probe(struct neuronspi_driver_data *n_spi); + #endif /* MODULES_NEURON_SPI_SRC_UNIPI_PLATFORM_H_ */ diff --git a/modules/unipi/src/unipi_spi.c b/modules/unipi/src/unipi_spi.c index f383d5f..453e5e6 100644 --- a/modules/unipi/src/unipi_spi.c +++ b/modules/unipi/src/unipi_spi.c @@ -237,7 +237,6 @@ int _neuronspi_spi_send_op(struct spi_device* spi_dev, s32 trans_count, const st if (opcode != 0x43) { // read one incomming character from UART neuronspi_rx_queue_add(port, recv_buf->first_message[3]); - //neuronspi_uart_handle_rx(port, 1, 1); } // read queue length port->rx_remain = recv_buf->first_message[2]; @@ -353,7 +352,7 @@ ssize_t neuronspi_read (struct file *file_p, char *buffer, size_t len, loff_t *o driver_data = spi_get_drvdata(spi_driver_data); if (driver_data == NULL) return -2; - if (driver_data->spi_driver == NULL) return -2; // Invalid private data + //if (driver_data->spi_driver == NULL) return -2; // Invalid private data if ((driver_data->first_probe_reply[0] == 0) && !(driver_data->probe_always_succeeds) ) return -3; // Device not present mutex_lock(&(private_data->lock)); @@ -361,8 +360,8 @@ ssize_t neuronspi_read (struct file *file_p, char *buffer, size_t len, loff_t *o mutex_unlock(&(private_data->lock)); return -10; } - unipi_spi_trace(KERN_INFO "UNIPISPI: CDEV Read %d, DEV:%s%d DRV:%s%d msglen=%d offset=%d\n", len, (spi_driver_data->dev.of_node->name), - (spi_driver_data->chip_select), (driver_data->spi_driver->driver.name), (private_data->device_index),private_data->message_len, (int)*offset); + unipi_spi_trace(KERN_INFO "UNIPISPI: CDEV Read %d, DEV:%s%d DRV:%d msglen=%d offset=%d\n", len, (spi_driver_data->dev.of_node->name), + (spi_driver_data->chip_select), (private_data->device_index),private_data->message_len, (int)*offset); if (private_data->has_first_message & UNIPISPI_OP_MODE_SEND_HEADER) { result = simple_read_from_buffer(buffer, len, &dummy_offset, private_data->recv_buf.first_message, NEURONSPI_FIRST_MESSAGE_LENGTH); @@ -435,7 +434,7 @@ ssize_t neuronspi_write (struct file *file_p, const char *buffer, size_t len, lo driver_data = spi_get_drvdata(spi_driver_data); if (driver_data == NULL) return -2; - if (driver_data->spi_driver == NULL) return -2; // Invalid private data + //if (driver_data->spi_driver == NULL) return -2; // Invalid private data if ((driver_data->first_probe_reply[0] == 0) && !(driver_data->probe_always_succeeds) ) return -3; // Device not present @@ -763,164 +762,23 @@ int unipispi_modbus_write_coil(struct spi_device* spi_dev, u16 coil, int value) void neuronspi_spi_set_irqs(struct spi_device* spi_dev, u16 to) { unipispi_modbus_write_register(spi_dev, 1007, to); - unipi_spi_trace(KERN_INFO "UNIPISPI: SPI IRQ Set, Dev-CS:%d, to:%d\n", spi_dev->chip_select, to); + unipi_spi_trace(KERN_INFO "UNIPISPI: SPI IRQ Set, CS%d, to:0x%x\n", spi_dev->chip_select, to); } - -/* -int neuronspi_spi_send_message(struct spi_device* spi_dev, u8 *send_buf, u8 *recv_buf, s32 len, s32 freq, s32 delay, s32 send_header, u8 lock_val) -{ - s32 i = 0; - int ret_code = 0; - u16 recv_crc1 = 0; - u16 recv_crc2 = 0; - u16 packet_crc = 0; - s32 trans_count = (len<=0) ? 2 : ((len-1) / NEURONSPI_MAX_TX) + 3; // number of transmissions - //struct spi_message *s_msg; - struct neuronspi_driver_data *d_data; - struct spi_transfer* s_trans; - mutex_lock(&neuronspi_master_mutex); - //if ((len % NEURONSPI_MAX_TX) == 0) trans_count--; - d_data = spi_get_drvdata(spi_dev); - if (d_data != NULL && d_data->reserved_device && lock_val != d_data->reserved_device) { - memset(&recv_buf, 0, len); - } else { - s_trans = kzalloc(sizeof(struct spi_transfer) * trans_count, GFP_ATOMIC); - unipi_spi_trace_1(KERN_INFO "UNIPISPI: SPI Master Write, len:%d,\n %100ph\n", len, send_buf); - - if (!send_header) { - trans_count -= 1; // one less transmission as the header is omitted - } - //s_msg = kmalloc(sizeof(struct spi_message), GFP_ATOMIC); - //spi_message_init(s_msg); - for (i = 0; i < trans_count; i++) { - memset(&(s_trans[i]), 0, sizeof(s_trans[i])); - s_trans[i].delay_usecs = 0; - s_trans[i].bits_per_word = 8; - s_trans[i].speed_hz = freq; - if (i == 0) { - s_trans[i].delay_usecs = NEURONSPI_EDGE_DELAY; - } else if (i == 1) { - s_trans[i].tx_buf = send_buf; - s_trans[i].rx_buf = recv_buf; - if (send_header) { - s_trans[i].delay_usecs = delay; - s_trans[i].len = NEURONSPI_FIRST_MESSAGE_LENGTH; - } else { - // If len is more than NEURONSPI_MAX_TX * i, then chunk len is NEURONSPI_MAX_TX, otherwise it's the remainder - s_trans[i].len = (len - (NEURONSPI_MAX_TX * i)) > 0 ? NEURONSPI_MAX_TX : len; - } - } else if (i == trans_count - 1) { - if (send_header) { - s_trans[i].tx_buf = &(send_buf[NEURONSPI_FIRST_MESSAGE_LENGTH + (NEURONSPI_MAX_TX * (i - 2))]); - s_trans[i].rx_buf = &(recv_buf[NEURONSPI_FIRST_MESSAGE_LENGTH + (NEURONSPI_MAX_TX * (i - 2))]); - s_trans[i].len = (len - (NEURONSPI_MAX_TX * (i - 2))); - //s_trans[i].len = ((NEURONSPI_MAX_TX * (i - 1)) - len) < 0 ? NEURONSPI_MAX_TX : (len - (NEURONSPI_MAX_TX * (i - 2))); - } else { - s_trans[i].tx_buf = &(send_buf[NEURONSPI_MAX_TX * (i - 1)]); - s_trans[i].rx_buf = &(recv_buf[NEURONSPI_MAX_TX * (i - 1)]); - s_trans[i].len = ((NEURONSPI_MAX_TX * i) - len) < 0 ? NEURONSPI_MAX_TX : (len - (NEURONSPI_MAX_TX * (i - 1))); - } - s_trans[i].delay_usecs = NEURONSPI_LAST_TRANSFER_DELAY; - // If len is more than NEURONSPI_MAX_TX * i (+ optionally header), then chunk len is NEURONSPI_MAX_TX (+ optionally header), - // otherwise it's the remainder - } else { - if (send_header) { - s_trans[i].tx_buf = &(send_buf[NEURONSPI_FIRST_MESSAGE_LENGTH + (NEURONSPI_MAX_TX * (i - 2))]); - s_trans[i].rx_buf = &(recv_buf[NEURONSPI_FIRST_MESSAGE_LENGTH + (NEURONSPI_MAX_TX * (i - 2))]); - s_trans[i].len = NEURONSPI_MAX_TX; - //s_trans[i].len = ((NEURONSPI_MAX_TX * (i - 1)) - len) < 0 ? NEURONSPI_MAX_TX : (len - (NEURONSPI_MAX_TX * (i - 2))); - } else { - s_trans[i].tx_buf = &(send_buf[NEURONSPI_MAX_TX * (i - 1)]); - s_trans[i].rx_buf = &(recv_buf[NEURONSPI_MAX_TX * (i - 1)]); - s_trans[i].len = ((NEURONSPI_MAX_TX * i) - len) < 0 ? NEURONSPI_MAX_TX : (len - (NEURONSPI_MAX_TX * (i - 1))); - } - // If len is more than NEURONSPI_MAX_TX * i (+ optionally header), then chunk len is NEURONSPI_MAX_TX (+ optionally header), - // otherwise it's the remainder - } - //spi_message_add_tail(&(s_trans[i]), s_msg); - } - //spi_sync(spi_dev, s_msg); - spi_sync_transfer(spi_dev, s_trans, trans_count); - //for (i = 0; i < trans_count; i++) { - // spi_transfer_del(&(s_trans[i])); - //} - kfree(s_trans); - //kfree(s_msg); - unipi_spi_trace_1(KERN_INFO "UNIPISPI: SPI Master Read - %d:\n\t%100ph\n\t%100ph\n\t%100ph\n\t%100ph\n", len,recv_buf, &recv_buf[64], - &recv_buf[128], &recv_buf[192]); - - } - if (d_data == NULL || (d_data != NULL && !d_data->reserved_device)) { - recv_crc1 = neuronspi_spi_crc(recv_buf, 4, 0); - memcpy(&packet_crc, &recv_buf[4], 2); - unipi_spi_trace_1(KERN_INFO "UNIPISPI: SPI CRC1: %x\t COMPUTED CRC1:%x\n", packet_crc, recv_crc1); - - if (recv_crc1 == packet_crc) { - // Signal the UART to issue character reads - unipi_spi_trace_1(KERN_INFO "UNIPISPI: SPI CRC1 Correct"); - - if (d_data && ((recv_buf[0] & 0xfd) == 0x41)) { - unipi_spi_trace(KERN_INFO "UNIPISPI: Reading UART data for device %d\n", d_data->neuron_index); - - if (recv_buf[0] == 0x41) { - d_data->uart_buf[0] = recv_buf[3]; - for (i = 0; i < d_data->uart_data->p_count; i++) { - if (d_data->uart_data->p[i].dev_index == d_data->neuron_index) { - neuronspi_uart_handle_rx(&d_data->uart_data->p[i], 1, 1); - } - } - } - if (!(d_data->uart_read) && (d_data->uart_count)) { - d_data->uart_read = recv_buf[2]; - for (i = 0; i < d_data->uart_data->p_count; i++) { - unipi_spi_trace(KERN_INFO "UNIPISPI: UART Buffer:%d, UART Local Port Count:%d, UART Global Port Count:%d\n", d_data->uart_read, - d_data->uart_count, d_data->uart_data->p_count); - - if (d_data->uart_data->p[i].dev_index == d_data->neuron_index && !d_data->reserved_device) { - kthread_queue_work(&d_data->uart_data->kworker, &d_data->uart_data->p[i].rx_work); - } - } - } - } - } else { - unipi_spi_trace(KERN_INFO "UNIPISPI: SPI CRC1 Not Correct"); - } - recv_crc2 = neuronspi_spi_crc(&recv_buf[6], len - 8, recv_crc1); - memcpy(&packet_crc, &recv_buf[len - 2], 2); - unipi_spi_trace_1(KERN_INFO "UNIPISPI: SPI CRC2: %x\t COMPUTED CRC2:%x\n", packet_crc, recv_crc2); - if (recv_crc2 != packet_crc) { - unipi_spi_trace(KERN_INFO "UNIPISPI: SPI CRC2 Not Correct"); - - recv_buf[0] = 0; - ret_code = 1; - } - } - mutex_unlock(&neuronspi_master_mutex); - return ret_code; -} -*/ - - irqreturn_t neuronspi_spi_irq(s32 irq, void *dev_id) { - s32 i; - struct spi_device *spi; - struct neuronspi_driver_data *d_data; - //struct neuronspi_uart_data *u_data; - spi = (struct spi_device *)dev_id; - d_data = spi_get_drvdata(spi); + struct spi_device *spi = (struct spi_device *)dev_id; + struct neuronspi_driver_data *d_data = spi_get_drvdata(spi); + struct neuronspi_port *port; + unipi_spi_trace(KERN_INFO "UNIPISPI: SPI IRQ\n"); if (d_data->uart_count) { - for (i = 0; i < neuronspi_uart_data_global->p_count; i++) { - if (neuronspi_uart_data_global->p[i].dev_index == d_data->neuron_index) { - kthread_queue_work(&neuronspi_uart_data_global->kworker, &neuronspi_uart_data_global->p[i].irq_work); - } - + // it is enough to call one port of spi board + port = neuronspi_uart_data_global->p + d_data->uart_pindex; + kthread_queue_work(&neuronspi_uart_data_global->kworker, &port->irq_work); } - } return IRQ_HANDLED; } @@ -959,14 +817,8 @@ s32 neuronspi_spi_probe(struct spi_device *spi) n_spi->neuron_index = spi->chip_select - 1; n_spi->reserved_device = 0; - if (neuron_plc_dev == NULL) { - neuron_plc_dev = platform_device_alloc("unipi_plc", -1); - neuron_plc_dev->dev.groups = neuron_plc_attr_groups; - platform_device_add(neuron_plc_dev); - } - - unipi_spi_trace(KERN_DEBUG "UNIPISPI: CS: %d, Chip Max Hz-%d %d\n", spi->chip_select, spi->master->max_speed_hz, spi->max_speed_hz); + unipi_spi_trace(KERN_DEBUG "UNIPISPI: CS%d, Chip Max Hz-%d %d\n", spi->chip_select, spi->master->max_speed_hz, spi->max_speed_hz); if (spi->dev.of_node) { const struct of_device_id *of_id = of_match_device(neuronspi_id_match, &spi->dev); @@ -985,12 +837,13 @@ s32 neuronspi_spi_probe(struct spi_device *spi) devtype = (struct neuronspi_devtype *)id_entry->driver_data; } - + // Prepare worker for interrupt, LEDs, kthread_init_worker(&n_spi->primary_worker); n_spi->primary_worker_task = kthread_run(kthread_worker_fn, &n_spi->primary_worker, "neuronspi"); if (IS_ERR(n_spi->primary_worker_task )) { ret = PTR_ERR(n_spi->primary_worker_task); + kfree(n_spi); return ret; } sched_setscheduler(n_spi->primary_worker_task, SCHED_FIFO, &neuronspi_sched_param); @@ -998,7 +851,6 @@ s32 neuronspi_spi_probe(struct spi_device *spi) // We perform an initial probe of registers 1000-1004 to identify the device, using a premade message n_spi->first_probe_reply = kzalloc(UNIPISPI_PROBE_MESSAGE_LEN, GFP_ATOMIC); // allocate space for initial probe n_spi->lower_board_id = n_spi->upper_board_id = n_spi->combination_id = 0xFF; - n_spi->spi_driver = &neuronspi_spi_driver; neuronspi_spi_send_const_op(spi, &UNIPISPI_IDLE_MESSAGE, &recv_op, 0, NEURONSPI_DEFAULT_FREQ, 25); // Throw away the first message - the associated SPI Master is sometimes not properly initialised at this point @@ -1026,17 +878,19 @@ s32 neuronspi_spi_probe(struct spi_device *spi) } } } + } else if (!n_spi->probe_always_succeeds) { ret = -ENODEV; kfree(n_spi); - printk(KERN_INFO "UNIPISPI: Probe did not detect a valid UniPi device on CS %d\n", spi->chip_select); + printk(KERN_INFO "UNIPISPI: Probe did not detect a valid UniPi device at CS%d\n", spi->chip_select); return ret; + } else if (n_spi->always_create_uart) { uart_count = 1; } 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 = kzalloc(sizeof(struct neuronspi_board_features), GFP_ATOMIC); n_spi->features = &(NEURONSPI_BOARDTABLE[n_spi->combination_id].definition->features); } else { n_spi->features = NULL; @@ -1045,28 +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])) { - //n_spi->slower_model = 1; 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) Index: %d Fw: v%d.%d on CS %d, \ -Uart count: %d - reg1000: %x, reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\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->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]); + 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 on CS %d, Uart count: %d - reg1000: %x, \ + 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]); } 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, \ + 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], @@ -1074,10 +924,11 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", n_spi->first_probe_reply[19-6] << 8 | n_spi->first_probe_reply[18-6]); } if (n_spi->combination_id != 0xFF) { - printk(KERN_INFO "UNIPISPI: UniPi device %s on CS %d uses SPI communication freq. %d Hz\n", + printk(KERN_INFO "UNIPISPI: UniPi device %s at CS%d uses SPI communication freq. %d Hz\n", NEURONSPI_BOARDTABLE[n_spi->combination_id].definition->combination_name, spi->chip_select, n_spi->ideal_frequency); } + n_spi->reg_map = regmap_init(&(spi->dev), &neuronspi_regmap_bus, spi, &neuronspi_regmap_config_default); spin_lock_init(&n_spi->sysfs_regmap_lock); if (n_spi->features) { @@ -1087,26 +938,12 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", n_spi->regstart_table = NULL; } - - // Check for user-configurable LED devices - if (n_spi->features && n_spi->features->led_count > 0) { - printk(KERN_INFO "UNIPISPI: LED model %s with %d LEDs detected at CS: %d\n", - NEURONSPI_BOARDTABLE[n_spi->combination_id].definition->combination_name, - n_spi->features->led_count, spi->chip_select); - n_spi->led_driver = kzalloc(sizeof(struct neuronspi_led_driver) * n_spi->features->led_count, GFP_ATOMIC); - for (i = 0; i < n_spi->features->led_count; i++) { - kthread_init_work(&(n_spi->led_driver[i].led_work), neuronspi_led_proc); - } - } - - n_spi->char_driver = &neuronspi_cdrv; - - + //n_spi->char_driver = &neuronspi_cdrv; spin_lock_irqsave(neuronspi_probe_spinlock, flags); + neuronspi_s_dev[n_spi->neuron_index] = spi; spi_set_drvdata(spi, n_spi); - - //spi_set_drvdata(neuronspi_s_dev[n_spi->neuron_index], n_spi); + if (neuronspi_probe_count == NEURONSPI_MAX_DEVS) { neuronspi_model_id = neuronspi_find_model_id(neuronspi_probe_count); } @@ -1115,8 +952,17 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", printk(KERN_INFO "UNIPISPI: Detected UniPi board combination corresponding to %s\n", NEURONSPI_MODELTABLE[neuronspi_model_id].model_name); } - unipi_spi_trace(KERN_DEBUG "UNIPISPI: SPI IRQ: %d", spi->irq); - strcpy(n_spi->platform_name, "io_group0"); + /* Platform LED, GPIO, IIO sysfs subsystem init */ + if (neuron_plc_dev == NULL) { + // global platform root + neuron_plc_dev = platform_device_alloc("unipi_plc", -1); + neuron_plc_dev->dev.groups = neuron_plc_attr_groups; + platform_device_add(neuron_plc_dev); + } + + 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); @@ -1125,118 +971,23 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", } 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 (!(neuronspi_cdrv.major_number)) { // Register character device if it doesn't exist - ret = char_register_driver(); - if (ret) { - printk(KERN_ERR "UNIPISPI: Failed to register the neuronspi character driver, ERR:%d\n", ret); - } - } + platform_set_drvdata(n_spi->board_device, n_spi);*/ if (n_spi->features) { if (n_spi->features->led_count) { - for (i = 0; i < n_spi->features->led_count; i++) { - strcpy(n_spi->led_driver[i].name, "unipi:green:uled-x1"); - if (i < 9) { - n_spi->led_driver[i].name[18] = i + '1'; - } else { - n_spi->led_driver[i].name[18] = i - 9 + 'a'; - } - // Initialise the rest of the structure - n_spi->led_driver[i].id = i; - n_spi->led_driver[i].brightness = LED_OFF; - n_spi->led_driver[i].spi = spi; - spin_lock_init(&n_spi->led_driver[i].lock); - n_spi->led_driver[i].ldev.name = n_spi->led_driver[i].name; - n_spi->led_driver[i].ldev.brightness = n_spi->led_driver[i].brightness; - n_spi->led_driver[i].ldev.brightness_set = neuronspi_led_set_brightness; - led_classdev_register(&(n_spi->board_device->dev), &(n_spi->led_driver[i].ldev)); - } + printk(KERN_INFO "UNIPISPI: LED: %d User leds detected at CS%d\n", n_spi->features->led_count, spi->chip_select); + n_spi->led_driver = neuronspi_led_probe(n_spi->features->led_count, n_spi->neuron_index, n_spi->board_device); } #ifdef CONFIG_GPIOLIB if (n_spi->features->di_count) { - n_spi->di_driver = kzalloc(sizeof(struct neuronspi_di_driver*) * n_spi->features->di_count, GFP_ATOMIC); - for (i = 0; i < n_spi->features->di_count; i++) { - n_spi->di_driver[i] = kzalloc(sizeof(struct neuronspi_di_driver), GFP_ATOMIC); - strcpy(n_spi->di_driver[i]->name, "di_0_00"); - n_spi->di_driver[i]->name[3] = n_spi->neuron_index + '1'; - n_spi->di_driver[i]->name[5] = ((i + 1) / 10) + '0'; - n_spi->di_driver[i]->name[6] = ((i + 1) % 10) + '0'; - n_spi->di_driver[i]->di_index = i; - n_spi->di_driver[i]->spi = spi; - n_spi->di_driver[i]->plat_dev = platform_device_alloc(n_spi->di_driver[i]->name, -1); - n_spi->di_driver[i]->plat_dev->dev.parent = &(n_spi->board_device->dev); - n_spi->di_driver[i]->plat_dev->dev.groups = neuron_gpio_di_attr_groups; - n_spi->di_driver[i]->plat_dev->dev.driver = &neuronspi_spi_driver.driver; - platform_device_add(n_spi->di_driver[i]->plat_dev); - platform_set_drvdata(n_spi->di_driver[i]->plat_dev, n_spi->di_driver[i]); - n_spi->di_driver[i]->gpio_c.owner = THIS_MODULE; - n_spi->di_driver[i]->gpio_c.parent = &(n_spi->di_driver[i]->plat_dev->dev); - n_spi->di_driver[i]->gpio_c.label = "neuron_di"; - n_spi->di_driver[i]->gpio_c.can_sleep = 1; - n_spi->di_driver[i]->gpio_c.ngpio = 1; - n_spi->di_driver[i]->gpio_c.base = -1; - n_spi->di_driver[i]->gpio_c.direction_input = neuronspi_gpio_di_direction_input; - n_spi->di_driver[i]->gpio_c.get = neuronspi_gpio_di_get; - gpiochip_add_data(&n_spi->di_driver[i]->gpio_c, n_spi->di_driver[i]); - } + n_spi->di_driver = neuronspi_di_probe(n_spi->features->di_count, n_spi->neuron_index, n_spi->board_device); } - if (n_spi->features->do_count) { - n_spi->do_driver = kzalloc(sizeof(struct neuronspi_do_driver*) * n_spi->features->do_count, GFP_ATOMIC); - for (i = 0; i < n_spi->features->do_count; i++) { - n_spi->do_driver[i] = kzalloc(sizeof(struct neuronspi_do_driver), GFP_ATOMIC); - strcpy(n_spi->do_driver[i]->name, "do_0_00"); - n_spi->do_driver[i]->name[3] = n_spi->neuron_index + '1'; - n_spi->do_driver[i]->name[5] = ((i + 1) / 10) + '0'; - n_spi->do_driver[i]->name[6] = ((i + 1) % 10) + '0'; - n_spi->do_driver[i]->do_index = i; - n_spi->do_driver[i]->spi = spi; - n_spi->do_driver[i]->plat_dev = platform_device_alloc(n_spi->do_driver[i]->name, -1); - n_spi->do_driver[i]->plat_dev->dev.parent = &(n_spi->board_device->dev); - n_spi->do_driver[i]->plat_dev->dev.groups = neuron_gpio_do_attr_groups; - n_spi->do_driver[i]->plat_dev->dev.driver = &neuronspi_spi_driver.driver; - platform_device_add(n_spi->do_driver[i]->plat_dev); - platform_set_drvdata(n_spi->do_driver[i]->plat_dev, n_spi->do_driver[i]); - n_spi->do_driver[i]->gpio_c.owner = THIS_MODULE; - n_spi->do_driver[i]->gpio_c.parent = &(n_spi->do_driver[i]->plat_dev->dev); - n_spi->do_driver[i]->gpio_c.label = "neuron_do"; - n_spi->do_driver[i]->gpio_c.can_sleep = 1; - n_spi->do_driver[i]->gpio_c.ngpio = 1; - n_spi->do_driver[i]->gpio_c.base = -1; - n_spi->do_driver[i]->gpio_c.direction_output = neuronspi_gpio_do_direction_output; - n_spi->do_driver[i]->gpio_c.set = neuronspi_gpio_do_set; - gpiochip_add_data(&n_spi->do_driver[i]->gpio_c, n_spi->do_driver[i]); - } + n_spi->do_driver = neuronspi_do_probe(n_spi->features->do_count, n_spi->neuron_index, n_spi->board_device); } if (n_spi->features->ro_count) { - n_spi->ro_driver = kzalloc(sizeof(struct neuronspi_ro_driver*) * n_spi->features->ro_count, GFP_ATOMIC); - for (i = 0; i < n_spi->features->ro_count; i++) { - n_spi->ro_driver[i] = kzalloc(sizeof(struct neuronspi_ro_driver), GFP_ATOMIC); - strcpy(n_spi->ro_driver[i]->name, "ro_0_00"); - n_spi->ro_driver[i]->name[3] = n_spi->neuron_index + '1'; - n_spi->ro_driver[i]->name[5] = ((i + 1) / 10) + '0'; - n_spi->ro_driver[i]->name[6] = ((i + 1) % 10) + '0'; - n_spi->ro_driver[i]->ro_index = i; - n_spi->ro_driver[i]->spi = spi; - n_spi->ro_driver[i]->plat_dev = platform_device_alloc(n_spi->ro_driver[i]->name, -1); - n_spi->ro_driver[i]->plat_dev->dev.parent = &(n_spi->board_device->dev); - n_spi->ro_driver[i]->plat_dev->dev.groups = neuron_gpio_ro_attr_groups; - n_spi->ro_driver[i]->plat_dev->dev.driver = &neuronspi_spi_driver.driver; - platform_device_add(n_spi->ro_driver[i]->plat_dev); - platform_set_drvdata(n_spi->ro_driver[i]->plat_dev, n_spi->ro_driver[i]); - n_spi->ro_driver[i]->gpio_c.owner = THIS_MODULE; - n_spi->ro_driver[i]->gpio_c.parent = &(n_spi->ro_driver[i]->plat_dev->dev); - n_spi->ro_driver[i]->gpio_c.label = "neuron_ro"; - n_spi->ro_driver[i]->gpio_c.can_sleep = 1; - n_spi->ro_driver[i]->gpio_c.ngpio = 1; - n_spi->ro_driver[i]->gpio_c.base = -1; - n_spi->ro_driver[i]->gpio_c.direction_output = neuronspi_gpio_ro_direction_output; - n_spi->ro_driver[i]->gpio_c.set = neuronspi_gpio_ro_set; - gpiochip_add_data(&n_spi->ro_driver[i]->gpio_c, n_spi->ro_driver[i]); - } + n_spi->ro_driver = neuronspi_ro_probe(n_spi->features->ro_count, n_spi->neuron_index, n_spi->board_device); } #endif if (n_spi->features->stm_ai_count) { @@ -1305,16 +1056,13 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", n_spi->uart_count_to_probe = uart_count; if (uart_count) { - //n_spi->uart_buf = kzalloc(NEURONSPI_FIFO_SIZE, GFP_ATOMIC); if (neuronspi_uart_driver_global != NULL) { - // Normalne se registrace portu udela az po inicializaci unipispi driveru. (Na konci __init__) - // Opravit proceduru probe !!! + // Normally is port registration done after unipispi driver probe. (in the end of __init__) unipi_spi_trace(KERN_DEBUG "UNIPISPI: UART registration\n"); - neuronspi_uart_probe(spi, n_spi); - //n_spi->uart_count = uart_count; + } else { - unipi_spi_trace(KERN_DEBUG "UNIPISPI: Neuronspi uart driver not registered yet. Uart port add later.\n"); + unipi_spi_trace(KERN_DEBUG "UNIPISPI: Uart driver not registered yet. Uart port add later.\n"); } } @@ -1322,6 +1070,7 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", for (i = 0; i < NEURONSPI_NO_INTERRUPT_MODELS_LEN; i++) { if (NEURONSPI_NO_INTERRUPT_MODELS[i] == (n_spi->first_probe_reply[17-6] << 8 | n_spi->first_probe_reply[16-6])) { no_irq = 1; + break; } } @@ -1329,7 +1078,7 @@ reg1001: %x, reg1002: %x, reg1003: %x, reg1004: %x\n", if (!no_irq) { n_spi->no_irq = 0; ret = devm_request_irq(&(spi->dev), spi->irq, neuronspi_spi_irq, 0x81, dev_name(&(spi->dev)), spi); - unipi_spi_trace(KERN_DEBUG "UNIPISPI: IRQ registration, ret:%d\n", ret); + unipi_spi_trace(KERN_DEBUG "UNIPISPI: SPI IRQ %d registration: ret=%d\n", spi->irq, ret); } else { n_spi->no_irq = 1; unipi_spi_trace(KERN_DEBUG "UNIPISPI: NO IRQ ON THIS MODEL !!\n"); @@ -1354,28 +1103,25 @@ s32 neuronspi_spi_remove(struct spi_device *spi) 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[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[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[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); } @@ -1401,10 +1147,6 @@ s32 neuronspi_spi_remove(struct spi_device *spi) n_spi->sec_ao_driver = NULL; } printk(KERN_INFO "UNIPISPI: IIO DRIVER UNREGISTERED\n"); - //if (n_spi->uart_buf) { - // kfree(n_spi->uart_buf); - // n_spi->uart_buf = NULL; - //} printk(KERN_INFO "UNIPISPI: SPI/UART DRIVER UNREGISTERED\n"); if (n_spi->board_device) { platform_set_drvdata(n_spi->board_device, 0); @@ -1471,15 +1213,15 @@ static s32 __init neuronspi_init(void) { s32 ret = 0; - //neuronspi_uart_driver_init(); - neuronspi_probe_spinlock = kzalloc(sizeof(struct spinlock), GFP_ATOMIC); spin_lock_init(neuronspi_probe_spinlock); mutex_init(&neuronspi_master_mutex); mutex_init(&unipi_inv_speed_mutex); + // clear global neuron spi devices list memset(&neuronspi_s_dev, 0, sizeof(neuronspi_s_dev)); ret = spi_register_driver(&neuronspi_spi_driver); + if (ret < 0) { printk(KERN_ERR "UNIPISPI: Failed to init neuronspi spi --> %d\n", ret); return ret; @@ -1490,11 +1232,19 @@ static s32 __init neuronspi_init(void) printk(KERN_INFO "UNIPISPI: SPI Driver Registered\n"); #endif } + neuronspi_invalidate_thread = kthread_create(neuronspi_regmap_invalidate, NULL, "unipispi_inv"); if (neuronspi_invalidate_thread != NULL) { wake_up_process(neuronspi_invalidate_thread); } + if (!(neuronspi_cdrv.major_number)) { // Register character device if it doesn't exist + ret = char_register_driver(); + if (ret) { + printk(KERN_ERR "UNIPISPI: Failed to register the neuronspi character driver, ERR:%d\n", ret); + } + } + neuronspi_uart_driver_init(); neuronspi_uart_probe_all(); diff --git a/modules/unipi/src/unipi_spi.h b/modules/unipi/src/unipi_spi.h index a799247..5f1cb86 100644 --- a/modules/unipi/src/unipi_spi.h +++ b/modules/unipi/src/unipi_spi.h @@ -33,15 +33,6 @@ static const u16 NEURONSPI_SLOWER_MODELS[NEURONSPI_SLOWER_MODELS_LEN] = { 0xb10, 0xc10, 0xf10 }; -/* -#define NEURONSPI_PROBE_MESSAGE_LEN 22 -static const u8 NEURONSPI_PROBE_MESSAGE[NEURONSPI_PROBE_MESSAGE_LEN] = { - 0x04, 0x0e, 0xe8, 0x03, 0xa0, 0xdd, - 0x04, 0x00, 0xe8, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x12, 0x16 -}; -*/ #define UNIPISPI_PROBE_MESSAGE_LEN 16 static u8 _probe_message_second[UNIPISPI_PROBE_MESSAGE_LEN] = @@ -51,77 +42,12 @@ static const struct neuronspi_op_buffer UNIPISPI_PROBE_MESSAGE = { second_message: _probe_message_second, }; -/* -#define NEURONSPI_UART_PROBE_MESSAGE_LEN 6 -static const u8 NEURONSPI_UART_PROBE_MESSAGE[NEURONSPI_UART_PROBE_MESSAGE_LEN] = { - 0xfa, 0x00, 0x55, 0x0e, 0xb6, 0x0a -}; -*/ static const struct neuronspi_op_buffer UNIPISPI_IDLE_MESSAGE = { first_message: {0xfa, 0x00, 0x55, 0x0e, 0xb6, 0x0a}, second_message: NULL, }; -/* -#define NEURONSPI_SPI_UART_SHORT_MESSAGE_LEN 6 -static const u8 NEURONSPI_SPI_UART_SHORT_MESSAGE[NEURONSPI_SPI_UART_SHORT_MESSAGE_LEN] = { - 0x41, 0x00, 0x00, 0x00, 0x00, 0x00 -}; - -#define NEURONSPI_SPI_UART_LONG_MESSAGE_LEN 8 -static const u8 NEURONSPI_SPI_UART_LONG_MESSAGE[NEURONSPI_SPI_UART_LONG_MESSAGE_LEN] = { - 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00 -}; - -#define NEURONSPI_SPI_UART_READ_MESSAGE_LEN 14 -static const u8 NEURONSPI_SPI_UART_READ_MESSAGE[NEURONSPI_SPI_UART_READ_MESSAGE_LEN] = { - 0x65, 0x06, 0x00, 0x00, 0x44, 0x69, - 0x65, 0x03, 0x00, 0x00, 0x00, 0x05, - 0x6a, 0x0c -}; - -#define NEURONSPI_SPI_UART_READ_MESSAGE0_LEN 14 -static const u8 NEURONSPI_SPI_UART_READ_MESSAGE0[NEURONSPI_SPI_UART_READ_MESSAGE0_LEN] = { - 0x68, 0x06, 0x00, 0x00, 0x00, 0x00, - 0x65, 0x03, 0x00, 0x00, 0x00, 0x05, - 0x6a, 0x0c -}; - -#define NEURONSPI_SPI_IRQ_SET_MESSAGE_LEN 14 -static const u8 NEURONSPI_SPI_IRQ_SET_MESSAGE[NEURONSPI_SPI_IRQ_SET_MESSAGE_LEN] = { - 0x06, 0x06, 0xef, 0x03, 0x00, 0x00, - 0x06, 0x01, 0xef, 0x03, 0x05, 0x00, - 0x00, 0x00 -}; - -#define NEURONSPI_SPI_UART_GET_CFLAG_MESSAGE_LEN 16 -static const u8 NEURONSPI_SPI_UART_GET_CFLAG_MESSAGE[NEURONSPI_SPI_UART_GET_CFLAG_MESSAGE_LEN] = { - 0x04, 0x08, 0xf4, 0x01, 0x00, 0x00, - 0x04, 0x02, 0xf4, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00 -}; - -#define NEURONSPI_SPI_UART_GET_LDISC_MESSAGE_LEN 16 -static const u8 NEURONSPI_SPI_UART_GET_LDISC_MESSAGE[NEURONSPI_SPI_UART_GET_LDISC_MESSAGE_LEN] = { - 0x04, 0x08, 0xf6, 0x01, 0x00, 0x00, - 0x04, 0x02, 0xf6, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00 -}; - -#define NEURONSPI_SPI_UART_SET_CFLAG_MESSAGE_LEN 16 -static const u8 NEURONSPI_SPI_UART_SET_CFLAG_MESSAGE[NEURONSPI_SPI_UART_SET_CFLAG_MESSAGE_LEN] = { - 0x06, 0x08, 0xf4, 0x01, 0x00, 0x00, - 0x06, 0x02, 0xf4, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00 -}; - -#define NEURONSPI_SPI_LED_SET_MESSAGE_LEN 6 -static const u8 NEURONSPI_SPI_LED_SET_MESSAGE[NEURONSPI_SPI_LED_SET_MESSAGE_LEN] = { - 0x05, 0x00, 0x08, 0x00, 0x00, 0x00 -}; -*/ #define NEURONSPI_CRC16TABLE_LEN 256 static const u16 NEURONSPI_CRC16TABLE[NEURONSPI_CRC16TABLE_LEN] = { @@ -206,10 +132,7 @@ int neuronspi_spi_send_const_op(struct spi_device* spi_dev, const struct neurons int neuronspi_spi_send_op(struct spi_device* spi_dev, struct neuronspi_op_buffer* send_buf, struct neuronspi_op_buffer* recv_buf, s32 len, s32 freq, s32 delay, s32 send_header, u8 lock_val); -//int neuronspi_spi_send_message_crc(struct spi_device* spi_dev, struct neuronspi_op_buffer* send_buf, struct neuronspi_op_buffer* recv_buf, s32 len, s32 freq, s32 delay); -//int neuronspi_spi_send_message(struct spi_device *spi_dev, u8 *send_buf, u8 *recv_buf, s32 len, s32 freq, s32 delay, s32 send_header, u8 lock_val); s32 neuronspi_spi_uart_write(struct spi_device *spi, u8 *send_buf, int length, u8 uart_index); -//void neuronspi_spi_uart_read(struct spi_device* spi_dev, u8 *send_buf, u8 *recv_buf, s32 len, u8 uart_index); void neuronspi_spi_uart_read(struct spi_device* spi_dev, u8 *recv_buf, s32 len, u8 uart_index); int unipispi_modbus_read_register(struct spi_device* spi_dev, u16 reg, u16* value); int unipispi_modbus_read_u32(struct spi_device* spi_dev, u16 reg, u32* value); @@ -384,147 +307,5 @@ static __always_inline u16 neuronspi_spi_crc(u8* inputstring, s32 length, u16 in return result; } -/* -static __always_inline size_t neuronspi_spi_compose_single_coil_write(u16 start, u8 **buf_inp, u8 **buf_outp, u8 data) -{ - u16 crc1; - *buf_outp = kzalloc(6, GFP_ATOMIC); - *buf_inp = kzalloc(6, GFP_ATOMIC); - (*buf_inp)[0] = 0x05; - (*buf_inp)[1] = data; - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - return 6; -} - -static __always_inline size_t neuronspi_spi_compose_single_coil_read(u16 start, u8 **buf_inp, u8 **buf_outp) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(14, GFP_ATOMIC); - *buf_inp = kzalloc(14, GFP_ATOMIC); - (*buf_inp)[0] = 0x01; - (*buf_inp)[1] = 0x06; - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 6, crc1); - memcpy(&(*buf_inp)[12], &crc2, 2); - return 14; -} - -static __always_inline size_t neuronspi_spi_compose_multiple_coil_write(u8 number, u16 start, u8 **buf_inp, u8 **buf_outp, u8 *data) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(12 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number), GFP_ATOMIC); - *buf_inp = kzalloc(12 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number), GFP_ATOMIC); - (*buf_inp)[0] = 0x0F; - (*buf_inp)[1] = 4 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number); - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - (*buf_inp)[7] = number; - memcpy(&(*buf_inp)[10], data, NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number)); - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 4 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number), crc1); - memcpy(&(*buf_inp)[10 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number)], &crc2, 2); - return 12 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number); -} - -static __always_inline size_t neuronspi_spi_compose_multiple_coil_read(u8 number, u16 start, u8 **buf_inp, u8 **buf_outp) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(12 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number), GFP_ATOMIC); - *buf_inp = kzalloc(12 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number), GFP_ATOMIC); - (*buf_inp)[0] = 0x01; - (*buf_inp)[1] = 4 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number); - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 4 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number), crc1); - memcpy(&(*buf_inp)[10 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number)], &crc2, 2); - return 12 + NEURONSPI_GET_COIL_READ_PHASE2_BYTE_LENGTH(number); -} - -static __always_inline size_t neuronspi_spi_compose_single_register_write(u16 start, u8 **buf_inp, u8 **buf_outp, u16 data) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(14, GFP_ATOMIC); - *buf_inp = kzalloc(14, GFP_ATOMIC); - (*buf_inp)[0] = 0x06; - (*buf_inp)[1] = 0x06; - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - (*buf_inp)[7] = 0x01; - memcpy(&(*buf_inp)[10], &data, 2); - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 6, crc1); - memcpy(&(*buf_inp)[12], &crc2, 2); - return 14; -} - -static __always_inline size_t neuronspi_spi_compose_single_register_read(u16 start, u8 **buf_inp, u8 **buf_outp) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(14, GFP_ATOMIC); - *buf_inp = kzalloc(14, GFP_ATOMIC); - (*buf_inp)[0] = 0x03; - (*buf_inp)[1] = 0x06; - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - (*buf_inp)[7] = 0x01; - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 6, crc1); - memcpy(&(*buf_inp)[12], &crc2, 2); - return 14; -} - -static __always_inline size_t neuronspi_spi_compose_multiple_register_write(u8 number, u16 start, u8 **buf_inp, u8 **buf_outp, u8 *data) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(12 + (number * 2), GFP_ATOMIC); - *buf_inp = kzalloc(12 + (number * 2), GFP_ATOMIC); - (*buf_inp)[0] = 0x10; - (*buf_inp)[1] = 4 + (number * 2); - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - (*buf_inp)[7] = number; - memcpy(&(*buf_inp)[10], data, number * 2); - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 4 + (number * 2), crc1); - memcpy(&(*buf_inp)[10 + (number * 2)], &crc2, 2); - return 12 + (number * 2); -} - -static __always_inline size_t neuronspi_spi_compose_multiple_register_read(u8 number, u16 start, u8 **buf_inp, u8 **buf_outp) -{ - u16 crc1, crc2; - *buf_outp = kzalloc(12 + (number * 2), GFP_ATOMIC); - *buf_inp = kzalloc(12 + (number * 2), GFP_ATOMIC); - (*buf_inp)[0] = 0x03; - (*buf_inp)[1] = 4 + (number * 2); - (*buf_inp)[2] = start & 0xFF; - (*buf_inp)[3] = start >> 8; - crc1 = neuronspi_spi_crc(*buf_inp, 4, 0); - memcpy(&(*buf_inp)[4], &crc1, 2); - memcpy(&(*buf_inp)[6], *buf_inp, 4); - (*buf_inp)[7] = number; - crc2 = neuronspi_spi_crc(&(*buf_inp)[6], 4 + (number * 2), crc1); - memcpy(&(*buf_inp)[10 + (number * 2)], &crc2, 2); - return 12 + (number * 2); -} -*/ #endif /* MODULES_NEURON_SPI_SRC_UNIPI_SPI_H_ */ diff --git a/modules/unipi/src/unipi_sysfs.c b/modules/unipi/src/unipi_sysfs.c index 67b5fa2..3398b71 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_do_driver *n_do; + struct neuronspi_gpio_driver *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_do_driver *n_do; + struct neuronspi_gpio_driver *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_do_driver *n_do; + struct neuronspi_gpio_driver *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_do_driver *n_do; + struct neuronspi_gpio_driver *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -409,13 +409,13 @@ static ssize_t neuronspi_spi_gpio_show_pwm_cycle(struct device *dev, struct devi { ssize_t ret = 0; u32 val = 0; - struct neuronspi_do_driver *n_do; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->reg_map) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->do_pwm_reg + n_do->do_index, &val); + regmap_read(n_spi->reg_map, n_spi->regstart_table->do_pwm_reg + n_do->io_index, &val); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -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_do_driver *n_do; + struct neuronspi_gpio_driver *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -433,7 +433,7 @@ static ssize_t neuronspi_spi_gpio_store_pwm_cycle(struct device *dev, struct dev err = kstrtouint(buf, 0, &val); if (err < 0) goto err_end; if (n_spi && n_spi->combination_id != 0xFF && n_spi->reg_map) { - regmap_write(n_spi->reg_map, n_spi->regstart_table->do_pwm_reg + n_do->do_index, val); + regmap_write(n_spi->reg_map, n_spi->regstart_table->do_pwm_reg + n_do->io_index, val); } err_end: return count; @@ -444,14 +444,14 @@ 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_di_driver *n_di; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->reg_map) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + (2 * n_di->di_index), &val); - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + 1 + (2 * n_di->di_index), &val_upper); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + (2 * n_di->io_index), &val); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + 1 + (2 * n_di->io_index), &val_upper); val |= val_upper << 16; ret = scnprintf(buf, 255, "%d\n", val); } @@ -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_di_driver *n_di; + struct neuronspi_gpio_driver *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -470,8 +470,8 @@ static ssize_t neuronspi_spi_gpio_di_store_counter(struct device *dev, struct de err = kstrtouint(buf, 0, &val); if (err < 0) goto err_end; if (n_spi && n_spi->combination_id != 0xFF && n_spi->reg_map) { - regmap_write(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + (2 * n_di->di_index), val & 0xFFFF); - regmap_write(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + 1 + (2 * n_di->di_index), val >> 16); + regmap_write(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + (2 * n_di->io_index), val & 0xFFFF); + regmap_write(n_spi->reg_map, n_spi->regstart_table->di_counter_reg + 1 + (2 * n_di->io_index), val >> 16); } err_end: return count; @@ -481,13 +481,13 @@ static ssize_t neuronspi_spi_gpio_di_show_debounce(struct device *dev, struct de { ssize_t ret = 0; u32 val = 0; - struct neuronspi_di_driver *n_di; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->reg_map && n_spi->features && n_spi->features->di_count > n_di->di_index) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_deboun_reg + n_di->di_index, &val); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->reg_map && n_spi->features && n_spi->features->di_count > n_di->io_index) { + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_deboun_reg + n_di->io_index, &val); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -497,15 +497,15 @@ static ssize_t neuronspi_spi_gpio_di_store_debounce(struct device *dev, struct d { ssize_t err = 0; unsigned int val = 0; - struct neuronspi_di_driver *n_di; + struct neuronspi_gpio_driver *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); err = kstrtouint(buf, 0, &val); if (err < 0) goto err_end; - if (n_spi && n_spi->combination_id != 0xFF && n_spi->reg_map && n_spi->features && n_spi->features->di_count > n_di->di_index) { - regmap_write(n_spi->reg_map, n_spi->regstart_table->di_deboun_reg + n_di->di_index, val); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->reg_map && n_spi->features && n_spi->features->di_count > n_di->io_index) { + regmap_write(n_spi->reg_map, n_spi->regstart_table->di_deboun_reg + n_di->io_index, val); } err_end: return count; @@ -515,15 +515,15 @@ static ssize_t neuronspi_spi_gpio_di_show_value(struct device *dev, struct devic { ssize_t ret = 0; int val; - struct neuronspi_di_driver *n_di; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->di_count > n_di->di_index) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_val_reg + (n_di->di_index / 16), &val); - val &= 0x1 << (n_di->di_index % 15); - val = val >> (n_di->di_index % 15); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->di_count > n_di->io_index) { + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_val_reg + (n_di->io_index / 16), &val); + val &= 0x1 << (n_di->io_index % 15); + val = val >> (n_di->io_index % 15); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -533,15 +533,15 @@ static ssize_t neuronspi_spi_gpio_do_show_value(struct device *dev, struct devic { ssize_t ret = 0; int val; - struct neuronspi_do_driver *n_do; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->do_count > n_do->do_index) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->do_val_reg + (n_do->do_index / 16), &val); - val &= 0x1 << (n_do->do_index % 15); - val = val >> (n_do->do_index % 15); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->do_count > n_do->io_index) { + regmap_read(n_spi->reg_map, n_spi->regstart_table->do_val_reg + (n_do->io_index / 16), &val); + val &= 0x1 << (n_do->io_index % 15); + val = val >> (n_do->io_index % 15); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -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_do_driver *n_do; + struct neuronspi_gpio_driver *n_do; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_do = platform_get_drvdata(plat); @@ -562,11 +562,11 @@ static ssize_t neuronspi_spi_gpio_do_store_value(struct device *dev, struct devi if (inp > 1 || inp < 0) { goto err_end; } - if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->do_count > n_do->do_index) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->do_val_reg + (n_do->do_index / 16), &val); - val &= ~(0x1 << (n_do->do_index % 15)); - val |= inp << (n_do->do_index % 15); - regmap_write(n_spi->reg_map, n_spi->regstart_table->do_val_reg + (n_do->do_index / 16), val); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->do_count > n_do->io_index) { + regmap_read(n_spi->reg_map, n_spi->regstart_table->do_val_reg + (n_do->io_index / 16), &val); + val &= ~(0x1 << (n_do->io_index % 15)); + val |= inp << (n_do->io_index % 15); + regmap_write(n_spi->reg_map, n_spi->regstart_table->do_val_reg + (n_do->io_index / 16), val); } err_end: return count; @@ -576,15 +576,15 @@ static ssize_t neuronspi_spi_gpio_ro_show_value(struct device *dev, struct devic { ssize_t ret = 0; int val; - struct neuronspi_ro_driver *n_ro; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ro_count > n_ro->ro_index) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->ro_val_reg + (n_ro->ro_index / 16), &val); - val &= 0x1 << (n_ro->ro_index % 15); - val = val >> (n_ro->ro_index % 15); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ro_count > n_ro->io_index) { + regmap_read(n_spi->reg_map, n_spi->regstart_table->ro_val_reg + (n_ro->io_index / 16), &val); + val &= 0x1 << (n_ro->io_index % 15); + val = val >> (n_ro->io_index % 15); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -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_ro_driver *n_ro; + struct neuronspi_gpio_driver *n_ro; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_ro = platform_get_drvdata(plat); @@ -605,11 +605,11 @@ static ssize_t neuronspi_spi_gpio_ro_store_value(struct device *dev, struct devi if (inp > 1 || inp < 0) { goto err_end; } - if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ro_count > n_ro->ro_index) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->ro_val_reg + (n_ro->ro_index / 16), &val); - val &= ~(0x1 << (n_ro->ro_index % 15)); - val |= inp << (n_ro->ro_index % 15); - regmap_write(n_spi->reg_map, n_spi->regstart_table->ro_val_reg + (n_ro->ro_index / 16), val); + if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ro_count > n_ro->io_index) { + regmap_read(n_spi->reg_map, n_spi->regstart_table->ro_val_reg + (n_ro->io_index / 16), &val); + val &= ~(0x1 << (n_ro->io_index % 15)); + val |= inp << (n_ro->io_index % 15); + regmap_write(n_spi->reg_map, n_spi->regstart_table->ro_val_reg + (n_ro->io_index / 16), val); } err_end: return count; @@ -620,15 +620,15 @@ static ssize_t neuronspi_spi_gpio_show_ds_enable(struct device *dev, struct devi { ssize_t ret = 0; int val; - struct neuronspi_di_driver *n_di; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ds_count) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_direct_reg + (n_di->di_index / 16), &val); - val &= 0x1 << (n_di->di_index % 15); - val = val >> (n_di->di_index % 15); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_direct_reg + (n_di->io_index / 16), &val); + val &= 0x1 << (n_di->io_index % 15); + val = val >> (n_di->io_index % 15); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -638,15 +638,15 @@ static ssize_t neuronspi_spi_gpio_show_ds_toggle(struct device *dev, struct devi { ssize_t ret = 0; int val; - struct neuronspi_di_driver *n_di; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ds_count) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_toggle_reg + (n_di->di_index / 16), &val); - val &= 0x1 << (n_di->di_index % 15); - val = val >> (n_di->di_index % 15); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_toggle_reg + (n_di->io_index / 16), &val); + val &= 0x1 << (n_di->io_index % 15); + val = val >> (n_di->io_index % 15); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -656,15 +656,15 @@ static ssize_t neuronspi_spi_gpio_show_ds_polarity(struct device *dev, struct de { ssize_t ret = 0; int val; - struct neuronspi_di_driver *n_di; + struct neuronspi_gpio_driver *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 && n_spi->combination_id != -1 && n_spi->features && n_spi->features->ds_count) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_polar_reg + (n_di->di_index / 16), &val); - val &= 0x1 << (n_di->di_index % 15); - val = val >> (n_di->di_index % 15); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_polar_reg + (n_di->io_index / 16), &val); + val &= 0x1 << (n_di->io_index % 15); + val = val >> (n_di->io_index % 15); ret = scnprintf(buf, 255, "%d\n", val); } return ret; @@ -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_di_driver *n_di; + struct neuronspi_gpio_driver *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -686,10 +686,10 @@ static ssize_t neuronspi_spi_gpio_store_ds_enable(struct device *dev, struct dev goto err_end; } if (n_spi && n_spi->combination_id != -1 && n_spi->features && n_spi->features->ds_count) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_direct_reg + (n_di->di_index / 16), &val); - val &= ~(0x1 << (n_di->di_index % 15)); - val |= inp << (n_di->di_index % 15); - regmap_write(n_spi->reg_map, n_spi->regstart_table->di_direct_reg + (n_di->di_index / 16), val); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_direct_reg + (n_di->io_index / 16), &val); + val &= ~(0x1 << (n_di->io_index % 15)); + val |= inp << (n_di->io_index % 15); + regmap_write(n_spi->reg_map, n_spi->regstart_table->di_direct_reg + (n_di->io_index / 16), val); } err_end: return count; @@ -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_di_driver *n_di; + struct neuronspi_gpio_driver *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -711,10 +711,10 @@ static ssize_t neuronspi_spi_gpio_store_ds_toggle(struct device *dev, struct dev goto err_end; } if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ds_count) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_toggle_reg + (n_di->di_index / 16), &val); - val &= ~(0x1 << (n_di->di_index % 15)); - val |= inp << (n_di->di_index % 15); - regmap_write(n_spi->reg_map, n_spi->regstart_table->di_toggle_reg + (n_di->di_index / 16), val); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_toggle_reg + (n_di->io_index / 16), &val); + val &= ~(0x1 << (n_di->io_index % 15)); + val |= inp << (n_di->io_index % 15); + regmap_write(n_spi->reg_map, n_spi->regstart_table->di_toggle_reg + (n_di->io_index / 16), val); } err_end: return count; @@ -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_di_driver *n_di; + struct neuronspi_gpio_driver *n_di; struct neuronspi_driver_data *n_spi; struct platform_device *plat = to_platform_device(dev); n_di = platform_get_drvdata(plat); @@ -736,10 +736,10 @@ static ssize_t neuronspi_spi_gpio_store_ds_polarity(struct device *dev, struct d goto err_end; } if (n_spi && n_spi->combination_id != 0xFF && n_spi->features && n_spi->features->ds_count) { - regmap_read(n_spi->reg_map, n_spi->regstart_table->di_polar_reg + (n_di->di_index / 16), &val); - val &= ~(0x1 << (n_di->di_index % 15)); - val |= inp << (n_di->di_index % 15); - regmap_write(n_spi->reg_map, n_spi->regstart_table->di_polar_reg + (n_di->di_index / 16), val); + regmap_read(n_spi->reg_map, n_spi->regstart_table->di_polar_reg + (n_di->io_index / 16), &val); + val &= ~(0x1 << (n_di->io_index % 15)); + val |= inp << (n_di->io_index % 15); + regmap_write(n_spi->reg_map, n_spi->regstart_table->di_polar_reg + (n_di->io_index / 16), val); } err_end: return count; @@ -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_do_driver *n_do; + struct neuronspi_gpio_driver *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->do_index]->gpio_c.label, n_spi->neuron_index + 1); + ret = scnprintf(buf, 255, "%s_%d\n", n_spi->do_driver[n_do->io_index].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_di_driver *n_di; + struct neuronspi_gpio_driver *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->di_index]->gpio_c.label, n_spi->neuron_index + 1); + ret = scnprintf(buf, 255, "%s_%d\n", n_spi->di_driver[n_di->io_index].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_ro_driver *n_ro; + struct neuronspi_gpio_driver *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->ro_index]->gpio_c.label, n_spi->neuron_index + 1); + ret = scnprintf(buf, 255, "%s_%d\n", n_spi->ro_driver[n_ro->io_index].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_do_driver *n_do; + struct neuronspi_gpio_driver *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->do_index]->gpio_c.base); + ret = scnprintf(buf, 255, "%d\n", n_spi->do_driver[n_do->io_index].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_di_driver *n_di; + struct neuronspi_gpio_driver *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->di_index]->gpio_c.base); + ret = scnprintf(buf, 255, "%d\n", n_spi->di_driver[n_di->io_index].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_ro_driver *n_ro; + struct neuronspi_gpio_driver *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->ro_index]->gpio_c.base); + ret = scnprintf(buf, 255, "%d\n", n_spi->ro_driver[n_ro->io_index].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_do_driver *n_do; + struct neuronspi_gpio_driver *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->do_index]->gpio_c.ngpio); + ret = scnprintf(buf, 255, "%d\n", n_spi->do_driver[n_do->io_index].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_di_driver *n_di; + struct neuronspi_gpio_driver *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->di_index]->gpio_c.ngpio); + ret = scnprintf(buf, 255, "%d\n", n_spi->di_driver[n_di->io_index].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_ro_driver *n_ro; + struct neuronspi_gpio_driver *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->ro_index]->gpio_c.ngpio); + ret = scnprintf(buf, 255, "%d\n", n_spi->ro_driver[n_ro->io_index].gpio_c.ngpio); } return ret; } diff --git a/modules/unipi/src/unipi_uart.c b/modules/unipi/src/unipi_uart.c index fb601aa..f57af1f 100644 --- a/modules/unipi/src/unipi_uart.c +++ b/modules/unipi/src/unipi_uart.c @@ -310,37 +310,6 @@ int static neuronspi_uart_read_tx_fifo_len(struct neuronspi_port *port) return ret; } -/* -void neuronspi_uart_fifo_write(struct neuronspi_port *n_port, u8 to_send) -{ - int in_queue, need; - - unipi_uart_trace("FIFO Write to_send:%d %16ph\n", to_send, n_port->tx_buf); - //unipi_uart_trace_2(KERN_INFO "FIFO Write to_send:%d %16ph\n", to_send, n_port->tx_buf); - - do { - in_queue = neuronspi_uart_get_charcount(n_port); - need = (int)to_send - (NEURONSPI_FIFO_SIZE - in_queue); - if (need <= 0) break; - usleep_range(need * n_port->one_char_usec, (need + NEURONSPI_FIFO_SIZE/4) * n_port->one_char_usec); - } while(1); - neuronspi_spi_uart_write(neuronspi_s_dev[n_port->dev_index], n_port->tx_buf, to_send, n_port->dev_port); -} -*/ - -/* -s32 neuronspi_uart_alloc_line(void) -{ - s32 i; - BUILD_BUG_ON(NEURONSPI_MAX_DEVS > BITS_PER_LONG); - - for (i = 0; i < NEURONSPI_MAX_DEVS; i++) - if (!test_and_set_bit(i, &neuronspi_lines)) - break; - - return i; -} -*/ void neuronspi_rx_queue_clear(struct neuronspi_port *port, u8 data) { @@ -439,7 +408,7 @@ void neuronspi_uart_handle_tx(struct neuronspi_port *port) ret = neuronspi_uart_read_tx_fifo_len(port); if (ret || port->tx_fifo_len) { // set timer to check tx_empty - unipi_uart_trace("ttyNS%d Handle TX. Start timer=%llu", port->port.line, port->tx_fifo_len * port->one_char_nsec); + unipi_uart_trace_1("ttyNS%d Handle TX. Start timer=%llu", port->port.line, port->tx_fifo_len * port->one_char_nsec); start_tx_timer(port, port->tx_fifo_len, 2); //hrtimer_start_range_ns(&port->tx_timer, port->tx_fifo_len * port->one_char_nsec, 2*port->one_char_nsec, HRTIMER_MODE_REL); } @@ -505,7 +474,7 @@ void neuronspi_uart_handle_tx(struct neuronspi_port *port) kthread_queue_work(&neuronspi_uart_data_global->kworker, &port->tx_work); } else { // set timer to check tx_empty - unipi_uart_trace("ttyNS%d Handle TX. Start timer=%llu", port->port.line, to_send_packet * port->one_char_nsec); + unipi_uart_trace_1("ttyNS%d Handle TX. Start timer=%llu", port->port.line, to_send_packet * port->one_char_nsec); start_tx_timer(port, to_send_packet, 2); //hrtimer_start_range_ns(&port->tx_timer, to_send_packet * port->one_char_nsec, 2*port->one_char_nsec, HRTIMER_MODE_REL); } @@ -797,7 +766,7 @@ int neuronspi_uart_probe_all(void) } ret = neuronspi_uart_probe(spi, n_spi); - if (ret) break; + if (ret) break; // max number of uarts reached } return ret; }