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