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