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
  38 #include "host.h"
  39 #include "decl.h"
  40 #include "defs.h"
  41 #include "dev.h"
  42 #include "if_sdio.h"
  43
  44 static char *lbs_helper_name = NULL;
  45 module_param_named(helper_name, lbs_helper_name, charp, 0644);
  46
  47 static char *lbs_fw_name = NULL;
  48 module_param_named(fw_name, lbs_fw_name, charp, 0644);
  49
  50 static const struct sdio_device_id if_sdio_ids[] = {
  51         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  52                         SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
  53         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  54                         SDIO_DEVICE_ID_MARVELL_8688WLAN) },
  55         { /* end: all zeroes */                         },
  56 };
  57
  58 MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
  59
  60 struct if_sdio_model {
  61         int model;
  62         const char *helper;
  63         const char *firmware;
  64 };
  65
  66 static struct if_sdio_model if_sdio_models[] = {
  67         {
  68                 /* 8385 */
  69                 .model = 0x04,
  70                 .helper = "sd8385_helper.bin",
  71                 .firmware = "sd8385.bin",
  72         },
  73         {
  74                 /* 8686 */
  75                 .model = 0x0B,
  76                 .helper = "sd8686_helper.bin",
  77                 .firmware = "sd8686.bin",
  78         },
  79         {
  80                 /* 8688 */
  81                 .model = 0x10,
  82                 .helper = "sd8688_helper.bin",
  83                 .firmware = "sd8688.bin",
  84         },
  85 };
  86
  87 struct if_sdio_packet {
  88         struct if_sdio_packet   *next;
  89         u16                     nb;
  90         u8                      buffer[0] __attribute__((aligned(4)));
  91 };
  92
  93 struct if_sdio_card {
  94         struct sdio_func        *func;
  95         struct lbs_private      *priv;
  96
  97         int                     model;
  98         unsigned long           ioport;
  99
 100         const char              *helper;
 101         const char              *firmware;
 102
 103         u8                      buffer[65536];
 104
 105         spinlock_t              lock;
 106         struct if_sdio_packet   *packets;
 107
 108         struct workqueue_struct *workqueue;
 109         struct work_struct      packet_worker;
 110 };
 111
 112 /********************************************************************/
 113 /* I/O                                                              */
 114 /********************************************************************/
 115
 116 static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
 117 {
 118         int ret, reg;
 119         u16 scratch;
 120
 121         if (card->model == 0x04)
 122                 reg = IF_SDIO_SCRATCH_OLD;
 123         else
 124                 reg = IF_SDIO_SCRATCH;
 125
 126         scratch = sdio_readb(card->func, reg, &ret);
 127         if (!ret)
 128                 scratch |= sdio_readb(card->func, reg + 1, &ret) << 8;
 129
 130         if (err)
 131                 *err = ret;
 132
 133         if (ret)
 134                 return 0xffff;
 135
 136         return scratch;
 137 }
 138
 139 static int if_sdio_handle_cmd(struct if_sdio_card *card,
 140                 u8 *buffer, unsigned size)
 141 {
 142         struct lbs_private *priv = card->priv;
 143         int ret;
 144         unsigned long flags;
 145         u8 i;
 146
 147         lbs_deb_enter(LBS_DEB_SDIO);
 148
 149         if (size > LBS_CMD_BUFFER_SIZE) {
 150                 lbs_deb_sdio("response packet too large (%d bytes)\n",
 151                         (int)size);
 152                 ret = -E2BIG;
 153                 goto out;
 154         }
 155
 156         spin_lock_irqsave(&priv->driver_lock, flags);
 157
 158         i = (priv->resp_idx == 0) ? 1 : 0;
 159         BUG_ON(priv->resp_len[i]);
 160         priv->resp_len[i] = size;
 161         memcpy(priv->resp_buf[i], buffer, size);
 162         lbs_notify_command_response(priv, i);
 163
 164         spin_unlock_irqrestore(&card->priv->driver_lock, flags);
 165
 166         ret = 0;
 167
 168 out:
 169         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 170         return ret;
 171 }
 172
 173 static int if_sdio_handle_data(struct if_sdio_card *card,
 174                 u8 *buffer, unsigned size)
 175 {
 176         int ret;
 177         struct sk_buff *skb;
 178         char *data;
 179
 180         lbs_deb_enter(LBS_DEB_SDIO);
 181
 182         if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
 183                 lbs_deb_sdio("response packet too large (%d bytes)\n",
 184                         (int)size);
 185                 ret = -E2BIG;
 186                 goto out;
 187         }
 188
 189         skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
 190         if (!skb) {
 191                 ret = -ENOMEM;
 192                 goto out;
 193         }
 194
 195         skb_reserve(skb, NET_IP_ALIGN);
 196
 197         data = skb_put(skb, size);
 198
 199         memcpy(data, buffer, size);
 200
 201         lbs_process_rxed_packet(card->priv, skb);
 202
 203         ret = 0;
 204
 205 out:
 206         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 207
 208         return ret;
 209 }
 210
 211 static int if_sdio_handle_event(struct if_sdio_card *card,
 212                 u8 *buffer, unsigned size)
 213 {
 214         int ret;
 215         u32 event;
 216
 217         lbs_deb_enter(LBS_DEB_SDIO);
 218
 219         if (card->model == 0x04) {
 220                 event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
 221                 if (ret)
 222                         goto out;
 223
 224                 /* right shift 3 bits to get the event id */
 225                 event >>= 3;
 226         } else {
 227                 if (size < 4) {
 228                         lbs_deb_sdio("event packet too small (%d bytes)\n",
 229                                 (int)size);
 230                         ret = -EINVAL;
 231                         goto out;
 232                 }
 233                 event = buffer[3] << 24;
 234                 event |= buffer[2] << 16;
 235                 event |= buffer[1] << 8;
 236                 event |= buffer[0] << 0;
 237         }
 238
 239         lbs_queue_event(card->priv, event & 0xFF);
 240         ret = 0;
 241
 242 out:
 243         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 244
 245         return ret;
 246 }
 247
 248 static int if_sdio_card_to_host(struct if_sdio_card *card)
 249 {
 250         int ret;
 251         u8 status;
 252         u16 size, type, chunk;
 253         unsigned long timeout;
 254
 255         lbs_deb_enter(LBS_DEB_SDIO);
 256
 257         size = if_sdio_read_scratch(card, &ret);
 258         if (ret)
 259                 goto out;
 260
 261         if (size < 4) {
 262                 lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
 263                         (int)size);
 264                 ret = -EINVAL;
 265                 goto out;
 266         }
 267
 268         timeout = jiffies + HZ;
 269         while (1) {
 270                 status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 271                 if (ret)
 272                         goto out;
 273                 if (status & IF_SDIO_IO_RDY)
 274                         break;
 275                 if (time_after(jiffies, timeout)) {
 276                         ret = -ETIMEDOUT;
 277                         goto out;
 278                 }
 279                 mdelay(1);
 280         }
 281
 282         /*
 283          * The transfer must be in one transaction or the firmware
 284          * goes suicidal. There's no way to guarantee that for all
 285          * controllers, but we can at least try.
 286          */
 287         chunk = sdio_align_size(card->func, size);
 288
 289         ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);
 290         if (ret)
 291                 goto out;
 292
 293         chunk = card->buffer[0] | (card->buffer[1] << 8);
 294         type = card->buffer[2] | (card->buffer[3] << 8);
 295
 296         lbs_deb_sdio("packet of type %d and size %d bytes\n",
 297                 (int)type, (int)chunk);
 298
 299         if (chunk > size) {
 300                 lbs_deb_sdio("packet fragment (%d > %d)\n",
 301                         (int)chunk, (int)size);
 302                 ret = -EINVAL;
 303                 goto out;
 304         }
 305
 306         if (chunk < size) {
 307                 lbs_deb_sdio("packet fragment (%d < %d)\n",
 308                         (int)chunk, (int)size);
 309         }
 310
 311         switch (type) {
 312         case MVMS_CMD:
 313                 ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);
 314                 if (ret)
 315                         goto out;
 316                 break;
 317         case MVMS_DAT:
 318                 ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);
 319                 if (ret)
 320                         goto out;
 321                 break;
 322         case MVMS_EVENT:
 323                 ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);
 324                 if (ret)
 325                         goto out;
 326                 break;
 327         default:
 328                 lbs_deb_sdio("invalid type (%d) from firmware\n",
 329                                 (int)type);
 330                 ret = -EINVAL;
 331                 goto out;
 332         }
 333
 334 out:
 335         if (ret)
 336                 lbs_pr_err("problem fetching packet from firmware\n");
 337
 338         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 339
 340         return ret;
 341 }
 342
 343 static void if_sdio_host_to_card_worker(struct work_struct *work)
 344 {
 345         struct if_sdio_card *card;
 346         struct if_sdio_packet *packet;
 347         unsigned long timeout;
 348         u8 status;
 349         int ret;
 350         unsigned long flags;
 351
 352         lbs_deb_enter(LBS_DEB_SDIO);
 353
 354         card = container_of(work, struct if_sdio_card, packet_worker);
 355
 356         while (1) {
 357                 spin_lock_irqsave(&card->lock, flags);
 358                 packet = card->packets;
 359                 if (packet)
 360                         card->packets = packet->next;
 361                 spin_unlock_irqrestore(&card->lock, flags);
 362
 363                 if (!packet)
 364                         break;
 365
 366                 sdio_claim_host(card->func);
 367
 368                 timeout = jiffies + HZ;
 369                 while (1) {
 370                         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 371                         if (ret)
 372                                 goto release;
 373                         if (status & IF_SDIO_IO_RDY)
 374                                 break;
 375                         if (time_after(jiffies, timeout)) {
 376                                 ret = -ETIMEDOUT;
 377                                 goto release;
 378                         }
 379                         mdelay(1);
 380                 }
 381
 382                 ret = sdio_writesb(card->func, card->ioport,
 383                                 packet->buffer, packet->nb);
 384                 if (ret)
 385                         goto release;
 386 release:
 387                 sdio_release_host(card->func);
 388
 389                 kfree(packet);
 390         }
 391
 392         lbs_deb_leave(LBS_DEB_SDIO);
 393 }
 394
 395 /********************************************************************/
 396 /* Firmware                                                         */
 397 /********************************************************************/
 398
 399 static int if_sdio_prog_helper(struct if_sdio_card *card)
 400 {
 401         int ret;
 402         u8 status;
 403         const struct firmware *fw;
 404         unsigned long timeout;
 405         u8 *chunk_buffer;
 406         u32 chunk_size;
 407         const u8 *firmware;
 408         size_t size;
 409
 410         lbs_deb_enter(LBS_DEB_SDIO);
 411
 412         ret = request_firmware(&fw, card->helper, &card->func->dev);
 413         if (ret) {
 414                 lbs_pr_err("can't load helper firmware\n");
 415                 goto out;
 416         }
 417
 418         chunk_buffer = kzalloc(64, GFP_KERNEL);
 419         if (!chunk_buffer) {
 420                 ret = -ENOMEM;
 421                 goto release_fw;
 422         }
 423
 424         sdio_claim_host(card->func);
 425
 426         ret = sdio_set_block_size(card->func, 32);
 427         if (ret)
 428                 goto release;
 429
 430         firmware = fw->data;
 431         size = fw->size;
 432
 433         while (size) {
 434                 timeout = jiffies + HZ;
 435                 while (1) {
 436                         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 437                         if (ret)
 438                                 goto release;
 439                         if ((status & IF_SDIO_IO_RDY) &&
 440                                         (status & IF_SDIO_DL_RDY))
 441                                 break;
 442                         if (time_after(jiffies, timeout)) {
 443                                 ret = -ETIMEDOUT;
 444                                 goto release;
 445                         }
 446                         mdelay(1);
 447                 }
 448
 449                 chunk_size = min(size, (size_t)60);
 450
 451                 *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
 452                 memcpy(chunk_buffer + 4, firmware, chunk_size);
 453 /*
 454                 lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
 455 */
 456                 ret = sdio_writesb(card->func, card->ioport,
 457                                 chunk_buffer, 64);
 458                 if (ret)
 459                         goto release;
 460
 461                 firmware += chunk_size;
 462                 size -= chunk_size;
 463         }
 464
 465         /* an empty block marks the end of the transfer */
 466         memset(chunk_buffer, 0, 4);
 467         ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);
 468         if (ret)
 469                 goto release;
 470
 471         lbs_deb_sdio("waiting for helper to boot...\n");
 472
 473         /* wait for the helper to boot by looking at the size register */
 474         timeout = jiffies + HZ;
 475         while (1) {
 476                 u16 req_size;
 477
 478                 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
 479                 if (ret)
 480                         goto release;
 481
 482                 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
 483                 if (ret)
 484                         goto release;
 485
 486                 if (req_size != 0)
 487                         break;
 488
 489                 if (time_after(jiffies, timeout)) {
 490                         ret = -ETIMEDOUT;
 491                         goto release;
 492                 }
 493
 494                 msleep(10);
 495         }
 496
 497         ret = 0;
 498
 499 release:
 500         sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
 501         sdio_release_host(card->func);
 502         kfree(chunk_buffer);
 503 release_fw:
 504         release_firmware(fw);
 505
 506 out:
 507         if (ret)
 508                 lbs_pr_err("failed to load helper firmware\n");
 509
 510         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 511
 512         return ret;
 513 }
 514
 515 static int if_sdio_prog_real(struct if_sdio_card *card)
 516 {
 517         int ret;
 518         u8 status;
 519         const struct firmware *fw;
 520         unsigned long timeout;
 521         u8 *chunk_buffer;
 522         u32 chunk_size;
 523         const u8 *firmware;
 524         size_t size, req_size;
 525
 526         lbs_deb_enter(LBS_DEB_SDIO);
 527
 528         ret = request_firmware(&fw, card->firmware, &card->func->dev);
 529         if (ret) {
 530                 lbs_pr_err("can't load firmware\n");
 531                 goto out;
 532         }
 533
 534         chunk_buffer = kzalloc(512, GFP_KERNEL);
 535         if (!chunk_buffer) {
 536                 ret = -ENOMEM;
 537                 goto release_fw;
 538         }
 539
 540         sdio_claim_host(card->func);
 541
 542         ret = sdio_set_block_size(card->func, 32);
 543         if (ret)
 544                 goto release;
 545
 546         firmware = fw->data;
 547         size = fw->size;
 548
 549         while (size) {
 550                 timeout = jiffies + HZ;
 551                 while (1) {
 552                         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 553                         if (ret)
 554                                 goto release;
 555                         if ((status & IF_SDIO_IO_RDY) &&
 556                                         (status & IF_SDIO_DL_RDY))
 557                                 break;
 558                         if (time_after(jiffies, timeout)) {
 559                                 ret = -ETIMEDOUT;
 560                                 goto release;
 561                         }
 562                         mdelay(1);
 563                 }
 564
 565                 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
 566                 if (ret)
 567                         goto release;
 568
 569                 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
 570                 if (ret)
 571                         goto release;
 572 /*
 573                 lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);
 574 */
 575                 if (req_size == 0) {
 576                         lbs_deb_sdio("firmware helper gave up early\n");
 577                         ret = -EIO;
 578                         goto release;
 579                 }
 580
 581                 if (req_size & 0x01) {
 582                         lbs_deb_sdio("firmware helper signalled error\n");
 583                         ret = -EIO;
 584                         goto release;
 585                 }
 586
 587                 if (req_size > size)
 588                         req_size = size;
 589
 590                 while (req_size) {
 591                         chunk_size = min(req_size, (size_t)512);
 592
 593                         memcpy(chunk_buffer, firmware, chunk_size);
 594 /*
 595                         lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",
 596                                 chunk_size, (chunk_size + 31) / 32 * 32);
 597 */
 598                         ret = sdio_writesb(card->func, card->ioport,
 599                                 chunk_buffer, roundup(chunk_size, 32));
 600                         if (ret)
 601                                 goto release;
 602
 603                         firmware += chunk_size;
 604                         size -= chunk_size;
 605                         req_size -= chunk_size;
 606                 }
 607         }
 608
 609         ret = 0;
 610
 611         lbs_deb_sdio("waiting for firmware to boot...\n");
 612
 613         /* wait for the firmware to boot */
 614         timeout = jiffies + HZ;
 615         while (1) {
 616                 u16 scratch;
 617
 618                 scratch = if_sdio_read_scratch(card, &ret);
 619                 if (ret)
 620                         goto release;
 621
 622                 if (scratch == IF_SDIO_FIRMWARE_OK)
 623                         break;
 624
 625                 if (time_after(jiffies, timeout)) {
 626                         ret = -ETIMEDOUT;
 627                         goto release;
 628                 }
 629
 630                 msleep(10);
 631         }
 632
 633         ret = 0;
 634
 635 release:
 636         sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
 637         sdio_release_host(card->func);
 638         kfree(chunk_buffer);
 639 release_fw:
 640         release_firmware(fw);
 641
 642 out:
 643         if (ret)
 644                 lbs_pr_err("failed to load firmware\n");
 645
 646         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 647
 648         return ret;
 649 }
 650
 651 static int if_sdio_prog_firmware(struct if_sdio_card *card)
 652 {
 653         int ret;
 654         u16 scratch;
 655
 656         lbs_deb_enter(LBS_DEB_SDIO);
 657
 658         sdio_claim_host(card->func);
 659         scratch = if_sdio_read_scratch(card, &ret);
 660         sdio_release_host(card->func);
 661
 662         if (ret)
 663                 goto out;
 664
 665         if (scratch == IF_SDIO_FIRMWARE_OK) {
 666                 lbs_deb_sdio("firmware already loaded\n");
 667                 goto success;
 668         }
 669
 670         ret = if_sdio_prog_helper(card);
 671         if (ret)
 672                 goto out;
 673
 674         ret = if_sdio_prog_real(card);
 675         if (ret)
 676                 goto out;
 677
 678 success:
 679         ret = 0;
 680
 681 out:
 682         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 683
 684         return ret;
 685 }
 686
 687 /*******************************************************************/
 688 /* Libertas callbacks                                              */
 689 /*******************************************************************/
 690
 691 static int if_sdio_host_to_card(struct lbs_private *priv,
 692                 u8 type, u8 *buf, u16 nb)
 693 {
 694         int ret;
 695         struct if_sdio_card *card;
 696         struct if_sdio_packet *packet, *cur;
 697         u16 size;
 698         unsigned long flags;
 699
 700         lbs_deb_enter_args(LBS_DEB_SDIO, "type %d, bytes %d", type, nb);
 701
 702         card = priv->card;
 703
 704         if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {
 705                 ret = -EINVAL;
 706                 goto out;
 707         }
 708
 709         /*
 710          * The transfer must be in one transaction or the firmware
 711          * goes suicidal. There's no way to guarantee that for all
 712          * controllers, but we can at least try.
 713          */
 714         size = sdio_align_size(card->func, nb + 4);
 715
 716         packet = kzalloc(sizeof(struct if_sdio_packet) + size,
 717                         GFP_ATOMIC);
 718         if (!packet) {
 719                 ret = -ENOMEM;
 720                 goto out;
 721         }
 722
 723         packet->next = NULL;
 724         packet->nb = size;
 725
 726         /*
 727          * SDIO specific header.
 728          */
 729         packet->buffer[0] = (nb + 4) & 0xff;
 730         packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
 731         packet->buffer[2] = type;
 732         packet->buffer[3] = 0;
 733
 734         memcpy(packet->buffer + 4, buf, nb);
 735
 736         spin_lock_irqsave(&card->lock, flags);
 737
 738         if (!card->packets)
 739                 card->packets = packet;
 740         else {
 741                 cur = card->packets;
 742                 while (cur->next)
 743                         cur = cur->next;
 744                 cur->next = packet;
 745         }
 746
 747         switch (type) {
 748         case MVMS_CMD:
 749                 priv->dnld_sent = DNLD_CMD_SENT;
 750                 break;
 751         case MVMS_DAT:
 752                 priv->dnld_sent = DNLD_DATA_SENT;
 753                 break;
 754         default:
 755                 lbs_deb_sdio("unknown packet type %d\n", (int)type);
 756         }
 757
 758         spin_unlock_irqrestore(&card->lock, flags);
 759
 760         queue_work(card->workqueue, &card->packet_worker);
 761
 762         ret = 0;
 763
 764 out:
 765         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 766
 767         return ret;
 768 }
 769
 770 /*******************************************************************/
 771 /* SDIO callbacks                                                  */
 772 /*******************************************************************/
 773
 774 static void if_sdio_interrupt(struct sdio_func *func)
 775 {
 776         int ret;
 777         struct if_sdio_card *card;
 778         u8 cause;
 779
 780         lbs_deb_enter(LBS_DEB_SDIO);
 781
 782         card = sdio_get_drvdata(func);
 783
 784         cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
 785         if (ret)
 786                 goto out;
 787
 788         lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
 789
 790         sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
 791         if (ret)
 792                 goto out;
 793
 794         /*
 795          * Ignore the define name, this really means the card has
 796          * successfully received the command.
 797          */
 798         if (cause & IF_SDIO_H_INT_DNLD)
 799                 lbs_host_to_card_done(card->priv);
 800
 801
 802         if (cause & IF_SDIO_H_INT_UPLD) {
 803                 ret = if_sdio_card_to_host(card);
 804                 if (ret)
 805                         goto out;
 806         }
 807
 808         ret = 0;
 809
 810 out:
 811         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 812 }
 813
 814 static int if_sdio_probe(struct sdio_func *func,
 815                 const struct sdio_device_id *id)
 816 {
 817         struct if_sdio_card *card;
 818         struct lbs_private *priv;
 819         int ret, i;
 820         unsigned int model;
 821         struct if_sdio_packet *packet;
 822
 823         lbs_deb_enter(LBS_DEB_SDIO);
 824
 825         for (i = 0;i < func->card->num_info;i++) {
 826                 if (sscanf(func->card->info[i],
 827                                 "802.11 SDIO ID: %x", &model) == 1)
 828                         break;
 829                 if (sscanf(func->card->info[i],
 830                                 "ID: %x", &model) == 1)
 831                         break;
 832                if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
 833                        model = 4;
 834                        break;
 835                }
 836         }
 837
 838         if (i == func->card->num_info) {
 839                 lbs_pr_err("unable to identify card model\n");
 840                 return -ENODEV;
 841         }
 842
 843         card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
 844         if (!card)
 845                 return -ENOMEM;
 846
 847         card->func = func;
 848         card->model = model;
 849         spin_lock_init(&card->lock);
 850         card->workqueue = create_workqueue("libertas_sdio");
 851         INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
 852
 853         for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) {
 854                 if (card->model == if_sdio_models[i].model)
 855                         break;
 856         }
 857
 858         if (i == ARRAY_SIZE(if_sdio_models)) {
 859                 lbs_pr_err("unkown card model 0x%x\n", card->model);
 860                 ret = -ENODEV;
 861                 goto free;
 862         }
 863
 864         card->helper = if_sdio_models[i].helper;
 865         card->firmware = if_sdio_models[i].firmware;
 866
 867         if (lbs_helper_name) {
 868                 lbs_deb_sdio("overriding helper firmware: %s\n",
 869                         lbs_helper_name);
 870                 card->helper = lbs_helper_name;
 871         }
 872
 873         if (lbs_fw_name) {
 874                 lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
 875                 card->firmware = lbs_fw_name;
 876         }
 877
 878         sdio_claim_host(func);
 879
 880         ret = sdio_enable_func(func);
 881         if (ret)
 882                 goto release;
 883
 884         ret = sdio_claim_irq(func, if_sdio_interrupt);
 885         if (ret)
 886                 goto disable;
 887
 888         card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
 889         if (ret)
 890                 goto release_int;
 891
 892         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
 893         if (ret)
 894                 goto release_int;
 895
 896         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
 897         if (ret)
 898                 goto release_int;
 899
 900         sdio_release_host(func);
 901
 902         sdio_set_drvdata(func, card);
 903
 904         lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
 905                         "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
 906                         func->class, func->vendor, func->device,
 907                         model, (unsigned)card->ioport);
 908
 909         ret = if_sdio_prog_firmware(card);
 910         if (ret)
 911                 goto reclaim;
 912
 913         priv = lbs_add_card(card, &func->dev);
 914         if (!priv) {
 915                 ret = -ENOMEM;
 916                 goto reclaim;
 917         }
 918
 919         card->priv = priv;
 920
 921         priv->card = card;
 922         priv->hw_host_to_card = if_sdio_host_to_card;
 923
 924         priv->fw_ready = 1;
 925
 926         /*
 927          * Enable interrupts now that everything is set up
 928          */
 929         sdio_claim_host(func);
 930         sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
 931         sdio_release_host(func);
 932         if (ret)
 933                 goto reclaim;
 934
 935         ret = lbs_start_card(priv);
 936         if (ret)
 937                 goto err_activate_card;
 938
 939         if (priv->fwcapinfo & FW_CAPINFO_PS)
 940                 priv->ps_supported = 1;
 941
 942 out:
 943         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 944
 945         return ret;
 946
 947 err_activate_card:
 948         flush_workqueue(card->workqueue);
 949         lbs_remove_card(priv);
 950 reclaim:
 951         sdio_claim_host(func);
 952 release_int:
 953         sdio_release_irq(func);
 954 disable:
 955         sdio_disable_func(func);
 956 release:
 957         sdio_release_host(func);
 958 free:
 959         destroy_workqueue(card->workqueue);
 960         while (card->packets) {
 961                 packet = card->packets;
 962                 card->packets = card->packets->next;
 963                 kfree(packet);
 964         }
 965
 966         kfree(card);
 967
 968         goto out;
 969 }
 970
 971 static void if_sdio_remove(struct sdio_func *func)
 972 {
 973         struct if_sdio_card *card;
 974         struct if_sdio_packet *packet;
 975
 976         lbs_deb_enter(LBS_DEB_SDIO);
 977
 978         card = sdio_get_drvdata(func);
 979
 980         card->priv->surpriseremoved = 1;
 981
 982         lbs_deb_sdio("call remove card\n");
 983         lbs_stop_card(card->priv);
 984         lbs_remove_card(card->priv);
 985
 986         flush_workqueue(card->workqueue);
 987         destroy_workqueue(card->workqueue);
 988
 989         sdio_claim_host(func);
 990         sdio_release_irq(func);
 991         sdio_disable_func(func);
 992         sdio_release_host(func);
 993
 994         while (card->packets) {
 995                 packet = card->packets;
 996                 card->packets = card->packets->next;
 997                 kfree(packet);
 998         }
 999
1000         kfree(card);
1001
1002         lbs_deb_leave(LBS_DEB_SDIO);
1003 }
1004
1005 static struct sdio_driver if_sdio_driver = {
1006         .name           = "libertas_sdio",
1007         .id_table       = if_sdio_ids,
1008         .probe          = if_sdio_probe,
1009         .remove         = if_sdio_remove,
1010 };
1011
1012 /*******************************************************************/
1013 /* Module functions                                                */
1014 /*******************************************************************/
1015
1016 static int __init if_sdio_init_module(void)
1017 {
1018         int ret = 0;
1019
1020         lbs_deb_enter(LBS_DEB_SDIO);
1021
1022         printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
1023         printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
1024
1025         ret = sdio_register_driver(&if_sdio_driver);
1026
1027         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
1028
1029         return ret;
1030 }
1031
1032 static void __exit if_sdio_exit_module(void)
1033 {
1034         lbs_deb_enter(LBS_DEB_SDIO);
1035
1036         sdio_unregister_driver(&if_sdio_driver);
1037
1038         lbs_deb_leave(LBS_DEB_SDIO);
1039 }
1040
1041 module_init(if_sdio_init_module);
1042 module_exit(if_sdio_exit_module);
1043
1044 MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
1045 MODULE_AUTHOR("Pierre Ossman");
1046 MODULE_LICENSE("GPL");