drivers/pcmcia/db1xxx_ss.c

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