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