11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/arch/arm/mach-sa1100/neponset.c 31da177e4SLinus Torvalds */ 49590e898SRussell King #include <linux/err.h> 51da177e4SLinus Torvalds #include <linux/init.h> 61da177e4SLinus Torvalds #include <linux/ioport.h> 7ced8d21cSRussell King #include <linux/irq.h> 892e617d9SRussell King #include <linux/kernel.h> 9ae14c2e2SRussell King #include <linux/module.h> 10d052d1beSRussell King #include <linux/platform_device.h> 1151f93390SRussell King #include <linux/pm.h> 1292e617d9SRussell King #include <linux/serial_core.h> 13ae14c2e2SRussell King #include <linux/slab.h> 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds #include <asm/mach-types.h> 161da177e4SLinus Torvalds #include <asm/mach/map.h> 171da177e4SLinus Torvalds #include <asm/mach/serial_sa1100.h> 181da177e4SLinus Torvalds #include <asm/hardware/sa1111.h> 191da177e4SLinus Torvalds #include <asm/sizes.h> 201da177e4SLinus Torvalds 2192e617d9SRussell King #include <mach/hardware.h> 2292e617d9SRussell King #include <mach/assabet.h> 2392e617d9SRussell King #include <mach/neponset.h> 2492e617d9SRussell King 25ced8d21cSRussell King #define NEP_IRQ_SMC91X 0 26ced8d21cSRussell King #define NEP_IRQ_USAR 1 27ced8d21cSRussell King #define NEP_IRQ_SA1111 2 28ced8d21cSRussell King #define NEP_IRQ_NR 3 29ced8d21cSRussell King 30ae14c2e2SRussell King struct neponset_drvdata { 319590e898SRussell King struct platform_device *sa1111; 329590e898SRussell King struct platform_device *smc91x; 33ced8d21cSRussell King unsigned irq_base; 34ae14c2e2SRussell King #ifdef CONFIG_PM_SLEEP 35ae14c2e2SRussell King u32 ncr0; 36ae14c2e2SRussell King u32 mdm_ctl_0; 37ae14c2e2SRussell King #endif 38ae14c2e2SRussell King }; 39ae14c2e2SRussell King 406ad1b614SRussell King void neponset_ncr_frob(unsigned int mask, unsigned int val) 416ad1b614SRussell King { 426ad1b614SRussell King unsigned long flags; 436ad1b614SRussell King 446ad1b614SRussell King local_irq_save(flags); 456ad1b614SRussell King NCR_0 = (NCR_0 & ~mask) | val; 466ad1b614SRussell King local_irq_restore(flags); 476ad1b614SRussell King } 486ad1b614SRussell King 491da177e4SLinus Torvalds static void neponset_set_mctrl(struct uart_port *port, u_int mctrl) 501da177e4SLinus Torvalds { 511da177e4SLinus Torvalds u_int mdm_ctl0 = MDM_CTL_0; 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds if (port->mapbase == _Ser1UTCR0) { 541da177e4SLinus Torvalds if (mctrl & TIOCM_RTS) 551da177e4SLinus Torvalds mdm_ctl0 &= ~MDM_CTL0_RTS2; 561da177e4SLinus Torvalds else 571da177e4SLinus Torvalds mdm_ctl0 |= MDM_CTL0_RTS2; 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds if (mctrl & TIOCM_DTR) 601da177e4SLinus Torvalds mdm_ctl0 &= ~MDM_CTL0_DTR2; 611da177e4SLinus Torvalds else 621da177e4SLinus Torvalds mdm_ctl0 |= MDM_CTL0_DTR2; 631da177e4SLinus Torvalds } else if (port->mapbase == _Ser3UTCR0) { 641da177e4SLinus Torvalds if (mctrl & TIOCM_RTS) 651da177e4SLinus Torvalds mdm_ctl0 &= ~MDM_CTL0_RTS1; 661da177e4SLinus Torvalds else 671da177e4SLinus Torvalds mdm_ctl0 |= MDM_CTL0_RTS1; 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds if (mctrl & TIOCM_DTR) 701da177e4SLinus Torvalds mdm_ctl0 &= ~MDM_CTL0_DTR1; 711da177e4SLinus Torvalds else 721da177e4SLinus Torvalds mdm_ctl0 |= MDM_CTL0_DTR1; 731da177e4SLinus Torvalds } 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds MDM_CTL_0 = mdm_ctl0; 761da177e4SLinus Torvalds } 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds static u_int neponset_get_mctrl(struct uart_port *port) 791da177e4SLinus Torvalds { 801da177e4SLinus Torvalds u_int ret = TIOCM_CD | TIOCM_CTS | TIOCM_DSR; 811da177e4SLinus Torvalds u_int mdm_ctl1 = MDM_CTL_1; 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds if (port->mapbase == _Ser1UTCR0) { 841da177e4SLinus Torvalds if (mdm_ctl1 & MDM_CTL1_DCD2) 851da177e4SLinus Torvalds ret &= ~TIOCM_CD; 861da177e4SLinus Torvalds if (mdm_ctl1 & MDM_CTL1_CTS2) 871da177e4SLinus Torvalds ret &= ~TIOCM_CTS; 881da177e4SLinus Torvalds if (mdm_ctl1 & MDM_CTL1_DSR2) 891da177e4SLinus Torvalds ret &= ~TIOCM_DSR; 901da177e4SLinus Torvalds } else if (port->mapbase == _Ser3UTCR0) { 911da177e4SLinus Torvalds if (mdm_ctl1 & MDM_CTL1_DCD1) 921da177e4SLinus Torvalds ret &= ~TIOCM_CD; 931da177e4SLinus Torvalds if (mdm_ctl1 & MDM_CTL1_CTS1) 941da177e4SLinus Torvalds ret &= ~TIOCM_CTS; 951da177e4SLinus Torvalds if (mdm_ctl1 & MDM_CTL1_DSR1) 961da177e4SLinus Torvalds ret &= ~TIOCM_DSR; 971da177e4SLinus Torvalds } 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds return ret; 1001da177e4SLinus Torvalds } 1011da177e4SLinus Torvalds 102cdea4606SRussell King static struct sa1100_port_fns neponset_port_fns __devinitdata = { 1031da177e4SLinus Torvalds .set_mctrl = neponset_set_mctrl, 1041da177e4SLinus Torvalds .get_mctrl = neponset_get_mctrl, 1051da177e4SLinus Torvalds }; 1061da177e4SLinus Torvalds 10771045520SRussell King /* 10892e617d9SRussell King * Install handler for Neponset IRQ. Note that we have to loop here 10992e617d9SRussell King * since the ETHERNET and USAR IRQs are level based, and we need to 11092e617d9SRussell King * ensure that the IRQ signal is deasserted before returning. This 11192e617d9SRussell King * is rather unfortunate. 11292e617d9SRussell King */ 113ced8d21cSRussell King static void neponset_irq_handler(unsigned int irq, struct irq_desc *desc) 11492e617d9SRussell King { 115ced8d21cSRussell King struct neponset_drvdata *d = irq_desc_get_handler_data(desc); 11692e617d9SRussell King unsigned int irr; 11792e617d9SRussell King 11892e617d9SRussell King while (1) { 11992e617d9SRussell King /* 12092e617d9SRussell King * Acknowledge the parent IRQ. 12192e617d9SRussell King */ 12292e617d9SRussell King desc->irq_data.chip->irq_ack(&desc->irq_data); 12392e617d9SRussell King 12492e617d9SRussell King /* 12592e617d9SRussell King * Read the interrupt reason register. Let's have all 12692e617d9SRussell King * active IRQ bits high. Note: there is a typo in the 12792e617d9SRussell King * Neponset user's guide for the SA1111 IRR level. 12892e617d9SRussell King */ 12992e617d9SRussell King irr = IRR ^ (IRR_ETHERNET | IRR_USAR); 13092e617d9SRussell King 13192e617d9SRussell King if ((irr & (IRR_ETHERNET | IRR_USAR | IRR_SA1111)) == 0) 13292e617d9SRussell King break; 13392e617d9SRussell King 13492e617d9SRussell King /* 13592e617d9SRussell King * Since there is no individual mask, we have to 13692e617d9SRussell King * mask the parent IRQ. This is safe, since we'll 13792e617d9SRussell King * recheck the register for any pending IRQs. 13892e617d9SRussell King */ 13992e617d9SRussell King if (irr & (IRR_ETHERNET | IRR_USAR)) { 14092e617d9SRussell King desc->irq_data.chip->irq_mask(&desc->irq_data); 14192e617d9SRussell King 14292e617d9SRussell King /* 14392e617d9SRussell King * Ack the interrupt now to prevent re-entering 14492e617d9SRussell King * this neponset handler. Again, this is safe 14592e617d9SRussell King * since we'll check the IRR register prior to 14692e617d9SRussell King * leaving. 14792e617d9SRussell King */ 14892e617d9SRussell King desc->irq_data.chip->irq_ack(&desc->irq_data); 14992e617d9SRussell King 150ced8d21cSRussell King if (irr & IRR_ETHERNET) 151ced8d21cSRussell King generic_handle_irq(d->irq_base + NEP_IRQ_SMC91X); 15292e617d9SRussell King 153ced8d21cSRussell King if (irr & IRR_USAR) 154ced8d21cSRussell King generic_handle_irq(d->irq_base + NEP_IRQ_USAR); 15592e617d9SRussell King 15692e617d9SRussell King desc->irq_data.chip->irq_unmask(&desc->irq_data); 15792e617d9SRussell King } 15892e617d9SRussell King 159ced8d21cSRussell King if (irr & IRR_SA1111) 160ced8d21cSRussell King generic_handle_irq(d->irq_base + NEP_IRQ_SA1111); 16192e617d9SRussell King } 16292e617d9SRussell King } 16392e617d9SRussell King 164ced8d21cSRussell King /* Yes, we really do not have any kind of masking or unmasking */ 16571045520SRussell King static void nochip_noop(struct irq_data *irq) 16671045520SRussell King { 16771045520SRussell King } 16871045520SRussell King 16971045520SRussell King static struct irq_chip nochip = { 17071045520SRussell King .name = "neponset", 17171045520SRussell King .irq_ack = nochip_noop, 17271045520SRussell King .irq_mask = nochip_noop, 17371045520SRussell King .irq_unmask = nochip_noop, 17471045520SRussell King }; 17571045520SRussell King 17692e617d9SRussell King static struct sa1111_platform_data sa1111_info = { 17792e617d9SRussell King .irq_base = IRQ_BOARD_END, 17892e617d9SRussell King }; 17992e617d9SRussell King 180cdea4606SRussell King static int __devinit neponset_probe(struct platform_device *dev) 1811da177e4SLinus Torvalds { 182ae14c2e2SRussell King struct neponset_drvdata *d; 183d2e539a5SRussell King struct resource *sa1111_res, *smc91x_res; 184ced8d21cSRussell King struct resource sa1111_resources[] = { 185ced8d21cSRussell King DEFINE_RES_MEM(0x40000000, SZ_8K), 186ced8d21cSRussell King { .flags = IORESOURCE_IRQ }, 187ced8d21cSRussell King }; 1889590e898SRussell King struct platform_device_info sa1111_devinfo = { 1899590e898SRussell King .parent = &dev->dev, 1909590e898SRussell King .name = "sa1111", 1919590e898SRussell King .id = 0, 1929590e898SRussell King .res = sa1111_resources, 1939590e898SRussell King .num_res = ARRAY_SIZE(sa1111_resources), 1949590e898SRussell King .data = &sa1111_info, 1959590e898SRussell King .size_data = sizeof(sa1111_info), 1969590e898SRussell King .dma_mask = 0xffffffffUL, 1979590e898SRussell King }; 198ced8d21cSRussell King struct resource smc91x_resources[] = { 199ced8d21cSRussell King DEFINE_RES_MEM_NAMED(SA1100_CS3_PHYS, 200ced8d21cSRussell King 0x02000000, "smc91x-regs"), 201ced8d21cSRussell King DEFINE_RES_MEM_NAMED(SA1100_CS3_PHYS + 0x02000000, 202ced8d21cSRussell King 0x02000000, "smc91x-attrib"), 203ced8d21cSRussell King { .flags = IORESOURCE_IRQ }, 204ced8d21cSRussell King }; 2059590e898SRussell King struct platform_device_info smc91x_devinfo = { 2069590e898SRussell King .parent = &dev->dev, 2079590e898SRussell King .name = "smc91x", 2089590e898SRussell King .id = 0, 2099590e898SRussell King .res = smc91x_resources, 2109590e898SRussell King .num_res = ARRAY_SIZE(smc91x_resources), 2119590e898SRussell King }; 212b6bdfcf5SRussell King int ret, irq; 213b6bdfcf5SRussell King 214b6bdfcf5SRussell King irq = ret = platform_get_irq(dev, 0); 215b6bdfcf5SRussell King if (ret < 0) 216b6bdfcf5SRussell King goto err_alloc; 217ae14c2e2SRussell King 218d2e539a5SRussell King smc91x_res = platform_get_resource(dev, IORESOURCE_MEM, 1); 219d2e539a5SRussell King sa1111_res = platform_get_resource(dev, IORESOURCE_MEM, 2); 220d2e539a5SRussell King if (!smc91x_res || !sa1111_res) { 221d2e539a5SRussell King ret = -ENXIO; 222d2e539a5SRussell King goto err_alloc; 223d2e539a5SRussell King } 224d2e539a5SRussell King 225ae14c2e2SRussell King d = kzalloc(sizeof(*d), GFP_KERNEL); 226ae14c2e2SRussell King if (!d) { 227ae14c2e2SRussell King ret = -ENOMEM; 228ae14c2e2SRussell King goto err_alloc; 229ae14c2e2SRussell King } 230ae14c2e2SRussell King 231ced8d21cSRussell King ret = irq_alloc_descs(-1, IRQ_BOARD_START, NEP_IRQ_NR, -1); 232ced8d21cSRussell King if (ret <= 0) { 233ced8d21cSRussell King dev_err(&dev->dev, "unable to allocate %u irqs: %d\n", 234ced8d21cSRussell King NEP_IRQ_NR, ret); 235ced8d21cSRussell King if (ret == 0) 236ced8d21cSRussell King ret = -ENOMEM; 237ced8d21cSRussell King goto err_irq_alloc; 238ced8d21cSRussell King } 2391da177e4SLinus Torvalds 240ced8d21cSRussell King d->irq_base = ret; 241ced8d21cSRussell King 242ced8d21cSRussell King irq_set_chip_and_handler(d->irq_base + NEP_IRQ_SMC91X, &nochip, 243ced8d21cSRussell King handle_simple_irq); 244ced8d21cSRussell King set_irq_flags(d->irq_base + NEP_IRQ_SMC91X, IRQF_VALID | IRQF_PROBE); 245ced8d21cSRussell King irq_set_chip_and_handler(d->irq_base + NEP_IRQ_USAR, &nochip, 246ced8d21cSRussell King handle_simple_irq); 247ced8d21cSRussell King set_irq_flags(d->irq_base + NEP_IRQ_USAR, IRQF_VALID | IRQF_PROBE); 248ced8d21cSRussell King irq_set_chip(d->irq_base + NEP_IRQ_SA1111, &nochip); 249ced8d21cSRussell King 250b6bdfcf5SRussell King irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING); 251b6bdfcf5SRussell King irq_set_handler_data(irq, d); 252b6bdfcf5SRussell King irq_set_chained_handler(irq, neponset_irq_handler); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds /* 255ced8d21cSRussell King * We would set IRQ_GPIO25 to be a wake-up IRQ, but unfortunately 256ced8d21cSRussell King * something on the Neponset activates this IRQ on sleep (eth?) 2571da177e4SLinus Torvalds */ 2581da177e4SLinus Torvalds #if 0 259b6bdfcf5SRussell King enable_irq_wake(irq); 2601da177e4SLinus Torvalds #endif 2611da177e4SLinus Torvalds 262ced8d21cSRussell King dev_info(&dev->dev, "Neponset daughter board, providing IRQ%u-%u\n", 263ced8d21cSRussell King d->irq_base, d->irq_base + NEP_IRQ_NR - 1); 2641da177e4SLinus Torvalds 265ced8d21cSRussell King sa1100_register_uart_fns(&neponset_port_fns); 266ced8d21cSRussell King 267ced8d21cSRussell King /* Disable GPIO 0/1 drivers so the buttons work on the Assabet */ 2681da177e4SLinus Torvalds NCR_0 = NCR_GP01_OFF; 2691da177e4SLinus Torvalds 270d2e539a5SRussell King sa1111_resources[0].parent = sa1111_res; 271ced8d21cSRussell King sa1111_resources[1].start = d->irq_base + NEP_IRQ_SA1111; 272ced8d21cSRussell King sa1111_resources[1].end = d->irq_base + NEP_IRQ_SA1111; 2739590e898SRussell King d->sa1111 = platform_device_register_full(&sa1111_devinfo); 274ced8d21cSRussell King 275d2e539a5SRussell King smc91x_resources[0].parent = smc91x_res; 276d2e539a5SRussell King smc91x_resources[1].parent = smc91x_res; 277ced8d21cSRussell King smc91x_resources[2].start = d->irq_base + NEP_IRQ_SMC91X; 278ced8d21cSRussell King smc91x_resources[2].end = d->irq_base + NEP_IRQ_SMC91X; 2799590e898SRussell King d->smc91x = platform_device_register_full(&smc91x_devinfo); 2809590e898SRussell King 281ae14c2e2SRussell King platform_set_drvdata(dev, d); 282ae14c2e2SRussell King 283ae14c2e2SRussell King return 0; 284ae14c2e2SRussell King 285ced8d21cSRussell King err_irq_alloc: 286ced8d21cSRussell King kfree(d); 287ae14c2e2SRussell King err_alloc: 288ae14c2e2SRussell King return ret; 289ae14c2e2SRussell King } 290ae14c2e2SRussell King 291ae14c2e2SRussell King static int __devexit neponset_remove(struct platform_device *dev) 292ae14c2e2SRussell King { 293ae14c2e2SRussell King struct neponset_drvdata *d = platform_get_drvdata(dev); 294b6bdfcf5SRussell King int irq = platform_get_irq(dev, 0); 295ae14c2e2SRussell King 2969590e898SRussell King if (!IS_ERR(d->sa1111)) 2979590e898SRussell King platform_device_unregister(d->sa1111); 2989590e898SRussell King if (!IS_ERR(d->smc91x)) 2999590e898SRussell King platform_device_unregister(d->smc91x); 300b6bdfcf5SRussell King irq_set_chained_handler(irq, NULL); 301ced8d21cSRussell King irq_free_descs(d->irq_base, NEP_IRQ_NR); 302ae14c2e2SRussell King kfree(d); 303ae14c2e2SRussell King 3041da177e4SLinus Torvalds return 0; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 30751f93390SRussell King #ifdef CONFIG_PM_SLEEP 30851f93390SRussell King static int neponset_suspend(struct device *dev) 3091da177e4SLinus Torvalds { 31051f93390SRussell King struct neponset_drvdata *d = dev_get_drvdata(dev); 311ae14c2e2SRussell King 312ae14c2e2SRussell King d->ncr0 = NCR_0; 313ae14c2e2SRussell King d->mdm_ctl_0 = MDM_CTL_0; 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds return 0; 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds 31851f93390SRussell King static int neponset_resume(struct device *dev) 3191da177e4SLinus Torvalds { 32051f93390SRussell King struct neponset_drvdata *d = dev_get_drvdata(dev); 321ae14c2e2SRussell King 322ae14c2e2SRussell King NCR_0 = d->ncr0; 323ae14c2e2SRussell King MDM_CTL_0 = d->mdm_ctl_0; 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds return 0; 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds 32851f93390SRussell King static const struct dev_pm_ops neponset_pm_ops = { 32951f93390SRussell King .suspend_noirq = neponset_suspend, 33051f93390SRussell King .resume_noirq = neponset_resume, 33151f93390SRussell King .freeze_noirq = neponset_suspend, 33251f93390SRussell King .restore_noirq = neponset_resume, 33351f93390SRussell King }; 33451f93390SRussell King #define PM_OPS &neponset_pm_ops 3351da177e4SLinus Torvalds #else 33651f93390SRussell King #define PM_OPS NULL 3371da177e4SLinus Torvalds #endif 3381da177e4SLinus Torvalds 3393ae5eaecSRussell King static struct platform_driver neponset_device_driver = { 3401da177e4SLinus Torvalds .probe = neponset_probe, 341ae14c2e2SRussell King .remove = __devexit_p(neponset_remove), 3423ae5eaecSRussell King .driver = { 3433ae5eaecSRussell King .name = "neponset", 344398e58d0SRussell King .owner = THIS_MODULE, 34551f93390SRussell King .pm = PM_OPS, 3463ae5eaecSRussell King }, 3471da177e4SLinus Torvalds }; 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds static struct resource neponset_resources[] = { 350b6bdfcf5SRussell King DEFINE_RES_MEM(0x10000000, 0x08000000), 351d2e539a5SRussell King DEFINE_RES_MEM(0x18000000, 0x04000000), 352d2e539a5SRussell King DEFINE_RES_MEM(0x40000000, SZ_8K), 353b6bdfcf5SRussell King DEFINE_RES_IRQ(IRQ_GPIO25), 3541da177e4SLinus Torvalds }; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds static struct platform_device neponset_device = { 3571da177e4SLinus Torvalds .name = "neponset", 3581da177e4SLinus Torvalds .id = 0, 3591da177e4SLinus Torvalds .num_resources = ARRAY_SIZE(neponset_resources), 3601da177e4SLinus Torvalds .resource = neponset_resources, 3611da177e4SLinus Torvalds }; 3621da177e4SLinus Torvalds 363cdcb81f7SRussell King extern void sa1110_mb_disable(void); 364cdcb81f7SRussell King 3651da177e4SLinus Torvalds static int __init neponset_init(void) 3661da177e4SLinus Torvalds { 3673ae5eaecSRussell King platform_driver_register(&neponset_device_driver); 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds /* 3701da177e4SLinus Torvalds * The Neponset is only present on the Assabet machine type. 3711da177e4SLinus Torvalds */ 3721da177e4SLinus Torvalds if (!machine_is_assabet()) 3731da177e4SLinus Torvalds return -ENODEV; 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds /* 3761da177e4SLinus Torvalds * Ensure that the memory bus request/grant signals are setup, 3771da177e4SLinus Torvalds * and the grant is held in its inactive state, whether or not 3781da177e4SLinus Torvalds * we actually have a Neponset attached. 3791da177e4SLinus Torvalds */ 3801da177e4SLinus Torvalds sa1110_mb_disable(); 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds if (!machine_has_neponset()) { 3831da177e4SLinus Torvalds printk(KERN_DEBUG "Neponset expansion board not present\n"); 3841da177e4SLinus Torvalds return -ENODEV; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds if (WHOAMI != 0x11) { 3881da177e4SLinus Torvalds printk(KERN_WARNING "Neponset board detected, but " 3891da177e4SLinus Torvalds "wrong ID: %02x\n", WHOAMI); 3901da177e4SLinus Torvalds return -ENODEV; 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds 3939590e898SRussell King return platform_device_register(&neponset_device); 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds subsys_initcall(neponset_init); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds static struct map_desc neponset_io_desc[] __initdata = { 39992519d82SDeepak Saxena { /* System Registers */ 40092519d82SDeepak Saxena .virtual = 0xf3000000, 40192519d82SDeepak Saxena .pfn = __phys_to_pfn(0x10000000), 40292519d82SDeepak Saxena .length = SZ_1M, 40392519d82SDeepak Saxena .type = MT_DEVICE 40492519d82SDeepak Saxena }, { /* SA-1111 */ 40592519d82SDeepak Saxena .virtual = 0xf4000000, 40692519d82SDeepak Saxena .pfn = __phys_to_pfn(0x40000000), 40792519d82SDeepak Saxena .length = SZ_1M, 40892519d82SDeepak Saxena .type = MT_DEVICE 40992519d82SDeepak Saxena } 4101da177e4SLinus Torvalds }; 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds void __init neponset_map_io(void) 4131da177e4SLinus Torvalds { 4141da177e4SLinus Torvalds iotable_init(neponset_io_desc, ARRAY_SIZE(neponset_io_desc)); 4151da177e4SLinus Torvalds } 416