drivers/net/wireless/marvell/libertas/if_spi.c

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