path: root/io-module/machine/mtcap.c

#include "at91gpio.h"
#include "mts_supercap.h"
/* Used for both MTCAP 0.0 and 0.1 */
static struct gpio_pin gpio_pins_mtcap_0_0[] = {
	{
		.name = "ETH_RESET",
		.pin = {
			.gpio = AT91_PIN_PC6, // NETH_RST
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "eth-reset",
		},
	},
	{
		.name = "RADIO_POWER_MONITOR",
		.pin = {
			.gpio = AT91_PIN_PD21, // PWRMON
			.flags = GPIOF_IN,
			.label = "radio-power-monitor",
		},
	},
	{
		.name = "RADIO_RESET",
		.pin = {
			.gpio = AT91_PIN_PA22, // 3G_RST
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "radio-reset",
		},
	},
	{
		.name = "RADIO_POWER",
		.pin = {
			.gpio = AT91_PIN_PA21, // 3G_ONOFF
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "radio-power",
		},
	},
	{
		.name = "DEVICE_RESET",
		.pin = {
			.gpio = AT91_PIN_PC4, // OPT_RST
			.flags = GPIOF_IN,
			.label = "reset",
		},
		.active_low = 1,
	},
	{
		.name = "LORA_RESET",
		.pin = {
			.gpio = AT91_PIN_PA8, // LORA_RST
			.flags = GPIOF_OUT_INIT_LOW,
			.label = "lora/reset",
		},
		.capability = CAPA_LORA,
		.active_low = 1,
	},
	{  // gpio 1 for LORA 1.5 ref design
		.name = "LORA_CDONE",
		.pin = {
			.gpio = AT91_PIN_PA6,
			.flags = GPIOF_IN,
			.label = "lora/cdone",
		},
		.capability = CAPA_LORA,
	},
	{  // gpio 2 for LORA 1.5 ref design
		.name = "LORA_CRESET",
		.pin = {
			.gpio = AT91_PIN_PA29,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "lora/creset",
		},
		.capability = CAPA_LORA,
	},
	{
		.name = "GNSS_RESET",
		.pin = {
			.gpio = AT91_PIN_PD15,
			.flags = GPIOF_OUT_INIT_LOW,
			.label = "gnss-reset",
		},
		.capability = CAPA_GPS,
	},
	{
		.name = "GNSS_INT",
		.pin = {
			.gpio = AT91_PIN_PD19,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "gnss-int",
		},
		.capability = CAPA_GPS,
	},
	{
		.name = "ALLOW_RESET",
		.pin = {
			.gpio = AT91_PIN_PC26,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "allow-reset",
		},
		.active_low = 1,
		.capability = CAPA_SUPERCAP,
	},
	{
		.name = "POWER_FAIL",
		.pin = {
			.gpio = AT91_PIN_PC14,
			.flags = GPIOF_IN,
			.label = "power-fail",
		},
		.active_low = 1,
		.capability = CAPA_SUPERCAP,
	},
	{
		.name = "SUPERCAP_FULL",
		.pin = {
			.gpio = AT91_PIN_PC27,
			.flags = GPIOF_IN,
			.label = "supercap-full",
		},
		.capability = CAPA_SUPERCAP,
	},
        /* Cellular power supply */
	{
		.name = "RADIO_ENABLE_BBREG",
		.pin = {
			.gpio = AT91_PIN_PB12, // Radio Buck Boost
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "radio-enable-bbreg",
		},
	},
	{
		.name = "RADIO_ENABLE_LDOREG",
		.pin = {
			.gpio = AT91_PIN_PB11, // Radio LDO
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "radio-enable-ldoreg",
		},
	},
	/* LEDs */
	{
		.name = "STATUS_LED", // DEV_LED_GN
		.pin = {
			.gpio = AT91_PIN_PC25,
			.flags = GPIOF_OUT_INIT_LOW,
			.label = "led-status",
		},
		.active_low = 1,
	},
	{
		.name = "LED2", // LED2 is for LoRa status
		.pin = {
			.gpio = AT91_PIN_PC15,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "led-lora",
		},
		.active_low = 1,
	},
	{
		.name = "LED3", // LED3 is for Cellular status (Modem can directly enable it)
		.pin = {
			.gpio = AT91_PIN_PC16,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "led-cd",
		},
		.active_low = 1,
	},
	{
		.name = "LED4", // LED4 is for WiFi status
		.pin = {
			.gpio = AT91_PIN_PC20,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "led-wifi",
		},
		.active_low = 1,
	},
	{
		.name = "WLAN_EN",
		.pin = {
			.gpio = AT91_PIN_PA4,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "wlan-en",
		},
		.capability = CAPA_WIFI,
	},
	{
		.name = "WLAN_RST",
		.pin = {
			.gpio = AT91_PIN_PA3,
			.flags = GPIOF_OUT_INIT_HIGH,
			.label = "wlan-rst",
		},
		.capability = CAPA_WIFI,
	},
	{ },
};

