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