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