2 * Pinctrl driver for Rockchip SoCs
4 * Copyright (c) 2016 Rockchip electronic L.T.D
5 * Author: Luo Wei <lw@rock-chips.com>
7 * Thanks to Heiko Stuebner <heiko@sntech.de>
8 * With some ideas taken from pinctrl-samsung
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as published
13 * by the Free Software Foundation.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
24 #include <linux/bitops.h>
25 #include <linux/irq.h>
26 #include <linux/interrupt.h>
27 #include <linux/gpio.h>
28 #include <linux/of_address.h>
29 #include <linux/of_irq.h>
30 #include <linux/pinctrl/machine.h>
31 #include <linux/pinctrl/pinconf.h>
32 #include <linux/pinctrl/pinctrl.h>
33 #include <linux/pinctrl/pinmux.h>
34 #include <linux/pinctrl/pinconf-generic.h>
35 #include <linux/irqchip/chained_irq.h>
36 #include <linux/clk.h>
37 #include <linux/syscore_ops.h>
38 #include <linux/highmem.h>
39 #include <dt-bindings/pinctrl/rockchip.h>
41 #include <linux/of_device.h>
42 #include <linux/pinctrl/consumer.h>
43 #include <linux/slab.h>
44 #include <linux/delay.h>
45 #include <linux/rockchip/grf.h>
46 #include <linux/of_gpio.h>
49 #ifdef CONFIG_DEBUG_FS
50 #include <linux/debugfs.h>
59 #define DBG_PINCTRL(x...) do { if((((atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1)) && (atomic_read(&info->pin_debug_flag) == (pin + 1))) || ((atomic_read(&info->pin_debug_flag) == 0) && (atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1)))) && bank && info) printk(x); } while (0)
61 #define DBG_PINCTRL(x...)
65 /* GPIO control registers */
66 #define GPIO_SWPORT_DR 0x00
67 #define GPIO_SWPORT_DDR 0x04
68 #define GPIO_INTEN 0x30
69 #define GPIO_INTMASK 0x34
70 #define GPIO_INTTYPE_LEVEL 0x38
71 #define GPIO_INT_POLARITY 0x3c
72 #define GPIO_INT_STATUS 0x40
73 #define GPIO_INT_RAWSTATUS 0x44
74 #define GPIO_DEBOUNCE 0x48
75 #define GPIO_PORTS_EOI 0x4c
76 #define GPIO_EXT_PORT 0x50
77 #define GPIO_LS_SYNC 0x60
79 enum rockchip_pinctrl_type {
88 enum rockchip_pin_bank_type {
95 * @reg_base: register base of the gpio bank
96 * @reg_pull: optional separate register for additional pull settings
97 * @clk: clock of the gpio bank
98 * @irq: interrupt of the gpio bank
99 * @pin_base: first pin number
100 * @nr_pins: number of pins in this bank
101 * @name: name of the bank
102 * @bank_num: number of the bank, to account for holes
103 * @valid: are all necessary informations present
104 * @of_node: dt node of this bank
105 * @drvdata: common pinctrl basedata
106 * @domain: irqdomain of the gpio bank
107 * @gpio_chip: gpiolib chip
108 * @grange: gpio range
109 * @slock: spinlock for the gpio bank
111 struct rockchip_pin_bank {
112 void __iomem *reg_base;
113 void __iomem *reg_mux_bank0;
114 void __iomem *reg_pull_bank0;
115 void __iomem *reg_drv_bank0;
122 enum rockchip_pin_bank_type bank_type;
124 struct device_node *of_node;
125 struct rockchip_pinctrl *drvdata;
126 struct irq_domain *domain;
127 struct gpio_chip gpio_chip;
128 struct pinctrl_gpio_range grange;
130 u32 toggle_edge_mode;
135 #define PIN_BANK(id, pins, label) \
144 struct rockchip_pin_ctrl {
145 struct rockchip_pin_bank *pin_banks;
149 enum rockchip_pinctrl_type type;
151 void (*pull_calc_reg)(struct rockchip_pin_bank *bank, int pin_num,
152 void __iomem **reg, u8 *bit);
153 void (*drv_calc_reg)(struct rockchip_pin_bank *bank, int pin_num,
154 void __iomem **reg, u8 *bit);
157 struct rockchip_pin_config {
159 unsigned long *configs;
160 unsigned int nconfigs;
164 * struct rockchip_pin_group: represent group of pins of a pinmux function.
165 * @name: name of the pin group, used to lookup the group.
166 * @pins: the pins included in this group.
167 * @npins: number of pins included in this group.
168 * @func: the mux function number to be programmed when selected.
169 * @configs: the config values to be set for each pin
170 * @nconfigs: number of configs for each pin
172 struct rockchip_pin_group {
174 const char *func_name;
177 struct rockchip_pin_config *data;
178 unsigned long gconfigs;
182 * struct rockchip_pmx_func: represent a pin function.
183 * @name: name of the pin function, used to lookup the function.
184 * @groups: one or more names of pin groups that provide this function.
185 * @num_groups: number of groups included in @groups.
187 struct rockchip_pmx_func {
193 struct gpio_init_config {
199 struct rockchip_pinctrl {
200 void __iomem *reg_base;
202 void __iomem *reg_mux;
203 void __iomem *reg_pull;
204 void __iomem *reg_drv;
207 struct rockchip_pin_ctrl *ctrl;
208 struct pinctrl_desc pctl;
209 struct pinctrl_dev *pctl_dev;
210 struct rockchip_pin_group *groups;
211 unsigned int ngroups;
212 struct rockchip_pmx_func *functions;
213 unsigned int nfunctions;
215 atomic_t bank_debug_flag;
216 atomic_t pin_debug_flag;
217 #ifdef CONFIG_DEBUG_FS
218 struct dentry *debugfs;
220 struct gpio_init_config *config;
233 struct iomux_mode mux;
238 struct func_to_reg_offset {
239 unsigned int reg_type;
240 const char *vol_name;
241 const char *func_name;
242 const char *group_name;
243 unsigned int reg_offset;
244 unsigned int bit_offset;
245 unsigned int bit_mask;
248 #define FUNC_GROUP_TO_REG_OFFSET(type, vol, func, group, reg, bit, mask) \
253 .group_name = group, \
260 static struct rockchip_pinctrl *g_info;
263 #ifdef CONFIG_DEBUG_FS
264 #define PINCTRL_REGS_BUFSIZE (1024<<4)
265 static ssize_t pinctrl_write_proc_data(struct file *file, const char __user *buffer,
266 size_t count, loff_t *data)
268 struct rockchip_pinctrl *info;
271 int bank_value, pin_value;
273 info = file->private_data;
275 buf = kzalloc(32, GFP_KERNEL);
279 ret = copy_from_user(buf, buffer, count);
285 if((strstr(buf, "debug") != NULL) || (strstr(buf, "DEBUG") != NULL))
287 if(strstr(buf, "-") != NULL)
289 if(strstr(buf, "debug") != NULL)
290 sscanf(buf, "debug%d-%d", &bank_value, &pin_value);
291 else if(strstr(buf, "DEBUG") != NULL)
292 sscanf(buf, "DEBUG%d-%d", &bank_value, &pin_value);
294 if((bank_value < 0) || (pin_value < 0))
296 printk("%s:error:bank %d or pin %d is out of range %d-%d\n",__func__, bank_value, pin_value, info->ctrl->nr_banks-1, info->ctrl->nr_pins);
300 atomic_set(&info->bank_debug_flag, bank_value+1);
301 atomic_set(&info->pin_debug_flag, pin_value+1);
302 printk("%s:open debug for bank%d-%d\n",__func__,bank_value, pin_value);
307 if(strstr(buf, "debug") != NULL)
308 sscanf(buf, "debug%d", &bank_value);
309 else if(strstr(buf, "DEBUG") != NULL)
310 sscanf(buf, "DEBUG%d", &bank_value);
314 printk("%s:error:bank%d is out of range %d\n",__func__, bank_value,info->ctrl->nr_banks-1);
318 atomic_set(&info->bank_debug_flag, bank_value+1);
319 atomic_set(&info->pin_debug_flag, 0);
320 printk("%s:open debug for bank%d\n",__func__,bank_value);
325 else if((strstr(buf, "stop") != NULL) || (strstr(buf, "STOP") != NULL))
327 atomic_set(&info->bank_debug_flag, 0);
328 atomic_set(&info->pin_debug_flag, 0);
329 printk("%s:close debug\n",__func__);
337 static ssize_t pinctrl_show_regs(struct file *file, char __user *user_buf,
338 size_t count, loff_t *ppos)
340 struct rockchip_pinctrl *info;
341 struct rockchip_pin_ctrl *ctrl;
342 struct rockchip_pin_bank *bank, *bank0;
349 info = file->private_data;
351 bank = ctrl->pin_banks;
354 buf = kzalloc(PINCTRL_REGS_BUFSIZE, GFP_KERNEL);
358 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
359 "%s registers:\n",ctrl->label);
360 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
361 "=================================\n");
363 for(n=0; n<ctrl->nr_banks-1; n++)
365 for(i=GPIO_SWPORT_DR; i<GPIO_LS_SYNC; i=i+4)
367 value = readl_relaxed(bank->reg_base + i);
368 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len, "bank%d reg[0x%p+0x%x]=0x%08x\n",bank->bank_num, (int *)bank->reg_base, i, value);
373 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
374 "=================================\n\n");
376 if(bank0 && bank0->reg_mux_bank0 && bank0->reg_pull_bank0 && bank0->reg_drv_bank0)
378 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
379 "BANK0 GRF registers:\n");
380 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
381 "=================================\n");
383 for(i=0; i<0x0c; i=i+4)
385 value = readl_relaxed(bank0->reg_mux_bank0 + i);
386 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len, "MUX_BANK0[0x%p+0x%x]=0x%08x\n",(int *)bank0->reg_mux_bank0, i, value);
389 for(i=0; i<0x0c; i=i+4)
391 value = readl_relaxed(bank0->reg_pull_bank0 + i);
392 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len, "PULL_BANK0[0x%p+0x%x]=0x%08x\n",(int *)bank0->reg_pull_bank0, i, value);
395 for(i=0; i<0x0c; i=i+4)
397 value = readl_relaxed(bank0->reg_drv_bank0 + i);
398 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len, "DRV_BANK0[0x%p+0x%x]=0x%08x\n",(int *)bank0->reg_drv_bank0, i, value);
401 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
402 "=================================\n\n");
406 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
407 "rockchip pinctrl GRF registers:\n");
408 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
409 "=================================\n");
412 for(i=0; i<0x400; i=i+4)
414 value = readl_relaxed(info->reg_base + i);
415 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len, "GRF[0x%p+0x%x]=0x%08x\n",(int *)info->reg_base, i, value);
418 len += snprintf(buf + len, PINCTRL_REGS_BUFSIZE - len,
419 "=================================\n\n");
421 ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
427 static const struct file_operations pinctrl_regs_ops = {
428 .owner = THIS_MODULE,
430 .read = pinctrl_show_regs,
431 .write = pinctrl_write_proc_data,
432 .llseek = default_llseek,
435 static int pinctrl_debugfs_init(struct rockchip_pinctrl *info)
437 info->debugfs = debugfs_create_dir("rockchip_pinctrl", NULL);
441 debugfs_create_file("registers", S_IFREG | S_IRUGO,
442 info->debugfs, (void *)info, &pinctrl_regs_ops);
447 static void pinctrl_debugfs_remove(struct rockchip_pinctrl*info)
450 debugfs_remove_recursive(info->debugfs);
455 static inline int pinctrl_debugfs_init(struct rockchip_pinctrl*info)
461 static inline void pinctrl_debugfs_remove(struct rockchip_pinctrl*info)
465 #endif /* CONFIG_DEBUG_FS */
468 static inline struct rockchip_pin_bank *gc_to_pin_bank(struct gpio_chip *gc)
470 return container_of(gc, struct rockchip_pin_bank, gpio_chip);
473 static const inline struct rockchip_pin_group *pinctrl_name_to_group(
474 const struct rockchip_pinctrl *info,
479 for (i = 0; i < info->ngroups; i++) {
480 if (!strcmp(info->groups[i].name, name))
481 return &info->groups[i];
488 * given a pin number that is local to a pin controller, find out the pin bank
489 * and the register base of the pin bank.
491 static struct rockchip_pin_bank *pin_to_bank(struct rockchip_pinctrl *info,
494 struct rockchip_pin_bank *b = info->ctrl->pin_banks;
496 while (pin >= (b->pin_base + b->nr_pins))
502 static struct rockchip_pin_bank *bank_num_to_bank(
503 struct rockchip_pinctrl *info,
506 struct rockchip_pin_bank *b = info->ctrl->pin_banks;
509 for (i = 0; i < info->ctrl->nr_banks; i++, b++) {
510 if (b->bank_num == num)
514 return ERR_PTR(-EINVAL);
518 * Pinctrl_ops handling
521 static int rockchip_get_groups_count(struct pinctrl_dev *pctldev)
523 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
525 return info->ngroups;
528 static const char *rockchip_get_group_name(struct pinctrl_dev *pctldev,
531 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
533 return info->groups[selector].name;
536 static int rockchip_get_group_pins(struct pinctrl_dev *pctldev,
537 unsigned selector, const unsigned **pins,
540 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
542 if (selector >= info->ngroups)
545 *pins = info->groups[selector].pins;
546 *npins = info->groups[selector].npins;
551 static int rockchip_dt_node_to_map(struct pinctrl_dev *pctldev,
552 struct device_node *np,
553 struct pinctrl_map **map, unsigned *num_maps)
555 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
556 const struct rockchip_pin_group *grp;
557 struct pinctrl_map *new_map;
558 struct device_node *parent;
563 * first find the group of this node and check if we need to create
564 * config maps for pins
566 grp = pinctrl_name_to_group(info, np->name);
568 dev_err(info->dev, "unable to find group for node %s\n",
573 map_num += grp->npins;
574 new_map = devm_kzalloc(pctldev->dev, sizeof(*new_map) * map_num,
583 parent = of_get_parent(np);
585 devm_kfree(pctldev->dev, new_map);
588 new_map[0].type = PIN_MAP_TYPE_MUX_GROUP;
589 new_map[0].data.mux.function = parent->name;
590 new_map[0].data.mux.group = np->name;
593 /* create config map */
595 for (i = 0; i < grp->npins; i++) {
596 new_map[i].type = PIN_MAP_TYPE_CONFIGS_GROUP;
597 new_map[i].data.configs.group_or_pin = grp->name;
598 //pin_get_name(pctldev, grp->pins[i]);
599 new_map[i].data.configs.configs = grp->data[i].configs;
600 new_map[i].data.configs.num_configs = grp->data[i].nconfigs;
603 dev_dbg(pctldev->dev, "maps: function %s group %s num %d\n",
604 (*map)->data.mux.function, (*map)->data.mux.group, map_num);
609 static void rockchip_dt_free_map(struct pinctrl_dev *pctldev,
610 struct pinctrl_map *map, unsigned num_maps)
614 static const struct pinctrl_ops rockchip_pctrl_ops = {
615 .get_groups_count = rockchip_get_groups_count,
616 .get_group_name = rockchip_get_group_name,
617 .get_group_pins = rockchip_get_group_pins,
618 .dt_node_to_map = rockchip_dt_node_to_map,
619 .dt_free_map = rockchip_dt_free_map,
623 #define RK3288_GRF_GPIO1A_IOMUX 0x0000
624 #define RK3288_GRF_GPIO5A_IOMUX 0x004C
626 static int rk32_iomux_bit_op(struct rockchip_pin_bank *bank, int pin, int mux, void __iomem *reg, int bits)
631 struct rockchip_pinctrl *info = bank->drvdata;
635 reg += (pin / 8) * 4;
638 spin_lock_irqsave(&bank->slock, flags);
639 if(bank->bank_num == 0)
641 data = readl_relaxed(reg);
643 data |= (mux & 3) << bit;
648 data = (3 << (bit + 16));
649 data |= (mux & 3) << bit;
653 spin_unlock_irqrestore(&bank->slock, flags);
658 reg += (pin / 4) * 4;
661 spin_lock_irqsave(&bank->slock, flags);
662 if(bank->bank_num == 0)
664 data = readl_relaxed(reg);
665 data &= ~(0x0f<<bit);
666 data |= (mux & 0x0f) << bit;
671 data = (0x0f << (bit + 16));
672 data |= (mux & 0x0f) << bit;
676 spin_unlock_irqrestore(&bank->slock, flags);
680 printk("%s:unknow bits %d\n",__func__, bits);
684 result = readl_relaxed(reg);
685 if(bank->bank_num == 0)
686 DBG_PINCTRL("%s:GPIO%d-%d,reg=0x%x,data=0x%x,result=0x%x\n",__func__, bank->bank_num, pin, reg - bank->reg_mux_bank0, data, result);
688 DBG_PINCTRL("%s:GPIO%d-%d,reg=0x%x,data=0x%x,result=0x%x\n",__func__, bank->bank_num, pin, reg - info->reg_base, data, result);
695 static int rockchip_set_rk32_mux(struct rockchip_pin_bank *bank, int pin, int mux)
697 struct rockchip_pinctrl *info = bank->drvdata;
698 void __iomem *reg = info->reg_mux;
704 if((m.mux.bank != bank->bank_num))
706 printk("%s:error:mux_bank(%d) != gpio_bank(%d)\n",__func__, m.mux.bank, bank->bank_num);
710 switch(bank->bank_num)
714 reg = bank->reg_mux_bank0;
715 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b) || (m.mux.goff == 0x0c))
719 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
723 reg += RK3288_GRF_GPIO1A_IOMUX;
724 if((m.mux.goff == 0x0d))
728 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
732 reg += RK3288_GRF_GPIO2A_IOMUX;
733 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b) || (m.mux.goff == 0x0c))
737 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
741 reg += RK3288_GRF_GPIO3A_IOMUX;
742 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b) || (m.mux.goff == 0x0c))
746 else if(m.mux.goff == 0x0d)
752 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
756 reg += RK3288_GRF_GPIO4AL_IOMUX;
757 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b))
761 else if((m.mux.goff == 0x0c) || (m.mux.goff == 0x0d))
767 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
772 reg += RK3288_GRF_GPIO5A_IOMUX;
773 if((m.mux.goff == 0x0b) || (m.mux.goff == 0x0c))
778 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
783 reg += RK3288_GRF_GPIO6A_IOMUX;
784 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b) || (m.mux.goff == 0x0c))
789 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
793 reg += RK3288_GRF_GPIO7A_IOMUX;
794 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b))
798 else if((m.mux.goff == 0x0c))
804 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
808 reg += RK3288_GRF_GPIO8A_IOMUX;
809 if((m.mux.goff == 0x0a) || (m.mux.goff == 0x0b))
814 rk32_iomux_bit_op(bank, pin, mux, reg, bits);
818 printk("%s:unknow bank num %d\n", __func__, bank->bank_num);
830 * Set a new mux function for a pin.
832 * The register is divided into the upper and lower 16 bit. When changing
833 * a value, the previous register value is not read and changed. Instead
834 * it seems the changed bits are marked in the upper 16 bit, while the
835 * changed value gets set in the same offset in the lower 16 bit.
836 * All pin settings seem to be 2 bit wide in both the upper and lower
838 * @bank: pin bank to change
839 * @pin: pin to change
840 * @mux: new mux function to set
842 static void rockchip_set_mux(struct rockchip_pin_bank *bank, int pin, int mux)
844 struct rockchip_pinctrl *info = bank->drvdata;
845 void __iomem *reg = info->reg_base + info->ctrl->mux_offset;
852 /*GPIO0_C0 = 0x0c00, NAND_D8, */
853 /*GPIO0_C1 = 0x0c10, NAND_D9, */
855 if(bank->bank_num == 15)
857 printk("%s:warning ignore bank num %d\n",__func__, bank->bank_num);
861 if(info->ctrl->type == RK3288)
863 rockchip_set_rk32_mux(bank, pin, mux);
869 if((m.mux.bank != bank->bank_num) || (((m.mux.goff - 0x0A) * 8 + m.mux.off ) != pin))
871 printk("%s:error:mux_bank(%d) != gpio_bank(%d), mux_offset(%d) != gpio_offset(%d)\n",__func__,
872 m.mux.bank, bank->bank_num, ((m.mux.goff - 0x0A) * 8 + m.mux.off ), pin);
876 if((info->ctrl->type == RK312X) && (bank->bank_num == 2) && (pin >= 20) && (pin <= 24))
878 /*RK321X GPIO2C_IOMUX2 and GPIO2D_IOMUX are special */
879 if((pin >= 20) && (pin <= 23))
881 reg -= info->ctrl->mux_offset;
887 reg -= info->ctrl->mux_offset;
891 spin_lock_irqsave(&bank->slock, flags);
893 data = (0x0f << (bit + 16));
894 data |= (mux & 0x0f) << bit;
897 spin_unlock_irqrestore(&bank->slock, flags);
903 /* get basic quadrupel of mux registers and the correct reg inside */
904 reg += bank->bank_num * 0x10;
905 reg += (pin / 8) * 4;
908 spin_lock_irqsave(&bank->slock, flags);
910 data = (3 << (bit + 16));
911 data |= (mux & 3) << bit;
914 spin_unlock_irqrestore(&bank->slock, flags);
917 DBG_PINCTRL("%s:setting GPIO%d-%d to mux:0x%x\n", __func__, m.mux.bank, ((m.mux.goff - 0x0A) * 8 + m.mux.off ), mux);
919 //DBG_PINCTRL("%s:setting mux of GPIO%d-%d to %d\n", __func__, bank->bank_num, pin, mux&0x3);
924 * Pinmux_ops handling
927 static int rockchip_pmx_get_funcs_count(struct pinctrl_dev *pctldev)
929 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
931 return info->nfunctions;
934 static const char *rockchip_pmx_get_func_name(struct pinctrl_dev *pctldev,
937 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
939 return info->functions[selector].name;
942 static int rockchip_pmx_get_groups(struct pinctrl_dev *pctldev,
943 unsigned selector, const char * const **groups,
944 unsigned * const num_groups)
946 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
948 *groups = info->functions[selector].groups;
949 *num_groups = info->functions[selector].ngroups;
954 static int rockchip_pmx_enable(struct pinctrl_dev *pctldev, unsigned selector,
957 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
958 const unsigned int *pins = info->groups[group].pins;
959 const struct rockchip_pin_config *data = info->groups[group].data;
960 struct rockchip_pin_bank *bank;
965 * for each pin in the pin group selected, program the correspoding pin
966 * pin function number in the config register.
968 for (cnt = 0; cnt < info->groups[group].npins; cnt++) {
969 bank = pin_to_bank(info, pins[cnt]);
971 DBG_PINCTRL("%s:enable function %s group %s\n",
972 __func__, info->functions[selector].name, info->groups[group].name);
973 rockchip_set_mux(bank, pins[cnt] - bank->pin_base,
981 static void rockchip_pmx_disable(struct pinctrl_dev *pctldev,
982 unsigned selector, unsigned group)
984 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
985 const unsigned int *pins = info->groups[group].pins;
986 const struct rockchip_pin_config *data = info->groups[group].data;
987 struct rockchip_pin_bank *bank;
991 for (cnt = 0; cnt < info->groups[group].npins; cnt++) {
992 bank = pin_to_bank(info, pins[cnt]);
994 DBG_PINCTRL("%s:disable function %s group %s\n",
995 __func__, info->functions[selector].name, info->groups[group].name);
996 rockchip_set_mux(bank, pins[cnt] - bank->pin_base, FUNC_TO_GPIO(data[cnt].func));
1002 * The calls to gpio_direction_output() and gpio_direction_input()
1003 * leads to this function call (via the pinctrl_gpio_direction_{input|output}()
1004 * function called from the gpiolib interface).
1006 static int rockchip_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
1007 struct pinctrl_gpio_range *range,
1008 unsigned offset, bool input)
1010 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
1011 struct rockchip_pin_bank *bank;
1012 struct gpio_chip *chip;
1018 bank = gc_to_pin_bank(chip);
1019 pin = offset - chip->base;
1021 mux = (bank->bank_num << 12) | (((pin / 8) + 0x0A) << 8) | ((pin % 8)<< 4) | RK_FUNC_GPIO;
1023 rockchip_set_mux(bank, pin, mux);
1025 data = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
1026 /* set bit to 1 for output, 0 for input */
1031 writel_relaxed(data, bank->reg_base + GPIO_SWPORT_DDR);
1033 result = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
1035 DBG_PINCTRL("%s:gpio_direction for pin %u as %s-%d to %s,data=0x%x,result=0x%x\n",
1036 __func__, offset, range->name, pin, input ? "input" : "output", data, result);
1040 static const struct pinmux_ops rockchip_pmx_ops = {
1041 .get_functions_count = rockchip_pmx_get_funcs_count,
1042 .get_function_name = rockchip_pmx_get_func_name,
1043 .get_function_groups = rockchip_pmx_get_groups,
1044 .enable = rockchip_pmx_enable,
1045 //.disable = rockchip_pmx_disable,
1046 .gpio_set_direction = rockchip_pmx_gpio_set_direction,
1055 static struct func_to_reg_offset rk3188_func_to_drv_reg_offset[] =
1057 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "NULL", "reserve" ,"NULL", RK3188_GRF_IO_CON0, 0 ,3),
1058 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "flash-vcc", "gpio0_flash" ,"NULL", RK3188_GRF_IO_CON0, 2, 3),
1059 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "flash-vcc", "gpio0_flash" ,"NULL", RK3188_GRF_IO_CON0, 4 ,3),
1060 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "flash-vcc", "gpio0_d" ,"NULL", RK3188_GRF_IO_CON0, 6 ,3),
1061 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap0-vcc", "gpio1_uart0" ,"NULL", RK3188_GRF_IO_CON0, 8 ,3),
1062 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap1-vcc", "gpio1_uart1" ,"NULL", RK3188_GRF_IO_CON0, 10 ,3),
1063 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap1-vcc", "gpio1_spi0" ,"NULL", RK3188_GRF_IO_CON0, 10 ,3),
1064 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "NULL", "gpio1_uart2" ,"NULL", RK3188_GRF_IO_CON0, 12 ,3),
1065 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio1_uart3" ,"NULL", RK3188_GRF_IO_CON0, 14 ,3),
1066 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio1_spi1" ,"NULL", RK3188_GRF_IO_CON0, 14 ,3),
1067 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio1_gps" ,"NULL", RK3188_GRF_IO_CON0, 14 ,3),
1069 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap1-vcc", "gpio1_i2s0" ,"NULL", RK3188_GRF_IO_CON1, 0 ,3),
1070 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap1-vcc", "gpio1_i2s0" ,"NULL", RK3188_GRF_IO_CON1, 2 ,3),
1071 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap1-vcc", "gpio1_c" ,"NULL", RK3188_GRF_IO_CON1, 4 ,3),
1072 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio1-vcc", "gpio1_i2c0" ,"NULL", RK3188_GRF_IO_CON1, 6 ,3),
1073 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio1-vcc", "gpio1_i2c1" ,"NULL", RK3188_GRF_IO_CON1, 8 ,3),
1074 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio1-vcc", "gpio1_i2c2" ,"NULL", RK3188_GRF_IO_CON1, 10 ,3),
1075 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap1-vcc", "gpio1_i2c4" ,"NULL", RK3188_GRF_IO_CON1, 12 ,3),
1076 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "lcdc1-vcc", "gpio2_lcdc1" ,"NULL", RK3188_GRF_IO_CON1, 14 ,3),
1078 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "lcdc1-vcc", "gpio2_lcdc1" ,"NULL", RK3188_GRF_IO_CON2, 0 ,3),
1079 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "lcdc1-vcc", "gpio2_smc" ,"NULL", RK3188_GRF_IO_CON2, 2 ,3),
1080 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "NULL", "reserve" ,"NULL", RK3188_GRF_IO_CON2, 4 ,3),
1081 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap0-vcc", "gpio3_sdmmc" ,"NULL", RK3188_GRF_IO_CON2, 6 ,3),
1082 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap0-vcc", "gpio3_rmii" ,"NULL", RK3188_GRF_IO_CON2, 6 ,3),
1083 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap0-vcc", "gpio3_sdmmc" ,"NULL", RK3188_GRF_IO_CON2, 8 ,3),
1084 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "ap0-vcc", "gpio3_rmii" ,"NULL", RK3188_GRF_IO_CON2, 8 ,3),
1085 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "cif-vcc", "gpio3_b" ,"NULL", RK3188_GRF_IO_CON2, 10 ,3),
1086 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "cif-vcc", "gpio3_i2c3" ,"NULL", RK3188_GRF_IO_CON2, 10 ,3),
1087 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "cif-vcc", "gpio3_cif" ,"NULL", RK3188_GRF_IO_CON2, 12 ,3),
1088 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "cif-vcc", "gpio3_cif" ,"NULL", RK3188_GRF_IO_CON2, 14 ,3),
1090 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio3_sdio" ,"NULL", RK3188_GRF_IO_CON3, 0 ,3),
1091 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio3_sdio" ,"NULL", RK3188_GRF_IO_CON3, 2 ,3),
1092 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio3_pwm" ,"NULL", RK3188_GRF_IO_CON3, 4 ,3),
1093 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "gpio3_d" ,"NULL", RK3188_GRF_IO_CON3, 6 ,3),
1094 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "flash-vcc", "flash" ,"NULL", RK3188_GRF_IO_CON3, 8 ,3),
1095 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "flash-vcc", "flash" ,"NULL", RK3188_GRF_IO_CON3, 10 ,3),
1096 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "cif-vcc", "cif" ,"NULL", RK3188_GRF_IO_CON3, 12 ,3),
1097 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "lcdc0-vcc", "lcdc0" ,"NULL", RK3188_GRF_IO_CON3, 14 ,3),
1099 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "lcdc0-vcc", "lcdc0" ,"NULL", RK3188_GRF_IO_CON4, 0 ,3),
1100 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "vccio0-vcc", "jtag" ,"NULL", RK3188_GRF_IO_CON4, 2 ,3),
1101 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "NULL", "misc" ,"NULL", RK3188_GRF_IO_CON4, 4 ,3),
1102 FUNC_GROUP_TO_REG_OFFSET(TYPE_DRV_REG, "NULL", "reserve" ,"NULL", RK3188_GRF_IO_CON4, 6 ,3),
1106 static struct func_to_reg_offset rk3188_func_to_vol_reg_offset[] =
1108 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "ap0-vcc", "vol_domain", "ap0-vcc", RK3188_GRF_IO_CON4, 8 ,1),
1109 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "ap1-vcc", "vol_domain", "ap1-vcc", RK3188_GRF_IO_CON4, 9 ,1),
1110 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "cif-vcc", "vol_domain", "cif-vcc", RK3188_GRF_IO_CON4, 10 ,1),
1111 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "flash-vcc", "vol_domain", "flash-vcc", RK3188_GRF_IO_CON4, 11 ,1),
1112 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "vccio0-vcc", "vol_domain", "vccio0-vcc", RK3188_GRF_IO_CON4, 12 ,1),
1113 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "vccio1-vcc", "vol_domain", "vccio1-vcc", RK3188_GRF_IO_CON4, 13 ,1),
1114 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "lcdc0-vcc", "vol_domain", "lcdc0-vcc", RK3188_GRF_IO_CON4, 14 ,1),
1115 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "lcdc1-vcc", "vol_domain", "lcdc1-vcc", RK3188_GRF_IO_CON4, 15 ,1),
1119 static struct func_to_reg_offset rk3288_func_to_vol_reg_offset[] =
1121 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "lcdc-vcc", "vol_domain", "lcdc-vcc", RK3288_GRF_IO_VSEL, 0 ,1),
1122 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "dvp-vcc", "vol_domain", "dvp-vcc", RK3288_GRF_IO_VSEL, 1 ,1),
1123 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "flash0-vcc", "vol_domain", "flash0-vcc", RK3288_GRF_IO_VSEL, 2 ,1),
1124 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "flash1-vcc", "vol_domain", "flash1-vcc", RK3288_GRF_IO_VSEL, 3 ,1),
1125 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "wifi-vcc", "vol_domain", "wifi-vcc", RK3288_GRF_IO_VSEL, 4 ,1),
1126 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "bb-vcc", "vol_domain", "bb-vcc", RK3288_GRF_IO_VSEL, 5 ,1),
1127 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "audio-vcc", "vol_domain", "audio-vcc", RK3288_GRF_IO_VSEL, 6 ,1),
1128 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "sdcard-vcc", "vol_domain", "sdcard-vcc", RK3288_GRF_IO_VSEL, 7 ,1),
1130 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "gpio30-vcc", "vol_domain", "gpio30-vcc", RK3288_GRF_IO_VSEL, 8 ,1),
1131 FUNC_GROUP_TO_REG_OFFSET(TYPE_VOL_REG, "gpio1830-vcc", "vol_domain", "gpio1830-vcc", RK3288_GRF_IO_VSEL, 9 ,1),
1135 static void rk2928_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
1136 int pin_num, void __iomem **reg, u8 *bit)
1138 struct rockchip_pinctrl *info = bank->drvdata;
1139 void __iomem *reg_base;
1142 *reg = info->reg_base + RK2928_PULL_OFFSET;
1143 *reg += bank->bank_num * RK2928_PULL_BANK_STRIDE;
1144 *reg += (pin_num / RK2928_PULL_PINS_PER_REG) * 4;
1146 *bit = pin_num % RK2928_PULL_PINS_PER_REG;
1148 reg_base = info->reg_base;
1150 DBG_PINCTRL("%s:GPIO%d-%d, pull_reg=0x%x, bit=%d\n", __func__, bank->bank_num, pin_num, *reg - reg_base, *bit);
1154 static void rk3188_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
1155 int pin_num, void __iomem **reg, u8 *bit)
1157 struct rockchip_pinctrl *info = bank->drvdata;
1158 void __iomem *reg_base;
1161 /* The first 12 pins of the first bank are located elsewhere */
1162 if (bank->bank_type == RK3188_BANK0 && pin_num < 12) {
1163 *reg = bank->reg_pull_bank0 +
1164 ((pin_num / RK3188_PULL_PINS_PER_REG) * 4);
1165 *bit = pin_num % RK3188_PULL_PINS_PER_REG;
1166 *bit *= RK3188_PULL_BITS_PER_PIN;
1167 reg_base = bank->reg_pull_bank0;
1169 *reg = info->reg_pull - 4;
1170 *reg += bank->bank_num * RK3188_PULL_BANK_STRIDE;
1171 *reg += ((pin_num / RK3188_PULL_PINS_PER_REG) * 4);
1174 * The bits in these registers have an inverse ordering
1175 * with the lowest pin being in bits 15:14 and the highest
1178 *bit = 7 - (pin_num % RK3188_PULL_PINS_PER_REG);
1179 *bit *= RK3188_PULL_BITS_PER_PIN;
1180 reg_base = info->reg_pull - 4;
1183 DBG_PINCTRL("%s:GPIO%d-%d, pull_reg=0x%x, bit=%d\n", __func__, bank->bank_num, pin_num, *reg - reg_base, *bit);
1186 static void rk3288_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
1187 int pin_num, void __iomem **reg, u8 *bit)
1189 struct rockchip_pinctrl *info = bank->drvdata;
1190 void __iomem *reg_base;
1193 /* The first 24 pins of the first bank are located elsewhere */
1194 if (bank->bank_type == RK3288_BANK0 && pin_num < 24) {
1195 *reg = bank->reg_pull_bank0 +
1196 ((pin_num / 8) * 4);
1199 reg_base = bank->reg_pull_bank0;
1201 *reg = info->reg_pull - 0x10;
1202 *reg += bank->bank_num * 0x10;
1203 *reg += ((pin_num / 8) * 4);
1205 *bit = (pin_num % 8);
1207 reg_base = info->reg_pull - 0x10;
1210 DBG_PINCTRL("%s:GPIO%d-%d, pull_reg=0x%x, bit=%d\n", __func__, bank->bank_num, pin_num, *reg - reg_base, *bit);
1214 static void rk3288_calc_drv_reg_and_bit(struct rockchip_pin_bank *bank,
1215 int pin_num, void __iomem **reg, u8 *bit)
1217 struct rockchip_pinctrl *info = bank->drvdata;
1218 void __iomem *reg_base;
1221 /* The first 24 pins of the first bank are located elsewhere */
1222 if (bank->bank_type == RK3288_BANK0 && pin_num < 24) {
1223 *reg = bank->reg_drv_bank0 +
1224 ((pin_num / 8) * 4);
1228 reg_base = bank->reg_drv_bank0;
1230 *reg = info->reg_drv - 0x10;
1231 *reg += bank->bank_num * 0x10;
1232 *reg += ((pin_num / 8) * 4);
1234 *bit = (pin_num % 8);
1237 reg_base = info->reg_drv - 0x10;
1240 DBG_PINCTRL("%s:GPIO%d-%d, drv_reg=0x%x, bit=%d\n", __func__, bank->bank_num, pin_num, *reg - reg_base, *bit);
1244 static void rk3036_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
1245 int pin_num, void __iomem **reg, u8 *bit)
1247 struct rockchip_pinctrl *info = bank->drvdata;
1248 void __iomem *reg_base;
1251 *reg = info->reg_pull;
1252 *reg += bank->bank_num * RK3036_PULL_BANK_STRIDE;
1253 *reg += (pin_num / RK3036_PULL_PINS_PER_REG) * 4;
1255 *bit = pin_num % RK3036_PULL_PINS_PER_REG;
1257 reg_base = info->reg_pull;
1259 DBG_PINCTRL("%s:GPIO%d-%d, pull_reg=0x%x, bit=%d\n", __func__, bank->bank_num, pin_num, *reg - reg_base, *bit);
1263 static void rk312x_calc_pull_reg_and_bit(struct rockchip_pin_bank *bank,
1264 int pin_num, void __iomem **reg, u8 *bit)
1266 struct rockchip_pinctrl *info = bank->drvdata;
1267 void __iomem *reg_base;
1270 *reg = info->reg_pull;
1271 *reg += bank->bank_num * RK312X_PULL_BANK_STRIDE;
1272 *reg += (pin_num / RK312X_PULL_PINS_PER_REG) * 4;
1274 *bit = pin_num % RK312X_PULL_PINS_PER_REG;
1276 reg_base = info->reg_pull;
1278 DBG_PINCTRL("%s:GPIO%d-%d, pull_reg=0x%x, bit=%d\n", __func__, bank->bank_num, pin_num, *reg - reg_base, *bit);
1285 static int rockchip_get_pull(struct rockchip_pin_bank *bank, int pin_num)
1287 struct rockchip_pinctrl *info = bank->drvdata;
1288 struct rockchip_pin_ctrl *ctrl = info->ctrl;
1294 /* rk3066b does support any pulls */
1295 if (ctrl->type == RK3066B)
1296 return PIN_CONFIG_BIAS_DISABLE;
1298 ctrl->pull_calc_reg(bank, pin_num, ®, &bit);
1300 switch (ctrl->type) {
1302 return !(readl_relaxed(reg) & BIT(bit))
1303 ? PIN_CONFIG_BIAS_PULL_PIN_DEFAULT
1304 : PIN_CONFIG_BIAS_DISABLE;
1307 data = readl_relaxed(reg) >> bit;
1308 data &= (1 << RK3188_PULL_BITS_PER_PIN) - 1;
1312 return PIN_CONFIG_BIAS_DISABLE;
1314 return PIN_CONFIG_BIAS_PULL_UP;
1316 return PIN_CONFIG_BIAS_PULL_DOWN;
1318 return PIN_CONFIG_BIAS_BUS_HOLD;
1321 dev_err(info->dev, "unknown pull setting\n");
1324 dev_err(info->dev, "unsupported pinctrl type\n");
1328 DBG_PINCTRL("%s:GPIO%d-%d pull is 0x%x\n", __func__, bank->bank_num, pin_num, data);
1332 static int rockchip_set_pull(struct rockchip_pin_bank *bank,
1333 int pin_num, int pull)
1335 struct rockchip_pinctrl *info = bank->drvdata;
1336 struct rockchip_pin_ctrl *ctrl = info->ctrl;
1338 unsigned long flags;
1344 /* rk3066b does support any pulls */
1345 if (ctrl->type == RK3066B)
1346 return pull ? -EINVAL : 0;
1348 ctrl->pull_calc_reg(bank, pin_num, ®, &bit);
1350 switch (ctrl->type) {
1354 spin_lock_irqsave(&bank->slock, flags);
1356 data = BIT(bit + 16);
1357 if (pull == PIN_CONFIG_BIAS_DISABLE)
1360 if(pull != PIN_CONFIG_BIAS_PULL_PIN_DEFAULT)
1363 spin_unlock_irqrestore(&bank->slock, flags);
1367 spin_lock_irqsave(&bank->slock, flags);
1369 /* enable the write to the equivalent lower bits */
1370 data = ((1 << RK3188_PULL_BITS_PER_PIN) - 1) << (bit + 16);
1373 case PIN_CONFIG_BIAS_DISABLE:
1375 case PIN_CONFIG_BIAS_PULL_UP:
1378 case PIN_CONFIG_BIAS_PULL_DOWN:
1381 case PIN_CONFIG_BIAS_BUS_HOLD:
1385 dev_err(info->dev, "unsupported pull setting %d\n",
1392 spin_unlock_irqrestore(&bank->slock, flags);
1395 dev_err(info->dev, "unsupported pinctrl type\n");
1400 DBG_PINCTRL("%s:GPIO%d-%d pull is 0x%x\n", __func__, bank->bank_num, pin_num, data);
1406 * Pinconf_ops handling
1409 static bool rockchip_pinconf_pull_valid(struct rockchip_pin_ctrl *ctrl,
1410 enum pin_config_param pull)
1412 switch (ctrl->type) {
1416 return (pull == PIN_CONFIG_BIAS_PULL_PIN_DEFAULT ||
1417 pull == PIN_CONFIG_BIAS_DISABLE);
1419 return pull ? false : true;
1421 return (pull != PIN_CONFIG_BIAS_PULL_PIN_DEFAULT);
1423 return (pull != PIN_CONFIG_BIAS_PULL_PIN_DEFAULT);
1430 static int _rockchip_pinconf_get(struct rockchip_pin_bank *bank,
1431 int pin_num, unsigned long *config, int config_type, unsigned group)
1433 struct rockchip_pinctrl *info = bank->drvdata;
1434 struct rockchip_pin_ctrl *ctrl = info->ctrl;
1435 struct func_to_reg_offset reg_offset[4];//same name count should be less four
1436 struct func_to_reg_offset *func_to_reg;
1437 int i = 0, ii = 0, j = 0, jj = 0, num = 0;
1440 unsigned long flags;
1448 DBG_PINCTRL("%s:GPIO%d-%d,group=%s, function=%s, type=%d\n", __func__, bank->bank_num, pin_num, info->groups[group].name, info->groups[group].func_name, config_type);
1470 //compare group_name
1471 func_to_reg = rk3188_func_to_vol_reg_offset;
1472 num = ARRAY_SIZE(rk3188_func_to_vol_reg_offset);
1473 for(i = 0; i < num; i++)
1475 //lcdc0-vcc-33 = lcdc0-vcc and lcdc0-vcc-18=lcdc0-vcc
1476 if(strstr(info->groups[group].name, func_to_reg[i].group_name) != NULL)
1478 reg_offset[j++] = func_to_reg[i];
1479 DBG_PINCTRL("%s:select \"%s\" dts:\"%s\"\n",__func__, func_to_reg[i].group_name, info->groups[group].name);
1485 func_to_reg = rk3188_func_to_drv_reg_offset;
1486 num = ARRAY_SIZE(rk3188_func_to_drv_reg_offset);
1487 for(i = 0; i < num; i++)
1489 if(!strcmp(info->groups[group].func_name, func_to_reg[i].func_name))
1492 func_to_reg = rk3188_func_to_vol_reg_offset;
1493 num = ARRAY_SIZE(rk3188_func_to_vol_reg_offset);
1494 for(ii = 0; ii < num; ii++)
1496 if(!strcmp(func_to_reg[i].vol_name, func_to_reg[ii].group_name))
1498 reg_offset[jj++] = func_to_reg[ii];
1499 DBG_PINCTRL("%s:select \"%s\"\n",__func__, func_to_reg[ii].group_name);
1516 func_to_reg = rk3188_func_to_drv_reg_offset;
1517 num = ARRAY_SIZE(rk3188_func_to_drv_reg_offset);
1518 for(i = 0; i < num; i++)
1520 if(!strcmp(info->groups[group].func_name, func_to_reg[i].func_name))
1522 reg_offset[j++] = func_to_reg[i];
1523 DBG_PINCTRL("%s:select \"%s\"\n",__func__, func_to_reg[i].func_name);
1544 //compare group_name
1545 func_to_reg = rk3288_func_to_vol_reg_offset;
1546 num = ARRAY_SIZE(rk3288_func_to_vol_reg_offset);
1547 for(i = 0; i < num; i++)
1549 //lcdc-vcc-33 = lcdc-vcc and lcdc-vcc-18 = lcdc-vcc
1550 if(strstr(info->groups[group].name, func_to_reg[i].group_name) != NULL)
1552 reg_offset[j++] = func_to_reg[i];
1553 DBG_PINCTRL("%s:select \"%s\" dts:\"%s\"\n",__func__, func_to_reg[i].group_name, info->groups[group].name);
1561 ctrl->drv_calc_reg(bank, pin_num, ®, &bit);
1563 data = readl_relaxed(reg) >> bit;
1564 data &= (1 << 2) - 1;
1581 if((ctrl->type == RK3188) || ((ctrl->type == RK3288) && (config_type == TYPE_VOL_REG)))
1585 printk("%s:could find config register for PIN%d-%d,type=%d,num=%d\n",__func__, bank->bank_num, pin_num, config_type, num);
1590 for(i=0; i < j; i++)
1592 reg = info->reg_base + reg_offset[i].reg_offset;
1593 spin_lock_irqsave(&bank->slock, flags);
1594 data = readl_relaxed(reg) >> reg_offset[i].bit_offset;
1595 data &= reg_offset[i].bit_mask;
1596 spin_unlock_irqrestore(&bank->slock, flags);
1600 DBG_PINCTRL("%s:reg_offset[%d]=0x%x,,bit_offset[%d]=0x%x,data[%d]=0x%x\n",__func__, i, reg_offset[i].reg_offset, i, reg_offset[i].bit_offset, i, data);
1604 else if((ctrl->type == RK3288) && (config_type == TYPE_DRV_REG))
1606 DBG_PINCTRL("%s:GPIO-%d %d drv=0x%x\n",__func__, bank->bank_num, pin_num, (u32)*config);
1614 static int _rockchip_pinconf_set(struct rockchip_pin_bank *bank,
1615 int pin_num, int arg, int config_type, unsigned group)
1617 struct rockchip_pinctrl *info = bank->drvdata;
1618 struct rockchip_pin_ctrl *ctrl = info->ctrl;
1619 struct func_to_reg_offset reg_offset[4];//same name count should be less four
1620 struct func_to_reg_offset *func_to_reg;
1621 int i = 0, ii = 0, j = 0, jj = 0, num = 0;
1622 int data = 0, value = 0;
1624 unsigned long flags;
1632 DBG_PINCTRL("%s:GPIO%d-%d,group=%s, function=%s, type=%d\n", __func__, bank->bank_num, pin_num, info->groups[group].name, info->groups[group].func_name, config_type);
1654 //compare group_name
1655 func_to_reg = rk3188_func_to_vol_reg_offset;
1656 num = ARRAY_SIZE(rk3188_func_to_vol_reg_offset);
1657 for(i = 0; i < num; i++)
1659 //lcdc0-vcc-33 = lcdc0-vcc and lcdc0-vcc-18=lcdc0-vcc
1660 if(strstr(info->groups[group].name, func_to_reg[i].group_name) != NULL)
1662 reg_offset[j++] = func_to_reg[i];
1663 DBG_PINCTRL("%s:select \"%s\" dts:\"%s\"\n",__func__, func_to_reg[i].group_name, info->groups[group].name);
1669 func_to_reg = rk3188_func_to_drv_reg_offset;
1670 num = ARRAY_SIZE(rk3188_func_to_drv_reg_offset);
1671 for(i = 0; i < num; i++)
1673 if(!strcmp(info->groups[group].func_name, func_to_reg[i].func_name))
1676 func_to_reg = rk3188_func_to_vol_reg_offset;
1677 num = ARRAY_SIZE(rk3188_func_to_vol_reg_offset);
1678 for(ii = 0; ii < num; ii++)
1680 if(!strcmp(rk3188_func_to_drv_reg_offset[i].vol_name, func_to_reg[ii].group_name))
1682 reg_offset[jj++] = func_to_reg[ii];
1683 DBG_PINCTRL("%s:select \"%s\"\n",__func__, func_to_reg[ii].group_name);
1700 func_to_reg = rk3188_func_to_drv_reg_offset;
1701 num = ARRAY_SIZE(rk3188_func_to_drv_reg_offset);
1702 for(i = 0; i < num; i++)
1704 if(!strcmp(info->groups[group].func_name, func_to_reg[i].func_name))
1706 reg_offset[j++] = func_to_reg[i];
1707 DBG_PINCTRL("%s:select \"%s\"\n",__func__, func_to_reg[i].func_name);
1728 //compare group_name
1729 func_to_reg = rk3288_func_to_vol_reg_offset;
1730 num = ARRAY_SIZE(rk3288_func_to_vol_reg_offset);
1731 for(i = 0; i < num; i++)
1733 //lcdc-vcc-33 = lcdc-vcc and lcdc-vcc-18 = lcdc-vcc
1734 if(strstr(info->groups[group].name, func_to_reg[i].group_name) != NULL)
1736 reg_offset[j++] = func_to_reg[i];
1737 DBG_PINCTRL("%s:select \"%s\" dts:\"%s\"\n",__func__, func_to_reg[i].group_name, info->groups[group].name);
1745 ctrl->drv_calc_reg(bank, pin_num, ®, &bit);
1747 spin_lock_irqsave(&bank->slock, flags);
1751 data |= (3<<(bit+16));
1753 writel_relaxed(data, reg);
1754 spin_unlock_irqrestore(&bank->slock, flags);
1770 if((bank->bank_num == 1) && (pin_num >= 0) && (pin_num <= 3))
1772 bit = pin_num*2 + 4;
1773 reg = info->reg_drv;
1774 spin_lock_irqsave(&bank->slock, flags);
1778 data |= (3<<(bit+16));
1780 writel_relaxed(data, reg);
1781 spin_unlock_irqrestore(&bank->slock, flags);
1785 printk("%s:RK3036 GPIO%d-%d could not support driver setting\n",__func__, bank->bank_num, pin_num);
1801 if((bank->bank_num == 0)&&((pin_num == GPIO_A6)|| (pin_num == GPIO_A7)||(pin_num == GPIO_B7)||(pin_num == GPIO_C4)))
1803 if(pin_num == GPIO_A6)
1805 else if(pin_num == GPIO_A7)
1807 else if(pin_num == GPIO_B7)
1809 else if(pin_num == GPIO_C4)
1812 reg = info->reg_drv;
1813 spin_lock_irqsave(&bank->slock, flags);
1817 data |= (3<<(bit+16));
1819 writel_relaxed(data, reg);
1820 spin_unlock_irqrestore(&bank->slock, flags);
1824 printk("%s:RK312X GPIO%d-%d could not support driver setting\n",__func__, bank->bank_num, pin_num);
1839 if((ctrl->type == RK3188) || ((ctrl->type == RK3288) && (config_type == TYPE_VOL_REG)))
1843 printk("%s:could not find config register for PIN%d-%d,type=%d,num=%d\n",__func__, bank->bank_num, pin_num, config_type, num);
1847 for(i=0; i < j; i++)
1849 reg = info->reg_base + reg_offset[i].reg_offset;
1850 data |= ((reg_offset[i].bit_mask) << (16 + reg_offset[i].bit_offset));
1851 data |= ((arg & reg_offset[i].bit_mask) << reg_offset[i].bit_offset);
1852 spin_lock_irqsave(&bank->slock, flags);
1853 writel_relaxed(data, reg);
1854 value = readl_relaxed(reg);
1855 spin_unlock_irqrestore(&bank->slock, flags);
1856 DBG_PINCTRL("%s:reg_offset[%d]=0x%x,,bit_offset[%d]=%d,data[%d]=0x%08x,result=0x%08x,arg=%d\n",__func__, i, reg_offset[i].reg_offset, i, reg_offset[i].bit_offset, i, data, value, arg);
1861 else if((ctrl->type == RK3288) && (config_type == TYPE_DRV_REG))
1863 DBG_PINCTRL("%s:GPIO-%d %d data=0x%x,type=%d\n",__func__, bank->bank_num, pin_num, data,TYPE_DRV_REG);
1870 /* set the pin config settings for a specified pin */
1871 static int rockchip_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
1872 unsigned long configs, unsigned group)
1874 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
1875 struct rockchip_pin_bank *bank = pin_to_bank(info, pin);
1876 struct rockchip_pin_group *grp = &info->groups[group];
1877 enum pin_config_param param;
1882 param = pinconf_to_config_param(configs);
1883 arg = pinconf_to_config_argument(configs);
1886 case PIN_CONFIG_BIAS_DISABLE:
1887 rc = rockchip_set_pull(bank, pin - bank->pin_base,
1892 case PIN_CONFIG_BIAS_PULL_UP:
1893 case PIN_CONFIG_BIAS_PULL_DOWN:
1894 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
1895 case PIN_CONFIG_BIAS_BUS_HOLD:
1896 if (!rockchip_pinconf_pull_valid(info->ctrl, param))
1902 rc = rockchip_set_pull(bank, pin - bank->pin_base,
1908 case PIN_CONFIG_POWER_SOURCE:
1909 rc = _rockchip_pinconf_set(bank, pin - bank->pin_base, arg, TYPE_VOL_REG, group);
1914 case PIN_CONFIG_DRIVE_STRENGTH:
1915 rc = _rockchip_pinconf_set(bank, pin - bank->pin_base, arg, TYPE_DRV_REG, group);
1919 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
1920 rc = _rockchip_pinconf_set(bank, pin - bank->pin_base, arg, TYPE_TRI_REG, group);
1929 /* cache the config value for rockchip_pinconf_get() */
1930 grp->gconfigs = configs;
1932 DBG_PINCTRL("%s,bank_num=%d,pin=%d,param=%d, arg=%d\n",__func__,bank->bank_num, pin, param, arg);
1938 /* get the pin config settings for a specified pin */
1939 static int rockchip_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
1940 unsigned long *config, unsigned group)
1942 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
1943 struct rockchip_pin_bank *bank = pin_to_bank(info, pin);
1944 enum pin_config_param param = pinconf_to_config_param(*config);
1948 case PIN_CONFIG_BIAS_DISABLE:
1949 if (rockchip_get_pull(bank, pin - bank->pin_base) != param)
1954 case PIN_CONFIG_BIAS_PULL_UP:
1955 case PIN_CONFIG_BIAS_PULL_DOWN:
1956 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
1957 case PIN_CONFIG_BIAS_BUS_HOLD:
1958 if (!rockchip_pinconf_pull_valid(info->ctrl, param))
1961 if (rockchip_get_pull(bank, pin - bank->pin_base) != param)
1967 case PIN_CONFIG_POWER_SOURCE:
1968 rc = _rockchip_pinconf_get(bank, pin - bank->pin_base, config, TYPE_VOL_REG, group);
1973 case PIN_CONFIG_DRIVE_STRENGTH:
1974 rc = _rockchip_pinconf_get(bank, pin - bank->pin_base, config, TYPE_DRV_REG, group);
1978 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
1979 rc = _rockchip_pinconf_get(bank, pin - bank->pin_base, config, TYPE_TRI_REG, group);
1990 DBG_PINCTRL("%s:bank_num=%d, pin=%d, param=%d\n",__func__, bank->bank_num, pin, param);
1996 /* set the pin config settings for a specified pin group */
1997 static int rockchip_pinconf_group_set(struct pinctrl_dev *pctldev,
1998 unsigned group, unsigned long config)
2000 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
2001 const unsigned int *pins;
2003 struct rockchip_pin_bank *bank;
2006 pins = info->groups[group].pins;
2008 for (cnt = 0; cnt < info->groups[group].npins; cnt++)
2010 bank = pin_to_bank(info, pins[cnt]);
2012 DBG_PINCTRL("%s:group[%d]:%s, pins[%d]=%d\n",__func__, group, info->groups[group].name, cnt, pins[cnt]);
2013 rockchip_pinconf_set(pctldev, pins[cnt], config, group);
2019 /* get the pin config settings for a specified pin group */
2020 static int rockchip_pinconf_group_get(struct pinctrl_dev *pctldev,
2021 unsigned int group, unsigned long *config)
2023 struct rockchip_pinctrl *info = pinctrl_dev_get_drvdata(pctldev);
2024 const unsigned int *pins;
2025 struct rockchip_pin_bank *bank;
2027 pins = info->groups[group].pins;
2028 bank = pin_to_bank(info, pins[0]);
2030 //rockchip_pinconf_get(pctldev, pins[0], config, group);
2031 *config = info->groups[group].gconfigs;
2032 if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
2033 printk("%s:group[%d]:%s,config=0x%lx\n",__func__, group, info->groups[group].name, *config);
2037 static void rockchip_pinconf_dbg_show(struct pinctrl_dev *pctldev,
2038 struct seq_file *s, unsigned pin)
2043 static void rockchip_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
2044 struct seq_file *s, unsigned group)
2050 static const struct pinconf_ops rockchip_pinconf_ops = {
2051 .pin_config_group_get = rockchip_pinconf_group_get,
2052 .pin_config_group_set = rockchip_pinconf_group_set,
2053 .pin_config_dbg_show = rockchip_pinconf_dbg_show,
2054 .pin_config_group_dbg_show = rockchip_pinconf_group_dbg_show,
2057 static const struct of_device_id rockchip_bank_match[] = {
2058 { .compatible = "rockchip,gpio-bank" },
2059 { .compatible = "rockchip,rk3188-gpio-bank0" },
2060 { .compatible = "rockchip,rk3288-gpio-bank0" },
2064 static void rockchip_pinctrl_child_count(struct rockchip_pinctrl *info,
2065 struct device_node *np)
2067 struct device_node *child;
2069 for_each_child_of_node(np, child) {
2070 if (of_match_node(rockchip_bank_match, child))
2074 info->ngroups += of_get_child_count(child);
2078 static int rockchip_pinctrl_parse_groups(struct device_node *np,
2079 struct rockchip_pin_group *grp,
2080 struct rockchip_pinctrl *info,
2083 struct rockchip_pin_bank *bank;
2087 struct union_mode m;
2089 unsigned long *pinconfig;
2092 //printk("%s:group(%d): %s\n", __func__, index, np->name);
2094 /* Initialise group */
2095 grp->name = np->name;
2098 * the binding format is rockchip,pins = <mux>,
2099 * do sanity check and calculate pins number
2101 list = of_get_property(np, "rockchip,pins", &size);
2102 /* we do not check return since it's safe node passed down */
2103 size /= sizeof(*list);
2104 if (!size || size % 1) {
2105 dev_err(info->dev, "wrong pins number or pins and configs should be by 1\n");
2109 grp->npins = size / 1;
2111 grp->pins = devm_kzalloc(info->dev, grp->npins * sizeof(unsigned int),
2113 grp->data = devm_kzalloc(info->dev, grp->npins *
2114 sizeof(struct rockchip_pin_config),
2116 if (!grp->pins || !grp->data)
2119 pinconfig = kzalloc(configlen * sizeof(*pinconfig), GFP_KERNEL);
2121 for (i = 0; i < size; i++) {
2122 m.mode = be32_to_cpu(*list++);
2124 bank = bank_num_to_bank(info, m.mux.bank);
2126 return PTR_ERR(bank);
2128 grp->pins[i] = bank->pin_base + (m.mux.goff - 0x0A) * 8 + m.mux.off;
2129 grp->data[i].func = m.mode;
2135 if (of_find_property(np, "rockchip,pull", NULL))
2137 if (of_find_property(np, "rockchip,voltage", NULL))
2139 if (of_find_property(np, "rockchip,drive", NULL))
2141 if (of_find_property(np, "rockchip,tristate", NULL))
2144 pinconfig = kzalloc(configlen * sizeof(*pinconfig), GFP_KERNEL);
2146 if (!of_property_read_u32(np, "rockchip,pull", &val)) {
2147 enum pin_config_param pull = PIN_CONFIG_END;
2149 pull = PIN_CONFIG_BIAS_DISABLE;
2151 pull = PIN_CONFIG_BIAS_PULL_UP;
2153 pull = PIN_CONFIG_BIAS_PULL_DOWN;
2155 pull = PIN_CONFIG_BIAS_BUS_HOLD;
2157 pull = PIN_CONFIG_BIAS_PULL_PIN_DEFAULT;
2159 pinconfig[j++] = pinconf_to_config_packed(pull, val);
2162 if (!of_property_read_u32(np, "rockchip,voltage", &val)) {
2164 pinconf_to_config_packed(PIN_CONFIG_POWER_SOURCE,
2168 if (!of_property_read_u32(np, "rockchip,drive", &val)) {
2170 pinconf_to_config_packed(PIN_CONFIG_DRIVE_STRENGTH,
2174 if (!of_property_read_u32(np, "rockchip,tristate", &val)) {
2176 pinconf_to_config_packed(PIN_CONFIG_BIAS_HIGH_IMPEDANCE,
2180 grp->data[i].configs = pinconfig;
2181 grp->data[i].nconfigs = configlen;
2189 static int rockchip_pinctrl_parse_functions(struct device_node *np,
2190 struct rockchip_pinctrl *info,
2193 struct device_node *child;
2194 struct rockchip_pmx_func *func;
2195 struct rockchip_pin_group *grp;
2197 static u32 grp_index;
2200 //printk("%s:parse function(%d): %s\n", __func__, index, np->name);
2202 func = &info->functions[index];
2204 /* Initialise function */
2205 func->name = np->name;
2206 func->ngroups = of_get_child_count(np);
2207 if (func->ngroups <= 0)
2210 func->groups = devm_kzalloc(info->dev,
2211 func->ngroups * sizeof(char *), GFP_KERNEL);
2215 for_each_child_of_node(np, child) {
2216 func->groups[i] = child->name;
2217 grp = &info->groups[grp_index++];
2218 grp->func_name = np->name;
2219 ret = rockchip_pinctrl_parse_groups(child, grp, info, i++);
2223 //printk("%s:grp->func_name(%d): %s\n", __func__, grp_index, grp->func_name);
2229 static int rockchip_pinctrl_parse_dt(struct platform_device *pdev,
2230 struct rockchip_pinctrl *info)
2232 struct device *dev = &pdev->dev;
2233 struct device_node *np = dev->of_node;
2234 struct device_node *child;
2238 rockchip_pinctrl_child_count(info, np);
2240 dev_dbg(&pdev->dev, "nfunctions = %d\n", info->nfunctions);
2241 dev_dbg(&pdev->dev, "ngroups = %d\n", info->ngroups);
2243 info->functions = devm_kzalloc(dev, info->nfunctions *
2244 sizeof(struct rockchip_pmx_func),
2246 if (!info->functions) {
2247 dev_err(dev, "failed to allocate memory for function list\n");
2251 info->groups = devm_kzalloc(dev, info->ngroups *
2252 sizeof(struct rockchip_pin_group),
2254 if (!info->groups) {
2255 dev_err(dev, "failed allocate memory for ping group list\n");
2261 for_each_child_of_node(np, child) {
2262 if (of_match_node(rockchip_bank_match, child))
2265 ret = rockchip_pinctrl_parse_functions(child, info, i++);
2267 dev_err(&pdev->dev, "failed to parse function\n");
2275 static int rockchip_pinctrl_register(struct platform_device *pdev,
2276 struct rockchip_pinctrl *info)
2278 struct pinctrl_desc *ctrldesc = &info->pctl;
2279 struct pinctrl_pin_desc *pindesc, *pdesc;
2280 struct rockchip_pin_bank *pin_bank;
2284 ctrldesc->name = "rockchip-pinctrl";
2285 ctrldesc->owner = THIS_MODULE;
2286 ctrldesc->pctlops = &rockchip_pctrl_ops;
2287 ctrldesc->pmxops = &rockchip_pmx_ops;
2288 ctrldesc->confops = &rockchip_pinconf_ops;
2290 pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) *
2291 info->ctrl->nr_pins, GFP_KERNEL);
2293 dev_err(&pdev->dev, "mem alloc for pin descriptors failed\n");
2296 ctrldesc->pins = pindesc;
2297 ctrldesc->npins = info->ctrl->nr_pins;
2300 for (bank = 0 , k = 0; bank < info->ctrl->nr_banks; bank++) {
2301 pin_bank = &info->ctrl->pin_banks[bank];
2302 for (pin = 0; pin < pin_bank->nr_pins; pin++, k++) {
2304 pdesc->name = kasprintf(GFP_KERNEL, "%s-%d",
2305 pin_bank->name, pin);
2310 info->pctl_dev = pinctrl_register(ctrldesc, &pdev->dev, info);
2311 if (!info->pctl_dev) {
2312 dev_err(&pdev->dev, "could not register pinctrl driver\n");
2316 for (bank = 0; bank < info->ctrl->nr_banks; ++bank) {
2317 pin_bank = &info->ctrl->pin_banks[bank];
2318 pin_bank->grange.name = pin_bank->name;
2319 pin_bank->grange.id = bank;
2320 pin_bank->grange.pin_base = pin_bank->pin_base;
2321 pin_bank->grange.base = pin_bank->gpio_chip.base;
2322 pin_bank->grange.npins = pin_bank->gpio_chip.ngpio;
2323 pin_bank->grange.gc = &pin_bank->gpio_chip;
2324 pinctrl_add_gpio_range(info->pctl_dev, &pin_bank->grange);
2327 ret = rockchip_pinctrl_parse_dt(pdev, info);
2329 pinctrl_unregister(info->pctl_dev);
2340 static int rockchip_gpio_request(struct gpio_chip *chip, unsigned offset)
2342 struct rockchip_pin_bank *bank = gc_to_pin_bank(chip);
2343 struct rockchip_pinctrl *info = bank->drvdata;
2346 if(bank->bank_num == 15)
2348 printk("%s:error bank num %d is out of range\n",__func__, bank->bank_num);
2353 DBG_PINCTRL("%s:GPIO%d-%d\n", __func__, bank->bank_num, offset);
2354 return pinctrl_request_gpio(chip->base + offset);
2357 static void rockchip_gpio_free(struct gpio_chip *chip, unsigned offset)
2359 struct rockchip_pin_bank *bank = gc_to_pin_bank(chip);
2360 struct rockchip_pinctrl *info = bank->drvdata;
2363 if(bank->bank_num == 15)
2365 printk("%s:error bank num %d is out of range\n",__func__, bank->bank_num);
2368 DBG_PINCTRL("%s:GPIO%d-%d\n", __func__, bank->bank_num, offset);
2369 pinctrl_free_gpio(chip->base + offset);
2372 static void rockchip_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
2374 struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
2375 struct rockchip_pinctrl *info = bank->drvdata;
2376 void __iomem *reg = bank->reg_base + GPIO_SWPORT_DR;
2377 unsigned long flags;
2381 spin_lock_irqsave(&bank->slock, flags);
2384 data &= ~BIT(offset);
2386 data |= BIT(offset);
2389 spin_unlock_irqrestore(&bank->slock, flags);
2391 DBG_PINCTRL("%s:GPIO%d-%d level = %d\n", __func__, bank->bank_num, offset, value);
2395 * Returns the level of the pin for input direction and setting of the DR
2396 * register for output gpios.
2398 static int rockchip_gpio_get(struct gpio_chip *gc, unsigned offset)
2400 struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
2401 struct rockchip_pinctrl *info = bank->drvdata;
2405 data = readl(bank->reg_base + GPIO_EXT_PORT);
2409 DBG_PINCTRL("%s:GPIO%d-%d level = %d\n", __func__, bank->bank_num, offset, data);
2414 * gpiolib gpio_direction_input callback function. The setting of the pin
2415 * mux function as 'gpio input' will be handled by the pinctrl susbsystem
2418 static int rockchip_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
2420 struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
2421 struct rockchip_pinctrl *info = bank->drvdata;
2424 if(bank->bank_num == 15)
2426 printk("%s:error bank num %d is out of range\n",__func__, bank->bank_num);
2430 DBG_PINCTRL("%s:GPIO%d-%d\n", __func__, bank->bank_num, offset);
2431 return pinctrl_gpio_direction_input(gc->base + offset);
2435 * gpiolib gpio_direction_output callback function. The setting of the pin
2436 * mux function as 'gpio output' will be handled by the pinctrl susbsystem
2439 static int rockchip_gpio_direction_output(struct gpio_chip *gc,
2440 unsigned offset, int value)
2442 struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
2443 struct rockchip_pinctrl *info = bank->drvdata;
2446 if(bank->bank_num == 15)
2448 printk("%s:error bank num %d is out of range\n",__func__, bank->bank_num);
2452 rockchip_gpio_set(gc, offset, value);
2454 DBG_PINCTRL("%s:set GPIO%d-%d level %d\n", __func__, bank->bank_num, offset, value);
2455 return pinctrl_gpio_direction_output(gc->base + offset);
2459 * gpiolib gpio_to_irq callback function. Creates a mapping between a GPIO pin
2460 * and a virtual IRQ, if not already present.
2462 static int rockchip_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
2464 struct rockchip_pin_bank *bank = gc_to_pin_bank(gc);
2465 struct rockchip_pinctrl *info = bank->drvdata;
2470 if(bank->bank_num == 15)
2472 printk("%s:error bank num %d is out of range\n",__func__, bank->bank_num);
2479 virq = irq_create_mapping(bank->domain, offset);
2481 DBG_PINCTRL("%s:virq=%d, GPIO%d-%d\n", __func__, virq, bank->bank_num, offset);
2483 return (virq) ? : -ENXIO;
2486 static const struct gpio_chip rockchip_gpiolib_chip = {
2487 .request = rockchip_gpio_request,
2488 .free = rockchip_gpio_free,
2489 .set = rockchip_gpio_set,
2490 .get = rockchip_gpio_get,
2491 .direction_input = rockchip_gpio_direction_input,
2492 .direction_output = rockchip_gpio_direction_output,
2493 .to_irq = rockchip_gpio_to_irq,
2494 .owner = THIS_MODULE,
2498 * Interrupt handling
2501 static void rockchip_irq_demux(unsigned int irq, struct irq_desc *desc)
2503 struct irq_chip *chip = irq_get_chip(irq);
2504 struct rockchip_pin_bank *bank = irq_get_handler_data(irq);
2505 struct rockchip_pinctrl *info = bank->drvdata;
2508 u32 polarity = 0, data = 0;
2510 bool edge_changed = false;
2512 chained_irq_enter(chip, desc);
2514 pend = readl_relaxed(bank->reg_base + GPIO_INT_STATUS);
2516 if (bank->toggle_edge_mode) {
2517 polarity = readl_relaxed(bank->reg_base +
2519 data = readl_relaxed(bank->reg_base + GPIO_EXT_PORT);
2527 virq = irq_linear_revmap(bank->domain, irq);
2530 dev_err(bank->drvdata->dev, "unmapped irq %d\n", irq);
2534 dev_dbg(bank->drvdata->dev, "handling irq %d\n", irq);
2537 * Triggering IRQ on both rising and falling edge
2538 * needs manual intervention.
2540 if (bank->toggle_edge_mode & BIT(irq)) {
2541 if (data & BIT(irq))
2542 polarity &= ~BIT(irq);
2544 polarity |= BIT(irq);
2546 edge_changed = true;
2549 generic_handle_irq(virq);
2552 DBG_PINCTRL("%s:irq=%d,%s\n",__func__, irq, bank->name);
2555 if (bank->toggle_edge_mode && edge_changed) {
2556 /* Interrupt params should only be set with ints disabled */
2557 data = readl_relaxed(bank->reg_base + GPIO_INTEN);
2558 writel_relaxed(0, bank->reg_base + GPIO_INTEN);
2559 writel(polarity, bank->reg_base + GPIO_INT_POLARITY);
2560 writel(data, bank->reg_base + GPIO_INTEN);
2563 chained_irq_exit(chip, desc);
2566 static int rockchip_gpio_irq_set_type(struct irq_data *d, unsigned int type)
2568 struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
2569 struct rockchip_pinctrl *info = bank->drvdata;
2570 u32 mask = BIT(d->hwirq);
2575 unsigned long flags;
2578 /* make sure the pin is configured as gpio input */
2579 mux = (bank->bank_num << 12) | (((d->hwirq / 8) + 0x0A) << 8) | ((d->hwirq % 8)<< 4) | RK_FUNC_GPIO;
2580 rockchip_set_mux(bank, d->hwirq, mux);
2582 data = readl_relaxed(bank->reg_base + GPIO_SWPORT_DDR);
2584 writel_relaxed(data, bank->reg_base + GPIO_SWPORT_DDR);
2586 if (type & IRQ_TYPE_EDGE_BOTH)
2587 __irq_set_handler_locked(d->irq, handle_edge_irq);
2589 __irq_set_handler_locked(d->irq, handle_level_irq);
2591 spin_lock_irqsave(&bank->slock, flags);
2593 level = readl_relaxed(bank->reg_base + GPIO_INTTYPE_LEVEL);
2594 polarity = readl_relaxed(bank->reg_base + GPIO_INT_POLARITY);
2597 case IRQ_TYPE_EDGE_BOTH:
2598 bank->toggle_edge_mode |= mask;
2602 * Determine gpio state. If 1 next interrupt should be falling
2605 data = readl(bank->reg_base + GPIO_EXT_PORT);
2611 case IRQ_TYPE_EDGE_RISING:
2612 bank->toggle_edge_mode &= ~mask;
2616 case IRQ_TYPE_EDGE_FALLING:
2617 bank->toggle_edge_mode &= ~mask;
2621 case IRQ_TYPE_LEVEL_HIGH:
2622 bank->toggle_edge_mode &= ~mask;
2626 case IRQ_TYPE_LEVEL_LOW:
2627 bank->toggle_edge_mode &= ~mask;
2632 //spin_unlock_irqrestore(&bank->slock, flags);
2636 writel_relaxed(level, bank->reg_base + GPIO_INTTYPE_LEVEL);
2637 writel_relaxed(polarity, bank->reg_base + GPIO_INT_POLARITY);
2639 spin_unlock_irqrestore(&bank->slock, flags);
2641 DBG_PINCTRL("%s:type=%d,irq=%d,hwirq=%d,ok\n",__func__,type, d->irq, (int)d->hwirq);
2646 static inline void rockchip_gpio_bit_op(void __iomem *reg_base, unsigned int offset, u32 bit, unsigned char flag)
2648 u32 val = __raw_readl(reg_base + offset);
2655 __raw_writel(val, reg_base + offset);
2658 static inline unsigned gpio_to_bit(struct rockchip_pin_bank *bank, unsigned gpio)
2660 while (gpio >= (bank->pin_base + bank->nr_pins))
2663 return gpio - bank->pin_base;
2666 static inline unsigned offset_to_bit(unsigned offset)
2668 return 1u << offset;
2671 static void GPIOEnableIntr(void __iomem *reg_base, unsigned int bit)
2673 rockchip_gpio_bit_op(reg_base, GPIO_INTEN, bit, 1);
2676 static void GPIODisableIntr(void __iomem *reg_base, unsigned int bit)
2678 rockchip_gpio_bit_op(reg_base, GPIO_INTEN, bit, 0);
2681 static void GPIOAckIntr(void __iomem *reg_base, unsigned int bit)
2683 rockchip_gpio_bit_op(reg_base, GPIO_PORTS_EOI, bit, 1);
2686 static int rockchip_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
2688 struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
2689 struct rockchip_pinctrl *info = bank->drvdata;
2692 unsigned long flags;
2695 spin_lock_irqsave(&bank->slock, flags);
2699 bank->suspend_wakeup |= BIT(bit);
2703 bank->suspend_wakeup &= ~BIT(bit);
2705 spin_unlock_irqrestore(&bank->slock, flags);
2707 DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n",__func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
2711 static void rockchip_gpio_irq_unmask(struct irq_data *d)
2713 struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
2714 struct rockchip_pinctrl *info = bank->drvdata;
2716 unsigned long flags;
2719 spin_lock_irqsave(&bank->slock, flags);
2720 GPIOEnableIntr(bank->reg_base, bit);
2721 spin_unlock_irqrestore(&bank->slock, flags);
2723 DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n",__func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
2726 static void rockchip_gpio_irq_mask(struct irq_data *d)
2728 struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
2729 struct rockchip_pinctrl *info = bank->drvdata;
2730 //u32 bit = gpio_to_bit(bank, d->irq);
2732 unsigned long flags;
2735 spin_lock_irqsave(&bank->slock, flags);
2736 GPIODisableIntr(bank->reg_base, bit);
2737 spin_unlock_irqrestore(&bank->slock, flags);
2739 DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n",__func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
2742 static void rockchip_gpio_irq_ack(struct irq_data *d)
2744 struct rockchip_pin_bank *bank = irq_data_get_irq_chip_data(d);
2745 struct rockchip_pinctrl *info = bank->drvdata;
2746 //u32 bit = gpio_to_bit(bank, d->irq);
2750 GPIOAckIntr(bank->reg_base, bit);
2752 DBG_PINCTRL("%s:irq=%d,hwirq=%d,bank->reg_base=0x%x,bit=%d\n",__func__,d->irq, (int)d->hwirq, (int)bank->reg_base,bit);
2756 static struct irq_chip rockchip_gpio_irq_chip = {
2758 .irq_ack = rockchip_gpio_irq_ack,
2759 .irq_disable = rockchip_gpio_irq_mask,
2760 .irq_mask = rockchip_gpio_irq_mask,
2761 .irq_unmask = rockchip_gpio_irq_unmask,
2762 .irq_set_type = rockchip_gpio_irq_set_type,
2763 .irq_set_wake = rockchip_gpio_irq_set_wake,
2767 static int rockchip_gpio_irq_map(struct irq_domain *d, unsigned int irq,
2768 irq_hw_number_t hwirq)
2770 struct rockchip_pin_bank *bank = d->host_data;
2771 struct rockchip_pinctrl *info = bank->drvdata;
2772 struct irq_data *irq_data = irq_get_irq_data(irq);
2777 printk("%s:bank=0x%p,irq=%d\n",__func__,bank, irq);
2781 irq_set_chip_and_handler(irq, &rockchip_gpio_irq_chip, handle_level_irq);
2782 irq_set_chip_data(irq, bank);
2783 set_irq_flags(irq, IRQF_VALID);
2785 irq_data->hwirq = hwirq;
2786 irq_data->irq = irq;
2788 DBG_PINCTRL("%s:irq=%d\n",__func__,irq);
2792 const struct irq_domain_ops rockchip_gpio_irq_ops = {
2793 .map = rockchip_gpio_irq_map,
2794 .xlate = irq_domain_xlate_twocell,
2798 static int rockchip_interrupts_register(struct platform_device *pdev,
2799 struct rockchip_pinctrl *info)
2801 struct rockchip_pin_ctrl *ctrl = info->ctrl;
2802 struct rockchip_pin_bank *bank = ctrl->pin_banks;
2803 //unsigned int clr = IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_NOAUTOEN;
2806 for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
2808 dev_warn(&pdev->dev, "bank %s is not valid\n",
2813 __raw_writel(0, bank->reg_base + GPIO_INTEN);
2815 bank->drvdata = info;
2816 bank->domain = irq_domain_add_linear(bank->of_node, 32,
2817 &rockchip_gpio_irq_ops, bank);
2818 if (!bank->domain) {
2819 dev_warn(&pdev->dev, "could not initialize irq domain for bank %s\n",
2824 if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
2825 printk("%s:bank_num=%d\n",__func__,bank->bank_num);
2827 irq_set_handler_data(bank->irq, bank);
2828 irq_set_chained_handler(bank->irq, rockchip_irq_demux);
2836 static int rockchip_gpiolib_register(struct platform_device *pdev,
2837 struct rockchip_pinctrl *info)
2839 struct rockchip_pin_ctrl *ctrl = info->ctrl;
2840 struct rockchip_pin_bank *bank = ctrl->pin_banks;
2841 struct gpio_chip *gc;
2845 for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
2847 dev_warn(&pdev->dev, "bank %s is not valid\n",
2852 bank->gpio_chip = rockchip_gpiolib_chip;
2854 gc = &bank->gpio_chip;
2855 gc->base = bank->pin_base;
2856 gc->ngpio = bank->nr_pins;
2857 gc->dev = &pdev->dev;
2858 gc->of_node = bank->of_node;
2859 gc->label = bank->name;
2861 ret = gpiochip_add(gc);
2863 dev_err(&pdev->dev, "failed to register gpio_chip %s, error code: %d\n",
2869 rockchip_interrupts_register(pdev, info);
2874 for (--i, --bank; i >= 0; --i, --bank) {
2878 if (gpiochip_remove(&bank->gpio_chip))
2879 dev_err(&pdev->dev, "gpio chip %s remove failed\n",
2880 bank->gpio_chip.label);
2885 static int rockchip_gpiolib_unregister(struct platform_device *pdev,
2886 struct rockchip_pinctrl *info)
2888 struct rockchip_pin_ctrl *ctrl = info->ctrl;
2889 struct rockchip_pin_bank *bank = ctrl->pin_banks;
2893 for (i = 0; !ret && i < ctrl->nr_banks; ++i, ++bank) {
2897 ret = gpiochip_remove(&bank->gpio_chip);
2901 dev_err(&pdev->dev, "gpio chip remove failed\n");
2906 static int rockchip_get_bank_data(struct rockchip_pin_bank *bank,
2909 struct resource res;
2910 int rk3188 = 0, rk3288 = 0;
2912 //"base", "mux_bank0", "pull_bank0", "drv_bank0"
2913 if (of_address_to_resource(bank->of_node, 0, &res)) {
2914 dev_err(dev, "cannot find IO resource for bank %s\n", bank->name);
2917 bank->reg_base = devm_ioremap_resource(dev, &res);
2918 if (IS_ERR(bank->reg_base))
2919 return PTR_ERR(bank->reg_base);
2921 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res.name, res.start, res.end);
2924 * special case, where parts of the pull setting-registers are
2925 * part of the PMU register space
2927 rk3188 = of_device_is_compatible(bank->of_node, "rockchip,rk3188-gpio-bank0");
2929 rk3288 = of_device_is_compatible(bank->of_node, "rockchip,rk3288-gpio-bank0");
2933 bank->bank_type = RK3188_BANK0;
2935 if (of_address_to_resource(bank->of_node, 1, &res)) {
2936 dev_err(dev, "cannot find IO resource for bank %s\n", bank->name);
2939 bank->reg_pull_bank0 = devm_ioremap_resource(dev, &res);
2940 if (IS_ERR(bank->reg_pull_bank0))
2941 return PTR_ERR(bank->reg_pull_bank0);
2943 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res.name, res.start, res.end);
2948 bank->bank_type = RK3288_BANK0;
2949 if (of_address_to_resource(bank->of_node, 1, &res)) {
2950 dev_err(dev, "cannot find IO resource for bank %s\n", bank->name);
2953 bank->reg_mux_bank0 = devm_ioremap_resource(dev, &res);
2954 if (IS_ERR(bank->reg_mux_bank0))
2955 return PTR_ERR(bank->reg_mux_bank0);
2957 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res.name, res.start, res.end);
2959 if (of_address_to_resource(bank->of_node, 2, &res)) {
2960 dev_err(dev, "cannot find IO resource for bank %s\n", bank->name);
2963 bank->reg_pull_bank0 = devm_ioremap_resource(dev, &res);
2964 if (IS_ERR(bank->reg_pull_bank0))
2965 return PTR_ERR(bank->reg_pull_bank0);
2967 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res.name, res.start, res.end);
2969 if (of_address_to_resource(bank->of_node, 3, &res)) {
2970 dev_err(dev, "cannot find IO resource for bank %s\n", bank->name);
2973 bank->reg_drv_bank0 = devm_ioremap_resource(dev, &res);
2974 if (IS_ERR(bank->reg_drv_bank0))
2975 return PTR_ERR(bank->reg_drv_bank0);
2977 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res.name, res.start, res.end);
2982 bank->bank_type = COMMON_BANK;
2985 bank->irq = irq_of_parse_and_map(bank->of_node, 0);
2987 bank->clk = of_clk_get(bank->of_node, 0);
2988 if (IS_ERR(bank->clk)) {
2989 dev_warn(dev, "failed to get clk for bank %s\n", bank->name);
2992 clk_prepare_enable(bank->clk);
2996 static const struct of_device_id rockchip_pinctrl_dt_match[];
2998 /* retrieve the soc specific data */
2999 static struct rockchip_pin_ctrl *rockchip_pinctrl_get_soc_data(
3000 struct rockchip_pinctrl *d,
3001 struct platform_device *pdev)
3003 const struct of_device_id *match;
3004 struct device_node *node = pdev->dev.of_node;
3005 struct device_node *np;
3006 struct rockchip_pin_ctrl *ctrl;
3007 struct rockchip_pin_bank *bank;
3010 match = of_match_node(rockchip_pinctrl_dt_match, node);
3011 ctrl = (struct rockchip_pin_ctrl *)match->data;
3013 for_each_child_of_node(node, np) {
3014 if (!of_find_property(np, "gpio-controller", NULL))
3017 bank = ctrl->pin_banks;
3018 for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
3019 if (!strcmp(bank->name, np->name)) {
3022 if (!rockchip_get_bank_data(bank, &pdev->dev))
3029 bank = ctrl->pin_banks;
3030 for (i = 0; i < ctrl->nr_banks; ++i, ++bank) {
3031 spin_lock_init(&bank->slock);
3033 bank->pin_base = ctrl->nr_pins;
3034 ctrl->nr_pins += bank->nr_pins;
3042 static int rockchip_pinctrl_suspend(void)
3044 struct rockchip_pinctrl *info = g_info;
3045 struct rockchip_pin_ctrl *ctrl = info->ctrl;
3046 struct rockchip_pin_bank *bank = ctrl->pin_banks;
3050 for(n=0; n<ctrl->nr_banks-1; n++)
3054 for(i=0; i<0x60; i=i+4)
3056 value = readl_relaxed(bank->reg_base + i);
3057 printk("%s:bank_num=%d,reg[0x%x+0x%x]=0x%x,bank_name=%s\n",__func__,bank->bank_num, bank->reg_base, i, value, bank->name);
3060 bank->saved_wakeup = __raw_readl(bank->reg_base + GPIO_INTEN);
3061 __raw_writel(bank->suspend_wakeup, bank->reg_base + GPIO_INTEN);
3063 if (!bank->suspend_wakeup)
3064 clk_disable_unprepare(bank->clk);
3066 if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
3067 printk("%s:bank_num=%d, suspend_wakeup=0x%x\n",__func__, bank->bank_num, bank->suspend_wakeup);
3075 static void rockchip_pinctrl_resume(void)
3077 struct rockchip_pinctrl *info = g_info;
3078 struct rockchip_pin_ctrl *ctrl = info->ctrl;
3079 struct rockchip_pin_bank *bank = ctrl->pin_banks;
3083 for(n=0; n<ctrl->nr_banks-1; n++)
3087 for(i=0; i<0x60; i=i+4)
3089 u32 value = readl_relaxed(bank->reg_base + i);
3090 printk("%s:bank_num=%d,reg[0x%x+0x%x]=0x%x,bank_name=%s\n",__func__,bank->bank_num, bank->reg_base, i, value, bank->name);
3093 if (!bank->suspend_wakeup)
3094 clk_prepare_enable(bank->clk);
3096 /* keep enable for resume irq */
3097 isr = __raw_readl(bank->reg_base + GPIO_INT_STATUS);
3098 __raw_writel(bank->saved_wakeup | (bank->suspend_wakeup & isr), bank->reg_base + GPIO_INTEN);
3100 if(atomic_read(&info->bank_debug_flag) == (bank->bank_num + 1))
3101 printk("%s:bank_num=%d, suspend_wakeup=0x%x\n",__func__, bank->bank_num, bank->saved_wakeup | (bank->suspend_wakeup & isr));
3111 static struct gpio_init_config *
3112 of_get_gpio_init_config(struct device *dev, struct device_node *np)
3114 struct gpio_init_config *config;
3116 enum of_gpio_flags flags;
3118 config = devm_kzalloc(dev,
3119 sizeof(struct gpio_init_config),
3122 return ERR_PTR(-ENOMEM);
3125 config->nr_gpios = of_gpio_named_count(np, "init-gpios");
3127 config->gpios = devm_kzalloc(dev,
3128 sizeof(struct gpio) * config->nr_gpios,
3131 return ERR_PTR(-ENOMEM);
3133 for (i = 0; i < config->nr_gpios; i++) {
3134 //gpio = of_get_named_gpio(np, "gpios", i);
3135 gpio = of_get_named_gpio_flags(np, "init-gpios", i, &flags);
3138 config->gpios[i].gpio = gpio;
3139 config->gpios[i].flags = flags & OF_GPIO_ACTIVE_LOW;
3141 printk("%s:gpio[%d] = %d, value = %lu\n",__func__, i, gpio, config->gpios[i].flags);
3148 static int rockchip_pinctrl_probe(struct platform_device *pdev)
3150 struct rockchip_pinctrl *info;
3151 struct device *dev = &pdev->dev;
3152 struct rockchip_pin_ctrl *ctrl;
3153 struct resource *res;
3155 struct device_node *np;
3158 if (!dev->of_node) {
3159 dev_err(dev, "device tree node not found\n");
3163 info = devm_kzalloc(dev, sizeof(struct rockchip_pinctrl), GFP_KERNEL);
3167 ctrl = rockchip_pinctrl_get_soc_data(info, pdev);
3169 dev_err(dev, "driver data not available\n");
3177 /*if debug GPIO0 then
3178 *atomic_set(&info->bank_debug_flag, 1);
3179 *atomic_set(&info->pin_debug_flag, 0);
3180 *if debug GPIO0-10 then
3181 *atomic_set(&info->bank_debug_flag, 1);
3182 *atomic_set(&info->pin_debug_flag, 11);
3184 atomic_set(&info->bank_debug_flag, 8);
3185 atomic_set(&info->pin_debug_flag, 14);
3187 printk("%s:name=%s,type=%d\n",__func__, ctrl->label, (int)ctrl->type);
3189 //"base", "mux", "pull", "drv";
3194 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3195 info->reg_base = devm_ioremap_resource(&pdev->dev, res);
3196 if (IS_ERR(info->reg_base))
3197 return PTR_ERR(info->reg_base);
3198 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3204 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3205 info->reg_base = devm_ioremap_resource(&pdev->dev, res);
3206 if (IS_ERR(info->reg_base))
3207 return PTR_ERR(info->reg_base);
3208 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3210 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
3211 info->reg_mux = devm_ioremap_resource(&pdev->dev, res);
3212 if (IS_ERR(info->reg_mux))
3213 return PTR_ERR(info->reg_mux);
3214 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3216 res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
3217 info->reg_pull = devm_ioremap_resource(&pdev->dev, res);
3218 if (IS_ERR(info->reg_pull))
3219 return PTR_ERR(info->reg_pull);
3220 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3222 res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
3223 info->reg_drv = devm_ioremap_resource(&pdev->dev, res);
3224 if (IS_ERR(info->reg_drv))
3225 return PTR_ERR(info->reg_drv);
3226 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3231 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
3232 info->reg_base = devm_ioremap_resource(&pdev->dev, res);
3233 if (IS_ERR(info->reg_base))
3234 return PTR_ERR(info->reg_base);
3235 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3237 info->reg_mux = info->reg_base;
3239 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
3240 info->reg_pull = devm_ioremap_resource(&pdev->dev, res);
3241 if (IS_ERR(info->reg_pull))
3242 return PTR_ERR(info->reg_pull);
3243 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3245 res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
3246 info->reg_drv = devm_ioremap_resource(&pdev->dev, res);
3247 if (IS_ERR(info->reg_drv))
3248 return PTR_ERR(info->reg_drv);
3249 printk("%s:name=%s start=0x%x,end=0x%x\n",__func__,res->name, res->start, res->end);
3254 printk("%s:unknown chip type %d\n",__func__, (int)ctrl->type);
3260 ret = rockchip_gpiolib_register(pdev, info);
3264 ret = rockchip_pinctrl_register(pdev, info);
3266 rockchip_gpiolib_unregister(pdev, info);
3271 if (of_find_property(np, "init-gpios", NULL))
3273 info->config = of_get_gpio_init_config(&pdev->dev, np);
3274 if (IS_ERR(info->config))
3275 return PTR_ERR(info->config);
3277 ret = gpio_request_array(info->config->gpios, info->config->nr_gpios);
3279 dev_err(&pdev->dev, "Could not obtain init GPIOs: %d\n", ret);
3283 for(i=0; i<info->config->nr_gpios; i++)
3285 gpio_direction_output(info->config->gpios[i].gpio, info->config->gpios[i].flags);
3289 pinctrl_debugfs_init(info);
3291 platform_set_drvdata(pdev, info);
3293 printk("%s:init ok\n",__func__);
3297 static struct rockchip_pin_bank rk2928_pin_banks[] = {
3298 PIN_BANK(0, 32, "gpio0"),
3299 PIN_BANK(1, 32, "gpio1"),
3300 PIN_BANK(2, 32, "gpio2"),
3301 PIN_BANK(3, 32, "gpio3"),
3303 PIN_BANK(15, 32, "gpio15"),//virtual bank
3306 static struct rockchip_pin_ctrl rk2928_pin_ctrl = {
3307 .pin_banks = rk2928_pin_banks,
3308 .nr_banks = ARRAY_SIZE(rk2928_pin_banks),
3309 .label = "RK2928-GPIO",
3312 .pull_calc_reg = rk2928_calc_pull_reg_and_bit,
3315 static struct rockchip_pin_bank rk3066a_pin_banks[] = {
3316 PIN_BANK(0, 32, "gpio0"),
3317 PIN_BANK(1, 32, "gpio1"),
3318 PIN_BANK(2, 32, "gpio2"),
3319 PIN_BANK(3, 32, "gpio3"),
3320 PIN_BANK(4, 32, "gpio4"),
3321 PIN_BANK(6, 16, "gpio6"),
3322 PIN_BANK(15, 32, "gpio15"),//virtual bank
3325 static struct rockchip_pin_ctrl rk3066a_pin_ctrl = {
3326 .pin_banks = rk3066a_pin_banks,
3327 .nr_banks = ARRAY_SIZE(rk3066a_pin_banks),
3328 .label = "RK3066a-GPIO",
3331 .pull_calc_reg = rk2928_calc_pull_reg_and_bit,
3334 static struct rockchip_pin_bank rk3066b_pin_banks[] = {
3335 PIN_BANK(0, 32, "gpio0"),
3336 PIN_BANK(1, 32, "gpio1"),
3337 PIN_BANK(2, 32, "gpio2"),
3338 PIN_BANK(3, 32, "gpio3"),
3340 PIN_BANK(15, 32, "gpio15"),//virtual bank
3343 static struct rockchip_pin_ctrl rk3066b_pin_ctrl = {
3344 .pin_banks = rk3066b_pin_banks,
3345 .nr_banks = ARRAY_SIZE(rk3066b_pin_banks),
3346 .label = "RK3066b-GPIO",
3351 static struct rockchip_pin_bank rk3188_pin_banks[] = {
3352 PIN_BANK(0, 32, "gpio0"),
3353 PIN_BANK(1, 32, "gpio1"),
3354 PIN_BANK(2, 32, "gpio2"),
3355 PIN_BANK(3, 32, "gpio3"),
3357 PIN_BANK(15, 32, "gpio15"),//virtual bank
3360 static struct rockchip_pin_ctrl rk3188_pin_ctrl = {
3361 .pin_banks = rk3188_pin_banks,
3362 .nr_banks = ARRAY_SIZE(rk3188_pin_banks),
3363 .label = "RK3188-GPIO",
3366 .pull_calc_reg = rk3188_calc_pull_reg_and_bit,
3370 static struct rockchip_pin_bank rk3288_pin_banks[] = {
3371 PIN_BANK(0, 32, "gpio0"),
3372 PIN_BANK(1, 32, "gpio1"),
3373 PIN_BANK(2, 32, "gpio2"),
3374 PIN_BANK(3, 32, "gpio3"),
3375 PIN_BANK(4, 32, "gpio4"),
3376 PIN_BANK(5, 32, "gpio5"),
3377 PIN_BANK(6, 32, "gpio6"),
3378 PIN_BANK(7, 32, "gpio7"),
3379 PIN_BANK(8, 32, "gpio8"),
3382 PIN_BANK(15, 32, "gpio15"),//virtual bank
3385 static struct rockchip_pin_ctrl rk3288_pin_ctrl = {
3386 .pin_banks = rk3288_pin_banks,
3387 .nr_banks = ARRAY_SIZE(rk3288_pin_banks),
3388 .label = "RK3288-GPIO",
3391 .pull_calc_reg = rk3288_calc_pull_reg_and_bit,
3392 .drv_calc_reg = rk3288_calc_drv_reg_and_bit,
3396 static struct rockchip_pin_bank rk3036_pin_banks[] = {
3397 PIN_BANK(0, 32, "gpio0"),
3398 PIN_BANK(1, 32, "gpio1"),
3399 PIN_BANK(2, 32, "gpio2"),
3401 PIN_BANK(15, 32, "gpio15"),//virtual bank
3404 static struct rockchip_pin_ctrl rk3036_pin_ctrl = {
3405 .pin_banks = rk3036_pin_banks,
3406 .nr_banks = ARRAY_SIZE(rk3036_pin_banks),
3407 .label = "rk3036-GPIO",
3410 .pull_calc_reg = rk3036_calc_pull_reg_and_bit,
3414 static struct rockchip_pin_bank rk312x_pin_banks[] = {
3415 PIN_BANK(0, 32, "gpio0"),
3416 PIN_BANK(1, 32, "gpio1"),
3417 PIN_BANK(2, 32, "gpio2"),
3418 PIN_BANK(3, 32, "gpio3"),
3420 PIN_BANK(15, 32, "gpio15"),//virtual bank
3423 static struct rockchip_pin_ctrl rk312x_pin_ctrl = {
3424 .pin_banks = rk312x_pin_banks,
3425 .nr_banks = ARRAY_SIZE(rk312x_pin_banks),
3426 .label = "rk312x-GPIO",
3429 .pull_calc_reg = rk312x_calc_pull_reg_and_bit,
3434 static const struct of_device_id rockchip_pinctrl_dt_match[] = {
3435 { .compatible = "rockchip,rk2928-pinctrl",
3436 .data = (void *)&rk2928_pin_ctrl },
3437 { .compatible = "rockchip,rk3066a-pinctrl",
3438 .data = (void *)&rk3066a_pin_ctrl },
3439 { .compatible = "rockchip,rk3066b-pinctrl",
3440 .data = (void *)&rk3066b_pin_ctrl },
3441 { .compatible = "rockchip,rk3188-pinctrl",
3442 .data = (void *)&rk3188_pin_ctrl },
3443 { .compatible = "rockchip,rk3288-pinctrl",
3444 .data = (void *)&rk3288_pin_ctrl },
3445 { .compatible = "rockchip,rk3036-pinctrl",
3446 .data = (void *)&rk3036_pin_ctrl },
3447 { .compatible = "rockchip,rk312x-pinctrl",
3448 .data = (void *)&rk312x_pin_ctrl },
3451 MODULE_DEVICE_TABLE(of, rockchip_pinctrl_dt_match);
3453 static struct platform_driver rockchip_pinctrl_driver = {
3454 .probe = rockchip_pinctrl_probe,
3456 .name = "rockchip-pinctrl",
3457 .owner = THIS_MODULE,
3458 .of_match_table = rockchip_pinctrl_dt_match,
3463 static struct syscore_ops rockchip_gpio_syscore_ops = {
3464 .suspend = rockchip_pinctrl_suspend,
3465 .resume = rockchip_pinctrl_resume,
3469 static int __init rockchip_pinctrl_drv_register(void)
3472 register_syscore_ops(&rockchip_gpio_syscore_ops);
3474 return platform_driver_register(&rockchip_pinctrl_driver);
3476 postcore_initcall(rockchip_pinctrl_drv_register);
3478 MODULE_AUTHOR("Luo Wei <lw@rock-chips.com>");
3479 MODULE_DESCRIPTION("Rockchip pinctrl driver");
3480 MODULE_LICENSE("GPL v2");