MIPS: PCMCIA: new socket driver for Au1000 demoboards.

New PCMCIA socket driver for all Db/Pb1xxx boards (except Pb1000),
which replaces au1000_db1x00.c and (most of) au1000_pb1x00.c.
Notable improvements:
        - supports Db1000, DB/PB1100/1500/1550/1200.
        - support for carddetect and statuschange IRQs.
        - pcmcia socket mem/io/attr areas and irqs passed through
          platform resource information.
        - doesn't freeze system during card insertion/ejection like
          the one it replaces.
        - boardtype is automatically detected using BCSR ID register.

Run-tested on the DB1200.

Cc: Linux-PCMCIA <linux-pcmcia@lists.infradead.org>
Signed-off-by: Manuel Lauss <manuel.lauss@gmail.com>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

1 files changed, 630 insertions, 0 deletions

diff --git a/drivers/pcmcia/db1xxx_ss.c b/drivers/pcmcia/db1xxx_ss.c
new file mode 100644
index 000000000000..b35b72b0d5b5
--- /dev/null
+++ b/drivers/pcmcia/db1xxx_ss.c
@@ -0,0 +1,630 @@
+/*
+ * PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards.
+ *
+ * Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com>
+ *
+ */
+
+/* This is a fairly generic PCMCIA socket driver suitable for the
+ * following Alchemy Development boards:
+ *  Db1000, Db/Pb1500, Db/Pb1100, Db/Pb1550, Db/Pb1200.
+ *
+ * The Db1000 is used as a reference:  Per-socket card-, carddetect- and
+ *  statuschange IRQs connected to SoC GPIOs, control and status register
+ *  bits arranged in per-socket groups in an external PLD.  All boards
+ *  listed here use this layout, including bit positions and meanings.
+ *  Of course there are exceptions in later boards:
+ *
+ *      - Pb1100/Pb1500:  single socket only; voltage key bits VS are
+ *                        at STATUS[5:4] (instead of STATUS[1:0]).
+ *      - Au1200-based:   additional card-eject irqs, irqs not gpios!
+ */
+
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/resource.h>
+#include <linux/spinlock.h>
+
+#include <pcmcia/cs_types.h>
+#include <pcmcia/ss.h>
+
+#include <asm/mach-au1x00/au1000.h>
+#include <asm/mach-db1x00/bcsr.h>
+
+#define MEM_MAP_SIZE    0x400000
+#define IO_MAP_SIZE     0x1000
+
+struct db1x_pcmcia_sock {
+        struct pcmcia_socket    socket;
+        int             nr;             /* socket number */
+        void            *virt_io;
+
+        /* the "pseudo" addresses of the PCMCIA space. */
+        unsigned long   phys_io;
+        unsigned long   phys_attr;
+        unsigned long   phys_mem;
+
+        /* previous flags for set_socket() */
+        unsigned int old_flags;
+
+        /* interrupt sources: linux irq numbers! */
+        int     insert_irq;     /* default carddetect irq */
+        int     stschg_irq;     /* card-status-change irq */
+        int     card_irq;       /* card irq */
+        int     eject_irq;      /* db1200/pb1200 have these */
+
+#define BOARD_TYPE_DEFAULT      0       /* most boards */
+#define BOARD_TYPE_DB1200       1       /* IRQs aren't gpios */
+#define BOARD_TYPE_PB1100       2       /* VS bits slightly different */
+        int     board_type;
+};
+
+#define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket)
+
+/* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */
+static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
+{
+        unsigned short sigstat;
+
+        sigstat = bcsr_read(BCSR_SIGSTAT);
+        return sigstat & 1 << (8 + 2 * sock->nr);
+}
+
+/* carddetect gpio: low-active */
+static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
+{
+        return !gpio_get_value(irq_to_gpio(sock->insert_irq));
+}
+
+static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
+{
+        switch (sock->board_type) {
+        case BOARD_TYPE_DB1200:
+                return db1200_card_inserted(sock);
+        default:
+                return db1000_card_inserted(sock);
+        }
+}
+
+/* STSCHG tends to bounce heavily when cards are inserted/ejected.
+ * To avoid this, the interrupt is normally disabled and only enabled
+ * after reset to a card has been de-asserted.
+ */
+static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en)
+{
+        if (sock->stschg_irq != -1) {
+                if (en)
+                        enable_irq(sock->stschg_irq);
+                else
+                        disable_irq(sock->stschg_irq);
+        }
+}
+
+static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data)
+{
+        struct db1x_pcmcia_sock *sock = data;
+
+        pcmcia_parse_events(&sock->socket, SS_DETECT);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data)
+{
+        struct db1x_pcmcia_sock *sock = data;
+
+        pcmcia_parse_events(&sock->socket, SS_STSCHG);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data)
+{
+        struct db1x_pcmcia_sock *sock = data;
+
+        /* Db/Pb1200 have separate per-socket insertion and ejection
+         * interrupts which stay asserted as long as the card is
+         * inserted/missing.  The one which caused us to be called
+         * needs to be disabled and the other one enabled.
+         */
+        if (irq == sock->insert_irq) {
+                disable_irq_nosync(sock->insert_irq);
+                enable_irq(sock->eject_irq);
+        } else {
+                disable_irq_nosync(sock->eject_irq);
+                enable_irq(sock->insert_irq);
+        }
+
+        pcmcia_parse_events(&sock->socket, SS_DETECT);
+
+        return IRQ_HANDLED;
+}
+
+static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
+{
+        int ret;
+        unsigned long flags;
+
+        if (sock->stschg_irq != -1) {
+                ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq,
+                                  0, "pcmcia_stschg", sock);
+                if (ret)
+                        return ret;
+        }
+
+        /* Db/Pb1200 have separate per-socket insertion and ejection
+         * interrupts, which should show edge behaviour but don't.
+         * So interrupts are disabled until both insertion and
+         * ejection handler have been registered and the currently
+         * active one disabled.
+         */
+        if (sock->board_type == BOARD_TYPE_DB1200) {
+                local_irq_save(flags);
+
+                ret = request_irq(sock->insert_irq, db1200_pcmcia_cdirq,
+                                  IRQF_DISABLED, "pcmcia_insert", sock);
+                if (ret)
+                        goto out1;
+
+                ret = request_irq(sock->eject_irq, db1200_pcmcia_cdirq,
+                                  IRQF_DISABLED, "pcmcia_eject", sock);
+                if (ret) {
+                        free_irq(sock->insert_irq, sock);
+                        local_irq_restore(flags);
+                        goto out1;
+                }
+
+                /* disable the currently active one */
+                if (db1200_card_inserted(sock))
+                        disable_irq_nosync(sock->insert_irq);
+                else
+                        disable_irq_nosync(sock->eject_irq);
+
+                local_irq_restore(flags);
+        } else {
+                /* all other (older) Db1x00 boards use a GPIO to show
+                 * card detection status:  use both-edge triggers.
+                 */
+                set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
+                ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
+                                  0, "pcmcia_carddetect", sock);
+
+                if (ret)
+                        goto out1;
+        }
+
+        return 0;       /* all done */
+
+out1:
+        if (sock->stschg_irq != -1)
+                free_irq(sock->stschg_irq, sock);
+
+        return ret;
+}
+
+static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock)
+{
+        if (sock->stschg_irq != -1)
+                free_irq(sock->stschg_irq, sock);
+
+        free_irq(sock->insert_irq, sock);
+        if (sock->eject_irq != -1)
+                free_irq(sock->eject_irq, sock);
+}
+
+/*
+ * configure a PCMCIA socket on the Db1x00 series of boards (and
+ * compatibles).
+ *
+ * 2 external registers are involved:
+ *   pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id
+ *   pcmcia_control(offset 0x10):
+ *      bits[0:1] set vcc for card
+ *      bits[2:3] set vpp for card
+ *      bit 4:  enable data buffers
+ *      bit 7:  reset# for card
+ *      add 8 for second socket.
+ */
+static int db1x_pcmcia_configure(struct pcmcia_socket *skt,
+                                 struct socket_state_t *state)
+{
+        struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
+        unsigned short cr_clr, cr_set;
+        unsigned int changed;
+        int v, p, ret;
+
+        /* card voltage setup */
+        cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */
+        cr_set = 0;
+        v = p = ret = 0;
+
+        switch (state->Vcc) {
+        case 50:
+                ++v;
+        case 33:
+                ++v;
+        case 0:
+                break;
+        default:
+                printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n",
+                        sock->nr, state->Vcc);
+        }
+
+        switch (state->Vpp) {
+        case 12:
+                ++p;
+        case 33:
+        case 50:
+                ++p;
+        case 0:
+                break;
+        default:
+                printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n",
+                        sock->nr, state->Vpp);
+        }
+
+        /* sanity check: Vpp must be 0, 12, or Vcc */
+        if (((state->Vcc == 33) && (state->Vpp == 50)) ||
+            ((state->Vcc == 50) && (state->Vpp == 33))) {
+                printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n",
+                        sock->nr, state->Vcc, state->Vpp);
+                v = p = 0;
+                ret = -EINVAL;
+        }
+
+        /* create new voltage code */
+        cr_set |= ((v << 2) | p) << (sock->nr * 8);
+
+        changed = state->flags ^ sock->old_flags;
+
+        if (changed & SS_RESET) {
+                if (state->flags & SS_RESET) {
+                        set_stschg(sock, 0);
+                        /* assert reset, disable io buffers */
+                        cr_clr |= (1 << (7 + (sock->nr * 8)));
+                        cr_clr |= (1 << (4 + (sock->nr * 8)));
+                } else {
+                        /* de-assert reset, enable io buffers */
+                        cr_set |= 1 << (7 + (sock->nr * 8));
+                        cr_set |= 1 << (4 + (sock->nr * 8));
+                }
+        }
+
+        /* update PCMCIA configuration */
+        bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set);
+
+        sock->old_flags = state->flags;
+
+        /* reset was taken away: give card time to initialize properly */
+        if ((changed & SS_RESET) && !(state->flags & SS_RESET)) {
+                msleep(500);
+                set_stschg(sock, 1);
+        }
+
+        return ret;
+}
+
+/* VCC bits at [3:2]/[11:10] */
+#define GET_VCC(cr, socknr)             \
+        ((((cr) >> 2) >> ((socknr) * 8)) & 3)
+
+/* VS bits at [0:1]/[3:2] */
+#define GET_VS(sr, socknr)              \
+        (((sr) >> (2 * (socknr))) & 3)
+
+/* reset bits at [7]/[15] */
+#define GET_RESET(cr, socknr)           \
+        ((cr) & (1 << (7 + (8 * (socknr)))))
+
+static int db1x_pcmcia_get_status(struct pcmcia_socket *skt,
+                                  unsigned int *value)
+{
+        struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
+        unsigned short cr, sr;
+        unsigned int status;
+
+        status = db1x_card_inserted(sock) ? SS_DETECT : 0;
+
+        cr = bcsr_read(BCSR_PCMCIA);
+        sr = bcsr_read(BCSR_STATUS);
+
+        /* PB1100/PB1500: voltage key bits are at [5:4] */
+        if (sock->board_type == BOARD_TYPE_PB1100)
+                sr >>= 4;
+
+        /* determine card type */
+        switch (GET_VS(sr, sock->nr)) {
+        case 0:
+        case 2:
+                status |= SS_3VCARD;    /* 3V card */
+        case 3:
+                break;                  /* 5V card: set nothing */
+        default:
+                status |= SS_XVCARD;    /* treated as unsupported in core */
+        }
+
+        /* if Vcc is not zero, we have applied power to a card */
+        status |= GET_VCC(cr, sock->nr) ? SS_POWERON : 0;
+
+        /* reset de-asserted? then we're ready */
+        status |= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET;
+
+        *value = status;
+
+        return 0;
+}
+
+static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt)
+{
+        return 0;
+}
+
+static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt)
+{
+        return 0;
+}
+
+static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt,
+                                    struct pccard_io_map *map)
+{
+        struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
+
+        map->start = (u32)sock->virt_io;
+        map->stop = map->start + IO_MAP_SIZE;
+
+        return 0;
+}
+
+static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt,
+                                     struct pccard_mem_map *map)
+{
+        struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
+
+        if (map->flags & MAP_ATTRIB)
+                map->static_start = sock->phys_attr + map->card_start;
+        else
+                map->static_start = sock->phys_mem + map->card_start;
+
+        return 0;
+}
+
+static struct pccard_operations db1x_pcmcia_operations = {
+        .init                   = db1x_pcmcia_sock_init,
+        .suspend                = db1x_pcmcia_sock_suspend,
+        .get_status             = db1x_pcmcia_get_status,
+        .set_socket             = db1x_pcmcia_configure,
+        .set_io_map             = au1x00_pcmcia_set_io_map,
+        .set_mem_map            = au1x00_pcmcia_set_mem_map,
+};
+
+static int __devinit db1x_pcmcia_socket_probe(struct platform_device *pdev)
+{
+        struct db1x_pcmcia_sock *sock;
+        struct resource *r;
+        phys_t physio;
+        int ret, bid;
+
+        sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL);
+        if (!sock)
+                return -ENOMEM;
+
+        sock->nr = pdev->id;
+
+        bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI));
+        switch (bid) {
+        case BCSR_WHOAMI_PB1500:
+        case BCSR_WHOAMI_PB1500R2:
+        case BCSR_WHOAMI_PB1100:
+                sock->board_type = BOARD_TYPE_PB1100;
+                break;
+        case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR:
+                sock->board_type = BOARD_TYPE_DEFAULT;
+                break;
+        case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200:
+                sock->board_type = BOARD_TYPE_DB1200;
+                break;
+        default:
+                printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid);
+                ret = -ENODEV;
+                goto out0;
+        };
+
+        /*
+         * gather resources necessary and optional nice-to-haves to
+         * operate a socket:
+         * This includes IRQs for Carddetection/ejection, the card
+         *  itself and optional status change detection.
+         * Also, the memory areas covered by a socket.  For these
+         *  we require the 32bit "pseudo" addresses (see the au1000.h
+         *  header for more information).
+         */
+
+        /* card: irq assigned to the card itself. */
+        r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
+        sock->card_irq = r ? r->start : 0;
+
+        /* insert: irq which triggers on card insertion/ejection */
+        r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
+        sock->insert_irq = r ? r->start : -1;
+
+        /* stschg: irq which trigger on card status change (optional) */
+        r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
+        sock->stschg_irq = r ? r->start : -1;
+
+        /* eject: irq which triggers on ejection (DB1200/PB1200 only) */
+        r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject");
+        sock->eject_irq = r ? r->start : -1;
+
+        ret = -ENODEV;
+
+        /*
+         * pseudo-attr:  The 32bit address of the PCMCIA attribute space
+         * for this socket (usually the 36bit address shifted 4 to the
+         * right).
+         */
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pseudo-attr");
+        if (!r) {
+                printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n",
+                        sock->nr);
+                goto out0;
+        }
+        sock->phys_attr = r->start;
+
+        /*
+         * pseudo-mem:  The 32bit address of the PCMCIA memory space for
+         * this socket (usually the 36bit address shifted 4 to the right)
+         */
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pseudo-mem");
+        if (!r) {
+                printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n",
+                        sock->nr);
+                goto out0;
+        }
+        sock->phys_mem = r->start;
+
+        /*
+         * pseudo-io:  The 32bit address of the PCMCIA IO space for this
+         * socket (usually the 36bit address shifted 4 to the right).
+         */
+        r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pseudo-io");
+        if (!r) {
+                printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n",
+                        sock->nr);
+                goto out0;
+        }
+        sock->phys_io = r->start;
+
+
+        /* IO: we must remap the full 36bit address (for reference see
+         * alchemy/common/setup.c::__fixup_bigphys_addr())
+         */
+        physio = ((phys_t)sock->phys_io) << 4;
+
+        /*
+         * PCMCIA client drivers use the inb/outb macros to access
+         * the IO registers.  Since mips_io_port_base is added
+         * to the access address of the mips implementation of
+         * inb/outb, we need to subtract it here because we want
+         * to access the I/O or MEM address directly, without
+         * going through this "mips_io_port_base" mechanism.
+         */
+        sock->virt_io = (void *)(ioremap(physio, IO_MAP_SIZE) -
+                                 mips_io_port_base);
+
+        if (!sock->virt_io) {
+                printk(KERN_ERR "pcmcia%d: cannot remap IO area\n",
+                        sock->nr);
+                ret = -ENOMEM;
+                goto out0;
+        }
+
+        sock->socket.ops        = &db1x_pcmcia_operations;
+        sock->socket.owner      = THIS_MODULE;
+        sock->socket.pci_irq    = sock->card_irq;
+        sock->socket.features   = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
+        sock->socket.map_size   = MEM_MAP_SIZE;
+        sock->socket.io_offset  = (unsigned long)sock->virt_io;
+        sock->socket.dev.parent = &pdev->dev;
+        sock->socket.resource_ops = &pccard_static_ops;
+
+        platform_set_drvdata(pdev, sock);
+
+        ret = db1x_pcmcia_setup_irqs(sock);
+        if (ret) {
+                printk(KERN_ERR "pcmcia%d cannot setup interrupts\n",
+                        sock->nr);
+                goto out1;
+        }
+
+        set_stschg(sock, 0);
+
+        ret = pcmcia_register_socket(&sock->socket);
+        if (ret) {
+                printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr);
+                goto out2;
+        }
+
+        printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %08lx"
+                "(%p) %08lx %08lx  card/insert/stschg/eject irqs @ %d "
+                "%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io,
+                sock->phys_attr, sock->phys_mem, sock->card_irq,
+                sock->insert_irq, sock->stschg_irq, sock->eject_irq);
+
+        return 0;
+
+out2:
+        db1x_pcmcia_free_irqs(sock);
+out1:
+        iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
+out0:
+        kfree(sock);
+        return ret;
+}
+
+static int __devexit db1x_pcmcia_socket_remove(struct platform_device *pdev)
+{
+        struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev);
+
+        db1x_pcmcia_free_irqs(sock);
+        pcmcia_unregister_socket(&sock->socket);
+        iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
+        kfree(sock);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int db1x_pcmcia_suspend(struct device *dev)
+{
+        return pcmcia_socket_dev_suspend(dev);
+}
+
+static int db1x_pcmcia_resume(struct device *dev)
+{
+        return pcmcia_socket_dev_resume(dev);
+}
+
+static struct dev_pm_ops db1x_pcmcia_pmops = {
+        .resume         = db1x_pcmcia_resume,
+        .suspend        = db1x_pcmcia_suspend,
+        .thaw           = db1x_pcmcia_resume,
+        .freeze         = db1x_pcmcia_suspend,
+};
+
+#define DB1XXX_SS_PMOPS &db1x_pcmcia_pmops
+
+#else
+
+#define DB1XXX_SS_PMOPS NULL
+
+#endif
+
+static struct platform_driver db1x_pcmcia_socket_driver = {
+        .driver = {
+                .name   = "db1xxx_pcmcia",
+                .owner  = THIS_MODULE,
+                .pm     = DB1XXX_SS_PMOPS
+        },
+        .probe          = db1x_pcmcia_socket_probe,
+        .remove         = __devexit_p(db1x_pcmcia_socket_remove),
+};
+
+int __init db1x_pcmcia_socket_load(void)
+{
+        return platform_driver_register(&db1x_pcmcia_socket_driver);
+}
+
+void  __exit db1x_pcmcia_socket_unload(void)
+{
+        platform_driver_unregister(&db1x_pcmcia_socket_driver);
+}
+
+module_init(db1x_pcmcia_socket_load);
+module_exit(db1x_pcmcia_socket_unload);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards");
+MODULE_AUTHOR("Manuel Lauss");