2 * Copyright (c) 2011, NVIDIA Corporation.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 #include <linux/gpio.h>
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/rfkill.h>
24 #include <linux/platform_device.h>
25 #include <linux/clk.h>
26 #include <linux/slab.h>
27 #include <linux/acpi.h>
28 #include <linux/acpi_gpio.h>
30 #include <linux/rfkill-gpio.h>
32 struct rfkill_gpio_data
{
34 enum rfkill_type type
;
38 struct rfkill
*rfkill_dev
;
46 static int rfkill_gpio_set_power(void *data
, bool blocked
)
48 struct rfkill_gpio_data
*rfkill
= data
;
51 if (gpio_is_valid(rfkill
->shutdown_gpio
))
52 gpio_set_value(rfkill
->shutdown_gpio
, 0);
53 if (gpio_is_valid(rfkill
->reset_gpio
))
54 gpio_set_value(rfkill
->reset_gpio
, 0);
55 if (!IS_ERR(rfkill
->clk
) && rfkill
->clk_enabled
)
56 clk_disable(rfkill
->clk
);
58 if (!IS_ERR(rfkill
->clk
) && !rfkill
->clk_enabled
)
59 clk_enable(rfkill
->clk
);
60 if (gpio_is_valid(rfkill
->reset_gpio
))
61 gpio_set_value(rfkill
->reset_gpio
, 1);
62 if (gpio_is_valid(rfkill
->shutdown_gpio
))
63 gpio_set_value(rfkill
->shutdown_gpio
, 1);
66 rfkill
->clk_enabled
= blocked
;
71 static const struct rfkill_ops rfkill_gpio_ops
= {
72 .set_block
= rfkill_gpio_set_power
,
75 static int rfkill_gpio_acpi_probe(struct device
*dev
,
76 struct rfkill_gpio_data
*rfkill
)
78 const struct acpi_device_id
*id
;
80 id
= acpi_match_device(dev
->driver
->acpi_match_table
, dev
);
84 rfkill
->name
= dev_name(dev
);
85 rfkill
->type
= (unsigned)id
->driver_data
;
86 rfkill
->reset_gpio
= acpi_get_gpio_by_index(dev
, 0, NULL
);
87 rfkill
->shutdown_gpio
= acpi_get_gpio_by_index(dev
, 1, NULL
);
92 static int rfkill_gpio_probe(struct platform_device
*pdev
)
94 struct rfkill_gpio_platform_data
*pdata
= pdev
->dev
.platform_data
;
95 struct rfkill_gpio_data
*rfkill
;
96 const char *clk_name
= NULL
;
100 rfkill
= devm_kzalloc(&pdev
->dev
, sizeof(*rfkill
), GFP_KERNEL
);
104 if (ACPI_HANDLE(&pdev
->dev
)) {
105 ret
= rfkill_gpio_acpi_probe(&pdev
->dev
, rfkill
);
109 clk_name
= pdata
->power_clk_name
;
110 rfkill
->name
= pdata
->name
;
111 rfkill
->type
= pdata
->type
;
112 rfkill
->reset_gpio
= pdata
->reset_gpio
;
113 rfkill
->shutdown_gpio
= pdata
->shutdown_gpio
;
118 /* make sure at-least one of the GPIO is defined and that
119 * a name is specified for this instance */
120 if ((!gpio_is_valid(rfkill
->reset_gpio
) &&
121 !gpio_is_valid(rfkill
->shutdown_gpio
)) || !rfkill
->name
) {
122 pr_warn("%s: invalid platform data\n", __func__
);
126 if (pdata
&& pdata
->gpio_runtime_setup
) {
127 ret
= pdata
->gpio_runtime_setup(pdev
);
129 pr_warn("%s: can't set up gpio\n", __func__
);
134 len
= strlen(rfkill
->name
);
135 rfkill
->reset_name
= devm_kzalloc(&pdev
->dev
, len
+ 7, GFP_KERNEL
);
136 if (!rfkill
->reset_name
)
139 rfkill
->shutdown_name
= devm_kzalloc(&pdev
->dev
, len
+ 10, GFP_KERNEL
);
140 if (!rfkill
->shutdown_name
)
143 snprintf(rfkill
->reset_name
, len
+ 6 , "%s_reset", rfkill
->name
);
144 snprintf(rfkill
->shutdown_name
, len
+ 9, "%s_shutdown", rfkill
->name
);
146 rfkill
->clk
= devm_clk_get(&pdev
->dev
, clk_name
);
148 if (gpio_is_valid(rfkill
->reset_gpio
)) {
149 ret
= devm_gpio_request_one(&pdev
->dev
, rfkill
->reset_gpio
,
150 0, rfkill
->reset_name
);
152 pr_warn("%s: failed to get reset gpio.\n", __func__
);
157 if (gpio_is_valid(rfkill
->shutdown_gpio
)) {
158 ret
= devm_gpio_request_one(&pdev
->dev
, rfkill
->shutdown_gpio
,
159 0, rfkill
->shutdown_name
);
161 pr_warn("%s: failed to get shutdown gpio.\n", __func__
);
166 rfkill
->rfkill_dev
= rfkill_alloc(rfkill
->name
, &pdev
->dev
,
167 rfkill
->type
, &rfkill_gpio_ops
,
169 if (!rfkill
->rfkill_dev
)
172 ret
= rfkill_register(rfkill
->rfkill_dev
);
176 platform_set_drvdata(pdev
, rfkill
);
178 dev_info(&pdev
->dev
, "%s device registered.\n", rfkill
->name
);
183 static int rfkill_gpio_remove(struct platform_device
*pdev
)
185 struct rfkill_gpio_data
*rfkill
= platform_get_drvdata(pdev
);
186 struct rfkill_gpio_platform_data
*pdata
= pdev
->dev
.platform_data
;
188 if (pdata
&& pdata
->gpio_runtime_close
)
189 pdata
->gpio_runtime_close(pdev
);
190 rfkill_unregister(rfkill
->rfkill_dev
);
191 rfkill_destroy(rfkill
->rfkill_dev
);
196 static const struct acpi_device_id rfkill_acpi_match
[] = {
197 { "BCM4752", RFKILL_TYPE_GPS
},
201 static struct platform_driver rfkill_gpio_driver
= {
202 .probe
= rfkill_gpio_probe
,
203 .remove
= rfkill_gpio_remove
,
205 .name
= "rfkill_gpio",
206 .owner
= THIS_MODULE
,
207 .acpi_match_table
= ACPI_PTR(rfkill_acpi_match
),
211 module_platform_driver(rfkill_gpio_driver
);
213 MODULE_DESCRIPTION("gpio rfkill");
214 MODULE_AUTHOR("NVIDIA");
215 MODULE_LICENSE("GPL");