blob: 903c7d81d0d521a1b8bcf523c609f83516d8e952 [file] [log] [blame]
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -07001/*
2 * Atmel PIO2 Port Multiplexer support
3 *
4 * Copyright (C) 2004-2006 Atmel Corporation
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 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/clk.h>
12#include <linux/debugfs.h>
Paul Gortmaker09cf6a22011-08-01 12:55:26 -040013#include <linux/export.h>
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070014#include <linux/fs.h>
15#include <linux/platform_device.h>
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +010016#include <linux/irq.h>
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070017
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +010018#include <asm/gpio.h>
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070019#include <asm/io.h>
20
Haavard Skinnemoen3663b732008-08-05 13:57:38 +020021#include <mach/portmux.h>
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070022
23#include "pio.h"
24
25#define MAX_NR_PIO_DEVICES 8
26
27struct pio_device {
David Brownellb98348b2008-02-04 22:28:28 -080028 struct gpio_chip chip;
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070029 void __iomem *regs;
30 const struct platform_device *pdev;
31 struct clk *clk;
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010032 u32 pinmux_mask;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +010033 char name[8];
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070034};
35
36static struct pio_device pio_dev[MAX_NR_PIO_DEVICES];
37
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010038static struct pio_device *gpio_to_pio(unsigned int gpio)
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070039{
40 struct pio_device *pio;
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010041 unsigned int index;
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070042
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010043 index = gpio >> 5;
44 if (index >= MAX_NR_PIO_DEVICES)
45 return NULL;
46 pio = &pio_dev[index];
47 if (!pio->regs)
48 return NULL;
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070049
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010050 return pio;
51}
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070052
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010053/* Pin multiplexing API */
Julien Maycaf18f12008-09-24 10:30:47 +020054static DEFINE_SPINLOCK(pio_lock);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010055
Julien Maycaf18f12008-09-24 10:30:47 +020056void __init at32_select_periph(unsigned int port, u32 pin_mask,
57 unsigned int periph, unsigned long flags)
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010058{
59 struct pio_device *pio;
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010060
Julien Maycaf18f12008-09-24 10:30:47 +020061 /* assign and verify pio */
62 pio = gpio_to_pio(port);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010063 if (unlikely(!pio)) {
Julien Maycaf18f12008-09-24 10:30:47 +020064 printk(KERN_WARNING "pio: invalid port %u\n", port);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010065 goto fail;
66 }
67
Julien Maycaf18f12008-09-24 10:30:47 +020068 /* Test if any of the requested pins is already muxed */
69 spin_lock(&pio_lock);
70 if (unlikely(pio->pinmux_mask & pin_mask)) {
71 printk(KERN_WARNING "%s: pin(s) busy (requested 0x%x, busy 0x%x)\n",
72 pio->name, pin_mask, pio->pinmux_mask & pin_mask);
73 spin_unlock(&pio_lock);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010074 goto fail;
75 }
76
Julien Maycaf18f12008-09-24 10:30:47 +020077 pio->pinmux_mask |= pin_mask;
78
79 /* enable pull ups */
80 pio_writel(pio, PUER, pin_mask);
81
82 /* select either peripheral A or B */
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010083 if (periph)
Julien Maycaf18f12008-09-24 10:30:47 +020084 pio_writel(pio, BSR, pin_mask);
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -070085 else
Julien Maycaf18f12008-09-24 10:30:47 +020086 pio_writel(pio, ASR, pin_mask);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010087
Julien Maycaf18f12008-09-24 10:30:47 +020088 /* enable peripheral control */
89 pio_writel(pio, PDR, pin_mask);
90
91 /* Disable pull ups if not requested. */
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010092 if (!(flags & AT32_GPIOF_PULLUP))
Julien Maycaf18f12008-09-24 10:30:47 +020093 pio_writel(pio, PUDR, pin_mask);
94
95 spin_unlock(&pio_lock);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +010096
97 return;
98
99fail:
100 dump_stack();
101}
102
103void __init at32_select_gpio(unsigned int pin, unsigned long flags)
104{
105 struct pio_device *pio;
106 unsigned int pin_index = pin & 0x1f;
107 u32 mask = 1 << pin_index;
108
109 pio = gpio_to_pio(pin);
110 if (unlikely(!pio)) {
111 printk("pio: invalid pin %u\n", pin);
112 goto fail;
113 }
114
115 if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask))) {
116 printk("%s: pin %u is busy\n", pio->name, pin_index);
117 goto fail;
118 }
119
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100120 if (flags & AT32_GPIOF_OUTPUT) {
121 if (flags & AT32_GPIOF_HIGH)
122 pio_writel(pio, SODR, mask);
123 else
124 pio_writel(pio, CODR, mask);
Matteo Vit7808fa42007-08-09 14:55:34 +0200125 if (flags & AT32_GPIOF_MULTIDRV)
126 pio_writel(pio, MDER, mask);
127 else
128 pio_writel(pio, MDDR, mask);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100129 pio_writel(pio, PUDR, mask);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +0100130 pio_writel(pio, OER, mask);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100131 } else {
132 if (flags & AT32_GPIOF_PULLUP)
133 pio_writel(pio, PUER, mask);
134 else
135 pio_writel(pio, PUDR, mask);
136 if (flags & AT32_GPIOF_DEGLITCH)
137 pio_writel(pio, IFER, mask);
138 else
139 pio_writel(pio, IFDR, mask);
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +0100140 pio_writel(pio, ODR, mask);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100141 }
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +0100142
143 pio_writel(pio, PER, mask);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100144
Haavard Skinnemoenc3e2a792006-12-04 13:46:52 +0100145 return;
146
147fail:
148 dump_stack();
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700149}
150
Haavard Skinnemoenece26782008-09-19 17:13:28 +0200151/*
152 * Undo a previous pin reservation. Will not affect the hardware
153 * configuration.
154 */
155void at32_deselect_pin(unsigned int pin)
156{
157 struct pio_device *pio;
158 unsigned int pin_index = pin & 0x1f;
159
160 pio = gpio_to_pio(pin);
161 if (unlikely(!pio)) {
162 printk("pio: invalid pin %u\n", pin);
163 dump_stack();
164 return;
165 }
166
167 clear_bit(pin_index, &pio->pinmux_mask);
168}
169
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100170/* Reserve a pin, preventing anyone else from changing its configuration. */
Alex Raimondiadde42b2008-11-04 23:37:10 +0100171void __init at32_reserve_pin(unsigned int port, u32 pin_mask)
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100172{
173 struct pio_device *pio;
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100174
Alex Raimondiadde42b2008-11-04 23:37:10 +0100175 /* assign and verify pio */
176 pio = gpio_to_pio(port);
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100177 if (unlikely(!pio)) {
Alex Raimondiadde42b2008-11-04 23:37:10 +0100178 printk(KERN_WARNING "pio: invalid port %u\n", port);
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100179 goto fail;
180 }
181
Alex Raimondiadde42b2008-11-04 23:37:10 +0100182 /* Test if any of the requested pins is already muxed */
183 spin_lock(&pio_lock);
184 if (unlikely(pio->pinmux_mask & pin_mask)) {
185 printk(KERN_WARNING "%s: pin(s) busy (req. 0x%x, busy 0x%x)\n",
186 pio->name, pin_mask, pio->pinmux_mask & pin_mask);
187 spin_unlock(&pio_lock);
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100188 goto fail;
189 }
190
Alex Raimondiadde42b2008-11-04 23:37:10 +0100191 /* Reserve pins */
192 pio->pinmux_mask |= pin_mask;
193 spin_unlock(&pio_lock);
Haavard Skinnemoene7f70b82007-01-30 11:01:23 +0100194 return;
195
196fail:
197 dump_stack();
198}
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100199
200/*--------------------------------------------------------------------------*/
201
202/* GPIO API */
203
David Brownellb98348b2008-02-04 22:28:28 -0800204static int direction_input(struct gpio_chip *chip, unsigned offset)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100205{
David Brownellb98348b2008-02-04 22:28:28 -0800206 struct pio_device *pio = container_of(chip, struct pio_device, chip);
207 u32 mask = 1 << offset;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100208
David Brownellb98348b2008-02-04 22:28:28 -0800209 if (!(pio_readl(pio, PSR) & mask))
210 return -EINVAL;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100211
David Brownellb98348b2008-02-04 22:28:28 -0800212 pio_writel(pio, ODR, mask);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100213 return 0;
214}
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100215
David Brownellb98348b2008-02-04 22:28:28 -0800216static int gpio_get(struct gpio_chip *chip, unsigned offset)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100217{
David Brownellb98348b2008-02-04 22:28:28 -0800218 struct pio_device *pio = container_of(chip, struct pio_device, chip);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100219
David Brownellb98348b2008-02-04 22:28:28 -0800220 return (pio_readl(pio, PDSR) >> offset) & 1;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100221}
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100222
David Brownellb98348b2008-02-04 22:28:28 -0800223static void gpio_set(struct gpio_chip *chip, unsigned offset, int value);
224
225static int direction_output(struct gpio_chip *chip, unsigned offset, int value)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100226{
David Brownellb98348b2008-02-04 22:28:28 -0800227 struct pio_device *pio = container_of(chip, struct pio_device, chip);
228 u32 mask = 1 << offset;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100229
David Brownellb98348b2008-02-04 22:28:28 -0800230 if (!(pio_readl(pio, PSR) & mask))
231 return -EINVAL;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100232
David Brownellb98348b2008-02-04 22:28:28 -0800233 gpio_set(chip, offset, value);
234 pio_writel(pio, OER, mask);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100235 return 0;
236}
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100237
David Brownellb98348b2008-02-04 22:28:28 -0800238static void gpio_set(struct gpio_chip *chip, unsigned offset, int value)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100239{
David Brownellb98348b2008-02-04 22:28:28 -0800240 struct pio_device *pio = container_of(chip, struct pio_device, chip);
241 u32 mask = 1 << offset;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100242
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100243 if (value)
244 pio_writel(pio, SODR, mask);
245 else
246 pio_writel(pio, CODR, mask);
247}
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100248
249/*--------------------------------------------------------------------------*/
250
251/* GPIO IRQ support */
252
Thomas Gleixnerf2f9c652011-02-06 17:29:03 +0100253static void gpio_irq_mask(struct irq_data *d)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100254{
Thomas Gleixnerf2f9c652011-02-06 17:29:03 +0100255 unsigned gpio = irq_to_gpio(d->irq);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100256 struct pio_device *pio = &pio_dev[gpio >> 5];
257
258 pio_writel(pio, IDR, 1 << (gpio & 0x1f));
259}
260
Jean-Christophe PLAGNIOL-VILLARD024b3f22011-04-10 06:17:20 +0200261static void gpio_irq_unmask(struct irq_data *d)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100262{
Thomas Gleixnerf2f9c652011-02-06 17:29:03 +0100263 unsigned gpio = irq_to_gpio(d->irq);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100264 struct pio_device *pio = &pio_dev[gpio >> 5];
265
266 pio_writel(pio, IER, 1 << (gpio & 0x1f));
267}
268
Thomas Gleixnerf2f9c652011-02-06 17:29:03 +0100269static int gpio_irq_type(struct irq_data *d, unsigned type)
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100270{
271 if (type != IRQ_TYPE_EDGE_BOTH && type != IRQ_TYPE_NONE)
272 return -EINVAL;
273
274 return 0;
275}
276
277static struct irq_chip gpio_irqchip = {
278 .name = "gpio",
Thomas Gleixnerf2f9c652011-02-06 17:29:03 +0100279 .irq_mask = gpio_irq_mask,
280 .irq_unmask = gpio_irq_unmask,
281 .irq_set_type = gpio_irq_type,
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100282};
283
284static void gpio_irq_handler(unsigned irq, struct irq_desc *desc)
285{
Thomas Gleixnerdd8ea6a2011-03-30 15:33:51 +0200286 struct pio_device *pio = irq_desc_get_chip_data(desc);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100287 unsigned gpio_irq;
288
Thomas Gleixnerd75f1bf2011-03-24 16:39:32 +0100289 gpio_irq = (unsigned) irq_get_handler_data(irq);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100290 for (;;) {
291 u32 isr;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100292
293 /* ack pending GPIO interrupts */
294 isr = pio_readl(pio, ISR) & pio_readl(pio, IMR);
295 if (!isr)
296 break;
297 do {
298 int i;
299
300 i = ffs(isr) - 1;
301 isr &= ~(1 << i);
302
303 i += gpio_irq;
Thomas Gleixnerf2f9c652011-02-06 17:29:03 +0100304 generic_handle_irq(i);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100305 } while (isr);
306 }
307}
308
309static void __init
310gpio_irq_setup(struct pio_device *pio, int irq, int gpio_irq)
311{
312 unsigned i;
313
Thomas Gleixnerd75f1bf2011-03-24 16:39:32 +0100314 irq_set_chip_data(irq, pio);
315 irq_set_handler_data(irq, (void *)gpio_irq);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100316
317 for (i = 0; i < 32; i++, gpio_irq++) {
Thomas Gleixnerd75f1bf2011-03-24 16:39:32 +0100318 irq_set_chip_data(gpio_irq, pio);
319 irq_set_chip_and_handler(gpio_irq, &gpio_irqchip,
320 handle_simple_irq);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100321 }
322
Thomas Gleixnerd75f1bf2011-03-24 16:39:32 +0100323 irq_set_chained_handler(irq, gpio_irq_handler);
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100324}
325
326/*--------------------------------------------------------------------------*/
327
David Brownellb98348b2008-02-04 22:28:28 -0800328#ifdef CONFIG_DEBUG_FS
329
330#include <linux/seq_file.h>
331
332/*
333 * This shows more info than the generic gpio dump code:
334 * pullups, deglitching, open drain drive.
335 */
336static void pio_bank_show(struct seq_file *s, struct gpio_chip *chip)
337{
338 struct pio_device *pio = container_of(chip, struct pio_device, chip);
339 u32 psr, osr, imr, pdsr, pusr, ifsr, mdsr;
340 unsigned i;
341 u32 mask;
342 char bank;
343
344 psr = pio_readl(pio, PSR);
345 osr = pio_readl(pio, OSR);
346 imr = pio_readl(pio, IMR);
347 pdsr = pio_readl(pio, PDSR);
348 pusr = pio_readl(pio, PUSR);
349 ifsr = pio_readl(pio, IFSR);
350 mdsr = pio_readl(pio, MDSR);
351
352 bank = 'A' + pio->pdev->id;
353
354 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
355 const char *label;
356
357 label = gpiochip_is_requested(chip, i);
David Brownellaafafdd2008-06-10 13:55:52 +0200358 if (!label && (imr & mask))
359 label = "[irq]";
David Brownellb98348b2008-02-04 22:28:28 -0800360 if (!label)
361 continue;
362
363 seq_printf(s, " gpio-%-3d P%c%-2d (%-12s) %s %s %s",
364 chip->base + i, bank, i,
365 label,
366 (osr & mask) ? "out" : "in ",
367 (mask & pdsr) ? "hi" : "lo",
368 (mask & pusr) ? " " : "up");
369 if (ifsr & mask)
370 seq_printf(s, " deglitch");
371 if ((osr & mdsr) & mask)
372 seq_printf(s, " open-drain");
373 if (imr & mask)
374 seq_printf(s, " irq-%d edge-both",
375 gpio_to_irq(chip->base + i));
376 seq_printf(s, "\n");
377 }
378}
379
380#else
381#define pio_bank_show NULL
382#endif
383
384
385/*--------------------------------------------------------------------------*/
386
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700387static int __init pio_probe(struct platform_device *pdev)
388{
389 struct pio_device *pio = NULL;
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100390 int irq = platform_get_irq(pdev, 0);
391 int gpio_irq_base = GPIO_IRQ_BASE + pdev->id * 32;
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700392
393 BUG_ON(pdev->id >= MAX_NR_PIO_DEVICES);
394 pio = &pio_dev[pdev->id];
395 BUG_ON(!pio->regs);
396
David Brownellb98348b2008-02-04 22:28:28 -0800397 pio->chip.label = pio->name;
398 pio->chip.base = pdev->id * 32;
399 pio->chip.ngpio = 32;
David Brownelld8f388d2008-07-25 01:46:07 -0700400 pio->chip.dev = &pdev->dev;
401 pio->chip.owner = THIS_MODULE;
David Brownellb98348b2008-02-04 22:28:28 -0800402
403 pio->chip.direction_input = direction_input;
404 pio->chip.get = gpio_get;
405 pio->chip.direction_output = direction_output;
406 pio->chip.set = gpio_set;
407 pio->chip.dbg_show = pio_bank_show;
408
409 gpiochip_add(&pio->chip);
410
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100411 gpio_irq_setup(pio, irq, gpio_irq_base);
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700412
413 platform_set_drvdata(pdev, pio);
414
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100415 printk(KERN_DEBUG "%s: base 0x%p, irq %d chains %d..%d\n",
416 pio->name, pio->regs, irq, gpio_irq_base, gpio_irq_base + 31);
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700417
418 return 0;
419}
420
421static struct platform_driver pio_driver = {
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700422 .driver = {
423 .name = "pio",
424 },
425};
426
427static int __init pio_init(void)
428{
Uwe Kleine-Königd6634db2008-09-21 23:52:07 +0200429 return platform_driver_probe(&pio_driver, pio_probe);
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700430}
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100431postcore_initcall(pio_init);
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700432
433void __init at32_init_pio(struct platform_device *pdev)
434{
435 struct resource *regs;
436 struct pio_device *pio;
437
438 if (pdev->id > MAX_NR_PIO_DEVICES) {
439 dev_err(&pdev->dev, "only %d PIO devices supported\n",
440 MAX_NR_PIO_DEVICES);
441 return;
442 }
443
444 pio = &pio_dev[pdev->id];
445 snprintf(pio->name, sizeof(pio->name), "pio%d", pdev->id);
446
447 regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
448 if (!regs) {
449 dev_err(&pdev->dev, "no mmio resource defined\n");
450 return;
451 }
452
453 pio->clk = clk_get(&pdev->dev, "mck");
454 if (IS_ERR(pio->clk))
455 /*
456 * This is a fatal error, but if we continue we might
457 * be so lucky that we manage to initialize the
458 * console and display this message...
459 */
460 dev_err(&pdev->dev, "no mck clock defined\n");
461 else
462 clk_enable(pio->clk);
463
464 pio->pdev = pdev;
Joe Perches28f65c12011-06-09 09:13:32 -0700465 pio->regs = ioremap(regs->start, resource_size(regs));
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700466
Haavard Skinnemoen6a4e5222007-02-05 16:57:13 +0100467 /* start with irqs disabled and acked */
468 pio_writel(pio, IDR, ~0UL);
469 (void) pio_readl(pio, ISR);
Haavard Skinnemoen5f97f7f2006-09-25 23:32:13 -0700470}