diff options
Diffstat (limited to 'drivers/staging/ks7010/ks7010_sdio.c')
| -rw-r--r-- | drivers/staging/ks7010/ks7010_sdio.c | 899 |
1 files changed, 383 insertions, 516 deletions
diff --git a/drivers/staging/ks7010/ks7010_sdio.c b/drivers/staging/ks7010/ks7010_sdio.c index 6f9f746..c325f48 100644 --- a/drivers/staging/ks7010/ks7010_sdio.c +++ b/drivers/staging/ks7010/ks7010_sdio.c @@ -32,8 +32,6 @@ static const struct sdio_device_id ks7010_sdio_ids[] = { }; MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids); -/* macro */ - #define inc_txqhead(priv) \ (priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE) #define inc_txqtail(priv) \ @@ -48,48 +46,51 @@ MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids); #define cnt_rxqbody(priv) \ (((priv->rx_dev.qtail + RX_DEVICE_BUFF_SIZE) - (priv->rx_dev.qhead)) % RX_DEVICE_BUFF_SIZE) +/* 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) +{ + struct sdio_func *func = priv->ks_sdio_card->func; + int ret; + + *byte = sdio_readb(func, address, &ret); + + return ret; +} + +/* 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) { - struct ks_sdio_card *card; - int rc; + struct sdio_func *func = priv->ks_sdio_card->func; - card = priv->ks_wlan_hw.sdio_card; + return sdio_memcpy_fromio(func, buffer, address, length); +} - if (length == 1) /* CMD52 */ - *buffer = sdio_readb(card->func, address, &rc); - else /* CMD53 multi-block transfer */ - rc = sdio_memcpy_fromio(card->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) +{ + struct sdio_func *func = priv->ks_sdio_card->func; + int ret; - if (rc != 0) - DPRINTK(1, "sdio error=%d size=%d\n", rc, length); + sdio_writeb(func, byte, address, &ret); - return rc; + return ret; } +/* 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) { - struct ks_sdio_card *card; - int rc; - - card = priv->ks_wlan_hw.sdio_card; - - if (length == 1) /* CMD52 */ - sdio_writeb(card->func, *buffer, address, &rc); - else /* CMD53 */ - rc = sdio_memcpy_toio(card->func, address, buffer, length); - - if (rc != 0) - DPRINTK(1, "sdio error=%d size=%d\n", rc, length); + struct sdio_func *func = priv->ks_sdio_card->func; - return rc; + return sdio_memcpy_toio(func, address, buffer, length); } static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv) { - unsigned char rw_data; - int retval; + int ret; DPRINTK(4, "\n"); @@ -97,14 +98,11 @@ 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) { - rw_data = GCR_B_DOZE; - retval = - ks7010_sdio_write(priv, GCR_B, &rw_data, sizeof(rw_data)); - if (retval) { - DPRINTK(1, " error : GCR_B=%02X\n", rw_data); - goto out; + ret = ks7010_sdio_writeb(priv, GCR_B, GCR_B_DOZE); + if (ret) { + DPRINTK(1, " error : GCR_B\n"); + goto set_sleep_mode; } - DPRINTK(4, "PMG SET!! : GCR_B=%02X\n", rw_data); DPRINTK(3, "sleep_mode=SLP_SLEEP\n"); atomic_set(&priv->sleepstatus.status, 1); priv->last_doze = jiffies; @@ -112,14 +110,13 @@ static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv) DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode); } - out: +set_sleep_mode: priv->sleep_mode = atomic_read(&priv->sleepstatus.status); } static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv) { - unsigned char rw_data; - int retval; + int ret; DPRINTK(4, "\n"); @@ -127,14 +124,12 @@ 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) { - rw_data = WAKEUP_REQ; - retval = - ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data)); - if (retval) { - DPRINTK(1, " error : WAKEUP=%02X\n", rw_data); - goto out; + ret = ks7010_sdio_writeb(priv, WAKEUP, WAKEUP_REQ); + if (ret) { + DPRINTK(1, " error : WAKEUP\n"); + goto set_sleep_mode; } - DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data); + DPRINTK(4, "wake up : WAKEUP\n"); atomic_set(&priv->sleepstatus.status, 0); priv->last_wakeup = jiffies; ++priv->wakeup_count; @@ -142,24 +137,22 @@ static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv) DPRINTK(1, "sleep_mode=%d\n", priv->sleep_mode); } - out: +set_sleep_mode: priv->sleep_mode = atomic_read(&priv->sleepstatus.status); } void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv) { - unsigned char rw_data; - int retval; + int ret; DPRINTK(4, "\n"); if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { - rw_data = WAKEUP_REQ; - retval = - ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data)); - if (retval) - DPRINTK(1, " error : WAKEUP=%02X\n", rw_data); + ret = ks7010_sdio_writeb(priv, WAKEUP, WAKEUP_REQ); + if (ret) + DPRINTK(1, " error : WAKEUP\n"); + else + DPRINTK(4, "wake up : WAKEUP\n"); - DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data); priv->last_wakeup = jiffies; ++priv->wakeup_count; } else { @@ -168,131 +161,110 @@ void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv) } } -static int _ks_wlan_hw_power_save(struct ks_wlan_private *priv) +static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv) { - unsigned char rw_data; - int retval; + unsigned char byte; + int ret; - if (priv->reg.powermgt == POWMGT_ACTIVE_MODE) - return 0; + if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE) + return; - if (priv->reg.operation_mode == MODE_INFRASTRUCTURE && - (priv->connect_status & CONNECT_STATUS_MASK) == CONNECT_STATUS) { - if (priv->dev_state == DEVICE_STATE_SLEEP) { - switch (atomic_read(&priv->psstatus.status)) { - case PS_SNOOZE: /* 4 */ - break; - default: - DPRINTK(5, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n", - atomic_read(&priv->psstatus.status), - atomic_read(&priv->psstatus.confirm_wait), - atomic_read(&priv->psstatus.snooze_guard), - cnt_txqbody(priv)); - - if (!atomic_read(&priv->psstatus.confirm_wait) - && !atomic_read(&priv->psstatus.snooze_guard) - && !cnt_txqbody(priv)) { - retval = - ks7010_sdio_read(priv, INT_PENDING, - &rw_data, - sizeof(rw_data)); - if (retval) { - DPRINTK(1, - " error : INT_PENDING=%02X\n", - rw_data); - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); - break; - } - if (!rw_data) { - rw_data = GCR_B_DOZE; - retval = - ks7010_sdio_write(priv, - GCR_B, - &rw_data, - sizeof(rw_data)); - if (retval) { - DPRINTK(1, - " error : GCR_B=%02X\n", - rw_data); - queue_delayed_work - (priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); - break; - } - DPRINTK(4, - "PMG SET!! : GCR_B=%02X\n", - rw_data); - atomic_set(&priv->psstatus. - status, PS_SNOOZE); - DPRINTK(3, - "psstatus.status=PS_SNOOZE\n"); - } else { - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); - } - } else { - queue_delayed_work(priv->ks_wlan_hw. - ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, - 0); - } - break; - } - } + if (priv->reg.operation_mode != MODE_INFRASTRUCTURE) + return; + + if (!is_connect_status(priv->connect_status)) + return; + + if (priv->dev_state != DEVICE_STATE_SLEEP) + return; + + if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) + return; + + DPRINTK(5, "\npsstatus.status=%d\npsstatus.confirm_wait=%d\npsstatus.snooze_guard=%d\ncnt_txqbody=%d\n", + atomic_read(&priv->psstatus.status), + atomic_read(&priv->psstatus.confirm_wait), + atomic_read(&priv->psstatus.snooze_guard), + cnt_txqbody(priv)); + + if (atomic_read(&priv->psstatus.confirm_wait) || + atomic_read(&priv->psstatus.snooze_guard) || + cnt_txqbody(priv)) { + queue_delayed_work(priv->wq, &priv->rw_dwork, 0); + return; } - return 0; + ret = ks7010_sdio_readb(priv, INT_PENDING, &byte); + if (ret) { + DPRINTK(1, " error : INT_PENDING\n"); + goto queue_delayed_work; + } + if (byte) + goto queue_delayed_work; + + ret = ks7010_sdio_writeb(priv, GCR_B, GCR_B_DOZE); + if (ret) { + DPRINTK(1, " error : GCR_B\n"); + goto queue_delayed_work; + } + atomic_set(&priv->psstatus.status, PS_SNOOZE); + DPRINTK(3, "psstatus.status=PS_SNOOZE\n"); + + return; + +queue_delayed_work: + queue_delayed_work(priv->wq, &priv->rw_dwork, 1); } int ks_wlan_hw_power_save(struct ks_wlan_private *priv) { - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); + queue_delayed_work(priv->wq, &priv->rw_dwork, 1); return 0; } static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p, unsigned long size, - void (*complete_handler)(void *arg1, void *arg2), - void *arg1, void *arg2) + void (*complete_handler)(struct ks_wlan_private *priv, + struct sk_buff *skb), + struct sk_buff *skb) { struct tx_device_buffer *sp; + int ret; if (priv->dev_state < DEVICE_STATE_BOOT) { - kfree(p); - if (complete_handler) - (*complete_handler) (arg1, arg2); - return 1; + ret = -EPERM; + goto err_complete; } if ((TX_DEVICE_BUFF_SIZE - 1) <= cnt_txqbody(priv)) { - /* in case of buffer overflow */ DPRINTK(1, "tx buffer overflow\n"); - kfree(p); - if (complete_handler) - (*complete_handler) (arg1, arg2); - return 1; + ret = -EOVERFLOW; + goto err_complete; } sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail]; sp->sendp = p; sp->size = size; sp->complete_handler = complete_handler; - sp->arg1 = arg1; - sp->arg2 = arg2; + sp->skb = skb; inc_txqtail(priv); return 0; + +err_complete: + kfree(p); + if (complete_handler) + (*complete_handler)(priv, skb); + + return ret; } /* write data */ static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer, unsigned long size) { - int retval; - unsigned char rw_data; struct hostif_hdr *hdr; + int ret; hdr = (struct hostif_hdr *)buffer; @@ -302,59 +274,53 @@ static int write_to_device(struct ks_wlan_private *priv, unsigned char *buffer, return 0; } - retval = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size); - if (retval) { - DPRINTK(1, " write error : retval=%d\n", retval); - return -4; + ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size); + if (ret) { + DPRINTK(1, " write error : retval=%d\n", ret); + return ret; } - rw_data = WRITE_STATUS_BUSY; - retval = - ks7010_sdio_write(priv, WRITE_STATUS, &rw_data, sizeof(rw_data)); - if (retval) { - DPRINTK(1, " error : WRITE_STATUS=%02X\n", rw_data); - return -3; + ret = ks7010_sdio_writeb(priv, WRITE_STATUS, REG_STATUS_BUSY); + if (ret) { + DPRINTK(1, " error : WRITE_STATUS\n"); + return ret; } return 0; } -static void tx_device_task(void *dev) +static void tx_device_task(struct ks_wlan_private *priv) { - struct ks_wlan_private *priv = (struct ks_wlan_private *)dev; struct tx_device_buffer *sp; - int rc = 0; + int ret; DPRINTK(4, "\n"); - if (cnt_txqbody(priv) > 0 - && atomic_read(&priv->psstatus.status) != PS_SNOOZE) { - sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead]; - if (priv->dev_state >= DEVICE_STATE_BOOT) { - rc = write_to_device(priv, sp->sendp, sp->size); - if (rc) { - DPRINTK(1, "write_to_device error !!(%d)\n", - rc); - queue_delayed_work(priv->ks_wlan_hw. - ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); - return; - } - } - kfree(sp->sendp); /* allocated memory free */ - if (sp->complete_handler) /* TX Complete */ - (*sp->complete_handler) (sp->arg1, sp->arg2); - inc_txqhead(priv); + if (cnt_txqbody(priv) <= 0 || + atomic_read(&priv->psstatus.status) == PS_SNOOZE) + return; - if (cnt_txqbody(priv) > 0) { - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 0); + sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead]; + if (priv->dev_state >= DEVICE_STATE_BOOT) { + ret = write_to_device(priv, sp->sendp, sp->size); + if (ret) { + DPRINTK(1, "write_to_device error !!(%d)\n", ret); + queue_delayed_work(priv->wq, &priv->rw_dwork, 1); + return; } } + kfree(sp->sendp); + if (sp->complete_handler) /* TX Complete */ + (*sp->complete_handler)(priv, sp->skb); + inc_txqhead(priv); + + if (cnt_txqbody(priv) > 0) + queue_delayed_work(priv->wq, &priv->rw_dwork, 0); } int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size, - void (*complete_handler)(void *arg1, void *arg2), - void *arg1, void *arg2) + void (*complete_handler)(struct ks_wlan_private *priv, + struct sk_buff *skb), + struct sk_buff *skb) { int result = 0; struct hostif_hdr *hdr; @@ -372,13 +338,12 @@ int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size, DPRINTK(4, "event=%04X\n", hdr->event); spin_lock(&priv->tx_dev.tx_dev_lock); - result = enqueue_txdev(priv, p, size, complete_handler, arg1, arg2); + result = enqueue_txdev(priv, p, size, complete_handler, skb); spin_unlock(&priv->tx_dev.tx_dev_lock); - if (cnt_txqbody(priv) > 0) { - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 0); - } + if (cnt_txqbody(priv) > 0) + queue_delayed_work(priv->wq, &priv->rw_dwork, 0); + return result; } @@ -395,34 +360,30 @@ static void rx_event_task(unsigned long dev) inc_rxqhead(priv); if (cnt_rxqbody(priv) > 0) - tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task); + tasklet_schedule(&priv->rx_bh_task); } } -static void ks_wlan_hw_rx(void *dev, uint16_t size) +static void ks_wlan_hw_rx(struct ks_wlan_private *priv, uint16_t size) { - struct ks_wlan_private *priv = (struct ks_wlan_private *)dev; - int retval; + int ret; struct rx_device_buffer *rx_buffer; struct hostif_hdr *hdr; - unsigned char read_status; unsigned short event = 0; DPRINTK(4, "\n"); /* receive data */ if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) { - /* in case of buffer overflow */ DPRINTK(1, "rx buffer overflow\n"); - goto error_out; + return; } rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail]; - retval = - ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0], - hif_align_size(size)); - if (retval) - goto error_out; + ret = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0], + hif_align_size(size)); + if (ret) + return; /* length check */ if (size > 2046 || size == 0) { @@ -432,15 +393,12 @@ static void ks_wlan_hw_rx(void *dev, uint16_t size) DUMP_PREFIX_OFFSET, rx_buffer->data, 32); #endif - /* rx_status update */ - read_status = READ_STATUS_IDLE; - retval = - ks7010_sdio_write(priv, READ_STATUS, &read_status, - sizeof(read_status)); - if (retval) - DPRINTK(1, " error : READ_STATUS=%02X\n", read_status); - - goto error_out; + ret = ks7010_sdio_writeb(priv, READ_STATUS, REG_STATUS_IDLE); + if (ret) + DPRINTK(1, " error : READ_STATUS\n"); + + /* length check fail */ + return; } hdr = (struct hostif_hdr *)&rx_buffer->data[0]; @@ -448,15 +406,9 @@ static void ks_wlan_hw_rx(void *dev, uint16_t size) event = hdr->event; inc_rxqtail(priv); - /* read status update */ - read_status = READ_STATUS_IDLE; - retval = - ks7010_sdio_write(priv, READ_STATUS, &read_status, - sizeof(read_status)); - if (retval) - DPRINTK(1, " error : READ_STATUS=%02X\n", read_status); - - DPRINTK(4, "READ_STATUS=%02X\n", read_status); + ret = ks7010_sdio_writeb(priv, READ_STATUS, REG_STATUS_IDLE); + if (ret) + DPRINTK(1, " error : READ_STATUS\n"); if (atomic_read(&priv->psstatus.confirm_wait)) { if (IS_HIF_CONF(event)) { @@ -465,213 +417,162 @@ static void ks_wlan_hw_rx(void *dev, uint16_t size) } } - /* rx_event_task((void *)priv); */ - tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task); - - error_out: - return; + tasklet_schedule(&priv->rx_bh_task); } static void ks7010_rw_function(struct work_struct *work) { - struct hw_info_t *hw; struct ks_wlan_private *priv; - unsigned char rw_data; - int retval; + unsigned char byte; + int ret; - hw = container_of(work, struct hw_info_t, rw_wq.work); - priv = container_of(hw, struct ks_wlan_private, ks_wlan_hw); + priv = container_of(work, struct ks_wlan_private, rw_dwork.work); DPRINTK(4, "\n"); - /* wiat after DOZE */ + /* wait after DOZE */ if (time_after(priv->last_doze + ((30 * HZ) / 1000), jiffies)) { DPRINTK(4, "wait after DOZE\n"); - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); + queue_delayed_work(priv->wq, &priv->rw_dwork, 1); return; } - /* wiat after WAKEUP */ + /* wait after WAKEUP */ while (time_after(priv->last_wakeup + ((30 * HZ) / 1000), jiffies)) { DPRINTK(4, "wait after WAKEUP\n"); -/* queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, - (priv->last_wakeup + ((30*HZ)/1000) - jiffies));*/ - dev_info(&priv->ks_wlan_hw.sdio_card->func->dev, + dev_info(&priv->ks_sdio_card->func->dev, "wake: %lu %lu\n", priv->last_wakeup + (30 * HZ) / 1000, jiffies); msleep(30); } - sdio_claim_host(priv->ks_wlan_hw.sdio_card->func); + sdio_claim_host(priv->ks_sdio_card->func); /* power save wakeup */ if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { if (cnt_txqbody(priv) > 0) { ks_wlan_hw_wakeup_request(priv); - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 1); + queue_delayed_work(priv->wq, &priv->rw_dwork, 1); } - goto err_out; + goto release_host; } /* sleep mode doze */ if (atomic_read(&priv->sleepstatus.doze_request) == 1) { ks_wlan_hw_sleep_doze_request(priv); - goto err_out; + goto release_host; } /* sleep mode wakeup */ if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) { ks_wlan_hw_sleep_wakeup_request(priv); - goto err_out; + goto release_host; } /* read (WriteStatus/ReadDataSize FN1:00_0014) */ - retval = - ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, sizeof(rw_data)); - if (retval) { - DPRINTK(1, " error : WSTATUS_RSIZE=%02X psstatus=%d\n", rw_data, + ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE, &byte); + if (ret) { + DPRINTK(1, " error : WSTATUS_RSIZE psstatus=%d\n", atomic_read(&priv->psstatus.status)); - goto err_out; + goto release_host; } - DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data); + DPRINTK(4, "WSTATUS_RSIZE=%02X\n", byte); - if (rw_data & RSIZE_MASK) { /* Read schedule */ - ks_wlan_hw_rx((void *)priv, - (uint16_t)((rw_data & RSIZE_MASK) << 4)); + if (byte & RSIZE_MASK) { /* Read schedule */ + ks_wlan_hw_rx(priv, (uint16_t)((byte & RSIZE_MASK) << 4)); } - if ((rw_data & WSTATUS_MASK)) - tx_device_task((void *)priv); + if ((byte & WSTATUS_MASK)) + tx_device_task(priv); _ks_wlan_hw_power_save(priv); - err_out: - sdio_release_host(priv->ks_wlan_hw.sdio_card->func); +release_host: + sdio_release_host(priv->ks_sdio_card->func); } static void ks_sdio_interrupt(struct sdio_func *func) { - int retval; + int ret; struct ks_sdio_card *card; struct ks_wlan_private *priv; - unsigned char status, rsize, rw_data; + unsigned char status, rsize, byte; card = sdio_get_drvdata(func); priv = card->priv; DPRINTK(4, "\n"); - if (priv->dev_state >= DEVICE_STATE_BOOT) { - retval = - ks7010_sdio_read(priv, INT_PENDING, &status, - sizeof(status)); - if (retval) { - DPRINTK(1, "read INT_PENDING Failed!!(%d)\n", retval); - goto intr_out; + if (priv->dev_state < DEVICE_STATE_BOOT) + goto queue_delayed_work; + + ret = ks7010_sdio_readb(priv, INT_PENDING, &status); + if (ret) { + DPRINTK(1, "error : INT_PENDING\n"); + goto queue_delayed_work; + } + DPRINTK(4, "INT_PENDING=%02X\n", status); + + /* schedule task for interrupt status */ + /* bit7 -> Write General Communication B register */ + /* read (General Communication B register) */ + /* bit5 -> Write Status Idle */ + /* bit2 -> Read Status Busy */ + if (status & INT_GCR_B || + atomic_read(&priv->psstatus.status) == PS_SNOOZE) { + ret = ks7010_sdio_readb(priv, GCR_B, &byte); + if (ret) { + DPRINTK(1, " error : GCR_B\n"); + goto queue_delayed_work; } - DPRINTK(4, "INT_PENDING=%02X\n", rw_data); - - /* schedule task for interrupt status */ - /* bit7 -> Write General Communication B register */ - /* read (General Communication B register) */ - /* bit5 -> Write Status Idle */ - /* bit2 -> Read Status Busy */ - if (status & INT_GCR_B - || atomic_read(&priv->psstatus.status) == PS_SNOOZE) { - retval = - ks7010_sdio_read(priv, GCR_B, &rw_data, - sizeof(rw_data)); - if (retval) { - DPRINTK(1, " error : GCR_B=%02X\n", rw_data); - goto intr_out; - } - /* DPRINTK(1, "GCR_B=%02X\n", rw_data); */ - if (rw_data == GCR_B_ACTIVE) { - if (atomic_read(&priv->psstatus.status) == - PS_SNOOZE) { - atomic_set(&priv->psstatus.status, - PS_WAKEUP); - priv->wakeup_count = 0; - } - complete(&priv->psstatus.wakeup_wait); + if (byte == GCR_B_ACTIVE) { + if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { + atomic_set(&priv->psstatus.status, PS_WAKEUP); + priv->wakeup_count = 0; } + complete(&priv->psstatus.wakeup_wait); } + } - do { - /* read (WriteStatus/ReadDataSize FN1:00_0014) */ - retval = - ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, - sizeof(rw_data)); - if (retval) { - DPRINTK(1, " error : WSTATUS_RSIZE=%02X\n", - rw_data); - goto intr_out; - } - DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data); - rsize = rw_data & RSIZE_MASK; - if (rsize) { /* Read schedule */ - ks_wlan_hw_rx((void *)priv, - (uint16_t)(rsize << 4)); - } - if (rw_data & WSTATUS_MASK) { -#if 0 - if (status & INT_WRITE_STATUS - && !cnt_txqbody(priv)) { - /* dummy write for interrupt clear */ - rw_data = 0; - retval = - ks7010_sdio_write(priv, DATA_WINDOW, - &rw_data, - sizeof(rw_data)); - if (retval) { - DPRINTK(1, - "write DATA_WINDOW Failed!!(%d)\n", - retval); - } - status &= ~INT_WRITE_STATUS; - } else { -#endif - if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { - if (cnt_txqbody(priv)) { - ks_wlan_hw_wakeup_request(priv); - queue_delayed_work - (priv->ks_wlan_hw. - ks7010sdio_wq, - &priv->ks_wlan_hw. - rw_wq, 1); - return; - } - } else { - tx_device_task((void *)priv); - } -#if 0 + do { + /* read (WriteStatus/ReadDataSize FN1:00_0014) */ + ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE, &byte); + if (ret) { + DPRINTK(1, " error : WSTATUS_RSIZE\n"); + goto queue_delayed_work; + } + DPRINTK(4, "WSTATUS_RSIZE=%02X\n", byte); + rsize = byte & RSIZE_MASK; + if (rsize != 0) /* Read schedule */ + ks_wlan_hw_rx(priv, (uint16_t)(rsize << 4)); + + if (byte & WSTATUS_MASK) { + if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) { + if (cnt_txqbody(priv)) { + ks_wlan_hw_wakeup_request(priv); + queue_delayed_work(priv->wq, &priv->rw_dwork, 1); + return; } -#endif + } else { + tx_device_task(priv); } - } while (rsize); - } + } + } while (rsize); - intr_out: - queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, - &priv->ks_wlan_hw.rw_wq, 0); +queue_delayed_work: + queue_delayed_work(priv->wq, &priv->rw_dwork, 0); } static int trx_device_init(struct ks_wlan_private *priv) { - /* initialize values (tx) */ priv->tx_dev.qhead = 0; priv->tx_dev.qtail = 0; - /* initialize values (rx) */ priv->rx_dev.qhead = 0; priv->rx_dev.qtail = 0; - /* initialize spinLock (tx,rx) */ spin_lock_init(&priv->tx_dev.tx_dev_lock); spin_lock_init(&priv->rx_dev.rx_dev_lock); - tasklet_init(&priv->ks_wlan_hw.rx_bh_task, rx_event_task, - (unsigned long)priv); + tasklet_init(&priv->rx_bh_task, rx_event_task, (unsigned long)priv); return 0; } @@ -683,106 +584,100 @@ static void trx_device_exit(struct ks_wlan_private *priv) /* tx buffer clear */ while (cnt_txqbody(priv) > 0) { sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead]; - kfree(sp->sendp); /* allocated memory free */ + kfree(sp->sendp); if (sp->complete_handler) /* TX Complete */ - (*sp->complete_handler) (sp->arg1, sp->arg2); + (*sp->complete_handler)(priv, sp->skb); inc_txqhead(priv); } - tasklet_kill(&priv->ks_wlan_hw.rx_bh_task); + tasklet_kill(&priv->rx_bh_task); } static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index) { - int rc = 0; - int retval; + int ret; unsigned char *data_buf; data_buf = kmalloc(sizeof(u32), GFP_KERNEL); - if (!data_buf) { - rc = 1; - goto error_out; - } + if (!data_buf) + return -ENOMEM; memcpy(data_buf, &index, sizeof(index)); - retval = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index)); - if (retval) { - rc = 2; - goto error_out; - } + ret = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index)); + if (ret) + goto err_free_data_buf; - retval = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index)); - if (retval) { - rc = 3; - goto error_out; - } - error_out: + ret = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index)); + if (ret) + goto err_free_data_buf; + + return 0; + +err_free_data_buf: kfree(data_buf); - return rc; + + return ret; } #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) { - int rc = 0; - int retval; + int ret; unsigned char *read_buf; read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL); - if (!read_buf) { - rc = 1; - goto error_out; - } - retval = ks7010_sdio_read(priv, address, read_buf, size); - if (retval) { - rc = 2; - goto error_out; - } - retval = memcmp(data, read_buf, size); + if (!read_buf) + return -ENOMEM; - if (retval) { - DPRINTK(0, "data compare error (%d)\n", retval); - rc = 3; - goto error_out; + ret = ks7010_sdio_read(priv, address, read_buf, size); + if (ret) + goto err_free_read_buf; + + if (memcmp(data, read_buf, size) != 0) { + ret = -EIO; + DPRINTK(0, "data compare error (%d)\n", ret); + goto err_free_read_buf; } - error_out: + + return 0; + +err_free_read_buf: kfree(read_buf); - return rc; + + return ret; } -static int ks7010_upload_firmware(struct ks_wlan_private *priv, - struct ks_sdio_card *card) +static int ks7010_upload_firmware(struct ks_sdio_card *card) { + struct ks_wlan_private *priv = card->priv; unsigned int size, offset, n = 0; unsigned char *rom_buf; - unsigned char rw_data = 0; - int retval, rc = 0; - int length; + unsigned char byte = 0; + int ret; + unsigned int length; const struct firmware *fw_entry = NULL; - /* buffer allocate */ rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL); if (!rom_buf) - return 3; + return -ENOMEM; sdio_claim_host(card->func); /* Firmware running ? */ - retval = ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data)); - if (rw_data == GCR_A_RUN) { + ret = ks7010_sdio_readb(priv, GCR_A, &byte); + if (byte == GCR_A_RUN) { DPRINTK(0, "MAC firmware running ...\n"); - rc = 0; - goto error_out0; + goto release_host_and_free; } - retval = request_firmware(&fw_entry, ROM_FILE, &priv->ks_wlan_hw.sdio_card->func->dev); - if (retval) - goto error_out0; + ret = request_firmware(&fw_entry, ROM_FILE, + &priv->ks_sdio_card->func->dev); + if (ret) + goto release_host_and_free; length = fw_entry->size; - /* Load Program */ n = 0; do { if (length >= ROM_BUFF_SIZE) { @@ -796,77 +691,62 @@ static int ks7010_upload_firmware(struct ks_wlan_private *priv, if (size == 0) break; memcpy(rom_buf, fw_entry->data + n, size); - /* Update write index */ + offset = n; - retval = - ks7010_sdio_update_index(priv, - KS7010_IRAM_ADDRESS + offset); - if (retval) { - rc = 6; - goto error_out1; - } + ret = ks7010_sdio_update_index(priv, KS7010_IRAM_ADDRESS + offset); + if (ret) + goto release_firmware; - /* Write data */ - retval = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size); - if (retval) { - rc = 8; - goto error_out1; - } + ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size); + if (ret) + goto release_firmware; + + ret = ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size); + if (ret) + goto release_firmware; - /* compare */ - retval = - ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size); - if (retval) { - rc = 9; - goto error_out1; - } n += size; } while (size); - /* Remap request */ - rw_data = GCR_A_REMAP; - retval = ks7010_sdio_write(priv, GCR_A, &rw_data, sizeof(rw_data)); - if (retval) { - rc = 11; - goto error_out1; - } - DPRINTK(4, " REMAP Request : GCR_A=%02X\n", rw_data); + ret = ks7010_sdio_writeb(priv, GCR_A, GCR_A_REMAP); + if (ret) + goto release_firmware; + + DPRINTK(4, " REMAP Request : GCR_A\n"); /* Firmware running check */ for (n = 0; n < 50; ++n) { mdelay(10); /* wait_ms(10); */ - retval = - ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data)); - if (retval) { - rc = 11; - goto error_out1; - } - if (rw_data == GCR_A_RUN) + ret = ks7010_sdio_readb(priv, GCR_A, &byte); + if (ret) + goto release_firmware; + + if (byte == GCR_A_RUN) break; } DPRINTK(4, "firmware wakeup (%d)!!!!\n", n); if ((50) <= n) { DPRINTK(1, "firmware can't start\n"); - rc = 12; - goto error_out1; + ret = -EIO; + goto release_firmware; } - rc = 0; + ret = 0; - error_out1: + release_firmware: release_firmware(fw_entry); - error_out0: + release_host_and_free: sdio_release_host(card->func); kfree(rom_buf); - return rc; + + return ret; } static void ks7010_card_init(struct ks_wlan_private *priv) { DPRINTK(5, "\ncard_init_task()\n"); - /* init_waitqueue_head(&priv->confirm_wait); */ init_completion(&priv->confirm_wait); DPRINTK(5, "init_completion()\n"); @@ -881,7 +761,7 @@ static void ks7010_card_init(struct ks_wlan_private *priv) DPRINTK(1, "wait time out!! SME_START\n"); } - if (priv->mac_address_valid && priv->version_size) + if (priv->mac_address_valid && priv->version_size != 0) priv->dev_state = DEVICE_STATE_PREINIT; hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM); @@ -920,7 +800,7 @@ static void ks7010_init_defaults(struct ks_wlan_private *priv) { priv->reg.tx_rate = TX_RATE_AUTO; priv->reg.preamble = LONG_PREAMBLE; - priv->reg.powermgt = POWMGT_ACTIVE_MODE; + priv->reg.power_mgmt = POWER_MGMT_ACTIVE; priv->reg.scan_type = ACTIVE_SCAN; priv->reg.beacon_lost_count = 20; priv->reg.rts = 2347UL; @@ -949,7 +829,7 @@ static int ks7010_sdio_probe(struct sdio_func *func, struct ks_wlan_private *priv; struct ks_sdio_card *card; struct net_device *netdev; - unsigned char rw_data; + unsigned char byte; int ret; DPRINTK(5, "ks7010_sdio_probe()\n"); @@ -957,63 +837,53 @@ static int ks7010_sdio_probe(struct sdio_func *func, priv = NULL; netdev = NULL; - /* initialize ks_sdio_card */ card = kzalloc(sizeof(*card), GFP_KERNEL); if (!card) return -ENOMEM; card->func = func; - spin_lock_init(&card->lock); - /*** Initialize SDIO ***/ sdio_claim_host(func); - /* bus setting */ - /* Issue config request to override clock rate */ - - /* function blocksize set */ ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE); DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n", func->card->cccr.multi_block, func->cur_blksize, ret); - /* Allocate the slot current */ - - /* function enable */ ret = sdio_enable_func(func); DPRINTK(5, "sdio_enable_func() %d\n", ret); if (ret) - goto error_free_card; + goto err_free_card; /* interrupt disable */ sdio_writeb(func, 0, INT_ENABLE, &ret); if (ret) - goto error_free_card; + goto err_free_card; sdio_writeb(func, 0xff, INT_PENDING, &ret); if (ret) - goto error_disable_func; + goto err_disable_func; /* setup interrupt handler */ ret = sdio_claim_irq(func, ks_sdio_interrupt); if (ret) - goto error_disable_func; + goto err_disable_func; sdio_release_host(func); sdio_set_drvdata(func, card); - DPRINTK(5, "class = 0x%X, vendor = 0x%X, " - "device = 0x%X\n", func->class, func->vendor, func->device); + DPRINTK(5, "class = 0x%X, vendor = 0x%X, device = 0x%X\n", + func->class, func->vendor, func->device); /* private memory allocate */ netdev = alloc_etherdev(sizeof(*priv)); if (!netdev) { dev_err(&card->func->dev, "ks7010 : Unable to alloc new net device\n"); - goto error_release_irq; + goto err_release_irq; } if (dev_alloc_name(netdev, "wlan%d") < 0) { dev_err(&card->func->dev, "ks7010 : Couldn't get name!\n"); - goto error_free_netdev; + goto err_free_netdev; } priv = netdev_priv(netdev); @@ -1022,18 +892,13 @@ static int ks7010_sdio_probe(struct sdio_func *func, SET_NETDEV_DEV(netdev, &card->func->dev); /* for create sysfs symlinks */ /* private memory initialize */ - priv->ks_wlan_hw.sdio_card = card; - init_completion(&priv->ks_wlan_hw.ks7010_sdio_wait); - priv->ks_wlan_hw.read_buf = NULL; - priv->ks_wlan_hw.read_buf = kmalloc(RX_DATA_SIZE, GFP_KERNEL); - if (!priv->ks_wlan_hw.read_buf) - goto error_free_netdev; + 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; /* set current jiffies */ + priv->last_doze = jiffies; priv->last_wakeup = jiffies; memset(&priv->nstats, 0, sizeof(priv->nstats)); memset(&priv->wstats, 0, sizeof(priv->wstats)); @@ -1049,64 +914,57 @@ static int ks7010_sdio_probe(struct sdio_func *func, ks7010_init_defaults(priv); - /* Upload firmware */ - ret = ks7010_upload_firmware(priv, card); /* firmware load */ + ret = ks7010_upload_firmware(card); if (ret) { dev_err(&card->func->dev, "ks7010: firmware load failed !! return code = %d\n", ret); - goto error_free_read_buf; + goto err_free_netdev; } /* interrupt setting */ /* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */ - rw_data = 0xff; sdio_claim_host(func); - ret = ks7010_sdio_write(priv, INT_PENDING, &rw_data, sizeof(rw_data)); + ret = ks7010_sdio_writeb(priv, INT_PENDING, 0xff); sdio_release_host(func); if (ret) - DPRINTK(1, " error : INT_PENDING=%02X\n", rw_data); + DPRINTK(1, " error : INT_PENDING\n"); - DPRINTK(4, " clear Interrupt : INT_PENDING=%02X\n", rw_data); - - /* enable ks7010sdio interrupt (INT_GCR_B|INT_READ_STATUS|INT_WRITE_STATUS) */ - rw_data = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS); + /* enable ks7010sdio interrupt */ + byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS); sdio_claim_host(func); - ret = ks7010_sdio_write(priv, INT_ENABLE, &rw_data, sizeof(rw_data)); + ret = ks7010_sdio_writeb(priv, INT_ENABLE, byte); sdio_release_host(func); if (ret) - DPRINTK(1, " error : INT_ENABLE=%02X\n", rw_data); + DPRINTK(1, " err : INT_ENABLE\n"); - DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", rw_data); + DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", byte); priv->dev_state = DEVICE_STATE_BOOT; - priv->ks_wlan_hw.ks7010sdio_wq = create_workqueue("ks7010sdio_wq"); - if (!priv->ks_wlan_hw.ks7010sdio_wq) { + priv->wq = create_workqueue("wq"); + if (!priv->wq) { DPRINTK(1, "create_workqueue failed !!\n"); - goto error_free_read_buf; + goto err_free_netdev; } - INIT_DELAYED_WORK(&priv->ks_wlan_hw.rw_wq, ks7010_rw_function); + INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function); ks7010_card_init(priv); ret = register_netdev(priv->net_dev); if (ret) - goto error_free_read_buf; + goto err_free_netdev; return 0; - error_free_read_buf: - kfree(priv->ks_wlan_hw.read_buf); - priv->ks_wlan_hw.read_buf = NULL; - error_free_netdev: + err_free_netdev: free_netdev(priv->net_dev); card->priv = NULL; - error_release_irq: + err_release_irq: sdio_claim_host(func); sdio_release_irq(func); - error_disable_func: + err_disable_func: sdio_disable_func(func); - error_free_card: + err_free_card: sdio_release_host(func); sdio_set_drvdata(func, NULL); kfree(card); @@ -1114,6 +972,34 @@ static int ks7010_sdio_probe(struct sdio_func *func, return -ENODEV; } +/* send stop request to MAC */ +static int send_stop_request(struct sdio_func *func) +{ + struct hostif_stop_request_t *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) { + DPRINTK(3, "allocate memory failed..\n"); + 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); + + sdio_claim_host(func); + write_to_device(card->priv, (unsigned char *)pp, + hif_align_size(sizeof(*pp))); + sdio_release_host(func); + + kfree(pp); + return 0; +} + static void ks7010_sdio_remove(struct sdio_func *func) { int ret; @@ -1142,35 +1028,17 @@ static void ks7010_sdio_remove(struct sdio_func *func) sdio_release_host(func); DPRINTK(1, "interrupt disable\n"); - /* send stop request to MAC */ - { - struct hostif_stop_request_t *pp; + ret = send_stop_request(func); + if (ret) /* memory allocation failure */ + return; - pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL); - if (!pp) { - DPRINTK(3, "allocate memory failed..\n"); - return; /* to do goto ni suru */ - } - pp->header.size = - cpu_to_le16((uint16_t) - (sizeof(*pp) - - sizeof(pp->header.size))); - pp->header.event = cpu_to_le16((uint16_t)HIF_STOP_REQ); - - sdio_claim_host(func); - write_to_device(priv, (unsigned char *)pp, - hif_align_size(sizeof(*pp))); - sdio_release_host(func); - kfree(pp); - } DPRINTK(1, "STOP Req\n"); - if (priv->ks_wlan_hw.ks7010sdio_wq) { - flush_workqueue(priv->ks_wlan_hw.ks7010sdio_wq); - destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq); + if (priv->wq) { + flush_workqueue(priv->wq); + destroy_workqueue(priv->wq); } - DPRINTK(1, - "destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);\n"); + DPRINTK(1, "destroy_workqueue(priv->wq);\n"); hostif_exit(priv); DPRINTK(1, "hostif_exit\n"); @@ -1178,7 +1046,6 @@ static void ks7010_sdio_remove(struct sdio_func *func) unregister_netdev(netdev); trx_device_exit(priv); - kfree(priv->ks_wlan_hw.read_buf); free_netdev(priv->net_dev); card->priv = NULL; } |
