linux/drivers/staging/ks7010/ks7010_sdio.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 *   Driver for KeyStream, KS7010 based SDIO cards.
   4 *
   5 *   Copyright (C) 2006-2008 KeyStream Corp.
   6 *   Copyright (C) 2009 Renesas Technology Corp.
   7 *   Copyright (C) 2016 Sang Engineering, Wolfram Sang
   8 */
   9
  10#include <linux/atomic.h>
  11#include <linux/firmware.h>
  12#include <linux/jiffies.h>
  13#include <linux/mmc/card.h>
  14#include <linux/mmc/sdio_func.h>
  15#include <linux/module.h>
  16#include <linux/workqueue.h>
  17#include "ks_wlan.h"
  18#include "ks_hostif.h"
  19
  20#define ROM_FILE "ks7010sd.rom"
  21
  22/*  SDIO KeyStream vendor and device */
  23#define SDIO_VENDOR_ID_KS_CODE_A        0x005b
  24#define SDIO_VENDOR_ID_KS_CODE_B        0x0023
  25
  26/* Older sources suggest earlier versions were named 7910 or 79xx */
  27#define SDIO_DEVICE_ID_KS_7010          0x7910
  28
  29/* Read/Write Status Register */
  30#define READ_STATUS_REG         0x000000
  31#define WRITE_STATUS_REG        0x00000C
  32enum reg_status_type {
  33        REG_STATUS_BUSY,
  34        REG_STATUS_IDLE
  35};
  36
  37/* Read Index Register */
  38#define READ_INDEX_REG          0x000004
  39
  40/* Read Data Size Register */
  41#define READ_DATA_SIZE_REG      0x000008
  42
  43/* Write Index Register */
  44#define WRITE_INDEX_REG         0x000010
  45
  46/*
  47 * Write Status/Read Data Size Register
  48 * for network packet (less than 2048 bytes data)
  49 */
  50#define WSTATUS_RSIZE_REG       0x000014
  51
  52/* Write Status Register value */
  53#define WSTATUS_MASK            0x80
  54
  55/* Read Data Size Register value [10:4] */
  56#define RSIZE_MASK              0x7F
  57
  58/* ARM to SD interrupt Enable */
  59#define INT_ENABLE_REG          0x000020
  60/* ARM to SD interrupt Pending */
  61#define INT_PENDING_REG         0x000024
  62
  63#define INT_GCR_B              BIT(7)
  64#define INT_GCR_A              BIT(6)
  65#define INT_WRITE_STATUS       BIT(5)
  66#define INT_WRITE_INDEX        BIT(4)
  67#define INT_WRITE_SIZE         BIT(3)
  68#define INT_READ_STATUS        BIT(2)
  69#define INT_READ_INDEX         BIT(1)
  70#define INT_READ_SIZE          BIT(0)
  71
  72/* General Communication Register A */
  73#define GCR_A_REG               0x000028
  74enum gen_com_reg_a {
  75        GCR_A_INIT,
  76        GCR_A_REMAP,
  77        GCR_A_RUN
  78};
  79
  80/* General Communication Register B */
  81#define GCR_B_REG               0x00002C
  82enum gen_com_reg_b {
  83        GCR_B_ACTIVE,
  84        GCR_B_DOZE
  85};
  86
  87/* Wakeup Register */
  88#define WAKEUP_REG              0x008018
  89#define WAKEUP_REQ              0x5a
  90
  91/* AHB Data Window  0x010000-0x01FFFF */
  92#define DATA_WINDOW             0x010000
  93#define WINDOW_SIZE             (64 * 1024)
  94
  95#define KS7010_IRAM_ADDRESS     0x06000000
  96
  97#define KS7010_IO_BLOCK_SIZE 512
  98
  99/**
 100 * struct ks_sdio_card - SDIO device data.
 101 *
 102 * Structure is used as the &struct sdio_func private data.
 103 *
 104 * @func: Pointer to the SDIO function device.
 105 * @priv: Pointer to the &struct net_device private data.
 106 */
 107struct ks_sdio_card {
 108        struct sdio_func *func;
 109        struct ks_wlan_private *priv;
 110};
 111
 112static struct sdio_func *ks7010_to_func(struct ks_wlan_private *priv)
 113{
 114        struct ks_sdio_card *ks_sdio = priv->if_hw;
 115
 116        return ks_sdio->func;
 117}
 118
 119/* Read single byte from device address into byte (CMD52) */
 120static int ks7010_sdio_readb(struct ks_wlan_private *priv,
 121                             u32 address, u8 *byte)
 122{
 123        struct sdio_func *func = ks7010_to_func(priv);
 124        int ret;
 125
 126        *byte = sdio_readb(func, address, &ret);
 127
 128        return ret;
 129}
 130
 131/* Read length bytes from device address into buffer (CMD53) */
 132static int ks7010_sdio_read(struct ks_wlan_private *priv, u32 address,
 133                            u8 *buffer, unsigned int length)
 134{
 135        struct sdio_func *func = ks7010_to_func(priv);
 136
 137        return sdio_memcpy_fromio(func, buffer, address, length);
 138}
 139
 140/* Write single byte to device address (CMD52) */
 141static int ks7010_sdio_writeb(struct ks_wlan_private *priv,
 142                              u32 address, u8 byte)
 143{
 144        struct sdio_func *func = ks7010_to_func(priv);
 145        int ret;
 146
 147        sdio_writeb(func, byte, address, &ret);
 148
 149        return ret;
 150}
 151
 152/* Write length bytes to device address from buffer (CMD53) */
 153static int ks7010_sdio_write(struct ks_wlan_private *priv, u32 address,
 154                             u8 *buffer, unsigned int length)
 155{
 156        struct sdio_func *func = ks7010_to_func(priv);
 157
 158        return sdio_memcpy_toio(func, address, buffer, length);
 159}
 160
 161static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
 162{
 163        int ret;
 164
 165        /* clear request */
 166        atomic_set(&priv->sleepstatus.doze_request, 0);
 167
 168        if (atomic_read(&priv->sleepstatus.status) == 0) {
 169                ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
 170                if (ret) {
 171                        netdev_err(priv->net_dev, "write GCR_B_REG\n");
 172                        goto set_sleep_mode;
 173                }
 174                atomic_set(&priv->sleepstatus.status, 1);
 175                priv->last_doze = jiffies;
 176        }
 177
 178set_sleep_mode:
 179        priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
 180}
 181
 182static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
 183{
 184        int ret;
 185
 186        /* clear request */
 187        atomic_set(&priv->sleepstatus.wakeup_request, 0);
 188
 189        if (atomic_read(&priv->sleepstatus.status) == 1) {
 190                ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
 191                if (ret) {
 192                        netdev_err(priv->net_dev, "write WAKEUP_REG\n");
 193                        goto set_sleep_mode;
 194                }
 195                atomic_set(&priv->sleepstatus.status, 0);
 196                priv->last_wakeup = jiffies;
 197                ++priv->wakeup_count;
 198        }
 199
 200set_sleep_mode:
 201        priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
 202}
 203
 204void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
 205{
 206        int ret;
 207
 208        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 209                ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
 210                if (ret)
 211                        netdev_err(priv->net_dev, "write WAKEUP_REG\n");
 212
 213                priv->last_wakeup = jiffies;
 214                ++priv->wakeup_count;
 215        }
 216}
 217
 218static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
 219{
 220        u8 byte;
 221        int ret;
 222
 223        if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE)
 224                return;
 225
 226        if (priv->reg.operation_mode != MODE_INFRASTRUCTURE)
 227                return;
 228
 229        if (!is_connect_status(priv->connect_status))
 230                return;
 231
 232        if (priv->dev_state != DEVICE_STATE_SLEEP)
 233                return;
 234
 235        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE)
 236                return;
 237
 238        netdev_dbg(priv->net_dev,
 239                   "STATUS:\n"
 240                   "- psstatus.status = %d\n"
 241                   "- psstatus.confirm_wait = %d\n"
 242                   "- psstatus.snooze_guard = %d\n"
 243                   "- txq_count = %d\n",
 244                   atomic_read(&priv->psstatus.status),
 245                   atomic_read(&priv->psstatus.confirm_wait),
 246                   atomic_read(&priv->psstatus.snooze_guard),
 247                   txq_count(priv));
 248
 249        if (atomic_read(&priv->psstatus.confirm_wait) ||
 250            atomic_read(&priv->psstatus.snooze_guard) ||
 251            txq_has_space(priv)) {
 252                queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 253                return;
 254        }
 255
 256        ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &byte);
 257        if (ret) {
 258                netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
 259                goto queue_delayed_work;
 260        }
 261        if (byte)
 262                goto queue_delayed_work;
 263
 264        ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
 265        if (ret) {
 266                netdev_err(priv->net_dev, "write GCR_B_REG\n");
 267                goto queue_delayed_work;
 268        }
 269        atomic_set(&priv->psstatus.status, PS_SNOOZE);
 270
 271        return;
 272
 273queue_delayed_work:
 274        queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 275}
 276
 277int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
 278{
 279        queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 280        return 0;
 281}
 282
 283static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
 284                         unsigned long size,
 285                         void (*complete_handler)(struct ks_wlan_private *priv,
 286                                                  struct sk_buff *skb),
 287                         struct sk_buff *skb)
 288{
 289        struct tx_device_buffer *sp;
 290        int ret;
 291
 292        if (priv->dev_state < DEVICE_STATE_BOOT) {
 293                ret = -EPERM;
 294                goto err_complete;
 295        }
 296
 297        if ((TX_DEVICE_BUFF_SIZE - 1) <= txq_count(priv)) {
 298                netdev_err(priv->net_dev, "tx buffer overflow\n");
 299                ret = -EOVERFLOW;
 300                goto err_complete;
 301        }
 302
 303        sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
 304        sp->sendp = p;
 305        sp->size = size;
 306        sp->complete_handler = complete_handler;
 307        sp->skb = skb;
 308        inc_txqtail(priv);
 309
 310        return 0;
 311
 312err_complete:
 313        kfree(p);
 314        if (complete_handler)
 315                (*complete_handler)(priv, skb);
 316
 317        return ret;
 318}
 319
 320/* write data */
 321static int write_to_device(struct ks_wlan_private *priv, u8 *buffer,
 322                           unsigned long size)
 323{
 324        struct hostif_hdr *hdr;
 325        int ret;
 326
 327        hdr = (struct hostif_hdr *)buffer;
 328
 329        if (le16_to_cpu(hdr->event) < HIF_DATA_REQ ||
 330            le16_to_cpu(hdr->event) > HIF_REQ_MAX) {
 331                netdev_err(priv->net_dev, "unknown event=%04X\n", hdr->event);
 332                return 0;
 333        }
 334
 335        ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
 336        if (ret) {
 337                netdev_err(priv->net_dev, "write DATA_WINDOW\n");
 338                return ret;
 339        }
 340
 341        ret = ks7010_sdio_writeb(priv, WRITE_STATUS_REG, REG_STATUS_BUSY);
 342        if (ret) {
 343                netdev_err(priv->net_dev, "write WRITE_STATUS_REG\n");
 344                return ret;
 345        }
 346
 347        return 0;
 348}
 349
 350static void tx_device_task(struct ks_wlan_private *priv)
 351{
 352        struct tx_device_buffer *sp;
 353        int ret;
 354
 355        if (!txq_has_space(priv) ||
 356            atomic_read(&priv->psstatus.status) == PS_SNOOZE)
 357                return;
 358
 359        sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
 360        if (priv->dev_state >= DEVICE_STATE_BOOT) {
 361                ret = write_to_device(priv, sp->sendp, sp->size);
 362                if (ret) {
 363                        netdev_err(priv->net_dev,
 364                                   "write_to_device error !!(%d)\n", ret);
 365                        queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 366                        return;
 367                }
 368        }
 369        kfree(sp->sendp);
 370        if (sp->complete_handler)       /* TX Complete */
 371                (*sp->complete_handler)(priv, sp->skb);
 372        inc_txqhead(priv);
 373
 374        if (txq_has_space(priv))
 375                queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 376}
 377
 378int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
 379                  void (*complete_handler)(struct ks_wlan_private *priv,
 380                                           struct sk_buff *skb),
 381                  struct sk_buff *skb)
 382{
 383        int result = 0;
 384        struct hostif_hdr *hdr;
 385
 386        hdr = (struct hostif_hdr *)p;
 387
 388        if (le16_to_cpu(hdr->event) < HIF_DATA_REQ ||
 389            le16_to_cpu(hdr->event) > HIF_REQ_MAX) {
 390                netdev_err(priv->net_dev, "unknown event=%04X\n", hdr->event);
 391                return 0;
 392        }
 393
 394        /* add event to hostt buffer */
 395        priv->hostt.buff[priv->hostt.qtail] = le16_to_cpu(hdr->event);
 396        priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
 397
 398        spin_lock(&priv->tx_dev.tx_dev_lock);
 399        result = enqueue_txdev(priv, p, size, complete_handler, skb);
 400        spin_unlock(&priv->tx_dev.tx_dev_lock);
 401
 402        if (txq_has_space(priv))
 403                queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 404
 405        return result;
 406}
 407
 408static void rx_event_task(unsigned long dev)
 409{
 410        struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
 411        struct rx_device_buffer *rp;
 412
 413        if (rxq_has_space(priv) && priv->dev_state >= DEVICE_STATE_BOOT) {
 414                rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
 415                hostif_receive(priv, rp->data, rp->size);
 416                inc_rxqhead(priv);
 417
 418                if (rxq_has_space(priv))
 419                        tasklet_schedule(&priv->rx_bh_task);
 420        }
 421}
 422
 423static void ks_wlan_hw_rx(struct ks_wlan_private *priv, size_t size)
 424{
 425        int ret;
 426        struct rx_device_buffer *rx_buffer;
 427        struct hostif_hdr *hdr;
 428        u16 event = 0;
 429
 430        /* receive data */
 431        if (rxq_count(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
 432                netdev_err(priv->net_dev, "rx buffer overflow\n");
 433                return;
 434        }
 435        rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
 436
 437        ret = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
 438                               hif_align_size(size));
 439        if (ret)
 440                return;
 441
 442        /* length check */
 443        if (size > 2046 || size == 0) {
 444#ifdef DEBUG
 445                print_hex_dump_bytes("INVALID DATA dump: ",
 446                                     DUMP_PREFIX_OFFSET,
 447                                     rx_buffer->data, 32);
 448#endif
 449                ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
 450                if (ret)
 451                        netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
 452
 453                /* length check fail */
 454                return;
 455        }
 456
 457        hdr = (struct hostif_hdr *)&rx_buffer->data[0];
 458        rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
 459        event = le16_to_cpu(hdr->event);
 460        inc_rxqtail(priv);
 461
 462        ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
 463        if (ret)
 464                netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
 465
 466        if (atomic_read(&priv->psstatus.confirm_wait) && is_hif_conf(event)) {
 467                netdev_dbg(priv->net_dev, "IS_HIF_CONF true !!\n");
 468                atomic_dec(&priv->psstatus.confirm_wait);
 469        }
 470
 471        tasklet_schedule(&priv->rx_bh_task);
 472}
 473
 474static void ks7010_rw_function(struct work_struct *work)
 475{
 476        struct ks_wlan_private *priv = container_of(work,
 477                                                    struct ks_wlan_private,
 478                                                    rw_dwork.work);
 479        struct sdio_func *func = ks7010_to_func(priv);
 480        u8 byte;
 481        int ret;
 482
 483        /* wait after DOZE */
 484        if (time_after(priv->last_doze + msecs_to_jiffies(30), jiffies)) {
 485                netdev_dbg(priv->net_dev, "wait after DOZE\n");
 486                queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 487                return;
 488        }
 489
 490        /* wait after WAKEUP */
 491        while (time_after(priv->last_wakeup + msecs_to_jiffies(30), jiffies)) {
 492                netdev_dbg(priv->net_dev, "wait after WAKEUP\n");
 493                dev_info(&func->dev, "wake: %lu %lu\n",
 494                         priv->last_wakeup + msecs_to_jiffies(30), jiffies);
 495                msleep(30);
 496        }
 497
 498        sdio_claim_host(func);
 499
 500        /* power save wakeup */
 501        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 502                if (txq_has_space(priv)) {
 503                        ks_wlan_hw_wakeup_request(priv);
 504                        queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 505                }
 506                goto release_host;
 507        }
 508
 509        /* sleep mode doze */
 510        if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
 511                ks_wlan_hw_sleep_doze_request(priv);
 512                goto release_host;
 513        }
 514        /* sleep mode wakeup */
 515        if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
 516                ks_wlan_hw_sleep_wakeup_request(priv);
 517                goto release_host;
 518        }
 519
 520        /* read (WriteStatus/ReadDataSize FN1:00_0014) */
 521        ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
 522        if (ret) {
 523                netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG psstatus=%d\n",
 524                           atomic_read(&priv->psstatus.status));
 525                goto release_host;
 526        }
 527
 528        if (byte & RSIZE_MASK) {        /* Read schedule */
 529                ks_wlan_hw_rx(priv, (size_t)((byte & RSIZE_MASK) << 4));
 530        }
 531        if ((byte & WSTATUS_MASK))
 532                tx_device_task(priv);
 533
 534        _ks_wlan_hw_power_save(priv);
 535
 536release_host:
 537        sdio_release_host(func);
 538}
 539
 540static void ks_sdio_interrupt(struct sdio_func *func)
 541{
 542        int ret;
 543        struct ks_sdio_card *card;
 544        struct ks_wlan_private *priv;
 545        u8 status, rsize, byte;
 546
 547        card = sdio_get_drvdata(func);
 548        priv = card->priv;
 549
 550        if (priv->dev_state < DEVICE_STATE_BOOT)
 551                goto queue_delayed_work;
 552
 553        ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &status);
 554        if (ret) {
 555                netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
 556                goto queue_delayed_work;
 557        }
 558
 559        /* schedule task for interrupt status */
 560        /* bit7 -> Write General Communication B register */
 561        /* read (General Communication B register) */
 562        /* bit5 -> Write Status Idle */
 563        /* bit2 -> Read Status Busy  */
 564        if (status & INT_GCR_B ||
 565            atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 566                ret = ks7010_sdio_readb(priv, GCR_B_REG, &byte);
 567                if (ret) {
 568                        netdev_err(priv->net_dev, "read GCR_B_REG\n");
 569                        goto queue_delayed_work;
 570                }
 571                if (byte == GCR_B_ACTIVE) {
 572                        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 573                                atomic_set(&priv->psstatus.status, PS_WAKEUP);
 574                                priv->wakeup_count = 0;
 575                        }
 576                        complete(&priv->psstatus.wakeup_wait);
 577                }
 578        }
 579
 580        do {
 581                /* read (WriteStatus/ReadDataSize FN1:00_0014) */
 582                ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
 583                if (ret) {
 584                        netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG\n");
 585                        goto queue_delayed_work;
 586                }
 587                rsize = byte & RSIZE_MASK;
 588                if (rsize != 0)         /* Read schedule */
 589                        ks_wlan_hw_rx(priv, (size_t)(rsize << 4));
 590
 591                if (byte & WSTATUS_MASK) {
 592                        if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 593                                if (txq_has_space(priv)) {
 594                                        ks_wlan_hw_wakeup_request(priv);
 595                                        queue_delayed_work(priv->wq,
 596                                                           &priv->rw_dwork, 1);
 597                                        return;
 598                                }
 599                        } else {
 600                                tx_device_task(priv);
 601                        }
 602                }
 603        } while (rsize);
 604
 605queue_delayed_work:
 606        queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 607}
 608
 609static int trx_device_init(struct ks_wlan_private *priv)
 610{
 611        priv->tx_dev.qhead = 0;
 612        priv->tx_dev.qtail = 0;
 613
 614        priv->rx_dev.qhead = 0;
 615        priv->rx_dev.qtail = 0;
 616
 617        spin_lock_init(&priv->tx_dev.tx_dev_lock);
 618        spin_lock_init(&priv->rx_dev.rx_dev_lock);
 619
 620        tasklet_init(&priv->rx_bh_task, rx_event_task, (unsigned long)priv);
 621
 622        return 0;
 623}
 624
 625static void trx_device_exit(struct ks_wlan_private *priv)
 626{
 627        struct tx_device_buffer *sp;
 628
 629        /* tx buffer clear */
 630        while (txq_has_space(priv)) {
 631                sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
 632                kfree(sp->sendp);
 633                if (sp->complete_handler)       /* TX Complete */
 634                        (*sp->complete_handler)(priv, sp->skb);
 635                inc_txqhead(priv);
 636        }
 637
 638        tasklet_kill(&priv->rx_bh_task);
 639}
 640
 641static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
 642{
 643        int ret;
 644        unsigned char *data_buf;
 645
 646        data_buf = kmemdup(&index, sizeof(u32), GFP_KERNEL);
 647        if (!data_buf)
 648                return -ENOMEM;
 649
 650        ret = ks7010_sdio_write(priv, WRITE_INDEX_REG, data_buf, sizeof(index));
 651        if (ret)
 652                goto err_free_data_buf;
 653
 654        ret = ks7010_sdio_write(priv, READ_INDEX_REG, data_buf, sizeof(index));
 655        if (ret)
 656                goto err_free_data_buf;
 657
 658        return 0;
 659
 660err_free_data_buf:
 661        kfree(data_buf);
 662
 663        return ret;
 664}
 665
 666#define ROM_BUFF_SIZE (64 * 1024)
 667static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
 668                                    u8 *data, unsigned int size)
 669{
 670        int ret;
 671        u8 *read_buf;
 672
 673        read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
 674        if (!read_buf)
 675                return -ENOMEM;
 676
 677        ret = ks7010_sdio_read(priv, address, read_buf, size);
 678        if (ret)
 679                goto err_free_read_buf;
 680
 681        if (memcmp(data, read_buf, size) != 0) {
 682                ret = -EIO;
 683                netdev_err(priv->net_dev, "data compare error (%d)\n", ret);
 684                goto err_free_read_buf;
 685        }
 686
 687        return 0;
 688
 689err_free_read_buf:
 690        kfree(read_buf);
 691
 692        return ret;
 693}
 694
 695static int ks7010_copy_firmware(struct ks_wlan_private *priv,
 696                                const struct firmware *fw_entry)
 697{
 698        unsigned int length;
 699        unsigned int size;
 700        unsigned int offset;
 701        unsigned int n = 0;
 702        u8 *rom_buf;
 703        int ret;
 704
 705        rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
 706        if (!rom_buf)
 707                return -ENOMEM;
 708
 709        length = fw_entry->size;
 710
 711        do {
 712                if (length >= ROM_BUFF_SIZE) {
 713                        size = ROM_BUFF_SIZE;
 714                        length = length - ROM_BUFF_SIZE;
 715                } else {
 716                        size = length;
 717                        length = 0;
 718                }
 719                if (size == 0)
 720                        break;
 721
 722                memcpy(rom_buf, fw_entry->data + n, size);
 723
 724                offset = n;
 725                ret = ks7010_sdio_update_index(priv,
 726                                               KS7010_IRAM_ADDRESS + offset);
 727                if (ret)
 728                        goto free_rom_buf;
 729
 730                ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
 731                if (ret)
 732                        goto free_rom_buf;
 733
 734                ret = ks7010_sdio_data_compare(priv,
 735                                               DATA_WINDOW, rom_buf, size);
 736                if (ret)
 737                        goto free_rom_buf;
 738
 739                n += size;
 740
 741        } while (size);
 742
 743        ret = ks7010_sdio_writeb(priv, GCR_A_REG, GCR_A_REMAP);
 744
 745free_rom_buf:
 746        kfree(rom_buf);
 747        return ret;
 748}
 749
 750static int ks7010_upload_firmware(struct ks_sdio_card *card)
 751{
 752        struct ks_wlan_private *priv = card->priv;
 753        struct sdio_func *func = ks7010_to_func(priv);
 754        unsigned int n;
 755        u8 byte = 0;
 756        int ret;
 757        const struct firmware *fw_entry = NULL;
 758
 759        sdio_claim_host(func);
 760
 761        /* Firmware running ? */
 762        ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
 763        if (ret)
 764                goto release_host;
 765        if (byte == GCR_A_RUN) {
 766                netdev_dbg(priv->net_dev, "MAC firmware running ...\n");
 767                ret = -EBUSY;
 768                goto release_host;
 769        }
 770
 771        ret = request_firmware(&fw_entry, ROM_FILE,
 772                               &func->dev);
 773        if (ret)
 774                goto release_host;
 775
 776        ret = ks7010_copy_firmware(priv, fw_entry);
 777        if (ret)
 778                goto release_firmware;
 779
 780        /* Firmware running check */
 781        for (n = 0; n < 50; ++n) {
 782                usleep_range(10000, 11000);     /* wait_ms(10); */
 783                ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
 784                if (ret)
 785                        goto release_firmware;
 786
 787                if (byte == GCR_A_RUN)
 788                        break;
 789        }
 790        if ((50) <= n) {
 791                netdev_err(priv->net_dev, "firmware can't start\n");
 792                ret = -EIO;
 793                goto release_firmware;
 794        }
 795
 796        ret = 0;
 797
 798 release_firmware:
 799        release_firmware(fw_entry);
 800 release_host:
 801        sdio_release_host(func);
 802
 803        return ret;
 804}
 805
 806static void ks7010_sme_enqueue_events(struct ks_wlan_private *priv)
 807{
 808        static const u16 init_events[] = {
 809                SME_GET_EEPROM_CKSUM, SME_STOP_REQUEST,
 810                SME_RTS_THRESHOLD_REQUEST, SME_FRAGMENTATION_THRESHOLD_REQUEST,
 811                SME_WEP_INDEX_REQUEST, SME_WEP_KEY1_REQUEST,
 812                SME_WEP_KEY2_REQUEST, SME_WEP_KEY3_REQUEST,
 813                SME_WEP_KEY4_REQUEST, SME_WEP_FLAG_REQUEST,
 814                SME_RSN_ENABLED_REQUEST, SME_MODE_SET_REQUEST,
 815                SME_START_REQUEST
 816        };
 817        int ev;
 818
 819        for (ev = 0; ev < ARRAY_SIZE(init_events); ev++)
 820                hostif_sme_enqueue(priv, init_events[ev]);
 821}
 822
 823static void ks7010_card_init(struct ks_wlan_private *priv)
 824{
 825        init_completion(&priv->confirm_wait);
 826
 827        /* get mac address & firmware version */
 828        hostif_sme_enqueue(priv, SME_START);
 829
 830        if (!wait_for_completion_interruptible_timeout
 831            (&priv->confirm_wait, 5 * HZ)) {
 832                netdev_dbg(priv->net_dev, "wait time out!! SME_START\n");
 833        }
 834
 835        if (priv->mac_address_valid && priv->version_size != 0)
 836                priv->dev_state = DEVICE_STATE_PREINIT;
 837
 838        ks7010_sme_enqueue_events(priv);
 839
 840        if (!wait_for_completion_interruptible_timeout
 841            (&priv->confirm_wait, 5 * HZ)) {
 842                netdev_dbg(priv->net_dev, "wait time out!! wireless parameter set\n");
 843        }
 844
 845        if (priv->dev_state >= DEVICE_STATE_PREINIT) {
 846                netdev_dbg(priv->net_dev, "DEVICE READY!!\n");
 847                priv->dev_state = DEVICE_STATE_READY;
 848        }
 849}
 850
 851static void ks7010_init_defaults(struct ks_wlan_private *priv)
 852{
 853        priv->reg.tx_rate = TX_RATE_AUTO;
 854        priv->reg.preamble = LONG_PREAMBLE;
 855        priv->reg.power_mgmt = POWER_MGMT_ACTIVE;
 856        priv->reg.scan_type = ACTIVE_SCAN;
 857        priv->reg.beacon_lost_count = 20;
 858        priv->reg.rts = 2347UL;
 859        priv->reg.fragment = 2346UL;
 860        priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
 861        priv->reg.cts_mode = CTS_MODE_FALSE;
 862        priv->reg.rate_set.body[11] = TX_RATE_54M;
 863        priv->reg.rate_set.body[10] = TX_RATE_48M;
 864        priv->reg.rate_set.body[9] = TX_RATE_36M;
 865        priv->reg.rate_set.body[8] = TX_RATE_18M;
 866        priv->reg.rate_set.body[7] = TX_RATE_9M;
 867        priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
 868        priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
 869        priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
 870        priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
 871        priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
 872        priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
 873        priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
 874        priv->reg.tx_rate = TX_RATE_FULL_AUTO;
 875        priv->reg.rate_set.size = 12;
 876}
 877
 878static int ks7010_sdio_setup_irqs(struct sdio_func *func)
 879{
 880        int ret;
 881
 882        /* interrupt disable */
 883        sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
 884        if (ret)
 885                goto irq_error;
 886
 887        sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
 888        if (ret)
 889                goto irq_error;
 890
 891        /* setup interrupt handler */
 892        ret = sdio_claim_irq(func, ks_sdio_interrupt);
 893
 894irq_error:
 895        return ret;
 896}
 897
 898static void ks7010_sdio_init_irqs(struct sdio_func *func,
 899                                  struct ks_wlan_private *priv)
 900{
 901        u8 byte;
 902        int ret;
 903
 904        /*
 905         * interrupt setting
 906         * clear Interrupt status write
 907         * (ARMtoSD_InterruptPending FN1:00_0024)
 908         */
 909        sdio_claim_host(func);
 910        ret = ks7010_sdio_writeb(priv, INT_PENDING_REG, 0xff);
 911        sdio_release_host(func);
 912        if (ret)
 913                netdev_err(priv->net_dev, "write INT_PENDING_REG\n");
 914
 915        /* enable ks7010sdio interrupt */
 916        byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
 917        sdio_claim_host(func);
 918        ret = ks7010_sdio_writeb(priv, INT_ENABLE_REG, byte);
 919        sdio_release_host(func);
 920        if (ret)
 921                netdev_err(priv->net_dev, "write INT_ENABLE_REG\n");
 922}
 923
 924static void ks7010_private_init(struct ks_wlan_private *priv,
 925                                struct ks_sdio_card *card,
 926                                struct net_device *netdev)
 927{
 928        /* private memory initialize */
 929        priv->if_hw = card;
 930
 931        priv->dev_state = DEVICE_STATE_PREBOOT;
 932        priv->net_dev = netdev;
 933        priv->firmware_version[0] = '\0';
 934        priv->version_size = 0;
 935        priv->last_doze = jiffies;
 936        priv->last_wakeup = jiffies;
 937        memset(&priv->nstats, 0, sizeof(priv->nstats));
 938        memset(&priv->wstats, 0, sizeof(priv->wstats));
 939
 940        /* sleep mode */
 941        atomic_set(&priv->sleepstatus.doze_request, 0);
 942        atomic_set(&priv->sleepstatus.wakeup_request, 0);
 943        atomic_set(&priv->sleepstatus.wakeup_request, 0);
 944
 945        trx_device_init(priv);
 946        hostif_init(priv);
 947        ks_wlan_net_start(netdev);
 948        ks7010_init_defaults(priv);
 949}
 950
 951static int ks7010_sdio_probe(struct sdio_func *func,
 952                             const struct sdio_device_id *device)
 953{
 954        struct ks_wlan_private *priv = NULL;
 955        struct net_device *netdev = NULL;
 956        struct ks_sdio_card *card;
 957        int ret;
 958
 959        card = kzalloc(sizeof(*card), GFP_KERNEL);
 960        if (!card)
 961                return -ENOMEM;
 962
 963        card->func = func;
 964
 965        sdio_claim_host(func);
 966
 967        ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
 968        if (ret)
 969                goto err_free_card;
 970
 971        dev_dbg(&card->func->dev, "multi_block=%d sdio_set_block_size()=%d %d\n",
 972                func->card->cccr.multi_block, func->cur_blksize, ret);
 973
 974        ret = sdio_enable_func(func);
 975        if (ret)
 976                goto err_free_card;
 977
 978        ret = ks7010_sdio_setup_irqs(func);
 979        if (ret)
 980                goto err_disable_func;
 981
 982        sdio_release_host(func);
 983
 984        sdio_set_drvdata(func, card);
 985
 986        dev_dbg(&card->func->dev, "class = 0x%X, vendor = 0x%X, device = 0x%X\n",
 987                func->class, func->vendor, func->device);
 988
 989        /* private memory allocate */
 990        netdev = alloc_etherdev(sizeof(*priv));
 991        if (!netdev) {
 992                dev_err(&card->func->dev, "Unable to alloc new net device\n");
 993                goto err_release_irq;
 994        }
 995
 996        ret = dev_alloc_name(netdev, "wlan%d");
 997        if (ret < 0) {
 998                dev_err(&card->func->dev, "Couldn't get name!\n");
 999                goto err_free_netdev;
1000        }
1001
1002        priv = netdev_priv(netdev);
1003
1004        card->priv = priv;
1005        SET_NETDEV_DEV(netdev, &card->func->dev);
1006
1007        ks7010_private_init(priv, card, netdev);
1008
1009        ret = ks7010_upload_firmware(card);
1010        if (ret) {
1011                netdev_err(priv->net_dev,
1012                           "firmware load failed !! ret = %d\n", ret);
1013                goto err_free_netdev;
1014        }
1015
1016        ks7010_sdio_init_irqs(func, priv);
1017
1018        priv->dev_state = DEVICE_STATE_BOOT;
1019
1020        priv->wq = alloc_workqueue("wq", WQ_MEM_RECLAIM, 1);
1021        if (!priv->wq) {
1022                netdev_err(priv->net_dev, "create_workqueue failed !!\n");
1023                goto err_free_netdev;
1024        }
1025
1026        INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function);
1027        ks7010_card_init(priv);
1028
1029        ret = register_netdev(priv->net_dev);
1030        if (ret)
1031                goto err_free_netdev;
1032
1033        return 0;
1034
1035 err_free_netdev:
1036        free_netdev(netdev);
1037 err_release_irq:
1038        sdio_claim_host(func);
1039        sdio_release_irq(func);
1040 err_disable_func:
1041        sdio_disable_func(func);
1042 err_free_card:
1043        sdio_release_host(func);
1044        sdio_set_drvdata(func, NULL);
1045        kfree(card);
1046
1047        return -ENODEV;
1048}
1049
1050/* send stop request to MAC */
1051static int send_stop_request(struct sdio_func *func)
1052{
1053        struct hostif_stop_request *pp;
1054        struct ks_sdio_card *card;
1055        size_t size;
1056
1057        card = sdio_get_drvdata(func);
1058
1059        pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
1060        if (!pp)
1061                return -ENOMEM;
1062
1063        size = sizeof(*pp) - sizeof(pp->header.size);
1064        pp->header.size = cpu_to_le16(size);
1065        pp->header.event = cpu_to_le16(HIF_STOP_REQ);
1066
1067        sdio_claim_host(func);
1068        write_to_device(card->priv, (u8 *)pp, hif_align_size(sizeof(*pp)));
1069        sdio_release_host(func);
1070
1071        kfree(pp);
1072        return 0;
1073}
1074
1075static void ks7010_sdio_remove(struct sdio_func *func)
1076{
1077        int ret;
1078        struct ks_sdio_card *card;
1079        struct ks_wlan_private *priv;
1080
1081        card = sdio_get_drvdata(func);
1082
1083        if (!card)
1084                return;
1085
1086        priv = card->priv;
1087        if (!priv)
1088                goto err_free_card;
1089
1090        ks_wlan_net_stop(priv->net_dev);
1091
1092        /* interrupt disable */
1093        sdio_claim_host(func);
1094        sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
1095        sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
1096        sdio_release_host(func);
1097
1098        ret = send_stop_request(func);
1099        if (ret)        /* memory allocation failure */
1100                goto err_free_card;
1101
1102        if (priv->wq) {
1103                flush_workqueue(priv->wq);
1104                destroy_workqueue(priv->wq);
1105        }
1106
1107        hostif_exit(priv);
1108
1109        unregister_netdev(priv->net_dev);
1110
1111        trx_device_exit(priv);
1112        free_netdev(priv->net_dev);
1113        card->priv = NULL;
1114
1115        sdio_claim_host(func);
1116        sdio_release_irq(func);
1117        sdio_disable_func(func);
1118        sdio_release_host(func);
1119err_free_card:
1120        sdio_set_drvdata(func, NULL);
1121        kfree(card);
1122}
1123
1124static const struct sdio_device_id ks7010_sdio_ids[] = {
1125        {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
1126        {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
1127        { /* all zero */ }
1128};
1129MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
1130
1131static struct sdio_driver ks7010_sdio_driver = {
1132        .name = "ks7010_sdio",
1133        .id_table = ks7010_sdio_ids,
1134        .probe = ks7010_sdio_probe,
1135        .remove = ks7010_sdio_remove,
1136};
1137
1138module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver);
1139MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream");
1140MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards");
1141MODULE_LICENSE("GPL v2");
1142MODULE_FIRMWARE(ROM_FILE);
1143