11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/arch/arm/mach-sa1100/sa1111.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * SA1111 support 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Original code by John Dorsey 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds * it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds * published by the Free Software Foundation. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * This file contains all generic SA1111 support. 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * All initialization functions provided here are intended to be called 151da177e4SLinus Torvalds * from machine specific code with proper arguments when required. 161da177e4SLinus Torvalds */ 171da177e4SLinus Torvalds #include <linux/config.h> 181da177e4SLinus Torvalds #include <linux/module.h> 191da177e4SLinus Torvalds #include <linux/init.h> 201da177e4SLinus Torvalds #include <linux/kernel.h> 211da177e4SLinus Torvalds #include <linux/delay.h> 221da177e4SLinus Torvalds #include <linux/ptrace.h> 231da177e4SLinus Torvalds #include <linux/errno.h> 241da177e4SLinus Torvalds #include <linux/ioport.h> 25d052d1beSRussell King #include <linux/platform_device.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/spinlock.h> 281da177e4SLinus Torvalds #include <linux/dma-mapping.h> 2997d654f8SRussell King #include <linux/clk.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <asm/hardware.h> 321da177e4SLinus Torvalds #include <asm/mach-types.h> 331da177e4SLinus Torvalds #include <asm/io.h> 341da177e4SLinus Torvalds #include <asm/irq.h> 351da177e4SLinus Torvalds #include <asm/mach/irq.h> 3645e109d0SRussell King #include <asm/sizes.h> 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds #include <asm/hardware/sa1111.h> 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds extern void __init sa1110_mb_enable(void); 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds /* 431da177e4SLinus Torvalds * We keep the following data for the overall SA1111. Note that the 441da177e4SLinus Torvalds * struct device and struct resource are "fake"; they should be supplied 451da177e4SLinus Torvalds * by the bus above us. However, in the interests of getting all SA1111 461da177e4SLinus Torvalds * drivers converted over to the device model, we provide this as an 471da177e4SLinus Torvalds * anchor point for all the other drivers. 481da177e4SLinus Torvalds */ 491da177e4SLinus Torvalds struct sa1111 { 501da177e4SLinus Torvalds struct device *dev; 5197d654f8SRussell King struct clk *clk; 521da177e4SLinus Torvalds unsigned long phys; 531da177e4SLinus Torvalds int irq; 541da177e4SLinus Torvalds spinlock_t lock; 551da177e4SLinus Torvalds void __iomem *base; 561da177e4SLinus Torvalds }; 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds /* 591da177e4SLinus Torvalds * We _really_ need to eliminate this. Its only users 601da177e4SLinus Torvalds * are the PWM and DMA checking code. 611da177e4SLinus Torvalds */ 621da177e4SLinus Torvalds static struct sa1111 *g_sa1111; 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds struct sa1111_dev_info { 651da177e4SLinus Torvalds unsigned long offset; 661da177e4SLinus Torvalds unsigned long skpcr_mask; 671da177e4SLinus Torvalds unsigned int devid; 681da177e4SLinus Torvalds unsigned int irq[6]; 691da177e4SLinus Torvalds }; 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds static struct sa1111_dev_info sa1111_devices[] = { 721da177e4SLinus Torvalds { 731da177e4SLinus Torvalds .offset = SA1111_USB, 741da177e4SLinus Torvalds .skpcr_mask = SKPCR_UCLKEN, 751da177e4SLinus Torvalds .devid = SA1111_DEVID_USB, 761da177e4SLinus Torvalds .irq = { 771da177e4SLinus Torvalds IRQ_USBPWR, 781da177e4SLinus Torvalds IRQ_HCIM, 791da177e4SLinus Torvalds IRQ_HCIBUFFACC, 801da177e4SLinus Torvalds IRQ_HCIRMTWKP, 811da177e4SLinus Torvalds IRQ_NHCIMFCIR, 821da177e4SLinus Torvalds IRQ_USB_PORT_RESUME 831da177e4SLinus Torvalds }, 841da177e4SLinus Torvalds }, 851da177e4SLinus Torvalds { 861da177e4SLinus Torvalds .offset = 0x0600, 871da177e4SLinus Torvalds .skpcr_mask = SKPCR_I2SCLKEN | SKPCR_L3CLKEN, 881da177e4SLinus Torvalds .devid = SA1111_DEVID_SAC, 891da177e4SLinus Torvalds .irq = { 901da177e4SLinus Torvalds AUDXMTDMADONEA, 911da177e4SLinus Torvalds AUDXMTDMADONEB, 921da177e4SLinus Torvalds AUDRCVDMADONEA, 931da177e4SLinus Torvalds AUDRCVDMADONEB 941da177e4SLinus Torvalds }, 951da177e4SLinus Torvalds }, 961da177e4SLinus Torvalds { 971da177e4SLinus Torvalds .offset = 0x0800, 981da177e4SLinus Torvalds .skpcr_mask = SKPCR_SCLKEN, 991da177e4SLinus Torvalds .devid = SA1111_DEVID_SSP, 1001da177e4SLinus Torvalds }, 1011da177e4SLinus Torvalds { 1021da177e4SLinus Torvalds .offset = SA1111_KBD, 1031da177e4SLinus Torvalds .skpcr_mask = SKPCR_PTCLKEN, 1041da177e4SLinus Torvalds .devid = SA1111_DEVID_PS2, 1051da177e4SLinus Torvalds .irq = { 1061da177e4SLinus Torvalds IRQ_TPRXINT, 1071da177e4SLinus Torvalds IRQ_TPTXINT 1081da177e4SLinus Torvalds }, 1091da177e4SLinus Torvalds }, 1101da177e4SLinus Torvalds { 1111da177e4SLinus Torvalds .offset = SA1111_MSE, 1121da177e4SLinus Torvalds .skpcr_mask = SKPCR_PMCLKEN, 1131da177e4SLinus Torvalds .devid = SA1111_DEVID_PS2, 1141da177e4SLinus Torvalds .irq = { 1151da177e4SLinus Torvalds IRQ_MSRXINT, 1161da177e4SLinus Torvalds IRQ_MSTXINT 1171da177e4SLinus Torvalds }, 1181da177e4SLinus Torvalds }, 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds .offset = 0x1800, 1211da177e4SLinus Torvalds .skpcr_mask = 0, 1221da177e4SLinus Torvalds .devid = SA1111_DEVID_PCMCIA, 1231da177e4SLinus Torvalds .irq = { 1241da177e4SLinus Torvalds IRQ_S0_READY_NINT, 1251da177e4SLinus Torvalds IRQ_S0_CD_VALID, 1261da177e4SLinus Torvalds IRQ_S0_BVD1_STSCHG, 1271da177e4SLinus Torvalds IRQ_S1_READY_NINT, 1281da177e4SLinus Torvalds IRQ_S1_CD_VALID, 1291da177e4SLinus Torvalds IRQ_S1_BVD1_STSCHG, 1301da177e4SLinus Torvalds }, 1311da177e4SLinus Torvalds }, 1321da177e4SLinus Torvalds }; 1331da177e4SLinus Torvalds 1341b12050fSRussell King void __init sa1111_adjust_zones(int node, unsigned long *size, unsigned long *holes) 1351b12050fSRussell King { 1361b12050fSRussell King unsigned int sz = SZ_1M >> PAGE_SHIFT; 1371b12050fSRussell King 1381b12050fSRussell King if (node != 0) 1391b12050fSRussell King sz = 0; 1401b12050fSRussell King 1411b12050fSRussell King size[1] = size[0] - sz; 1421b12050fSRussell King size[0] = sz; 1431b12050fSRussell King } 1441b12050fSRussell King 1451da177e4SLinus Torvalds /* 1461da177e4SLinus Torvalds * SA1111 interrupt support. Since clearing an IRQ while there are 1471da177e4SLinus Torvalds * active IRQs causes the interrupt output to pulse, the upper levels 1481da177e4SLinus Torvalds * will call us again if there are more interrupts to process. 1491da177e4SLinus Torvalds */ 1501da177e4SLinus Torvalds static void 1511da177e4SLinus Torvalds sa1111_irq_handler(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs) 1521da177e4SLinus Torvalds { 1531da177e4SLinus Torvalds unsigned int stat0, stat1, i; 1541da177e4SLinus Torvalds void __iomem *base = desc->data; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds stat0 = sa1111_readl(base + SA1111_INTSTATCLR0); 1571da177e4SLinus Torvalds stat1 = sa1111_readl(base + SA1111_INTSTATCLR1); 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds sa1111_writel(stat0, base + SA1111_INTSTATCLR0); 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds desc->chip->ack(irq); 1621da177e4SLinus Torvalds 1631da177e4SLinus Torvalds sa1111_writel(stat1, base + SA1111_INTSTATCLR1); 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds if (stat0 == 0 && stat1 == 0) { 1661da177e4SLinus Torvalds do_bad_IRQ(irq, desc, regs); 1671da177e4SLinus Torvalds return; 1681da177e4SLinus Torvalds } 1691da177e4SLinus Torvalds 1701da177e4SLinus Torvalds for (i = IRQ_SA1111_START; stat0; i++, stat0 >>= 1) 1711da177e4SLinus Torvalds if (stat0 & 1) 1721da177e4SLinus Torvalds do_edge_IRQ(i, irq_desc + i, regs); 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds for (i = IRQ_SA1111_START + 32; stat1; i++, stat1 >>= 1) 1751da177e4SLinus Torvalds if (stat1 & 1) 1761da177e4SLinus Torvalds do_edge_IRQ(i, irq_desc + i, regs); 1771da177e4SLinus Torvalds 1781da177e4SLinus Torvalds /* For level-based interrupts */ 1791da177e4SLinus Torvalds desc->chip->unmask(irq); 1801da177e4SLinus Torvalds } 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds #define SA1111_IRQMASK_LO(x) (1 << (x - IRQ_SA1111_START)) 1831da177e4SLinus Torvalds #define SA1111_IRQMASK_HI(x) (1 << (x - IRQ_SA1111_START - 32)) 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds static void sa1111_ack_irq(unsigned int irq) 1861da177e4SLinus Torvalds { 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds static void sa1111_mask_lowirq(unsigned int irq) 1901da177e4SLinus Torvalds { 1911da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 1921da177e4SLinus Torvalds unsigned long ie0; 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds ie0 = sa1111_readl(mapbase + SA1111_INTEN0); 1951da177e4SLinus Torvalds ie0 &= ~SA1111_IRQMASK_LO(irq); 1961da177e4SLinus Torvalds writel(ie0, mapbase + SA1111_INTEN0); 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds static void sa1111_unmask_lowirq(unsigned int irq) 2001da177e4SLinus Torvalds { 2011da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 2021da177e4SLinus Torvalds unsigned long ie0; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds ie0 = sa1111_readl(mapbase + SA1111_INTEN0); 2051da177e4SLinus Torvalds ie0 |= SA1111_IRQMASK_LO(irq); 2061da177e4SLinus Torvalds sa1111_writel(ie0, mapbase + SA1111_INTEN0); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* 2101da177e4SLinus Torvalds * Attempt to re-trigger the interrupt. The SA1111 contains a register 2111da177e4SLinus Torvalds * (INTSET) which claims to do this. However, in practice no amount of 2121da177e4SLinus Torvalds * manipulation of INTEN and INTSET guarantees that the interrupt will 2131da177e4SLinus Torvalds * be triggered. In fact, its very difficult, if not impossible to get 2141da177e4SLinus Torvalds * INTSET to re-trigger the interrupt. 2151da177e4SLinus Torvalds */ 2161da177e4SLinus Torvalds static int sa1111_retrigger_lowirq(unsigned int irq) 2171da177e4SLinus Torvalds { 2181da177e4SLinus Torvalds unsigned int mask = SA1111_IRQMASK_LO(irq); 2191da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 2201da177e4SLinus Torvalds unsigned long ip0; 2211da177e4SLinus Torvalds int i; 2221da177e4SLinus Torvalds 2231da177e4SLinus Torvalds ip0 = sa1111_readl(mapbase + SA1111_INTPOL0); 2241da177e4SLinus Torvalds for (i = 0; i < 8; i++) { 2251da177e4SLinus Torvalds sa1111_writel(ip0 ^ mask, mapbase + SA1111_INTPOL0); 2261da177e4SLinus Torvalds sa1111_writel(ip0, mapbase + SA1111_INTPOL0); 2271da177e4SLinus Torvalds if (sa1111_readl(mapbase + SA1111_INTSTATCLR1) & mask) 2281da177e4SLinus Torvalds break; 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds if (i == 8) 2321da177e4SLinus Torvalds printk(KERN_ERR "Danger Will Robinson: failed to " 2331da177e4SLinus Torvalds "re-trigger IRQ%d\n", irq); 2341da177e4SLinus Torvalds return i == 8 ? -1 : 0; 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds static int sa1111_type_lowirq(unsigned int irq, unsigned int flags) 2381da177e4SLinus Torvalds { 2391da177e4SLinus Torvalds unsigned int mask = SA1111_IRQMASK_LO(irq); 2401da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 2411da177e4SLinus Torvalds unsigned long ip0; 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds if (flags == IRQT_PROBE) 2441da177e4SLinus Torvalds return 0; 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds if ((!(flags & __IRQT_RISEDGE) ^ !(flags & __IRQT_FALEDGE)) == 0) 2471da177e4SLinus Torvalds return -EINVAL; 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds ip0 = sa1111_readl(mapbase + SA1111_INTPOL0); 2501da177e4SLinus Torvalds if (flags & __IRQT_RISEDGE) 2511da177e4SLinus Torvalds ip0 &= ~mask; 2521da177e4SLinus Torvalds else 2531da177e4SLinus Torvalds ip0 |= mask; 2541da177e4SLinus Torvalds sa1111_writel(ip0, mapbase + SA1111_INTPOL0); 2551da177e4SLinus Torvalds sa1111_writel(ip0, mapbase + SA1111_WAKEPOL0); 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds return 0; 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds static int sa1111_wake_lowirq(unsigned int irq, unsigned int on) 2611da177e4SLinus Torvalds { 2621da177e4SLinus Torvalds unsigned int mask = SA1111_IRQMASK_LO(irq); 2631da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 2641da177e4SLinus Torvalds unsigned long we0; 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds we0 = sa1111_readl(mapbase + SA1111_WAKEEN0); 2671da177e4SLinus Torvalds if (on) 2681da177e4SLinus Torvalds we0 |= mask; 2691da177e4SLinus Torvalds else 2701da177e4SLinus Torvalds we0 &= ~mask; 2711da177e4SLinus Torvalds sa1111_writel(we0, mapbase + SA1111_WAKEEN0); 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds return 0; 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds static struct irqchip sa1111_low_chip = { 2771da177e4SLinus Torvalds .ack = sa1111_ack_irq, 2781da177e4SLinus Torvalds .mask = sa1111_mask_lowirq, 2791da177e4SLinus Torvalds .unmask = sa1111_unmask_lowirq, 2801da177e4SLinus Torvalds .retrigger = sa1111_retrigger_lowirq, 2817801907bSRussell King .set_type = sa1111_type_lowirq, 2827801907bSRussell King .set_wake = sa1111_wake_lowirq, 2831da177e4SLinus Torvalds }; 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds static void sa1111_mask_highirq(unsigned int irq) 2861da177e4SLinus Torvalds { 2871da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 2881da177e4SLinus Torvalds unsigned long ie1; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds ie1 = sa1111_readl(mapbase + SA1111_INTEN1); 2911da177e4SLinus Torvalds ie1 &= ~SA1111_IRQMASK_HI(irq); 2921da177e4SLinus Torvalds sa1111_writel(ie1, mapbase + SA1111_INTEN1); 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds static void sa1111_unmask_highirq(unsigned int irq) 2961da177e4SLinus Torvalds { 2971da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 2981da177e4SLinus Torvalds unsigned long ie1; 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds ie1 = sa1111_readl(mapbase + SA1111_INTEN1); 3011da177e4SLinus Torvalds ie1 |= SA1111_IRQMASK_HI(irq); 3021da177e4SLinus Torvalds sa1111_writel(ie1, mapbase + SA1111_INTEN1); 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds /* 3061da177e4SLinus Torvalds * Attempt to re-trigger the interrupt. The SA1111 contains a register 3071da177e4SLinus Torvalds * (INTSET) which claims to do this. However, in practice no amount of 3081da177e4SLinus Torvalds * manipulation of INTEN and INTSET guarantees that the interrupt will 3091da177e4SLinus Torvalds * be triggered. In fact, its very difficult, if not impossible to get 3101da177e4SLinus Torvalds * INTSET to re-trigger the interrupt. 3111da177e4SLinus Torvalds */ 3121da177e4SLinus Torvalds static int sa1111_retrigger_highirq(unsigned int irq) 3131da177e4SLinus Torvalds { 3141da177e4SLinus Torvalds unsigned int mask = SA1111_IRQMASK_HI(irq); 3151da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 3161da177e4SLinus Torvalds unsigned long ip1; 3171da177e4SLinus Torvalds int i; 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds ip1 = sa1111_readl(mapbase + SA1111_INTPOL1); 3201da177e4SLinus Torvalds for (i = 0; i < 8; i++) { 3211da177e4SLinus Torvalds sa1111_writel(ip1 ^ mask, mapbase + SA1111_INTPOL1); 3221da177e4SLinus Torvalds sa1111_writel(ip1, mapbase + SA1111_INTPOL1); 3231da177e4SLinus Torvalds if (sa1111_readl(mapbase + SA1111_INTSTATCLR1) & mask) 3241da177e4SLinus Torvalds break; 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds if (i == 8) 3281da177e4SLinus Torvalds printk(KERN_ERR "Danger Will Robinson: failed to " 3291da177e4SLinus Torvalds "re-trigger IRQ%d\n", irq); 3301da177e4SLinus Torvalds return i == 8 ? -1 : 0; 3311da177e4SLinus Torvalds } 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds static int sa1111_type_highirq(unsigned int irq, unsigned int flags) 3341da177e4SLinus Torvalds { 3351da177e4SLinus Torvalds unsigned int mask = SA1111_IRQMASK_HI(irq); 3361da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 3371da177e4SLinus Torvalds unsigned long ip1; 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds if (flags == IRQT_PROBE) 3401da177e4SLinus Torvalds return 0; 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds if ((!(flags & __IRQT_RISEDGE) ^ !(flags & __IRQT_FALEDGE)) == 0) 3431da177e4SLinus Torvalds return -EINVAL; 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds ip1 = sa1111_readl(mapbase + SA1111_INTPOL1); 3461da177e4SLinus Torvalds if (flags & __IRQT_RISEDGE) 3471da177e4SLinus Torvalds ip1 &= ~mask; 3481da177e4SLinus Torvalds else 3491da177e4SLinus Torvalds ip1 |= mask; 3501da177e4SLinus Torvalds sa1111_writel(ip1, mapbase + SA1111_INTPOL1); 3511da177e4SLinus Torvalds sa1111_writel(ip1, mapbase + SA1111_WAKEPOL1); 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds return 0; 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds static int sa1111_wake_highirq(unsigned int irq, unsigned int on) 3571da177e4SLinus Torvalds { 3581da177e4SLinus Torvalds unsigned int mask = SA1111_IRQMASK_HI(irq); 3591da177e4SLinus Torvalds void __iomem *mapbase = get_irq_chipdata(irq); 3601da177e4SLinus Torvalds unsigned long we1; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds we1 = sa1111_readl(mapbase + SA1111_WAKEEN1); 3631da177e4SLinus Torvalds if (on) 3641da177e4SLinus Torvalds we1 |= mask; 3651da177e4SLinus Torvalds else 3661da177e4SLinus Torvalds we1 &= ~mask; 3671da177e4SLinus Torvalds sa1111_writel(we1, mapbase + SA1111_WAKEEN1); 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds return 0; 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds static struct irqchip sa1111_high_chip = { 3731da177e4SLinus Torvalds .ack = sa1111_ack_irq, 3741da177e4SLinus Torvalds .mask = sa1111_mask_highirq, 3751da177e4SLinus Torvalds .unmask = sa1111_unmask_highirq, 3761da177e4SLinus Torvalds .retrigger = sa1111_retrigger_highirq, 3777801907bSRussell King .set_type = sa1111_type_highirq, 3787801907bSRussell King .set_wake = sa1111_wake_highirq, 3791da177e4SLinus Torvalds }; 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds static void sa1111_setup_irq(struct sa1111 *sachip) 3821da177e4SLinus Torvalds { 3831da177e4SLinus Torvalds void __iomem *irqbase = sachip->base + SA1111_INTC; 3841da177e4SLinus Torvalds unsigned int irq; 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds /* 3871da177e4SLinus Torvalds * We're guaranteed that this region hasn't been taken. 3881da177e4SLinus Torvalds */ 3891da177e4SLinus Torvalds request_mem_region(sachip->phys + SA1111_INTC, 512, "irq"); 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds /* disable all IRQs */ 3921da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_INTEN0); 3931da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_INTEN1); 3941da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_WAKEEN0); 3951da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_WAKEEN1); 3961da177e4SLinus Torvalds 3971da177e4SLinus Torvalds /* 3981da177e4SLinus Torvalds * detect on rising edge. Note: Feb 2001 Errata for SA1111 3991da177e4SLinus Torvalds * specifies that S0ReadyInt and S1ReadyInt should be '1'. 4001da177e4SLinus Torvalds */ 4011da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_INTPOL0); 4021da177e4SLinus Torvalds sa1111_writel(SA1111_IRQMASK_HI(IRQ_S0_READY_NINT) | 4031da177e4SLinus Torvalds SA1111_IRQMASK_HI(IRQ_S1_READY_NINT), 4041da177e4SLinus Torvalds irqbase + SA1111_INTPOL1); 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds /* clear all IRQs */ 4071da177e4SLinus Torvalds sa1111_writel(~0, irqbase + SA1111_INTSTATCLR0); 4081da177e4SLinus Torvalds sa1111_writel(~0, irqbase + SA1111_INTSTATCLR1); 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds for (irq = IRQ_GPAIN0; irq <= SSPROR; irq++) { 4111da177e4SLinus Torvalds set_irq_chip(irq, &sa1111_low_chip); 4121da177e4SLinus Torvalds set_irq_chipdata(irq, irqbase); 4131da177e4SLinus Torvalds set_irq_handler(irq, do_edge_IRQ); 4141da177e4SLinus Torvalds set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); 4151da177e4SLinus Torvalds } 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds for (irq = AUDXMTDMADONEA; irq <= IRQ_S1_BVD1_STSCHG; irq++) { 4181da177e4SLinus Torvalds set_irq_chip(irq, &sa1111_high_chip); 4191da177e4SLinus Torvalds set_irq_chipdata(irq, irqbase); 4201da177e4SLinus Torvalds set_irq_handler(irq, do_edge_IRQ); 4211da177e4SLinus Torvalds set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds /* 4251da177e4SLinus Torvalds * Register SA1111 interrupt 4261da177e4SLinus Torvalds */ 4271da177e4SLinus Torvalds set_irq_type(sachip->irq, IRQT_RISING); 4281da177e4SLinus Torvalds set_irq_data(sachip->irq, irqbase); 4291da177e4SLinus Torvalds set_irq_chained_handler(sachip->irq, sa1111_irq_handler); 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds /* 4331da177e4SLinus Torvalds * Bring the SA1111 out of reset. This requires a set procedure: 4341da177e4SLinus Torvalds * 1. nRESET asserted (by hardware) 4351da177e4SLinus Torvalds * 2. CLK turned on from SA1110 4361da177e4SLinus Torvalds * 3. nRESET deasserted 4371da177e4SLinus Torvalds * 4. VCO turned on, PLL_BYPASS turned off 4381da177e4SLinus Torvalds * 5. Wait lock time, then assert RCLKEn 4391da177e4SLinus Torvalds * 7. PCR set to allow clocking of individual functions 4401da177e4SLinus Torvalds * 4411da177e4SLinus Torvalds * Until we've done this, the only registers we can access are: 4421da177e4SLinus Torvalds * SBI_SKCR 4431da177e4SLinus Torvalds * SBI_SMCR 4441da177e4SLinus Torvalds * SBI_SKID 4451da177e4SLinus Torvalds */ 4461da177e4SLinus Torvalds static void sa1111_wake(struct sa1111 *sachip) 4471da177e4SLinus Torvalds { 4481da177e4SLinus Torvalds unsigned long flags, r; 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 4511da177e4SLinus Torvalds 45297d654f8SRussell King clk_enable(sachip->clk); 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds /* 4551da177e4SLinus Torvalds * Turn VCO on, and disable PLL Bypass. 4561da177e4SLinus Torvalds */ 4571da177e4SLinus Torvalds r = sa1111_readl(sachip->base + SA1111_SKCR); 4581da177e4SLinus Torvalds r &= ~SKCR_VCO_OFF; 4591da177e4SLinus Torvalds sa1111_writel(r, sachip->base + SA1111_SKCR); 4601da177e4SLinus Torvalds r |= SKCR_PLL_BYPASS | SKCR_OE_EN; 4611da177e4SLinus Torvalds sa1111_writel(r, sachip->base + SA1111_SKCR); 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds /* 4641da177e4SLinus Torvalds * Wait lock time. SA1111 manual _doesn't_ 4651da177e4SLinus Torvalds * specify a figure for this! We choose 100us. 4661da177e4SLinus Torvalds */ 4671da177e4SLinus Torvalds udelay(100); 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds /* 4701da177e4SLinus Torvalds * Enable RCLK. We also ensure that RDYEN is set. 4711da177e4SLinus Torvalds */ 4721da177e4SLinus Torvalds r |= SKCR_RCLKEN | SKCR_RDYEN; 4731da177e4SLinus Torvalds sa1111_writel(r, sachip->base + SA1111_SKCR); 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds /* 4761da177e4SLinus Torvalds * Wait 14 RCLK cycles for the chip to finish coming out 4771da177e4SLinus Torvalds * of reset. (RCLK=24MHz). This is 590ns. 4781da177e4SLinus Torvalds */ 4791da177e4SLinus Torvalds udelay(1); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds /* 4821da177e4SLinus Torvalds * Ensure all clocks are initially off. 4831da177e4SLinus Torvalds */ 4841da177e4SLinus Torvalds sa1111_writel(0, sachip->base + SA1111_SKPCR); 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds #ifdef CONFIG_ARCH_SA1100 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds static u32 sa1111_dma_mask[] = { 4921da177e4SLinus Torvalds ~0, 4931da177e4SLinus Torvalds ~(1 << 20), 4941da177e4SLinus Torvalds ~(1 << 23), 4951da177e4SLinus Torvalds ~(1 << 24), 4961da177e4SLinus Torvalds ~(1 << 25), 4971da177e4SLinus Torvalds ~(1 << 20), 4981da177e4SLinus Torvalds ~(1 << 20), 4991da177e4SLinus Torvalds 0, 5001da177e4SLinus Torvalds }; 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds /* 5031da177e4SLinus Torvalds * Configure the SA1111 shared memory controller. 5041da177e4SLinus Torvalds */ 5051da177e4SLinus Torvalds void 5061da177e4SLinus Torvalds sa1111_configure_smc(struct sa1111 *sachip, int sdram, unsigned int drac, 5071da177e4SLinus Torvalds unsigned int cas_latency) 5081da177e4SLinus Torvalds { 5091da177e4SLinus Torvalds unsigned int smcr = SMCR_DTIM | SMCR_MBGE | FInsrt(drac, SMCR_DRAC); 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds if (cas_latency == 3) 5121da177e4SLinus Torvalds smcr |= SMCR_CLAT; 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds sa1111_writel(smcr, sachip->base + SA1111_SMCR); 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds /* 5171da177e4SLinus Torvalds * Now clear the bits in the DMA mask to work around the SA1111 5181da177e4SLinus Torvalds * DMA erratum (Intel StrongARM SA-1111 Microprocessor Companion 5191da177e4SLinus Torvalds * Chip Specification Update, June 2000, Erratum #7). 5201da177e4SLinus Torvalds */ 5211da177e4SLinus Torvalds if (sachip->dev->dma_mask) 5221da177e4SLinus Torvalds *sachip->dev->dma_mask &= sa1111_dma_mask[drac >> 2]; 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds sachip->dev->coherent_dma_mask &= sa1111_dma_mask[drac >> 2]; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds #endif 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds static void sa1111_dev_release(struct device *_dev) 5301da177e4SLinus Torvalds { 5311da177e4SLinus Torvalds struct sa1111_dev *dev = SA1111_DEV(_dev); 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds release_resource(&dev->res); 5341da177e4SLinus Torvalds kfree(dev); 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds static int 5381da177e4SLinus Torvalds sa1111_init_one_child(struct sa1111 *sachip, struct resource *parent, 5391da177e4SLinus Torvalds struct sa1111_dev_info *info) 5401da177e4SLinus Torvalds { 5411da177e4SLinus Torvalds struct sa1111_dev *dev; 5421da177e4SLinus Torvalds int ret; 5431da177e4SLinus Torvalds 544*d2a02b93SRussell King dev = kzalloc(sizeof(struct sa1111_dev), GFP_KERNEL); 5451da177e4SLinus Torvalds if (!dev) { 5461da177e4SLinus Torvalds ret = -ENOMEM; 5471da177e4SLinus Torvalds goto out; 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), 5511da177e4SLinus Torvalds "%4.4lx", info->offset); 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds dev->devid = info->devid; 5541da177e4SLinus Torvalds dev->dev.parent = sachip->dev; 5551da177e4SLinus Torvalds dev->dev.bus = &sa1111_bus_type; 5561da177e4SLinus Torvalds dev->dev.release = sa1111_dev_release; 5571da177e4SLinus Torvalds dev->dev.coherent_dma_mask = sachip->dev->coherent_dma_mask; 5581da177e4SLinus Torvalds dev->res.start = sachip->phys + info->offset; 5591da177e4SLinus Torvalds dev->res.end = dev->res.start + 511; 5601da177e4SLinus Torvalds dev->res.name = dev->dev.bus_id; 5611da177e4SLinus Torvalds dev->res.flags = IORESOURCE_MEM; 5621da177e4SLinus Torvalds dev->mapbase = sachip->base + info->offset; 5631da177e4SLinus Torvalds dev->skpcr_mask = info->skpcr_mask; 5641da177e4SLinus Torvalds memmove(dev->irq, info->irq, sizeof(dev->irq)); 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds ret = request_resource(parent, &dev->res); 5671da177e4SLinus Torvalds if (ret) { 5681da177e4SLinus Torvalds printk("SA1111: failed to allocate resource for %s\n", 5691da177e4SLinus Torvalds dev->res.name); 5701da177e4SLinus Torvalds kfree(dev); 5711da177e4SLinus Torvalds goto out; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds ret = device_register(&dev->dev); 5761da177e4SLinus Torvalds if (ret) { 5771da177e4SLinus Torvalds release_resource(&dev->res); 5781da177e4SLinus Torvalds kfree(dev); 5791da177e4SLinus Torvalds goto out; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds /* 5831da177e4SLinus Torvalds * If the parent device has a DMA mask associated with it, 5841da177e4SLinus Torvalds * propagate it down to the children. 5851da177e4SLinus Torvalds */ 5861da177e4SLinus Torvalds if (sachip->dev->dma_mask) { 5871da177e4SLinus Torvalds dev->dma_mask = *sachip->dev->dma_mask; 5881da177e4SLinus Torvalds dev->dev.dma_mask = &dev->dma_mask; 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds if (dev->dma_mask != 0xffffffffUL) { 5911da177e4SLinus Torvalds ret = dmabounce_register_dev(&dev->dev, 1024, 4096); 5921da177e4SLinus Torvalds if (ret) { 5931da177e4SLinus Torvalds printk("SA1111: Failed to register %s with dmabounce", dev->dev.bus_id); 5941da177e4SLinus Torvalds device_unregister(&dev->dev); 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds out: 6001da177e4SLinus Torvalds return ret; 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds /** 6041da177e4SLinus Torvalds * sa1111_probe - probe for a single SA1111 chip. 6051da177e4SLinus Torvalds * @phys_addr: physical address of device. 6061da177e4SLinus Torvalds * 6071da177e4SLinus Torvalds * Probe for a SA1111 chip. This must be called 6081da177e4SLinus Torvalds * before any other SA1111-specific code. 6091da177e4SLinus Torvalds * 6101da177e4SLinus Torvalds * Returns: 6111da177e4SLinus Torvalds * %-ENODEV device not found. 6121da177e4SLinus Torvalds * %-EBUSY physical address already marked in-use. 6131da177e4SLinus Torvalds * %0 successful. 6141da177e4SLinus Torvalds */ 6151da177e4SLinus Torvalds static int 6161da177e4SLinus Torvalds __sa1111_probe(struct device *me, struct resource *mem, int irq) 6171da177e4SLinus Torvalds { 6181da177e4SLinus Torvalds struct sa1111 *sachip; 6191da177e4SLinus Torvalds unsigned long id; 6201da177e4SLinus Torvalds unsigned int has_devs, val; 6211da177e4SLinus Torvalds int i, ret = -ENODEV; 6221da177e4SLinus Torvalds 623*d2a02b93SRussell King sachip = kzalloc(sizeof(struct sa1111), GFP_KERNEL); 6241da177e4SLinus Torvalds if (!sachip) 6251da177e4SLinus Torvalds return -ENOMEM; 6261da177e4SLinus Torvalds 62797d654f8SRussell King sachip->clk = clk_get(me, "GPIO27_CLK"); 62897d654f8SRussell King if (!sachip->clk) { 62997d654f8SRussell King ret = PTR_ERR(sachip->clk); 63097d654f8SRussell King goto err_free; 63197d654f8SRussell King } 63297d654f8SRussell King 6331da177e4SLinus Torvalds spin_lock_init(&sachip->lock); 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds sachip->dev = me; 6361da177e4SLinus Torvalds dev_set_drvdata(sachip->dev, sachip); 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds sachip->phys = mem->start; 6391da177e4SLinus Torvalds sachip->irq = irq; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds /* 6421da177e4SLinus Torvalds * Map the whole region. This also maps the 6431da177e4SLinus Torvalds * registers for our children. 6441da177e4SLinus Torvalds */ 6451da177e4SLinus Torvalds sachip->base = ioremap(mem->start, PAGE_SIZE * 2); 6461da177e4SLinus Torvalds if (!sachip->base) { 6471da177e4SLinus Torvalds ret = -ENOMEM; 64897d654f8SRussell King goto err_clkput; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds /* 6521da177e4SLinus Torvalds * Probe for the chip. Only touch the SBI registers. 6531da177e4SLinus Torvalds */ 6541da177e4SLinus Torvalds id = sa1111_readl(sachip->base + SA1111_SKID); 6551da177e4SLinus Torvalds if ((id & SKID_ID_MASK) != SKID_SA1111_ID) { 6561da177e4SLinus Torvalds printk(KERN_DEBUG "SA1111 not detected: ID = %08lx\n", id); 6571da177e4SLinus Torvalds ret = -ENODEV; 65897d654f8SRussell King goto err_unmap; 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds printk(KERN_INFO "SA1111 Microprocessor Companion Chip: " 6621da177e4SLinus Torvalds "silicon revision %lx, metal revision %lx\n", 6631da177e4SLinus Torvalds (id & SKID_SIREV_MASK)>>4, (id & SKID_MTREV_MASK)); 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds /* 6661da177e4SLinus Torvalds * We found it. Wake the chip up, and initialise. 6671da177e4SLinus Torvalds */ 6681da177e4SLinus Torvalds sa1111_wake(sachip); 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds #ifdef CONFIG_ARCH_SA1100 6711da177e4SLinus Torvalds /* 6721da177e4SLinus Torvalds * The SDRAM configuration of the SA1110 and the SA1111 must 6731da177e4SLinus Torvalds * match. This is very important to ensure that SA1111 accesses 6741da177e4SLinus Torvalds * don't corrupt the SDRAM. Note that this ungates the SA1111's 6751da177e4SLinus Torvalds * MBGNT signal, so we must have called sa1110_mb_disable() 6761da177e4SLinus Torvalds * beforehand. 6771da177e4SLinus Torvalds */ 6781da177e4SLinus Torvalds sa1111_configure_smc(sachip, 1, 6791da177e4SLinus Torvalds FExtr(MDCNFG, MDCNFG_SA1110_DRAC0), 6801da177e4SLinus Torvalds FExtr(MDCNFG, MDCNFG_SA1110_TDL0)); 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds /* 6831da177e4SLinus Torvalds * We only need to turn on DCLK whenever we want to use the 6841da177e4SLinus Torvalds * DMA. It can otherwise be held firmly in the off position. 6851da177e4SLinus Torvalds * (currently, we always enable it.) 6861da177e4SLinus Torvalds */ 6871da177e4SLinus Torvalds val = sa1111_readl(sachip->base + SA1111_SKPCR); 6881da177e4SLinus Torvalds sa1111_writel(val | SKPCR_DCLKEN, sachip->base + SA1111_SKPCR); 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds /* 6911da177e4SLinus Torvalds * Enable the SA1110 memory bus request and grant signals. 6921da177e4SLinus Torvalds */ 6931da177e4SLinus Torvalds sa1110_mb_enable(); 6941da177e4SLinus Torvalds #endif 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds /* 6971da177e4SLinus Torvalds * The interrupt controller must be initialised before any 6981da177e4SLinus Torvalds * other device to ensure that the interrupts are available. 6991da177e4SLinus Torvalds */ 7001da177e4SLinus Torvalds if (sachip->irq != NO_IRQ) 7011da177e4SLinus Torvalds sa1111_setup_irq(sachip); 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds g_sa1111 = sachip; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds has_devs = ~0; 7061da177e4SLinus Torvalds if (machine_is_assabet() || machine_is_jornada720() || 7071da177e4SLinus Torvalds machine_is_badge4()) 7081da177e4SLinus Torvalds has_devs &= ~(1 << 4); 7091da177e4SLinus Torvalds else 7101da177e4SLinus Torvalds has_devs &= ~(1 << 1); 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds for (i = 0; i < ARRAY_SIZE(sa1111_devices); i++) 7131da177e4SLinus Torvalds if (has_devs & (1 << i)) 7141da177e4SLinus Torvalds sa1111_init_one_child(sachip, mem, &sa1111_devices[i]); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds return 0; 7171da177e4SLinus Torvalds 71897d654f8SRussell King err_unmap: 7191da177e4SLinus Torvalds iounmap(sachip->base); 72097d654f8SRussell King err_clkput: 72197d654f8SRussell King clk_put(sachip->clk); 72297d654f8SRussell King err_free: 7231da177e4SLinus Torvalds kfree(sachip); 7241da177e4SLinus Torvalds return ret; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 727522c37b9SRussell King static int sa1111_remove_one(struct device *dev, void *data) 728522c37b9SRussell King { 729522c37b9SRussell King device_unregister(dev); 730522c37b9SRussell King return 0; 731522c37b9SRussell King } 732522c37b9SRussell King 7331da177e4SLinus Torvalds static void __sa1111_remove(struct sa1111 *sachip) 7341da177e4SLinus Torvalds { 7351da177e4SLinus Torvalds void __iomem *irqbase = sachip->base + SA1111_INTC; 7361da177e4SLinus Torvalds 737522c37b9SRussell King device_for_each_child(sachip->dev, NULL, sa1111_remove_one); 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds /* disable all IRQs */ 7401da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_INTEN0); 7411da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_INTEN1); 7421da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_WAKEEN0); 7431da177e4SLinus Torvalds sa1111_writel(0, irqbase + SA1111_WAKEEN1); 7441da177e4SLinus Torvalds 74597d654f8SRussell King clk_disable(sachip->clk); 74697d654f8SRussell King 7471da177e4SLinus Torvalds if (sachip->irq != NO_IRQ) { 7481da177e4SLinus Torvalds set_irq_chained_handler(sachip->irq, NULL); 7491da177e4SLinus Torvalds set_irq_data(sachip->irq, NULL); 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds release_mem_region(sachip->phys + SA1111_INTC, 512); 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds iounmap(sachip->base); 75597d654f8SRussell King clk_put(sachip->clk); 7561da177e4SLinus Torvalds kfree(sachip); 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds /* 7601da177e4SLinus Torvalds * According to the "Intel StrongARM SA-1111 Microprocessor Companion 7611da177e4SLinus Torvalds * Chip Specification Update" (June 2000), erratum #7, there is a 7621da177e4SLinus Torvalds * significant bug in the SA1111 SDRAM shared memory controller. If 7631da177e4SLinus Torvalds * an access to a region of memory above 1MB relative to the bank base, 7641da177e4SLinus Torvalds * it is important that address bit 10 _NOT_ be asserted. Depending 7651da177e4SLinus Torvalds * on the configuration of the RAM, bit 10 may correspond to one 7661da177e4SLinus Torvalds * of several different (processor-relative) address bits. 7671da177e4SLinus Torvalds * 7681da177e4SLinus Torvalds * This routine only identifies whether or not a given DMA address 7691da177e4SLinus Torvalds * is susceptible to the bug. 7701da177e4SLinus Torvalds * 7711da177e4SLinus Torvalds * This should only get called for sa1111_device types due to the 7721da177e4SLinus Torvalds * way we configure our device dma_masks. 7731da177e4SLinus Torvalds */ 7741da177e4SLinus Torvalds int dma_needs_bounce(struct device *dev, dma_addr_t addr, size_t size) 7751da177e4SLinus Torvalds { 7761da177e4SLinus Torvalds /* 7771da177e4SLinus Torvalds * Section 4.6 of the "Intel StrongARM SA-1111 Development Module 7781da177e4SLinus Torvalds * User's Guide" mentions that jumpers R51 and R52 control the 7791da177e4SLinus Torvalds * target of SA-1111 DMA (either SDRAM bank 0 on Assabet, or 7801da177e4SLinus Torvalds * SDRAM bank 1 on Neponset). The default configuration selects 7811da177e4SLinus Torvalds * Assabet, so any address in bank 1 is necessarily invalid. 7821da177e4SLinus Torvalds */ 7831da177e4SLinus Torvalds return ((machine_is_assabet() || machine_is_pfs168()) && 7841da177e4SLinus Torvalds (addr >= 0xc8000000 || (addr + size) >= 0xc8000000)); 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds struct sa1111_save_data { 7881da177e4SLinus Torvalds unsigned int skcr; 7891da177e4SLinus Torvalds unsigned int skpcr; 7901da177e4SLinus Torvalds unsigned int skcdr; 7911da177e4SLinus Torvalds unsigned char skaud; 7921da177e4SLinus Torvalds unsigned char skpwm0; 7931da177e4SLinus Torvalds unsigned char skpwm1; 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds /* 7961da177e4SLinus Torvalds * Interrupt controller 7971da177e4SLinus Torvalds */ 7981da177e4SLinus Torvalds unsigned int intpol0; 7991da177e4SLinus Torvalds unsigned int intpol1; 8001da177e4SLinus Torvalds unsigned int inten0; 8011da177e4SLinus Torvalds unsigned int inten1; 8021da177e4SLinus Torvalds unsigned int wakepol0; 8031da177e4SLinus Torvalds unsigned int wakepol1; 8041da177e4SLinus Torvalds unsigned int wakeen0; 8051da177e4SLinus Torvalds unsigned int wakeen1; 8061da177e4SLinus Torvalds }; 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds #ifdef CONFIG_PM 8091da177e4SLinus Torvalds 8103ae5eaecSRussell King static int sa1111_suspend(struct platform_device *dev, pm_message_t state) 8111da177e4SLinus Torvalds { 8123ae5eaecSRussell King struct sa1111 *sachip = platform_get_drvdata(dev); 8131da177e4SLinus Torvalds struct sa1111_save_data *save; 8141da177e4SLinus Torvalds unsigned long flags; 8151da177e4SLinus Torvalds unsigned int val; 8161da177e4SLinus Torvalds void __iomem *base; 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds save = kmalloc(sizeof(struct sa1111_save_data), GFP_KERNEL); 8191da177e4SLinus Torvalds if (!save) 8201da177e4SLinus Torvalds return -ENOMEM; 8213ae5eaecSRussell King dev->dev.power.saved_state = save; 8221da177e4SLinus Torvalds 8231da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds /* 8261da177e4SLinus Torvalds * Save state. 8271da177e4SLinus Torvalds */ 8281da177e4SLinus Torvalds base = sachip->base; 8291da177e4SLinus Torvalds save->skcr = sa1111_readl(base + SA1111_SKCR); 8301da177e4SLinus Torvalds save->skpcr = sa1111_readl(base + SA1111_SKPCR); 8311da177e4SLinus Torvalds save->skcdr = sa1111_readl(base + SA1111_SKCDR); 8321da177e4SLinus Torvalds save->skaud = sa1111_readl(base + SA1111_SKAUD); 8331da177e4SLinus Torvalds save->skpwm0 = sa1111_readl(base + SA1111_SKPWM0); 8341da177e4SLinus Torvalds save->skpwm1 = sa1111_readl(base + SA1111_SKPWM1); 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds base = sachip->base + SA1111_INTC; 8371da177e4SLinus Torvalds save->intpol0 = sa1111_readl(base + SA1111_INTPOL0); 8381da177e4SLinus Torvalds save->intpol1 = sa1111_readl(base + SA1111_INTPOL1); 8391da177e4SLinus Torvalds save->inten0 = sa1111_readl(base + SA1111_INTEN0); 8401da177e4SLinus Torvalds save->inten1 = sa1111_readl(base + SA1111_INTEN1); 8411da177e4SLinus Torvalds save->wakepol0 = sa1111_readl(base + SA1111_WAKEPOL0); 8421da177e4SLinus Torvalds save->wakepol1 = sa1111_readl(base + SA1111_WAKEPOL1); 8431da177e4SLinus Torvalds save->wakeen0 = sa1111_readl(base + SA1111_WAKEEN0); 8441da177e4SLinus Torvalds save->wakeen1 = sa1111_readl(base + SA1111_WAKEEN1); 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds /* 8471da177e4SLinus Torvalds * Disable. 8481da177e4SLinus Torvalds */ 8491da177e4SLinus Torvalds val = sa1111_readl(sachip->base + SA1111_SKCR); 8501da177e4SLinus Torvalds sa1111_writel(val | SKCR_SLEEP, sachip->base + SA1111_SKCR); 8511da177e4SLinus Torvalds sa1111_writel(0, sachip->base + SA1111_SKPWM0); 8521da177e4SLinus Torvalds sa1111_writel(0, sachip->base + SA1111_SKPWM1); 8531da177e4SLinus Torvalds 85497d654f8SRussell King clk_disable(sachip->clk); 85597d654f8SRussell King 8561da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds return 0; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds /* 8621da177e4SLinus Torvalds * sa1111_resume - Restore the SA1111 device state. 8631da177e4SLinus Torvalds * @dev: device to restore 8641da177e4SLinus Torvalds * 8651da177e4SLinus Torvalds * Restore the general state of the SA1111; clock control and 8661da177e4SLinus Torvalds * interrupt controller. Other parts of the SA1111 must be 8671da177e4SLinus Torvalds * restored by their respective drivers, and must be called 8681da177e4SLinus Torvalds * via LDM after this function. 8691da177e4SLinus Torvalds */ 8703ae5eaecSRussell King static int sa1111_resume(struct platform_device *dev) 8711da177e4SLinus Torvalds { 8723ae5eaecSRussell King struct sa1111 *sachip = platform_get_drvdata(dev); 8731da177e4SLinus Torvalds struct sa1111_save_data *save; 8741da177e4SLinus Torvalds unsigned long flags, id; 8751da177e4SLinus Torvalds void __iomem *base; 8761da177e4SLinus Torvalds 8773ae5eaecSRussell King save = (struct sa1111_save_data *)dev->dev.power.saved_state; 8781da177e4SLinus Torvalds if (!save) 8791da177e4SLinus Torvalds return 0; 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 8821da177e4SLinus Torvalds 8831da177e4SLinus Torvalds /* 8841da177e4SLinus Torvalds * Ensure that the SA1111 is still here. 8851da177e4SLinus Torvalds * FIXME: shouldn't do this here. 8861da177e4SLinus Torvalds */ 8871da177e4SLinus Torvalds id = sa1111_readl(sachip->base + SA1111_SKID); 8881da177e4SLinus Torvalds if ((id & SKID_ID_MASK) != SKID_SA1111_ID) { 8891da177e4SLinus Torvalds __sa1111_remove(sachip); 8903ae5eaecSRussell King platform_set_drvdata(dev, NULL); 8911da177e4SLinus Torvalds kfree(save); 8921da177e4SLinus Torvalds return 0; 8931da177e4SLinus Torvalds } 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds /* 8961da177e4SLinus Torvalds * First of all, wake up the chip. 8971da177e4SLinus Torvalds */ 8981da177e4SLinus Torvalds sa1111_wake(sachip); 8991da177e4SLinus Torvalds sa1111_writel(0, sachip->base + SA1111_INTC + SA1111_INTEN0); 9001da177e4SLinus Torvalds sa1111_writel(0, sachip->base + SA1111_INTC + SA1111_INTEN1); 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds base = sachip->base; 9031da177e4SLinus Torvalds sa1111_writel(save->skcr, base + SA1111_SKCR); 9041da177e4SLinus Torvalds sa1111_writel(save->skpcr, base + SA1111_SKPCR); 9051da177e4SLinus Torvalds sa1111_writel(save->skcdr, base + SA1111_SKCDR); 9061da177e4SLinus Torvalds sa1111_writel(save->skaud, base + SA1111_SKAUD); 9071da177e4SLinus Torvalds sa1111_writel(save->skpwm0, base + SA1111_SKPWM0); 9081da177e4SLinus Torvalds sa1111_writel(save->skpwm1, base + SA1111_SKPWM1); 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds base = sachip->base + SA1111_INTC; 9111da177e4SLinus Torvalds sa1111_writel(save->intpol0, base + SA1111_INTPOL0); 9121da177e4SLinus Torvalds sa1111_writel(save->intpol1, base + SA1111_INTPOL1); 9131da177e4SLinus Torvalds sa1111_writel(save->inten0, base + SA1111_INTEN0); 9141da177e4SLinus Torvalds sa1111_writel(save->inten1, base + SA1111_INTEN1); 9151da177e4SLinus Torvalds sa1111_writel(save->wakepol0, base + SA1111_WAKEPOL0); 9161da177e4SLinus Torvalds sa1111_writel(save->wakepol1, base + SA1111_WAKEPOL1); 9171da177e4SLinus Torvalds sa1111_writel(save->wakeen0, base + SA1111_WAKEEN0); 9181da177e4SLinus Torvalds sa1111_writel(save->wakeen1, base + SA1111_WAKEEN1); 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 9211da177e4SLinus Torvalds 9223ae5eaecSRussell King dev->dev.power.saved_state = NULL; 9231da177e4SLinus Torvalds kfree(save); 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds return 0; 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds #else 9291da177e4SLinus Torvalds #define sa1111_suspend NULL 9301da177e4SLinus Torvalds #define sa1111_resume NULL 9311da177e4SLinus Torvalds #endif 9321da177e4SLinus Torvalds 9333ae5eaecSRussell King static int sa1111_probe(struct platform_device *pdev) 9341da177e4SLinus Torvalds { 9351da177e4SLinus Torvalds struct resource *mem; 9361da177e4SLinus Torvalds int irq; 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 9391da177e4SLinus Torvalds if (!mem) 9401da177e4SLinus Torvalds return -EINVAL; 9411da177e4SLinus Torvalds irq = platform_get_irq(pdev, 0); 94248944738SDavid Vrabel if (irq < 0) 94348944738SDavid Vrabel return -ENXIO; 9441da177e4SLinus Torvalds 9453ae5eaecSRussell King return __sa1111_probe(&pdev->dev, mem, irq); 9461da177e4SLinus Torvalds } 9471da177e4SLinus Torvalds 9483ae5eaecSRussell King static int sa1111_remove(struct platform_device *pdev) 9491da177e4SLinus Torvalds { 9503ae5eaecSRussell King struct sa1111 *sachip = platform_get_drvdata(pdev); 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds if (sachip) { 9531da177e4SLinus Torvalds __sa1111_remove(sachip); 9543ae5eaecSRussell King platform_set_drvdata(pdev, NULL); 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds #ifdef CONFIG_PM 9573ae5eaecSRussell King kfree(pdev->dev.power.saved_state); 9583ae5eaecSRussell King pdev->dev.power.saved_state = NULL; 9591da177e4SLinus Torvalds #endif 9601da177e4SLinus Torvalds } 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds return 0; 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds /* 9661da177e4SLinus Torvalds * Not sure if this should be on the system bus or not yet. 9671da177e4SLinus Torvalds * We really want some way to register a system device at 9681da177e4SLinus Torvalds * the per-machine level, and then have this driver pick 9691da177e4SLinus Torvalds * up the registered devices. 9701da177e4SLinus Torvalds * 9711da177e4SLinus Torvalds * We also need to handle the SDRAM configuration for 9721da177e4SLinus Torvalds * PXA250/SA1110 machine classes. 9731da177e4SLinus Torvalds */ 9743ae5eaecSRussell King static struct platform_driver sa1111_device_driver = { 9751da177e4SLinus Torvalds .probe = sa1111_probe, 9761da177e4SLinus Torvalds .remove = sa1111_remove, 9771da177e4SLinus Torvalds .suspend = sa1111_suspend, 9781da177e4SLinus Torvalds .resume = sa1111_resume, 9793ae5eaecSRussell King .driver = { 9803ae5eaecSRussell King .name = "sa1111", 9813ae5eaecSRussell King }, 9821da177e4SLinus Torvalds }; 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds /* 9851da177e4SLinus Torvalds * Get the parent device driver (us) structure 9861da177e4SLinus Torvalds * from a child function device 9871da177e4SLinus Torvalds */ 9881da177e4SLinus Torvalds static inline struct sa1111 *sa1111_chip_driver(struct sa1111_dev *sadev) 9891da177e4SLinus Torvalds { 9901da177e4SLinus Torvalds return (struct sa1111 *)dev_get_drvdata(sadev->dev.parent); 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds /* 9941da177e4SLinus Torvalds * The bits in the opdiv field are non-linear. 9951da177e4SLinus Torvalds */ 9961da177e4SLinus Torvalds static unsigned char opdiv_table[] = { 1, 4, 2, 8 }; 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds static unsigned int __sa1111_pll_clock(struct sa1111 *sachip) 9991da177e4SLinus Torvalds { 10001da177e4SLinus Torvalds unsigned int skcdr, fbdiv, ipdiv, opdiv; 10011da177e4SLinus Torvalds 10021da177e4SLinus Torvalds skcdr = sa1111_readl(sachip->base + SA1111_SKCDR); 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds fbdiv = (skcdr & 0x007f) + 2; 10051da177e4SLinus Torvalds ipdiv = ((skcdr & 0x0f80) >> 7) + 2; 10061da177e4SLinus Torvalds opdiv = opdiv_table[(skcdr & 0x3000) >> 12]; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds return 3686400 * fbdiv / (ipdiv * opdiv); 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds 10111da177e4SLinus Torvalds /** 10121da177e4SLinus Torvalds * sa1111_pll_clock - return the current PLL clock frequency. 10131da177e4SLinus Torvalds * @sadev: SA1111 function block 10141da177e4SLinus Torvalds * 10151da177e4SLinus Torvalds * BUG: we should look at SKCR. We also blindly believe that 10161da177e4SLinus Torvalds * the chip is being fed with the 3.6864MHz clock. 10171da177e4SLinus Torvalds * 10181da177e4SLinus Torvalds * Returns the PLL clock in Hz. 10191da177e4SLinus Torvalds */ 10201da177e4SLinus Torvalds unsigned int sa1111_pll_clock(struct sa1111_dev *sadev) 10211da177e4SLinus Torvalds { 10221da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 10231da177e4SLinus Torvalds 10241da177e4SLinus Torvalds return __sa1111_pll_clock(sachip); 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds 10271da177e4SLinus Torvalds /** 10281da177e4SLinus Torvalds * sa1111_select_audio_mode - select I2S or AC link mode 10291da177e4SLinus Torvalds * @sadev: SA1111 function block 10301da177e4SLinus Torvalds * @mode: One of %SA1111_AUDIO_ACLINK or %SA1111_AUDIO_I2S 10311da177e4SLinus Torvalds * 10321da177e4SLinus Torvalds * Frob the SKCR to select AC Link mode or I2S mode for 10331da177e4SLinus Torvalds * the audio block. 10341da177e4SLinus Torvalds */ 10351da177e4SLinus Torvalds void sa1111_select_audio_mode(struct sa1111_dev *sadev, int mode) 10361da177e4SLinus Torvalds { 10371da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 10381da177e4SLinus Torvalds unsigned long flags; 10391da177e4SLinus Torvalds unsigned int val; 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds val = sa1111_readl(sachip->base + SA1111_SKCR); 10441da177e4SLinus Torvalds if (mode == SA1111_AUDIO_I2S) { 10451da177e4SLinus Torvalds val &= ~SKCR_SELAC; 10461da177e4SLinus Torvalds } else { 10471da177e4SLinus Torvalds val |= SKCR_SELAC; 10481da177e4SLinus Torvalds } 10491da177e4SLinus Torvalds sa1111_writel(val, sachip->base + SA1111_SKCR); 10501da177e4SLinus Torvalds 10511da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds /** 10551da177e4SLinus Torvalds * sa1111_set_audio_rate - set the audio sample rate 10561da177e4SLinus Torvalds * @sadev: SA1111 SAC function block 10571da177e4SLinus Torvalds * @rate: sample rate to select 10581da177e4SLinus Torvalds */ 10591da177e4SLinus Torvalds int sa1111_set_audio_rate(struct sa1111_dev *sadev, int rate) 10601da177e4SLinus Torvalds { 10611da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 10621da177e4SLinus Torvalds unsigned int div; 10631da177e4SLinus Torvalds 10641da177e4SLinus Torvalds if (sadev->devid != SA1111_DEVID_SAC) 10651da177e4SLinus Torvalds return -EINVAL; 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds div = (__sa1111_pll_clock(sachip) / 256 + rate / 2) / rate; 10681da177e4SLinus Torvalds if (div == 0) 10691da177e4SLinus Torvalds div = 1; 10701da177e4SLinus Torvalds if (div > 128) 10711da177e4SLinus Torvalds div = 128; 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds sa1111_writel(div - 1, sachip->base + SA1111_SKAUD); 10741da177e4SLinus Torvalds 10751da177e4SLinus Torvalds return 0; 10761da177e4SLinus Torvalds } 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds /** 10791da177e4SLinus Torvalds * sa1111_get_audio_rate - get the audio sample rate 10801da177e4SLinus Torvalds * @sadev: SA1111 SAC function block device 10811da177e4SLinus Torvalds */ 10821da177e4SLinus Torvalds int sa1111_get_audio_rate(struct sa1111_dev *sadev) 10831da177e4SLinus Torvalds { 10841da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 10851da177e4SLinus Torvalds unsigned long div; 10861da177e4SLinus Torvalds 10871da177e4SLinus Torvalds if (sadev->devid != SA1111_DEVID_SAC) 10881da177e4SLinus Torvalds return -EINVAL; 10891da177e4SLinus Torvalds 10901da177e4SLinus Torvalds div = sa1111_readl(sachip->base + SA1111_SKAUD) + 1; 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds return __sa1111_pll_clock(sachip) / (256 * div); 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds void sa1111_set_io_dir(struct sa1111_dev *sadev, 10961da177e4SLinus Torvalds unsigned int bits, unsigned int dir, 10971da177e4SLinus Torvalds unsigned int sleep_dir) 10981da177e4SLinus Torvalds { 10991da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 11001da177e4SLinus Torvalds unsigned long flags; 11011da177e4SLinus Torvalds unsigned int val; 11021da177e4SLinus Torvalds void __iomem *gpio = sachip->base + SA1111_GPIO; 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds #define MODIFY_BITS(port, mask, dir) \ 11051da177e4SLinus Torvalds if (mask) { \ 11061da177e4SLinus Torvalds val = sa1111_readl(port); \ 11071da177e4SLinus Torvalds val &= ~(mask); \ 11081da177e4SLinus Torvalds val |= (dir) & (mask); \ 11091da177e4SLinus Torvalds sa1111_writel(val, port); \ 11101da177e4SLinus Torvalds } 11111da177e4SLinus Torvalds 11121da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 11131da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PADDR, bits & 15, dir); 11141da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PBDDR, (bits >> 8) & 255, dir >> 8); 11151da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PCDDR, (bits >> 16) & 255, dir >> 16); 11161da177e4SLinus Torvalds 11171da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PASDR, bits & 15, sleep_dir); 11181da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PBSDR, (bits >> 8) & 255, sleep_dir >> 8); 11191da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PCSDR, (bits >> 16) & 255, sleep_dir >> 16); 11201da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds void sa1111_set_io(struct sa1111_dev *sadev, unsigned int bits, unsigned int v) 11241da177e4SLinus Torvalds { 11251da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 11261da177e4SLinus Torvalds unsigned long flags; 11271da177e4SLinus Torvalds unsigned int val; 11281da177e4SLinus Torvalds void __iomem *gpio = sachip->base + SA1111_GPIO; 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 11311da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PADWR, bits & 15, v); 11321da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PBDWR, (bits >> 8) & 255, v >> 8); 11331da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PCDWR, (bits >> 16) & 255, v >> 16); 11341da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds void sa1111_set_sleep_io(struct sa1111_dev *sadev, unsigned int bits, unsigned int v) 11381da177e4SLinus Torvalds { 11391da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 11401da177e4SLinus Torvalds unsigned long flags; 11411da177e4SLinus Torvalds unsigned int val; 11421da177e4SLinus Torvalds void __iomem *gpio = sachip->base + SA1111_GPIO; 11431da177e4SLinus Torvalds 11441da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 11451da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PASSR, bits & 15, v); 11461da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PBSSR, (bits >> 8) & 255, v >> 8); 11471da177e4SLinus Torvalds MODIFY_BITS(gpio + SA1111_GPIO_PCSSR, (bits >> 16) & 255, v >> 16); 11481da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 11491da177e4SLinus Torvalds } 11501da177e4SLinus Torvalds 11511da177e4SLinus Torvalds /* 11521da177e4SLinus Torvalds * Individual device operations. 11531da177e4SLinus Torvalds */ 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds /** 11561da177e4SLinus Torvalds * sa1111_enable_device - enable an on-chip SA1111 function block 11571da177e4SLinus Torvalds * @sadev: SA1111 function block device to enable 11581da177e4SLinus Torvalds */ 11591da177e4SLinus Torvalds void sa1111_enable_device(struct sa1111_dev *sadev) 11601da177e4SLinus Torvalds { 11611da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 11621da177e4SLinus Torvalds unsigned long flags; 11631da177e4SLinus Torvalds unsigned int val; 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 11661da177e4SLinus Torvalds val = sa1111_readl(sachip->base + SA1111_SKPCR); 11671da177e4SLinus Torvalds sa1111_writel(val | sadev->skpcr_mask, sachip->base + SA1111_SKPCR); 11681da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 11691da177e4SLinus Torvalds } 11701da177e4SLinus Torvalds 11711da177e4SLinus Torvalds /** 11721da177e4SLinus Torvalds * sa1111_disable_device - disable an on-chip SA1111 function block 11731da177e4SLinus Torvalds * @sadev: SA1111 function block device to disable 11741da177e4SLinus Torvalds */ 11751da177e4SLinus Torvalds void sa1111_disable_device(struct sa1111_dev *sadev) 11761da177e4SLinus Torvalds { 11771da177e4SLinus Torvalds struct sa1111 *sachip = sa1111_chip_driver(sadev); 11781da177e4SLinus Torvalds unsigned long flags; 11791da177e4SLinus Torvalds unsigned int val; 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds spin_lock_irqsave(&sachip->lock, flags); 11821da177e4SLinus Torvalds val = sa1111_readl(sachip->base + SA1111_SKPCR); 11831da177e4SLinus Torvalds sa1111_writel(val & ~sadev->skpcr_mask, sachip->base + SA1111_SKPCR); 11841da177e4SLinus Torvalds spin_unlock_irqrestore(&sachip->lock, flags); 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds /* 11881da177e4SLinus Torvalds * SA1111 "Register Access Bus." 11891da177e4SLinus Torvalds * 11901da177e4SLinus Torvalds * We model this as a regular bus type, and hang devices directly 11911da177e4SLinus Torvalds * off this. 11921da177e4SLinus Torvalds */ 11931da177e4SLinus Torvalds static int sa1111_match(struct device *_dev, struct device_driver *_drv) 11941da177e4SLinus Torvalds { 11951da177e4SLinus Torvalds struct sa1111_dev *dev = SA1111_DEV(_dev); 11961da177e4SLinus Torvalds struct sa1111_driver *drv = SA1111_DRV(_drv); 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds return dev->devid == drv->devid; 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds static int sa1111_bus_suspend(struct device *dev, pm_message_t state) 12021da177e4SLinus Torvalds { 12031da177e4SLinus Torvalds struct sa1111_dev *sadev = SA1111_DEV(dev); 12041da177e4SLinus Torvalds struct sa1111_driver *drv = SA1111_DRV(dev->driver); 12051da177e4SLinus Torvalds int ret = 0; 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds if (drv && drv->suspend) 12081da177e4SLinus Torvalds ret = drv->suspend(sadev, state); 12091da177e4SLinus Torvalds return ret; 12101da177e4SLinus Torvalds } 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds static int sa1111_bus_resume(struct device *dev) 12131da177e4SLinus Torvalds { 12141da177e4SLinus Torvalds struct sa1111_dev *sadev = SA1111_DEV(dev); 12151da177e4SLinus Torvalds struct sa1111_driver *drv = SA1111_DRV(dev->driver); 12161da177e4SLinus Torvalds int ret = 0; 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds if (drv && drv->resume) 12191da177e4SLinus Torvalds ret = drv->resume(sadev); 12201da177e4SLinus Torvalds return ret; 12211da177e4SLinus Torvalds } 12221da177e4SLinus Torvalds 12231da177e4SLinus Torvalds static int sa1111_bus_probe(struct device *dev) 12241da177e4SLinus Torvalds { 12251da177e4SLinus Torvalds struct sa1111_dev *sadev = SA1111_DEV(dev); 12261da177e4SLinus Torvalds struct sa1111_driver *drv = SA1111_DRV(dev->driver); 12271da177e4SLinus Torvalds int ret = -ENODEV; 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds if (drv->probe) 12301da177e4SLinus Torvalds ret = drv->probe(sadev); 12311da177e4SLinus Torvalds return ret; 12321da177e4SLinus Torvalds } 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds static int sa1111_bus_remove(struct device *dev) 12351da177e4SLinus Torvalds { 12361da177e4SLinus Torvalds struct sa1111_dev *sadev = SA1111_DEV(dev); 12371da177e4SLinus Torvalds struct sa1111_driver *drv = SA1111_DRV(dev->driver); 12381da177e4SLinus Torvalds int ret = 0; 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds if (drv->remove) 12411da177e4SLinus Torvalds ret = drv->remove(sadev); 12421da177e4SLinus Torvalds return ret; 12431da177e4SLinus Torvalds } 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds struct bus_type sa1111_bus_type = { 12461da177e4SLinus Torvalds .name = "sa1111-rab", 12471da177e4SLinus Torvalds .match = sa1111_match, 12482876ba43SRussell King .probe = sa1111_bus_probe, 12492876ba43SRussell King .remove = sa1111_bus_remove, 12501da177e4SLinus Torvalds .suspend = sa1111_bus_suspend, 12511da177e4SLinus Torvalds .resume = sa1111_bus_resume, 12521da177e4SLinus Torvalds }; 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds int sa1111_driver_register(struct sa1111_driver *driver) 12551da177e4SLinus Torvalds { 12561da177e4SLinus Torvalds driver->drv.bus = &sa1111_bus_type; 12571da177e4SLinus Torvalds return driver_register(&driver->drv); 12581da177e4SLinus Torvalds } 12591da177e4SLinus Torvalds 12601da177e4SLinus Torvalds void sa1111_driver_unregister(struct sa1111_driver *driver) 12611da177e4SLinus Torvalds { 12621da177e4SLinus Torvalds driver_unregister(&driver->drv); 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds static int __init sa1111_init(void) 12661da177e4SLinus Torvalds { 12671da177e4SLinus Torvalds int ret = bus_register(&sa1111_bus_type); 12681da177e4SLinus Torvalds if (ret == 0) 12693ae5eaecSRussell King platform_driver_register(&sa1111_device_driver); 12701da177e4SLinus Torvalds return ret; 12711da177e4SLinus Torvalds } 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds static void __exit sa1111_exit(void) 12741da177e4SLinus Torvalds { 12753ae5eaecSRussell King platform_driver_unregister(&sa1111_device_driver); 12761da177e4SLinus Torvalds bus_unregister(&sa1111_bus_type); 12771da177e4SLinus Torvalds } 12781da177e4SLinus Torvalds 127972724382SRussell King subsys_initcall(sa1111_init); 12801da177e4SLinus Torvalds module_exit(sa1111_exit); 12811da177e4SLinus Torvalds 12821da177e4SLinus Torvalds MODULE_DESCRIPTION("Intel Corporation SA1111 core driver"); 12831da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_select_audio_mode); 12861da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_set_audio_rate); 12871da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_get_audio_rate); 12881da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_set_io_dir); 12891da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_set_io); 12901da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_set_sleep_io); 12911da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_enable_device); 12921da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_disable_device); 12931da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_pll_clock); 12941da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_bus_type); 12951da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_driver_register); 12961da177e4SLinus Torvalds EXPORT_SYMBOL(sa1111_driver_unregister); 1297