From dc83e06e8dffb228b56879f9150f63d36546e330 Mon Sep 17 00:00:00 2001 From: Daniel Drown Date: Fri, 17 Jun 2016 20:25:59 -0500 Subject: [PATCH] switch from device tree to module parameters --- drivers/pps/clients/pps-gpio.c | 172 +++++++++++++++------------------ 1 file changed, 79 insertions(+), 93 deletions(-) diff --git a/drivers/pps/clients/pps-gpio.c b/drivers/pps/clients/pps-gpio.c index bf8208174494a5..6624405dbb8dd7 100644 --- a/drivers/pps/clients/pps-gpio.c +++ b/drivers/pps/clients/pps-gpio.c @@ -41,14 +41,23 @@ #define AMLGPIO_IRQ_BASE 96 /* Info for each registered platform device */ -struct pps_gpio_device_data { +static struct pps_gpio_device_data { int irq; /* IRQ used as PPS source */ struct pps_device *pps; /* PPS source device */ struct pps_source_info info; /* PPS source information */ - bool assert_falling_edge; bool capture_clear; unsigned int gpio_pin; -}; +} pps_data; + +// Default GPIO. Use parameters during module load to override. +// note: this only handles one instance of pps-gpio. If you want more, use the devicetree version +static int gpio_pin = 238; // GPIOX_10 / pin 12 +module_param(gpio_pin, int, S_IRUSR | S_IRGRP | S_IROTH); +MODULE_PARM_DESC(gpio_pin, "GPIO pin number (\"Export GPIO\" type), default=238 (GPIOX_10 / pin 12)"); + +static int assert_falling_edge = 0; +module_param(assert_falling_edge, int, S_IRUSR | S_IRGRP | S_IROTH); +MODULE_PARM_DESC(assert_falling_edge, "use the falling edge instead of the rising edge, default=0 (rising)"); /* * Report the PPS event @@ -56,23 +65,20 @@ struct pps_gpio_device_data { static irqreturn_t pps_gpio_irq_handler(int irq, void *data) { - const struct pps_gpio_device_data *info; struct pps_event_time ts; int rising_edge; /* Get the time stamp first */ pps_get_ts(&ts); - info = data; - - rising_edge = gpio_get_value(info->gpio_pin); - if ((rising_edge && !info->assert_falling_edge) || - (!rising_edge && info->assert_falling_edge)) - pps_event(info->pps, &ts, PPS_CAPTUREASSERT, NULL); - else if (info->capture_clear && - ((rising_edge && info->assert_falling_edge) || - (!rising_edge && !info->assert_falling_edge))) - pps_event(info->pps, &ts, PPS_CAPTURECLEAR, NULL); + rising_edge = gpio_get_value(pps_data.gpio_pin); + if ((rising_edge && !assert_falling_edge) || + (!rising_edge && assert_falling_edge)) + pps_event(pps_data.pps, &ts, PPS_CAPTUREASSERT, NULL); + else if (pps_data.capture_clear && + ((rising_edge && assert_falling_edge) || + (!rising_edge && !assert_falling_edge))) + pps_event(pps_data.pps, &ts, PPS_CAPTURECLEAR, NULL); return IRQ_HANDLED; } @@ -80,7 +86,7 @@ static irqreturn_t pps_gpio_irq_handler(int irq, void *data) static unsigned long get_irqf_trigger_flags(const struct pps_gpio_device_data *data) { - unsigned long flags = data->assert_falling_edge ? + unsigned long flags = assert_falling_edge ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING; if (data->capture_clear) { @@ -91,7 +97,7 @@ get_irqf_trigger_flags(const struct pps_gpio_device_data *data) return flags; } -static int pps_gpio_irq_setup(unsigned int gpio_pin, bool assert_falling_edge) +static int pps_gpio_irq_setup(unsigned int gpio_pin) { struct gpio_chip *chip; int ret; @@ -118,131 +124,111 @@ static int pps_gpio_irq_setup(unsigned int gpio_pin, bool assert_falling_edge) return -EINVAL; } -static int pps_gpio_probe(struct platform_device *pdev) +static void pps_gpio_release(struct device *dev) { + // does nothing, everything is allocated as part of the module +} + +static struct device pps_gpio_dev = { + .id = 0, + .parent = &platform_bus, + .release = &pps_gpio_release +}; + +static int __init pps_gpio_init(void) { - struct pps_gpio_device_data *data; - const char *gpio_label; int ret; int pps_default_params; - const struct pps_gpio_platform_data *pdata = pdev->dev.platform_data; - struct device_node *np = pdev->dev.of_node; - - /* allocate space for device info */ - data = devm_kzalloc(&pdev->dev, sizeof(struct pps_gpio_device_data), - GFP_KERNEL); - if (!data) - return -ENOMEM; - - if (pdata) { - data->gpio_pin = pdata->gpio_pin; - gpio_label = pdata->gpio_label; - - data->assert_falling_edge = pdata->assert_falling_edge; - data->capture_clear = pdata->capture_clear; - } else { - ret = of_get_gpio(np, 0); - if (ret < 0) { - dev_err(&pdev->dev, "failed to get GPIO from device tree\n"); - return ret; - } - data->gpio_pin = ret; - gpio_label = PPS_GPIO_NAME; - - if (of_get_property(np, "assert-falling-edge", NULL)) - data->assert_falling_edge = true; + + /* register the device */ + ret = dev_set_name(&pps_gpio_dev, "%s%d", PPS_GPIO_NAME, pps_gpio_dev.id); + if(ret < 0) { + pr_err("dev_set_name failed with %d\n", ret); + return ret; + } + ret = device_register(&pps_gpio_dev); + if(ret < 0) { + pr_err("device_register failed with %d\n", ret); + return ret; } + pps_data.gpio_pin = gpio_pin; + /* GPIO setup */ - ret = devm_gpio_request(&pdev->dev, data->gpio_pin, gpio_label); + ret = devm_gpio_request(&pps_gpio_dev, pps_data.gpio_pin, "PPS-GPIO"); if (ret) { - dev_err(&pdev->dev, "failed to request GPIO %u\n", - data->gpio_pin); + dev_err(&pps_gpio_dev, "failed to request GPIO %u\n", + pps_data.gpio_pin); return ret; } - ret = gpio_direction_input(data->gpio_pin); + ret = gpio_direction_input(pps_data.gpio_pin); if (ret) { - dev_err(&pdev->dev, "failed to set pin direction\n"); + dev_err(&pps_gpio_dev, "failed to set pin direction\n"); return -EINVAL; } /* IRQ setup */ - ret = pps_gpio_irq_setup(data->gpio_pin, data->assert_falling_edge); + ret = pps_gpio_irq_setup(pps_data.gpio_pin); if (ret < 0) { - dev_err(&pdev->dev, "failed to map GPIO to IRQ: %d\n", ret); + dev_err(&pps_gpio_dev, "failed to map GPIO to IRQ: %d\n", ret); return -EINVAL; } - data->irq = ret; + pps_data.irq = ret; /* initialize PPS specific parts of the bookkeeping data structure. */ - data->info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | + pps_data.info.mode = PPS_CAPTUREASSERT | PPS_OFFSETASSERT | PPS_ECHOASSERT | PPS_CANWAIT | PPS_TSFMT_TSPEC; - if (data->capture_clear) - data->info.mode |= PPS_CAPTURECLEAR | PPS_OFFSETCLEAR | + if (pps_data.capture_clear) + pps_data.info.mode |= PPS_CAPTURECLEAR | PPS_OFFSETCLEAR | PPS_ECHOCLEAR; - data->info.owner = THIS_MODULE; - snprintf(data->info.name, PPS_MAX_NAME_LEN - 1, "%s.%d", - pdev->name, pdev->id); + pps_data.info.owner = THIS_MODULE; + snprintf(pps_data.info.name, PPS_MAX_NAME_LEN - 1, "%s.%d", + PPS_GPIO_NAME, pps_gpio_dev.id); /* register PPS source */ pps_default_params = PPS_CAPTUREASSERT | PPS_OFFSETASSERT; - if (data->capture_clear) + if (pps_data.capture_clear) pps_default_params |= PPS_CAPTURECLEAR | PPS_OFFSETCLEAR; - data->pps = pps_register_source(&data->info, pps_default_params); - if (data->pps == NULL) { - dev_err(&pdev->dev, "failed to register IRQ %d as PPS source\n", - data->irq); + pps_data.pps = pps_register_source(&pps_data.info, pps_default_params); + if (pps_data.pps == NULL) { + dev_err(&pps_gpio_dev, "failed to register IRQ %d as PPS source\n", + pps_data.irq); return -EINVAL; } /* register IRQ interrupt handler */ - ret = devm_request_irq(&pdev->dev, data->irq, pps_gpio_irq_handler, - get_irqf_trigger_flags(data), data->info.name, data); + ret = devm_request_irq(&pps_gpio_dev, pps_data.irq, pps_gpio_irq_handler, + get_irqf_trigger_flags(&pps_data), pps_data.info.name, NULL); if (ret) { - pps_unregister_source(data->pps); - dev_err(&pdev->dev, "failed to acquire IRQ %d\n", data->irq); + pps_unregister_source(pps_data.pps); + dev_err(&pps_gpio_dev, "failed to acquire IRQ %d\n", pps_data.irq); return -EINVAL; } - platform_set_drvdata(pdev, data); - dev_info(data->pps->dev, "Registered IRQ %d as PPS source\n", - data->irq); + dev_info(pps_data.pps->dev, "Registered IRQ %d as PPS source\n", + pps_data.irq); return 0; } -static int pps_gpio_remove(struct platform_device *pdev) +static void __exit pps_gpio_exit(void) { unsigned int gpio_pin; int irq_banks[2] = {0, 0}; - struct pps_gpio_device_data *data = platform_get_drvdata(pdev); // gpio_to_irq translates from global GPIO # to chip offset, which meson_free_irq wants - gpio_pin = gpio_to_irq(data->gpio_pin); + gpio_pin = gpio_to_irq(pps_data.gpio_pin); meson_free_irq(gpio_pin, irq_banks); - pps_unregister_source(data->pps); - dev_info(&pdev->dev, "removed IRQ %d as PPS source\n", data->irq); - return 0; + pps_unregister_source(pps_data.pps); + dev_info(&pps_gpio_dev, "removed IRQ %d as PPS source\n", pps_data.irq); + + device_unregister(&pps_gpio_dev); } -static const struct of_device_id pps_gpio_dt_ids[] = { - { .compatible = "pps-gpio", }, - { /* sentinel */ } -}; -MODULE_DEVICE_TABLE(of, pps_gpio_dt_ids); - -static struct platform_driver pps_gpio_driver = { - .probe = pps_gpio_probe, - .remove = pps_gpio_remove, - .driver = { - .name = PPS_GPIO_NAME, - .owner = THIS_MODULE, - .of_match_table = pps_gpio_dt_ids, - }, -}; +module_init(pps_gpio_init); +module_exit(pps_gpio_exit); -module_platform_driver(pps_gpio_driver); MODULE_AUTHOR("Ricardo Martins "); MODULE_AUTHOR("James Nuss "); MODULE_DESCRIPTION("Use GPIO pin as PPS source");