static int radio_unconditional_shutdown_mtcap(void)
{
	struct gpio_pin *rst_pin = gpio_pin_by_attr_name("radio-reset");
	struct gpio_pin *pwrmon_pin = gpio_pin_by_attr_name("radio-power-monitor");
	int value;
	int i;

	if (!rst_pin || !pwrmon_pin) {
		return -ENODEV;
	}

	// To unconditionally shutdown the LE910, the pad HW_SHUTDOWN* must
	// be tied low for at least 200 milliseconds and then released.
	reset_gpio_pin(rst_pin, 500, 0);

	msleep(100);

	// Wait for the power off
	for (i = 0; i < 5; i++) {
		value = gpio_get_value(pwrmon_pin->pin.gpio);
		if (value != 0) {
			log_warning("radio is still on.");
			msleep(500);
			continue;
		}
		log_warning("radio has been shutdown unconditionally");
		break;
	}

	return 0;
}


/* radio control (power/reset) for mtcap */
static int radio_off_mtcap(int radio_model)
{
	// ref: Telit_LE910_Hardware_User_Guide_r6.pdf (4.3.2 Hardware Shutdown)
	struct gpio_pin *pwrmon_pin = gpio_pin_by_attr_name("radio-power-monitor");
	struct gpio_pin *onoff_pin = gpio_pin_by_attr_name("radio-power");
	struct gpio_pin *rst_pin = gpio_pin_by_attr_name("radio-reset");
	unsigned int hold_time;
	int value;
	int i;

	if (!onoff_pin || !pwrmon_pin || !rst_pin) {
		return -ENODEV;
	}

	value = gpio_get_value(pwrmon_pin->pin.gpio);
	if(value == 0) {
		log_warning("cell radio is already off");
		return 0;
	}

	log_info("turning off cell radio");

	// To turn OFF LE910 the pad ON/OFF# must be tied low for at least 2 seconds and then
	// released. Same circuitry and timing for the power on must be used. When the hold
	// time of ON/OFF# is above 2 seconds, LE910 goes into the finalization state and
	// finally will shut down PWRMON at the end of this state. The period of the
	// finalization state can differ according to the situation in which the LE910 is so it
	// cannot be fixed definitely. Normally it will be above 15 seconds later from releasing
	// ON/OFF# and DTE should monitor the status of PWRMON to see the actual power off.
	hold_time = 2500;
	if (radio_model == RADIO_LNA3 || radio_model == RADIO_LEU3) {
		
		// To turn OFF the LE910 V2 the pad ON_OFF* must be tied low for at least 3 seconds and then released.
		// ref: Telit_LE910_V2_Hardware_User_Guide_r7.pdf
		hold_time = 3500;
	}

	reset_gpio_pin(onoff_pin, hold_time, 0);
	msleep(200);  // Give time for pin to change state before inspection.

	value = 0;
	for (i = 0; i < 15; i++) {
		// check that power is low
		value = gpio_get_value(pwrmon_pin->pin.gpio);
		if (value != 0) {
			log_info("cell radio is still on. keep waiting...");
			msleep(2000);
			continue;
		}
		break;
	}

	if (value == 0) {
		log_info("cell radio has been shut down");
	}
	else {
		log_warning("cell radio is still on. performing unconditional shutdown...");
		radio_unconditional_shutdown_mtcap();
	}

	return 0;
}

