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