From 6100eadd4bc610ba6002e4a6f29b1d1423efdde5 Mon Sep 17 00:00:00 2001 From: Kumar Gala Date: Tue, 5 Jul 2022 10:04:33 -0500 Subject: [PATCH] modem: hl7800: Update driver to use gpio_dt_spec Simplify the implementation by using gpio_dt_spec. Signed-off-by: Kumar Gala --- drivers/modem/hl7800.c | 224 ++++++++++++++++++++--------------------- 1 file changed, 109 insertions(+), 115 deletions(-) diff --git a/drivers/modem/hl7800.c b/drivers/modem/hl7800.c index e2c3c5a697f..1911f60b0e2 100644 --- a/drivers/modem/hl7800.c +++ b/drivers/modem/hl7800.c @@ -137,18 +137,6 @@ enum hl7800_lpm { HL7800_LPM_PSM, }; -struct mdm_control_pinconfig { - char *dev_name; - gpio_pin_t pin; - gpio_flags_t config; - gpio_flags_t irq_config; -}; - -#define PINCONFIG(name_, pin_, config_, irq_config_) \ - { \ - .dev_name = name_, .pin = pin_, .config = config_, .irq_config = irq_config_ \ - } - /* pin settings */ enum mdm_control_pins { MDM_RESET = 0, @@ -193,41 +181,6 @@ struct xmodem_packet { }; #endif -static const struct mdm_control_pinconfig pinconfig[] = { - /* MDM_RESET */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_reset_gpios), DT_INST_GPIO_PIN(0, mdm_reset_gpios), - (GPIO_OUTPUT | GPIO_OPEN_DRAIN), 0), - - /* MDM_WAKE */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_wake_gpios), DT_INST_GPIO_PIN(0, mdm_wake_gpios), - (GPIO_OUTPUT | GPIO_OPEN_SOURCE), 0), - - /* MDM_PWR_ON */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_pwr_on_gpios), DT_INST_GPIO_PIN(0, mdm_pwr_on_gpios), - (GPIO_OUTPUT | GPIO_OPEN_DRAIN), 0), - - /* MDM_FAST_SHUTD */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_fast_shutd_gpios), - DT_INST_GPIO_PIN(0, mdm_fast_shutd_gpios), (GPIO_OUTPUT | GPIO_OPEN_DRAIN), - 0), - - /* MDM_VGPIO */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_vgpio_gpios), DT_INST_GPIO_PIN(0, mdm_vgpio_gpios), - GPIO_INPUT, GPIO_INT_EDGE_BOTH), - - /* MDM_UART_DSR */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_uart_dsr_gpios), - DT_INST_GPIO_PIN(0, mdm_uart_dsr_gpios), GPIO_INPUT, GPIO_INT_EDGE_BOTH), - - /* MDM_UART_CTS */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_uart_cts_gpios), - DT_INST_GPIO_PIN(0, mdm_uart_cts_gpios), GPIO_INPUT, GPIO_INT_EDGE_BOTH), - - /* MDM_GPIO6 */ - PINCONFIG(DT_INST_GPIO_LABEL(0, mdm_gpio6_gpios), DT_INST_GPIO_PIN(0, mdm_gpio6_gpios), - GPIO_INPUT, GPIO_INT_EDGE_BOTH), -}; - #define MDM_UART_DEV DEVICE_DT_GET(DT_INST_BUS(0)) #define MDM_WAKE_ASSERTED 1 /* Asserted keeps the module awake */ @@ -460,6 +413,10 @@ struct stale_socket { #define NO_ID_RESP_CMD_MAX_LENGTH 32 +struct hl7800_config { + struct gpio_dt_spec gpio[MAX_MDM_CONTROL_PINS]; +}; + struct hl7800_iface_ctx { struct net_if *iface; uint8_t mac_addr[6]; @@ -478,7 +435,6 @@ struct hl7800_iface_ctx { bool search_no_id_resp; /* GPIO PORT devices */ - const struct device *gpio_port_dev[MAX_MDM_CONTROL_PINS]; struct gpio_callback mdm_vgpio_cb; struct gpio_callback mdm_uart_dsr_cb; struct gpio_callback mdm_gpio6_cb; @@ -581,6 +537,18 @@ struct cmd_handler { static sys_slist_t hl7800_event_callback_list = SYS_SLIST_STATIC_INIT(&hl7800_event_callback_list); +const static struct hl7800_config hl7800_cfg = { + .gpio = { + GPIO_DT_SPEC_INST_GET(0, mdm_reset_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_wake_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_pwr_on_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_fast_shutd_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_vgpio_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_uart_dsr_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_uart_cts_gpios), + GPIO_DT_SPEC_INST_GET(0, mdm_gpio6_gpios), + }, +}; static struct hl7800_iface_ctx ictx; static size_t hl7800_read_rx(struct net_buf **buf); @@ -668,12 +636,13 @@ static bool convert_time_string_to_struct(struct tm *tm, int32_t *offset, char *time_string); static int modem_reset_and_configure(void); -static int read_pin(int default_state, const struct device *port, gpio_pin_t pin) +static int read_pin(int default_state, const struct gpio_dt_spec *spec) { - int state = gpio_pin_get(port, pin); + int state = gpio_pin_get_dt(spec); if (state < 0) { - LOG_ERR("Unable to read port: %s pin: %d status: %d", port->name, pin, state); + LOG_ERR("Unable to read port: %s pin: %d status: %d", + spec->port->name, spec->pin, state); state = default_state; } @@ -683,11 +652,11 @@ static int read_pin(int default_state, const struct device *port, gpio_pin_t pin #ifdef CONFIG_MODEM_HL7800_LOW_POWER_MODE static bool is_cmd_ready(void) { - ictx.vgpio_state = read_pin(0, ictx.gpio_port_dev[MDM_VGPIO], pinconfig[MDM_VGPIO].pin); + ictx.vgpio_state = read_pin(0, &hl7800_cfg.gpio[MDM_VGPIO]); - ictx.gpio6_state = read_pin(0, ictx.gpio_port_dev[MDM_GPIO6], pinconfig[MDM_GPIO6].pin); + ictx.gpio6_state = read_pin(0, &hl7800_cfg.gpio[MDM_GPIO6]); - ictx.cts_state = read_pin(1, ictx.gpio_port_dev[MDM_UART_CTS], pinconfig[MDM_UART_CTS].pin); + ictx.cts_state = read_pin(1, &hl7800_cfg.gpio[MDM_UART_CTS]); return ictx.vgpio_state && ictx.gpio6_state && !ictx.cts_state; } @@ -901,7 +870,7 @@ static void modem_assert_wake(bool assert) state = MDM_WAKE_NOT_ASSERTED; } - gpio_pin_set(ictx.gpio_port_dev[MDM_WAKE], pinconfig[MDM_WAKE].pin, state); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_WAKE], state); if (ictx.wake_up_callback != NULL) { ictx.wake_up_callback(state); @@ -912,13 +881,10 @@ static void modem_assert_pwr_on(bool assert) { if (assert) { HL7800_IO_DBG_LOG("MDM_PWR_ON -> ASSERTED"); - gpio_pin_set(ictx.gpio_port_dev[MDM_PWR_ON], - pinconfig[MDM_PWR_ON].pin, MDM_PWR_ON_ASSERTED); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_PWR_ON], MDM_PWR_ON_ASSERTED); } else { HL7800_IO_DBG_LOG("MDM_PWR_ON -> NOT_ASSERTED"); - gpio_pin_set(ictx.gpio_port_dev[MDM_PWR_ON], - pinconfig[MDM_PWR_ON].pin, - MDM_PWR_ON_NOT_ASSERTED); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_PWR_ON], MDM_PWR_ON_NOT_ASSERTED); } } @@ -926,14 +892,10 @@ static void modem_assert_fast_shutd(bool assert) { if (assert) { HL7800_IO_DBG_LOG("MDM_FAST_SHUTD -> ASSERTED"); - gpio_pin_set(ictx.gpio_port_dev[MDM_FAST_SHUTD], - pinconfig[MDM_FAST_SHUTD].pin, - MDM_FAST_SHUTD_ASSERTED); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_FAST_SHUTD], MDM_FAST_SHUTD_ASSERTED); } else { HL7800_IO_DBG_LOG("MDM_FAST_SHUTD -> NOT_ASSERTED"); - gpio_pin_set(ictx.gpio_port_dev[MDM_FAST_SHUTD], - pinconfig[MDM_FAST_SHUTD].pin, - MDM_FAST_SHUTD_NOT_ASSERTED); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_FAST_SHUTD], MDM_FAST_SHUTD_NOT_ASSERTED); } } @@ -4741,7 +4703,7 @@ static void mdm_vgpio_work_cb(struct k_work *item) void mdm_vgpio_callback_isr(const struct device *port, struct gpio_callback *cb, uint32_t pins) { - ictx.vgpio_state = read_pin(1, ictx.gpio_port_dev[MDM_VGPIO], pinconfig[MDM_VGPIO].pin); + ictx.vgpio_state = read_pin(1, &hl7800_cfg.gpio[MDM_VGPIO]); HL7800_IO_DBG_LOG("VGPIO:%d", ictx.vgpio_state); if (!ictx.vgpio_state) { prepare_io_for_reset(); @@ -4768,7 +4730,7 @@ void mdm_vgpio_callback_isr(const struct device *port, struct gpio_callback *cb, void mdm_uart_dsr_callback_isr(const struct device *port, struct gpio_callback *cb, uint32_t pins) { - ictx.dsr_state = read_pin(1, ictx.gpio_port_dev[MDM_UART_DSR], pinconfig[MDM_UART_DSR].pin); + ictx.dsr_state = read_pin(1, &hl7800_cfg.gpio[MDM_UART_DSR]); HL7800_IO_DBG_LOG("MDM_UART_DSR:%d", ictx.dsr_state); } @@ -4792,7 +4754,7 @@ void mdm_gpio6_callback_isr(const struct device *port, struct gpio_callback *cb, uint32_t pins) { #ifdef CONFIG_MODEM_HL7800_LOW_POWER_MODE - ictx.gpio6_state = read_pin(1, ictx.gpio_port_dev[MDM_GPIO6], pinconfig[MDM_GPIO6].pin); + ictx.gpio6_state = read_pin(1, &hl7800_cfg.gpio[MDM_GPIO6]); HL7800_IO_DBG_LOG("MDM_GPIO6:%d", ictx.gpio6_state); if (!ictx.gpio6_state) { /* HL7800 is not awake, shut down UART to save power */ @@ -4821,7 +4783,7 @@ void mdm_gpio6_callback_isr(const struct device *port, struct gpio_callback *cb, /** * @brief Short spikes in CTS can be removed in the signal used by the application */ -static int glitch_filter(int default_state, const struct device *port, gpio_pin_t pin, +static int glitch_filter(int default_state, const struct gpio_dt_spec *spec, uint32_t usec_to_wait, uint32_t max_iterations) { int i = 0; @@ -4829,9 +4791,9 @@ static int glitch_filter(int default_state, const struct device *port, gpio_pin_ int state2; do { - state1 = read_pin(-1, port, pin); + state1 = read_pin(-1, spec); k_busy_wait(usec_to_wait); - state2 = read_pin(-1, port, pin); + state2 = read_pin(-1, spec); i += 1; } while (((state1 != state2) || (state1 < 0) || (state2 < 0)) && (i < max_iterations)); @@ -4839,7 +4801,7 @@ static int glitch_filter(int default_state, const struct device *port, gpio_pin_ LOG_WRN("glitch filter max iterations exceeded %d", i); if (state1 < 0) { if (state2 < 0) { - state1 = read_pin(default_state, port, pin); + state1 = read_pin(default_state, spec); } else { state1 = state2; } @@ -4856,7 +4818,7 @@ void mdm_uart_cts_callback(const struct device *port, struct gpio_callback *cb, ARG_UNUSED(pins); ictx.cts_state = - glitch_filter(0, ictx.gpio_port_dev[MDM_UART_CTS], pinconfig[MDM_UART_CTS].pin, + glitch_filter(0, &hl7800_cfg.gpio[MDM_UART_CTS], CONFIG_MODEM_HL7800_CTS_FILTER_US, CONFIG_MODEM_HL7800_CTS_FILTER_MAX_ITERATIONS); @@ -4892,8 +4854,7 @@ static void modem_reset(void) LOG_INF("Modem Reset"); /* Hard reset the modem */ - gpio_pin_set(ictx.gpio_port_dev[MDM_RESET], pinconfig[MDM_RESET].pin, - MDM_RESET_ASSERTED); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_RESET], MDM_RESET_ASSERTED); /* >20 milliseconds required for reset low */ k_sleep(MDM_RESET_LOW_TIME); @@ -4915,8 +4876,7 @@ static void modem_reset(void) static void modem_run(void) { LOG_INF("Modem Run"); - gpio_pin_set(ictx.gpio_port_dev[MDM_RESET], pinconfig[MDM_RESET].pin, - MDM_RESET_NOT_ASSERTED); + gpio_pin_set_dt(&hl7800_cfg.gpio[MDM_RESET], MDM_RESET_NOT_ASSERTED); k_sleep(MDM_RESET_HIGH_TIME); allow_sleep(false); } @@ -6103,10 +6063,6 @@ static int hl7800_init(const struct device *dev) LOG_DBG("HL7800 Init"); - /* check for valid pinconfig */ - __ASSERT(ARRAY_SIZE(pinconfig) == MAX_MDM_CONTROL_PINS, - "Incorrect modem pinconfig!"); - /* Prevent the network interface from starting until * the modem has been initialized * because the modem may not have a valid SIM card. @@ -6159,21 +6115,67 @@ static int hl7800_init(const struct device *dev) /* setup port devices and pin directions */ for (i = 0; i < MAX_MDM_CONTROL_PINS; i++) { - ictx.gpio_port_dev[i] = - device_get_binding(pinconfig[i].dev_name); - if (!ictx.gpio_port_dev[i]) { - LOG_ERR("gpio port (%s) not found!", - pinconfig[i].dev_name); + if (!device_is_ready(hl7800_cfg.gpio[i].port)) { + LOG_ERR("gpio port (%s) not ready!", + hl7800_cfg.gpio[i].port->name); return -ENODEV; } + } - ret = gpio_pin_configure(ictx.gpio_port_dev[i], pinconfig[i].pin, - pinconfig[i].config); - if (ret) { - LOG_ERR("Error configuring IO %s %d err: %d!", pinconfig[i].dev_name, - pinconfig[i].pin, ret); - return ret; - } + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_RESET], GPIO_OUTPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_RESET %d err: %d!", + hl7800_cfg.gpio[MDM_RESET].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_WAKE], GPIO_OUTPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_WAKE %d err: %d!", + hl7800_cfg.gpio[MDM_WAKE].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_PWR_ON], GPIO_OUTPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_PWR_ON %d err: %d!", + hl7800_cfg.gpio[MDM_PWR_ON].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_FAST_SHUTD], GPIO_OUTPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_FAST_SHUTD %d err: %d!", + hl7800_cfg.gpio[MDM_FAST_SHUTD].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_VGPIO], GPIO_INPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_VGPIO %d err: %d!", + hl7800_cfg.gpio[MDM_VGPIO].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_UART_DSR], GPIO_INPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_UART_DSR %d err: %d!", + hl7800_cfg.gpio[MDM_UART_DSR].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_UART_CTS], GPIO_INPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_UART_CTS %d err: %d!", + hl7800_cfg.gpio[MDM_UART_CTS].pin, ret); + return ret; + } + + ret = gpio_pin_configure_dt(&hl7800_cfg.gpio[MDM_GPIO6], GPIO_INPUT); + if (ret) { + LOG_ERR("Error configuring IO MDM_GPIO6 %d err: %d!", + hl7800_cfg.gpio[MDM_GPIO6].pin, ret); + return ret; } /* when this driver starts, the UART peripheral is already enabled */ @@ -6192,16 +6194,14 @@ static int hl7800_init(const struct device *dev) /* setup input pin callbacks */ /* VGPIO */ gpio_init_callback(&ictx.mdm_vgpio_cb, mdm_vgpio_callback_isr, - BIT(pinconfig[MDM_VGPIO].pin)); - ret = gpio_add_callback(ictx.gpio_port_dev[MDM_VGPIO], + BIT(hl7800_cfg.gpio[MDM_VGPIO].pin)); + ret = gpio_add_callback(hl7800_cfg.gpio[MDM_VGPIO].port, &ictx.mdm_vgpio_cb); if (ret) { LOG_ERR("Cannot setup vgpio callback! (%d)", ret); return ret; } - ret = gpio_pin_interrupt_configure(ictx.gpio_port_dev[MDM_VGPIO], - pinconfig[MDM_VGPIO].pin, - pinconfig[MDM_VGPIO].irq_config); + ret = gpio_pin_interrupt_configure_dt(&hl7800_cfg.gpio[MDM_VGPIO], GPIO_INT_EDGE_BOTH); if (ret) { LOG_ERR("Error config vgpio interrupt! (%d)", ret); return ret; @@ -6209,16 +6209,14 @@ static int hl7800_init(const struct device *dev) /* UART DSR */ gpio_init_callback(&ictx.mdm_uart_dsr_cb, mdm_uart_dsr_callback_isr, - BIT(pinconfig[MDM_UART_DSR].pin)); - ret = gpio_add_callback(ictx.gpio_port_dev[MDM_UART_DSR], + BIT(hl7800_cfg.gpio[MDM_UART_DSR].pin)); + ret = gpio_add_callback(hl7800_cfg.gpio[MDM_UART_DSR].port, &ictx.mdm_uart_dsr_cb); if (ret) { LOG_ERR("Cannot setup uart dsr callback! (%d)", ret); return ret; } - ret = gpio_pin_interrupt_configure(ictx.gpio_port_dev[MDM_UART_DSR], - pinconfig[MDM_UART_DSR].pin, - pinconfig[MDM_UART_DSR].irq_config); + ret = gpio_pin_interrupt_configure_dt(&hl7800_cfg.gpio[MDM_UART_DSR], GPIO_INT_EDGE_BOTH); if (ret) { LOG_ERR("Error config uart dsr interrupt! (%d)", ret); return ret; @@ -6226,16 +6224,14 @@ static int hl7800_init(const struct device *dev) /* GPIO6 */ gpio_init_callback(&ictx.mdm_gpio6_cb, mdm_gpio6_callback_isr, - BIT(pinconfig[MDM_GPIO6].pin)); - ret = gpio_add_callback(ictx.gpio_port_dev[MDM_GPIO6], + BIT(hl7800_cfg.gpio[MDM_GPIO6].pin)); + ret = gpio_add_callback(hl7800_cfg.gpio[MDM_GPIO6].port, &ictx.mdm_gpio6_cb); if (ret) { LOG_ERR("Cannot setup gpio6 callback! (%d)", ret); return ret; } - ret = gpio_pin_interrupt_configure(ictx.gpio_port_dev[MDM_GPIO6], - pinconfig[MDM_GPIO6].pin, - pinconfig[MDM_GPIO6].irq_config); + ret = gpio_pin_interrupt_configure_dt(&hl7800_cfg.gpio[MDM_GPIO6], GPIO_INT_EDGE_BOTH); if (ret) { LOG_ERR("Error config gpio6 interrupt! (%d)", ret); return ret; @@ -6243,16 +6239,14 @@ static int hl7800_init(const struct device *dev) /* UART CTS */ gpio_init_callback(&ictx.mdm_uart_cts_cb, mdm_uart_cts_callback, - BIT(pinconfig[MDM_UART_CTS].pin)); - ret = gpio_add_callback(ictx.gpio_port_dev[MDM_UART_CTS], + BIT(hl7800_cfg.gpio[MDM_UART_CTS].pin)); + ret = gpio_add_callback(hl7800_cfg.gpio[MDM_UART_CTS].port, &ictx.mdm_uart_cts_cb); if (ret) { LOG_ERR("Cannot setup uart cts callback! (%d)", ret); return ret; } - ret = gpio_pin_interrupt_configure(ictx.gpio_port_dev[MDM_UART_CTS], - pinconfig[MDM_UART_CTS].pin, - pinconfig[MDM_UART_CTS].irq_config); + ret = gpio_pin_interrupt_configure_dt(&hl7800_cfg.gpio[MDM_UART_CTS], GPIO_INT_EDGE_BOTH); if (ret) { LOG_ERR("Error config uart cts interrupt! (%d)", ret); return ret; @@ -6314,5 +6308,5 @@ static struct net_if_api api_funcs = { }; NET_DEVICE_DT_INST_OFFLOAD_DEFINE(0, hl7800_init, NULL, &ictx, - NULL, CONFIG_MODEM_HL7800_INIT_PRIORITY, + &hl7800_cfg, CONFIG_MODEM_HL7800_INIT_PRIORITY, &api_funcs, MDM_MTU);