static int radio_on_mtcap(int radio_model)
{
	// ref: Telit_LE910_Hardware_User_Guide_r6.pdf
	struct gpio_pin *pwrmon_pin = gpio_pin_by_attr_name("radio-power-monitor");
	struct gpio_pin *onoff_pin = gpio_pin_by_attr_name("radio-power");
	struct gpio_pin *rst_pin = gpio_pin_by_attr_name("radio-reset");
	unsigned int hold_time;
	int value;

	if (!onoff_pin || !pwrmon_pin || !rst_pin) {
		return -ENODEV;
	}

	value = gpio_get_value(pwrmon_pin->pin.gpio);
	if(value != 0) {
		log_warning("cell radio is already on");
		return 0;
	}

	log_info("turning on cell radio");

	// for LEU1 (ref: Telit_LE910_Hardware_User_Guide_r6.pdf)
	hold_time = 1500;
	if (radio_model == RADIO_LNA3 || radio_model == RADIO_LEU3) {
		
		// To turn on the LE910 V2 the pad ON_OFF* must be tied low for at least 5 seconds and then released.
		// ref: Telit_LE910_V2_Hardware_User_Guide_r7.pdf
		// ref:Telit_LE910_V2_Hardware_User_Guide_r9.pdf
		//    pg 32: When USB is connected or after firmware updating,
		//    delay must be equal at least to 10 seconds.
		hold_time = 10500;
	}

	// drive on/off pin high for at least 1 seconoff_pin
	gpio_set_value(onoff_pin->pin.gpio, 1);
	msleep(1000);

	// ON_OFF must be tied low and then released
	reset_gpio_pin(onoff_pin, hold_time, 0);
	msleep(200);  // Make sure modem has had time to move the status pin
	// check that power is high
	value = gpio_get_value(pwrmon_pin->pin.gpio);
	if(value == 0) {
		log_warning("cell radio is still off.");
	} else {
		log_info("cell radio has been turned on");
	}

	return 0;
}

static int radio_reset_mtcap(int radio_model)
{
	// ref: Telit_LE910_Hardware_User_Guide_r6.pdf
	struct gpio_pin *rst_pin = gpio_pin_by_attr_name("radio-reset");
	struct gpio_pin *onoff_pin = gpio_pin_by_attr_name("radio-power");
	unsigned int hold_time;

	if (!rst_pin || !onoff_pin)  {
		return -ENODEV;
	}

	//
	// Unconditional shutdown
	//

	log_info("performing unconditional cell radio shutdown");

	radio_unconditional_shutdown_mtcap();

	//
	// Turning on radio
	//
	log_info("turning on cell radio for reset");

	// for LEU1 (ref: Telit_LE910_Hardware_User_Guide_r6.pdf)
	hold_time = 1500;
	if (radio_model == RADIO_LNA3 || radio_model == RADIO_LEU3) {
		// To turn on the LE910 V2 the pad ON_OFF* must be tied low for at least 5 seconds and then released.
		// ref: Telit_LE910_V2_Hardware_User_Guide_r7.pdf
		// ref:Telit_LE910_V2_Hardware_User_Guide_r9.pdf
		//    pg 32: When USB is connected or after firmware updating,
		//    delay must be equal at least to 10 seconds.
                //
                // Note that a hold time of 5.5 seconds on MTCAP
                // with Verizon Firmware 20.00.12 will cause a
                // radio-reset to power the LE910-NA1 off until
                // a reload of the mts-io driver, or a reboot.
		hold_time = 10500;
	}

	// drive on/off pin high for at least 1 sec
	gpio_set_value(onoff_pin->pin.gpio, 1);
	msleep(1000);


	// drive on/off pin low for < 2 sec
	// drive on/off pin high
	log_info("turning off cell radio for reset");
	reset_gpio_pin(onoff_pin, hold_time, 0);
	log_info("Reset is complete.  Wait for power monitor pin");
	msleep(200);  // Make sure modem has had time to move the status pin
	return 0;
}

static ssize_t mts_attr_store_radio_power_mtcap(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int value;
	int err;
	int radio_model = get_radio_model_from_product_id();

	if (sscanf(buf, "%i", &value) != 1) {
		return -EINVAL;
	}

	mutex_lock(&mts_io_mutex);
	if (value == 0) {
		err = radio_off_mtcap(radio_model);
	} else {
		err = radio_on_mtcap(radio_model);
	}
	mutex_unlock(&mts_io_mutex);

	if (err) {
		return err;
	}

	return count;
}

/* bb and ldo do not exist at the same time, so set both together */
static ssize_t mts_attr_store_radio_enable_mtcap(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int value;
	int err;
	struct gpio_pin *enable_pin_bb = gpio_pin_by_attr_name("radio-enable-bbreg");
        struct gpio_pin *enable_pin_ldo = gpio_pin_by_attr_name("radio-enable-ldoreg");

	if (sscanf(buf, "%i", &value) != 1) {
            return -EINVAL;
	}

	mutex_lock(&mts_io_mutex);
	if (value == 0) {
            gpio_set_value(enable_pin_bb->pin.gpio, 0);
            gpio_set_value(enable_pin_ldo->pin.gpio, 0);
	} else {
            gpio_set_value(enable_pin_bb->pin.gpio, 1);
            gpio_set_value(enable_pin_ldo->pin.gpio, 1);
	}
	mutex_unlock(&mts_io_mutex);

	if (err) {
            return err;
	}

	return count;
}

