accessory cards: support both ports

	allow for 2 GPIOB accessory cards to be used at the same time
	some misc cleanup, more specific logging on init
	commented out mtr2 platform as it currently causes build issues with accessory card changes

1 files changed, 214 insertions, 75 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,
+};