aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging/ks7010/ks7010_sdio.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/staging/ks7010/ks7010_sdio.c')
-rw-r--r--drivers/staging/ks7010/ks7010_sdio.c632
1 files changed, 368 insertions, 264 deletions
diff --git a/drivers/staging/ks7010/ks7010_sdio.c b/drivers/staging/ks7010/ks7010_sdio.c
index b8f55a11ee1c..74551eb717fc 100644
--- a/drivers/staging/ks7010/ks7010_sdio.c
+++ b/drivers/staging/ks7010/ks7010_sdio.c
@@ -1,76 +1,126 @@
+// SPDX-License-Identifier: GPL-2.0
/*
* Driver for KeyStream, KS7010 based SDIO cards.
*
* Copyright (C) 2006-2008 KeyStream Corp.
* Copyright (C) 2009 Renesas Technology Corp.
* Copyright (C) 2016 Sang Engineering, Wolfram Sang
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
*/
+#include <linux/atomic.h>
#include <linux/firmware.h>
+#include <linux/jiffies.h>
#include <linux/mmc/card.h>
#include <linux/mmc/sdio_func.h>
+#include <linux/module.h>
#include <linux/workqueue.h>
-#include <linux/atomic.h>
-
#include "ks_wlan.h"
-#include "ks_wlan_ioctl.h"
#include "ks_hostif.h"
-#include "ks7010_sdio.h"
-#define KS7010_FUNC_NUM 1
-#define KS7010_IO_BLOCK_SIZE 512
-#define KS7010_MAX_CLOCK 25000000
+#define ROM_FILE "ks7010sd.rom"
-static const struct sdio_device_id ks7010_sdio_ids[] = {
- {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
- {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
- { /* all zero */ }
+/* SDIO KeyStream vendor and device */
+#define SDIO_VENDOR_ID_KS_CODE_A 0x005b
+#define SDIO_VENDOR_ID_KS_CODE_B 0x0023
+
+/* Older sources suggest earlier versions were named 7910 or 79xx */
+#define SDIO_DEVICE_ID_KS_7010 0x7910
+
+/* Read/Write Status Register */
+#define READ_STATUS_REG 0x000000
+#define WRITE_STATUS_REG 0x00000C
+enum reg_status_type {
+ REG_STATUS_BUSY,
+ REG_STATUS_IDLE
};
-MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
-static inline void inc_txqhead(struct ks_wlan_private *priv)
-{
- priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE;
-}
+/* Read Index Register */
+#define READ_INDEX_REG 0x000004
-static inline void inc_txqtail(struct ks_wlan_private *priv)
-{
- priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE;
-}
+/* Read Data Size Register */
+#define READ_DATA_SIZE_REG 0x000008
-static inline unsigned int cnt_txqbody(struct ks_wlan_private *priv)
-{
- unsigned int tx_cnt = priv->tx_dev.qtail - priv->tx_dev.qhead;
+/* Write Index Register */
+#define WRITE_INDEX_REG 0x000010
- return (tx_cnt + TX_DEVICE_BUFF_SIZE) % TX_DEVICE_BUFF_SIZE;
-}
+/*
+ * Write Status/Read Data Size Register
+ * for network packet (less than 2048 bytes data)
+ */
+#define WSTATUS_RSIZE_REG 0x000014
+
+/* Write Status Register value */
+#define WSTATUS_MASK 0x80
+
+/* Read Data Size Register value [10:4] */
+#define RSIZE_MASK 0x7F
+
+/* ARM to SD interrupt Enable */
+#define INT_ENABLE_REG 0x000020
+/* ARM to SD interrupt Pending */
+#define INT_PENDING_REG 0x000024
+
+#define INT_GCR_B BIT(7)
+#define INT_GCR_A BIT(6)
+#define INT_WRITE_STATUS BIT(5)
+#define INT_WRITE_INDEX BIT(4)
+#define INT_WRITE_SIZE BIT(3)
+#define INT_READ_STATUS BIT(2)
+#define INT_READ_INDEX BIT(1)
+#define INT_READ_SIZE BIT(0)
+
+/* General Communication Register A */
+#define GCR_A_REG 0x000028
+enum gen_com_reg_a {
+ GCR_A_INIT,
+ GCR_A_REMAP,
+ GCR_A_RUN
+};
-static inline void inc_rxqhead(struct ks_wlan_private *priv)
-{
- priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE;
-}
+/* General Communication Register B */
+#define GCR_B_REG 0x00002C
+enum gen_com_reg_b {
+ GCR_B_ACTIVE,
+ GCR_B_DOZE
+};
-static inline void inc_rxqtail(struct ks_wlan_private *priv)
-{
- priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE;
-}
+/* Wakeup Register */
+#define WAKEUP_REG 0x008018
+#define WAKEUP_REQ 0x5a
+
+/* AHB Data Window 0x010000-0x01FFFF */
+#define DATA_WINDOW 0x010000
+#define WINDOW_SIZE (64 * 1024)
-static inline unsigned int cnt_rxqbody(struct ks_wlan_private *priv)
+#define KS7010_IRAM_ADDRESS 0x06000000
+
+#define KS7010_IO_BLOCK_SIZE 512
+
+/**
+ * struct ks_sdio_card - SDIO device data.
+ *
+ * Structure is used as the &struct sdio_func private data.
+ *
+ * @func: Pointer to the SDIO function device.
+ * @priv: Pointer to the &struct net_device private data.
+ */
+struct ks_sdio_card {
+ struct sdio_func *func;
+ struct ks_wlan_private *priv;
+};
+
+static struct sdio_func *ks7010_to_func(struct ks_wlan_private *priv)
{
- unsigned int rx_cnt = priv->rx_dev.qtail - priv->rx_dev.qhead;
+ struct ks_sdio_card *ks_sdio = priv->if_hw;
- return (rx_cnt + RX_DEVICE_BUFF_SIZE) % RX_DEVICE_BUFF_SIZE;
+ return ks_sdio->func;
}
/* Read single byte from device address into byte (CMD52) */
-static int ks7010_sdio_readb(struct ks_wlan_private *priv, unsigned int address,
- unsigned char *byte)
+static int ks7010_sdio_readb(struct ks_wlan_private *priv,
+ u32 address, u8 *byte)
{
- struct sdio_func *func = priv->ks_sdio_card->func;
+ struct sdio_func *func = ks7010_to_func(priv);
int ret;
*byte = sdio_readb(func, address, &ret);
@@ -79,19 +129,19 @@ static int ks7010_sdio_readb(struct ks_wlan_private *priv, unsigned int address,
}
/* Read length bytes from device address into buffer (CMD53) */
-static int ks7010_sdio_read(struct ks_wlan_private *priv, unsigned int address,
- unsigned char *buffer, int length)
+static int ks7010_sdio_read(struct ks_wlan_private *priv, u32 address,
+ u8 *buffer, unsigned int length)
{
- struct sdio_func *func = priv->ks_sdio_card->func;
+ struct sdio_func *func = ks7010_to_func(priv);
return sdio_memcpy_fromio(func, buffer, address, length);
}
/* Write single byte to device address (CMD52) */
static int ks7010_sdio_writeb(struct ks_wlan_private *priv,
- unsigned int address, unsigned char byte)
+ u32 address, u8 byte)
{
- struct sdio_func *func = priv->ks_sdio_card->func;
+ struct sdio_func *func = ks7010_to_func(priv);
int ret;
sdio_writeb(func, byte, address, &ret);
@@ -100,10 +150,10 @@ static int ks7010_sdio_writeb(struct ks_wlan_private *priv,
}
/* Write length bytes to device address from buffer (CMD53) */
-static int ks7010_sdio_write(struct ks_wlan_private *priv, unsigned int address,
- unsigned char *buffer, int length)
+static int ks7010_sdio_write(struct ks_wlan_private *priv, u32 address,
+ u8 *buffer, unsigned int length)
{
- struct sdio_func *func = priv->ks_sdio_card->func;
+ struct sdio_func *func = ks7010_to_func(priv);
return sdio_memcpy_toio(func, address, buffer, length);
}
@@ -116,9 +166,9 @@ static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
atomic_set(&priv->sleepstatus.doze_request, 0);
if (atomic_read(&priv->sleepstatus.status) == 0) {
- ret = ks7010_sdio_writeb(priv, GCR_B, GCR_B_DOZE);
+ ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
if (ret) {
- netdev_err(priv->net_dev, " error : GCR_B\n");
+ netdev_err(priv->net_dev, "write GCR_B_REG\n");
goto set_sleep_mode;
}
atomic_set(&priv->sleepstatus.status, 1);
@@ -137,9 +187,9 @@ static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
atomic_set(&priv->sleepstatus.wakeup_request, 0);
if (atomic_read(&priv->sleepstatus.status) == 1) {
- ret = ks7010_sdio_writeb(priv, WAKEUP, WAKEUP_REQ);
+ ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
if (ret) {
- netdev_err(priv->net_dev, " error : WAKEUP\n");
+ netdev_err(priv->net_dev, "write WAKEUP_REG\n");
goto set_sleep_mode;
}
atomic_set(&priv->sleepstatus.status, 0);
@@ -156,9 +206,9 @@ void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
int ret;
if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
- ret = ks7010_sdio_writeb(priv, WAKEUP, WAKEUP_REQ);
+ ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
if (ret)
- netdev_err(priv->net_dev, " error : WAKEUP\n");
+ netdev_err(priv->net_dev, "write WAKEUP_REG\n");
priv->last_wakeup = jiffies;
++priv->wakeup_count;
@@ -167,7 +217,7 @@ void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
{
- unsigned char byte;
+ u8 byte;
int ret;
if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE)
@@ -185,30 +235,35 @@ static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
if (atomic_read(&priv->psstatus.status) == PS_SNOOZE)
return;
- netdev_dbg(priv->net_dev, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n",
+ netdev_dbg(priv->net_dev,
+ "STATUS:\n"
+ "- psstatus.status = %d\n"
+ "- psstatus.confirm_wait = %d\n"
+ "- psstatus.snooze_guard = %d\n"
+ "- txq_count = %d\n",
atomic_read(&priv->psstatus.status),
atomic_read(&priv->psstatus.confirm_wait),
atomic_read(&priv->psstatus.snooze_guard),
- cnt_txqbody(priv));
+ txq_count(priv));
if (atomic_read(&priv->psstatus.confirm_wait) ||
atomic_read(&priv->psstatus.snooze_guard) ||
- cnt_txqbody(priv)) {
+ txq_has_space(priv)) {
queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
return;
}
- ret = ks7010_sdio_readb(priv, INT_PENDING, &byte);
+ ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &byte);
if (ret) {
- netdev_err(priv->net_dev, " error : INT_PENDING\n");
+ netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
goto queue_delayed_work;
}
if (byte)
goto queue_delayed_work;
- ret = ks7010_sdio_writeb(priv, GCR_B, GCR_B_DOZE);
+ ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
if (ret) {
- netdev_err(priv->net_dev, " error : GCR_B\n");
+ netdev_err(priv->net_dev, "write GCR_B_REG\n");
goto queue_delayed_work;
}
atomic_set(&priv->psstatus.status, PS_SNOOZE);
@@ -239,7 +294,7 @@ static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
goto err_complete;
}
- if ((TX_DEVICE_BUFF_SIZE - 1) <= cnt_txqbody(priv)) {
+ if ((TX_DEVICE_BUFF_SIZE - 1) <= txq_count(priv)) {
netdev_err(priv->net_dev, "tx buffer overflow\n");
ret = -EOVERFLOW;
goto err_complete;
@@ -263,7 +318,7 @@ err_complete:
}
/* write data */
-static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer,
+static int write_to_device(struct ks_wlan_private *priv, u8 *buffer,
unsigned long size)
{
struct hostif_hdr *hdr;
@@ -279,13 +334,13 @@ static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer,
ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
if (ret) {
- netdev_err(priv->net_dev, " write error : retval=%d\n", ret);
+ netdev_err(priv->net_dev, "write DATA_WINDOW\n");
return ret;
}
- ret = ks7010_sdio_writeb(priv, WRITE_STATUS, REG_STATUS_BUSY);
+ ret = ks7010_sdio_writeb(priv, WRITE_STATUS_REG, REG_STATUS_BUSY);
if (ret) {
- netdev_err(priv->net_dev, " error : WRITE_STATUS\n");
+ netdev_err(priv->net_dev, "write WRITE_STATUS_REG\n");
return ret;
}
@@ -297,7 +352,7 @@ static void tx_device_task(struct ks_wlan_private *priv)
struct tx_device_buffer *sp;
int ret;
- if (cnt_txqbody(priv) <= 0 ||
+ if (!txq_has_space(priv) ||
atomic_read(&priv->psstatus.status) == PS_SNOOZE)
return;
@@ -305,7 +360,8 @@ static void tx_device_task(struct ks_wlan_private *priv)
if (priv->dev_state >= DEVICE_STATE_BOOT) {
ret = write_to_device(priv, sp->sendp, sp->size);
if (ret) {
- netdev_err(priv->net_dev, "write_to_device error !!(%d)\n", ret);
+ netdev_err(priv->net_dev,
+ "write_to_device error !!(%d)\n", ret);
queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
return;
}
@@ -315,7 +371,7 @@ static void tx_device_task(struct ks_wlan_private *priv)
(*sp->complete_handler)(priv, sp->skb);
inc_txqhead(priv);
- if (cnt_txqbody(priv) > 0)
+ if (txq_has_space(priv))
queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
}
@@ -343,7 +399,7 @@ int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
result = enqueue_txdev(priv, p, size, complete_handler, skb);
spin_unlock(&priv->tx_dev.tx_dev_lock);
- if (cnt_txqbody(priv) > 0)
+ if (txq_has_space(priv))
queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
return result;
@@ -354,25 +410,25 @@ static void rx_event_task(unsigned long dev)
struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
struct rx_device_buffer *rp;
- if (cnt_rxqbody(priv) > 0 && priv->dev_state >= DEVICE_STATE_BOOT) {
+ if (rxq_has_space(priv) && priv->dev_state >= DEVICE_STATE_BOOT) {
rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
hostif_receive(priv, rp->data, rp->size);
inc_rxqhead(priv);
- if (cnt_rxqbody(priv) > 0)
+ if (rxq_has_space(priv))
tasklet_schedule(&priv->rx_bh_task);
}
}
-static void ks_wlan_hw_rx(struct ks_wlan_private *priv, uint16_t size)
+static void ks_wlan_hw_rx(struct ks_wlan_private *priv, size_t size)
{
int ret;
struct rx_device_buffer *rx_buffer;
struct hostif_hdr *hdr;
- unsigned short event = 0;
+ u16 event = 0;
/* receive data */
- if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
+ if (rxq_count(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
netdev_err(priv->net_dev, "rx buffer overflow\n");
return;
}
@@ -390,9 +446,9 @@ static void ks_wlan_hw_rx(struct ks_wlan_private *priv, uint16_t size)
DUMP_PREFIX_OFFSET,
rx_buffer->data, 32);
#endif
- ret = ks7010_sdio_writeb(priv, READ_STATUS, REG_STATUS_IDLE);
+ ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
if (ret)
- netdev_err(priv->net_dev, " error : READ_STATUS\n");
+ netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
/* length check fail */
return;
@@ -403,15 +459,13 @@ static void ks_wlan_hw_rx(struct ks_wlan_private *priv, uint16_t size)
event = le16_to_cpu(hdr->event);
inc_rxqtail(priv);
- ret = ks7010_sdio_writeb(priv, READ_STATUS, REG_STATUS_IDLE);
+ ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
if (ret)
- netdev_err(priv->net_dev, " error : READ_STATUS\n");
+ netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
- if (atomic_read(&priv->psstatus.confirm_wait)) {
- if (IS_HIF_CONF(event)) {
- netdev_dbg(priv->net_dev, "IS_HIF_CONF true !!\n");
- atomic_dec(&priv->psstatus.confirm_wait);
- }
+ if (atomic_read(&priv->psstatus.confirm_wait) && is_hif_conf(event)) {
+ netdev_dbg(priv->net_dev, "IS_HIF_CONF true !!\n");
+ atomic_dec(&priv->psstatus.confirm_wait);
}
tasklet_schedule(&priv->rx_bh_task);
@@ -419,34 +473,33 @@ static void ks_wlan_hw_rx(struct ks_wlan_private *priv, uint16_t size)
static void ks7010_rw_function(struct work_struct *work)
{
- struct ks_wlan_private *priv;
- unsigned char byte;
+ struct ks_wlan_private *priv = container_of(work,
+ struct ks_wlan_private,
+ rw_dwork.work);
+ struct sdio_func *func = ks7010_to_func(priv);
+ u8 byte;
int ret;
- priv = container_of(work, struct ks_wlan_private, rw_dwork.work);
-
/* wait after DOZE */
- if (time_after(priv->last_doze + ((30 * HZ) / 1000), jiffies)) {
+ if (time_after(priv->last_doze + msecs_to_jiffies(30), jiffies)) {
netdev_dbg(priv->net_dev, "wait after DOZE\n");
queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
return;
}
/* wait after WAKEUP */
- while (time_after(priv->last_wakeup + ((30 * HZ) / 1000), jiffies)) {
+ while (time_after(priv->last_wakeup + msecs_to_jiffies(30), jiffies)) {
netdev_dbg(priv->net_dev, "wait after WAKEUP\n");
- dev_info(&priv->ks_sdio_card->func->dev,
- "wake: %lu %lu\n",
- priv->last_wakeup + (30 * HZ) / 1000,
- jiffies);
+ dev_info(&func->dev, "wake: %lu %lu\n",
+ priv->last_wakeup + msecs_to_jiffies(30), jiffies);
msleep(30);
}
- sdio_claim_host(priv->ks_sdio_card->func);
+ sdio_claim_host(func);
/* power save wakeup */
if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
- if (cnt_txqbody(priv) > 0) {
+ if (txq_has_space(priv)) {
ks_wlan_hw_wakeup_request(priv);
queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
}
@@ -465,15 +518,15 @@ static void ks7010_rw_function(struct work_struct *work)
}
/* read (WriteStatus/ReadDataSize FN1:00_0014) */
- ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE, &byte);
+ ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
if (ret) {
- netdev_err(priv->net_dev, " error : WSTATUS_RSIZE psstatus=%d\n",
+ netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG psstatus=%d\n",
atomic_read(&priv->psstatus.status));
goto release_host;
}
if (byte & RSIZE_MASK) { /* Read schedule */
- ks_wlan_hw_rx(priv, (uint16_t)((byte & RSIZE_MASK) << 4));
+ ks_wlan_hw_rx(priv, (size_t)((byte & RSIZE_MASK) << 4));
}
if ((byte & WSTATUS_MASK))
tx_device_task(priv);
@@ -481,7 +534,7 @@ static void ks7010_rw_function(struct work_struct *work)
_ks_wlan_hw_power_save(priv);
release_host:
- sdio_release_host(priv->ks_sdio_card->func);
+ sdio_release_host(func);
}
static void ks_sdio_interrupt(struct sdio_func *func)
@@ -489,7 +542,7 @@ static void ks_sdio_interrupt(struct sdio_func *func)
int ret;
struct ks_sdio_card *card;
struct ks_wlan_private *priv;
- unsigned char status, rsize, byte;
+ u8 status, rsize, byte;
card = sdio_get_drvdata(func);
priv = card->priv;
@@ -497,9 +550,9 @@ static void ks_sdio_interrupt(struct sdio_func *func)
if (priv->dev_state < DEVICE_STATE_BOOT)
goto queue_delayed_work;
- ret = ks7010_sdio_readb(priv, INT_PENDING, &status);
+ ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &status);
if (ret) {
- netdev_err(priv->net_dev, "error : INT_PENDING\n");
+ netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
goto queue_delayed_work;
}
@@ -510,9 +563,9 @@ static void ks_sdio_interrupt(struct sdio_func *func)
/* bit2 -> Read Status Busy */
if (status & INT_GCR_B ||
atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
- ret = ks7010_sdio_readb(priv, GCR_B, &byte);
+ ret = ks7010_sdio_readb(priv, GCR_B_REG, &byte);
if (ret) {
- netdev_err(priv->net_dev, " error : GCR_B\n");
+ netdev_err(priv->net_dev, "read GCR_B_REG\n");
goto queue_delayed_work;
}
if (byte == GCR_B_ACTIVE) {
@@ -526,20 +579,21 @@ static void ks_sdio_interrupt(struct sdio_func *func)
do {
/* read (WriteStatus/ReadDataSize FN1:00_0014) */
- ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE, &byte);
+ ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
if (ret) {
- netdev_err(priv->net_dev, " error : WSTATUS_RSIZE\n");
+ netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG\n");
goto queue_delayed_work;
}
rsize = byte & RSIZE_MASK;
if (rsize != 0) /* Read schedule */
- ks_wlan_hw_rx(priv, (uint16_t)(rsize << 4));
+ ks_wlan_hw_rx(priv, (size_t)(rsize << 4));
if (byte & WSTATUS_MASK) {
if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
- if (cnt_txqbody(priv)) {
+ if (txq_has_space(priv)) {
ks_wlan_hw_wakeup_request(priv);
- queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
+ queue_delayed_work(priv->wq,
+ &priv->rw_dwork, 1);
return;
}
} else {
@@ -573,7 +627,7 @@ static void trx_device_exit(struct ks_wlan_private *priv)
struct tx_device_buffer *sp;
/* tx buffer clear */
- while (cnt_txqbody(priv) > 0) {
+ while (txq_has_space(priv)) {
sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
kfree(sp->sendp);
if (sp->complete_handler) /* TX Complete */
@@ -589,16 +643,15 @@ static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
int ret;
unsigned char *data_buf;
- data_buf = kmalloc(sizeof(u32), GFP_KERNEL);
+ data_buf = kmemdup(&index, sizeof(u32), GFP_KERNEL);
if (!data_buf)
return -ENOMEM;
- memcpy(data_buf, &index, sizeof(index));
- ret = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index));
+ ret = ks7010_sdio_write(priv, WRITE_INDEX_REG, data_buf, sizeof(index));
if (ret)
goto err_free_data_buf;
- ret = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index));
+ ret = ks7010_sdio_write(priv, READ_INDEX_REG, data_buf, sizeof(index));
if (ret)
goto err_free_data_buf;
@@ -612,10 +665,10 @@ err_free_data_buf:
#define ROM_BUFF_SIZE (64 * 1024)
static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
- unsigned char *data, unsigned int size)
+ u8 *data, unsigned int size)
{
int ret;
- unsigned char *read_buf;
+ u8 *read_buf;
read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
if (!read_buf)
@@ -639,37 +692,22 @@ err_free_read_buf:
return ret;
}
-static int ks7010_upload_firmware(struct ks_sdio_card *card)
+static int ks7010_copy_firmware(struct ks_wlan_private *priv,
+ const struct firmware *fw_entry)
{
- struct ks_wlan_private *priv = card->priv;
- unsigned int size, offset, n = 0;
- unsigned char *rom_buf;
- unsigned char byte = 0;
- int ret;
unsigned int length;
- const struct firmware *fw_entry = NULL;
+ unsigned int size;
+ unsigned int offset;
+ unsigned int n = 0;
+ u8 *rom_buf;
+ int ret;
rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
if (!rom_buf)
return -ENOMEM;
- sdio_claim_host(card->func);
-
- /* Firmware running ? */
- ret = ks7010_sdio_readb(priv, GCR_A, &byte);
- if (byte == GCR_A_RUN) {
- netdev_dbg(priv->net_dev, "MAC firmware running ...\n");
- goto release_host_and_free;
- }
-
- ret = request_firmware(&fw_entry, ROM_FILE,
- &priv->ks_sdio_card->func->dev);
- if (ret)
- goto release_host_and_free;
-
length = fw_entry->size;
- n = 0;
do {
if (length >= ROM_BUFF_SIZE) {
size = ROM_BUFF_SIZE;
@@ -680,33 +718,69 @@ static int ks7010_upload_firmware(struct ks_sdio_card *card)
}
if (size == 0)
break;
+
memcpy(rom_buf, fw_entry->data + n, size);
offset = n;
- ret = ks7010_sdio_update_index(priv, KS7010_IRAM_ADDRESS + offset);
+ ret = ks7010_sdio_update_index(priv,
+ KS7010_IRAM_ADDRESS + offset);
if (ret)
- goto release_firmware;
+ goto free_rom_buf;
ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
if (ret)
- goto release_firmware;
+ goto free_rom_buf;
- ret = ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size);
+ ret = ks7010_sdio_data_compare(priv,
+ DATA_WINDOW, rom_buf, size);
if (ret)
- goto release_firmware;
+ goto free_rom_buf;
n += size;
} while (size);
- ret = ks7010_sdio_writeb(priv, GCR_A, GCR_A_REMAP);
+ ret = ks7010_sdio_writeb(priv, GCR_A_REG, GCR_A_REMAP);
+
+free_rom_buf:
+ kfree(rom_buf);
+ return ret;
+}
+
+static int ks7010_upload_firmware(struct ks_sdio_card *card)
+{
+ struct ks_wlan_private *priv = card->priv;
+ struct sdio_func *func = ks7010_to_func(priv);
+ unsigned int n;
+ u8 byte = 0;
+ int ret;
+ const struct firmware *fw_entry = NULL;
+
+ sdio_claim_host(func);
+
+ /* Firmware running ? */
+ ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
+ if (ret)
+ goto release_host;
+ if (byte == GCR_A_RUN) {
+ netdev_dbg(priv->net_dev, "MAC firmware running ...\n");
+ ret = -EBUSY;
+ goto release_host;
+ }
+
+ ret = request_firmware(&fw_entry, ROM_FILE,
+ &func->dev);
+ if (ret)
+ goto release_host;
+
+ ret = ks7010_copy_firmware(priv, fw_entry);
if (ret)
goto release_firmware;
/* Firmware running check */
for (n = 0; n < 50; ++n) {
- mdelay(10); /* wait_ms(10); */
- ret = ks7010_sdio_readb(priv, GCR_A, &byte);
+ usleep_range(10000, 11000); /* wait_ms(10); */
+ ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
if (ret)
goto release_firmware;
@@ -723,13 +797,29 @@ static int ks7010_upload_firmware(struct ks_sdio_card *card)
release_firmware:
release_firmware(fw_entry);
- release_host_and_free:
- sdio_release_host(card->func);
- kfree(rom_buf);
+ release_host:
+ sdio_release_host(func);
return ret;
}
+static void ks7010_sme_enqueue_events(struct ks_wlan_private *priv)
+{
+ static const u16 init_events[] = {
+ SME_GET_EEPROM_CKSUM, SME_STOP_REQUEST,
+ SME_RTS_THRESHOLD_REQUEST, SME_FRAGMENTATION_THRESHOLD_REQUEST,
+ SME_WEP_INDEX_REQUEST, SME_WEP_KEY1_REQUEST,
+ SME_WEP_KEY2_REQUEST, SME_WEP_KEY3_REQUEST,
+ SME_WEP_KEY4_REQUEST, SME_WEP_FLAG_REQUEST,
+ SME_RSN_ENABLED_REQUEST, SME_MODE_SET_REQUEST,
+ SME_START_REQUEST
+ };
+ int ev;
+
+ for (ev = 0; ev < ARRAY_SIZE(init_events); ev++)
+ hostif_sme_enqueue(priv, init_events[ev]);
+}
+
static void ks7010_card_init(struct ks_wlan_private *priv)
{
init_completion(&priv->confirm_wait);
@@ -745,24 +835,7 @@ static void ks7010_card_init(struct ks_wlan_private *priv)
if (priv->mac_address_valid && priv->version_size != 0)
priv->dev_state = DEVICE_STATE_PREINIT;
- hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM);
-
- /* load initial wireless parameter */
- hostif_sme_enqueue(priv, SME_STOP_REQUEST);
-
- hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
- hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);
-
- hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
- hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
- hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
- hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
- hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);
-
- hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
- hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
- hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
- hostif_sme_enqueue(priv, SME_START_REQUEST);
+ ks7010_sme_enqueue_events(priv);
if (!wait_for_completion_interruptible_timeout
(&priv->confirm_wait, 5 * HZ)) {
@@ -802,18 +875,87 @@ static void ks7010_init_defaults(struct ks_wlan_private *priv)
priv->reg.rate_set.size = 12;
}
+static int ks7010_sdio_setup_irqs(struct sdio_func *func)
+{
+ int ret;
+
+ /* interrupt disable */
+ sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
+ if (ret)
+ goto irq_error;
+
+ sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
+ if (ret)
+ goto irq_error;
+
+ /* setup interrupt handler */
+ ret = sdio_claim_irq(func, ks_sdio_interrupt);
+
+irq_error:
+ return ret;
+}
+
+static void ks7010_sdio_init_irqs(struct sdio_func *func,
+ struct ks_wlan_private *priv)
+{
+ u8 byte;
+ int ret;
+
+ /*
+ * interrupt setting
+ * clear Interrupt status write
+ * (ARMtoSD_InterruptPending FN1:00_0024)
+ */
+ sdio_claim_host(func);
+ ret = ks7010_sdio_writeb(priv, INT_PENDING_REG, 0xff);
+ sdio_release_host(func);
+ if (ret)
+ netdev_err(priv->net_dev, "write INT_PENDING_REG\n");
+
+ /* enable ks7010sdio interrupt */
+ byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
+ sdio_claim_host(func);
+ ret = ks7010_sdio_writeb(priv, INT_ENABLE_REG, byte);
+ sdio_release_host(func);
+ if (ret)
+ netdev_err(priv->net_dev, "write INT_ENABLE_REG\n");
+}
+
+static void ks7010_private_init(struct ks_wlan_private *priv,
+ struct ks_sdio_card *card,
+ struct net_device *netdev)
+{
+ /* private memory initialize */
+ priv->if_hw = card;
+
+ priv->dev_state = DEVICE_STATE_PREBOOT;
+ priv->net_dev = netdev;
+ priv->firmware_version[0] = '\0';
+ priv->version_size = 0;
+ priv->last_doze = jiffies;
+ priv->last_wakeup = jiffies;
+ memset(&priv->nstats, 0, sizeof(priv->nstats));
+ memset(&priv->wstats, 0, sizeof(priv->wstats));
+
+ /* sleep mode */
+ atomic_set(&priv->sleepstatus.doze_request, 0);
+ atomic_set(&priv->sleepstatus.wakeup_request, 0);
+ atomic_set(&priv->sleepstatus.wakeup_request, 0);
+
+ trx_device_init(priv);
+ hostif_init(priv);
+ ks_wlan_net_start(netdev);
+ ks7010_init_defaults(priv);
+}
+
static int ks7010_sdio_probe(struct sdio_func *func,
const struct sdio_device_id *device)
{
- struct ks_wlan_private *priv;
+ struct ks_wlan_private *priv = NULL;
+ struct net_device *netdev = NULL;
struct ks_sdio_card *card;
- struct net_device *netdev;
- unsigned char byte;
int ret;
- priv = NULL;
- netdev = NULL;
-
card = kzalloc(sizeof(*card), GFP_KERNEL);
if (!card)
return -ENOMEM;
@@ -823,6 +965,9 @@ static int ks7010_sdio_probe(struct sdio_func *func,
sdio_claim_host(func);
ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
+ if (ret)
+ goto err_free_card;
+
dev_dbg(&card->func->dev, "multi_block=%d sdio_set_block_size()=%d %d\n",
func->card->cccr.multi_block, func->cur_blksize, ret);
@@ -830,16 +975,7 @@ static int ks7010_sdio_probe(struct sdio_func *func,
if (ret)
goto err_free_card;
- /* interrupt disable */
- sdio_writeb(func, 0, INT_ENABLE, &ret);
- if (ret)
- goto err_free_card;
- sdio_writeb(func, 0xff, INT_PENDING, &ret);
- if (ret)
- goto err_disable_func;
-
- /* setup interrupt handler */
- ret = sdio_claim_irq(func, ks_sdio_interrupt);
+ ret = ks7010_sdio_setup_irqs(func);
if (ret)
goto err_disable_func;
@@ -853,70 +989,35 @@ static int ks7010_sdio_probe(struct sdio_func *func,
/* private memory allocate */
netdev = alloc_etherdev(sizeof(*priv));
if (!netdev) {
- dev_err(&card->func->dev, "ks7010 : Unable to alloc new net device\n");
+ dev_err(&card->func->dev, "Unable to alloc new net device\n");
goto err_release_irq;
}
- if (dev_alloc_name(netdev, "wlan%d") < 0) {
- dev_err(&card->func->dev,
- "ks7010 : Couldn't get name!\n");
+
+ ret = dev_alloc_name(netdev, "wlan%d");
+ if (ret < 0) {
+ dev_err(&card->func->dev, "Couldn't get name!\n");
goto err_free_netdev;
}
priv = netdev_priv(netdev);
card->priv = priv;
- SET_NETDEV_DEV(netdev, &card->func->dev); /* for create sysfs symlinks */
-
- /* private memory initialize */
- priv->ks_sdio_card = card;
-
- priv->dev_state = DEVICE_STATE_PREBOOT;
- priv->net_dev = netdev;
- priv->firmware_version[0] = '\0';
- priv->version_size = 0;
- priv->last_doze = jiffies;
- priv->last_wakeup = jiffies;
- memset(&priv->nstats, 0, sizeof(priv->nstats));
- memset(&priv->wstats, 0, sizeof(priv->wstats));
-
- /* sleep mode */
- atomic_set(&priv->sleepstatus.doze_request, 0);
- atomic_set(&priv->sleepstatus.wakeup_request, 0);
- atomic_set(&priv->sleepstatus.wakeup_request, 0);
+ SET_NETDEV_DEV(netdev, &card->func->dev);
- trx_device_init(priv);
- hostif_init(priv);
- ks_wlan_net_start(netdev);
-
- ks7010_init_defaults(priv);
+ ks7010_private_init(priv, card, netdev);
ret = ks7010_upload_firmware(card);
if (ret) {
netdev_err(priv->net_dev,
- "ks7010: firmware load failed !! return code = %d\n",
- ret);
+ "firmware load failed !! ret = %d\n", ret);
goto err_free_netdev;
}
- /* interrupt setting */
- /* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
- sdio_claim_host(func);
- ret = ks7010_sdio_writeb(priv, INT_PENDING, 0xff);
- sdio_release_host(func);
- if (ret)
- netdev_err(priv->net_dev, " error : INT_PENDING\n");
-
- /* enable ks7010sdio interrupt */
- byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
- sdio_claim_host(func);
- ret = ks7010_sdio_writeb(priv, INT_ENABLE, byte);
- sdio_release_host(func);
- if (ret)
- netdev_err(priv->net_dev, " err : INT_ENABLE\n");
+ ks7010_sdio_init_irqs(func, priv);
priv->dev_state = DEVICE_STATE_BOOT;
- priv->wq = create_workqueue("wq");
+ priv->wq = alloc_workqueue("wq", WQ_MEM_RECLAIM, 1);
if (!priv->wq) {
netdev_err(priv->net_dev, "create_workqueue failed !!\n");
goto err_free_netdev;
@@ -932,8 +1033,7 @@ static int ks7010_sdio_probe(struct sdio_func *func,
return 0;
err_free_netdev:
- free_netdev(priv->net_dev);
- card->priv = NULL;
+ free_netdev(netdev);
err_release_irq:
sdio_claim_host(func);
sdio_release_irq(func);
@@ -950,25 +1050,22 @@ static int ks7010_sdio_probe(struct sdio_func *func,
/* send stop request to MAC */
static int send_stop_request(struct sdio_func *func)
{
- struct hostif_stop_request_t *pp;
+ struct hostif_stop_request *pp;
struct ks_sdio_card *card;
size_t size;
card = sdio_get_drvdata(func);
pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
- if (!pp) {
- netdev_err(card->priv->net_dev, "allocate memory failed..\n");
+ if (!pp)
return -ENOMEM;
- }
size = sizeof(*pp) - sizeof(pp->header.size);
- pp->header.size = cpu_to_le16((uint16_t)size);
- pp->header.event = cpu_to_le16((uint16_t)HIF_STOP_REQ);
+ pp->header.size = cpu_to_le16(size);
+ pp->header.event = cpu_to_le16(HIF_STOP_REQ);
sdio_claim_host(func);
- write_to_device(card->priv, (unsigned char *)pp,
- hif_align_size(sizeof(*pp)));
+ write_to_device(card->priv, (u8 *)pp, hif_align_size(sizeof(*pp)));
sdio_release_host(func);
kfree(pp);
@@ -987,43 +1084,50 @@ static void ks7010_sdio_remove(struct sdio_func *func)
return;
priv = card->priv;
- if (priv) {
- struct net_device *netdev = priv->net_dev;
+ if (!priv)
+ goto err_free_card;
- ks_wlan_net_stop(netdev);
+ ks_wlan_net_stop(priv->net_dev);
- /* interrupt disable */
- sdio_claim_host(func);
- sdio_writeb(func, 0, INT_ENABLE, &ret);
- sdio_writeb(func, 0xff, INT_PENDING, &ret);
- sdio_release_host(func);
+ /* interrupt disable */
+ sdio_claim_host(func);
+ sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
+ sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
+ sdio_release_host(func);
- ret = send_stop_request(func);
- if (ret) /* memory allocation failure */
- return;
+ ret = send_stop_request(func);
+ if (ret) /* memory allocation failure */
+ goto err_free_card;
- if (priv->wq) {
- flush_workqueue(priv->wq);
- destroy_workqueue(priv->wq);
- }
+ if (priv->wq) {
+ flush_workqueue(priv->wq);
+ destroy_workqueue(priv->wq);
+ }
- hostif_exit(priv);
+ hostif_exit(priv);
- unregister_netdev(netdev);
+ unregister_netdev(priv->net_dev);
- trx_device_exit(priv);
- free_netdev(priv->net_dev);
- card->priv = NULL;
- }
+ trx_device_exit(priv);
+ free_netdev(priv->net_dev);
+ card->priv = NULL;
sdio_claim_host(func);
sdio_release_irq(func);
sdio_disable_func(func);
sdio_release_host(func);
+err_free_card:
sdio_set_drvdata(func, NULL);
kfree(card);
}
+static const struct sdio_device_id ks7010_sdio_ids[] = {
+ {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
+ {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
+ { /* all zero */ }
+};
+MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
+
static struct sdio_driver ks7010_sdio_driver = {
.name = "ks7010_sdio",
.id_table = ks7010_sdio_ids,
Copyright © 1996 – 2023 Jason A. Donenfeld. All Rights Reverse Engineered.