net/rfkill/rfkill-gpio.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) 2011, NVIDIA Corporation.
0004  */
0005
0006 #include <linux/init.h>
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/mod_devicetable.h>
0010 #include <linux/rfkill.h>
0011 #include <linux/platform_device.h>
0012 #include <linux/clk.h>
0013 #include <linux/slab.h>
0014 #include <linux/acpi.h>
0015 #include <linux/gpio/consumer.h>
0016
0017 struct rfkill_gpio_data {
0018     const char      *name;
0019     enum rfkill_type    type;
0020     struct gpio_desc    *reset_gpio;
0021     struct gpio_desc    *shutdown_gpio;
0022
0023     struct rfkill       *rfkill_dev;
0024     struct clk      *clk;
0025
0026     bool            clk_enabled;
0027 };
0028
0029 static int rfkill_gpio_set_power(void *data, bool blocked)
0030 {
0031     struct rfkill_gpio_data *rfkill = data;
0032
0033     if (!blocked && !IS_ERR(rfkill->clk) && !rfkill->clk_enabled)
0034         clk_enable(rfkill->clk);
0035
0036     gpiod_set_value_cansleep(rfkill->shutdown_gpio, !blocked);
0037     gpiod_set_value_cansleep(rfkill->reset_gpio, !blocked);
0038
0039     if (blocked && !IS_ERR(rfkill->clk) && rfkill->clk_enabled)
0040         clk_disable(rfkill->clk);
0041
0042     rfkill->clk_enabled = !blocked;
0043
0044     return 0;
0045 }
0046
0047 static const struct rfkill_ops rfkill_gpio_ops = {
0048     .set_block = rfkill_gpio_set_power,
0049 };
0050
0051 static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
0052 static const struct acpi_gpio_params shutdown_gpios = { 1, 0, false };
0053
0054 static const struct acpi_gpio_mapping acpi_rfkill_default_gpios[] = {
0055     { "reset-gpios", &reset_gpios, 1 },
0056     { "shutdown-gpios", &shutdown_gpios, 1 },
0057     { },
0058 };
0059
0060 static int rfkill_gpio_acpi_probe(struct device *dev,
0061                   struct rfkill_gpio_data *rfkill)
0062 {
0063     const struct acpi_device_id *id;
0064
0065     id = acpi_match_device(dev->driver->acpi_match_table, dev);
0066     if (!id)
0067         return -ENODEV;
0068
0069     rfkill->type = (unsigned)id->driver_data;
0070
0071     return devm_acpi_dev_add_driver_gpios(dev, acpi_rfkill_default_gpios);
0072 }
0073
0074 static int rfkill_gpio_probe(struct platform_device *pdev)
0075 {
0076     struct rfkill_gpio_data *rfkill;
0077     struct gpio_desc *gpio;
0078     const char *type_name;
0079     int ret;
0080
0081     rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL);
0082     if (!rfkill)
0083         return -ENOMEM;
0084
0085     device_property_read_string(&pdev->dev, "name", &rfkill->name);
0086     device_property_read_string(&pdev->dev, "type", &type_name);
0087
0088     if (!rfkill->name)
0089         rfkill->name = dev_name(&pdev->dev);
0090
0091     rfkill->type = rfkill_find_type(type_name);
0092
0093     if (ACPI_HANDLE(&pdev->dev)) {
0094         ret = rfkill_gpio_acpi_probe(&pdev->dev, rfkill);
0095         if (ret)
0096             return ret;
0097     }
0098
0099     rfkill->clk = devm_clk_get(&pdev->dev, NULL);
0100
0101     gpio = devm_gpiod_get_optional(&pdev->dev, "reset", GPIOD_OUT_LOW);
0102     if (IS_ERR(gpio))
0103         return PTR_ERR(gpio);
0104
0105     rfkill->reset_gpio = gpio;
0106
0107     gpio = devm_gpiod_get_optional(&pdev->dev, "shutdown", GPIOD_OUT_LOW);
0108     if (IS_ERR(gpio))
0109         return PTR_ERR(gpio);
0110
0111     rfkill->shutdown_gpio = gpio;
0112
0113     /* Make sure at-least one GPIO is defined for this instance */
0114     if (!rfkill->reset_gpio && !rfkill->shutdown_gpio) {
0115         dev_err(&pdev->dev, "invalid platform data\n");
0116         return -EINVAL;
0117     }
0118
0119     rfkill->rfkill_dev = rfkill_alloc(rfkill->name, &pdev->dev,
0120                       rfkill->type, &rfkill_gpio_ops,
0121                       rfkill);
0122     if (!rfkill->rfkill_dev)
0123         return -ENOMEM;
0124
0125     ret = rfkill_register(rfkill->rfkill_dev);
0126     if (ret < 0)
0127         goto err_destroy;
0128
0129     platform_set_drvdata(pdev, rfkill);
0130
0131     dev_info(&pdev->dev, "%s device registered.\n", rfkill->name);
0132
0133     return 0;
0134
0135 err_destroy:
0136     rfkill_destroy(rfkill->rfkill_dev);
0137
0138     return ret;
0139 }
0140
0141 static int rfkill_gpio_remove(struct platform_device *pdev)
0142 {
0143     struct rfkill_gpio_data *rfkill = platform_get_drvdata(pdev);
0144
0145     rfkill_unregister(rfkill->rfkill_dev);
0146     rfkill_destroy(rfkill->rfkill_dev);
0147
0148     return 0;
0149 }
0150
0151 #ifdef CONFIG_ACPI
0152 static const struct acpi_device_id rfkill_acpi_match[] = {
0153     { "BCM4752", RFKILL_TYPE_GPS },
0154     { "LNV4752", RFKILL_TYPE_GPS },
0155     { },
0156 };
0157 MODULE_DEVICE_TABLE(acpi, rfkill_acpi_match);
0158 #endif
0159
0160 static struct platform_driver rfkill_gpio_driver = {
0161     .probe = rfkill_gpio_probe,
0162     .remove = rfkill_gpio_remove,
0163     .driver = {
0164         .name = "rfkill_gpio",
0165         .acpi_match_table = ACPI_PTR(rfkill_acpi_match),
0166     },
0167 };
0168
0169 module_platform_driver(rfkill_gpio_driver);
0170
0171 MODULE_DESCRIPTION("gpio rfkill");
0172 MODULE_AUTHOR("NVIDIA");
0173 MODULE_LICENSE("GPL");