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