1 /* 2 * linux/arch/arm/mach-sa1100/neponset.c 3 * 4 */ 5 #include <linux/kernel.h> 6 #include <linux/init.h> 7 #include <linux/tty.h> 8 #include <linux/ioport.h> 9 #include <linux/serial_core.h> 10 #include <linux/platform_device.h> 11 #include <linux/slab.h> 12 13 #include <asm/hardware.h> 14 #include <asm/mach-types.h> 15 #include <asm/irq.h> 16 #include <asm/mach/map.h> 17 #include <asm/mach/irq.h> 18 #include <asm/mach/serial_sa1100.h> 19 #include <asm/arch/assabet.h> 20 #include <asm/arch/neponset.h> 21 #include <asm/hardware/sa1111.h> 22 #include <asm/sizes.h> 23 24 /* 25 * Install handler for Neponset IRQ. Note that we have to loop here 26 * since the ETHERNET and USAR IRQs are level based, and we need to 27 * ensure that the IRQ signal is deasserted before returning. This 28 * is rather unfortunate. 29 */ 30 static void 31 neponset_irq_handler(unsigned int irq, struct irq_desc *desc) 32 { 33 unsigned int irr; 34 35 while (1) { 36 struct irq_desc *d; 37 38 /* 39 * Acknowledge the parent IRQ. 40 */ 41 desc->chip->ack(irq); 42 43 /* 44 * Read the interrupt reason register. Let's have all 45 * active IRQ bits high. Note: there is a typo in the 46 * Neponset user's guide for the SA1111 IRR level. 47 */ 48 irr = IRR ^ (IRR_ETHERNET | IRR_USAR); 49 50 if ((irr & (IRR_ETHERNET | IRR_USAR | IRR_SA1111)) == 0) 51 break; 52 53 /* 54 * Since there is no individual mask, we have to 55 * mask the parent IRQ. This is safe, since we'll 56 * recheck the register for any pending IRQs. 57 */ 58 if (irr & (IRR_ETHERNET | IRR_USAR)) { 59 desc->chip->mask(irq); 60 61 /* 62 * Ack the interrupt now to prevent re-entering 63 * this neponset handler. Again, this is safe 64 * since we'll check the IRR register prior to 65 * leaving. 66 */ 67 desc->chip->ack(irq); 68 69 if (irr & IRR_ETHERNET) { 70 d = irq_desc + IRQ_NEPONSET_SMC9196; 71 desc_handle_irq(IRQ_NEPONSET_SMC9196, d); 72 } 73 74 if (irr & IRR_USAR) { 75 d = irq_desc + IRQ_NEPONSET_USAR; 76 desc_handle_irq(IRQ_NEPONSET_USAR, d); 77 } 78 79 desc->chip->unmask(irq); 80 } 81 82 if (irr & IRR_SA1111) { 83 d = irq_desc + IRQ_NEPONSET_SA1111; 84 desc_handle_irq(IRQ_NEPONSET_SA1111, d); 85 } 86 } 87 } 88 89 static void neponset_set_mctrl(struct uart_port *port, u_int mctrl) 90 { 91 u_int mdm_ctl0 = MDM_CTL_0; 92 93 if (port->mapbase == _Ser1UTCR0) { 94 if (mctrl & TIOCM_RTS) 95 mdm_ctl0 &= ~MDM_CTL0_RTS2; 96 else 97 mdm_ctl0 |= MDM_CTL0_RTS2; 98 99 if (mctrl & TIOCM_DTR) 100 mdm_ctl0 &= ~MDM_CTL0_DTR2; 101 else 102 mdm_ctl0 |= MDM_CTL0_DTR2; 103 } else if (port->mapbase == _Ser3UTCR0) { 104 if (mctrl & TIOCM_RTS) 105 mdm_ctl0 &= ~MDM_CTL0_RTS1; 106 else 107 mdm_ctl0 |= MDM_CTL0_RTS1; 108 109 if (mctrl & TIOCM_DTR) 110 mdm_ctl0 &= ~MDM_CTL0_DTR1; 111 else 112 mdm_ctl0 |= MDM_CTL0_DTR1; 113 } 114 115 MDM_CTL_0 = mdm_ctl0; 116 } 117 118 static u_int neponset_get_mctrl(struct uart_port *port) 119 { 120 u_int ret = TIOCM_CD | TIOCM_CTS | TIOCM_DSR; 121 u_int mdm_ctl1 = MDM_CTL_1; 122 123 if (port->mapbase == _Ser1UTCR0) { 124 if (mdm_ctl1 & MDM_CTL1_DCD2) 125 ret &= ~TIOCM_CD; 126 if (mdm_ctl1 & MDM_CTL1_CTS2) 127 ret &= ~TIOCM_CTS; 128 if (mdm_ctl1 & MDM_CTL1_DSR2) 129 ret &= ~TIOCM_DSR; 130 } else if (port->mapbase == _Ser3UTCR0) { 131 if (mdm_ctl1 & MDM_CTL1_DCD1) 132 ret &= ~TIOCM_CD; 133 if (mdm_ctl1 & MDM_CTL1_CTS1) 134 ret &= ~TIOCM_CTS; 135 if (mdm_ctl1 & MDM_CTL1_DSR1) 136 ret &= ~TIOCM_DSR; 137 } 138 139 return ret; 140 } 141 142 static struct sa1100_port_fns neponset_port_fns __devinitdata = { 143 .set_mctrl = neponset_set_mctrl, 144 .get_mctrl = neponset_get_mctrl, 145 }; 146 147 static int __devinit neponset_probe(struct platform_device *dev) 148 { 149 sa1100_register_uart_fns(&neponset_port_fns); 150 151 /* 152 * Install handler for GPIO25. 153 */ 154 set_irq_type(IRQ_GPIO25, IRQT_RISING); 155 set_irq_chained_handler(IRQ_GPIO25, neponset_irq_handler); 156 157 /* 158 * We would set IRQ_GPIO25 to be a wake-up IRQ, but 159 * unfortunately something on the Neponset activates 160 * this IRQ on sleep (ethernet?) 161 */ 162 #if 0 163 enable_irq_wake(IRQ_GPIO25); 164 #endif 165 166 /* 167 * Setup other Neponset IRQs. SA1111 will be done by the 168 * generic SA1111 code. 169 */ 170 set_irq_handler(IRQ_NEPONSET_SMC9196, handle_simple_irq); 171 set_irq_flags(IRQ_NEPONSET_SMC9196, IRQF_VALID | IRQF_PROBE); 172 set_irq_handler(IRQ_NEPONSET_USAR, handle_simple_irq); 173 set_irq_flags(IRQ_NEPONSET_USAR, IRQF_VALID | IRQF_PROBE); 174 175 /* 176 * Disable GPIO 0/1 drivers so the buttons work on the module. 177 */ 178 NCR_0 = NCR_GP01_OFF; 179 180 return 0; 181 } 182 183 #ifdef CONFIG_PM 184 185 /* 186 * LDM power management. 187 */ 188 static int neponset_suspend(struct platform_device *dev, pm_message_t state) 189 { 190 /* 191 * Save state. 192 */ 193 if (!dev->dev.power.saved_state) 194 dev->dev.power.saved_state = kmalloc(sizeof(unsigned int), GFP_KERNEL); 195 if (!dev->dev.power.saved_state) 196 return -ENOMEM; 197 198 *(unsigned int *)dev->dev.power.saved_state = NCR_0; 199 200 return 0; 201 } 202 203 static int neponset_resume(struct platform_device *dev) 204 { 205 if (dev->dev.power.saved_state) { 206 NCR_0 = *(unsigned int *)dev->dev.power.saved_state; 207 kfree(dev->dev.power.saved_state); 208 dev->dev.power.saved_state = NULL; 209 } 210 211 return 0; 212 } 213 214 #else 215 #define neponset_suspend NULL 216 #define neponset_resume NULL 217 #endif 218 219 static struct platform_driver neponset_device_driver = { 220 .probe = neponset_probe, 221 .suspend = neponset_suspend, 222 .resume = neponset_resume, 223 .driver = { 224 .name = "neponset", 225 }, 226 }; 227 228 static struct resource neponset_resources[] = { 229 [0] = { 230 .start = 0x10000000, 231 .end = 0x17ffffff, 232 .flags = IORESOURCE_MEM, 233 }, 234 }; 235 236 static struct platform_device neponset_device = { 237 .name = "neponset", 238 .id = 0, 239 .num_resources = ARRAY_SIZE(neponset_resources), 240 .resource = neponset_resources, 241 }; 242 243 static struct resource sa1111_resources[] = { 244 [0] = { 245 .start = 0x40000000, 246 .end = 0x40001fff, 247 .flags = IORESOURCE_MEM, 248 }, 249 [1] = { 250 .start = IRQ_NEPONSET_SA1111, 251 .end = IRQ_NEPONSET_SA1111, 252 .flags = IORESOURCE_IRQ, 253 }, 254 }; 255 256 static u64 sa1111_dmamask = 0xffffffffUL; 257 258 static struct platform_device sa1111_device = { 259 .name = "sa1111", 260 .id = 0, 261 .dev = { 262 .dma_mask = &sa1111_dmamask, 263 .coherent_dma_mask = 0xffffffff, 264 }, 265 .num_resources = ARRAY_SIZE(sa1111_resources), 266 .resource = sa1111_resources, 267 }; 268 269 static struct resource smc91x_resources[] = { 270 [0] = { 271 .name = "smc91x-regs", 272 .start = SA1100_CS3_PHYS, 273 .end = SA1100_CS3_PHYS + 0x01ffffff, 274 .flags = IORESOURCE_MEM, 275 }, 276 [1] = { 277 .start = IRQ_NEPONSET_SMC9196, 278 .end = IRQ_NEPONSET_SMC9196, 279 .flags = IORESOURCE_IRQ, 280 }, 281 [2] = { 282 .name = "smc91x-attrib", 283 .start = SA1100_CS3_PHYS + 0x02000000, 284 .end = SA1100_CS3_PHYS + 0x03ffffff, 285 .flags = IORESOURCE_MEM, 286 }, 287 }; 288 289 static struct platform_device smc91x_device = { 290 .name = "smc91x", 291 .id = 0, 292 .num_resources = ARRAY_SIZE(smc91x_resources), 293 .resource = smc91x_resources, 294 }; 295 296 static struct platform_device *devices[] __initdata = { 297 &neponset_device, 298 &sa1111_device, 299 &smc91x_device, 300 }; 301 302 static int __init neponset_init(void) 303 { 304 platform_driver_register(&neponset_device_driver); 305 306 /* 307 * The Neponset is only present on the Assabet machine type. 308 */ 309 if (!machine_is_assabet()) 310 return -ENODEV; 311 312 /* 313 * Ensure that the memory bus request/grant signals are setup, 314 * and the grant is held in its inactive state, whether or not 315 * we actually have a Neponset attached. 316 */ 317 sa1110_mb_disable(); 318 319 if (!machine_has_neponset()) { 320 printk(KERN_DEBUG "Neponset expansion board not present\n"); 321 return -ENODEV; 322 } 323 324 if (WHOAMI != 0x11) { 325 printk(KERN_WARNING "Neponset board detected, but " 326 "wrong ID: %02x\n", WHOAMI); 327 return -ENODEV; 328 } 329 330 return platform_add_devices(devices, ARRAY_SIZE(devices)); 331 } 332 333 subsys_initcall(neponset_init); 334 335 static struct map_desc neponset_io_desc[] __initdata = { 336 { /* System Registers */ 337 .virtual = 0xf3000000, 338 .pfn = __phys_to_pfn(0x10000000), 339 .length = SZ_1M, 340 .type = MT_DEVICE 341 }, { /* SA-1111 */ 342 .virtual = 0xf4000000, 343 .pfn = __phys_to_pfn(0x40000000), 344 .length = SZ_1M, 345 .type = MT_DEVICE 346 } 347 }; 348 349 void __init neponset_map_io(void) 350 { 351 iotable_init(neponset_io_desc, ARRAY_SIZE(neponset_io_desc)); 352 } 353