Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gpio-mpc5200.c
Go to the documentation of this file.
1 /*
2  * MPC52xx gpio driver
3  *
4  * Copyright (c) 2008 Sascha Hauer <[email protected]>, Pengutronix
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  */
19 
20 #include <linux/of.h>
21 #include <linux/kernel.h>
22 #include <linux/slab.h>
23 #include <linux/of_gpio.h>
24 #include <linux/io.h>
25 #include <linux/of_platform.h>
26 #include <linux/module.h>
27 
28 #include <asm/gpio.h>
29 #include <asm/mpc52xx.h>
30 #include <sysdev/fsl_soc.h>
31 
32 static DEFINE_SPINLOCK(gpio_lock);
33 
35  struct of_mm_gpio_chip mmchip;
36  unsigned int shadow_dvo;
37  unsigned int shadow_gpioe;
38  unsigned int shadow_ddr;
39 };
40 
41 /*
42  * GPIO LIB API implementation for wakeup GPIOs.
43  *
44  * There's a maximum of 8 wakeup GPIOs. Which of these are available
45  * for use depends on your board setup.
46  *
47  * 0 -> GPIO_WKUP_7
48  * 1 -> GPIO_WKUP_6
49  * 2 -> PSC6_1
50  * 3 -> PSC6_0
51  * 4 -> ETH_17
52  * 5 -> PSC3_9
53  * 6 -> PSC2_4
54  * 7 -> PSC1_4
55  *
56  */
57 static int mpc52xx_wkup_gpio_get(struct gpio_chip *gc, unsigned int gpio)
58 {
59  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
60  struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
61  unsigned int ret;
62 
63  ret = (in_8(&regs->wkup_ival) >> (7 - gpio)) & 1;
64 
65  pr_debug("%s: gpio: %d ret: %d\n", __func__, gpio, ret);
66 
67  return ret;
68 }
69 
70 static inline void
71 __mpc52xx_wkup_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
72 {
73  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
74  struct mpc52xx_gpiochip *chip = container_of(mm_gc,
75  struct mpc52xx_gpiochip, mmchip);
76  struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
77 
78  if (val)
79  chip->shadow_dvo |= 1 << (7 - gpio);
80  else
81  chip->shadow_dvo &= ~(1 << (7 - gpio));
82 
83  out_8(&regs->wkup_dvo, chip->shadow_dvo);
84 }
85 
86 static void
87 mpc52xx_wkup_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
88 {
89  unsigned long flags;
90 
91  spin_lock_irqsave(&gpio_lock, flags);
92 
93  __mpc52xx_wkup_gpio_set(gc, gpio, val);
94 
95  spin_unlock_irqrestore(&gpio_lock, flags);
96 
97  pr_debug("%s: gpio: %d val: %d\n", __func__, gpio, val);
98 }
99 
100 static int mpc52xx_wkup_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
101 {
102  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
103  struct mpc52xx_gpiochip *chip = container_of(mm_gc,
104  struct mpc52xx_gpiochip, mmchip);
105  struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
106  unsigned long flags;
107 
108  spin_lock_irqsave(&gpio_lock, flags);
109 
110  /* set the direction */
111  chip->shadow_ddr &= ~(1 << (7 - gpio));
112  out_8(&regs->wkup_ddr, chip->shadow_ddr);
113 
114  /* and enable the pin */
115  chip->shadow_gpioe |= 1 << (7 - gpio);
116  out_8(&regs->wkup_gpioe, chip->shadow_gpioe);
117 
118  spin_unlock_irqrestore(&gpio_lock, flags);
119 
120  return 0;
121 }
122 
123 static int
124 mpc52xx_wkup_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
125 {
126  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
127  struct mpc52xx_gpio_wkup __iomem *regs = mm_gc->regs;
128  struct mpc52xx_gpiochip *chip = container_of(mm_gc,
129  struct mpc52xx_gpiochip, mmchip);
130  unsigned long flags;
131 
132  spin_lock_irqsave(&gpio_lock, flags);
133 
134  __mpc52xx_wkup_gpio_set(gc, gpio, val);
135 
136  /* Then set direction */
137  chip->shadow_ddr |= 1 << (7 - gpio);
138  out_8(&regs->wkup_ddr, chip->shadow_ddr);
139 
140  /* Finally enable the pin */
141  chip->shadow_gpioe |= 1 << (7 - gpio);
142  out_8(&regs->wkup_gpioe, chip->shadow_gpioe);
143 
144  spin_unlock_irqrestore(&gpio_lock, flags);
145 
146  pr_debug("%s: gpio: %d val: %d\n", __func__, gpio, val);
147 
148  return 0;
149 }
150 
151 static int __devinit mpc52xx_wkup_gpiochip_probe(struct platform_device *ofdev)
152 {
153  struct mpc52xx_gpiochip *chip;
155  struct gpio_chip *gc;
156  int ret;
157 
158  chip = kzalloc(sizeof(*chip), GFP_KERNEL);
159  if (!chip)
160  return -ENOMEM;
161 
162  gc = &chip->mmchip.gc;
163 
164  gc->ngpio = 8;
165  gc->direction_input = mpc52xx_wkup_gpio_dir_in;
166  gc->direction_output = mpc52xx_wkup_gpio_dir_out;
167  gc->get = mpc52xx_wkup_gpio_get;
168  gc->set = mpc52xx_wkup_gpio_set;
169 
170  ret = of_mm_gpiochip_add(ofdev->dev.of_node, &chip->mmchip);
171  if (ret)
172  return ret;
173 
174  regs = chip->mmchip.regs;
175  chip->shadow_gpioe = in_8(&regs->wkup_gpioe);
176  chip->shadow_ddr = in_8(&regs->wkup_ddr);
177  chip->shadow_dvo = in_8(&regs->wkup_dvo);
178 
179  return 0;
180 }
181 
182 static int mpc52xx_gpiochip_remove(struct platform_device *ofdev)
183 {
184  return -EBUSY;
185 }
186 
187 static const struct of_device_id mpc52xx_wkup_gpiochip_match[] = {
188  { .compatible = "fsl,mpc5200-gpio-wkup", },
189  {}
190 };
191 
192 static struct platform_driver mpc52xx_wkup_gpiochip_driver = {
193  .driver = {
194  .name = "mpc5200-gpio-wkup",
195  .owner = THIS_MODULE,
196  .of_match_table = mpc52xx_wkup_gpiochip_match,
197  },
198  .probe = mpc52xx_wkup_gpiochip_probe,
199  .remove = mpc52xx_gpiochip_remove,
200 };
201 
202 /*
203  * GPIO LIB API implementation for simple GPIOs
204  *
205  * There's a maximum of 32 simple GPIOs. Which of these are available
206  * for use depends on your board setup.
207  * The numbering reflects the bit numbering in the port registers:
208  *
209  * 0..1 > reserved
210  * 2..3 > IRDA
211  * 4..7 > ETHR
212  * 8..11 > reserved
213  * 12..15 > USB
214  * 16..17 > reserved
215  * 18..23 > PSC3
216  * 24..27 > PSC2
217  * 28..31 > PSC1
218  */
219 static int mpc52xx_simple_gpio_get(struct gpio_chip *gc, unsigned int gpio)
220 {
221  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
222  struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
223  unsigned int ret;
224 
225  ret = (in_be32(&regs->simple_ival) >> (31 - gpio)) & 1;
226 
227  return ret;
228 }
229 
230 static inline void
231 __mpc52xx_simple_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
232 {
233  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
234  struct mpc52xx_gpiochip *chip = container_of(mm_gc,
235  struct mpc52xx_gpiochip, mmchip);
236  struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
237 
238  if (val)
239  chip->shadow_dvo |= 1 << (31 - gpio);
240  else
241  chip->shadow_dvo &= ~(1 << (31 - gpio));
242  out_be32(&regs->simple_dvo, chip->shadow_dvo);
243 }
244 
245 static void
246 mpc52xx_simple_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
247 {
248  unsigned long flags;
249 
250  spin_lock_irqsave(&gpio_lock, flags);
251 
252  __mpc52xx_simple_gpio_set(gc, gpio, val);
253 
254  spin_unlock_irqrestore(&gpio_lock, flags);
255 
256  pr_debug("%s: gpio: %d val: %d\n", __func__, gpio, val);
257 }
258 
259 static int mpc52xx_simple_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
260 {
261  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
262  struct mpc52xx_gpiochip *chip = container_of(mm_gc,
263  struct mpc52xx_gpiochip, mmchip);
264  struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
265  unsigned long flags;
266 
267  spin_lock_irqsave(&gpio_lock, flags);
268 
269  /* set the direction */
270  chip->shadow_ddr &= ~(1 << (31 - gpio));
271  out_be32(&regs->simple_ddr, chip->shadow_ddr);
272 
273  /* and enable the pin */
274  chip->shadow_gpioe |= 1 << (31 - gpio);
275  out_be32(&regs->simple_gpioe, chip->shadow_gpioe);
276 
277  spin_unlock_irqrestore(&gpio_lock, flags);
278 
279  return 0;
280 }
281 
282 static int
283 mpc52xx_simple_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
284 {
285  struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
286  struct mpc52xx_gpiochip *chip = container_of(mm_gc,
287  struct mpc52xx_gpiochip, mmchip);
288  struct mpc52xx_gpio __iomem *regs = mm_gc->regs;
289  unsigned long flags;
290 
291  spin_lock_irqsave(&gpio_lock, flags);
292 
293  /* First set initial value */
294  __mpc52xx_simple_gpio_set(gc, gpio, val);
295 
296  /* Then set direction */
297  chip->shadow_ddr |= 1 << (31 - gpio);
298  out_be32(&regs->simple_ddr, chip->shadow_ddr);
299 
300  /* Finally enable the pin */
301  chip->shadow_gpioe |= 1 << (31 - gpio);
302  out_be32(&regs->simple_gpioe, chip->shadow_gpioe);
303 
304  spin_unlock_irqrestore(&gpio_lock, flags);
305 
306  pr_debug("%s: gpio: %d val: %d\n", __func__, gpio, val);
307 
308  return 0;
309 }
310 
311 static int __devinit mpc52xx_simple_gpiochip_probe(struct platform_device *ofdev)
312 {
313  struct mpc52xx_gpiochip *chip;
314  struct gpio_chip *gc;
315  struct mpc52xx_gpio __iomem *regs;
316  int ret;
317 
318  chip = kzalloc(sizeof(*chip), GFP_KERNEL);
319  if (!chip)
320  return -ENOMEM;
321 
322  gc = &chip->mmchip.gc;
323 
324  gc->ngpio = 32;
325  gc->direction_input = mpc52xx_simple_gpio_dir_in;
326  gc->direction_output = mpc52xx_simple_gpio_dir_out;
327  gc->get = mpc52xx_simple_gpio_get;
328  gc->set = mpc52xx_simple_gpio_set;
329 
330  ret = of_mm_gpiochip_add(ofdev->dev.of_node, &chip->mmchip);
331  if (ret)
332  return ret;
333 
334  regs = chip->mmchip.regs;
335  chip->shadow_gpioe = in_be32(&regs->simple_gpioe);
336  chip->shadow_ddr = in_be32(&regs->simple_ddr);
337  chip->shadow_dvo = in_be32(&regs->simple_dvo);
338 
339  return 0;
340 }
341 
342 static const struct of_device_id mpc52xx_simple_gpiochip_match[] = {
343  { .compatible = "fsl,mpc5200-gpio", },
344  {}
345 };
346 
347 static struct platform_driver mpc52xx_simple_gpiochip_driver = {
348  .driver = {
349  .name = "mpc5200-gpio",
350  .owner = THIS_MODULE,
351  .of_match_table = mpc52xx_simple_gpiochip_match,
352  },
353  .probe = mpc52xx_simple_gpiochip_probe,
354  .remove = mpc52xx_gpiochip_remove,
355 };
356 
357 static int __init mpc52xx_gpio_init(void)
358 {
359  if (platform_driver_register(&mpc52xx_wkup_gpiochip_driver))
360  printk(KERN_ERR "Unable to register wakeup GPIO driver\n");
361 
362  if (platform_driver_register(&mpc52xx_simple_gpiochip_driver))
363  printk(KERN_ERR "Unable to register simple GPIO driver\n");
364 
365  return 0;
366 }
367 
368 
369 /* Make sure we get initialised before anyone else tries to use us */
370 subsys_initcall(mpc52xx_gpio_init);
371 
372 /* No exit call at the moment as we cannot unregister of gpio chips */
373 
374 MODULE_DESCRIPTION("Freescale MPC52xx gpio driver");
375 MODULE_AUTHOR("Sascha Hauer <[email protected]");
376 MODULE_LICENSE("GPL v2");
377