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