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