linux/drivers/net/wireless/libertas/if_spi.c
<<
>>
Prefs
   1/*
   2 *      linux/drivers/net/wireless/libertas/if_spi.c
   3 *
   4 *      Driver for Marvell SPI WLAN cards.
   5 *
   6 *      Copyright 2008 Analog Devices Inc.
   7 *
   8 *      Authors:
   9 *      Andrey Yurovsky <andrey@cozybit.com>
  10 *      Colin McCabe <colin@cozybit.com>
  11 *
  12 *      Inspired by if_sdio.c, Copyright 2007-2008 Pierre Ossman
  13 *
  14 * This program is free software; you can redistribute it and/or modify
  15 * it under the terms of the GNU General Public License as published by
  16 * the Free Software Foundation; either version 2 of the License, or
  17 * (at your option) any later version.
  18 */
  19
  20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22#include <linux/hardirq.h>
  23#include <linux/interrupt.h>
  24#include <linux/module.h>
  25#include <linux/firmware.h>
  26#include <linux/jiffies.h>
  27#include <linux/list.h>
  28#include <linux/netdevice.h>
  29#include <linux/slab.h>
  30#include <linux/spi/libertas_spi.h>
  31#include <linux/spi/spi.h>
  32
  33#include "host.h"
  34#include "decl.h"
  35#include "defs.h"
  36#include "dev.h"
  37#include "if_spi.h"
  38
  39struct if_spi_packet {
  40        struct list_head                list;
  41        u16                             blen;
  42        u8                              buffer[0] __attribute__((aligned(4)));
  43};
  44
  45struct if_spi_card {
  46        struct spi_device               *spi;
  47        struct lbs_private              *priv;
  48        struct libertas_spi_platform_data *pdata;
  49
  50        /* The card ID and card revision, as reported by the hardware. */
  51        u16                             card_id;
  52        u8                              card_rev;
  53
  54        /* The last time that we initiated an SPU operation */
  55        unsigned long                   prev_xfer_time;
  56
  57        int                             use_dummy_writes;
  58        unsigned long                   spu_port_delay;
  59        unsigned long                   spu_reg_delay;
  60
  61        /* Handles all SPI communication (except for FW load) */
  62        struct workqueue_struct         *workqueue;
  63        struct work_struct              packet_work;
  64        struct work_struct              resume_work;
  65
  66        u8                              cmd_buffer[IF_SPI_CMD_BUF_SIZE];
  67
  68        /* A buffer of incoming packets from libertas core.
  69         * Since we can't sleep in hw_host_to_card, we have to buffer
  70         * them. */
  71        struct list_head                cmd_packet_list;
  72        struct list_head                data_packet_list;
  73
  74        /* Protects cmd_packet_list and data_packet_list */
  75        spinlock_t                      buffer_lock;
  76
  77        /* True is card suspended */
  78        u8                              suspended;
  79};
  80
  81static void free_if_spi_card(struct if_spi_card *card)
  82{
  83        struct list_head *cursor, *next;
  84        struct if_spi_packet *packet;
  85
  86        list_for_each_safe(cursor, next, &card->cmd_packet_list) {
  87                packet = container_of(cursor, struct if_spi_packet, list);
  88                list_del(&packet->list);
  89                kfree(packet);
  90        }
  91        list_for_each_safe(cursor, next, &card->data_packet_list) {
  92                packet = container_of(cursor, struct if_spi_packet, list);
  93                list_del(&packet->list);
  94                kfree(packet);
  95        }
  96        spi_set_drvdata(card->spi, NULL);
  97        kfree(card);
  98}
  99
 100#define MODEL_8385      0x04
 101#define MODEL_8686      0x0b
 102#define MODEL_8688      0x10
 103
 104static const struct lbs_fw_table fw_table[] = {
 105        { MODEL_8385, "libertas/gspi8385_helper.bin", "libertas/gspi8385.bin" },
 106        { MODEL_8385, "libertas/gspi8385_hlp.bin", "libertas/gspi8385.bin" },
 107        { MODEL_8686, "libertas/gspi8686_v9_helper.bin", "libertas/gspi8686_v9.bin" },
 108        { MODEL_8686, "libertas/gspi8686_hlp.bin", "libertas/gspi8686.bin" },
 109        { MODEL_8688, "libertas/gspi8688_helper.bin", "libertas/gspi8688.bin" },
 110        { 0, NULL, NULL }
 111};
 112MODULE_FIRMWARE("libertas/gspi8385_helper.bin");
 113MODULE_FIRMWARE("libertas/gspi8385_hlp.bin");
 114MODULE_FIRMWARE("libertas/gspi8385.bin");
 115MODULE_FIRMWARE("libertas/gspi8686_v9_helper.bin");
 116MODULE_FIRMWARE("libertas/gspi8686_v9.bin");
 117MODULE_FIRMWARE("libertas/gspi8686_hlp.bin");
 118MODULE_FIRMWARE("libertas/gspi8686.bin");
 119MODULE_FIRMWARE("libertas/gspi8688_helper.bin");
 120MODULE_FIRMWARE("libertas/gspi8688.bin");
 121
 122
 123/*
 124 * SPI Interface Unit Routines
 125 *
 126 * The SPU sits between the host and the WLAN module.
 127 * All communication with the firmware is through SPU transactions.
 128 *
 129 * First we have to put a SPU register name on the bus. Then we can
 130 * either read from or write to that register.
 131 *
 132 */
 133
 134static void spu_transaction_init(struct if_spi_card *card)
 135{
 136        if (!time_after(jiffies, card->prev_xfer_time + 1)) {
 137                /* Unfortunately, the SPU requires a delay between successive
 138                 * transactions. If our last transaction was more than a jiffy
 139                 * ago, we have obviously already delayed enough.
 140                 * If not, we have to busy-wait to be on the safe side. */
 141                ndelay(400);
 142        }
 143}
 144
 145static void spu_transaction_finish(struct if_spi_card *card)
 146{
 147        card->prev_xfer_time = jiffies;
 148}
 149
 150/*
 151 * Write out a byte buffer to an SPI register,
 152 * using a series of 16-bit transfers.
 153 */
 154static int spu_write(struct if_spi_card *card, u16 reg, const u8 *buf, int len)
 155{
 156        int err = 0;
 157        __le16 reg_out = cpu_to_le16(reg | IF_SPI_WRITE_OPERATION_MASK);
 158        struct spi_message m;
 159        struct spi_transfer reg_trans;
 160        struct spi_transfer data_trans;
 161
 162        spi_message_init(&m);
 163        memset(&reg_trans, 0, sizeof(reg_trans));
 164        memset(&data_trans, 0, sizeof(data_trans));
 165
 166        /* You must give an even number of bytes to the SPU, even if it
 167         * doesn't care about the last one.  */
 168        BUG_ON(len & 0x1);
 169
 170        spu_transaction_init(card);
 171
 172        /* write SPU register index */
 173        reg_trans.tx_buf = &reg_out;
 174        reg_trans.len = sizeof(reg_out);
 175
 176        data_trans.tx_buf = buf;
 177        data_trans.len = len;
 178
 179        spi_message_add_tail(&reg_trans, &m);
 180        spi_message_add_tail(&data_trans, &m);
 181
 182        err = spi_sync(card->spi, &m);
 183        spu_transaction_finish(card);
 184        return err;
 185}
 186
 187static inline int spu_write_u16(struct if_spi_card *card, u16 reg, u16 val)
 188{
 189        __le16 buff;
 190
 191        buff = cpu_to_le16(val);
 192        return spu_write(card, reg, (u8 *)&buff, sizeof(u16));
 193}
 194
 195static inline int spu_reg_is_port_reg(u16 reg)
 196{
 197        switch (reg) {
 198        case IF_SPI_IO_RDWRPORT_REG:
 199        case IF_SPI_CMD_RDWRPORT_REG:
 200        case IF_SPI_DATA_RDWRPORT_REG:
 201                return 1;
 202        default:
 203                return 0;
 204        }
 205}
 206
 207static int spu_read(struct if_spi_card *card, u16 reg, u8 *buf, int len)
 208{
 209        unsigned int delay;
 210        int err = 0;
 211        __le16 reg_out = cpu_to_le16(reg | IF_SPI_READ_OPERATION_MASK);
 212        struct spi_message m;
 213        struct spi_transfer reg_trans;
 214        struct spi_transfer dummy_trans;
 215        struct spi_transfer data_trans;
 216
 217        /*
 218         * You must take an even number of bytes from the SPU, even if you
 219         * don't care about the last one.
 220         */
 221        BUG_ON(len & 0x1);
 222
 223        spu_transaction_init(card);
 224
 225        spi_message_init(&m);
 226        memset(&reg_trans, 0, sizeof(reg_trans));
 227        memset(&dummy_trans, 0, sizeof(dummy_trans));
 228        memset(&data_trans, 0, sizeof(data_trans));
 229
 230        /* write SPU register index */
 231        reg_trans.tx_buf = &reg_out;
 232        reg_trans.len = sizeof(reg_out);
 233        spi_message_add_tail(&reg_trans, &m);
 234
 235        delay = spu_reg_is_port_reg(reg) ? card->spu_port_delay :
 236                                                card->spu_reg_delay;
 237        if (card->use_dummy_writes) {
 238                /* Clock in dummy cycles while the SPU fills the FIFO */
 239                dummy_trans.len = delay / 8;
 240                spi_message_add_tail(&dummy_trans, &m);
 241        } else {
 242                /* Busy-wait while the SPU fills the FIFO */
 243                reg_trans.delay_usecs =
 244                        DIV_ROUND_UP((100 + (delay * 10)), 1000);
 245        }
 246
 247        /* read in data */
 248        data_trans.rx_buf = buf;
 249        data_trans.len = len;
 250        spi_message_add_tail(&data_trans, &m);
 251
 252        err = spi_sync(card->spi, &m);
 253        spu_transaction_finish(card);
 254        return err;
 255}
 256
 257/* Read 16 bits from an SPI register */
 258static inline int spu_read_u16(struct if_spi_card *card, u16 reg, u16 *val)
 259{
 260        __le16 buf;
 261        int ret;
 262
 263        ret = spu_read(card, reg, (u8 *)&buf, sizeof(buf));
 264        if (ret == 0)
 265                *val = le16_to_cpup(&buf);
 266        return ret;
 267}
 268
 269/*
 270 * Read 32 bits from an SPI register.
 271 * The low 16 bits are read first.
 272 */
 273static int spu_read_u32(struct if_spi_card *card, u16 reg, u32 *val)
 274{
 275        __le32 buf;
 276        int err;
 277
 278        err = spu_read(card, reg, (u8 *)&buf, sizeof(buf));
 279        if (!err)
 280                *val = le32_to_cpup(&buf);
 281        return err;
 282}
 283
 284/*
 285 * Keep reading 16 bits from an SPI register until you get the correct result.
 286 *
 287 * If mask = 0, the correct result is any non-zero number.
 288 * If mask != 0, the correct result is any number where
 289 * number & target_mask == target
 290 *
 291 * Returns -ETIMEDOUT if a second passes without the correct result.
 292 */
 293static int spu_wait_for_u16(struct if_spi_card *card, u16 reg,
 294                        u16 target_mask, u16 target)
 295{
 296        int err;
 297        unsigned long timeout = jiffies + 5*HZ;
 298        while (1) {
 299                u16 val;
 300                err = spu_read_u16(card, reg, &val);
 301                if (err)
 302                        return err;
 303                if (target_mask) {
 304                        if ((val & target_mask) == target)
 305                                return 0;
 306                } else {
 307                        if (val)
 308                                return 0;
 309                }
 310                udelay(100);
 311                if (time_after(jiffies, timeout)) {
 312                        pr_err("%s: timeout with val=%02x, target_mask=%02x, target=%02x\n",
 313                               __func__, val, target_mask, target);
 314                        return -ETIMEDOUT;
 315                }
 316        }
 317}
 318
 319/*
 320 * Read 16 bits from an SPI register until you receive a specific value.
 321 * Returns -ETIMEDOUT if a 4 tries pass without success.
 322 */
 323static int spu_wait_for_u32(struct if_spi_card *card, u32 reg, u32 target)
 324{
 325        int err, try;
 326        for (try = 0; try < 4; ++try) {
 327                u32 val = 0;
 328                err = spu_read_u32(card, reg, &val);
 329                if (err)
 330                        return err;
 331                if (val == target)
 332                        return 0;
 333                mdelay(100);
 334        }
 335        return -ETIMEDOUT;
 336}
 337
 338static int spu_set_interrupt_mode(struct if_spi_card *card,
 339                           int suppress_host_int,
 340                           int auto_int)
 341{
 342        int err = 0;
 343
 344        /*
 345         * We can suppress a host interrupt by clearing the appropriate
 346         * bit in the "host interrupt status mask" register
 347         */
 348        if (suppress_host_int) {
 349                err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG, 0);
 350                if (err)
 351                        return err;
 352        } else {
 353                err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG,
 354                              IF_SPI_HISM_TX_DOWNLOAD_RDY |
 355                              IF_SPI_HISM_RX_UPLOAD_RDY |
 356                              IF_SPI_HISM_CMD_DOWNLOAD_RDY |
 357                              IF_SPI_HISM_CARDEVENT |
 358                              IF_SPI_HISM_CMD_UPLOAD_RDY);
 359                if (err)
 360                        return err;
 361        }
 362
 363        /*
 364         * If auto-interrupts are on, the completion of certain transactions
 365         * will trigger an interrupt automatically. If auto-interrupts
 366         * are off, we need to set the "Card Interrupt Cause" register to
 367         * trigger a card interrupt.
 368         */
 369        if (auto_int) {
 370                err = spu_write_u16(card, IF_SPI_HOST_INT_CTRL_REG,
 371                                IF_SPI_HICT_TX_DOWNLOAD_OVER_AUTO |
 372                                IF_SPI_HICT_RX_UPLOAD_OVER_AUTO |
 373                                IF_SPI_HICT_CMD_DOWNLOAD_OVER_AUTO |
 374                                IF_SPI_HICT_CMD_UPLOAD_OVER_AUTO);
 375                if (err)
 376                        return err;
 377        } else {
 378                err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG, 0);
 379                if (err)
 380                        return err;
 381        }
 382        return err;
 383}
 384
 385static int spu_get_chip_revision(struct if_spi_card *card,
 386                                  u16 *card_id, u8 *card_rev)
 387{
 388        int err = 0;
 389        u32 dev_ctrl;
 390        err = spu_read_u32(card, IF_SPI_DEVICEID_CTRL_REG, &dev_ctrl);
 391        if (err)
 392                return err;
 393        *card_id = IF_SPI_DEVICEID_CTRL_REG_TO_CARD_ID(dev_ctrl);
 394        *card_rev = IF_SPI_DEVICEID_CTRL_REG_TO_CARD_REV(dev_ctrl);
 395        return err;
 396}
 397
 398static int spu_set_bus_mode(struct if_spi_card *card, u16 mode)
 399{
 400        int err = 0;
 401        u16 rval;
 402        /* set bus mode */
 403        err = spu_write_u16(card, IF_SPI_SPU_BUS_MODE_REG, mode);
 404        if (err)
 405                return err;
 406        /* Check that we were able to read back what we just wrote. */
 407        err = spu_read_u16(card, IF_SPI_SPU_BUS_MODE_REG, &rval);
 408        if (err)
 409                return err;
 410        if ((rval & 0xF) != mode) {
 411                pr_err("Can't read bus mode register\n");
 412                return -EIO;
 413        }
 414        return 0;
 415}
 416
 417static int spu_init(struct if_spi_card *card, int use_dummy_writes)
 418{
 419        int err = 0;
 420        u32 delay;
 421
 422        /*
 423         * We have to start up in timed delay mode so that we can safely
 424         * read the Delay Read Register.
 425         */
 426        card->use_dummy_writes = 0;
 427        err = spu_set_bus_mode(card,
 428                                IF_SPI_BUS_MODE_SPI_CLOCK_PHASE_RISING |
 429                                IF_SPI_BUS_MODE_DELAY_METHOD_TIMED |
 430                                IF_SPI_BUS_MODE_16_BIT_ADDRESS_16_BIT_DATA);
 431        if (err)
 432                return err;
 433        card->spu_port_delay = 1000;
 434        card->spu_reg_delay = 1000;
 435        err = spu_read_u32(card, IF_SPI_DELAY_READ_REG, &delay);
 436        if (err)
 437                return err;
 438        card->spu_port_delay = delay & 0x0000ffff;
 439        card->spu_reg_delay = (delay & 0xffff0000) >> 16;
 440
 441        /* If dummy clock delay mode has been requested, switch to it now */
 442        if (use_dummy_writes) {
 443                card->use_dummy_writes = 1;
 444                err = spu_set_bus_mode(card,
 445                                IF_SPI_BUS_MODE_SPI_CLOCK_PHASE_RISING |
 446                                IF_SPI_BUS_MODE_DELAY_METHOD_DUMMY_CLOCK |
 447                                IF_SPI_BUS_MODE_16_BIT_ADDRESS_16_BIT_DATA);
 448                if (err)
 449                        return err;
 450        }
 451
 452        lbs_deb_spi("Initialized SPU unit. "
 453                    "spu_port_delay=0x%04lx, spu_reg_delay=0x%04lx\n",
 454                    card->spu_port_delay, card->spu_reg_delay);
 455        return err;
 456}
 457
 458/*
 459 * Firmware Loading
 460 */
 461
 462static int if_spi_prog_helper_firmware(struct if_spi_card *card,
 463                                        const struct firmware *firmware)
 464{
 465        int err = 0;
 466        int bytes_remaining;
 467        const u8 *fw;
 468        u8 temp[HELPER_FW_LOAD_CHUNK_SZ];
 469
 470        lbs_deb_enter(LBS_DEB_SPI);
 471
 472        err = spu_set_interrupt_mode(card, 1, 0);
 473        if (err)
 474                goto out;
 475
 476        bytes_remaining = firmware->size;
 477        fw = firmware->data;
 478
 479        /* Load helper firmware image */
 480        while (bytes_remaining > 0) {
 481                /*
 482                 * Scratch pad 1 should contain the number of bytes we
 483                 * want to download to the firmware
 484                 */
 485                err = spu_write_u16(card, IF_SPI_SCRATCH_1_REG,
 486                                        HELPER_FW_LOAD_CHUNK_SZ);
 487                if (err)
 488                        goto out;
 489
 490                err = spu_wait_for_u16(card, IF_SPI_HOST_INT_STATUS_REG,
 491                                        IF_SPI_HIST_CMD_DOWNLOAD_RDY,
 492                                        IF_SPI_HIST_CMD_DOWNLOAD_RDY);
 493                if (err)
 494                        goto out;
 495
 496                /*
 497                 * Feed the data into the command read/write port reg
 498                 * in chunks of 64 bytes
 499                 */
 500                memset(temp, 0, sizeof(temp));
 501                memcpy(temp, fw,
 502                       min(bytes_remaining, HELPER_FW_LOAD_CHUNK_SZ));
 503                mdelay(10);
 504                err = spu_write(card, IF_SPI_CMD_RDWRPORT_REG,
 505                                        temp, HELPER_FW_LOAD_CHUNK_SZ);
 506                if (err)
 507                        goto out;
 508
 509                /* Interrupt the boot code */
 510                err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
 511                if (err)
 512                        goto out;
 513                err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
 514                                       IF_SPI_CIC_CMD_DOWNLOAD_OVER);
 515                if (err)
 516                        goto out;
 517                bytes_remaining -= HELPER_FW_LOAD_CHUNK_SZ;
 518                fw += HELPER_FW_LOAD_CHUNK_SZ;
 519        }
 520
 521        /*
 522         * Once the helper / single stage firmware download is complete,
 523         * write 0 to scratch pad 1 and interrupt the
 524         * bootloader. This completes the helper download.
 525         */
 526        err = spu_write_u16(card, IF_SPI_SCRATCH_1_REG, FIRMWARE_DNLD_OK);
 527        if (err)
 528                goto out;
 529        err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
 530        if (err)
 531                goto out;
 532        err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
 533                                IF_SPI_CIC_CMD_DOWNLOAD_OVER);
 534out:
 535        if (err)
 536                pr_err("failed to load helper firmware (err=%d)\n", err);
 537        lbs_deb_leave_args(LBS_DEB_SPI, "err %d", err);
 538        return err;
 539}
 540
 541/*
 542 * Returns the length of the next packet the firmware expects us to send.
 543 * Sets crc_err if the previous transfer had a CRC error.
 544 */
 545static int if_spi_prog_main_firmware_check_len(struct if_spi_card *card,
 546                                                int *crc_err)
 547{
 548        u16 len;
 549        int err = 0;
 550
 551        /*
 552         * wait until the host interrupt status register indicates
 553         * that we are ready to download
 554         */
 555        err = spu_wait_for_u16(card, IF_SPI_HOST_INT_STATUS_REG,
 556                                IF_SPI_HIST_CMD_DOWNLOAD_RDY,
 557                                IF_SPI_HIST_CMD_DOWNLOAD_RDY);
 558        if (err) {
 559                pr_err("timed out waiting for host_int_status\n");
 560                return err;
 561        }
 562
 563        /* Ask the device how many bytes of firmware it wants. */
 564        err = spu_read_u16(card, IF_SPI_SCRATCH_1_REG, &len);
 565        if (err)
 566                return err;
 567
 568        if (len > IF_SPI_CMD_BUF_SIZE) {
 569                pr_err("firmware load device requested a larger transfer than we are prepared to handle (len = %d)\n",
 570                       len);
 571                return -EIO;
 572        }
 573        if (len & 0x1) {
 574                lbs_deb_spi("%s: crc error\n", __func__);
 575                len &= ~0x1;
 576                *crc_err = 1;
 577        } else
 578                *crc_err = 0;
 579
 580        return len;
 581}
 582
 583static int if_spi_prog_main_firmware(struct if_spi_card *card,
 584                                        const struct firmware *firmware)
 585{
 586        struct lbs_private *priv = card->priv;
 587        int len, prev_len;
 588        int bytes, crc_err = 0, err = 0;
 589        const u8 *fw;
 590        u16 num_crc_errs;
 591
 592        lbs_deb_enter(LBS_DEB_SPI);
 593
 594        err = spu_set_interrupt_mode(card, 1, 0);
 595        if (err)
 596                goto out;
 597
 598        err = spu_wait_for_u16(card, IF_SPI_SCRATCH_1_REG, 0, 0);
 599        if (err) {
 600                netdev_err(priv->dev,
 601                           "%s: timed out waiting for initial scratch reg = 0\n",
 602                           __func__);
 603                goto out;
 604        }
 605
 606        num_crc_errs = 0;
 607        prev_len = 0;
 608        bytes = firmware->size;
 609        fw = firmware->data;
 610        while ((len = if_spi_prog_main_firmware_check_len(card, &crc_err))) {
 611                if (len < 0) {
 612                        err = len;
 613                        goto out;
 614                }
 615                if (bytes < 0) {
 616                        /*
 617                         * If there are no more bytes left, we would normally
 618                         * expect to have terminated with len = 0
 619                         */
 620                        netdev_err(priv->dev,
 621                                   "Firmware load wants more bytes than we have to offer.\n");
 622                        break;
 623                }
 624                if (crc_err) {
 625                        /* Previous transfer failed. */
 626                        if (++num_crc_errs > MAX_MAIN_FW_LOAD_CRC_ERR) {
 627                                pr_err("Too many CRC errors encountered in firmware load.\n");
 628                                err = -EIO;
 629                                goto out;
 630                        }
 631                } else {
 632                        /* Previous transfer succeeded. Advance counters. */
 633                        bytes -= prev_len;
 634                        fw += prev_len;
 635                }
 636                if (bytes < len) {
 637                        memset(card->cmd_buffer, 0, len);
 638                        memcpy(card->cmd_buffer, fw, bytes);
 639                } else
 640                        memcpy(card->cmd_buffer, fw, len);
 641
 642                err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
 643                if (err)
 644                        goto out;
 645                err = spu_write(card, IF_SPI_CMD_RDWRPORT_REG,
 646                                card->cmd_buffer, len);
 647                if (err)
 648                        goto out;
 649                err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG ,
 650                                        IF_SPI_CIC_CMD_DOWNLOAD_OVER);
 651                if (err)
 652                        goto out;
 653                prev_len = len;
 654        }
 655        if (bytes > prev_len) {
 656                pr_err("firmware load wants fewer bytes than we have to offer\n");
 657        }
 658
 659        /* Confirm firmware download */
 660        err = spu_wait_for_u32(card, IF_SPI_SCRATCH_4_REG,
 661                                        SUCCESSFUL_FW_DOWNLOAD_MAGIC);
 662        if (err) {
 663                pr_err("failed to confirm the firmware download\n");
 664                goto out;
 665        }
 666
 667out:
 668        if (err)
 669                pr_err("failed to load firmware (err=%d)\n", err);
 670        lbs_deb_leave_args(LBS_DEB_SPI, "err %d", err);
 671        return err;
 672}
 673
 674/*
 675 * SPI Transfer Thread
 676 *
 677 * The SPI worker handles all SPI transfers, so there is no need for a lock.
 678 */
 679
 680/* Move a command from the card to the host */
 681static int if_spi_c2h_cmd(struct if_spi_card *card)
 682{
 683        struct lbs_private *priv = card->priv;
 684        unsigned long flags;
 685        int err = 0;
 686        u16 len;
 687        u8 i;
 688
 689        /*
 690         * We need a buffer big enough to handle whatever people send to
 691         * hw_host_to_card
 692         */
 693        BUILD_BUG_ON(IF_SPI_CMD_BUF_SIZE < LBS_CMD_BUFFER_SIZE);
 694        BUILD_BUG_ON(IF_SPI_CMD_BUF_SIZE < LBS_UPLD_SIZE);
 695
 696        /*
 697         * It's just annoying if the buffer size isn't a multiple of 4, because
 698         * then we might have len < IF_SPI_CMD_BUF_SIZE but
 699         * ALIGN(len, 4) > IF_SPI_CMD_BUF_SIZE
 700         */
 701        BUILD_BUG_ON(IF_SPI_CMD_BUF_SIZE % 4 != 0);
 702
 703        lbs_deb_enter(LBS_DEB_SPI);
 704
 705        /* How many bytes are there to read? */
 706        err = spu_read_u16(card, IF_SPI_SCRATCH_2_REG, &len);
 707        if (err)
 708                goto out;
 709        if (!len) {
 710                netdev_err(priv->dev, "%s: error: card has no data for host\n",
 711                           __func__);
 712                err = -EINVAL;
 713                goto out;
 714        } else if (len > IF_SPI_CMD_BUF_SIZE) {
 715                netdev_err(priv->dev,
 716                           "%s: error: response packet too large: %d bytes, but maximum is %d\n",
 717                           __func__, len, IF_SPI_CMD_BUF_SIZE);
 718                err = -EINVAL;
 719                goto out;
 720        }
 721
 722        /* Read the data from the WLAN module into our command buffer */
 723        err = spu_read(card, IF_SPI_CMD_RDWRPORT_REG,
 724                                card->cmd_buffer, ALIGN(len, 4));
 725        if (err)
 726                goto out;
 727
 728        spin_lock_irqsave(&priv->driver_lock, flags);
 729        i = (priv->resp_idx == 0) ? 1 : 0;
 730        BUG_ON(priv->resp_len[i]);
 731        priv->resp_len[i] = len;
 732        memcpy(priv->resp_buf[i], card->cmd_buffer, len);
 733        lbs_notify_command_response(priv, i);
 734        spin_unlock_irqrestore(&priv->driver_lock, flags);
 735
 736out:
 737        if (err)
 738                netdev_err(priv->dev, "%s: err=%d\n", __func__, err);
 739        lbs_deb_leave(LBS_DEB_SPI);
 740        return err;
 741}
 742
 743/* Move data from the card to the host */
 744static int if_spi_c2h_data(struct if_spi_card *card)
 745{
 746        struct lbs_private *priv = card->priv;
 747        struct sk_buff *skb;
 748        char *data;
 749        u16 len;
 750        int err = 0;
 751
 752        lbs_deb_enter(LBS_DEB_SPI);
 753
 754        /* How many bytes are there to read? */
 755        err = spu_read_u16(card, IF_SPI_SCRATCH_1_REG, &len);
 756        if (err)
 757                goto out;
 758        if (!len) {
 759                netdev_err(priv->dev, "%s: error: card has no data for host\n",
 760                           __func__);
 761                err = -EINVAL;
 762                goto out;
 763        } else if (len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
 764                netdev_err(priv->dev,
 765                           "%s: error: card has %d bytes of data, but our maximum skb size is %zu\n",
 766                           __func__, len, MRVDRV_ETH_RX_PACKET_BUFFER_SIZE);
 767                err = -EINVAL;
 768                goto out;
 769        }
 770
 771        /* TODO: should we allocate a smaller skb if we have less data? */
 772        skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE);
 773        if (!skb) {
 774                err = -ENOBUFS;
 775                goto out;
 776        }
 777        skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
 778        data = skb_put(skb, len);
 779
 780        /* Read the data from the WLAN module into our skb... */
 781        err = spu_read(card, IF_SPI_DATA_RDWRPORT_REG, data, ALIGN(len, 4));
 782        if (err)
 783                goto free_skb;
 784
 785        /* pass the SKB to libertas */
 786        err = lbs_process_rxed_packet(card->priv, skb);
 787        if (err)
 788                goto free_skb;
 789
 790        /* success */
 791        goto out;
 792
 793free_skb:
 794        dev_kfree_skb(skb);
 795out:
 796        if (err)
 797                netdev_err(priv->dev, "%s: err=%d\n", __func__, err);
 798        lbs_deb_leave(LBS_DEB_SPI);
 799        return err;
 800}
 801
 802/* Move data or a command from the host to the card. */
 803static void if_spi_h2c(struct if_spi_card *card,
 804                        struct if_spi_packet *packet, int type)
 805{
 806        struct lbs_private *priv = card->priv;
 807        int err = 0;
 808        u16 int_type, port_reg;
 809
 810        switch (type) {
 811        case MVMS_DAT:
 812                int_type = IF_SPI_CIC_TX_DOWNLOAD_OVER;
 813                port_reg = IF_SPI_DATA_RDWRPORT_REG;
 814                break;
 815        case MVMS_CMD:
 816                int_type = IF_SPI_CIC_CMD_DOWNLOAD_OVER;
 817                port_reg = IF_SPI_CMD_RDWRPORT_REG;
 818                break;
 819        default:
 820                netdev_err(priv->dev, "can't transfer buffer of type %d\n",
 821                           type);
 822                err = -EINVAL;
 823                goto out;
 824        }
 825
 826        /* Write the data to the card */
 827        err = spu_write(card, port_reg, packet->buffer, packet->blen);
 828        if (err)
 829                goto out;
 830
 831out:
 832        kfree(packet);
 833
 834        if (err)
 835                netdev_err(priv->dev, "%s: error %d\n", __func__, err);
 836}
 837
 838/* Inform the host about a card event */
 839static void if_spi_e2h(struct if_spi_card *card)
 840{
 841        int err = 0;
 842        u32 cause;
 843        struct lbs_private *priv = card->priv;
 844
 845        err = spu_read_u32(card, IF_SPI_SCRATCH_3_REG, &cause);
 846        if (err)
 847                goto out;
 848
 849        /* re-enable the card event interrupt */
 850        spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG,
 851                        ~IF_SPI_HICU_CARD_EVENT);
 852
 853        /* generate a card interrupt */
 854        spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG, IF_SPI_CIC_HOST_EVENT);
 855
 856        lbs_queue_event(priv, cause & 0xff);
 857out:
 858        if (err)
 859                netdev_err(priv->dev, "%s: error %d\n", __func__, err);
 860}
 861
 862static void if_spi_host_to_card_worker(struct work_struct *work)
 863{
 864        int err;
 865        struct if_spi_card *card;
 866        u16 hiStatus;
 867        unsigned long flags;
 868        struct if_spi_packet *packet;
 869        struct lbs_private *priv;
 870
 871        card = container_of(work, struct if_spi_card, packet_work);
 872        priv = card->priv;
 873
 874        lbs_deb_enter(LBS_DEB_SPI);
 875
 876        /*
 877         * Read the host interrupt status register to see what we
 878         * can do.
 879         */
 880        err = spu_read_u16(card, IF_SPI_HOST_INT_STATUS_REG,
 881                                &hiStatus);
 882        if (err) {
 883                netdev_err(priv->dev, "I/O error\n");
 884                goto err;
 885        }
 886
 887        if (hiStatus & IF_SPI_HIST_CMD_UPLOAD_RDY) {
 888                err = if_spi_c2h_cmd(card);
 889                if (err)
 890                        goto err;
 891        }
 892        if (hiStatus & IF_SPI_HIST_RX_UPLOAD_RDY) {
 893                err = if_spi_c2h_data(card);
 894                if (err)
 895                        goto err;
 896        }
 897
 898        /*
 899         * workaround: in PS mode, the card does not set the Command
 900         * Download Ready bit, but it sets TX Download Ready.
 901         */
 902        if (hiStatus & IF_SPI_HIST_CMD_DOWNLOAD_RDY ||
 903           (card->priv->psstate != PS_STATE_FULL_POWER &&
 904            (hiStatus & IF_SPI_HIST_TX_DOWNLOAD_RDY))) {
 905                /*
 906                 * This means two things. First of all,
 907                 * if there was a previous command sent, the card has
 908                 * successfully received it.
 909                 * Secondly, it is now ready to download another
 910                 * command.
 911                 */
 912                lbs_host_to_card_done(card->priv);
 913
 914                /* Do we have any command packets from the host to send? */
 915                packet = NULL;
 916                spin_lock_irqsave(&card->buffer_lock, flags);
 917                if (!list_empty(&card->cmd_packet_list)) {
 918                        packet = (struct if_spi_packet *)(card->
 919                                        cmd_packet_list.next);
 920                        list_del(&packet->list);
 921                }
 922                spin_unlock_irqrestore(&card->buffer_lock, flags);
 923
 924                if (packet)
 925                        if_spi_h2c(card, packet, MVMS_CMD);
 926        }
 927        if (hiStatus & IF_SPI_HIST_TX_DOWNLOAD_RDY) {
 928                /* Do we have any data packets from the host to send? */
 929                packet = NULL;
 930                spin_lock_irqsave(&card->buffer_lock, flags);
 931                if (!list_empty(&card->data_packet_list)) {
 932                        packet = (struct if_spi_packet *)(card->
 933                                        data_packet_list.next);
 934                        list_del(&packet->list);
 935                }
 936                spin_unlock_irqrestore(&card->buffer_lock, flags);
 937
 938                if (packet)
 939                        if_spi_h2c(card, packet, MVMS_DAT);
 940        }
 941        if (hiStatus & IF_SPI_HIST_CARD_EVENT)
 942                if_spi_e2h(card);
 943
 944err:
 945        if (err)
 946                netdev_err(priv->dev, "%s: got error %d\n", __func__, err);
 947
 948        lbs_deb_leave(LBS_DEB_SPI);
 949}
 950
 951/*
 952 * Host to Card
 953 *
 954 * Called from Libertas to transfer some data to the WLAN device
 955 * We can't sleep here.
 956 */
 957static int if_spi_host_to_card(struct lbs_private *priv,
 958                                u8 type, u8 *buf, u16 nb)
 959{
 960        int err = 0;
 961        unsigned long flags;
 962        struct if_spi_card *card = priv->card;
 963        struct if_spi_packet *packet;
 964        u16 blen;
 965
 966        lbs_deb_enter_args(LBS_DEB_SPI, "type %d, bytes %d", type, nb);
 967
 968        if (nb == 0) {
 969                netdev_err(priv->dev, "%s: invalid size requested: %d\n",
 970                           __func__, nb);
 971                err = -EINVAL;
 972                goto out;
 973        }
 974        blen = ALIGN(nb, 4);
 975        packet = kzalloc(sizeof(struct if_spi_packet) + blen, GFP_ATOMIC);
 976        if (!packet) {
 977                err = -ENOMEM;
 978                goto out;
 979        }
 980        packet->blen = blen;
 981        memcpy(packet->buffer, buf, nb);
 982        memset(packet->buffer + nb, 0, blen - nb);
 983
 984        switch (type) {
 985        case MVMS_CMD:
 986                priv->dnld_sent = DNLD_CMD_SENT;
 987                spin_lock_irqsave(&card->buffer_lock, flags);
 988                list_add_tail(&packet->list, &card->cmd_packet_list);
 989                spin_unlock_irqrestore(&card->buffer_lock, flags);
 990                break;
 991        case MVMS_DAT:
 992                priv->dnld_sent = DNLD_DATA_SENT;
 993                spin_lock_irqsave(&card->buffer_lock, flags);
 994                list_add_tail(&packet->list, &card->data_packet_list);
 995                spin_unlock_irqrestore(&card->buffer_lock, flags);
 996                break;
 997        default:
 998                kfree(packet);
 999                netdev_err(priv->dev, "can't transfer buffer of type %d\n",
1000                           type);
1001                err = -EINVAL;
1002                break;
1003        }
1004
1005        /* Queue spi xfer work */
1006        queue_work(card->workqueue, &card->packet_work);
1007out:
1008        lbs_deb_leave_args(LBS_DEB_SPI, "err=%d", err);
1009        return err;
1010}
1011
1012/*
1013 * Host Interrupts
1014 *
1015 * Service incoming interrupts from the WLAN device. We can't sleep here, so
1016 * don't try to talk on the SPI bus, just queue the SPI xfer work.
1017 */
1018static irqreturn_t if_spi_host_interrupt(int irq, void *dev_id)
1019{
1020        struct if_spi_card *card = dev_id;
1021
1022        queue_work(card->workqueue, &card->packet_work);
1023
1024        return IRQ_HANDLED;
1025}
1026
1027/*
1028 * SPI callbacks
1029 */
1030
1031static int if_spi_init_card(struct if_spi_card *card)
1032{
1033        struct lbs_private *priv = card->priv;
1034        int err, i;
1035        u32 scratch;
1036        const struct firmware *helper = NULL;
1037        const struct firmware *mainfw = NULL;
1038
1039        lbs_deb_enter(LBS_DEB_SPI);
1040
1041        err = spu_init(card, card->pdata->use_dummy_writes);
1042        if (err)
1043                goto out;
1044        err = spu_get_chip_revision(card, &card->card_id, &card->card_rev);
1045        if (err)
1046                goto out;
1047
1048        err = spu_read_u32(card, IF_SPI_SCRATCH_4_REG, &scratch);
1049        if (err)
1050                goto out;
1051        if (scratch == SUCCESSFUL_FW_DOWNLOAD_MAGIC)
1052                lbs_deb_spi("Firmware is already loaded for "
1053                            "Marvell WLAN 802.11 adapter\n");
1054        else {
1055                /* Check if we support this card */
1056                for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
1057                        if (card->card_id == fw_table[i].model)
1058                                break;
1059                }
1060                if (i == ARRAY_SIZE(fw_table)) {
1061                        netdev_err(priv->dev, "Unsupported chip_id: 0x%02x\n",
1062                                   card->card_id);
1063                        err = -ENODEV;
1064                        goto out;
1065                }
1066
1067                err = lbs_get_firmware(&card->spi->dev, card->card_id,
1068                                        &fw_table[0], &helper, &mainfw);
1069                if (err) {
1070                        netdev_err(priv->dev, "failed to find firmware (%d)\n",
1071                                   err);
1072                        goto out;
1073                }
1074
1075                lbs_deb_spi("Initializing FW for Marvell WLAN 802.11 adapter "
1076                                "(chip_id = 0x%04x, chip_rev = 0x%02x) "
1077                                "attached to SPI bus_num %d, chip_select %d. "
1078                                "spi->max_speed_hz=%d\n",
1079                                card->card_id, card->card_rev,
1080                                card->spi->master->bus_num,
1081                                card->spi->chip_select,
1082                                card->spi->max_speed_hz);
1083                err = if_spi_prog_helper_firmware(card, helper);
1084                if (err)
1085                        goto out;
1086                err = if_spi_prog_main_firmware(card, mainfw);
1087                if (err)
1088                        goto out;
1089                lbs_deb_spi("loaded FW for Marvell WLAN 802.11 adapter\n");
1090        }
1091
1092        err = spu_set_interrupt_mode(card, 0, 1);
1093        if (err)
1094                goto out;
1095
1096out:
1097        release_firmware(helper);
1098        release_firmware(mainfw);
1099
1100        lbs_deb_leave_args(LBS_DEB_SPI, "err %d\n", err);
1101
1102        return err;
1103}
1104
1105static void if_spi_resume_worker(struct work_struct *work)
1106{
1107        struct if_spi_card *card;
1108
1109        card = container_of(work, struct if_spi_card, resume_work);
1110
1111        if (card->suspended) {
1112                if (card->pdata->setup)
1113                        card->pdata->setup(card->spi);
1114
1115                /* Init card ... */
1116                if_spi_init_card(card);
1117
1118                enable_irq(card->spi->irq);
1119
1120                /* And resume it ... */
1121                lbs_resume(card->priv);
1122
1123                card->suspended = 0;
1124        }
1125}
1126
1127static int if_spi_probe(struct spi_device *spi)
1128{
1129        struct if_spi_card *card;
1130        struct lbs_private *priv = NULL;
1131        struct libertas_spi_platform_data *pdata = spi->dev.platform_data;
1132        int err = 0;
1133
1134        lbs_deb_enter(LBS_DEB_SPI);
1135
1136        if (!pdata) {
1137                err = -EINVAL;
1138                goto out;
1139        }
1140
1141        if (pdata->setup) {
1142                err = pdata->setup(spi);
1143                if (err)
1144                        goto out;
1145        }
1146
1147        /* Allocate card structure to represent this specific device */
1148        card = kzalloc(sizeof(struct if_spi_card), GFP_KERNEL);
1149        if (!card) {
1150                err = -ENOMEM;
1151                goto teardown;
1152        }
1153        spi_set_drvdata(spi, card);
1154        card->pdata = pdata;
1155        card->spi = spi;
1156        card->prev_xfer_time = jiffies;
1157
1158        INIT_LIST_HEAD(&card->cmd_packet_list);
1159        INIT_LIST_HEAD(&card->data_packet_list);
1160        spin_lock_init(&card->buffer_lock);
1161
1162        /* Initialize the SPI Interface Unit */
1163
1164        /* Firmware load */
1165        err = if_spi_init_card(card);
1166        if (err)
1167                goto free_card;
1168
1169        /*
1170         * Register our card with libertas.
1171         * This will call alloc_etherdev.
1172         */
1173        priv = lbs_add_card(card, &spi->dev);
1174        if (!priv) {
1175                err = -ENOMEM;
1176                goto free_card;
1177        }
1178        card->priv = priv;
1179        priv->setup_fw_on_resume = 1;
1180        priv->card = card;
1181        priv->hw_host_to_card = if_spi_host_to_card;
1182        priv->enter_deep_sleep = NULL;
1183        priv->exit_deep_sleep = NULL;
1184        priv->reset_deep_sleep_wakeup = NULL;
1185        priv->fw_ready = 1;
1186
1187        /* Initialize interrupt handling stuff. */
1188        card->workqueue = create_workqueue("libertas_spi");
1189        INIT_WORK(&card->packet_work, if_spi_host_to_card_worker);
1190        INIT_WORK(&card->resume_work, if_spi_resume_worker);
1191
1192        err = request_irq(spi->irq, if_spi_host_interrupt,
1193                        IRQF_TRIGGER_FALLING, "libertas_spi", card);
1194        if (err) {
1195                pr_err("can't get host irq line-- request_irq failed\n");
1196                goto terminate_workqueue;
1197        }
1198
1199        /*
1200         * Start the card.
1201         * This will call register_netdev, and we'll start
1202         * getting interrupts...
1203         */
1204        err = lbs_start_card(priv);
1205        if (err)
1206                goto release_irq;
1207
1208        lbs_deb_spi("Finished initializing WLAN module.\n");
1209
1210        /* successful exit */
1211        goto out;
1212
1213release_irq:
1214        free_irq(spi->irq, card);
1215terminate_workqueue:
1216        flush_workqueue(card->workqueue);
1217        destroy_workqueue(card->workqueue);
1218        lbs_remove_card(priv); /* will call free_netdev */
1219free_card:
1220        free_if_spi_card(card);
1221teardown:
1222        if (pdata->teardown)
1223                pdata->teardown(spi);
1224out:
1225        lbs_deb_leave_args(LBS_DEB_SPI, "err %d\n", err);
1226        return err;
1227}
1228
1229static int libertas_spi_remove(struct spi_device *spi)
1230{
1231        struct if_spi_card *card = spi_get_drvdata(spi);
1232        struct lbs_private *priv = card->priv;
1233
1234        lbs_deb_spi("libertas_spi_remove\n");
1235        lbs_deb_enter(LBS_DEB_SPI);
1236
1237        cancel_work_sync(&card->resume_work);
1238
1239        lbs_stop_card(priv);
1240        lbs_remove_card(priv); /* will call free_netdev */
1241
1242        free_irq(spi->irq, card);
1243        flush_workqueue(card->workqueue);
1244        destroy_workqueue(card->workqueue);
1245        if (card->pdata->teardown)
1246                card->pdata->teardown(spi);
1247        free_if_spi_card(card);
1248        lbs_deb_leave(LBS_DEB_SPI);
1249        return 0;
1250}
1251
1252static int if_spi_suspend(struct device *dev)
1253{
1254        struct spi_device *spi = to_spi_device(dev);
1255        struct if_spi_card *card = spi_get_drvdata(spi);
1256
1257        if (!card->suspended) {
1258                lbs_suspend(card->priv);
1259                flush_workqueue(card->workqueue);
1260                disable_irq(spi->irq);
1261
1262                if (card->pdata->teardown)
1263                        card->pdata->teardown(spi);
1264                card->suspended = 1;
1265        }
1266
1267        return 0;
1268}
1269
1270static int if_spi_resume(struct device *dev)
1271{
1272        struct spi_device *spi = to_spi_device(dev);
1273        struct if_spi_card *card = spi_get_drvdata(spi);
1274
1275        /* Schedule delayed work */
1276        schedule_work(&card->resume_work);
1277
1278        return 0;
1279}
1280
1281static const struct dev_pm_ops if_spi_pm_ops = {
1282        .suspend        = if_spi_suspend,
1283        .resume         = if_spi_resume,
1284};
1285
1286static struct spi_driver libertas_spi_driver = {
1287        .probe  = if_spi_probe,
1288        .remove = libertas_spi_remove,
1289        .driver = {
1290                .name   = "libertas_spi",
1291                .owner  = THIS_MODULE,
1292                .pm     = &if_spi_pm_ops,
1293        },
1294};
1295
1296/*
1297 * Module functions
1298 */
1299
1300static int __init if_spi_init_module(void)
1301{
1302        int ret = 0;
1303        lbs_deb_enter(LBS_DEB_SPI);
1304        printk(KERN_INFO "libertas_spi: Libertas SPI driver\n");
1305        ret = spi_register_driver(&libertas_spi_driver);
1306        lbs_deb_leave(LBS_DEB_SPI);
1307        return ret;
1308}
1309
1310static void __exit if_spi_exit_module(void)
1311{
1312        lbs_deb_enter(LBS_DEB_SPI);
1313        spi_unregister_driver(&libertas_spi_driver);
1314        lbs_deb_leave(LBS_DEB_SPI);
1315}
1316
1317module_init(if_spi_init_module);
1318module_exit(if_spi_exit_module);
1319
1320MODULE_DESCRIPTION("Libertas SPI WLAN Driver");
1321MODULE_AUTHOR("Andrey Yurovsky <andrey@cozybit.com>, "
1322              "Colin McCabe <colin@cozybit.com>");
1323MODULE_LICENSE("GPL");
1324MODULE_ALIAS("spi:libertas_spi");
1325