1a47fbf9cbbc939a9f8f484c5c89301752000cc5
[linux-2.6.git] / arch / arm / common / sa1111.c
1 /*
2  * linux/arch/arm/mach-sa1100/sa1111.c
3  *
4  * SA1111 support
5  *
6  * Original code by John Dorsey
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * This file contains all generic SA1111 support.
13  *
14  * All initialization functions provided here are intended to be called
15  * from machine specific code with proper arguments when required.
16  */
17 #include <linux/config.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/delay.h>
22 #include <linux/ptrace.h>
23 #include <linux/errno.h>
24 #include <linux/ioport.h>
25 #include <linux/device.h>
26 #include <linux/slab.h>
27 #include <linux/spinlock.h>
28 #include <linux/dma-mapping.h>
29
30 #include <asm/hardware.h>
31 #include <asm/mach-types.h>
32 #include <asm/io.h>
33 #include <asm/irq.h>
34 #include <asm/mach/irq.h>
35
36 #include <asm/hardware/sa1111.h>
37
38 #ifdef CONFIG_ARCH_PXA
39 #include <asm/arch/pxa-regs.h>
40 #endif
41
42 extern void __init sa1110_mb_enable(void);
43
44 /*
45  * We keep the following data for the overall SA1111.  Note that the
46  * struct device and struct resource are "fake"; they should be supplied
47  * by the bus above us.  However, in the interests of getting all SA1111
48  * drivers converted over to the device model, we provide this as an
49  * anchor point for all the other drivers.
50  */
51 struct sa1111 {
52         struct device   *dev;
53         unsigned long   phys;
54         int             irq;
55         spinlock_t      lock;
56         void __iomem    *base;
57 };
58
59 /*
60  * We _really_ need to eliminate this.  Its only users
61  * are the PWM and DMA checking code.
62  */
63 static struct sa1111 *g_sa1111;
64
65 struct sa1111_dev_info {
66         unsigned long   offset;
67         unsigned long   skpcr_mask;
68         unsigned int    devid;
69         unsigned int    irq[6];
70 };
71
72 static struct sa1111_dev_info sa1111_devices[] = {
73         {
74                 .offset         = SA1111_USB,
75                 .skpcr_mask     = SKPCR_UCLKEN,
76                 .devid          = SA1111_DEVID_USB,
77                 .irq = {
78                         IRQ_USBPWR,
79                         IRQ_HCIM,
80                         IRQ_HCIBUFFACC,
81                         IRQ_HCIRMTWKP,
82                         IRQ_NHCIMFCIR,
83                         IRQ_USB_PORT_RESUME
84                 },
85         },
86         {
87                 .offset         = 0x0600,
88                 .skpcr_mask     = SKPCR_I2SCLKEN | SKPCR_L3CLKEN,
89                 .devid          = SA1111_DEVID_SAC,
90                 .irq = {
91                         AUDXMTDMADONEA,
92                         AUDXMTDMADONEB,
93                         AUDRCVDMADONEA,
94                         AUDRCVDMADONEB
95                 },
96         },
97         {
98                 .offset         = 0x0800,
99                 .skpcr_mask     = SKPCR_SCLKEN,
100                 .devid          = SA1111_DEVID_SSP,
101         },
102         {
103                 .offset         = SA1111_KBD,
104                 .skpcr_mask     = SKPCR_PTCLKEN,
105                 .devid          = SA1111_DEVID_PS2,
106                 .irq = {
107                         IRQ_TPRXINT,
108                         IRQ_TPTXINT
109                 },
110         },
111         {
112                 .offset         = SA1111_MSE,
113                 .skpcr_mask     = SKPCR_PMCLKEN,
114                 .devid          = SA1111_DEVID_PS2,
115                 .irq = {
116                         IRQ_MSRXINT,
117                         IRQ_MSTXINT
118                 },
119         },
120         {
121                 .offset         = 0x1800,
122                 .skpcr_mask     = 0,
123                 .devid          = SA1111_DEVID_PCMCIA,
124                 .irq = {
125                         IRQ_S0_READY_NINT,
126                         IRQ_S0_CD_VALID,
127                         IRQ_S0_BVD1_STSCHG,
128                         IRQ_S1_READY_NINT,
129                         IRQ_S1_CD_VALID,
130                         IRQ_S1_BVD1_STSCHG,
131                 },
132         },
133 };
134
135 /*
136  * SA1111 interrupt support.  Since clearing an IRQ while there are
137  * active IRQs causes the interrupt output to pulse, the upper levels
138  * will call us again if there are more interrupts to process.
139  */
140 static void
141 sa1111_irq_handler(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
142 {
143         unsigned int stat0, stat1, i;
144         void __iomem *base = desc->data;
145
146         stat0 = sa1111_readl(base + SA1111_INTSTATCLR0);
147         stat1 = sa1111_readl(base + SA1111_INTSTATCLR1);
148
149         sa1111_writel(stat0, base + SA1111_INTSTATCLR0);
150
151         desc->chip->ack(irq);
152
153         sa1111_writel(stat1, base + SA1111_INTSTATCLR1);
154
155         if (stat0 == 0 && stat1 == 0) {
156                 do_bad_IRQ(irq, desc, regs);
157                 return;
158         }
159
160         for (i = IRQ_SA1111_START; stat0; i++, stat0 >>= 1)
161                 if (stat0 & 1)
162                         do_edge_IRQ(i, irq_desc + i, regs);
163
164         for (i = IRQ_SA1111_START + 32; stat1; i++, stat1 >>= 1)
165                 if (stat1 & 1)
166                         do_edge_IRQ(i, irq_desc + i, regs);
167
168         /* For level-based interrupts */
169         desc->chip->unmask(irq);
170 }
171
172 #define SA1111_IRQMASK_LO(x)    (1 << (x - IRQ_SA1111_START))
173 #define SA1111_IRQMASK_HI(x)    (1 << (x - IRQ_SA1111_START - 32))
174
175 static void sa1111_ack_irq(unsigned int irq)
176 {
177 }
178
179 static void sa1111_mask_lowirq(unsigned int irq)
180 {
181         void __iomem *mapbase = get_irq_chipdata(irq);
182         unsigned long ie0;
183
184         ie0 = sa1111_readl(mapbase + SA1111_INTEN0);
185         ie0 &= ~SA1111_IRQMASK_LO(irq);
186         writel(ie0, mapbase + SA1111_INTEN0);
187 }
188
189 static void sa1111_unmask_lowirq(unsigned int irq)
190 {
191         void __iomem *mapbase = get_irq_chipdata(irq);
192         unsigned long ie0;
193
194         ie0 = sa1111_readl(mapbase + SA1111_INTEN0);
195         ie0 |= SA1111_IRQMASK_LO(irq);
196         sa1111_writel(ie0, mapbase + SA1111_INTEN0);
197 }
198
199 /*
200  * Attempt to re-trigger the interrupt.  The SA1111 contains a register
201  * (INTSET) which claims to do this.  However, in practice no amount of
202  * manipulation of INTEN and INTSET guarantees that the interrupt will
203  * be triggered.  In fact, its very difficult, if not impossible to get
204  * INTSET to re-trigger the interrupt.
205  */
206 static int sa1111_retrigger_lowirq(unsigned int irq)
207 {
208         unsigned int mask = SA1111_IRQMASK_LO(irq);
209         void __iomem *mapbase = get_irq_chipdata(irq);
210         unsigned long ip0;
211         int i;
212
213         ip0 = sa1111_readl(mapbase + SA1111_INTPOL0);
214         for (i = 0; i < 8; i++) {
215                 sa1111_writel(ip0 ^ mask, mapbase + SA1111_INTPOL0);
216                 sa1111_writel(ip0, mapbase + SA1111_INTPOL0);
217                 if (sa1111_readl(mapbase + SA1111_INTSTATCLR1) & mask)
218                         break;
219         }
220
221         if (i == 8)
222                 printk(KERN_ERR "Danger Will Robinson: failed to "
223                         "re-trigger IRQ%d\n", irq);
224         return i == 8 ? -1 : 0;
225 }
226
227 static int sa1111_type_lowirq(unsigned int irq, unsigned int flags)
228 {
229         unsigned int mask = SA1111_IRQMASK_LO(irq);
230         void __iomem *mapbase = get_irq_chipdata(irq);
231         unsigned long ip0;
232
233         if (flags == IRQT_PROBE)
234                 return 0;
235
236         if ((!(flags & __IRQT_RISEDGE) ^ !(flags & __IRQT_FALEDGE)) == 0)
237                 return -EINVAL;
238
239         ip0 = sa1111_readl(mapbase + SA1111_INTPOL0);
240         if (flags & __IRQT_RISEDGE)
241                 ip0 &= ~mask;
242         else
243                 ip0 |= mask;
244         sa1111_writel(ip0, mapbase + SA1111_INTPOL0);
245         sa1111_writel(ip0, mapbase + SA1111_WAKEPOL0);
246
247         return 0;
248 }
249
250 static int sa1111_wake_lowirq(unsigned int irq, unsigned int on)
251 {
252         unsigned int mask = SA1111_IRQMASK_LO(irq);
253         void __iomem *mapbase = get_irq_chipdata(irq);
254         unsigned long we0;
255
256         we0 = sa1111_readl(mapbase + SA1111_WAKEEN0);
257         if (on)
258                 we0 |= mask;
259         else
260                 we0 &= ~mask;
261         sa1111_writel(we0, mapbase + SA1111_WAKEEN0);
262
263         return 0;
264 }
265
266 static struct irqchip sa1111_low_chip = {
267         .ack            = sa1111_ack_irq,
268         .mask           = sa1111_mask_lowirq,
269         .unmask         = sa1111_unmask_lowirq,
270         .retrigger      = sa1111_retrigger_lowirq,
271         .set_type       = sa1111_type_lowirq,
272         .set_wake       = sa1111_wake_lowirq,
273 };
274
275 static void sa1111_mask_highirq(unsigned int irq)
276 {
277         void __iomem *mapbase = get_irq_chipdata(irq);
278         unsigned long ie1;
279
280         ie1 = sa1111_readl(mapbase + SA1111_INTEN1);
281         ie1 &= ~SA1111_IRQMASK_HI(irq);
282         sa1111_writel(ie1, mapbase + SA1111_INTEN1);
283 }
284
285 static void sa1111_unmask_highirq(unsigned int irq)
286 {
287         void __iomem *mapbase = get_irq_chipdata(irq);
288         unsigned long ie1;
289
290         ie1 = sa1111_readl(mapbase + SA1111_INTEN1);
291         ie1 |= SA1111_IRQMASK_HI(irq);
292         sa1111_writel(ie1, mapbase + SA1111_INTEN1);
293 }
294
295 /*
296  * Attempt to re-trigger the interrupt.  The SA1111 contains a register
297  * (INTSET) which claims to do this.  However, in practice no amount of
298  * manipulation of INTEN and INTSET guarantees that the interrupt will
299  * be triggered.  In fact, its very difficult, if not impossible to get
300  * INTSET to re-trigger the interrupt.
301  */
302 static int sa1111_retrigger_highirq(unsigned int irq)
303 {
304         unsigned int mask = SA1111_IRQMASK_HI(irq);
305         void __iomem *mapbase = get_irq_chipdata(irq);
306         unsigned long ip1;
307         int i;
308
309         ip1 = sa1111_readl(mapbase + SA1111_INTPOL1);
310         for (i = 0; i < 8; i++) {
311                 sa1111_writel(ip1 ^ mask, mapbase + SA1111_INTPOL1);
312                 sa1111_writel(ip1, mapbase + SA1111_INTPOL1);
313                 if (sa1111_readl(mapbase + SA1111_INTSTATCLR1) & mask)
314                         break;
315         }
316
317         if (i == 8)
318                 printk(KERN_ERR "Danger Will Robinson: failed to "
319                         "re-trigger IRQ%d\n", irq);
320         return i == 8 ? -1 : 0;
321 }
322
323 static int sa1111_type_highirq(unsigned int irq, unsigned int flags)
324 {
325         unsigned int mask = SA1111_IRQMASK_HI(irq);
326         void __iomem *mapbase = get_irq_chipdata(irq);
327         unsigned long ip1;
328
329         if (flags == IRQT_PROBE)
330                 return 0;
331
332         if ((!(flags & __IRQT_RISEDGE) ^ !(flags & __IRQT_FALEDGE)) == 0)
333                 return -EINVAL;
334
335         ip1 = sa1111_readl(mapbase + SA1111_INTPOL1);
336         if (flags & __IRQT_RISEDGE)
337                 ip1 &= ~mask;
338         else
339                 ip1 |= mask;
340         sa1111_writel(ip1, mapbase + SA1111_INTPOL1);
341         sa1111_writel(ip1, mapbase + SA1111_WAKEPOL1);
342
343         return 0;
344 }
345
346 static int sa1111_wake_highirq(unsigned int irq, unsigned int on)
347 {
348         unsigned int mask = SA1111_IRQMASK_HI(irq);
349         void __iomem *mapbase = get_irq_chipdata(irq);
350         unsigned long we1;
351
352         we1 = sa1111_readl(mapbase + SA1111_WAKEEN1);
353         if (on)
354                 we1 |= mask;
355         else
356                 we1 &= ~mask;
357         sa1111_writel(we1, mapbase + SA1111_WAKEEN1);
358
359         return 0;
360 }
361
362 static struct irqchip sa1111_high_chip = {
363         .ack            = sa1111_ack_irq,
364         .mask           = sa1111_mask_highirq,
365         .unmask         = sa1111_unmask_highirq,
366         .retrigger      = sa1111_retrigger_highirq,
367         .set_type       = sa1111_type_highirq,
368         .set_wake       = sa1111_wake_highirq,
369 };
370
371 static void sa1111_setup_irq(struct sa1111 *sachip)
372 {
373         void __iomem *irqbase = sachip->base + SA1111_INTC;
374         unsigned int irq;
375
376         /*
377          * We're guaranteed that this region hasn't been taken.
378          */
379         request_mem_region(sachip->phys + SA1111_INTC, 512, "irq");
380
381         /* disable all IRQs */
382         sa1111_writel(0, irqbase + SA1111_INTEN0);
383         sa1111_writel(0, irqbase + SA1111_INTEN1);
384         sa1111_writel(0, irqbase + SA1111_WAKEEN0);
385         sa1111_writel(0, irqbase + SA1111_WAKEEN1);
386
387         /*
388          * detect on rising edge.  Note: Feb 2001 Errata for SA1111
389          * specifies that S0ReadyInt and S1ReadyInt should be '1'.
390          */
391         sa1111_writel(0, irqbase + SA1111_INTPOL0);
392         sa1111_writel(SA1111_IRQMASK_HI(IRQ_S0_READY_NINT) |
393                       SA1111_IRQMASK_HI(IRQ_S1_READY_NINT),
394                       irqbase + SA1111_INTPOL1);
395
396         /* clear all IRQs */
397         sa1111_writel(~0, irqbase + SA1111_INTSTATCLR0);
398         sa1111_writel(~0, irqbase + SA1111_INTSTATCLR1);
399
400         for (irq = IRQ_GPAIN0; irq <= SSPROR; irq++) {
401                 set_irq_chip(irq, &sa1111_low_chip);
402                 set_irq_chipdata(irq, irqbase);
403                 set_irq_handler(irq, do_edge_IRQ);
404                 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
405         }
406
407         for (irq = AUDXMTDMADONEA; irq <= IRQ_S1_BVD1_STSCHG; irq++) {
408                 set_irq_chip(irq, &sa1111_high_chip);
409                 set_irq_chipdata(irq, irqbase);
410                 set_irq_handler(irq, do_edge_IRQ);
411                 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
412         }
413
414         /*
415          * Register SA1111 interrupt
416          */
417         set_irq_type(sachip->irq, IRQT_RISING);
418         set_irq_data(sachip->irq, irqbase);
419         set_irq_chained_handler(sachip->irq, sa1111_irq_handler);
420 }
421
422 /*
423  * Bring the SA1111 out of reset.  This requires a set procedure:
424  *  1. nRESET asserted (by hardware)
425  *  2. CLK turned on from SA1110
426  *  3. nRESET deasserted
427  *  4. VCO turned on, PLL_BYPASS turned off
428  *  5. Wait lock time, then assert RCLKEn
429  *  7. PCR set to allow clocking of individual functions
430  *
431  * Until we've done this, the only registers we can access are:
432  *   SBI_SKCR
433  *   SBI_SMCR
434  *   SBI_SKID
435  */
436 static void sa1111_wake(struct sa1111 *sachip)
437 {
438         unsigned long flags, r;
439
440         spin_lock_irqsave(&sachip->lock, flags);
441
442 #ifdef CONFIG_ARCH_SA1100
443         /*
444          * First, set up the 3.6864MHz clock on GPIO 27 for the SA-1111:
445          * (SA-1110 Developer's Manual, section 9.1.2.1)
446          */
447         GAFR |= GPIO_32_768kHz;
448         GPDR |= GPIO_32_768kHz;
449         TUCR = TUCR_3_6864MHz;
450 #elif CONFIG_ARCH_PXA
451         pxa_gpio_mode(GPIO11_3_6MHz_MD);
452 #else
453 #error missing clock setup
454 #endif
455
456         /*
457          * Turn VCO on, and disable PLL Bypass.
458          */
459         r = sa1111_readl(sachip->base + SA1111_SKCR);
460         r &= ~SKCR_VCO_OFF;
461         sa1111_writel(r, sachip->base + SA1111_SKCR);
462         r |= SKCR_PLL_BYPASS | SKCR_OE_EN;
463         sa1111_writel(r, sachip->base + SA1111_SKCR);
464
465         /*
466          * Wait lock time.  SA1111 manual _doesn't_
467          * specify a figure for this!  We choose 100us.
468          */
469         udelay(100);
470
471         /*
472          * Enable RCLK.  We also ensure that RDYEN is set.
473          */
474         r |= SKCR_RCLKEN | SKCR_RDYEN;
475         sa1111_writel(r, sachip->base + SA1111_SKCR);
476
477         /*
478          * Wait 14 RCLK cycles for the chip to finish coming out
479          * of reset. (RCLK=24MHz).  This is 590ns.
480          */
481         udelay(1);
482
483         /*
484          * Ensure all clocks are initially off.
485          */
486         sa1111_writel(0, sachip->base + SA1111_SKPCR);
487
488         spin_unlock_irqrestore(&sachip->lock, flags);
489 }
490
491 #ifdef CONFIG_ARCH_SA1100
492
493 static u32 sa1111_dma_mask[] = {
494         ~0,
495         ~(1 << 20),
496         ~(1 << 23),
497         ~(1 << 24),
498         ~(1 << 25),
499         ~(1 << 20),
500         ~(1 << 20),
501         0,
502 };
503
504 /*
505  * Configure the SA1111 shared memory controller.
506  */
507 void
508 sa1111_configure_smc(struct sa1111 *sachip, int sdram, unsigned int drac,
509                      unsigned int cas_latency)
510 {
511         unsigned int smcr = SMCR_DTIM | SMCR_MBGE | FInsrt(drac, SMCR_DRAC);
512
513         if (cas_latency == 3)
514                 smcr |= SMCR_CLAT;
515
516         sa1111_writel(smcr, sachip->base + SA1111_SMCR);
517
518         /*
519          * Now clear the bits in the DMA mask to work around the SA1111
520          * DMA erratum (Intel StrongARM SA-1111 Microprocessor Companion
521          * Chip Specification Update, June 2000, Erratum #7).
522          */
523         if (sachip->dev->dma_mask)
524                 *sachip->dev->dma_mask &= sa1111_dma_mask[drac >> 2];
525
526         sachip->dev->coherent_dma_mask &= sa1111_dma_mask[drac >> 2];
527 }
528
529 #endif
530
531 static void sa1111_dev_release(struct device *_dev)
532 {
533         struct sa1111_dev *dev = SA1111_DEV(_dev);
534
535         release_resource(&dev->res);
536         kfree(dev);
537 }
538
539 static int
540 sa1111_init_one_child(struct sa1111 *sachip, struct resource *parent,
541                       struct sa1111_dev_info *info)
542 {
543         struct sa1111_dev *dev;
544         int ret;
545
546         dev = kmalloc(sizeof(struct sa1111_dev), GFP_KERNEL);
547         if (!dev) {
548                 ret = -ENOMEM;
549                 goto out;
550         }
551         memset(dev, 0, sizeof(struct sa1111_dev));
552
553         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
554                  "%4.4lx", info->offset);
555
556         dev->devid       = info->devid;
557         dev->dev.parent  = sachip->dev;
558         dev->dev.bus     = &sa1111_bus_type;
559         dev->dev.release = sa1111_dev_release;
560         dev->dev.coherent_dma_mask = sachip->dev->coherent_dma_mask;
561         dev->res.start   = sachip->phys + info->offset;
562         dev->res.end     = dev->res.start + 511;
563         dev->res.name    = dev->dev.bus_id;
564         dev->res.flags   = IORESOURCE_MEM;
565         dev->mapbase     = sachip->base + info->offset;
566         dev->skpcr_mask  = info->skpcr_mask;
567         memmove(dev->irq, info->irq, sizeof(dev->irq));
568
569         ret = request_resource(parent, &dev->res);
570         if (ret) {
571                 printk("SA1111: failed to allocate resource for %s\n",
572                         dev->res.name);
573                 kfree(dev);
574                 goto out;
575         }
576
577
578         ret = device_register(&dev->dev);
579         if (ret) {
580                 release_resource(&dev->res);
581                 kfree(dev);
582                 goto out;
583         }
584
585         /*
586          * If the parent device has a DMA mask associated with it,
587          * propagate it down to the children.
588          */
589         if (sachip->dev->dma_mask) {
590                 dev->dma_mask = *sachip->dev->dma_mask;
591                 dev->dev.dma_mask = &dev->dma_mask;
592
593                 if (dev->dma_mask != 0xffffffffUL) {
594                         ret = dmabounce_register_dev(&dev->dev, 1024, 4096);
595                         if (ret) {
596                                 printk("SA1111: Failed to register %s with dmabounce", dev->dev.bus_id);
597                                 device_unregister(&dev->dev);
598                         }
599                 }
600         }
601
602 out:
603         return ret;
604 }
605
606 /**
607  *      sa1111_probe - probe for a single SA1111 chip.
608  *      @phys_addr: physical address of device.
609  *
610  *      Probe for a SA1111 chip.  This must be called
611  *      before any other SA1111-specific code.
612  *
613  *      Returns:
614  *      %-ENODEV        device not found.
615  *      %-EBUSY         physical address already marked in-use.
616  *      %0              successful.
617  */
618 static int
619 __sa1111_probe(struct device *me, struct resource *mem, int irq)
620 {
621         struct sa1111 *sachip;
622         unsigned long id;
623         unsigned int has_devs, val;
624         int i, ret = -ENODEV;
625
626         sachip = kmalloc(sizeof(struct sa1111), GFP_KERNEL);
627         if (!sachip)
628                 return -ENOMEM;
629
630         memset(sachip, 0, sizeof(struct sa1111));
631
632         spin_lock_init(&sachip->lock);
633
634         sachip->dev = me;
635         dev_set_drvdata(sachip->dev, sachip);
636
637         sachip->phys = mem->start;
638         sachip->irq = irq;
639
640         /*
641          * Map the whole region.  This also maps the
642          * registers for our children.
643          */
644         sachip->base = ioremap(mem->start, PAGE_SIZE * 2);
645         if (!sachip->base) {
646                 ret = -ENOMEM;
647                 goto out;
648         }
649
650         /*
651          * Probe for the chip.  Only touch the SBI registers.
652          */
653         id = sa1111_readl(sachip->base + SA1111_SKID);
654         if ((id & SKID_ID_MASK) != SKID_SA1111_ID) {
655                 printk(KERN_DEBUG "SA1111 not detected: ID = %08lx\n", id);
656                 ret = -ENODEV;
657                 goto unmap;
658         }
659
660         printk(KERN_INFO "SA1111 Microprocessor Companion Chip: "
661                 "silicon revision %lx, metal revision %lx\n",
662                 (id & SKID_SIREV_MASK)>>4, (id & SKID_MTREV_MASK));
663
664         /*
665          * We found it.  Wake the chip up, and initialise.
666          */
667         sa1111_wake(sachip);
668
669 #ifdef CONFIG_ARCH_SA1100
670         /*
671          * The SDRAM configuration of the SA1110 and the SA1111 must
672          * match.  This is very important to ensure that SA1111 accesses
673          * don't corrupt the SDRAM.  Note that this ungates the SA1111's
674          * MBGNT signal, so we must have called sa1110_mb_disable()
675          * beforehand.
676          */
677         sa1111_configure_smc(sachip, 1,
678                              FExtr(MDCNFG, MDCNFG_SA1110_DRAC0),
679                              FExtr(MDCNFG, MDCNFG_SA1110_TDL0));
680
681         /*
682          * We only need to turn on DCLK whenever we want to use the
683          * DMA.  It can otherwise be held firmly in the off position.
684          * (currently, we always enable it.)
685          */
686         val = sa1111_readl(sachip->base + SA1111_SKPCR);
687         sa1111_writel(val | SKPCR_DCLKEN, sachip->base + SA1111_SKPCR);
688
689         /*
690          * Enable the SA1110 memory bus request and grant signals.
691          */
692         sa1110_mb_enable();
693 #endif
694
695         /*
696          * The interrupt controller must be initialised before any
697          * other device to ensure that the interrupts are available.
698          */
699         if (sachip->irq != NO_IRQ)
700                 sa1111_setup_irq(sachip);
701
702         g_sa1111 = sachip;
703
704         has_devs = ~0;
705         if (machine_is_assabet() || machine_is_jornada720() ||
706             machine_is_badge4())
707                 has_devs &= ~(1 << 4);
708         else
709                 has_devs &= ~(1 << 1);
710
711         for (i = 0; i < ARRAY_SIZE(sa1111_devices); i++)
712                 if (has_devs & (1 << i))
713                         sa1111_init_one_child(sachip, mem, &sa1111_devices[i]);
714
715         return 0;
716
717  unmap:
718         iounmap(sachip->base);
719  out:
720         kfree(sachip);
721         return ret;
722 }
723
724 static int sa1111_remove_one(struct device *dev, void *data)
725 {
726         device_unregister(dev);
727         return 0;
728 }
729
730 static void __sa1111_remove(struct sa1111 *sachip)
731 {
732         void __iomem *irqbase = sachip->base + SA1111_INTC;
733
734         device_for_each_child(sachip->dev, NULL, sa1111_remove_one);
735
736         /* disable all IRQs */
737         sa1111_writel(0, irqbase + SA1111_INTEN0);
738         sa1111_writel(0, irqbase + SA1111_INTEN1);
739         sa1111_writel(0, irqbase + SA1111_WAKEEN0);
740         sa1111_writel(0, irqbase + SA1111_WAKEEN1);
741
742         if (sachip->irq != NO_IRQ) {
743                 set_irq_chained_handler(sachip->irq, NULL);
744                 set_irq_data(sachip->irq, NULL);
745
746                 release_mem_region(sachip->phys + SA1111_INTC, 512);
747         }
748
749         iounmap(sachip->base);
750         kfree(sachip);
751 }
752
753 /*
754  * According to the "Intel StrongARM SA-1111 Microprocessor Companion
755  * Chip Specification Update" (June 2000), erratum #7, there is a
756  * significant bug in the SA1111 SDRAM shared memory controller.  If
757  * an access to a region of memory above 1MB relative to the bank base,
758  * it is important that address bit 10 _NOT_ be asserted. Depending
759  * on the configuration of the RAM, bit 10 may correspond to one
760  * of several different (processor-relative) address bits.
761  *
762  * This routine only identifies whether or not a given DMA address
763  * is susceptible to the bug.
764  *
765  * This should only get called for sa1111_device types due to the
766  * way we configure our device dma_masks.
767  */
768 int dma_needs_bounce(struct device *dev, dma_addr_t addr, size_t size)
769 {
770         /*
771          * Section 4.6 of the "Intel StrongARM SA-1111 Development Module
772          * User's Guide" mentions that jumpers R51 and R52 control the
773          * target of SA-1111 DMA (either SDRAM bank 0 on Assabet, or
774          * SDRAM bank 1 on Neponset). The default configuration selects
775          * Assabet, so any address in bank 1 is necessarily invalid.
776          */
777         return ((machine_is_assabet() || machine_is_pfs168()) &&
778                 (addr >= 0xc8000000 || (addr + size) >= 0xc8000000));
779 }
780
781 struct sa1111_save_data {
782         unsigned int    skcr;
783         unsigned int    skpcr;
784         unsigned int    skcdr;
785         unsigned char   skaud;
786         unsigned char   skpwm0;
787         unsigned char   skpwm1;
788
789         /*
790          * Interrupt controller
791          */
792         unsigned int    intpol0;
793         unsigned int    intpol1;
794         unsigned int    inten0;
795         unsigned int    inten1;
796         unsigned int    wakepol0;
797         unsigned int    wakepol1;
798         unsigned int    wakeen0;
799         unsigned int    wakeen1;
800 };
801
802 #ifdef CONFIG_PM
803
804 static int sa1111_suspend(struct device *dev, pm_message_t state, u32 level)
805 {
806         struct sa1111 *sachip = dev_get_drvdata(dev);
807         struct sa1111_save_data *save;
808         unsigned long flags;
809         unsigned int val;
810         void __iomem *base;
811
812         if (level != SUSPEND_DISABLE)
813                 return 0;
814
815         save = kmalloc(sizeof(struct sa1111_save_data), GFP_KERNEL);
816         if (!save)
817                 return -ENOMEM;
818         dev->power.saved_state = save;
819
820         spin_lock_irqsave(&sachip->lock, flags);
821
822         /*
823          * Save state.
824          */
825         base = sachip->base;
826         save->skcr     = sa1111_readl(base + SA1111_SKCR);
827         save->skpcr    = sa1111_readl(base + SA1111_SKPCR);
828         save->skcdr    = sa1111_readl(base + SA1111_SKCDR);
829         save->skaud    = sa1111_readl(base + SA1111_SKAUD);
830         save->skpwm0   = sa1111_readl(base + SA1111_SKPWM0);
831         save->skpwm1   = sa1111_readl(base + SA1111_SKPWM1);
832
833         base = sachip->base + SA1111_INTC;
834         save->intpol0  = sa1111_readl(base + SA1111_INTPOL0);
835         save->intpol1  = sa1111_readl(base + SA1111_INTPOL1);
836         save->inten0   = sa1111_readl(base + SA1111_INTEN0);
837         save->inten1   = sa1111_readl(base + SA1111_INTEN1);
838         save->wakepol0 = sa1111_readl(base + SA1111_WAKEPOL0);
839         save->wakepol1 = sa1111_readl(base + SA1111_WAKEPOL1);
840         save->wakeen0  = sa1111_readl(base + SA1111_WAKEEN0);
841         save->wakeen1  = sa1111_readl(base + SA1111_WAKEEN1);
842
843         /*
844          * Disable.
845          */
846         val = sa1111_readl(sachip->base + SA1111_SKCR);
847         sa1111_writel(val | SKCR_SLEEP, sachip->base + SA1111_SKCR);
848         sa1111_writel(0, sachip->base + SA1111_SKPWM0);
849         sa1111_writel(0, sachip->base + SA1111_SKPWM1);
850
851         spin_unlock_irqrestore(&sachip->lock, flags);
852
853         return 0;
854 }
855
856 /*
857  *      sa1111_resume - Restore the SA1111 device state.
858  *      @dev: device to restore
859  *      @level: resume level
860  *
861  *      Restore the general state of the SA1111; clock control and
862  *      interrupt controller.  Other parts of the SA1111 must be
863  *      restored by their respective drivers, and must be called
864  *      via LDM after this function.
865  */
866 static int sa1111_resume(struct device *dev, u32 level)
867 {
868         struct sa1111 *sachip = dev_get_drvdata(dev);
869         struct sa1111_save_data *save;
870         unsigned long flags, id;
871         void __iomem *base;
872
873         if (level != RESUME_ENABLE)
874                 return 0;
875
876         save = (struct sa1111_save_data *)dev->power.saved_state;
877         if (!save)
878                 return 0;
879
880         spin_lock_irqsave(&sachip->lock, flags);
881
882         /*
883          * Ensure that the SA1111 is still here.
884          * FIXME: shouldn't do this here.
885          */
886         id = sa1111_readl(sachip->base + SA1111_SKID);
887         if ((id & SKID_ID_MASK) != SKID_SA1111_ID) {
888                 __sa1111_remove(sachip);
889                 dev_set_drvdata(dev, NULL);
890                 kfree(save);
891                 return 0;
892         }
893
894         /*
895          * First of all, wake up the chip.
896          */
897         sa1111_wake(sachip);
898         sa1111_writel(0, sachip->base + SA1111_INTC + SA1111_INTEN0);
899         sa1111_writel(0, sachip->base + SA1111_INTC + SA1111_INTEN1);
900
901         base = sachip->base;
902         sa1111_writel(save->skcr,     base + SA1111_SKCR);
903         sa1111_writel(save->skpcr,    base + SA1111_SKPCR);
904         sa1111_writel(save->skcdr,    base + SA1111_SKCDR);
905         sa1111_writel(save->skaud,    base + SA1111_SKAUD);
906         sa1111_writel(save->skpwm0,   base + SA1111_SKPWM0);
907         sa1111_writel(save->skpwm1,   base + SA1111_SKPWM1);
908
909         base = sachip->base + SA1111_INTC;
910         sa1111_writel(save->intpol0,  base + SA1111_INTPOL0);
911         sa1111_writel(save->intpol1,  base + SA1111_INTPOL1);
912         sa1111_writel(save->inten0,   base + SA1111_INTEN0);
913         sa1111_writel(save->inten1,   base + SA1111_INTEN1);
914         sa1111_writel(save->wakepol0, base + SA1111_WAKEPOL0);
915         sa1111_writel(save->wakepol1, base + SA1111_WAKEPOL1);
916         sa1111_writel(save->wakeen0,  base + SA1111_WAKEEN0);
917         sa1111_writel(save->wakeen1,  base + SA1111_WAKEEN1);
918
919         spin_unlock_irqrestore(&sachip->lock, flags);
920
921         dev->power.saved_state = NULL;
922         kfree(save);
923
924         return 0;
925 }
926
927 #else
928 #define sa1111_suspend NULL
929 #define sa1111_resume  NULL
930 #endif
931
932 static int sa1111_probe(struct device *dev)
933 {
934         struct platform_device *pdev = to_platform_device(dev);
935         struct resource *mem;
936         int irq;
937
938         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
939         if (!mem)
940                 return -EINVAL;
941         irq = platform_get_irq(pdev, 0);
942
943         return __sa1111_probe(dev, mem, irq);
944 }
945
946 static int sa1111_remove(struct device *dev)
947 {
948         struct sa1111 *sachip = dev_get_drvdata(dev);
949
950         if (sachip) {
951                 __sa1111_remove(sachip);
952                 dev_set_drvdata(dev, NULL);
953
954 #ifdef CONFIG_PM
955                 kfree(dev->power.saved_state);
956                 dev->power.saved_state = NULL;
957 #endif
958         }
959
960         return 0;
961 }
962
963 /*
964  *      Not sure if this should be on the system bus or not yet.
965  *      We really want some way to register a system device at
966  *      the per-machine level, and then have this driver pick
967  *      up the registered devices.
968  *
969  *      We also need to handle the SDRAM configuration for
970  *      PXA250/SA1110 machine classes.
971  */
972 static struct device_driver sa1111_device_driver = {
973         .name           = "sa1111",
974         .bus            = &platform_bus_type,
975         .probe          = sa1111_probe,
976         .remove         = sa1111_remove,
977         .suspend        = sa1111_suspend,
978         .resume         = sa1111_resume,
979 };
980
981 /*
982  *      Get the parent device driver (us) structure
983  *      from a child function device
984  */
985 static inline struct sa1111 *sa1111_chip_driver(struct sa1111_dev *sadev)
986 {
987         return (struct sa1111 *)dev_get_drvdata(sadev->dev.parent);
988 }
989
990 /*
991  * The bits in the opdiv field are non-linear.
992  */
993 static unsigned char opdiv_table[] = { 1, 4, 2, 8 };
994
995 static unsigned int __sa1111_pll_clock(struct sa1111 *sachip)
996 {
997         unsigned int skcdr, fbdiv, ipdiv, opdiv;
998
999         skcdr = sa1111_readl(sachip->base + SA1111_SKCDR);
1000
1001         fbdiv = (skcdr & 0x007f) + 2;
1002         ipdiv = ((skcdr & 0x0f80) >> 7) + 2;
1003         opdiv = opdiv_table[(skcdr & 0x3000) >> 12];
1004
1005         return 3686400 * fbdiv / (ipdiv * opdiv);
1006 }
1007
1008 /**
1009  *      sa1111_pll_clock - return the current PLL clock frequency.
1010  *      @sadev: SA1111 function block
1011  *
1012  *      BUG: we should look at SKCR.  We also blindly believe that
1013  *      the chip is being fed with the 3.6864MHz clock.
1014  *
1015  *      Returns the PLL clock in Hz.
1016  */
1017 unsigned int sa1111_pll_clock(struct sa1111_dev *sadev)
1018 {
1019         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1020
1021         return __sa1111_pll_clock(sachip);
1022 }
1023
1024 /**
1025  *      sa1111_select_audio_mode - select I2S or AC link mode
1026  *      @sadev: SA1111 function block
1027  *      @mode: One of %SA1111_AUDIO_ACLINK or %SA1111_AUDIO_I2S
1028  *
1029  *      Frob the SKCR to select AC Link mode or I2S mode for
1030  *      the audio block.
1031  */
1032 void sa1111_select_audio_mode(struct sa1111_dev *sadev, int mode)
1033 {
1034         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1035         unsigned long flags;
1036         unsigned int val;
1037
1038         spin_lock_irqsave(&sachip->lock, flags);
1039
1040         val = sa1111_readl(sachip->base + SA1111_SKCR);
1041         if (mode == SA1111_AUDIO_I2S) {
1042                 val &= ~SKCR_SELAC;
1043         } else {
1044                 val |= SKCR_SELAC;
1045         }
1046         sa1111_writel(val, sachip->base + SA1111_SKCR);
1047
1048         spin_unlock_irqrestore(&sachip->lock, flags);
1049 }
1050
1051 /**
1052  *      sa1111_set_audio_rate - set the audio sample rate
1053  *      @sadev: SA1111 SAC function block
1054  *      @rate: sample rate to select
1055  */
1056 int sa1111_set_audio_rate(struct sa1111_dev *sadev, int rate)
1057 {
1058         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1059         unsigned int div;
1060
1061         if (sadev->devid != SA1111_DEVID_SAC)
1062                 return -EINVAL;
1063
1064         div = (__sa1111_pll_clock(sachip) / 256 + rate / 2) / rate;
1065         if (div == 0)
1066                 div = 1;
1067         if (div > 128)
1068                 div = 128;
1069
1070         sa1111_writel(div - 1, sachip->base + SA1111_SKAUD);
1071
1072         return 0;
1073 }
1074
1075 /**
1076  *      sa1111_get_audio_rate - get the audio sample rate
1077  *      @sadev: SA1111 SAC function block device
1078  */
1079 int sa1111_get_audio_rate(struct sa1111_dev *sadev)
1080 {
1081         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1082         unsigned long div;
1083
1084         if (sadev->devid != SA1111_DEVID_SAC)
1085                 return -EINVAL;
1086
1087         div = sa1111_readl(sachip->base + SA1111_SKAUD) + 1;
1088
1089         return __sa1111_pll_clock(sachip) / (256 * div);
1090 }
1091
1092 void sa1111_set_io_dir(struct sa1111_dev *sadev,
1093                        unsigned int bits, unsigned int dir,
1094                        unsigned int sleep_dir)
1095 {
1096         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1097         unsigned long flags;
1098         unsigned int val;
1099         void __iomem *gpio = sachip->base + SA1111_GPIO;
1100
1101 #define MODIFY_BITS(port, mask, dir)            \
1102         if (mask) {                             \
1103                 val = sa1111_readl(port);       \
1104                 val &= ~(mask);                 \
1105                 val |= (dir) & (mask);          \
1106                 sa1111_writel(val, port);       \
1107         }
1108
1109         spin_lock_irqsave(&sachip->lock, flags);
1110         MODIFY_BITS(gpio + SA1111_GPIO_PADDR, bits & 15, dir);
1111         MODIFY_BITS(gpio + SA1111_GPIO_PBDDR, (bits >> 8) & 255, dir >> 8);
1112         MODIFY_BITS(gpio + SA1111_GPIO_PCDDR, (bits >> 16) & 255, dir >> 16);
1113
1114         MODIFY_BITS(gpio + SA1111_GPIO_PASDR, bits & 15, sleep_dir);
1115         MODIFY_BITS(gpio + SA1111_GPIO_PBSDR, (bits >> 8) & 255, sleep_dir >> 8);
1116         MODIFY_BITS(gpio + SA1111_GPIO_PCSDR, (bits >> 16) & 255, sleep_dir >> 16);
1117         spin_unlock_irqrestore(&sachip->lock, flags);
1118 }
1119
1120 void sa1111_set_io(struct sa1111_dev *sadev, unsigned int bits, unsigned int v)
1121 {
1122         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1123         unsigned long flags;
1124         unsigned int val;
1125         void __iomem *gpio = sachip->base + SA1111_GPIO;
1126
1127         spin_lock_irqsave(&sachip->lock, flags);
1128         MODIFY_BITS(gpio + SA1111_GPIO_PADWR, bits & 15, v);
1129         MODIFY_BITS(gpio + SA1111_GPIO_PBDWR, (bits >> 8) & 255, v >> 8);
1130         MODIFY_BITS(gpio + SA1111_GPIO_PCDWR, (bits >> 16) & 255, v >> 16);
1131         spin_unlock_irqrestore(&sachip->lock, flags);
1132 }
1133
1134 void sa1111_set_sleep_io(struct sa1111_dev *sadev, unsigned int bits, unsigned int v)
1135 {
1136         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1137         unsigned long flags;
1138         unsigned int val;
1139         void __iomem *gpio = sachip->base + SA1111_GPIO;
1140
1141         spin_lock_irqsave(&sachip->lock, flags);
1142         MODIFY_BITS(gpio + SA1111_GPIO_PASSR, bits & 15, v);
1143         MODIFY_BITS(gpio + SA1111_GPIO_PBSSR, (bits >> 8) & 255, v >> 8);
1144         MODIFY_BITS(gpio + SA1111_GPIO_PCSSR, (bits >> 16) & 255, v >> 16);
1145         spin_unlock_irqrestore(&sachip->lock, flags);
1146 }
1147
1148 /*
1149  * Individual device operations.
1150  */
1151
1152 /**
1153  *      sa1111_enable_device - enable an on-chip SA1111 function block
1154  *      @sadev: SA1111 function block device to enable
1155  */
1156 void sa1111_enable_device(struct sa1111_dev *sadev)
1157 {
1158         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1159         unsigned long flags;
1160         unsigned int val;
1161
1162         spin_lock_irqsave(&sachip->lock, flags);
1163         val = sa1111_readl(sachip->base + SA1111_SKPCR);
1164         sa1111_writel(val | sadev->skpcr_mask, sachip->base + SA1111_SKPCR);
1165         spin_unlock_irqrestore(&sachip->lock, flags);
1166 }
1167
1168 /**
1169  *      sa1111_disable_device - disable an on-chip SA1111 function block
1170  *      @sadev: SA1111 function block device to disable
1171  */
1172 void sa1111_disable_device(struct sa1111_dev *sadev)
1173 {
1174         struct sa1111 *sachip = sa1111_chip_driver(sadev);
1175         unsigned long flags;
1176         unsigned int val;
1177
1178         spin_lock_irqsave(&sachip->lock, flags);
1179         val = sa1111_readl(sachip->base + SA1111_SKPCR);
1180         sa1111_writel(val & ~sadev->skpcr_mask, sachip->base + SA1111_SKPCR);
1181         spin_unlock_irqrestore(&sachip->lock, flags);
1182 }
1183
1184 /*
1185  *      SA1111 "Register Access Bus."
1186  *
1187  *      We model this as a regular bus type, and hang devices directly
1188  *      off this.
1189  */
1190 static int sa1111_match(struct device *_dev, struct device_driver *_drv)
1191 {
1192         struct sa1111_dev *dev = SA1111_DEV(_dev);
1193         struct sa1111_driver *drv = SA1111_DRV(_drv);
1194
1195         return dev->devid == drv->devid;
1196 }
1197
1198 static int sa1111_bus_suspend(struct device *dev, pm_message_t state)
1199 {
1200         struct sa1111_dev *sadev = SA1111_DEV(dev);
1201         struct sa1111_driver *drv = SA1111_DRV(dev->driver);
1202         int ret = 0;
1203
1204         if (drv && drv->suspend)
1205                 ret = drv->suspend(sadev, state);
1206         return ret;
1207 }
1208
1209 static int sa1111_bus_resume(struct device *dev)
1210 {
1211         struct sa1111_dev *sadev = SA1111_DEV(dev);
1212         struct sa1111_driver *drv = SA1111_DRV(dev->driver);
1213         int ret = 0;
1214
1215         if (drv && drv->resume)
1216                 ret = drv->resume(sadev);
1217         return ret;
1218 }
1219
1220 static int sa1111_bus_probe(struct device *dev)
1221 {
1222         struct sa1111_dev *sadev = SA1111_DEV(dev);
1223         struct sa1111_driver *drv = SA1111_DRV(dev->driver);
1224         int ret = -ENODEV;
1225
1226         if (drv->probe)
1227                 ret = drv->probe(sadev);
1228         return ret;
1229 }
1230
1231 static int sa1111_bus_remove(struct device *dev)
1232 {
1233         struct sa1111_dev *sadev = SA1111_DEV(dev);
1234         struct sa1111_driver *drv = SA1111_DRV(dev->driver);
1235         int ret = 0;
1236
1237         if (drv->remove)
1238                 ret = drv->remove(sadev);
1239         return ret;
1240 }
1241
1242 struct bus_type sa1111_bus_type = {
1243         .name           = "sa1111-rab",
1244         .match          = sa1111_match,
1245         .suspend        = sa1111_bus_suspend,
1246         .resume         = sa1111_bus_resume,
1247 };
1248
1249 int sa1111_driver_register(struct sa1111_driver *driver)
1250 {
1251         driver->drv.probe = sa1111_bus_probe;
1252         driver->drv.remove = sa1111_bus_remove;
1253         driver->drv.bus = &sa1111_bus_type;
1254         return driver_register(&driver->drv);
1255 }
1256
1257 void sa1111_driver_unregister(struct sa1111_driver *driver)
1258 {
1259         driver_unregister(&driver->drv);
1260 }
1261
1262 static int __init sa1111_init(void)
1263 {
1264         int ret = bus_register(&sa1111_bus_type);
1265         if (ret == 0)
1266                 driver_register(&sa1111_device_driver);
1267         return ret;
1268 }
1269
1270 static void __exit sa1111_exit(void)
1271 {
1272         driver_unregister(&sa1111_device_driver);
1273         bus_unregister(&sa1111_bus_type);
1274 }
1275
1276 module_init(sa1111_init);
1277 module_exit(sa1111_exit);
1278
1279 MODULE_DESCRIPTION("Intel Corporation SA1111 core driver");
1280 MODULE_LICENSE("GPL");
1281
1282 EXPORT_SYMBOL(sa1111_select_audio_mode);
1283 EXPORT_SYMBOL(sa1111_set_audio_rate);
1284 EXPORT_SYMBOL(sa1111_get_audio_rate);
1285 EXPORT_SYMBOL(sa1111_set_io_dir);
1286 EXPORT_SYMBOL(sa1111_set_io);
1287 EXPORT_SYMBOL(sa1111_set_sleep_io);
1288 EXPORT_SYMBOL(sa1111_enable_device);
1289 EXPORT_SYMBOL(sa1111_disable_device);
1290 EXPORT_SYMBOL(sa1111_pll_clock);
1291 EXPORT_SYMBOL(sa1111_bus_type);
1292 EXPORT_SYMBOL(sa1111_driver_register);
1293 EXPORT_SYMBOL(sa1111_driver_unregister);