drivers/net/wireless/libertas/if_sdio.c

   1 /*
   2  *  linux/drivers/net/wireless/libertas/if_sdio.c
   3  *
   4  *  Copyright 2007-2008 Pierre Ossman
   5  *
   6  * Inspired by if_cs.c, Copyright 2007 Holger Schurig
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or (at
  11  * your option) any later version.
  12  *
  13  * This hardware has more or less no CMD53 support, so all registers
  14  * must be accessed using sdio_readb()/sdio_writeb().
  15  *
  16  * Transfers must be in one transaction or the firmware goes bonkers.
  17  * This means that the transfer must either be small enough to do a
  18  * byte based transfer or it must be padded to a multiple of the
  19  * current block size.
  20  *
  21  * As SDIO is still new to the kernel, it is unfortunately common with
  22  * bugs in the host controllers related to that. One such bug is that
  23  * controllers cannot do transfers that aren't a multiple of 4 bytes.
  24  * If you don't have time to fix the host controller driver, you can
  25  * work around the problem by modifying if_sdio_host_to_card() and
  26  * if_sdio_card_to_host() to pad the data.
  27  */
  28
  29 #include <linux/kernel.h>
  30 #include <linux/moduleparam.h>
  31 #include <linux/firmware.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/delay.h>
  34 #include <linux/mmc/card.h>
  35 #include <linux/mmc/sdio_func.h>
  36 #include <linux/mmc/sdio_ids.h>
  37 #include <linux/mmc/sdio.h>
  38 #include <linux/mmc/host.h>
  39
  40 #include "host.h"
  41 #include "decl.h"
  42 #include "defs.h"
  43 #include "dev.h"
  44 #include "cmd.h"
  45 #include "if_sdio.h"
  46
  47 /* The if_sdio_remove() callback function is called when
  48  * user removes this module from kernel space or ejects
  49  * the card from the slot. The driver handles these 2 cases
  50  * differently for SD8688 combo chip.
  51  * If the user is removing the module, the FUNC_SHUTDOWN
  52  * command for SD8688 is sent to the firmware.
  53  * If the card is removed, there is no need to send this command.
  54  *
  55  * The variable 'user_rmmod' is used to distinguish these two
  56  * scenarios. This flag is initialized as FALSE in case the card
  57  * is removed, and will be set to TRUE for module removal when
  58  * module_exit function is called.
  59  */
  60 static u8 user_rmmod;
  61
  62 static char *lbs_helper_name = NULL;
  63 module_param_named(helper_name, lbs_helper_name, charp, 0644);
  64
  65 static char *lbs_fw_name = NULL;
  66 module_param_named(fw_name, lbs_fw_name, charp, 0644);
  67
  68 static const struct sdio_device_id if_sdio_ids[] = {
  69         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  70                         SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
  71         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  72                         SDIO_DEVICE_ID_MARVELL_8688WLAN) },
  73         { /* end: all zeroes */                         },
  74 };
  75
  76 MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
  77
  78 struct if_sdio_model {
  79         int model;
  80         const char *helper;
  81         const char *firmware;
  82 };
  83
  84 static struct if_sdio_model if_sdio_models[] = {
  85         {
  86                 /* 8385 */
  87                 .model = IF_SDIO_MODEL_8385,
  88                 .helper = "sd8385_helper.bin",
  89                 .firmware = "sd8385.bin",
  90         },
  91         {
  92                 /* 8686 */
  93                 .model = IF_SDIO_MODEL_8686,
  94                 .helper = "sd8686_helper.bin",
  95                 .firmware = "sd8686.bin",
  96         },
  97         {
  98                 /* 8688 */
  99                 .model = IF_SDIO_MODEL_8688,
 100                 .helper = "sd8688_helper.bin",
 101                 .firmware = "sd8688.bin",
 102         },
 103 };
 104
 105 struct if_sdio_packet {
 106         struct if_sdio_packet   *next;
 107         u16                     nb;
 108         u8                      buffer[0] __attribute__((aligned(4)));
 109 };
 110
 111 struct if_sdio_card {
 112         struct sdio_func        *func;
 113         struct lbs_private      *priv;
 114
 115         int                     model;
 116         unsigned long           ioport;
 117         unsigned int            scratch_reg;
 118
 119         const char              *helper;
 120         const char              *firmware;
 121
 122         u8                      buffer[65536];
 123
 124         spinlock_t              lock;
 125         struct if_sdio_packet   *packets;
 126
 127         struct workqueue_struct *workqueue;
 128         struct work_struct      packet_worker;
 129
 130         u8                      rx_unit;
 131 };
 132
 133 /********************************************************************/
 134 /* I/O                                                              */
 135 /********************************************************************/
 136
 137 /*
 138  *  For SD8385/SD8686, this function reads firmware status after
 139  *  the image is downloaded, or reads RX packet length when
 140  *  interrupt (with IF_SDIO_H_INT_UPLD bit set) is received.
 141  *  For SD8688, this function reads firmware status only.
 142  */
 143 static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
 144 {
 145         int ret;
 146         u16 scratch;
 147
 148         scratch = sdio_readb(card->func, card->scratch_reg, &ret);
 149         if (!ret)
 150                 scratch |= sdio_readb(card->func, card->scratch_reg + 1,
 151                                         &ret) << 8;
 152
 153         if (err)
 154                 *err = ret;
 155
 156         if (ret)
 157                 return 0xffff;
 158
 159         return scratch;
 160 }
 161
 162 static u8 if_sdio_read_rx_unit(struct if_sdio_card *card)
 163 {
 164         int ret;
 165         u8 rx_unit;
 166
 167         rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret);
 168
 169         if (ret)
 170                 rx_unit = 0;
 171
 172         return rx_unit;
 173 }
 174
 175 static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err)
 176 {
 177         int ret;
 178         u16 rx_len;
 179
 180         switch (card->model) {
 181         case IF_SDIO_MODEL_8385:
 182         case IF_SDIO_MODEL_8686:
 183                 rx_len = if_sdio_read_scratch(card, &ret);
 184                 break;
 185         case IF_SDIO_MODEL_8688:
 186         default: /* for newer chipsets */
 187                 rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret);
 188                 if (!ret)
 189                         rx_len <<= card->rx_unit;
 190                 else
 191                         rx_len = 0xffff;        /* invalid length */
 192
 193                 break;
 194         }
 195
 196         if (err)
 197                 *err = ret;
 198
 199         return rx_len;
 200 }
 201
 202 static int if_sdio_handle_cmd(struct if_sdio_card *card,
 203                 u8 *buffer, unsigned size)
 204 {
 205         struct lbs_private *priv = card->priv;
 206         int ret;
 207         unsigned long flags;
 208         u8 i;
 209
 210         lbs_deb_enter(LBS_DEB_SDIO);
 211
 212         if (size > LBS_CMD_BUFFER_SIZE) {
 213                 lbs_deb_sdio("response packet too large (%d bytes)\n",
 214                         (int)size);
 215                 ret = -E2BIG;
 216                 goto out;
 217         }
 218
 219         spin_lock_irqsave(&priv->driver_lock, flags);
 220
 221         i = (priv->resp_idx == 0) ? 1 : 0;
 222         BUG_ON(priv->resp_len[i]);
 223         priv->resp_len[i] = size;
 224         memcpy(priv->resp_buf[i], buffer, size);
 225         lbs_notify_command_response(priv, i);
 226
 227         spin_unlock_irqrestore(&card->priv->driver_lock, flags);
 228
 229         ret = 0;
 230
 231 out:
 232         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 233         return ret;
 234 }
 235
 236 static int if_sdio_handle_data(struct if_sdio_card *card,
 237                 u8 *buffer, unsigned size)
 238 {
 239         int ret;
 240         struct sk_buff *skb;
 241         char *data;
 242
 243         lbs_deb_enter(LBS_DEB_SDIO);
 244
 245         if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
 246                 lbs_deb_sdio("response packet too large (%d bytes)\n",
 247                         (int)size);
 248                 ret = -E2BIG;
 249                 goto out;
 250         }
 251
 252         skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
 253         if (!skb) {
 254                 ret = -ENOMEM;
 255                 goto out;
 256         }
 257
 258         skb_reserve(skb, NET_IP_ALIGN);
 259
 260         data = skb_put(skb, size);
 261
 262         memcpy(data, buffer, size);
 263
 264         lbs_process_rxed_packet(card->priv, skb);
 265
 266         ret = 0;
 267
 268 out:
 269         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 270
 271         return ret;
 272 }
 273
 274 static int if_sdio_handle_event(struct if_sdio_card *card,
 275                 u8 *buffer, unsigned size)
 276 {
 277         int ret;
 278         u32 event;
 279
 280         lbs_deb_enter(LBS_DEB_SDIO);
 281
 282         if (card->model == IF_SDIO_MODEL_8385) {
 283                 event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
 284                 if (ret)
 285                         goto out;
 286
 287                 /* right shift 3 bits to get the event id */
 288                 event >>= 3;
 289         } else {
 290                 if (size < 4) {
 291                         lbs_deb_sdio("event packet too small (%d bytes)\n",
 292                                 (int)size);
 293                         ret = -EINVAL;
 294                         goto out;
 295                 }
 296                 event = buffer[3] << 24;
 297                 event |= buffer[2] << 16;
 298                 event |= buffer[1] << 8;
 299                 event |= buffer[0] << 0;
 300         }
 301
 302         lbs_queue_event(card->priv, event & 0xFF);
 303         ret = 0;
 304
 305 out:
 306         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 307
 308         return ret;
 309 }
 310
 311 static int if_sdio_card_to_host(struct if_sdio_card *card)
 312 {
 313         int ret;
 314         u8 status;
 315         u16 size, type, chunk;
 316         unsigned long timeout;
 317
 318         lbs_deb_enter(LBS_DEB_SDIO);
 319
 320         size = if_sdio_read_rx_len(card, &ret);
 321         if (ret)
 322                 goto out;
 323
 324         if (size < 4) {
 325                 lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
 326                         (int)size);
 327                 ret = -EINVAL;
 328                 goto out;
 329         }
 330
 331         timeout = jiffies + HZ;
 332         while (1) {
 333                 status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 334                 if (ret)
 335                         goto out;
 336                 if (status & IF_SDIO_IO_RDY)
 337                         break;
 338                 if (time_after(jiffies, timeout)) {
 339                         ret = -ETIMEDOUT;
 340                         goto out;
 341                 }
 342                 mdelay(1);
 343         }
 344
 345         /*
 346          * The transfer must be in one transaction or the firmware
 347          * goes suicidal. There's no way to guarantee that for all
 348          * controllers, but we can at least try.
 349          */
 350         chunk = sdio_align_size(card->func, size);
 351
 352         ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);
 353         if (ret)
 354                 goto out;
 355
 356         chunk = card->buffer[0] | (card->buffer[1] << 8);
 357         type = card->buffer[2] | (card->buffer[3] << 8);
 358
 359         lbs_deb_sdio("packet of type %d and size %d bytes\n",
 360                 (int)type, (int)chunk);
 361
 362         if (chunk > size) {
 363                 lbs_deb_sdio("packet fragment (%d > %d)\n",
 364                         (int)chunk, (int)size);
 365                 ret = -EINVAL;
 366                 goto out;
 367         }
 368
 369         if (chunk < size) {
 370                 lbs_deb_sdio("packet fragment (%d < %d)\n",
 371                         (int)chunk, (int)size);
 372         }
 373
 374         switch (type) {
 375         case MVMS_CMD:
 376                 ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);
 377                 if (ret)
 378                         goto out;
 379                 break;
 380         case MVMS_DAT:
 381                 ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);
 382                 if (ret)
 383                         goto out;
 384                 break;
 385         case MVMS_EVENT:
 386                 ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);
 387                 if (ret)
 388                         goto out;
 389                 break;
 390         default:
 391                 lbs_deb_sdio("invalid type (%d) from firmware\n",
 392                                 (int)type);
 393                 ret = -EINVAL;
 394                 goto out;
 395         }
 396
 397 out:
 398         if (ret)
 399                 lbs_pr_err("problem fetching packet from firmware\n");
 400
 401         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 402
 403         return ret;
 404 }
 405
 406 static void if_sdio_host_to_card_worker(struct work_struct *work)
 407 {
 408         struct if_sdio_card *card;
 409         struct if_sdio_packet *packet;
 410         unsigned long timeout;
 411         u8 status;
 412         int ret;
 413         unsigned long flags;
 414
 415         lbs_deb_enter(LBS_DEB_SDIO);
 416
 417         card = container_of(work, struct if_sdio_card, packet_worker);
 418
 419         while (1) {
 420                 spin_lock_irqsave(&card->lock, flags);
 421                 packet = card->packets;
 422                 if (packet)
 423                         card->packets = packet->next;
 424                 spin_unlock_irqrestore(&card->lock, flags);
 425
 426                 if (!packet)
 427                         break;
 428
 429                 sdio_claim_host(card->func);
 430
 431                 timeout = jiffies + HZ;
 432                 while (1) {
 433                         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 434                         if (ret)
 435                                 goto release;
 436                         if (status & IF_SDIO_IO_RDY)
 437                                 break;
 438                         if (time_after(jiffies, timeout)) {
 439                                 ret = -ETIMEDOUT;
 440                                 goto release;
 441                         }
 442                         mdelay(1);
 443                 }
 444
 445                 ret = sdio_writesb(card->func, card->ioport,
 446                                 packet->buffer, packet->nb);
 447                 if (ret)
 448                         goto release;
 449 release:
 450                 sdio_release_host(card->func);
 451
 452                 kfree(packet);
 453         }
 454
 455         lbs_deb_leave(LBS_DEB_SDIO);
 456 }
 457
 458 /********************************************************************/
 459 /* Firmware                                                         */
 460 /********************************************************************/
 461
 462 static int if_sdio_prog_helper(struct if_sdio_card *card)
 463 {
 464         int ret;
 465         u8 status;
 466         const struct firmware *fw;
 467         unsigned long timeout;
 468         u8 *chunk_buffer;
 469         u32 chunk_size;
 470         const u8 *firmware;
 471         size_t size;
 472
 473         lbs_deb_enter(LBS_DEB_SDIO);
 474
 475         ret = request_firmware(&fw, card->helper, &card->func->dev);
 476         if (ret) {
 477                 lbs_pr_err("can't load helper firmware\n");
 478                 goto out;
 479         }
 480
 481         chunk_buffer = kzalloc(64, GFP_KERNEL);
 482         if (!chunk_buffer) {
 483                 ret = -ENOMEM;
 484                 goto release_fw;
 485         }
 486
 487         sdio_claim_host(card->func);
 488
 489         ret = sdio_set_block_size(card->func, 32);
 490         if (ret)
 491                 goto release;
 492
 493         firmware = fw->data;
 494         size = fw->size;
 495
 496         while (size) {
 497                 timeout = jiffies + HZ;
 498                 while (1) {
 499                         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 500                         if (ret)
 501                                 goto release;
 502                         if ((status & IF_SDIO_IO_RDY) &&
 503                                         (status & IF_SDIO_DL_RDY))
 504                                 break;
 505                         if (time_after(jiffies, timeout)) {
 506                                 ret = -ETIMEDOUT;
 507                                 goto release;
 508                         }
 509                         mdelay(1);
 510                 }
 511
 512                 chunk_size = min(size, (size_t)60);
 513
 514                 *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
 515                 memcpy(chunk_buffer + 4, firmware, chunk_size);
 516 /*
 517                 lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
 518 */
 519                 ret = sdio_writesb(card->func, card->ioport,
 520                                 chunk_buffer, 64);
 521                 if (ret)
 522                         goto release;
 523
 524                 firmware += chunk_size;
 525                 size -= chunk_size;
 526         }
 527
 528         /* an empty block marks the end of the transfer */
 529         memset(chunk_buffer, 0, 4);
 530         ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);
 531         if (ret)
 532                 goto release;
 533
 534         lbs_deb_sdio("waiting for helper to boot...\n");
 535
 536         /* wait for the helper to boot by looking at the size register */
 537         timeout = jiffies + HZ;
 538         while (1) {
 539                 u16 req_size;
 540
 541                 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
 542                 if (ret)
 543                         goto release;
 544
 545                 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
 546                 if (ret)
 547                         goto release;
 548
 549                 if (req_size != 0)
 550                         break;
 551
 552                 if (time_after(jiffies, timeout)) {
 553                         ret = -ETIMEDOUT;
 554                         goto release;
 555                 }
 556
 557                 msleep(10);
 558         }
 559
 560         ret = 0;
 561
 562 release:
 563         sdio_release_host(card->func);
 564         kfree(chunk_buffer);
 565 release_fw:
 566         release_firmware(fw);
 567
 568 out:
 569         if (ret)
 570                 lbs_pr_err("failed to load helper firmware\n");
 571
 572         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 573
 574         return ret;
 575 }
 576
 577 static int if_sdio_prog_real(struct if_sdio_card *card)
 578 {
 579         int ret;
 580         u8 status;
 581         const struct firmware *fw;
 582         unsigned long timeout;
 583         u8 *chunk_buffer;
 584         u32 chunk_size;
 585         const u8 *firmware;
 586         size_t size, req_size;
 587
 588         lbs_deb_enter(LBS_DEB_SDIO);
 589
 590         ret = request_firmware(&fw, card->firmware, &card->func->dev);
 591         if (ret) {
 592                 lbs_pr_err("can't load firmware\n");
 593                 goto out;
 594         }
 595
 596         chunk_buffer = kzalloc(512, GFP_KERNEL);
 597         if (!chunk_buffer) {
 598                 ret = -ENOMEM;
 599                 goto release_fw;
 600         }
 601
 602         sdio_claim_host(card->func);
 603
 604         ret = sdio_set_block_size(card->func, 32);
 605         if (ret)
 606                 goto release;
 607
 608         firmware = fw->data;
 609         size = fw->size;
 610
 611         while (size) {
 612                 timeout = jiffies + HZ;
 613                 while (1) {
 614                         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 615                         if (ret)
 616                                 goto release;
 617                         if ((status & IF_SDIO_IO_RDY) &&
 618                                         (status & IF_SDIO_DL_RDY))
 619                                 break;
 620                         if (time_after(jiffies, timeout)) {
 621                                 ret = -ETIMEDOUT;
 622                                 goto release;
 623                         }
 624                         mdelay(1);
 625                 }
 626
 627                 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
 628                 if (ret)
 629                         goto release;
 630
 631                 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
 632                 if (ret)
 633                         goto release;
 634 /*
 635                 lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);
 636 */
 637                 if (req_size == 0) {
 638                         lbs_deb_sdio("firmware helper gave up early\n");
 639                         ret = -EIO;
 640                         goto release;
 641                 }
 642
 643                 if (req_size & 0x01) {
 644                         lbs_deb_sdio("firmware helper signalled error\n");
 645                         ret = -EIO;
 646                         goto release;
 647                 }
 648
 649                 if (req_size > size)
 650                         req_size = size;
 651
 652                 while (req_size) {
 653                         chunk_size = min(req_size, (size_t)512);
 654
 655                         memcpy(chunk_buffer, firmware, chunk_size);
 656 /*
 657                         lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",
 658                                 chunk_size, (chunk_size + 31) / 32 * 32);
 659 */
 660                         ret = sdio_writesb(card->func, card->ioport,
 661                                 chunk_buffer, roundup(chunk_size, 32));
 662                         if (ret)
 663                                 goto release;
 664
 665                         firmware += chunk_size;
 666                         size -= chunk_size;
 667                         req_size -= chunk_size;
 668                 }
 669         }
 670
 671         ret = 0;
 672
 673         lbs_deb_sdio("waiting for firmware to boot...\n");
 674
 675         /* wait for the firmware to boot */
 676         timeout = jiffies + HZ;
 677         while (1) {
 678                 u16 scratch;
 679
 680                 scratch = if_sdio_read_scratch(card, &ret);
 681                 if (ret)
 682                         goto release;
 683
 684                 if (scratch == IF_SDIO_FIRMWARE_OK)
 685                         break;
 686
 687                 if (time_after(jiffies, timeout)) {
 688                         ret = -ETIMEDOUT;
 689                         goto release;
 690                 }
 691
 692                 msleep(10);
 693         }
 694
 695         ret = 0;
 696
 697 release:
 698         sdio_release_host(card->func);
 699         kfree(chunk_buffer);
 700 release_fw:
 701         release_firmware(fw);
 702
 703 out:
 704         if (ret)
 705                 lbs_pr_err("failed to load firmware\n");
 706
 707         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 708
 709         return ret;
 710 }
 711
 712 static int if_sdio_prog_firmware(struct if_sdio_card *card)
 713 {
 714         int ret;
 715         u16 scratch;
 716
 717         lbs_deb_enter(LBS_DEB_SDIO);
 718
 719         sdio_claim_host(card->func);
 720         scratch = if_sdio_read_scratch(card, &ret);
 721         sdio_release_host(card->func);
 722
 723         if (ret)
 724                 goto out;
 725
 726         lbs_deb_sdio("firmware status = %#x\n", scratch);
 727
 728         if (scratch == IF_SDIO_FIRMWARE_OK) {
 729                 lbs_deb_sdio("firmware already loaded\n");
 730                 goto success;
 731         }
 732
 733         ret = if_sdio_prog_helper(card);
 734         if (ret)
 735                 goto out;
 736
 737         ret = if_sdio_prog_real(card);
 738         if (ret)
 739                 goto out;
 740
 741 success:
 742         sdio_claim_host(card->func);
 743         sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
 744         sdio_release_host(card->func);
 745         ret = 0;
 746
 747 out:
 748         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 749
 750         return ret;
 751 }
 752
 753 /*******************************************************************/
 754 /* Libertas callbacks                                              */
 755 /*******************************************************************/
 756
 757 static int if_sdio_host_to_card(struct lbs_private *priv,
 758                 u8 type, u8 *buf, u16 nb)
 759 {
 760         int ret;
 761         struct if_sdio_card *card;
 762         struct if_sdio_packet *packet, *cur;
 763         u16 size;
 764         unsigned long flags;
 765
 766         lbs_deb_enter_args(LBS_DEB_SDIO, "type %d, bytes %d", type, nb);
 767
 768         card = priv->card;
 769
 770         if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {
 771                 ret = -EINVAL;
 772                 goto out;
 773         }
 774
 775         /*
 776          * The transfer must be in one transaction or the firmware
 777          * goes suicidal. There's no way to guarantee that for all
 778          * controllers, but we can at least try.
 779          */
 780         size = sdio_align_size(card->func, nb + 4);
 781
 782         packet = kzalloc(sizeof(struct if_sdio_packet) + size,
 783                         GFP_ATOMIC);
 784         if (!packet) {
 785                 ret = -ENOMEM;
 786                 goto out;
 787         }
 788
 789         packet->next = NULL;
 790         packet->nb = size;
 791
 792         /*
 793          * SDIO specific header.
 794          */
 795         packet->buffer[0] = (nb + 4) & 0xff;
 796         packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
 797         packet->buffer[2] = type;
 798         packet->buffer[3] = 0;
 799
 800         memcpy(packet->buffer + 4, buf, nb);
 801
 802         spin_lock_irqsave(&card->lock, flags);
 803
 804         if (!card->packets)
 805                 card->packets = packet;
 806         else {
 807                 cur = card->packets;
 808                 while (cur->next)
 809                         cur = cur->next;
 810                 cur->next = packet;
 811         }
 812
 813         switch (type) {
 814         case MVMS_CMD:
 815                 priv->dnld_sent = DNLD_CMD_SENT;
 816                 break;
 817         case MVMS_DAT:
 818                 priv->dnld_sent = DNLD_DATA_SENT;
 819                 break;
 820         default:
 821                 lbs_deb_sdio("unknown packet type %d\n", (int)type);
 822         }
 823
 824         spin_unlock_irqrestore(&card->lock, flags);
 825
 826         queue_work(card->workqueue, &card->packet_worker);
 827
 828         ret = 0;
 829
 830 out:
 831         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 832
 833         return ret;
 834 }
 835
 836 /*******************************************************************/
 837 /* SDIO callbacks                                                  */
 838 /*******************************************************************/
 839
 840 static void if_sdio_interrupt(struct sdio_func *func)
 841 {
 842         int ret;
 843         struct if_sdio_card *card;
 844         u8 cause;
 845
 846         lbs_deb_enter(LBS_DEB_SDIO);
 847
 848         card = sdio_get_drvdata(func);
 849
 850         cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
 851         if (ret)
 852                 goto out;
 853
 854         lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
 855
 856         sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
 857         if (ret)
 858                 goto out;
 859
 860         /*
 861          * Ignore the define name, this really means the card has
 862          * successfully received the command.
 863          */
 864         if (cause & IF_SDIO_H_INT_DNLD)
 865                 lbs_host_to_card_done(card->priv);
 866
 867
 868         if (cause & IF_SDIO_H_INT_UPLD) {
 869                 ret = if_sdio_card_to_host(card);
 870                 if (ret)
 871                         goto out;
 872         }
 873
 874         ret = 0;
 875
 876 out:
 877         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 878 }
 879
 880 static int if_sdio_probe(struct sdio_func *func,
 881                 const struct sdio_device_id *id)
 882 {
 883         struct if_sdio_card *card;
 884         struct lbs_private *priv;
 885         int ret, i;
 886         unsigned int model;
 887         struct if_sdio_packet *packet;
 888         struct mmc_host *host = func->card->host;
 889
 890         lbs_deb_enter(LBS_DEB_SDIO);
 891
 892         for (i = 0;i < func->card->num_info;i++) {
 893                 if (sscanf(func->card->info[i],
 894                                 "802.11 SDIO ID: %x", &model) == 1)
 895                         break;
 896                 if (sscanf(func->card->info[i],
 897                                 "ID: %x", &model) == 1)
 898                         break;
 899                 if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
 900                         model = IF_SDIO_MODEL_8385;
 901                         break;
 902                 }
 903         }
 904
 905         if (i == func->card->num_info) {
 906                 lbs_pr_err("unable to identify card model\n");
 907                 return -ENODEV;
 908         }
 909
 910         card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
 911         if (!card)
 912                 return -ENOMEM;
 913
 914         card->func = func;
 915         card->model = model;
 916
 917         switch (card->model) {
 918         case IF_SDIO_MODEL_8385:
 919                 card->scratch_reg = IF_SDIO_SCRATCH_OLD;
 920                 break;
 921         case IF_SDIO_MODEL_8686:
 922                 card->scratch_reg = IF_SDIO_SCRATCH;
 923                 break;
 924         case IF_SDIO_MODEL_8688:
 925         default: /* for newer chipsets */
 926                 card->scratch_reg = IF_SDIO_FW_STATUS;
 927                 break;
 928         }
 929
 930         spin_lock_init(&card->lock);
 931         card->workqueue = create_workqueue("libertas_sdio");
 932         INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
 933
 934         for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) {
 935                 if (card->model == if_sdio_models[i].model)
 936                         break;
 937         }
 938
 939         if (i == ARRAY_SIZE(if_sdio_models)) {
 940                 lbs_pr_err("unkown card model 0x%x\n", card->model);
 941                 ret = -ENODEV;
 942                 goto free;
 943         }
 944
 945         card->helper = if_sdio_models[i].helper;
 946         card->firmware = if_sdio_models[i].firmware;
 947
 948         if (lbs_helper_name) {
 949                 lbs_deb_sdio("overriding helper firmware: %s\n",
 950                         lbs_helper_name);
 951                 card->helper = lbs_helper_name;
 952         }
 953
 954         if (lbs_fw_name) {
 955                 lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
 956                 card->firmware = lbs_fw_name;
 957         }
 958
 959         sdio_claim_host(func);
 960
 961         ret = sdio_enable_func(func);
 962         if (ret)
 963                 goto release;
 964
 965         ret = sdio_claim_irq(func, if_sdio_interrupt);
 966         if (ret)
 967                 goto disable;
 968
 969         /* For 1-bit transfers to the 8686 model, we need to enable the
 970          * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
 971          * bit to allow access to non-vendor registers. */
 972         if ((card->model == IF_SDIO_MODEL_8686) &&
 973             (host->caps & MMC_CAP_SDIO_IRQ) &&
 974             (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
 975                 u8 reg;
 976
 977                 func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
 978                 reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
 979                 if (ret)
 980                         goto release_int;
 981
 982                 reg |= SDIO_BUS_ECSI;
 983                 sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
 984                 if (ret)
 985                         goto release_int;
 986         }
 987
 988         card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
 989         if (ret)
 990                 goto release_int;
 991
 992         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
 993         if (ret)
 994                 goto release_int;
 995
 996         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
 997         if (ret)
 998                 goto release_int;
 999
1000         sdio_release_host(func);
1001
1002         sdio_set_drvdata(func, card);
1003
1004         lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
1005                         "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
1006                         func->class, func->vendor, func->device,
1007                         model, (unsigned)card->ioport);
1008
1009         ret = if_sdio_prog_firmware(card);
1010         if (ret)
1011                 goto reclaim;
1012
1013         priv = lbs_add_card(card, &func->dev);
1014         if (!priv) {
1015                 ret = -ENOMEM;
1016                 goto reclaim;
1017         }
1018
1019         card->priv = priv;
1020
1021         priv->card = card;
1022         priv->hw_host_to_card = if_sdio_host_to_card;
1023
1024         priv->fw_ready = 1;
1025
1026         sdio_claim_host(func);
1027
1028         /*
1029          * Get rx_unit if the chip is SD8688 or newer.
1030          * SD8385 & SD8686 do not have rx_unit.
1031          */
1032         if ((card->model != IF_SDIO_MODEL_8385)
1033                         && (card->model != IF_SDIO_MODEL_8686))
1034                 card->rx_unit = if_sdio_read_rx_unit(card);
1035         else
1036                 card->rx_unit = 0;
1037
1038         /*
1039          * Enable interrupts now that everything is set up
1040          */
1041         sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
1042         sdio_release_host(func);
1043         if (ret)
1044                 goto reclaim;
1045
1046         /*
1047          * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
1048          */
1049         if (card->model == IF_SDIO_MODEL_8688) {
1050                 struct cmd_header cmd;
1051
1052                 memset(&cmd, 0, sizeof(cmd));
1053
1054                 lbs_deb_sdio("send function INIT command\n");
1055                 if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
1056                                 lbs_cmd_copyback, (unsigned long) &cmd))
1057                         lbs_pr_alert("CMD_FUNC_INIT cmd failed\n");
1058         }
1059
1060         ret = lbs_start_card(priv);
1061         if (ret)
1062                 goto err_activate_card;
1063
1064 out:
1065         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
1066
1067         return ret;
1068
1069 err_activate_card:
1070         flush_workqueue(card->workqueue);
1071         lbs_remove_card(priv);
1072 reclaim:
1073         sdio_claim_host(func);
1074 release_int:
1075         sdio_release_irq(func);
1076 disable:
1077         sdio_disable_func(func);
1078 release:
1079         sdio_release_host(func);
1080 free:
1081         destroy_workqueue(card->workqueue);
1082         while (card->packets) {
1083                 packet = card->packets;
1084                 card->packets = card->packets->next;
1085                 kfree(packet);
1086         }
1087
1088         kfree(card);
1089
1090         goto out;
1091 }
1092
1093 static void if_sdio_remove(struct sdio_func *func)
1094 {
1095         struct if_sdio_card *card;
1096         struct if_sdio_packet *packet;
1097
1098         lbs_deb_enter(LBS_DEB_SDIO);
1099
1100         card = sdio_get_drvdata(func);
1101
1102         if (user_rmmod && (card->model == IF_SDIO_MODEL_8688)) {
1103                 /*
1104                  * FUNC_SHUTDOWN is required for SD8688 WLAN/BT
1105                  * multiple functions
1106                  */
1107                 struct cmd_header cmd;
1108
1109                 memset(&cmd, 0, sizeof(cmd));
1110
1111                 lbs_deb_sdio("send function SHUTDOWN command\n");
1112                 if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN,
1113                                 &cmd, sizeof(cmd), lbs_cmd_copyback,
1114                                 (unsigned long) &cmd))
1115                         lbs_pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n");
1116         }
1117
1118
1119         lbs_deb_sdio("call remove card\n");
1120         lbs_stop_card(card->priv);
1121         lbs_remove_card(card->priv);
1122         card->priv->surpriseremoved = 1;
1123
1124         flush_workqueue(card->workqueue);
1125         destroy_workqueue(card->workqueue);
1126
1127         sdio_claim_host(func);
1128         sdio_release_irq(func);
1129         sdio_disable_func(func);
1130         sdio_release_host(func);
1131
1132         while (card->packets) {
1133                 packet = card->packets;
1134                 card->packets = card->packets->next;
1135                 kfree(packet);
1136         }
1137
1138         kfree(card);
1139
1140         lbs_deb_leave(LBS_DEB_SDIO);
1141 }
1142
1143 static struct sdio_driver if_sdio_driver = {
1144         .name           = "libertas_sdio",
1145         .id_table       = if_sdio_ids,
1146         .probe          = if_sdio_probe,
1147         .remove         = if_sdio_remove,
1148 };
1149
1150 /*******************************************************************/
1151 /* Module functions                                                */
1152 /*******************************************************************/
1153
1154 static int __init if_sdio_init_module(void)
1155 {
1156         int ret = 0;
1157
1158         lbs_deb_enter(LBS_DEB_SDIO);
1159
1160         printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
1161         printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
1162
1163         ret = sdio_register_driver(&if_sdio_driver);
1164
1165         /* Clear the flag in case user removes the card. */
1166         user_rmmod = 0;
1167
1168         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
1169
1170         return ret;
1171 }
1172
1173 static void __exit if_sdio_exit_module(void)
1174 {
1175         lbs_deb_enter(LBS_DEB_SDIO);
1176
1177         /* Set the flag as user is removing this module. */
1178         user_rmmod = 1;
1179
1180         sdio_unregister_driver(&if_sdio_driver);
1181
1182         lbs_deb_leave(LBS_DEB_SDIO);
1183 }
1184
1185 module_init(if_sdio_init_module);
1186 module_exit(if_sdio_exit_module);
1187
1188 MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
1189 MODULE_AUTHOR("Pierre Ossman");
1190 MODULE_LICENSE("GPL");