1/* 2 * PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards. 3 * 4 * Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com> 5 * 6 */ 7 8/* This is a fairly generic PCMCIA socket driver suitable for the 9 * following Alchemy Development boards: 10 * Db1000, Db/Pb1500, Db/Pb1100, Db/Pb1550, Db/Pb1200. 11 * 12 * The Db1000 is used as a reference: Per-socket card-, carddetect- and 13 * statuschange IRQs connected to SoC GPIOs, control and status register 14 * bits arranged in per-socket groups in an external PLD. All boards 15 * listed here use this layout, including bit positions and meanings. 16 * Of course there are exceptions in later boards: 17 * 18 * - Pb1100/Pb1500: single socket only; voltage key bits VS are 19 * at STATUS[5:4] (instead of STATUS[1:0]). 20 * - Au1200-based: additional card-eject irqs, irqs not gpios! 21 */ 22 23#include <linux/delay.h> 24#include <linux/gpio.h> 25#include <linux/interrupt.h> 26#include <linux/pm.h> 27#include <linux/platform_device.h> 28#include <linux/resource.h> 29#include <linux/slab.h> 30#include <linux/spinlock.h> 31 32#include <pcmcia/ss.h> 33 34#include <asm/mach-au1x00/au1000.h> 35#include <asm/mach-db1x00/bcsr.h> 36 37#define MEM_MAP_SIZE 0x400000 38#define IO_MAP_SIZE 0x1000 39 40struct db1x_pcmcia_sock { 41 struct pcmcia_socket socket; 42 int nr; /* socket number */ 43 void *virt_io; 44 45 phys_addr_t phys_io; 46 phys_addr_t phys_attr; 47 phys_addr_t phys_mem; 48 49 /* previous flags for set_socket() */ 50 unsigned int old_flags; 51 52 /* interrupt sources: linux irq numbers! */ 53 int insert_irq; /* default carddetect irq */ 54 int stschg_irq; /* card-status-change irq */ 55 int card_irq; /* card irq */ 56 int eject_irq; /* db1200/pb1200 have these */ 57 58#define BOARD_TYPE_DEFAULT 0 /* most boards */ 59#define BOARD_TYPE_DB1200 1 /* IRQs aren't gpios */ 60#define BOARD_TYPE_PB1100 2 /* VS bits slightly different */ 61 int board_type; 62}; 63 64#define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket) 65 66/* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */ 67static int db1200_card_inserted(struct db1x_pcmcia_sock *sock) 68{ 69 unsigned short sigstat; 70 71 sigstat = bcsr_read(BCSR_SIGSTAT); 72 return sigstat & 1 << (8 + 2 * sock->nr); 73} 74 75/* carddetect gpio: low-active */ 76static int db1000_card_inserted(struct db1x_pcmcia_sock *sock) 77{ 78 return !gpio_get_value(irq_to_gpio(sock->insert_irq)); 79} 80 81static int db1x_card_inserted(struct db1x_pcmcia_sock *sock) 82{ 83 switch (sock->board_type) { 84 case BOARD_TYPE_DB1200: 85 return db1200_card_inserted(sock); 86 default: 87 return db1000_card_inserted(sock); 88 } 89} 90 91/* STSCHG tends to bounce heavily when cards are inserted/ejected. 92 * To avoid this, the interrupt is normally disabled and only enabled 93 * after reset to a card has been de-asserted. 94 */ 95static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en) 96{ 97 if (sock->stschg_irq != -1) { 98 if (en) 99 enable_irq(sock->stschg_irq); 100 else 101 disable_irq(sock->stschg_irq); 102 } 103} 104 105static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data) 106{ 107 struct db1x_pcmcia_sock *sock = data; 108 109 pcmcia_parse_events(&sock->socket, SS_DETECT); 110 111 return IRQ_HANDLED; 112} 113 114static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data) 115{ 116 struct db1x_pcmcia_sock *sock = data; 117 118 pcmcia_parse_events(&sock->socket, SS_STSCHG); 119 120 return IRQ_HANDLED; 121} 122 123static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data) 124{ 125 struct db1x_pcmcia_sock *sock = data; 126 127 /* Db/Pb1200 have separate per-socket insertion and ejection 128 * interrupts which stay asserted as long as the card is 129 * inserted/missing. The one which caused us to be called 130 * needs to be disabled and the other one enabled. 131 */ 132 if (irq == sock->insert_irq) { 133 disable_irq_nosync(sock->insert_irq); 134 enable_irq(sock->eject_irq); 135 } else { 136 disable_irq_nosync(sock->eject_irq); 137 enable_irq(sock->insert_irq); 138 } 139 140 pcmcia_parse_events(&sock->socket, SS_DETECT); 141 142 return IRQ_HANDLED; 143} 144 145static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock) 146{ 147 int ret; 148 149 if (sock->stschg_irq != -1) { 150 ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq, 151 0, "pcmcia_stschg", sock); 152 if (ret) 153 return ret; 154 } 155 156 /* Db/Pb1200 have separate per-socket insertion and ejection 157 * interrupts, which should show edge behaviour but don't. 158 * So interrupts are disabled until both insertion and 159 * ejection handler have been registered and the currently 160 * active one disabled. 161 */ 162 if (sock->board_type == BOARD_TYPE_DB1200) { 163 ret = request_irq(sock->insert_irq, db1200_pcmcia_cdirq, 164 IRQF_DISABLED, "pcmcia_insert", sock); 165 if (ret) 166 goto out1; 167 168 ret = request_irq(sock->eject_irq, db1200_pcmcia_cdirq, 169 IRQF_DISABLED, "pcmcia_eject", sock); 170 if (ret) { 171 free_irq(sock->insert_irq, sock); 172 goto out1; 173 } 174 175 /* enable the currently silent one */ 176 if (db1200_card_inserted(sock)) 177 enable_irq(sock->eject_irq); 178 else 179 enable_irq(sock->insert_irq); 180 } else { 181 /* all other (older) Db1x00 boards use a GPIO to show 182 * card detection status: use both-edge triggers. 183 */ 184 set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH); 185 ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq, 186 0, "pcmcia_carddetect", sock); 187 188 if (ret) 189 goto out1; 190 } 191 192 return 0; /* all done */ 193 194out1: 195 if (sock->stschg_irq != -1) 196 free_irq(sock->stschg_irq, sock); 197 198 return ret; 199} 200 201static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock) 202{ 203 if (sock->stschg_irq != -1) 204 free_irq(sock->stschg_irq, sock); 205 206 free_irq(sock->insert_irq, sock); 207 if (sock->eject_irq != -1) 208 free_irq(sock->eject_irq, sock); 209} 210 211/* 212 * configure a PCMCIA socket on the Db1x00 series of boards (and 213 * compatibles). 214 * 215 * 2 external registers are involved: 216 * pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id 217 * pcmcia_control(offset 0x10): 218 * bits[0:1] set vcc for card 219 * bits[2:3] set vpp for card 220 * bit 4: enable data buffers 221 * bit 7: reset# for card 222 * add 8 for second socket. 223 */ 224static int db1x_pcmcia_configure(struct pcmcia_socket *skt, 225 struct socket_state_t *state) 226{ 227 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt); 228 unsigned short cr_clr, cr_set; 229 unsigned int changed; 230 int v, p, ret; 231 232 /* card voltage setup */ 233 cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */ 234 cr_set = 0; 235 v = p = ret = 0; 236 237 switch (state->Vcc) { 238 case 50: 239 ++v; 240 case 33: 241 ++v; 242 case 0: 243 break; 244 default: 245 printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n", 246 sock->nr, state->Vcc); 247 } 248 249 switch (state->Vpp) { 250 case 12: 251 ++p; 252 case 33: 253 case 50: 254 ++p; 255 case 0: 256 break; 257 default: 258 printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n", 259 sock->nr, state->Vpp); 260 } 261 262 /* sanity check: Vpp must be 0, 12, or Vcc */ 263 if (((state->Vcc == 33) && (state->Vpp == 50)) || 264 ((state->Vcc == 50) && (state->Vpp == 33))) { 265 printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n", 266 sock->nr, state->Vcc, state->Vpp); 267 v = p = 0; 268 ret = -EINVAL; 269 } 270 271 /* create new voltage code */ 272 cr_set |= ((v << 2) | p) << (sock->nr * 8); 273 274 changed = state->flags ^ sock->old_flags; 275 276 if (changed & SS_RESET) { 277 if (state->flags & SS_RESET) { 278 set_stschg(sock, 0); 279 /* assert reset, disable io buffers */ 280 cr_clr |= (1 << (7 + (sock->nr * 8))); 281 cr_clr |= (1 << (4 + (sock->nr * 8))); 282 } else { 283 /* de-assert reset, enable io buffers */ 284 cr_set |= 1 << (7 + (sock->nr * 8)); 285 cr_set |= 1 << (4 + (sock->nr * 8)); 286 } 287 } 288 289 /* update PCMCIA configuration */ 290 bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set); 291 292 sock->old_flags = state->flags; 293 294 /* reset was taken away: give card time to initialize properly */ 295 if ((changed & SS_RESET) && !(state->flags & SS_RESET)) { 296 msleep(500); 297 set_stschg(sock, 1); 298 } 299 300 return ret; 301} 302 303/* VCC bits at [3:2]/[11:10] */ 304#define GET_VCC(cr, socknr) \ 305 ((((cr) >> 2) >> ((socknr) * 8)) & 3) 306 307/* VS bits at [0:1]/[3:2] */ 308#define GET_VS(sr, socknr) \ 309 (((sr) >> (2 * (socknr))) & 3) 310 311/* reset bits at [7]/[15] */ 312#define GET_RESET(cr, socknr) \ 313 ((cr) & (1 << (7 + (8 * (socknr))))) 314 315static int db1x_pcmcia_get_status(struct pcmcia_socket *skt, 316 unsigned int *value) 317{ 318 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt); 319 unsigned short cr, sr; 320 unsigned int status; 321 322 status = db1x_card_inserted(sock) ? SS_DETECT : 0; 323 324 cr = bcsr_read(BCSR_PCMCIA); 325 sr = bcsr_read(BCSR_STATUS); 326 327 /* PB1100/PB1500: voltage key bits are at [5:4] */ 328 if (sock->board_type == BOARD_TYPE_PB1100) 329 sr >>= 4; 330 331 /* determine card type */ 332 switch (GET_VS(sr, sock->nr)) { 333 case 0: 334 case 2: 335 status |= SS_3VCARD; /* 3V card */ 336 case 3: 337 break; /* 5V card: set nothing */ 338 default: 339 status |= SS_XVCARD; /* treated as unsupported in core */ 340 } 341 342 /* if Vcc is not zero, we have applied power to a card */ 343 status |= GET_VCC(cr, sock->nr) ? SS_POWERON : 0; 344 345 /* reset de-asserted? then we're ready */ 346 status |= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET; 347 348 *value = status; 349 350 return 0; 351} 352 353static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt) 354{ 355 return 0; 356} 357 358static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt) 359{ 360 return 0; 361} 362 363static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt, 364 struct pccard_io_map *map) 365{ 366 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt); 367 368 map->start = (u32)sock->virt_io; 369 map->stop = map->start + IO_MAP_SIZE; 370 371 return 0; 372} 373 374static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt, 375 struct pccard_mem_map *map) 376{ 377 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt); 378 379 if (map->flags & MAP_ATTRIB) 380 map->static_start = sock->phys_attr + map->card_start; 381 else 382 map->static_start = sock->phys_mem + map->card_start; 383 384 return 0; 385} 386 387static struct pccard_operations db1x_pcmcia_operations = { 388 .init = db1x_pcmcia_sock_init, 389 .suspend = db1x_pcmcia_sock_suspend, 390 .get_status = db1x_pcmcia_get_status, 391 .set_socket = db1x_pcmcia_configure, 392 .set_io_map = au1x00_pcmcia_set_io_map, 393 .set_mem_map = au1x00_pcmcia_set_mem_map, 394}; 395 396static int __devinit db1x_pcmcia_socket_probe(struct platform_device *pdev) 397{ 398 struct db1x_pcmcia_sock *sock; 399 struct resource *r; 400 int ret, bid; 401 402 sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL); 403 if (!sock) 404 return -ENOMEM; 405 406 sock->nr = pdev->id; 407 408 bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI)); 409 switch (bid) { 410 case BCSR_WHOAMI_PB1500: 411 case BCSR_WHOAMI_PB1500R2: 412 case BCSR_WHOAMI_PB1100: 413 sock->board_type = BOARD_TYPE_PB1100; 414 break; 415 case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR: 416 sock->board_type = BOARD_TYPE_DEFAULT; 417 break; 418 case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200: 419 sock->board_type = BOARD_TYPE_DB1200; 420 break; 421 default: 422 printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid); 423 ret = -ENODEV; 424 goto out0; 425 }; 426 427 /* 428 * gather resources necessary and optional nice-to-haves to 429 * operate a socket: 430 * This includes IRQs for Carddetection/ejection, the card 431 * itself and optional status change detection. 432 * Also, the memory areas covered by a socket. For these 433 * we require the real 36bit addresses (see the au1000.h 434 * header for more information). 435 */ 436 437 /* card: irq assigned to the card itself. */ 438 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card"); 439 sock->card_irq = r ? r->start : 0; 440 441 /* insert: irq which triggers on card insertion/ejection */ 442 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert"); 443 sock->insert_irq = r ? r->start : -1; 444 445 /* stschg: irq which trigger on card status change (optional) */ 446 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg"); 447 sock->stschg_irq = r ? r->start : -1; 448 449 /* eject: irq which triggers on ejection (DB1200/PB1200 only) */ 450 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject"); 451 sock->eject_irq = r ? r->start : -1; 452 453 ret = -ENODEV; 454 455 /* 36bit PCMCIA Attribute area address */ 456 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-attr"); 457 if (!r) { 458 printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n", 459 sock->nr); 460 goto out0; 461 } 462 sock->phys_attr = r->start; 463 464 /* 36bit PCMCIA Memory area address */ 465 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-mem"); 466 if (!r) { 467 printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n", 468 sock->nr); 469 goto out0; 470 } 471 sock->phys_mem = r->start; 472 473 /* 36bit PCMCIA IO area address */ 474 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-io"); 475 if (!r) { 476 printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n", 477 sock->nr); 478 goto out0; 479 } 480 sock->phys_io = r->start; 481 482 /* 483 * PCMCIA client drivers use the inb/outb macros to access 484 * the IO registers. Since mips_io_port_base is added 485 * to the access address of the mips implementation of 486 * inb/outb, we need to subtract it here because we want 487 * to access the I/O or MEM address directly, without 488 * going through this "mips_io_port_base" mechanism. 489 */ 490 sock->virt_io = (void *)(ioremap(sock->phys_io, IO_MAP_SIZE) - 491 mips_io_port_base); 492 493 if (!sock->virt_io) { 494 printk(KERN_ERR "pcmcia%d: cannot remap IO area\n", 495 sock->nr); 496 ret = -ENOMEM; 497 goto out0; 498 } 499 500 sock->socket.ops = &db1x_pcmcia_operations; 501 sock->socket.owner = THIS_MODULE; 502 sock->socket.pci_irq = sock->card_irq; 503 sock->socket.features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD; 504 sock->socket.map_size = MEM_MAP_SIZE; 505 sock->socket.io_offset = (unsigned long)sock->virt_io; 506 sock->socket.dev.parent = &pdev->dev; 507 sock->socket.resource_ops = &pccard_static_ops; 508 509 platform_set_drvdata(pdev, sock); 510 511 ret = db1x_pcmcia_setup_irqs(sock); 512 if (ret) { 513 printk(KERN_ERR "pcmcia%d cannot setup interrupts\n", 514 sock->nr); 515 goto out1; 516 } 517 518 set_stschg(sock, 0); 519 520 ret = pcmcia_register_socket(&sock->socket); 521 if (ret) { 522 printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr); 523 goto out2; 524 } 525 526 printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %09llx" 527 "(%p) %09llx %09llx card/insert/stschg/eject irqs @ %d " 528 "%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io, 529 sock->phys_attr, sock->phys_mem, sock->card_irq, 530 sock->insert_irq, sock->stschg_irq, sock->eject_irq); 531 532 return 0; 533 534out2: 535 db1x_pcmcia_free_irqs(sock); 536out1: 537 iounmap((void *)(sock->virt_io + (u32)mips_io_port_base)); 538out0: 539 kfree(sock); 540 return ret; 541} 542 543static int __devexit db1x_pcmcia_socket_remove(struct platform_device *pdev) 544{ 545 struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev); 546 547 db1x_pcmcia_free_irqs(sock); 548 pcmcia_unregister_socket(&sock->socket); 549 iounmap((void *)(sock->virt_io + (u32)mips_io_port_base)); 550 kfree(sock); 551 552 return 0; 553} 554 555static struct platform_driver db1x_pcmcia_socket_driver = { 556 .driver = { 557 .name = "db1xxx_pcmcia", 558 .owner = THIS_MODULE, 559 }, 560 .probe = db1x_pcmcia_socket_probe, 561 .remove = __devexit_p(db1x_pcmcia_socket_remove), 562}; 563 564int __init db1x_pcmcia_socket_load(void) 565{ 566 return platform_driver_register(&db1x_pcmcia_socket_driver); 567} 568 569void __exit db1x_pcmcia_socket_unload(void) 570{ 571 platform_driver_unregister(&db1x_pcmcia_socket_driver); 572} 573 574module_init(db1x_pcmcia_socket_load); 575module_exit(db1x_pcmcia_socket_unload); 576 577MODULE_LICENSE("GPL"); 578MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards"); 579MODULE_AUTHOR("Manuel Lauss"); 580