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