1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/gpio/driver.h>
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/mfd/rk808.h>
20#include <linux/of.h>
21#include <linux/of_device.h>
22#include <linux/platform_device.h>
23#include <linux/pinctrl/consumer.h>
24#include <linux/pinctrl/machine.h>
25#include <linux/pinctrl/pinctrl.h>
26#include <linux/pinctrl/pinconf-generic.h>
27#include <linux/pinctrl/pinconf.h>
28#include <linux/pinctrl/pinmux.h>
29#include <linux/pm.h>
30#include <linux/slab.h>
31
32#include "core.h"
33#include "pinconf.h"
34#include "pinctrl-utils.h"
35
36struct rk805_pin_function {
37 const char *name;
38 const char *const *groups;
39 unsigned int ngroups;
40 int mux_option;
41};
42
43struct rk805_pin_group {
44 const char *name;
45 const unsigned int pins[1];
46 unsigned int npins;
47};
48
49
50
51
52
53
54
55
56
57
58
59
60
61struct rk805_pin_config {
62 u8 reg;
63 u8 fun_msk;
64 u8 dir_msk;
65 u8 val_msk;
66};
67
68struct rk805_pctrl_info {
69 struct rk808 *rk808;
70 struct device *dev;
71 struct pinctrl_dev *pctl;
72 struct gpio_chip gpio_chip;
73 struct pinctrl_desc pinctrl_desc;
74 const struct rk805_pin_function *functions;
75 unsigned int num_functions;
76 const struct rk805_pin_group *groups;
77 int num_pin_groups;
78 const struct pinctrl_pin_desc *pins;
79 unsigned int num_pins;
80 struct rk805_pin_config *pin_cfg;
81};
82
83enum rk805_pinmux_option {
84 RK805_PINMUX_GPIO,
85};
86
87enum {
88 RK805_GPIO0,
89 RK805_GPIO1,
90};
91
92static const char *const rk805_gpio_groups[] = {
93 "gpio0",
94 "gpio1",
95};
96
97
98static const struct pinctrl_pin_desc rk805_pins_desc[] = {
99 PINCTRL_PIN(RK805_GPIO0, "gpio0"),
100 PINCTRL_PIN(RK805_GPIO1, "gpio1"),
101};
102
103static const struct rk805_pin_function rk805_pin_functions[] = {
104 {
105 .name = "gpio",
106 .groups = rk805_gpio_groups,
107 .ngroups = ARRAY_SIZE(rk805_gpio_groups),
108 .mux_option = RK805_PINMUX_GPIO,
109 },
110};
111
112static const struct rk805_pin_group rk805_pin_groups[] = {
113 {
114 .name = "gpio0",
115 .pins = { RK805_GPIO0 },
116 .npins = 1,
117 },
118 {
119 .name = "gpio1",
120 .pins = { RK805_GPIO1 },
121 .npins = 1,
122 },
123};
124
125#define RK805_GPIO0_VAL_MSK BIT(0)
126#define RK805_GPIO1_VAL_MSK BIT(1)
127
128static struct rk805_pin_config rk805_gpio_cfgs[] = {
129 {
130 .reg = RK805_OUT_REG,
131 .val_msk = RK805_GPIO0_VAL_MSK,
132 },
133 {
134 .reg = RK805_OUT_REG,
135 .val_msk = RK805_GPIO1_VAL_MSK,
136 },
137};
138
139
140static int rk805_gpio_get(struct gpio_chip *chip, unsigned int offset)
141{
142 struct rk805_pctrl_info *pci = gpiochip_get_data(chip);
143 int ret, val;
144
145 ret = regmap_read(pci->rk808->regmap, pci->pin_cfg[offset].reg, &val);
146 if (ret) {
147 dev_err(pci->dev, "get gpio%d value failed\n", offset);
148 return ret;
149 }
150
151 return !!(val & pci->pin_cfg[offset].val_msk);
152}
153
154static void rk805_gpio_set(struct gpio_chip *chip,
155 unsigned int offset,
156 int value)
157{
158 struct rk805_pctrl_info *pci = gpiochip_get_data(chip);
159 int ret;
160
161 ret = regmap_update_bits(pci->rk808->regmap,
162 pci->pin_cfg[offset].reg,
163 pci->pin_cfg[offset].val_msk,
164 value ? pci->pin_cfg[offset].val_msk : 0);
165 if (ret)
166 dev_err(pci->dev, "set gpio%d value %d failed\n",
167 offset, value);
168}
169
170static int rk805_gpio_direction_input(struct gpio_chip *chip,
171 unsigned int offset)
172{
173 return pinctrl_gpio_direction_input(chip->base + offset);
174}
175
176static int rk805_gpio_direction_output(struct gpio_chip *chip,
177 unsigned int offset, int value)
178{
179 rk805_gpio_set(chip, offset, value);
180 return pinctrl_gpio_direction_output(chip->base + offset);
181}
182
183static int rk805_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
184{
185 struct rk805_pctrl_info *pci = gpiochip_get_data(chip);
186 unsigned int val;
187 int ret;
188
189
190 if (!pci->pin_cfg[offset].dir_msk)
191 return 0;
192
193 ret = regmap_read(pci->rk808->regmap,
194 pci->pin_cfg[offset].reg,
195 &val);
196 if (ret) {
197 dev_err(pci->dev, "get gpio%d direction failed\n", offset);
198 return ret;
199 }
200
201 return !(val & pci->pin_cfg[offset].dir_msk);
202}
203
204static struct gpio_chip rk805_gpio_chip = {
205 .label = "rk805-gpio",
206 .request = gpiochip_generic_request,
207 .free = gpiochip_generic_free,
208 .get_direction = rk805_gpio_get_direction,
209 .get = rk805_gpio_get,
210 .set = rk805_gpio_set,
211 .direction_input = rk805_gpio_direction_input,
212 .direction_output = rk805_gpio_direction_output,
213 .can_sleep = true,
214 .base = -1,
215 .owner = THIS_MODULE,
216};
217
218
219static int rk805_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
220{
221 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
222
223 return pci->num_pin_groups;
224}
225
226static const char *rk805_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
227 unsigned int group)
228{
229 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
230
231 return pci->groups[group].name;
232}
233
234static int rk805_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
235 unsigned int group,
236 const unsigned int **pins,
237 unsigned int *num_pins)
238{
239 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
240
241 *pins = pci->groups[group].pins;
242 *num_pins = pci->groups[group].npins;
243
244 return 0;
245}
246
247static const struct pinctrl_ops rk805_pinctrl_ops = {
248 .get_groups_count = rk805_pinctrl_get_groups_count,
249 .get_group_name = rk805_pinctrl_get_group_name,
250 .get_group_pins = rk805_pinctrl_get_group_pins,
251 .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
252 .dt_free_map = pinctrl_utils_free_map,
253};
254
255static int rk805_pinctrl_get_funcs_count(struct pinctrl_dev *pctldev)
256{
257 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
258
259 return pci->num_functions;
260}
261
262static const char *rk805_pinctrl_get_func_name(struct pinctrl_dev *pctldev,
263 unsigned int function)
264{
265 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
266
267 return pci->functions[function].name;
268}
269
270static int rk805_pinctrl_get_func_groups(struct pinctrl_dev *pctldev,
271 unsigned int function,
272 const char *const **groups,
273 unsigned int *const num_groups)
274{
275 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
276
277 *groups = pci->functions[function].groups;
278 *num_groups = pci->functions[function].ngroups;
279
280 return 0;
281}
282
283static int _rk805_pinctrl_set_mux(struct pinctrl_dev *pctldev,
284 unsigned int offset,
285 int mux)
286{
287 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
288 int ret;
289
290 if (!pci->pin_cfg[offset].fun_msk)
291 return 0;
292
293 if (mux == RK805_PINMUX_GPIO) {
294 ret = regmap_update_bits(pci->rk808->regmap,
295 pci->pin_cfg[offset].reg,
296 pci->pin_cfg[offset].fun_msk,
297 pci->pin_cfg[offset].fun_msk);
298 if (ret) {
299 dev_err(pci->dev, "set gpio%d GPIO failed\n", offset);
300 return ret;
301 }
302 } else {
303 dev_err(pci->dev, "Couldn't find function mux %d\n", mux);
304 return -EINVAL;
305 }
306
307 return 0;
308}
309
310static int rk805_pinctrl_set_mux(struct pinctrl_dev *pctldev,
311 unsigned int function,
312 unsigned int group)
313{
314 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
315 int mux = pci->functions[function].mux_option;
316 int offset = group;
317
318 return _rk805_pinctrl_set_mux(pctldev, offset, mux);
319}
320
321static int rk805_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
322 struct pinctrl_gpio_range *range,
323 unsigned int offset, bool input)
324{
325 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
326 int ret;
327
328
329 ret = _rk805_pinctrl_set_mux(pctldev, offset, RK805_PINMUX_GPIO);
330 if (ret) {
331 dev_err(pci->dev, "set gpio%d mux failed\n", offset);
332 return ret;
333 }
334
335
336 if (!pci->pin_cfg[offset].dir_msk)
337 return 0;
338
339 ret = regmap_update_bits(pci->rk808->regmap,
340 pci->pin_cfg[offset].reg,
341 pci->pin_cfg[offset].dir_msk,
342 input ? 0 : pci->pin_cfg[offset].dir_msk);
343 if (ret) {
344 dev_err(pci->dev, "set gpio%d direction failed\n", offset);
345 return ret;
346 }
347
348 return ret;
349}
350
351static const struct pinmux_ops rk805_pinmux_ops = {
352 .get_functions_count = rk805_pinctrl_get_funcs_count,
353 .get_function_name = rk805_pinctrl_get_func_name,
354 .get_function_groups = rk805_pinctrl_get_func_groups,
355 .set_mux = rk805_pinctrl_set_mux,
356 .gpio_set_direction = rk805_pmx_gpio_set_direction,
357};
358
359static int rk805_pinconf_get(struct pinctrl_dev *pctldev,
360 unsigned int pin, unsigned long *config)
361{
362 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
363 enum pin_config_param param = pinconf_to_config_param(*config);
364 u32 arg = 0;
365
366 switch (param) {
367 case PIN_CONFIG_OUTPUT:
368 arg = rk805_gpio_get(&pci->gpio_chip, pin);
369 break;
370 default:
371 dev_err(pci->dev, "Properties not supported\n");
372 return -ENOTSUPP;
373 }
374
375 *config = pinconf_to_config_packed(param, (u16)arg);
376
377 return 0;
378}
379
380static int rk805_pinconf_set(struct pinctrl_dev *pctldev,
381 unsigned int pin, unsigned long *configs,
382 unsigned int num_configs)
383{
384 struct rk805_pctrl_info *pci = pinctrl_dev_get_drvdata(pctldev);
385 enum pin_config_param param;
386 u32 i, arg = 0;
387
388 for (i = 0; i < num_configs; i++) {
389 param = pinconf_to_config_param(configs[i]);
390 arg = pinconf_to_config_argument(configs[i]);
391
392 switch (param) {
393 case PIN_CONFIG_OUTPUT:
394 rk805_gpio_set(&pci->gpio_chip, pin, arg);
395 rk805_pmx_gpio_set_direction(pctldev, NULL, pin, false);
396 break;
397 default:
398 dev_err(pci->dev, "Properties not supported\n");
399 return -ENOTSUPP;
400 }
401 }
402
403 return 0;
404}
405
406static const struct pinconf_ops rk805_pinconf_ops = {
407 .pin_config_get = rk805_pinconf_get,
408 .pin_config_set = rk805_pinconf_set,
409};
410
411static struct pinctrl_desc rk805_pinctrl_desc = {
412 .name = "rk805-pinctrl",
413 .pctlops = &rk805_pinctrl_ops,
414 .pmxops = &rk805_pinmux_ops,
415 .confops = &rk805_pinconf_ops,
416 .owner = THIS_MODULE,
417};
418
419static int rk805_pinctrl_probe(struct platform_device *pdev)
420{
421 struct rk805_pctrl_info *pci;
422 int ret;
423
424 pci = devm_kzalloc(&pdev->dev, sizeof(*pci), GFP_KERNEL);
425 if (!pci)
426 return -ENOMEM;
427
428 pci->dev = &pdev->dev;
429 pci->dev->of_node = pdev->dev.parent->of_node;
430 pci->rk808 = dev_get_drvdata(pdev->dev.parent);
431
432 pci->pinctrl_desc = rk805_pinctrl_desc;
433 pci->gpio_chip = rk805_gpio_chip;
434 pci->gpio_chip.parent = &pdev->dev;
435 pci->gpio_chip.of_node = pdev->dev.parent->of_node;
436
437 platform_set_drvdata(pdev, pci);
438
439 switch (pci->rk808->variant) {
440 case RK805_ID:
441 pci->pins = rk805_pins_desc;
442 pci->num_pins = ARRAY_SIZE(rk805_pins_desc);
443 pci->functions = rk805_pin_functions;
444 pci->num_functions = ARRAY_SIZE(rk805_pin_functions);
445 pci->groups = rk805_pin_groups;
446 pci->num_pin_groups = ARRAY_SIZE(rk805_pin_groups);
447 pci->pinctrl_desc.pins = rk805_pins_desc;
448 pci->pinctrl_desc.npins = ARRAY_SIZE(rk805_pins_desc);
449 pci->pin_cfg = rk805_gpio_cfgs;
450 pci->gpio_chip.ngpio = ARRAY_SIZE(rk805_gpio_cfgs);
451 break;
452 default:
453 dev_err(&pdev->dev, "unsupported RK805 ID %lu\n",
454 pci->rk808->variant);
455 return -EINVAL;
456 }
457
458
459 ret = devm_gpiochip_add_data(&pdev->dev, &pci->gpio_chip, pci);
460 if (ret < 0) {
461 dev_err(&pdev->dev, "Couldn't add gpiochip\n");
462 return ret;
463 }
464
465
466 pci->pctl = devm_pinctrl_register(&pdev->dev, &pci->pinctrl_desc, pci);
467 if (IS_ERR(pci->pctl)) {
468 dev_err(&pdev->dev, "Couldn't add pinctrl\n");
469 return PTR_ERR(pci->pctl);
470 }
471
472
473 ret = gpiochip_add_pin_range(&pci->gpio_chip, dev_name(&pdev->dev),
474 0, 0, pci->gpio_chip.ngpio);
475 if (ret < 0) {
476 dev_err(&pdev->dev, "Couldn't add gpiochip pin range\n");
477 return ret;
478 }
479
480 return 0;
481}
482
483static struct platform_driver rk805_pinctrl_driver = {
484 .probe = rk805_pinctrl_probe,
485 .driver = {
486 .name = "rk805-pinctrl",
487 },
488};
489module_platform_driver(rk805_pinctrl_driver);
490
491MODULE_DESCRIPTION("RK805 pin control and GPIO driver");
492MODULE_AUTHOR("Joseph Chen <chenjh@rock-chips.com>");
493MODULE_LICENSE("GPL v2");
494
