2 * linux/arch/arm/mach-sa1100/sa1111.c
6 * Original code by John Dorsey
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.
12 * This file contains all generic SA1111 support.
14 * All initialization functions provided here are intended to be called
15 * from machine specific code with proper arguments when required.
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>
30 #include <asm/hardware.h>
31 #include <asm/mach-types.h>
34 #include <asm/mach/irq.h>
35 #include <asm/sizes.h>
37 #include <asm/hardware/sa1111.h>
39 #ifdef CONFIG_ARCH_PXA
40 #include <asm/arch/pxa-regs.h>
43 extern void __init
sa1110_mb_enable(void);
46 * We keep the following data for the overall SA1111. Note that the
47 * struct device and struct resource are "fake"; they should be supplied
48 * by the bus above us. However, in the interests of getting all SA1111
49 * drivers converted over to the device model, we provide this as an
50 * anchor point for all the other drivers.
61 * We _really_ need to eliminate this. Its only users
62 * are the PWM and DMA checking code.
64 static struct sa1111
*g_sa1111
;
66 struct sa1111_dev_info
{
68 unsigned long skpcr_mask
;
73 static struct sa1111_dev_info sa1111_devices
[] = {
76 .skpcr_mask
= SKPCR_UCLKEN
,
77 .devid
= SA1111_DEVID_USB
,
89 .skpcr_mask
= SKPCR_I2SCLKEN
| SKPCR_L3CLKEN
,
90 .devid
= SA1111_DEVID_SAC
,
100 .skpcr_mask
= SKPCR_SCLKEN
,
101 .devid
= SA1111_DEVID_SSP
,
104 .offset
= SA1111_KBD
,
105 .skpcr_mask
= SKPCR_PTCLKEN
,
106 .devid
= SA1111_DEVID_PS2
,
113 .offset
= SA1111_MSE
,
114 .skpcr_mask
= SKPCR_PMCLKEN
,
115 .devid
= SA1111_DEVID_PS2
,
124 .devid
= SA1111_DEVID_PCMCIA
,
136 void __init
sa1111_adjust_zones(int node
, unsigned long *size
, unsigned long *holes
)
138 unsigned int sz
= SZ_1M
>> PAGE_SHIFT
;
143 size
[1] = size
[0] - sz
;
148 * SA1111 interrupt support. Since clearing an IRQ while there are
149 * active IRQs causes the interrupt output to pulse, the upper levels
150 * will call us again if there are more interrupts to process.
153 sa1111_irq_handler(unsigned int irq
, struct irqdesc
*desc
, struct pt_regs
*regs
)
155 unsigned int stat0
, stat1
, i
;
156 void __iomem
*base
= desc
->data
;
158 stat0
= sa1111_readl(base
+ SA1111_INTSTATCLR0
);
159 stat1
= sa1111_readl(base
+ SA1111_INTSTATCLR1
);
161 sa1111_writel(stat0
, base
+ SA1111_INTSTATCLR0
);
163 desc
->chip
->ack(irq
);
165 sa1111_writel(stat1
, base
+ SA1111_INTSTATCLR1
);
167 if (stat0
== 0 && stat1
== 0) {
168 do_bad_IRQ(irq
, desc
, regs
);
172 for (i
= IRQ_SA1111_START
; stat0
; i
++, stat0
>>= 1)
174 do_edge_IRQ(i
, irq_desc
+ i
, regs
);
176 for (i
= IRQ_SA1111_START
+ 32; stat1
; i
++, stat1
>>= 1)
178 do_edge_IRQ(i
, irq_desc
+ i
, regs
);
180 /* For level-based interrupts */
181 desc
->chip
->unmask(irq
);
184 #define SA1111_IRQMASK_LO(x) (1 << (x - IRQ_SA1111_START))
185 #define SA1111_IRQMASK_HI(x) (1 << (x - IRQ_SA1111_START - 32))
187 static void sa1111_ack_irq(unsigned int irq
)
191 static void sa1111_mask_lowirq(unsigned int irq
)
193 void __iomem
*mapbase
= get_irq_chipdata(irq
);
196 ie0
= sa1111_readl(mapbase
+ SA1111_INTEN0
);
197 ie0
&= ~SA1111_IRQMASK_LO(irq
);
198 writel(ie0
, mapbase
+ SA1111_INTEN0
);
201 static void sa1111_unmask_lowirq(unsigned int irq
)
203 void __iomem
*mapbase
= get_irq_chipdata(irq
);
206 ie0
= sa1111_readl(mapbase
+ SA1111_INTEN0
);
207 ie0
|= SA1111_IRQMASK_LO(irq
);
208 sa1111_writel(ie0
, mapbase
+ SA1111_INTEN0
);
212 * Attempt to re-trigger the interrupt. The SA1111 contains a register
213 * (INTSET) which claims to do this. However, in practice no amount of
214 * manipulation of INTEN and INTSET guarantees that the interrupt will
215 * be triggered. In fact, its very difficult, if not impossible to get
216 * INTSET to re-trigger the interrupt.
218 static int sa1111_retrigger_lowirq(unsigned int irq
)
220 unsigned int mask
= SA1111_IRQMASK_LO(irq
);
221 void __iomem
*mapbase
= get_irq_chipdata(irq
);
225 ip0
= sa1111_readl(mapbase
+ SA1111_INTPOL0
);
226 for (i
= 0; i
< 8; i
++) {
227 sa1111_writel(ip0
^ mask
, mapbase
+ SA1111_INTPOL0
);
228 sa1111_writel(ip0
, mapbase
+ SA1111_INTPOL0
);
229 if (sa1111_readl(mapbase
+ SA1111_INTSTATCLR1
) & mask
)
234 printk(KERN_ERR
"Danger Will Robinson: failed to "
235 "re-trigger IRQ%d\n", irq
);
236 return i
== 8 ? -1 : 0;
239 static int sa1111_type_lowirq(unsigned int irq
, unsigned int flags
)
241 unsigned int mask
= SA1111_IRQMASK_LO(irq
);
242 void __iomem
*mapbase
= get_irq_chipdata(irq
);
245 if (flags
== IRQT_PROBE
)
248 if ((!(flags
& __IRQT_RISEDGE
) ^ !(flags
& __IRQT_FALEDGE
)) == 0)
251 ip0
= sa1111_readl(mapbase
+ SA1111_INTPOL0
);
252 if (flags
& __IRQT_RISEDGE
)
256 sa1111_writel(ip0
, mapbase
+ SA1111_INTPOL0
);
257 sa1111_writel(ip0
, mapbase
+ SA1111_WAKEPOL0
);
262 static int sa1111_wake_lowirq(unsigned int irq
, unsigned int on
)
264 unsigned int mask
= SA1111_IRQMASK_LO(irq
);
265 void __iomem
*mapbase
= get_irq_chipdata(irq
);
268 we0
= sa1111_readl(mapbase
+ SA1111_WAKEEN0
);
273 sa1111_writel(we0
, mapbase
+ SA1111_WAKEEN0
);
278 static struct irqchip sa1111_low_chip
= {
279 .ack
= sa1111_ack_irq
,
280 .mask
= sa1111_mask_lowirq
,
281 .unmask
= sa1111_unmask_lowirq
,
282 .retrigger
= sa1111_retrigger_lowirq
,
283 .set_type
= sa1111_type_lowirq
,
284 .set_wake
= sa1111_wake_lowirq
,
287 static void sa1111_mask_highirq(unsigned int irq
)
289 void __iomem
*mapbase
= get_irq_chipdata(irq
);
292 ie1
= sa1111_readl(mapbase
+ SA1111_INTEN1
);
293 ie1
&= ~SA1111_IRQMASK_HI(irq
);
294 sa1111_writel(ie1
, mapbase
+ SA1111_INTEN1
);
297 static void sa1111_unmask_highirq(unsigned int irq
)
299 void __iomem
*mapbase
= get_irq_chipdata(irq
);
302 ie1
= sa1111_readl(mapbase
+ SA1111_INTEN1
);
303 ie1
|= SA1111_IRQMASK_HI(irq
);
304 sa1111_writel(ie1
, mapbase
+ SA1111_INTEN1
);
308 * Attempt to re-trigger the interrupt. The SA1111 contains a register
309 * (INTSET) which claims to do this. However, in practice no amount of
310 * manipulation of INTEN and INTSET guarantees that the interrupt will
311 * be triggered. In fact, its very difficult, if not impossible to get
312 * INTSET to re-trigger the interrupt.
314 static int sa1111_retrigger_highirq(unsigned int irq
)
316 unsigned int mask
= SA1111_IRQMASK_HI(irq
);
317 void __iomem
*mapbase
= get_irq_chipdata(irq
);
321 ip1
= sa1111_readl(mapbase
+ SA1111_INTPOL1
);
322 for (i
= 0; i
< 8; i
++) {
323 sa1111_writel(ip1
^ mask
, mapbase
+ SA1111_INTPOL1
);
324 sa1111_writel(ip1
, mapbase
+ SA1111_INTPOL1
);
325 if (sa1111_readl(mapbase
+ SA1111_INTSTATCLR1
) & mask
)
330 printk(KERN_ERR
"Danger Will Robinson: failed to "
331 "re-trigger IRQ%d\n", irq
);
332 return i
== 8 ? -1 : 0;
335 static int sa1111_type_highirq(unsigned int irq
, unsigned int flags
)
337 unsigned int mask
= SA1111_IRQMASK_HI(irq
);
338 void __iomem
*mapbase
= get_irq_chipdata(irq
);
341 if (flags
== IRQT_PROBE
)
344 if ((!(flags
& __IRQT_RISEDGE
) ^ !(flags
& __IRQT_FALEDGE
)) == 0)
347 ip1
= sa1111_readl(mapbase
+ SA1111_INTPOL1
);
348 if (flags
& __IRQT_RISEDGE
)
352 sa1111_writel(ip1
, mapbase
+ SA1111_INTPOL1
);
353 sa1111_writel(ip1
, mapbase
+ SA1111_WAKEPOL1
);
358 static int sa1111_wake_highirq(unsigned int irq
, unsigned int on
)
360 unsigned int mask
= SA1111_IRQMASK_HI(irq
);
361 void __iomem
*mapbase
= get_irq_chipdata(irq
);
364 we1
= sa1111_readl(mapbase
+ SA1111_WAKEEN1
);
369 sa1111_writel(we1
, mapbase
+ SA1111_WAKEEN1
);
374 static struct irqchip sa1111_high_chip
= {
375 .ack
= sa1111_ack_irq
,
376 .mask
= sa1111_mask_highirq
,
377 .unmask
= sa1111_unmask_highirq
,
378 .retrigger
= sa1111_retrigger_highirq
,
379 .set_type
= sa1111_type_highirq
,
380 .set_wake
= sa1111_wake_highirq
,
383 static void sa1111_setup_irq(struct sa1111
*sachip
)
385 void __iomem
*irqbase
= sachip
->base
+ SA1111_INTC
;
389 * We're guaranteed that this region hasn't been taken.
391 request_mem_region(sachip
->phys
+ SA1111_INTC
, 512, "irq");
393 /* disable all IRQs */
394 sa1111_writel(0, irqbase
+ SA1111_INTEN0
);
395 sa1111_writel(0, irqbase
+ SA1111_INTEN1
);
396 sa1111_writel(0, irqbase
+ SA1111_WAKEEN0
);
397 sa1111_writel(0, irqbase
+ SA1111_WAKEEN1
);
400 * detect on rising edge. Note: Feb 2001 Errata for SA1111
401 * specifies that S0ReadyInt and S1ReadyInt should be '1'.
403 sa1111_writel(0, irqbase
+ SA1111_INTPOL0
);
404 sa1111_writel(SA1111_IRQMASK_HI(IRQ_S0_READY_NINT
) |
405 SA1111_IRQMASK_HI(IRQ_S1_READY_NINT
),
406 irqbase
+ SA1111_INTPOL1
);
409 sa1111_writel(~0, irqbase
+ SA1111_INTSTATCLR0
);
410 sa1111_writel(~0, irqbase
+ SA1111_INTSTATCLR1
);
412 for (irq
= IRQ_GPAIN0
; irq
<= SSPROR
; irq
++) {
413 set_irq_chip(irq
, &sa1111_low_chip
);
414 set_irq_chipdata(irq
, irqbase
);
415 set_irq_handler(irq
, do_edge_IRQ
);
416 set_irq_flags(irq
, IRQF_VALID
| IRQF_PROBE
);
419 for (irq
= AUDXMTDMADONEA
; irq
<= IRQ_S1_BVD1_STSCHG
; irq
++) {
420 set_irq_chip(irq
, &sa1111_high_chip
);
421 set_irq_chipdata(irq
, irqbase
);
422 set_irq_handler(irq
, do_edge_IRQ
);
423 set_irq_flags(irq
, IRQF_VALID
| IRQF_PROBE
);
427 * Register SA1111 interrupt
429 set_irq_type(sachip
->irq
, IRQT_RISING
);
430 set_irq_data(sachip
->irq
, irqbase
);
431 set_irq_chained_handler(sachip
->irq
, sa1111_irq_handler
);
435 * Bring the SA1111 out of reset. This requires a set procedure:
436 * 1. nRESET asserted (by hardware)
437 * 2. CLK turned on from SA1110
438 * 3. nRESET deasserted
439 * 4. VCO turned on, PLL_BYPASS turned off
440 * 5. Wait lock time, then assert RCLKEn
441 * 7. PCR set to allow clocking of individual functions
443 * Until we've done this, the only registers we can access are:
448 static void sa1111_wake(struct sa1111
*sachip
)
450 unsigned long flags
, r
;
452 spin_lock_irqsave(&sachip
->lock
, flags
);
454 #ifdef CONFIG_ARCH_SA1100
456 * First, set up the 3.6864MHz clock on GPIO 27 for the SA-1111:
457 * (SA-1110 Developer's Manual, section 9.1.2.1)
459 GAFR
|= GPIO_32_768kHz
;
460 GPDR
|= GPIO_32_768kHz
;
461 TUCR
= TUCR_3_6864MHz
;
462 #elif CONFIG_ARCH_PXA
463 pxa_gpio_mode(GPIO11_3_6MHz_MD
);
465 #error missing clock setup
469 * Turn VCO on, and disable PLL Bypass.
471 r
= sa1111_readl(sachip
->base
+ SA1111_SKCR
);
473 sa1111_writel(r
, sachip
->base
+ SA1111_SKCR
);
474 r
|= SKCR_PLL_BYPASS
| SKCR_OE_EN
;
475 sa1111_writel(r
, sachip
->base
+ SA1111_SKCR
);
478 * Wait lock time. SA1111 manual _doesn't_
479 * specify a figure for this! We choose 100us.
484 * Enable RCLK. We also ensure that RDYEN is set.
486 r
|= SKCR_RCLKEN
| SKCR_RDYEN
;
487 sa1111_writel(r
, sachip
->base
+ SA1111_SKCR
);
490 * Wait 14 RCLK cycles for the chip to finish coming out
491 * of reset. (RCLK=24MHz). This is 590ns.
496 * Ensure all clocks are initially off.
498 sa1111_writel(0, sachip
->base
+ SA1111_SKPCR
);
500 spin_unlock_irqrestore(&sachip
->lock
, flags
);
503 #ifdef CONFIG_ARCH_SA1100
505 static u32 sa1111_dma_mask
[] = {
517 * Configure the SA1111 shared memory controller.
520 sa1111_configure_smc(struct sa1111
*sachip
, int sdram
, unsigned int drac
,
521 unsigned int cas_latency
)
523 unsigned int smcr
= SMCR_DTIM
| SMCR_MBGE
| FInsrt(drac
, SMCR_DRAC
);
525 if (cas_latency
== 3)
528 sa1111_writel(smcr
, sachip
->base
+ SA1111_SMCR
);
531 * Now clear the bits in the DMA mask to work around the SA1111
532 * DMA erratum (Intel StrongARM SA-1111 Microprocessor Companion
533 * Chip Specification Update, June 2000, Erratum #7).
535 if (sachip
->dev
->dma_mask
)
536 *sachip
->dev
->dma_mask
&= sa1111_dma_mask
[drac
>> 2];
538 sachip
->dev
->coherent_dma_mask
&= sa1111_dma_mask
[drac
>> 2];
543 static void sa1111_dev_release(struct device
*_dev
)
545 struct sa1111_dev
*dev
= SA1111_DEV(_dev
);
547 release_resource(&dev
->res
);
552 sa1111_init_one_child(struct sa1111
*sachip
, struct resource
*parent
,
553 struct sa1111_dev_info
*info
)
555 struct sa1111_dev
*dev
;
558 dev
= kmalloc(sizeof(struct sa1111_dev
), GFP_KERNEL
);
563 memset(dev
, 0, sizeof(struct sa1111_dev
));
565 snprintf(dev
->dev
.bus_id
, sizeof(dev
->dev
.bus_id
),
566 "%4.4lx", info
->offset
);
568 dev
->devid
= info
->devid
;
569 dev
->dev
.parent
= sachip
->dev
;
570 dev
->dev
.bus
= &sa1111_bus_type
;
571 dev
->dev
.release
= sa1111_dev_release
;
572 dev
->dev
.coherent_dma_mask
= sachip
->dev
->coherent_dma_mask
;
573 dev
->res
.start
= sachip
->phys
+ info
->offset
;
574 dev
->res
.end
= dev
->res
.start
+ 511;
575 dev
->res
.name
= dev
->dev
.bus_id
;
576 dev
->res
.flags
= IORESOURCE_MEM
;
577 dev
->mapbase
= sachip
->base
+ info
->offset
;
578 dev
->skpcr_mask
= info
->skpcr_mask
;
579 memmove(dev
->irq
, info
->irq
, sizeof(dev
->irq
));
581 ret
= request_resource(parent
, &dev
->res
);
583 printk("SA1111: failed to allocate resource for %s\n",
590 ret
= device_register(&dev
->dev
);
592 release_resource(&dev
->res
);
598 * If the parent device has a DMA mask associated with it,
599 * propagate it down to the children.
601 if (sachip
->dev
->dma_mask
) {
602 dev
->dma_mask
= *sachip
->dev
->dma_mask
;
603 dev
->dev
.dma_mask
= &dev
->dma_mask
;
605 if (dev
->dma_mask
!= 0xffffffffUL
) {
606 ret
= dmabounce_register_dev(&dev
->dev
, 1024, 4096);
608 printk("SA1111: Failed to register %s with dmabounce", dev
->dev
.bus_id
);
609 device_unregister(&dev
->dev
);
619 * sa1111_probe - probe for a single SA1111 chip.
620 * @phys_addr: physical address of device.
622 * Probe for a SA1111 chip. This must be called
623 * before any other SA1111-specific code.
626 * %-ENODEV device not found.
627 * %-EBUSY physical address already marked in-use.
631 __sa1111_probe(struct device
*me
, struct resource
*mem
, int irq
)
633 struct sa1111
*sachip
;
635 unsigned int has_devs
, val
;
636 int i
, ret
= -ENODEV
;
638 sachip
= kmalloc(sizeof(struct sa1111
), GFP_KERNEL
);
642 memset(sachip
, 0, sizeof(struct sa1111
));
644 spin_lock_init(&sachip
->lock
);
647 dev_set_drvdata(sachip
->dev
, sachip
);
649 sachip
->phys
= mem
->start
;
653 * Map the whole region. This also maps the
654 * registers for our children.
656 sachip
->base
= ioremap(mem
->start
, PAGE_SIZE
* 2);
663 * Probe for the chip. Only touch the SBI registers.
665 id
= sa1111_readl(sachip
->base
+ SA1111_SKID
);
666 if ((id
& SKID_ID_MASK
) != SKID_SA1111_ID
) {
667 printk(KERN_DEBUG
"SA1111 not detected: ID = %08lx\n", id
);
672 printk(KERN_INFO
"SA1111 Microprocessor Companion Chip: "
673 "silicon revision %lx, metal revision %lx\n",
674 (id
& SKID_SIREV_MASK
)>>4, (id
& SKID_MTREV_MASK
));
677 * We found it. Wake the chip up, and initialise.
681 #ifdef CONFIG_ARCH_SA1100
683 * The SDRAM configuration of the SA1110 and the SA1111 must
684 * match. This is very important to ensure that SA1111 accesses
685 * don't corrupt the SDRAM. Note that this ungates the SA1111's
686 * MBGNT signal, so we must have called sa1110_mb_disable()
689 sa1111_configure_smc(sachip
, 1,
690 FExtr(MDCNFG
, MDCNFG_SA1110_DRAC0
),
691 FExtr(MDCNFG
, MDCNFG_SA1110_TDL0
));
694 * We only need to turn on DCLK whenever we want to use the
695 * DMA. It can otherwise be held firmly in the off position.
696 * (currently, we always enable it.)
698 val
= sa1111_readl(sachip
->base
+ SA1111_SKPCR
);
699 sa1111_writel(val
| SKPCR_DCLKEN
, sachip
->base
+ SA1111_SKPCR
);
702 * Enable the SA1110 memory bus request and grant signals.
708 * The interrupt controller must be initialised before any
709 * other device to ensure that the interrupts are available.
711 if (sachip
->irq
!= NO_IRQ
)
712 sa1111_setup_irq(sachip
);
717 if (machine_is_assabet() || machine_is_jornada720() ||
719 has_devs
&= ~(1 << 4);
721 has_devs
&= ~(1 << 1);
723 for (i
= 0; i
< ARRAY_SIZE(sa1111_devices
); i
++)
724 if (has_devs
& (1 << i
))
725 sa1111_init_one_child(sachip
, mem
, &sa1111_devices
[i
]);
730 iounmap(sachip
->base
);
736 static int sa1111_remove_one(struct device
*dev
, void *data
)
738 device_unregister(dev
);
742 static void __sa1111_remove(struct sa1111
*sachip
)
744 void __iomem
*irqbase
= sachip
->base
+ SA1111_INTC
;
746 device_for_each_child(sachip
->dev
, NULL
, sa1111_remove_one
);
748 /* disable all IRQs */
749 sa1111_writel(0, irqbase
+ SA1111_INTEN0
);
750 sa1111_writel(0, irqbase
+ SA1111_INTEN1
);
751 sa1111_writel(0, irqbase
+ SA1111_WAKEEN0
);
752 sa1111_writel(0, irqbase
+ SA1111_WAKEEN1
);
754 if (sachip
->irq
!= NO_IRQ
) {
755 set_irq_chained_handler(sachip
->irq
, NULL
);
756 set_irq_data(sachip
->irq
, NULL
);
758 release_mem_region(sachip
->phys
+ SA1111_INTC
, 512);
761 iounmap(sachip
->base
);
766 * According to the "Intel StrongARM SA-1111 Microprocessor Companion
767 * Chip Specification Update" (June 2000), erratum #7, there is a
768 * significant bug in the SA1111 SDRAM shared memory controller. If
769 * an access to a region of memory above 1MB relative to the bank base,
770 * it is important that address bit 10 _NOT_ be asserted. Depending
771 * on the configuration of the RAM, bit 10 may correspond to one
772 * of several different (processor-relative) address bits.
774 * This routine only identifies whether or not a given DMA address
775 * is susceptible to the bug.
777 * This should only get called for sa1111_device types due to the
778 * way we configure our device dma_masks.
780 int dma_needs_bounce(struct device
*dev
, dma_addr_t addr
, size_t size
)
783 * Section 4.6 of the "Intel StrongARM SA-1111 Development Module
784 * User's Guide" mentions that jumpers R51 and R52 control the
785 * target of SA-1111 DMA (either SDRAM bank 0 on Assabet, or
786 * SDRAM bank 1 on Neponset). The default configuration selects
787 * Assabet, so any address in bank 1 is necessarily invalid.
789 return ((machine_is_assabet() || machine_is_pfs168()) &&
790 (addr
>= 0xc8000000 || (addr
+ size
) >= 0xc8000000));
793 struct sa1111_save_data
{
798 unsigned char skpwm0
;
799 unsigned char skpwm1
;
802 * Interrupt controller
804 unsigned int intpol0
;
805 unsigned int intpol1
;
808 unsigned int wakepol0
;
809 unsigned int wakepol1
;
810 unsigned int wakeen0
;
811 unsigned int wakeen1
;
816 static int sa1111_suspend(struct platform_device
*dev
, pm_message_t state
)
818 struct sa1111
*sachip
= platform_get_drvdata(dev
);
819 struct sa1111_save_data
*save
;
824 save
= kmalloc(sizeof(struct sa1111_save_data
), GFP_KERNEL
);
827 dev
->dev
.power
.saved_state
= save
;
829 spin_lock_irqsave(&sachip
->lock
, flags
);
835 save
->skcr
= sa1111_readl(base
+ SA1111_SKCR
);
836 save
->skpcr
= sa1111_readl(base
+ SA1111_SKPCR
);
837 save
->skcdr
= sa1111_readl(base
+ SA1111_SKCDR
);
838 save
->skaud
= sa1111_readl(base
+ SA1111_SKAUD
);
839 save
->skpwm0
= sa1111_readl(base
+ SA1111_SKPWM0
);
840 save
->skpwm1
= sa1111_readl(base
+ SA1111_SKPWM1
);
842 base
= sachip
->base
+ SA1111_INTC
;
843 save
->intpol0
= sa1111_readl(base
+ SA1111_INTPOL0
);
844 save
->intpol1
= sa1111_readl(base
+ SA1111_INTPOL1
);
845 save
->inten0
= sa1111_readl(base
+ SA1111_INTEN0
);
846 save
->inten1
= sa1111_readl(base
+ SA1111_INTEN1
);
847 save
->wakepol0
= sa1111_readl(base
+ SA1111_WAKEPOL0
);
848 save
->wakepol1
= sa1111_readl(base
+ SA1111_WAKEPOL1
);
849 save
->wakeen0
= sa1111_readl(base
+ SA1111_WAKEEN0
);
850 save
->wakeen1
= sa1111_readl(base
+ SA1111_WAKEEN1
);
855 val
= sa1111_readl(sachip
->base
+ SA1111_SKCR
);
856 sa1111_writel(val
| SKCR_SLEEP
, sachip
->base
+ SA1111_SKCR
);
857 sa1111_writel(0, sachip
->base
+ SA1111_SKPWM0
);
858 sa1111_writel(0, sachip
->base
+ SA1111_SKPWM1
);
860 spin_unlock_irqrestore(&sachip
->lock
, flags
);
866 * sa1111_resume - Restore the SA1111 device state.
867 * @dev: device to restore
869 * Restore the general state of the SA1111; clock control and
870 * interrupt controller. Other parts of the SA1111 must be
871 * restored by their respective drivers, and must be called
872 * via LDM after this function.
874 static int sa1111_resume(struct platform_device
*dev
)
876 struct sa1111
*sachip
= platform_get_drvdata(dev
);
877 struct sa1111_save_data
*save
;
878 unsigned long flags
, id
;
881 save
= (struct sa1111_save_data
*)dev
->dev
.power
.saved_state
;
885 spin_lock_irqsave(&sachip
->lock
, flags
);
888 * Ensure that the SA1111 is still here.
889 * FIXME: shouldn't do this here.
891 id
= sa1111_readl(sachip
->base
+ SA1111_SKID
);
892 if ((id
& SKID_ID_MASK
) != SKID_SA1111_ID
) {
893 __sa1111_remove(sachip
);
894 platform_set_drvdata(dev
, NULL
);
900 * First of all, wake up the chip.
903 sa1111_writel(0, sachip
->base
+ SA1111_INTC
+ SA1111_INTEN0
);
904 sa1111_writel(0, sachip
->base
+ SA1111_INTC
+ SA1111_INTEN1
);
907 sa1111_writel(save
->skcr
, base
+ SA1111_SKCR
);
908 sa1111_writel(save
->skpcr
, base
+ SA1111_SKPCR
);
909 sa1111_writel(save
->skcdr
, base
+ SA1111_SKCDR
);
910 sa1111_writel(save
->skaud
, base
+ SA1111_SKAUD
);
911 sa1111_writel(save
->skpwm0
, base
+ SA1111_SKPWM0
);
912 sa1111_writel(save
->skpwm1
, base
+ SA1111_SKPWM1
);
914 base
= sachip
->base
+ SA1111_INTC
;
915 sa1111_writel(save
->intpol0
, base
+ SA1111_INTPOL0
);
916 sa1111_writel(save
->intpol1
, base
+ SA1111_INTPOL1
);
917 sa1111_writel(save
->inten0
, base
+ SA1111_INTEN0
);
918 sa1111_writel(save
->inten1
, base
+ SA1111_INTEN1
);
919 sa1111_writel(save
->wakepol0
, base
+ SA1111_WAKEPOL0
);
920 sa1111_writel(save
->wakepol1
, base
+ SA1111_WAKEPOL1
);
921 sa1111_writel(save
->wakeen0
, base
+ SA1111_WAKEEN0
);
922 sa1111_writel(save
->wakeen1
, base
+ SA1111_WAKEEN1
);
924 spin_unlock_irqrestore(&sachip
->lock
, flags
);
926 dev
->dev
.power
.saved_state
= NULL
;
933 #define sa1111_suspend NULL
934 #define sa1111_resume NULL
937 static int sa1111_probe(struct platform_device
*pdev
)
939 struct resource
*mem
;
942 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
945 irq
= platform_get_irq(pdev
, 0);
949 return __sa1111_probe(&pdev
->dev
, mem
, irq
);
952 static int sa1111_remove(struct platform_device
*pdev
)
954 struct sa1111
*sachip
= platform_get_drvdata(pdev
);
957 __sa1111_remove(sachip
);
958 platform_set_drvdata(pdev
, NULL
);
961 kfree(pdev
->dev
.power
.saved_state
);
962 pdev
->dev
.power
.saved_state
= NULL
;
970 * Not sure if this should be on the system bus or not yet.
971 * We really want some way to register a system device at
972 * the per-machine level, and then have this driver pick
973 * up the registered devices.
975 * We also need to handle the SDRAM configuration for
976 * PXA250/SA1110 machine classes.
978 static struct platform_driver sa1111_device_driver
= {
979 .probe
= sa1111_probe
,
980 .remove
= sa1111_remove
,
981 .suspend
= sa1111_suspend
,
982 .resume
= sa1111_resume
,
989 * Get the parent device driver (us) structure
990 * from a child function device
992 static inline struct sa1111
*sa1111_chip_driver(struct sa1111_dev
*sadev
)
994 return (struct sa1111
*)dev_get_drvdata(sadev
->dev
.parent
);
998 * The bits in the opdiv field are non-linear.
1000 static unsigned char opdiv_table
[] = { 1, 4, 2, 8 };
1002 static unsigned int __sa1111_pll_clock(struct sa1111
*sachip
)
1004 unsigned int skcdr
, fbdiv
, ipdiv
, opdiv
;
1006 skcdr
= sa1111_readl(sachip
->base
+ SA1111_SKCDR
);
1008 fbdiv
= (skcdr
& 0x007f) + 2;
1009 ipdiv
= ((skcdr
& 0x0f80) >> 7) + 2;
1010 opdiv
= opdiv_table
[(skcdr
& 0x3000) >> 12];
1012 return 3686400 * fbdiv
/ (ipdiv
* opdiv
);
1016 * sa1111_pll_clock - return the current PLL clock frequency.
1017 * @sadev: SA1111 function block
1019 * BUG: we should look at SKCR. We also blindly believe that
1020 * the chip is being fed with the 3.6864MHz clock.
1022 * Returns the PLL clock in Hz.
1024 unsigned int sa1111_pll_clock(struct sa1111_dev
*sadev
)
1026 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1028 return __sa1111_pll_clock(sachip
);
1032 * sa1111_select_audio_mode - select I2S or AC link mode
1033 * @sadev: SA1111 function block
1034 * @mode: One of %SA1111_AUDIO_ACLINK or %SA1111_AUDIO_I2S
1036 * Frob the SKCR to select AC Link mode or I2S mode for
1039 void sa1111_select_audio_mode(struct sa1111_dev
*sadev
, int mode
)
1041 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1042 unsigned long flags
;
1045 spin_lock_irqsave(&sachip
->lock
, flags
);
1047 val
= sa1111_readl(sachip
->base
+ SA1111_SKCR
);
1048 if (mode
== SA1111_AUDIO_I2S
) {
1053 sa1111_writel(val
, sachip
->base
+ SA1111_SKCR
);
1055 spin_unlock_irqrestore(&sachip
->lock
, flags
);
1059 * sa1111_set_audio_rate - set the audio sample rate
1060 * @sadev: SA1111 SAC function block
1061 * @rate: sample rate to select
1063 int sa1111_set_audio_rate(struct sa1111_dev
*sadev
, int rate
)
1065 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1068 if (sadev
->devid
!= SA1111_DEVID_SAC
)
1071 div
= (__sa1111_pll_clock(sachip
) / 256 + rate
/ 2) / rate
;
1077 sa1111_writel(div
- 1, sachip
->base
+ SA1111_SKAUD
);
1083 * sa1111_get_audio_rate - get the audio sample rate
1084 * @sadev: SA1111 SAC function block device
1086 int sa1111_get_audio_rate(struct sa1111_dev
*sadev
)
1088 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1091 if (sadev
->devid
!= SA1111_DEVID_SAC
)
1094 div
= sa1111_readl(sachip
->base
+ SA1111_SKAUD
) + 1;
1096 return __sa1111_pll_clock(sachip
) / (256 * div
);
1099 void sa1111_set_io_dir(struct sa1111_dev
*sadev
,
1100 unsigned int bits
, unsigned int dir
,
1101 unsigned int sleep_dir
)
1103 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1104 unsigned long flags
;
1106 void __iomem
*gpio
= sachip
->base
+ SA1111_GPIO
;
1108 #define MODIFY_BITS(port, mask, dir) \
1110 val = sa1111_readl(port); \
1112 val |= (dir) & (mask); \
1113 sa1111_writel(val, port); \
1116 spin_lock_irqsave(&sachip
->lock
, flags
);
1117 MODIFY_BITS(gpio
+ SA1111_GPIO_PADDR
, bits
& 15, dir
);
1118 MODIFY_BITS(gpio
+ SA1111_GPIO_PBDDR
, (bits
>> 8) & 255, dir
>> 8);
1119 MODIFY_BITS(gpio
+ SA1111_GPIO_PCDDR
, (bits
>> 16) & 255, dir
>> 16);
1121 MODIFY_BITS(gpio
+ SA1111_GPIO_PASDR
, bits
& 15, sleep_dir
);
1122 MODIFY_BITS(gpio
+ SA1111_GPIO_PBSDR
, (bits
>> 8) & 255, sleep_dir
>> 8);
1123 MODIFY_BITS(gpio
+ SA1111_GPIO_PCSDR
, (bits
>> 16) & 255, sleep_dir
>> 16);
1124 spin_unlock_irqrestore(&sachip
->lock
, flags
);
1127 void sa1111_set_io(struct sa1111_dev
*sadev
, unsigned int bits
, unsigned int v
)
1129 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1130 unsigned long flags
;
1132 void __iomem
*gpio
= sachip
->base
+ SA1111_GPIO
;
1134 spin_lock_irqsave(&sachip
->lock
, flags
);
1135 MODIFY_BITS(gpio
+ SA1111_GPIO_PADWR
, bits
& 15, v
);
1136 MODIFY_BITS(gpio
+ SA1111_GPIO_PBDWR
, (bits
>> 8) & 255, v
>> 8);
1137 MODIFY_BITS(gpio
+ SA1111_GPIO_PCDWR
, (bits
>> 16) & 255, v
>> 16);
1138 spin_unlock_irqrestore(&sachip
->lock
, flags
);
1141 void sa1111_set_sleep_io(struct sa1111_dev
*sadev
, unsigned int bits
, unsigned int v
)
1143 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1144 unsigned long flags
;
1146 void __iomem
*gpio
= sachip
->base
+ SA1111_GPIO
;
1148 spin_lock_irqsave(&sachip
->lock
, flags
);
1149 MODIFY_BITS(gpio
+ SA1111_GPIO_PASSR
, bits
& 15, v
);
1150 MODIFY_BITS(gpio
+ SA1111_GPIO_PBSSR
, (bits
>> 8) & 255, v
>> 8);
1151 MODIFY_BITS(gpio
+ SA1111_GPIO_PCSSR
, (bits
>> 16) & 255, v
>> 16);
1152 spin_unlock_irqrestore(&sachip
->lock
, flags
);
1156 * Individual device operations.
1160 * sa1111_enable_device - enable an on-chip SA1111 function block
1161 * @sadev: SA1111 function block device to enable
1163 void sa1111_enable_device(struct sa1111_dev
*sadev
)
1165 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1166 unsigned long flags
;
1169 spin_lock_irqsave(&sachip
->lock
, flags
);
1170 val
= sa1111_readl(sachip
->base
+ SA1111_SKPCR
);
1171 sa1111_writel(val
| sadev
->skpcr_mask
, sachip
->base
+ SA1111_SKPCR
);
1172 spin_unlock_irqrestore(&sachip
->lock
, flags
);
1176 * sa1111_disable_device - disable an on-chip SA1111 function block
1177 * @sadev: SA1111 function block device to disable
1179 void sa1111_disable_device(struct sa1111_dev
*sadev
)
1181 struct sa1111
*sachip
= sa1111_chip_driver(sadev
);
1182 unsigned long flags
;
1185 spin_lock_irqsave(&sachip
->lock
, flags
);
1186 val
= sa1111_readl(sachip
->base
+ SA1111_SKPCR
);
1187 sa1111_writel(val
& ~sadev
->skpcr_mask
, sachip
->base
+ SA1111_SKPCR
);
1188 spin_unlock_irqrestore(&sachip
->lock
, flags
);
1192 * SA1111 "Register Access Bus."
1194 * We model this as a regular bus type, and hang devices directly
1197 static int sa1111_match(struct device
*_dev
, struct device_driver
*_drv
)
1199 struct sa1111_dev
*dev
= SA1111_DEV(_dev
);
1200 struct sa1111_driver
*drv
= SA1111_DRV(_drv
);
1202 return dev
->devid
== drv
->devid
;
1205 static int sa1111_bus_suspend(struct device
*dev
, pm_message_t state
)
1207 struct sa1111_dev
*sadev
= SA1111_DEV(dev
);
1208 struct sa1111_driver
*drv
= SA1111_DRV(dev
->driver
);
1211 if (drv
&& drv
->suspend
)
1212 ret
= drv
->suspend(sadev
, state
);
1216 static int sa1111_bus_resume(struct device
*dev
)
1218 struct sa1111_dev
*sadev
= SA1111_DEV(dev
);
1219 struct sa1111_driver
*drv
= SA1111_DRV(dev
->driver
);
1222 if (drv
&& drv
->resume
)
1223 ret
= drv
->resume(sadev
);
1227 static int sa1111_bus_probe(struct device
*dev
)
1229 struct sa1111_dev
*sadev
= SA1111_DEV(dev
);
1230 struct sa1111_driver
*drv
= SA1111_DRV(dev
->driver
);
1234 ret
= drv
->probe(sadev
);
1238 static int sa1111_bus_remove(struct device
*dev
)
1240 struct sa1111_dev
*sadev
= SA1111_DEV(dev
);
1241 struct sa1111_driver
*drv
= SA1111_DRV(dev
->driver
);
1245 ret
= drv
->remove(sadev
);
1249 struct bus_type sa1111_bus_type
= {
1250 .name
= "sa1111-rab",
1251 .match
= sa1111_match
,
1252 .probe
= sa1111_bus_probe
,
1253 .remove
= sa1111_bus_remove
,
1254 .suspend
= sa1111_bus_suspend
,
1255 .resume
= sa1111_bus_resume
,
1258 int sa1111_driver_register(struct sa1111_driver
*driver
)
1260 driver
->drv
.bus
= &sa1111_bus_type
;
1261 return driver_register(&driver
->drv
);
1264 void sa1111_driver_unregister(struct sa1111_driver
*driver
)
1266 driver_unregister(&driver
->drv
);
1269 static int __init
sa1111_init(void)
1271 int ret
= bus_register(&sa1111_bus_type
);
1273 platform_driver_register(&sa1111_device_driver
);
1277 static void __exit
sa1111_exit(void)
1279 platform_driver_unregister(&sa1111_device_driver
);
1280 bus_unregister(&sa1111_bus_type
);
1283 subsys_initcall(sa1111_init
);
1284 module_exit(sa1111_exit
);
1286 MODULE_DESCRIPTION("Intel Corporation SA1111 core driver");
1287 MODULE_LICENSE("GPL");
1289 EXPORT_SYMBOL(sa1111_select_audio_mode
);
1290 EXPORT_SYMBOL(sa1111_set_audio_rate
);
1291 EXPORT_SYMBOL(sa1111_get_audio_rate
);
1292 EXPORT_SYMBOL(sa1111_set_io_dir
);
1293 EXPORT_SYMBOL(sa1111_set_io
);
1294 EXPORT_SYMBOL(sa1111_set_sleep_io
);
1295 EXPORT_SYMBOL(sa1111_enable_device
);
1296 EXPORT_SYMBOL(sa1111_disable_device
);
1297 EXPORT_SYMBOL(sa1111_pll_clock
);
1298 EXPORT_SYMBOL(sa1111_bus_type
);
1299 EXPORT_SYMBOL(sa1111_driver_register
);
1300 EXPORT_SYMBOL(sa1111_driver_unregister
);