static ssize_t mts_attr_store_radio_reset_mtcap(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int value; /* 0 = normal reset; -1 = forced reset */
	int err;
	int radio_model = get_radio_model_from_product_id();

	if (sscanf(buf, "%i", &value) != 1) {
		return -EINVAL;
	}

	if (value != 0 && value != -1) {
		return -EINVAL;
	}

	/* check reset timings is enabled */
	if (value != -1 && NULL != timings_data) {
		/* check reset timer is started */
		if (radio_reset_timer_is_start == 1) {
			log_info("cell radio reset timer is running. \n");
			return count;
		}

		/* check reset timer available is started */
		if (radio_reset_available_timer_is_start == 1) {
			del_timer(&radio_reset_available_timer);
			radio_reset_available_timer_is_start = 0;
		}

		/* reset timer not started, start it */
		mod_timer(&radio_reset_timer, jiffies + msecs_to_jiffies((timings_data[timings_data_index]) * 1000));
		//log_info("radio reset timer is start = [%d]\n", time_now_secs());
		/* save timings_data_stop_seconds */
		timings_data_stop_seconds = timings_data[timings_data_index] + time_now_secs();
		radio_reset_timer_is_start = 1;
	}

	mutex_lock(&mts_io_mutex);

	err = radio_reset_mtcap(radio_model);

	mutex_unlock(&mts_io_mutex);

	if (err) {
		return err;
	}

	return count;
}

static ssize_t mts_attr_show_radio_power_mtcap(struct device *dev,
			struct device_attribute *attr,
			char *buf)
{
	int value;
	struct gpio_pin *pwrmon_pin = gpio_pin_by_attr_name("radio-power-monitor");

	if ( !pwrmon_pin ) {
		return -ENODEV;
	}

	value = gpio_get_value(pwrmon_pin->pin.gpio);
	return sprintf(buf, "%d\n", value);
}

static ssize_t mts_attr_show_radio_enable_mtcap(struct device *dev,
			struct device_attribute *attr,
			char *buf)
{
	int value;
	struct gpio_pin *enable_pin_bb = gpio_pin_by_attr_name("radio-enable-bbreg");
	struct gpio_pin *enable_pin_ldo = gpio_pin_by_attr_name("radio-enable-ldoreg");

	if ( !enable_pin_bb ) {
		return -ENODEV;
	}
	if ( !enable_pin_ldo ) {
		return -ENODEV;
	}


	value = gpio_get_value(enable_pin_bb->pin.gpio);
	value += (gpio_get_value(enable_pin_ldo->pin.gpio) * 2);


	return sprintf(buf, "%d\n", value);
}


static DEVICE_ATTR_MTS(dev_attr_radio_reset_mtcap, "radio-reset",
		mts_attr_show_gpio_pin, mts_attr_store_radio_reset_mtcap);

static DEVICE_ATTR_MTS(dev_attr_radio_power_mtcap, "radio-power",
		mts_attr_show_radio_power_mtcap, mts_attr_store_radio_power_mtcap);

static DEVICE_ATTR_MTS(dev_attr_eth_reset_mtcap, "eth-reset",
		mts_attr_show_gpio_pin, mts_attr_store_gpio_pin);

static DEVICE_ATTR_MTS(dev_attr_led_lora_gpio_mtcap, "led-lora",
		mts_attr_show_gpio_pin, mts_attr_store_gpio_pin);

static DEVICE_ATTR_MTS(dev_attr_led_wifi_gpio_mtcap, "led-wifi",
		mts_attr_show_gpio_pin, mts_attr_store_gpio_pin);

static DEVICE_ATTR_MTS(dev_attr_wlan_en_gpio_mtcap, "wlan-en",
		mts_attr_show_gpio_pin, mts_attr_store_gpio_pin);

static DEVICE_ATTR_MTS(dev_attr_wlan_rst_gpio_mtcap, "wlan-rst",
		mts_attr_show_gpio_pin, mts_attr_store_gpio_pin);

static struct attribute *mtcap_0_0_platform_attributes[] = {
		&dev_attr_vendor_id.attr,
		&dev_attr_product_id.attr,
		&dev_attr_device_id.attr,
		&dev_attr_uuid.attr,
		&dev_attr_hw_version.attr,
		&dev_attr_imei.attr,
		&dev_attr_eth_mac.attr,
		&dev_attr_has_radio.attr,
		&dev_attr_reset.attr,
		&dev_attr_reset_monitor.attr,
		&dev_attr_reset_monitor_intervals.attr,

