* current block size.
*
* As SDIO is still new to the kernel, it is unfortunately common with
- * bugs in the host controllers related to that. One such bug is that
+ * bugs in the host controllers related to that. One such bug is that
* controllers cannot do transfers that aren't a multiple of 4 bytes.
* If you don't have time to fix the host controller driver, you can
* work around the problem by modifying if_sdio_host_to_card() and
#include "dev.h"
#include "if_sdio.h"
-static char *libertas_helper_name = NULL;
-module_param_named(helper_name, libertas_helper_name, charp, 0644);
+static char *lbs_helper_name = NULL;
+module_param_named(helper_name, lbs_helper_name, charp, 0644);
-static char *libertas_fw_name = NULL;
-module_param_named(fw_name, libertas_fw_name, charp, 0644);
+static char *lbs_fw_name = NULL;
+module_param_named(fw_name, lbs_fw_name, charp, 0644);
static const struct sdio_device_id if_sdio_ids[] = {
{ SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
struct if_sdio_card {
struct sdio_func *func;
- wlan_private *priv;
+ struct lbs_private *priv;
int model;
unsigned long ioport;
const char *firmware;
u8 buffer[65536];
- u8 int_cause;
- u32 event;
spinlock_t lock;
struct if_sdio_packet *packets;
static int if_sdio_handle_cmd(struct if_sdio_card *card,
u8 *buffer, unsigned size)
{
+ struct lbs_private *priv = card->priv;
int ret;
unsigned long flags;
+ u8 i;
lbs_deb_enter(LBS_DEB_SDIO);
- spin_lock_irqsave(&card->priv->adapter->driver_lock, flags);
-
- if (!card->priv->adapter->cur_cmd) {
- lbs_deb_sdio("discarding spurious response\n");
- ret = 0;
- goto out;
- }
-
- if (size > MRVDRV_SIZE_OF_CMD_BUFFER) {
+ if (size > LBS_CMD_BUFFER_SIZE) {
lbs_deb_sdio("response packet too large (%d bytes)\n",
(int)size);
ret = -E2BIG;
goto out;
}
- memcpy(card->priv->adapter->cur_cmd->bufvirtualaddr, buffer, size);
- card->priv->upld_len = size;
+ spin_lock_irqsave(&priv->driver_lock, flags);
- card->int_cause |= MRVDRV_CMD_UPLD_RDY;
+ i = (priv->resp_idx == 0) ? 1 : 0;
+ BUG_ON(priv->resp_len[i]);
+ priv->resp_len[i] = size;
+ memcpy(priv->resp_buf[i], buffer, size);
+ lbs_notify_command_response(priv, i);
- libertas_interrupt(card->priv->dev);
+ spin_unlock_irqrestore(&card->priv->driver_lock, flags);
ret = 0;
out:
- spin_unlock_irqrestore(&card->priv->adapter->driver_lock, flags);
-
lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
-
return ret;
}
memcpy(data, buffer, size);
- libertas_process_rxed_packet(card->priv, skb);
+ lbs_process_rxed_packet(card->priv, skb);
ret = 0;
u8 *buffer, unsigned size)
{
int ret;
- unsigned long flags;
u32 event;
lbs_deb_enter(LBS_DEB_SDIO);
event |= buffer[2] << 16;
event |= buffer[1] << 8;
event |= buffer[0] << 0;
- event <<= SBI_EVENT_CAUSE_SHIFT;
}
- spin_lock_irqsave(&card->priv->adapter->driver_lock, flags);
-
- card->event = event;
- card->int_cause |= MRVDRV_CARDEVENT;
-
- libertas_interrupt(card->priv->dev);
-
- spin_unlock_irqrestore(&card->priv->adapter->driver_lock, flags);
-
+ lbs_queue_event(card->priv, event & 0xFF);
ret = 0;
out:
unsigned long timeout;
u8 *chunk_buffer;
u32 chunk_size;
- u8 *firmware;
+ const u8 *firmware;
size_t size;
lbs_deb_enter(LBS_DEB_SDIO);
chunk_size = min(size, (size_t)60);
- *((u32*)chunk_buffer) = cpu_to_le32(chunk_size);
+ *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
memcpy(chunk_buffer + 4, firmware, chunk_size);
/*
lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
unsigned long timeout;
u8 *chunk_buffer;
u32 chunk_size;
- u8 *firmware;
+ const u8 *firmware;
size_t size, req_size;
lbs_deb_enter(LBS_DEB_SDIO);
/* Libertas callbacks */
/*******************************************************************/
-static int if_sdio_host_to_card(wlan_private *priv, u8 type, u8 *buf, u16 nb)
+static int if_sdio_host_to_card(struct lbs_private *priv,
+ u8 type, u8 *buf, u16 nb)
{
int ret;
struct if_sdio_card *card;
return ret;
}
-static int if_sdio_get_int_status(wlan_private *priv, u8 *ireg)
-{
- struct if_sdio_card *card;
-
- lbs_deb_enter(LBS_DEB_SDIO);
-
- card = priv->card;
-
- *ireg = card->int_cause;
- card->int_cause = 0;
-
- lbs_deb_leave(LBS_DEB_SDIO);
-
- return 0;
-}
-
-static int if_sdio_read_event_cause(wlan_private *priv)
-{
- struct if_sdio_card *card;
-
- lbs_deb_enter(LBS_DEB_SDIO);
-
- card = priv->card;
-
- priv->adapter->eventcause = card->event;
-
- lbs_deb_leave(LBS_DEB_SDIO);
-
- return 0;
-}
-
/*******************************************************************/
/* SDIO callbacks */
/*******************************************************************/
* Ignore the define name, this really means the card has
* successfully received the command.
*/
- if (cause & IF_SDIO_H_INT_DNLD) {
- if ((card->priv->dnld_sent == DNLD_DATA_SENT) &&
- (card->priv->adapter->connect_status == LIBERTAS_CONNECTED))
- netif_wake_queue(card->priv->dev);
- card->priv->dnld_sent = DNLD_RES_RECEIVED;
- }
+ if (cause & IF_SDIO_H_INT_DNLD)
+ lbs_host_to_card_done(card->priv);
+
if (cause & IF_SDIO_H_INT_UPLD) {
ret = if_sdio_card_to_host(card);
const struct sdio_device_id *id)
{
struct if_sdio_card *card;
- wlan_private *priv;
+ struct lbs_private *priv;
int ret, i;
unsigned int model;
struct if_sdio_packet *packet;
if (sscanf(func->card->info[i],
"ID: %x", &model) == 1)
break;
+ if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
+ model = 4;
+ break;
+ }
}
if (i == func->card->num_info) {
card->helper = if_sdio_models[i].helper;
card->firmware = if_sdio_models[i].firmware;
- if (libertas_helper_name) {
+ if (lbs_helper_name) {
lbs_deb_sdio("overriding helper firmware: %s\n",
- libertas_helper_name);
- card->helper = libertas_helper_name;
+ lbs_helper_name);
+ card->helper = lbs_helper_name;
}
- if (libertas_fw_name) {
- lbs_deb_sdio("overriding firmware: %s\n", libertas_fw_name);
- card->firmware = libertas_fw_name;
+ if (lbs_fw_name) {
+ lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name);
+ card->firmware = lbs_fw_name;
}
sdio_claim_host(func);
if (ret)
goto reclaim;
- priv = libertas_add_card(card, &func->dev);
+ priv = lbs_add_card(card, &func->dev);
if (!priv) {
ret = -ENOMEM;
goto reclaim;
priv->card = card;
priv->hw_host_to_card = if_sdio_host_to_card;
- priv->hw_get_int_status = if_sdio_get_int_status;
- priv->hw_read_event_cause = if_sdio_read_event_cause;
- priv->adapter->fw_ready = 1;
+ priv->fw_ready = 1;
/*
* Enable interrupts now that everything is set up
if (ret)
goto reclaim;
- ret = libertas_start_card(priv);
+ ret = lbs_start_card(priv);
if (ret)
goto err_activate_card;
err_activate_card:
flush_scheduled_work();
free_netdev(priv->dev);
- kfree(priv->adapter);
+ kfree(priv);
reclaim:
sdio_claim_host(func);
release_int:
card = sdio_get_drvdata(func);
- card->priv->adapter->surpriseremoved = 1;
+ card->priv->surpriseremoved = 1;
lbs_deb_sdio("call remove card\n");
- libertas_stop_card(card->priv);
- libertas_remove_card(card->priv);
+ lbs_stop_card(card->priv);
+ lbs_remove_card(card->priv);
flush_scheduled_work();
/* Module functions */
/*******************************************************************/
-static int if_sdio_init_module(void)
+static int __init if_sdio_init_module(void)
{
int ret = 0;
return ret;
}
-static void if_sdio_exit_module(void)
+static void __exit if_sdio_exit_module(void)
{
lbs_deb_enter(LBS_DEB_SDIO);
git.openpandora.org / pandora-kernel.git / blobdiff