diff options
| -rw-r--r-- | io-module/mtdc_gpiob.c | 289 | ||||
| -rw-r--r-- | io-module/mtr2d2.c | 134 | ||||
| -rw-r--r-- | io-module/mts_io.c | 274 | ||||
| -rw-r--r-- | io-module/spi.c | 248 |
4 files changed, 750 insertions, 195 deletions
diff --git a/io-module/mtdc_gpiob.c b/io-module/mtdc_gpiob.c index c207483..5a592b7 100644 --- a/io-module/mtdc_gpiob.c +++ b/io-module/mtdc_gpiob.c @@ -1,16 +1,25 @@ - -struct gpio_pin *dc_gpio_pin_by_attr_name(const char *name) { +struct gpio_pin *ap_gpio_pin_by_attr_name(const char *name) { struct gpio_pin *pin; char *pin_attr_name; - if (!strcmp(name, "led1")) { - pin_attr_name = "dc-gpio1"; - } else if (!strcmp(name, "led2")) { - pin_attr_name = "dc-gpio2"; - } else if (!strcmp(name, "dout-enable")) { - pin_attr_name = "dc-gpio3"; + if (!strcmp(name, "ap1-led1")) { + pin_attr_name = "ap1-gpio3"; + } else if (!strcmp(name, "ap1-led2")) { + pin_attr_name = "ap1-gpio4"; + } else if (!strcmp(name, "ap1-dout-enable")) { + pin_attr_name = "ap1-gpio1"; + } else if (!strcmp(name, "ap1-reset")) { + pin_attr_name = "ap1-reset"; + } else if (!strcmp(name, "ap2-led1")) { + pin_attr_name = "ap2-gpio3"; + } else if (!strcmp(name, "ap2-led2")) { + pin_attr_name = "ap2-gpio4"; + } else if (!strcmp(name, "ap2-dout-enable")) { + pin_attr_name = "ap2-gpio1"; + } else if (!strcmp(name, "ap2-reset")) { + pin_attr_name = "ap2-reset"; } else { - log_error("daughter card attribute %s not available", name); + log_error("accessory card attribute %s not available", name); return NULL; } @@ -26,12 +35,12 @@ struct gpio_pin *dc_gpio_pin_by_attr_name(const char *name) { } -static ssize_t mts_attr_show_dc_gpio_pin(struct device *dev, +static ssize_t mts_attr_show_ap_gpio_pin(struct device *dev, struct device_attribute *attr, char *buf) { int value; - struct gpio_pin *pin = dc_gpio_pin_by_attr_name(attr->attr.name); + struct gpio_pin *pin = ap_gpio_pin_by_attr_name(attr->attr.name); if (!pin) { return -ENODEV; @@ -54,11 +63,11 @@ static ssize_t mts_attr_show_dc_gpio_pin(struct device *dev, return sprintf(buf, "%d\n", value); } -static ssize_t mts_attr_store_dc_gpio_pin(struct device *dev, +static ssize_t mts_attr_store_ap_gpio_pin(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int value; - struct gpio_pin *pin = dc_gpio_pin_by_attr_name(attr->attr.name); + struct gpio_pin *pin = ap_gpio_pin_by_attr_name(attr->attr.name); if (!pin) { return -ENODEV; @@ -81,31 +90,46 @@ static ssize_t mts_attr_store_dc_gpio_pin(struct device *dev, return count; } -static ssize_t mts_attr_show_dc_din(struct device *dev, struct device_attribute *attr, char *buf) +static ssize_t mts_attr_show_ap_din(struct device *dev, struct device_attribute *attr, char *buf) { int tmp; u8 bit; u8 byte; + struct spi_device* spi_dev; + + if (strstr(attr->attr.name, ":0")) { + if (!spi_ap1_din_dev) { + log_error("accessory card 1 din device not present"); + return -ENODEV; + } - if (!spi_dc_din_dev) { - log_error("dc din device not present"); + spi_dev = spi_ap1_din_dev; + } else if (strstr(attr->attr.name, ":1")) { + if (!spi_ap2_din_dev) { + log_error("accessory card 2 din device not present"); + return -ENODEV; + } + + spi_dev = spi_ap2_din_dev; + } else { + log_error("unknown din device %s", attr->attr.name); return -ENODEV; } - if (!strcmp(attr->attr.name, "din0")) { + if (strstr(attr->attr.name, "din0")) { bit = BIT(0); - } else if (!strcmp(attr->attr.name, "din1")) { + } else if (strstr(attr->attr.name, "din1")) { bit = BIT(1); - } else if (!strcmp(attr->attr.name, "din2")) { + } else if (strstr(attr->attr.name, "din2")) { bit = BIT(2); - } else if (!strcmp(attr->attr.name, "din3")) { + } else if (strstr(attr->attr.name, "din3")) { bit = BIT(3); } else { - log_error("dc din attr does not exist"); + log_error("accessory card din attr does not exist"); return -ENOENT; } - tmp = spi_readn(spi_dc_din_dev, &byte, 1); + tmp = spi_readn(spi_dev, &byte, 1); if (tmp) { log_error("spi_read failed %d", tmp); return tmp; @@ -116,82 +140,112 @@ static ssize_t mts_attr_show_dc_din(struct device *dev, struct device_attribute return sprintf(buf, "%d\n", tmp); } -static ssize_t mts_attr_store_dc_dout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) +static ssize_t mts_attr_store_ap_dout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int value; u8 bit; + struct spi_device* spi_dev; + + if (strstr(attr->attr.name, ":0")) { + if (!spi_ap1_dout_dev) { + log_error("accessory card 1 dout device not present"); + return -ENODEV; + } + + spi_dev = spi_ap1_dout_dev; + } else if (strstr(attr->attr.name, ":1")) { + if (!spi_ap2_dout_dev) { + log_error("accessory card 2 dout device not present"); + return -ENODEV; + } - if (!spi_dc_dout_dev) { - log_error("dc dout device not present"); + spi_dev = spi_ap2_dout_dev; + } else { + log_error("unknown dout device %s", attr->attr.name); return -ENODEV; } - if (!strcmp(attr->attr.name, "dout0")) { + if (strstr(attr->attr.name, "dout0")) { bit = BIT(0); - } else if (!strcmp(attr->attr.name, "dout1")) { + } else if (strstr(attr->attr.name, "dout1")) { bit = BIT(1); - } else if (!strcmp(attr->attr.name, "dout2")) { + } else if (strstr(attr->attr.name, "dout2")) { bit = BIT(2); - } else if (!strcmp(attr->attr.name, "dout3")) { + } else if (strstr(attr->attr.name, "dout3")) { bit = BIT(3); } else { - log_error("dc dout attr does not exist"); + log_error("accessory card dout attr does not exist"); return -ENOENT; } if (sscanf(buf, "%i", &value) != 1) { - log_error("dc dout attr invalid argument"); + log_error("accessory card dout attr invalid argument"); return -EINVAL; } - mutex_lock(&spi_dc_dout_mutex); + mutex_lock(&spi_ap_dout_mutex); if (value) { - spi_dc_dout_value &= ~bit; + spi_ap_dout_value &= ~bit; } else { - spi_dc_dout_value |= bit; + spi_ap_dout_value |= bit; } - spi_writen(spi_dc_dout_dev, &spi_dc_dout_value, 1); + spi_writen(spi_dev, &spi_ap_dout_value, 1); - mutex_unlock(&spi_dc_dout_mutex); + mutex_unlock(&spi_ap_dout_mutex); return count; } -static ssize_t mts_attr_show_dc_dout(struct device *dev, struct device_attribute *attr, char *buf) +static ssize_t mts_attr_show_ap_dout(struct device *dev, struct device_attribute *attr, char *buf) { int value; u8 bit; + struct spi_device* spi_dev; - if (!spi_dc_dout_dev) { - log_error("dc dout device not present"); + if (strstr(attr->attr.name, ":0")) { + if (!spi_ap1_dout_dev) { + log_error("accessory card 1 dout device not present"); + return -ENODEV; + } + + spi_dev = spi_ap1_dout_dev; + } else if (strstr(attr->attr.name, ":1")) { + if (!spi_ap2_dout_dev) { + log_error("accessory card 2 dout device not present"); + return -ENODEV; + } + + spi_dev = spi_ap2_dout_dev; + } else { + log_error("unknown dout device %s", attr->attr.name); return -ENODEV; } - if (!strcmp(attr->attr.name, "dout0")) { + if (strstr(attr->attr.name, "dout0")) { bit = BIT(0); - } else if (!strcmp(attr->attr.name, "dout1")) { + } else if (strstr(attr->attr.name, "dout1")) { bit = BIT(1); - } else if (!strcmp(attr->attr.name, "dout2")) { + } else if (strstr(attr->attr.name, "dout2")) { bit = BIT(2); - } else if (!strcmp(attr->attr.name, "dout3")) { + } else if (strstr(attr->attr.name, "dout3")) { bit = BIT(3); } else { - log_error("dc dout attr does not exist"); + log_error("accessory card dout attr does not exist"); return -ENOENT; } - mutex_lock(&spi_dc_dout_mutex); + mutex_lock(&spi_ap_dout_mutex); - value = spi_dc_dout_value & bit ? 0 : 1; + value = spi_ap_dout_value & bit ? 0 : 1; - mutex_unlock(&spi_dc_dout_mutex); + mutex_unlock(&spi_ap_dout_mutex); return sprintf(buf, "%d\n", value); } -static ssize_t mts_attr_show_dc_adc(struct device *dev, struct device_attribute *attr, char *buf) +static ssize_t mts_attr_show_ap_adc(struct device *dev, struct device_attribute *attr, char *buf) { int tmp; int tx_data; @@ -201,23 +255,38 @@ static ssize_t mts_attr_show_dc_adc(struct device *dev, struct device_attribute int manual_mode = 0x1840; /* 0b 0001 1000 0100 0000 */ uint8_t tx[2]; uint8_t rx[2]; - - if (!spi_dc_adc_dev) { - log_error("dc adc device not present"); - return -ENODEV; - } + struct spi_device* spi_dev; memset(tx, 0, sizeof(tx)); memset(rx, 0, sizeof(rx)); - if (!strcmp(attr->attr.name, "adc0")) { + if (strstr(attr->attr.name, ":0")) { + if (!spi_ap1_adc_dev) { + log_error("accessory card 1 adc device not present"); + return -ENODEV; + } + + spi_dev = spi_ap1_adc_dev; + } else if (strstr(attr->attr.name, ":1")) { + if (!spi_ap2_adc_dev) { + log_error("accessory card 2 adc device not present"); + return -ENODEV; + } + + spi_dev = spi_ap2_adc_dev; + } else { + log_error("unknown adc device %s", attr->attr.name); + return -ENODEV; + } + + if (strstr(attr->attr.name, "adc0")) { channel = 0; - } else if (!strcmp(attr->attr.name, "adc1")) { + } else if (strstr(attr->attr.name, "adc1")) { channel = 1; - } else if (! strcmp(attr->attr.name, "adc2")) { + } else if (strstr(attr->attr.name, "adc2")) { channel = 2; } else { - log_error("dc adc attr does not exist"); + log_error("accessory card adc attr does not exist"); return -ENOENT; } @@ -225,7 +294,7 @@ static ssize_t mts_attr_show_dc_adc(struct device *dev, struct device_attribute tx_data = manual_mode | ((channel << 7) & channel_mask); tx[0] = tx_data >> 8; tx[1] = tx_data & 0xFF; - tmp = spi_writen(spi_dc_adc_dev, tx, 2); + tmp = spi_writen(spi_dev, tx, 2); if (tmp) { log_error("spi_write failed %d", tmp); return tmp; @@ -236,14 +305,14 @@ static ssize_t mts_attr_show_dc_adc(struct device *dev, struct device_attribute * the ADC just needs the clock running so it can convert */ tx[0] = 0; tx[1] = 0; - tmp = spi_writen(spi_dc_adc_dev, tx, 2); + tmp = spi_writen(spi_dev, tx, 2); if (tmp) { log_error("2nd spi_write failed %d", tmp); return tmp; } /* 3rd transfer to read data */ - tmp = spi_readn(spi_dc_adc_dev, rx, 2); + tmp = spi_readn(spi_dev, rx, 2); if (tmp) { log_error("spi_read failed %d", tmp); return tmp; @@ -253,18 +322,88 @@ static ssize_t mts_attr_show_dc_adc(struct device *dev, struct device_attribute return sprintf(buf, "%lu\n", (unsigned long) rx_data); } -/* MTDC-GPIOB */ -static DEVICE_ATTR_RO_MTS(dev_attr_dc_din0, "din0", mts_attr_show_dc_din); -static DEVICE_ATTR_RO_MTS(dev_attr_dc_din1, "din1", mts_attr_show_dc_din); -static DEVICE_ATTR_RO_MTS(dev_attr_dc_din2, "din2", mts_attr_show_dc_din); -static DEVICE_ATTR_RO_MTS(dev_attr_dc_din3, "din3", mts_attr_show_dc_din); -static DEVICE_ATTR_MTS(dev_attr_dc_dout0, "dout0", mts_attr_show_dc_dout, mts_attr_store_dc_dout); -static DEVICE_ATTR_MTS(dev_attr_dc_dout1, "dout1", mts_attr_show_dc_dout, mts_attr_store_dc_dout); -static DEVICE_ATTR_MTS(dev_attr_dc_dout2, "dout2", mts_attr_show_dc_dout, mts_attr_store_dc_dout); -static DEVICE_ATTR_MTS(dev_attr_dc_dout3, "dout3", mts_attr_show_dc_dout, mts_attr_store_dc_dout); -static DEVICE_ATTR_RO_MTS(dev_attr_dc_adc0, "adc0", mts_attr_show_dc_adc); -static DEVICE_ATTR_RO_MTS(dev_attr_dc_adc1, "adc1", mts_attr_show_dc_adc); -static DEVICE_ATTR_RO_MTS(dev_attr_dc_adc2, "adc2", mts_attr_show_dc_adc); -static DEVICE_ATTR_MTS(dev_attr_dc_led1, "led1", mts_attr_show_dc_gpio_pin, mts_attr_store_dc_gpio_pin); -static DEVICE_ATTR_MTS(dev_attr_dc_led2, "led2", mts_attr_show_dc_gpio_pin, mts_attr_store_dc_gpio_pin); -static DEVICE_ATTR_MTS(dev_attr_dc_oe, "dout-enable", mts_attr_show_dc_gpio_pin, mts_attr_store_dc_gpio_pin); +/* accessory port 1 gpiob attributes */ +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_din0, "din0:0", mts_attr_show_ap_din); +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_din1, "din1:0", mts_attr_show_ap_din); +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_din2, "din2:0", mts_attr_show_ap_din); +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_din3, "din3:0", mts_attr_show_ap_din); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_dout0, "dout0:0", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_dout1, "dout1:0", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_dout2, "dout2:0", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_dout3, "dout3:0", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_adc0, "adc0:0", mts_attr_show_ap_adc); +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_adc1, "adc1:0", mts_attr_show_ap_adc); +static DEVICE_ATTR_RO_MTS(dev_attr_ap1_gpio_adc2, "adc2:0", mts_attr_show_ap_adc); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_led1, "ap1-led1", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_led2, "ap1-led2", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); +static DEVICE_ATTR_MTS(dev_attr_ap1_gpio_oe, "ap1-dout-enable", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); +static DEVICE_ATTR_MTS(dev_attr_ap1_reset, "ap1-reset", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); + +static int ap1_gpio_attributes_size = 15; // not including NULL at end + +static struct attribute *ap1_gpio_attributes[] = { + &dev_attr_ap1_reset.attr, + + &dev_attr_ap1_gpio_oe.attr, // gpio1 + &dev_attr_ap1_gpio_led1.attr, // gpio3 + &dev_attr_ap1_gpio_led2.attr, // gpio4 + + &dev_attr_ap1_gpio_din0.attr, + &dev_attr_ap1_gpio_din1.attr, + &dev_attr_ap1_gpio_din2.attr, + &dev_attr_ap1_gpio_din3.attr, + + &dev_attr_ap1_gpio_dout0.attr, + &dev_attr_ap1_gpio_dout1.attr, + &dev_attr_ap1_gpio_dout2.attr, + &dev_attr_ap1_gpio_dout3.attr, + + &dev_attr_ap1_gpio_adc0.attr, + &dev_attr_ap1_gpio_adc1.attr, + &dev_attr_ap1_gpio_adc2.attr, + + NULL, +}; + +/* accessory port 2 gpiob attributes */ +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_din0, "din0:1", mts_attr_show_ap_din); +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_din1, "din1:1", mts_attr_show_ap_din); +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_din2, "din2:1", mts_attr_show_ap_din); +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_din3, "din3:1", mts_attr_show_ap_din); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_dout0, "dout0:1", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_dout1, "dout1:1", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_dout2, "dout2:1", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_dout3, "dout3:1", mts_attr_show_ap_dout, mts_attr_store_ap_dout); +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_adc0, "adc0:1", mts_attr_show_ap_adc); +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_adc1, "adc1:1", mts_attr_show_ap_adc); +static DEVICE_ATTR_RO_MTS(dev_attr_ap2_gpio_adc2, "adc2:1", mts_attr_show_ap_adc); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_led1, "ap2-led1", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_led2, "ap2-led2", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); +static DEVICE_ATTR_MTS(dev_attr_ap2_gpio_oe, "ap2-dout-enable", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); +static DEVICE_ATTR_MTS(dev_attr_ap2_reset, "ap2-reset", mts_attr_show_ap_gpio_pin, mts_attr_store_ap_gpio_pin); + +static int ap2_gpio_attributes_size = 15; // not including NULL at end + +static struct attribute *ap2_gpio_attributes[] = { + &dev_attr_ap2_reset.attr, + + &dev_attr_ap2_gpio_oe.attr, // gpio1 + &dev_attr_ap2_gpio_led1.attr, // gpio3 + &dev_attr_ap2_gpio_led2.attr, // gpio4 + + &dev_attr_ap2_gpio_din0.attr, + &dev_attr_ap2_gpio_din1.attr, + &dev_attr_ap2_gpio_din2.attr, + &dev_attr_ap2_gpio_din3.attr, + + &dev_attr_ap2_gpio_dout0.attr, + &dev_attr_ap2_gpio_dout1.attr, + &dev_attr_ap2_gpio_dout2.attr, + &dev_attr_ap2_gpio_dout3.attr, + + &dev_attr_ap2_gpio_adc0.attr, + &dev_attr_ap2_gpio_adc1.attr, + &dev_attr_ap2_gpio_adc2.attr, + + NULL, +}; diff --git a/io-module/mtr2d2.c b/io-module/mtr2d2.c index 58aeb03..b2fc03f 100644 --- a/io-module/mtr2d2.c +++ b/io-module/mtr2d2.c @@ -146,9 +146,130 @@ static struct gpio_pin gpio_pins_mtr2d2_0_0[] = { }, .active_low = 1, }, + + // gpio pins for Accessory Card 1 + { + .name = "AP1_RESET", + .pin = { + .gpio = AT91_PIN_PB12, + .flags = GPIOF_OUT_INIT_HIGH, + .label = "ap1-reset", + } + }, + { + .name = "AP1_GPIO1", + .pin = { + .gpio = AT91_PIN_PC6, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap1-gpio1", + }, + .active_low = 1, + }, + { + .name = "AP1_GPIO2", + .pin = { + .gpio = AT91_PIN_PC7, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap1-gpio2", + } + }, + { + .name = "AP1_GPIO3", + .pin = { + .gpio = AT91_PIN_PC8, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap1-gpio3", + } + }, + { + .name = "AP1_GPIO4", + .pin = { + .gpio = AT91_PIN_PC9, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap1-gpio4", + } + }, + { + .name = "AP1_INTERRUPT1", + .pin = { + .gpio = AT91_PIN_PB14, + .flags = GPIOF_IN, + .label = "ap1-interrupt1", + } + }, + { + .name = "AP1_INTERRUPT2", + .pin = { + .gpio = AT91_PIN_PB15, + .flags = GPIOF_IN, + .label = "ap1-interrupt2", + } + }, + + // gpio pins for Accessory Card 2 + { + .name = "AP2_RESET", + .pin = { + .gpio = AT91_PIN_PB13, + .flags = GPIOF_OUT_INIT_HIGH, + .label = "ap2-reset", + } + }, + { + .name = "AP2_GPIO1", + .pin = { + .gpio = AT91_PIN_PC20, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap2-gpio1", + }, + .active_low = 1, + }, + { + .name = "AP2_GPIO2", + .pin = { + .gpio = AT91_PIN_PC21, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap2-gpio2", + } + }, + { + .name = "AP2_GPIO3", + .pin = { + .gpio = AT91_PIN_PC22, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap2-gpio3", + } + }, + { + .name = "AP2_GPIO4", + .pin = { + .gpio = AT91_PIN_PC23, + .flags = GPIOF_OUT_INIT_LOW, + .label = "ap2-gpio4", + } + }, + { + .name = "AP2_INTERRUPT1", + .pin = { + .gpio = AT91_PIN_PB17, + .flags = GPIOF_IN, + .label = "ap2-interrupt1", + } + }, + { + .name = "AP2_INTERRUPT2", + .pin = { + .gpio = AT91_PIN_PB18, + .flags = GPIOF_IN, + .label = "ap2-interrupt2", + } + }, + { }, }; +static int mtr2d2_platform_attributes_size = 64; // not including NULL at end + static struct attribute *mtr2d2_platform_attributes[] = { &dev_attr_vendor_id.attr, &dev_attr_product_id.attr, @@ -207,6 +328,19 @@ static struct attribute *mtr2d2_platform_attributes[] = { NULL, // index 49 NULL, // index 50 NULL, // index 51 + NULL, // index 52 + NULL, // index 53 + NULL, // index 54 + NULL, // index 55 + NULL, // index 56 + NULL, // index 57 + NULL, // index 58 + NULL, // index 59 + NULL, // index 60 + NULL, // index 61 + NULL, // index 62 + NULL, // index 63 + NULL, // index 64 NULL, }; diff --git a/io-module/mts_io.c b/io-module/mts_io.c index e26013d..b63a756 100644 --- a/io-module/mts_io.c +++ b/io-module/mts_io.c @@ -71,8 +71,8 @@ static struct mts_ap_eeprom_layout ap1_eeprom; static struct mts_ap_eeprom_layout ap2_eeprom; bool accessory_card_capable = false; -bool has_accessory_card_port_1 = false; -bool has_accessory_card_port_2 = false; +bool have_accessory_card_slot_1 = false; +bool have_accessory_card_slot_2 = false; static uint8_t mts_product_id; static uint8_t mts_ap1_product_id; @@ -405,7 +405,7 @@ static DEVICE_ATTR_RO_MTS(dev_attr_eth_mac, "mac-eth", mts_attr_show_product_info); /* include per-device pins and attributes */ -#include "mtr2.c" +//#include "mtr2.c" #include "mtr.c" #include "mtr2d2.c" @@ -414,10 +414,70 @@ static DEVICE_ATTR_RO_MTS(dev_attr_eth_mac, "mac-eth", #include "mt100eocg.c" */ -/* reorg this function to load and log both accessory card EEPROMs - * should be able to handle either or both slots being empty - */ -static int mts_ap_eeprom_load(void) +static bool add_accessory_card_attributes(int slot) +{ + size_t device_attrs_size; + size_t card_attrs_size; + size_t attrs_index; + size_t i; + + struct attribute **device_attrs; + struct attribute **card_attrs; + + switch (mts_product_id) { + case MTR2D2_0_0: + device_attrs_size = mtr2d2_platform_attributes_size; + device_attrs = mtr2d2_platform_attributes; + break; + default: + log_error("accessory cards aren't supported for platform %s", id_eeprom.hw_version); + return false; + } + + if (slot == 1) { + switch (mts_ap1_product_id) { + case MTDC_GPIOB_0_0: + card_attrs_size = ap1_gpio_attributes_size; + card_attrs = ap1_gpio_attributes; + break; + default: + log_error("accessory card %s isn't supported", ap1_eeprom.hw_version); + return false; + } + } else if (slot == 2) { + switch (mts_ap2_product_id) { + case MTDC_GPIOB_0_0: + card_attrs_size = ap2_gpio_attributes_size; + card_attrs = ap2_gpio_attributes; + break; + default: + log_error("accessory card %s isn't supported", ap2_eeprom.hw_version); + return false; + } + } else { + log_error("%d is an invalid slot value", slot); + return false; + } + + for (attrs_index = 0; attrs_index < device_attrs_size; attrs_index++) { + if (! device_attrs[attrs_index]) { + break; + } + } + + if (device_attrs_size < attrs_index + card_attrs_size) { + log_error("not enough room for accessory card attributes!"); + return false; + } + + for (i = 0; i < card_attrs_size; i++) { + device_attrs[attrs_index + i] = card_attrs[i]; + } + + return true; +} + +static bool mts_ap_eeprom_load(void) { // Accessory Card Slot 1 memcpy(&ap1_eeprom, mts_ap1_eeprom, sizeof(mts_ap1_eeprom)); @@ -427,7 +487,7 @@ static int mts_ap_eeprom_load(void) } else if (mts_ap1_eeprom[0] == 0x00) { log_info("no accessory card inserted in slot 1"); } else { - has_accessory_card_port_1 = true; + have_accessory_card_slot_1 = true; log_info("accessory card 1 vendor-id: %.32s", ap1_eeprom.vendor_id); log_info("accessory card 1 product-id: %.32s", ap1_eeprom.product_id); @@ -452,7 +512,7 @@ static int mts_ap_eeprom_load(void) } else if (mts_ap2_eeprom[0] == 0x00) { log_info("no accessory card inserted in slot 2"); } else { - has_accessory_card_port_2 = true; + have_accessory_card_slot_2 = true; log_info("accessory card 2 vendor-id: %.32s", ap2_eeprom.vendor_id); log_info("accessory card 2 product-id: %.32s", ap2_eeprom.product_id); @@ -469,7 +529,8 @@ static int mts_ap_eeprom_load(void) } } - return 0; + // if either slot has a valid card, return true + return (have_accessory_card_slot_1 || have_accessory_card_slot_2); } static int mts_id_eeprom_load(void) @@ -507,7 +568,6 @@ static int mts_id_eeprom_load(void) has_spi_dout = 1; has_spi_temp = 1; log_info("detected board %s", HW_VERSION_MT100EOCG_0_0); - */ } else if (strncmp(id_eeprom.hw_version, HW_VERSION_MTR2_0_0, strlen(HW_VERSION_MTR2_0_0)) == 0) { attr_group = &mtr2_platform_attribute_group; gpio_pins = gpio_pins_mtr2_0_0; @@ -518,6 +578,7 @@ static int mts_id_eeprom_load(void) has_spi_dout = 0; has_spi_temp = 1; log_info("detected board %s", HW_VERSION_MTR2_0_0); + */ } else if (strncmp(id_eeprom.hw_version, HW_VERSION_MTR_0_0, strlen(HW_VERSION_MTR_0_0)) == 0) { attr_group = &mtr_platform_attribute_group; gpio_pins = gpio_pins_mtr_0_0; @@ -536,6 +597,7 @@ static int mts_id_eeprom_load(void) has_spi_dout = 0; has_spi_temp = 0; log_info("detected board %s", HW_VERSION_MTR_0_1); + /* } else if (strncmp(id_eeprom.hw_version, HW_VERSION_MTOCGD2_0_0, strlen(HW_VERSION_MTOCGD2_0_0)) == 0) { attr_group = &mtr2_platform_attribute_group; gpio_pins = gpio_pins_mtr2_0_0; @@ -546,6 +608,7 @@ static int mts_id_eeprom_load(void) has_spi_dout = 0; has_spi_temp = 1; log_info("detected board %s", HW_VERSION_MTOCGD2_0_0); + */ } else if (strncmp(id_eeprom.hw_version, HW_VERSION_MTOCGD_0_0, strlen(HW_VERSION_MTOCGD_0_0)) == 0) { attr_group = &mtr_platform_attribute_group; gpio_pins = gpio_pins_mtr_0_0; @@ -568,6 +631,7 @@ static int mts_id_eeprom_load(void) attr_group = &mtr2d2_platform_attribute_group; gpio_pins = gpio_pins_mtr2d2_0_0; mts_product_id = MTR2D2_0_0; + accessory_card_capable = true; has_spi_sout = 0; has_spi_din = 0; has_spi_dout = 0; @@ -631,6 +695,8 @@ static int __init mts_io_init(void) { struct gpio_pin *pin; int ret; + size_t device_attributes_size; + size_t card_attributes_size; log_info("init: " DRIVER_VERSION); @@ -641,54 +707,92 @@ static int __init mts_io_init(void) if (accessory_card_capable) { mts_ap1_product_id = MTDC_NONE; - ret = mts_ap_eeprom_load(); - if (ret) { - /* error reading the EEPROM from the daughter card */ - log_error("error reading daughter card eeprom: %d", ret); - log_error("unable to initialize daughter card"); - goto error1; - } else if (false) { - // this needs review, stay away for now - /* no error and we have a daughter card */ - if (strstr(ap1_eeprom.product_id, PRODUCT_ID_MTDC_GPIOB)) { - mts_ap1_product_id = MTDC_GPIOB_0_0; + mts_ap2_product_id = MTDC_NONE; + if (mts_ap_eeprom_load()) { + // handle both slots, but do slot 1 first + // probably need special handling if both cards are the same type + if (have_accessory_card_slot_1) { + // more elegant way to handle this? + if (strstr(ap1_eeprom.product_id, PRODUCT_ID_MTDC_GPIOB)) { + mts_ap1_product_id = MTDC_GPIOB_0_0; + } // else if (...) { } + + switch(mts_ap1_product_id) { + case MTDC_GPIOB_0_0: + log_info("loading GPIO accessory card in slot 1"); + if (! add_accessory_card_attributes(1)) { + log_error("failed to load GPIO accessory card in slot 1"); + } else { + log_info("successfully loaded GPIO accessory card in slot 1"); + } + log_debug("registering accessory card 1 dout driver"); + ret = spi_register_driver(&mts_spi_ap1_dout_driver); + if (ret) { + log_error("failed to register accessory card 1 dout driver"); + spi_unregister_driver(&mts_spi_ap1_dout_driver); + goto error1; + } + log_debug("registering accessory card 1 din driver"); + ret = spi_register_driver(&mts_spi_ap1_din_driver); + if (ret) { + log_error("failed to register accessory card 1 din driver"); + spi_unregister_driver(&mts_spi_ap1_din_driver); + goto error1; + } + log_debug("registering accessory card 1 adc driver"); + ret = spi_register_driver(&mts_spi_ap1_adc_driver); + if (ret) { + log_error("failed to register accessory card 1 adc driver"); + spi_unregister_driver(&mts_spi_ap1_adc_driver); + goto error1; + } + break; + + default: + log_error("accessory card %s unsupported", ap1_eeprom.product_id); + } } - switch(mts_ap1_product_id) { - case MTDC_GPIOB_0_0: - log_debug("adding GPIO daughter card attributes"); - if (! mtr2_add_daughter_card_attributes()) { - log_error("failed to add GPIO daughter card attributes"); - goto error1; - } else { - log_info("successfully added GPIO daughter card attributes"); - } - - log_debug("registering daughter card dout driver"); - ret = spi_register_driver(&mts_spi_dc_dout_driver); - if (ret) { - log_error("failed to register dc dout driver"); - spi_unregister_driver(&mts_spi_dc_dout_driver); - goto error1; - } - log_debug("registering daughter card din driver"); - ret = spi_register_driver(&mts_spi_dc_din_driver); - if (ret) { - log_error("failed to register dc din driver"); - spi_unregister_driver(&mts_spi_dc_din_driver); - goto error1; - } - log_debug("registering daughter card adc driver"); - ret = spi_register_driver(&mts_spi_dc_adc_driver); - if (ret) { - log_error("failed to register dc adc driver"); - spi_unregister_driver(&mts_spi_dc_adc_driver); - goto error1; - } - break; - - default: - log_info("daughter card '%s' currently unsupported", ap1_eeprom.product_id); + if (have_accessory_card_slot_2) { + // more elegant way to handle this? + if (strstr(ap2_eeprom.product_id, PRODUCT_ID_MTDC_GPIOB)) { + mts_ap2_product_id = MTDC_GPIOB_0_0; + } // else if (...) { } + + switch(mts_ap2_product_id) { + case MTDC_GPIOB_0_0: + log_info("loading GPIO accessory card in slot 2"); + if (! add_accessory_card_attributes(2)) { + log_error("failed to load GPIO accessory card in slot 2"); + } else { + log_info("successfully loaded GPIO accessory card in slot 2"); + } + log_debug("registering accessory card 2 dout driver"); + ret = spi_register_driver(&mts_spi_ap2_dout_driver); + if (ret) { + log_error("failed to register accessory card 2 dout driver"); + spi_unregister_driver(&mts_spi_ap2_dout_driver); + goto error1; + } + log_debug("registering accessory card 2 din driver"); + ret = spi_register_driver(&mts_spi_ap2_din_driver); + if (ret) { + log_error("failed to register accessory card 2 din driver"); + spi_unregister_driver(&mts_spi_ap2_din_driver); + goto error1; + } + log_debug("registering accessory card 2 adc driver"); + ret = spi_register_driver(&mts_spi_ap2_adc_driver); + if (ret) { + log_error("failed to register accessory card 2 adc driver"); + spi_unregister_driver(&mts_spi_ap2_adc_driver); + goto error1; + } + break; + + default: + log_error("accessory card %s unsupported", ap1_eeprom.product_id); + } } } } @@ -815,6 +919,32 @@ error3: platform_device_del(mts_io_platform_device); error2: platform_device_put(mts_io_platform_device); + + if (have_accessory_card_slot_1) { + switch (mts_ap1_product_id) { + case MTDC_GPIOB_0_0: + spi_unregister_driver(&mts_spi_ap1_dout_driver); + spi_unregister_driver(&mts_spi_ap1_din_driver); + spi_unregister_driver(&mts_spi_ap1_adc_driver); + break; + + default: + break; + } + } + + if (have_accessory_card_slot_2) { + switch (mts_ap2_product_id) { + case MTDC_GPIOB_0_0: + spi_unregister_driver(&mts_spi_ap2_dout_driver); + spi_unregister_driver(&mts_spi_ap2_din_driver); + spi_unregister_driver(&mts_spi_ap2_adc_driver); + break; + + default: + break; + } + } error1: log_error("init failed: %d", ret); @@ -843,12 +973,25 @@ static void __exit mts_io_exit(void) if (has_spi_sout) spi_unregister_driver(&mts_spi_sout_driver); - if (has_accessory_card_port_1) { + if (have_accessory_card_slot_1) { switch (mts_ap1_product_id) { case MTDC_GPIOB_0_0: - spi_unregister_driver(&mts_spi_dc_dout_driver); - spi_unregister_driver(&mts_spi_dc_din_driver); - spi_unregister_driver(&mts_spi_dc_adc_driver); + spi_unregister_driver(&mts_spi_ap1_dout_driver); + spi_unregister_driver(&mts_spi_ap1_din_driver); + spi_unregister_driver(&mts_spi_ap1_adc_driver); + break; + + default: + break; + } + } + + if (have_accessory_card_slot_2) { + switch (mts_ap2_product_id) { + case MTDC_GPIOB_0_0: + spi_unregister_driver(&mts_spi_ap2_dout_driver); + spi_unregister_driver(&mts_spi_ap2_din_driver); + spi_unregister_driver(&mts_spi_ap2_adc_driver); break; default: @@ -877,6 +1020,9 @@ MODULE_ALIAS("mts-io-sout"); MODULE_ALIAS("mts-io-board-temp"); MODULE_ALIAS("mts-io-dout"); MODULE_ALIAS("mts-io-din"); -MODULE_ALIAS("mts-io-dc-dout"); -MODULE_ALIAS("mts-io-dc-din"); -MODULE_ALIAS("mts-io-dc-adc"); +MODULE_ALIAS("mts-io-ap1-dout"); +MODULE_ALIAS("mts-io-ap1-din"); +MODULE_ALIAS("mts-io-ap1-adc"); +MODULE_ALIAS("mts-io-ap2-dout"); +MODULE_ALIAS("mts-io-ap2-din"); +MODULE_ALIAS("mts-io-ap2-adc"); diff --git a/io-module/spi.c b/io-module/spi.c index dfbdfe2..df663ae 100644 --- a/io-module/spi.c +++ b/io-module/spi.c @@ -40,29 +40,32 @@ MODULE_PARM_DESC( "Maximum clock rate to be used with this device (default: 1 MHz)" ); -static struct spi_device *spi_dc_dout_dev; -static u8 spi_dc_dout_value; -static DEFINE_MUTEX(spi_dc_dout_mutex); -static unsigned int dc_dout_max_speed_hz = 1 * 1000 * 1000; -module_param(dc_dout_max_speed_hz, uint, S_IRUGO); +static struct spi_device *spi_ap1_dout_dev; +static struct spi_device *spi_ap2_dout_dev; +static u8 spi_ap_dout_value; +static DEFINE_MUTEX(spi_ap_dout_mutex); +static unsigned int ap_dout_max_speed_hz = 1 * 1000 * 1000; +module_param(ap_dout_max_speed_hz, uint, S_IRUGO); MODULE_PARM_DESC( - dc_dout_max_speed_hz, + ap_dout_max_speed_hz, "Maximum clock rate to be used with this device (default: 1 MHz)" ); -static struct spi_device *spi_dc_din_dev; -static unsigned int dc_din_max_speed_hz = 1 * 1000 * 1000; -module_param(dc_din_max_speed_hz, uint, S_IRUGO); +static struct spi_device *spi_ap1_din_dev; +static struct spi_device *spi_ap2_din_dev; +static unsigned int ap_din_max_speed_hz = 1 * 1000 * 1000; +module_param(ap_din_max_speed_hz, uint, S_IRUGO); MODULE_PARM_DESC( - dc_din_max_speed_hz, + ap_din_max_speed_hz, "Maximum clock rate to be used with this device (default: 1 MHz)" ); -static struct spi_device *spi_dc_adc_dev; -static unsigned int dc_adc_max_speed_hz = 20 * 1000 * 1000; -module_param(dc_adc_max_speed_hz, uint, S_IRUGO); +static struct spi_device *spi_ap1_adc_dev; +static struct spi_device *spi_ap2_adc_dev; +static unsigned int ap_adc_max_speed_hz = 20 * 1000 * 1000; +module_param(ap_adc_max_speed_hz, uint, S_IRUGO); MODULE_PARM_DESC( - dc_adc_max_speed_hz, + ap_adc_max_speed_hz, "Maximum clock rate to be used with this device (default: 20 MHz)" ); @@ -595,137 +598,270 @@ static struct spi_driver mts_spi_din_driver = { .remove = mts_spi_din_remove, }; -static int mts_spi_dc_dout_probe(struct spi_device *spi) +static int mts_spi_ap1_dout_probe(struct spi_device *spi) { int tmp; - if (! has_accessory_card_port_1 || mts_ap1_product_id != MTDC_GPIOB_0_0) { - log_error("accessory card digital outputs not available"); + if (! have_accessory_card_slot_1 || mts_ap1_product_id != MTDC_GPIOB_0_0) { + log_error("accessory card 1 digital outputs not available"); return -ENODEV; } - spi->max_speed_hz = dc_dout_max_speed_hz; + spi->max_speed_hz = ap_dout_max_speed_hz; spi->mode = 0; - log_debug("dc_dout_max_speed_hz: %d", dc_dout_max_speed_hz); + log_debug("ap1_dout_max_speed_hz: %d", ap_dout_max_speed_hz); tmp = spi_setup(spi); if (tmp < 0) { - log_error("spi_setup dc dout failed"); + log_error("spi_setup accessory card 1 dout failed"); return tmp; } - spi_dc_dout_value = 0x00; - spi_writen(spi, &spi_dc_dout_value, 1); + spi_ap_dout_value = 0x00; + spi_writen(spi, &spi_ap_dout_value, 1); - spi_dc_dout_dev = spi; + spi_ap1_dout_dev = spi; return 0; } -static int mts_spi_dc_dout_remove(struct spi_device *spi) +static int mts_spi_ap1_dout_remove(struct spi_device *spi) { - spi_dc_dout_dev = NULL; + spi_ap1_dout_dev = NULL; return 0; } -static struct spi_driver mts_spi_dc_dout_driver = { +static struct spi_driver mts_spi_ap1_dout_driver = { .driver = { - .name = "mts-io-dc-dout", + .name = "mts-io-ap1-dout", .bus = &spi_bus_type, .owner = THIS_MODULE, }, - .probe = mts_spi_dc_dout_probe, - .remove = mts_spi_dc_dout_remove, + .probe = mts_spi_ap1_dout_probe, + .remove = mts_spi_ap1_dout_remove, }; -static int mts_spi_dc_din_probe(struct spi_device *spi) +static int mts_spi_ap1_din_probe(struct spi_device *spi) { int tmp; - if (! has_accessory_card_port_1 || mts_ap1_product_id != MTDC_GPIOB_0_0) { - log_error("accessory card digital inputs not available"); + if (! have_accessory_card_slot_1 || mts_ap1_product_id != MTDC_GPIOB_0_0) { + log_error("accessory card 1 digital inputs not available"); return -ENODEV; } - spi->max_speed_hz = dc_din_max_speed_hz; + spi->max_speed_hz = ap_din_max_speed_hz; spi->mode = SPI_CPOL; - log_debug("dc_din_max_speed_hz: %d", dc_din_max_speed_hz); + log_debug("ap1_din_max_speed_hz: %d", ap_din_max_speed_hz); tmp = spi_setup(spi); if (tmp < 0) { - log_error("spi_setup daughter card din failed"); + log_error("spi_setup accessory card 1 din failed"); return tmp; } - spi_dc_din_dev = spi; + spi_ap1_din_dev = spi; return 0; } -static int mts_spi_dc_din_remove(struct spi_device *spi) +static int mts_spi_ap1_din_remove(struct spi_device *spi) { - spi_dc_din_dev = NULL; + spi_ap1_din_dev = NULL; return 0; } -static struct spi_driver mts_spi_dc_din_driver = { +static struct spi_driver mts_spi_ap1_din_driver = { .driver = { - .name = "mts-io-dc-din", + .name = "mts-io-ap1-din", .bus = &spi_bus_type, .owner = THIS_MODULE, }, - .probe = mts_spi_dc_din_probe, - .remove = mts_spi_dc_din_remove, + .probe = mts_spi_ap1_din_probe, + .remove = mts_spi_ap1_din_remove, }; -static int mts_spi_dc_adc_probe(struct spi_device *spi) +static int mts_spi_ap1_adc_probe(struct spi_device *spi) { int tmp; - if (! has_accessory_card_port_1 || mts_ap1_product_id != MTDC_GPIOB_0_0) { - log_error("accessory card analog to digital not available"); + if (! have_accessory_card_slot_1 || mts_ap1_product_id != MTDC_GPIOB_0_0) { + log_error("accessory card 1 analog to digital not available"); return -ENODEV; } - spi->max_speed_hz = dc_adc_max_speed_hz; + spi->max_speed_hz = ap_adc_max_speed_hz; spi->mode = 0; - log_debug("dc_adc_max_speed_hz: %d", dc_adc_max_speed_hz); - log_debug("dc_adc_mode: %d", spi->mode); + log_debug("ap1_adc_max_speed_hz: %d", ap_adc_max_speed_hz); + log_debug("ap1_adc_mode: %d", spi->mode); tmp = spi_setup(spi); if (tmp < 0) { - log_error("spi_setup daughter card adc failed"); + log_error("spi_setup accessory card 1 adc failed"); return tmp; } - spi_dc_adc_dev = spi; + spi_ap1_adc_dev = spi; return 0; } -static int mts_spi_dc_adc_remove(struct spi_device *spi) +static int mts_spi_ap1_adc_remove(struct spi_device *spi) { - spi_dc_adc_dev = NULL; + spi_ap1_adc_dev = NULL; return 0; } -static struct spi_driver mts_spi_dc_adc_driver = { +static struct spi_driver mts_spi_ap1_adc_driver = { .driver = { - .name = "mts-io-dc-adc", + .name = "mts-io-ap1-adc", .bus = &spi_bus_type, .owner = THIS_MODULE, }, - .probe = mts_spi_dc_adc_probe, - .remove = mts_spi_dc_adc_remove, + .probe = mts_spi_ap1_adc_probe, + .remove = mts_spi_ap1_adc_remove, +}; + +static int mts_spi_ap2_dout_probe(struct spi_device *spi) +{ + int tmp; + + if (! have_accessory_card_slot_2 || mts_ap2_product_id != MTDC_GPIOB_0_0) { + log_error("accessory card 2 digital outputs not available"); + return -ENODEV; + } + + spi->max_speed_hz = ap_dout_max_speed_hz; + spi->mode = 0; + + log_debug("ap2_dout_max_speed_hz: %d", ap_dout_max_speed_hz); + + tmp = spi_setup(spi); + if (tmp < 0) { + log_error("spi_setup accessory card 2 dout failed"); + return tmp; + } + + spi_ap_dout_value = 0x00; + spi_writen(spi, &spi_ap_dout_value, 2); + + spi_ap2_dout_dev = spi; + + return 0; +} + +static int mts_spi_ap2_dout_remove(struct spi_device *spi) +{ + spi_ap2_dout_dev = NULL; + + return 0; +} + +static struct spi_driver mts_spi_ap2_dout_driver = { + .driver = { + .name = "mts-io-ap2-dout", + .bus = &spi_bus_type, + .owner = THIS_MODULE, + }, + + .probe = mts_spi_ap2_dout_probe, + .remove = mts_spi_ap2_dout_remove, +}; + +static int mts_spi_ap2_din_probe(struct spi_device *spi) +{ + int tmp; + + if (! have_accessory_card_slot_2 || mts_ap2_product_id != MTDC_GPIOB_0_0) { + log_error("accessory card 2 digital inputs not available"); + return -ENODEV; + } + + spi->max_speed_hz = ap_din_max_speed_hz; + spi->mode = SPI_CPOL; + + log_debug("ap2_din_max_speed_hz: %d", ap_din_max_speed_hz); + + tmp = spi_setup(spi); + if (tmp < 0) { + log_error("spi_setup accessory card 2 din failed"); + return tmp; + } + + spi_ap2_din_dev = spi; + + return 0; +} + +static int mts_spi_ap2_din_remove(struct spi_device *spi) +{ + spi_ap2_din_dev = NULL; + + return 0; +} + +static struct spi_driver mts_spi_ap2_din_driver = { + .driver = { + .name = "mts-io-ap2-din", + .bus = &spi_bus_type, + .owner = THIS_MODULE, + }, + + .probe = mts_spi_ap2_din_probe, + .remove = mts_spi_ap2_din_remove, +}; + +static int mts_spi_ap2_adc_probe(struct spi_device *spi) +{ + int tmp; + + if (! have_accessory_card_slot_2 || mts_ap2_product_id != MTDC_GPIOB_0_0) { + log_error("accessory card 2 analog to digital not available"); + return -ENODEV; + } + + spi->max_speed_hz = ap_adc_max_speed_hz; + spi->mode = 0; + + log_debug("ap2_adc_max_speed_hz: %d", ap_adc_max_speed_hz); + log_debug("ap2_adc_mode: %d", spi->mode); + + tmp = spi_setup(spi); + if (tmp < 0) { + log_error("spi_setup accessory card 2 adc failed"); + return tmp; + } + + spi_ap2_adc_dev = spi; + + return 0; +} + +static int mts_spi_ap2_adc_remove(struct spi_device *spi) +{ + spi_ap2_adc_dev = NULL; + + return 0; +} + +static struct spi_driver mts_spi_ap2_adc_driver = { + .driver = { + .name = "mts-io-ap2-adc", + .bus = &spi_bus_type, + .owner = THIS_MODULE, + }, + + .probe = mts_spi_ap2_adc_probe, + .remove = mts_spi_ap2_adc_remove, }; static int mts_spi_board_temp_probe(struct spi_device *spi) |