		&dev_attr_eth_reset_mtcap.attr,
		&dev_attr_led_status.attr,
		&dev_attr_led_cd_gpio.attr,
		&dev_attr_led_lora_gpio_mtcap.attr,
		&dev_attr_led_wifi_gpio_mtcap.attr,

		/* Set to NULL if no radio -- should be 1st radio attribute */
		&dev_attr_radio_power_mtcap.attr,
		&dev_attr_radio_reset_mtcap.attr,

		&dev_attr_radio_reset_backoffs.attr,
		&dev_attr_radio_reset_backoff_index.attr,
		&dev_attr_radio_reset_backoff_seconds.attr,

		NULL,
};

static int 
is_radio_power_attr_mtcap(struct attribute *attr)
{
    return (attr ==  &dev_attr_radio_power_mtcap.attr);
}

static struct attribute_group mtcap_0_0_platform_attribute_group = {
	.attrs = mtcap_0_0_platform_attributes
};

//
// on-board LORA attributes are to be stored in the lora/ sub-directory
//
//
static DEVICE_ATTR_MTS(dev_attr_lora_reset_mtcap, "reset",
		mts_attr_show_lora_gpio_pin, mts_attr_store_lora_gpio_pin);

static DEVICE_ATTR_RO_MTS(dev_attr_lora_cdone_mtcap, "cdone",
		mts_attr_show_lora_gpio_pin);

static DEVICE_ATTR_MTS(dev_attr_lora_creset_mtcap, "creset",
		mts_attr_show_lora_gpio_pin, mts_attr_store_lora_gpio_pin);

static DEVICE_ATTR_RO_MTS(dev_attr_lora_eui_mtcap, "eui",
		mts_attr_show_lora_product_info);

static DEVICE_ATTR_RO_MTS(dev_attr_lora_product_id_mtcap, "product-id",
		mts_attr_show_lora_product_info);

static DEVICE_ATTR_RO_MTS(dev_attr_lora_hw_version_mtcap, "hw-version",
		mts_attr_show_lora_product_info);

static struct attribute *mtcap_0_0_lora_attributes[] = {
		&dev_attr_lora_eui_mtcap.attr,
		&dev_attr_lora_product_id_mtcap.attr,
		&dev_attr_lora_hw_version_mtcap.attr,
		&dev_attr_lora_reset_mtcap.attr,
		&dev_attr_lora_cdone_mtcap.attr,
		&dev_attr_lora_creset_mtcap.attr,
		NULL,
};

static struct attribute_group mtcap_0_0_lora_attribute_group = {
	.attrs = mtcap_0_0_lora_attributes
};

// Reset for LoRa firmware is done using the I2C bus
// on the MTCDTIPHP LoRa board.
static struct attribute *mtcdtiphp_0_0_lora_attributes[] = {
		&dev_attr_lora_eui_mtcap.attr,
		&dev_attr_lora_product_id_mtcap.attr,
		&dev_attr_lora_hw_version_mtcap.attr,
		NULL,
};

static struct attribute_group mtcdtiphp_0_0_lora_attribute_group = {
	.attrs = mtcdtiphp_0_0_lora_attributes
};

static struct attribute *mtcap_0_3_gnss_attributes[] = {
		&dev_attr_gnss_reset.attr,
		&dev_attr_gnss_int.attr,
};

static DEVICE_ATTR_MTS(dev_attr_supercap_allow_reset_mtcap, "allow-reset",
	mts_attr_show_gpio_pin, mts_attr_store_gpio_pin);

static DEVICE_ATTR_RO_MTS(dev_attr_supercap_power_fail_mtcap, "power-fail",
	mts_attr_show_gpio_pin);

static DEVICE_ATTR_RO_MTS(dev_attr_supercap_supercap_full_mtcap, "supercap-full",
	mts_attr_show_gpio_pin);

static DEVICE_ATTR_MTS(dev_attr_radio_enable_mtcap, "radio-enable",
	mts_attr_show_radio_enable_mtcap, mts_attr_store_radio_enable_mtcap);

static struct attribute *mtcap_0_3_supercap_attributes[] = {
		&dev_attr_supercap_allow_reset_mtcap.attr,
		&dev_attr_supercap_power_fail_mtcap.attr,
		&dev_attr_supercap_supercap_full_mtcap.attr,
		&dev_attr_supercap_monitor.attr,
};

static struct attribute *mtcap_0_2_enable_radio_attribute[] = {
        &dev_attr_radio_enable_mtcap.attr,
};

static struct attribute *mtcap_0_0_wifi_attributes[] = {
	&dev_attr_wlan_en_gpio_mtcap.attr,
	&dev_attr_wlan_rst_gpio_mtcap.attr,
};