libertas_tf: command helper functions for libertas_tf
PATCH v2 4/6 libertas_tf: command helper functions for libertas_tf
Signed-off-by Luis Carlos Cobo <[email protected]>
--- drivers/net/wireless/libertas_tf/cmd.c | 669 ++++++++++++++++++++++++++++++++ 1 files changed, 669 insertions(+), 0 deletions(-) create mode 100644 drivers/net/wireless/libertas_tf/cmd.c
drivers/net/wireless/libertas_tf/cmd.c new file +669 -0
@@ -0,0 +1,669 @@ +/* +* Copyright (C) 2008, cozybit Inc. +* Copyright (C) 2003-2006, Marvell International Ltd. +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or (at +* your option) any later version. +*/ +#include "libertas_tf.h" + +static const struct channel_range channel_ranges[] = { + {LBTF_REGDOMAIN_US ,1 ,12 }, + {LBTF_REGDOMAIN_CA ,1 ,12 }, + {LBTF_REGDOMAIN_EU ,1 ,14 }, + {LBTF_REGDOMAIN_JP ,1 ,14 }, + {LBTF_REGDOMAIN_SP ,1 ,14 }, + {LBTF_REGDOMAIN_FR ,1 ,14 }, +}; + +static u16 lbtf_region_code_to_index[MRVDRV_MAX_REGION_CODE ] = +{ +LBTF_REGDOMAIN_US ,LBTF_REGDOMAIN_CA ,LBTF_REGDOMAIN_EU , +LBTF_REGDOMAIN_SP ,LBTF_REGDOMAIN_FR ,LBTF_REGDOMAIN_JP , +}; + +static struct cmd_ctrl_node *lbtf_get_cmd_ctrl_node (struct lbtf_private *priv); + + +/** +* lbtf_cmd_copyback - Simple callback that copies response back into command +* +* @priv A pointer to struct lbtf_private structure +* @extra A pointer to the original command structure for which +* 'resp' is a response +* @resp A pointer to the command response +* +* Returns: 0 on success, error on failure +*/ +int lbtf_cmd_copyback (struct lbtf_private *priv,unsigned long extra, +struct cmd_header *resp) +{ +struct cmd_header *buf = (void *)extra; +uint16_t copy_len; + + copy_len =min (le16_to_cpu (buf->size),le16_to_cpu (resp->size)); +memcpy (buf, resp, copy_len); +return 0 ; +} +EXPORT_SYMBOL_GPL (lbtf_cmd_copyback); + +#define CHAN_TO_IDX (chan) ((chan) - 1) + +static void lbtf_geo_init (struct lbtf_private *priv) +{ +const struct channel_range *range = channel_ranges; +u8 ch; +int i; + +for (i =0 ; i <ARRAY_SIZE (channel_ranges); i++) +if (channel_ranges[i].regdomain == priv->regioncode) { + range = &channel_ranges[i]; +break ; + } + +for (ch = priv->range.start; ch < priv->range.end; ch++) + priv->channels[CHAN_TO_IDX (ch)].flags =0 ; +} + +/** +* lbtf_update_hw_spec: Updates the hardware details. +* +* @priv A pointer to struct lbtf_private structure +* +* Returns: 0 on success, error on failure +*/ +int lbtf_update_hw_spec (struct lbtf_private *priv) +{ +struct cmd_ds_get_hw_spec cmd; +int ret =-1 ; +u32 i; +DECLARE_MAC_BUF (mac); + +memset (&cmd,0 ,sizeof (cmd)); + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); +memcpy (cmd.permanentaddr, priv->current_addr,ETH_ALEN ); + ret =lbtf_cmd_with_response (priv,CMD_GET_HW_SPEC , &cmd); +if (ret) + goto out; + + priv->fwcapinfo =le32_to_cpu (cmd.fwcapinfo); + +/* The firmware release is in an interesting format: the patch +* level is in the most significant nibble ... so fix that: */ + priv->fwrelease =le32_to_cpu (cmd.fwrelease); + priv->fwrelease = (priv->fwrelease <<8 ) | + (priv->fwrelease >>24 &0xff ); + +printk (KERN_INFO "libertastf: %s, fw %u.%u.%up%u, cap 0x%08x\n" , +print_mac (mac, cmd.permanentaddr), + priv->fwrelease >>24 &0xff , + priv->fwrelease >>16 &0xff , + priv->fwrelease >>8 &0xff , + priv->fwrelease &0xff , + priv->fwcapinfo); + +/* Clamp region code to 8-bit since FW spec indicates that it should +* only ever be 8-bit, even though the field size is 16-bit. Some +* firmware returns non-zero high 8 bits here. +*/ + priv->regioncode =le16_to_cpu (cmd.regioncode) &0xFF ; + +for (i =0 ; i <MRVDRV_MAX_REGION_CODE ; i++) { +/* use the region code to search for the index */ +if (priv->regioncode == lbtf_region_code_to_index[i]) +break ; + } + +/* if it's unidentified region code, use the default (USA) */ +if (i >=MRVDRV_MAX_REGION_CODE ) + priv->regioncode =0x10 ; + +if (priv->current_addr[0 ] ==0xff ) +memmove (priv->current_addr, cmd.permanentaddr,ETH_ALEN ); + +SET_IEEE80211_PERM_ADDR (priv->hw, priv->current_addr); + +lbtf_geo_init (priv); +out: +return ret; +} + +/** +* lbtf_set_channel: Set the radio channel +* +* @priv A pointer to struct lbtf_private structure +* @channel The desired channel, or 0 to clear a locked channel +* +* Returns: 0 on success, error on failure +*/ +int lbtf_set_channel (struct lbtf_private *priv,u8 channel) +{ +struct cmd_ds_802_11_rf_channel cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.action =cpu_to_le16 (CMD_OPT_802_11_RF_CHANNEL_SET ); + cmd.channel =cpu_to_le16 (channel); + +return lbtf_cmd_with_response (priv,CMD_802_11_RF_CHANNEL , &cmd); +} + +int lbtf_beacon_set (struct lbtf_private *priv,struct sk_buff *beacon) +{ +struct cmd_ds_802_11_beacon_set cmd; +int size; + +if (beacon->len >MRVL_MAX_BCN_SIZE ) +return -1 ; + size =sizeof (cmd) -sizeof (cmd.beacon) + beacon->len; + cmd.hdr.size =cpu_to_le16 (size); + cmd.len =cpu_to_le16 (beacon->len); +memcpy (cmd.beacon, (u8 *) beacon->data, beacon->len); + +lbtf_cmd_async (priv,CMD_802_11_BEACON_SET , &cmd.hdr, size); +return 0 ; +} + +int lbtf_beacon_ctrl (struct lbtf_private *priv,bool beacon_enable, +int beacon_int) { +struct cmd_ds_802_11_beacon_control cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.action =cpu_to_le16 (CMD_ACT_SET ); + cmd.beacon_enable =cpu_to_le16 (beacon_enable); + cmd.beacon_period =cpu_to_le16 (beacon_int); + +lbtf_cmd_async (priv,CMD_802_11_BEACON_CTRL , &cmd.hdr,sizeof (cmd)); +return 0 ; +} + +static void lbtf_queue_cmd (struct lbtf_private *priv, +struct cmd_ctrl_node *cmdnode) +{ +unsigned long flags; + +if (!cmdnode) +return ; + +if (!cmdnode->cmdbuf->size) +return ; + + cmdnode->result =0 ; +spin_lock_irqsave (&priv->driver_lock, flags); +list_add_tail (&cmdnode->list, &priv->cmdpendingq); +spin_unlock_irqrestore (&priv->driver_lock, flags); +} + +static void lbtf_submit_command (struct lbtf_private *priv, +struct cmd_ctrl_node *cmdnode) +{ +unsigned long flags; +struct cmd_header *cmd; +uint16_t cmdsize; +uint16_t command; +int timeo =5 *HZ ; +int ret; + + cmd = cmdnode->cmdbuf; + +spin_lock_irqsave (&priv->driver_lock, flags); + priv->cur_cmd = cmdnode; + cmdsize =le16_to_cpu (cmd->size); + command =le16_to_cpu (cmd->command); + ret = priv->hw_host_to_card (priv,MVMS_CMD , (u8 *) cmd, cmdsize); +spin_unlock_irqrestore (&priv->driver_lock, flags); + +if (ret) +/* Let the timer kick in and retry, and potentially reset +the whole thing if the condition persists */ + timeo =HZ ; + +/* Setup the timer after transmit command */ +mod_timer (&priv->command_timer, jiffies + timeo); +} + +/** +* This function inserts command node to cmdfreeq +* after cleans it. Requires priv->driver_lock held. +*/ +static void __lbtf_cleanup_and_insert_cmd (struct lbtf_private *priv, +struct cmd_ctrl_node *cmdnode) +{ +if (!cmdnode) +return ; + + cmdnode->callback =NULL ; + cmdnode->callback_arg =0 ; + +memset (cmdnode->cmdbuf,0 ,LBS_CMD_BUFFER_SIZE ); + +list_add_tail (&cmdnode->list, &priv->cmdfreeq); +} + +static void lbtf_cleanup_and_insert_cmd (struct lbtf_private *priv, +struct cmd_ctrl_node *ptempcmd) +{ +unsigned long flags; + +spin_lock_irqsave (&priv->driver_lock, flags); +__lbtf_cleanup_and_insert_cmd (priv, ptempcmd); +spin_unlock_irqrestore (&priv->driver_lock, flags); +} + +void lbtf_complete_command (struct lbtf_private *priv,struct cmd_ctrl_node *cmd, +int result) +{ + cmd->result = result; + cmd->cmdwaitqwoken =1 ; +wake_up_interruptible (&cmd->cmdwait_q); + +if (!cmd->callback) +__lbtf_cleanup_and_insert_cmd (priv, cmd); + priv->cur_cmd =NULL ; +} + +int lbtf_cmd_set_mac_multicast_addr (struct lbtf_private *priv) +{ +struct cmd_ds_mac_multicast_addr cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.action =cpu_to_le16 (CMD_ACT_SET ); + + cmd.nr_of_adrs =cpu_to_le16 ((u16 ) priv->nr_of_multicastmacaddr); +memcpy (cmd.maclist, priv->multicastlist, + priv->nr_of_multicastmacaddr *ETH_ALEN ); + +lbtf_cmd_async (priv,CMD_MAC_MULTICAST_ADR , &cmd.hdr,sizeof (cmd)); +return 0 ; +} + +void lbtf_set_mode (struct lbtf_private *priv,enum lbtf_mode mode) +{ +struct cmd_ds_set_mode cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.mode =cpu_to_le16 (mode); +lbtf_cmd_async (priv,CMD_802_11_SET_MODE , &cmd.hdr,sizeof (cmd)); +} + +void lbtf_set_bssid (struct lbtf_private *priv,bool activate,u8 *bssid) +{ +struct cmd_ds_set_bssid cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.activate = activate ?1 :0 ; +if (activate) +memcpy (cmd.bssid, bssid,ETH_ALEN ); + +lbtf_cmd_async (priv,CMD_802_11_SET_BSSID , &cmd.hdr,sizeof (cmd)); +} + +int lbtf_set_mac_address (struct lbtf_private *priv,uint8_t *mac_addr) +{ +struct cmd_ds_802_11_mac_address cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.action =cpu_to_le16 (CMD_ACT_SET ); + +memcpy (cmd.macadd, mac_addr,ETH_ALEN ); + +lbtf_cmd_async (priv,CMD_802_11_MAC_ADDRESS , &cmd.hdr,sizeof (cmd)); +return 0 ; +} + +int lbtf_set_radio_control (struct lbtf_private *priv) +{ +int ret =0 ; +struct cmd_ds_802_11_radio_control cmd; + + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.action =cpu_to_le16 (CMD_ACT_SET ); + +switch (priv->preamble) { +case CMD_TYPE_SHORT_PREAMBLE : + cmd.control =cpu_to_le16 (SET_SHORT_PREAMBLE ); +break ; + +case CMD_TYPE_LONG_PREAMBLE : + cmd.control =cpu_to_le16 (SET_LONG_PREAMBLE ); +break ; + +case CMD_TYPE_AUTO_PREAMBLE : +default : + cmd.control =cpu_to_le16 (SET_AUTO_PREAMBLE ); +break ; + } + +if (priv->radioon) + cmd.control |=cpu_to_le16 (TURN_ON_RF ); +else + cmd.control &=cpu_to_le16 (~TURN_ON_RF ); + + ret =lbtf_cmd_with_response (priv,CMD_802_11_RADIO_CONTROL , &cmd); +return ret; +} + +void lbtf_set_mac_control (struct lbtf_private *priv) +{ +struct cmd_ds_mac_control cmd; + cmd.hdr.size =cpu_to_le16 (sizeof (cmd)); + cmd.action =cpu_to_le16 (priv->mac_control); + cmd.reserved =0 ; + +lbtf_cmd_async (priv,CMD_MAC_CONTROL , + &cmd.hdr,sizeof (cmd)); +} + +/** +* lbtf_allocate_cmd_buffer - Allocates cmd buffer, links it to free cmd queue +* +* @priv A pointer to struct lbtf_private structure +* +* Returns: 0 on success. +*/ +int lbtf_allocate_cmd_buffer (struct lbtf_private *priv) +{ +u32 bufsize; +u32 i; +struct cmd_ctrl_node *cmdarray; + +/* Allocate and initialize the command array */ + bufsize =sizeof (struct cmd_ctrl_node ) *LBS_NUM_CMD_BUFFERS ; + cmdarray =kzalloc (bufsize,GFP_KERNEL ); +if (!cmdarray) +return -1 ; + priv->cmd_array = cmdarray; + +/* Allocate and initialize each command buffer in the command array */ +for (i =0 ; i <LBS_NUM_CMD_BUFFERS ; i++) { + cmdarray[i].cmdbuf =kzalloc (LBS_CMD_BUFFER_SIZE ,GFP_KERNEL ); +if (!cmdarray[i].cmdbuf) +return -1 ; + } + +for (i =0 ; i <LBS_NUM_CMD_BUFFERS ; i++) { +init_waitqueue_head (&cmdarray[i].cmdwait_q); +lbtf_cleanup_and_insert_cmd (priv, &cmdarray[i]); + } +return 0 ; +} + +/** +* lbtf_free_cmd_buffer - Frees the cmd buffer. +* +* @priv A pointer to struct lbtf_private structure +* +* Returns: 0 +*/ +int lbtf_free_cmd_buffer (struct lbtf_private *priv) +{ +struct cmd_ctrl_node *cmdarray; +unsigned int i; + +/* need to check if cmd array is allocated or not */ +if (priv->cmd_array ==NULL ) +return 0 ; + + cmdarray = priv->cmd_array; + +/* Release shared memory buffers */ +for (i =0 ; i <LBS_NUM_CMD_BUFFERS ; i++) { +kfree (cmdarray[i].cmdbuf); + cmdarray[i].cmdbuf =NULL ; + } + +/* Release cmd_ctrl_node */ +kfree (priv->cmd_array); + priv->cmd_array =NULL ; + +return 0 ; +} + +/** +* lbtf_get_cmd_ctrl_node - Gets free cmd node from free cmd queue. +* +* @priv A pointer to struct lbtf_private structure +* +* Returns: pointer to a struct cmd_ctrl_node or NULL if none available. +*/ +static struct cmd_ctrl_node *lbtf_get_cmd_ctrl_node (struct lbtf_private *priv) +{ +struct cmd_ctrl_node *tempnode; +unsigned long flags; + +if (!priv) +return NULL ; + +spin_lock_irqsave (&priv->driver_lock, flags); + +if (!list_empty (&priv->cmdfreeq)) { + tempnode =list_first_entry (&priv->cmdfreeq, + struct cmd_ctrl_node, list); +list_del (&tempnode->list); + }else + tempnode =NULL ; + +spin_unlock_irqrestore (&priv->driver_lock, flags); + +return tempnode; +} + +/** +* lbtf_execute_next_command: execute next command in cmd pending queue. +* +* @priv A pointer to struct lbtf_private structure +* +* Returns: 0 on success. +*/ +int lbtf_execute_next_command (struct lbtf_private *priv) +{ +struct cmd_ctrl_node *cmdnode =NULL ; +struct cmd_header *cmd; +unsigned long flags; + +/* Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the +* only caller to us is lbtf_thread() and we get even when a +* data packet is received */ + +spin_lock_irqsave (&priv->driver_lock, flags); + +if (priv->cur_cmd) { +spin_unlock_irqrestore (&priv->driver_lock, flags); +return -1 ; + } + +if (!list_empty (&priv->cmdpendingq)) { + cmdnode =list_first_entry (&priv->cmdpendingq, + struct cmd_ctrl_node, list); + } + +if (cmdnode) { + cmd = cmdnode->cmdbuf; + +list_del (&cmdnode->list); +spin_unlock_irqrestore (&priv->driver_lock, flags); +lbtf_submit_command (priv, cmdnode); + }else +spin_unlock_irqrestore (&priv->driver_lock, flags); +return 0 ; +} + +static struct cmd_ctrl_node *__lbtf_cmd_async (struct lbtf_private *priv, +uint16_t command,struct cmd_header *in_cmd,int in_cmd_size, +int (*callback)(struct lbtf_private *,unsigned long , +struct cmd_header *), +unsigned long callback_arg) +{ +struct cmd_ctrl_node *cmdnode; + +if (priv->surpriseremoved) +return ERR_PTR (-ENOENT ); + + cmdnode =lbtf_get_cmd_ctrl_node (priv); +if (cmdnode ==NULL ) { +/* Wake up main thread to execute next command */ +queue_work (lbtf_wq, &priv->cmd_work); +return ERR_PTR (-ENOBUFS ); + } + + cmdnode->callback = callback; + cmdnode->callback_arg = callback_arg; + +/* Copy the incoming command to the buffer */ +memcpy (cmdnode->cmdbuf, in_cmd, in_cmd_size); + +/* Set sequence number, clean result, move to buffer */ + priv->seqnum++; + cmdnode->cmdbuf->command =cpu_to_le16 (command); + cmdnode->cmdbuf->size =cpu_to_le16 (in_cmd_size); + cmdnode->cmdbuf->seqnum =cpu_to_le16 (priv->seqnum); + cmdnode->cmdbuf->result =0 ; + cmdnode->cmdwaitqwoken =0 ; +lbtf_queue_cmd (priv, cmdnode); +queue_work (lbtf_wq, &priv->cmd_work); + +return cmdnode; +} + +void lbtf_cmd_async (struct lbtf_private *priv,uint16_t command, +struct cmd_header *in_cmd,int in_cmd_size) +{ +__lbtf_cmd_async (priv, command, in_cmd, in_cmd_size,NULL ,0 ); +} + +int __lbtf_cmd (struct lbtf_private *priv,uint16_t command, +struct cmd_header *in_cmd,int in_cmd_size, +int (*callback)(struct lbtf_private *, +unsigned long ,struct cmd_header *), +unsigned long callback_arg) +{ +struct cmd_ctrl_node *cmdnode; +unsigned long flags; +int ret =0 ; + + cmdnode =__lbtf_cmd_async (priv, command, in_cmd, in_cmd_size, + callback, callback_arg); +if (IS_ERR (cmdnode)) +return PTR_ERR (cmdnode); + +might_sleep (); + ret =wait_event_interruptible (cmdnode->cmdwait_q, + cmdnode->cmdwaitqwoken); +if (ret) { +printk (KERN_DEBUG +"libertastf: command 0x%04x interrupted by signal" , + command); +return ret; + } + +spin_lock_irqsave (&priv->driver_lock, flags); + ret = cmdnode->result; +if (ret) +printk (KERN_DEBUG "libertastf: command 0x%04x failed: %d\n" , + command, ret); + +__lbtf_cleanup_and_insert_cmd (priv, cmdnode); +spin_unlock_irqrestore (&priv->driver_lock, flags); + +return ret; +} +EXPORT_SYMBOL_GPL (__lbtf_cmd); + +/* Call holding driver_lock */ +void lbtf_cmd_response_rx (struct lbtf_private *priv) +{ + priv->cmd_response_rxed =1 ; +queue_work (lbtf_wq, &priv->cmd_work); +} +EXPORT_SYMBOL_GPL (lbtf_cmd_response_rx); + +int lbtf_process_rx_command (struct lbtf_private *priv) +{ +uint16_t respcmd, curcmd; +struct cmd_header *resp; +int ret =0 ; +unsigned long flags; +uint16_t result; + +mutex_lock (&priv->lock); +spin_lock_irqsave (&priv->driver_lock, flags); + +if (!priv->cur_cmd) { + ret =-1 ; +spin_unlock_irqrestore (&priv->driver_lock, flags); + goto done; + } + + resp = (void *)priv->cmd_resp_buff; + curcmd =le16_to_cpu (priv->cur_cmd->cmdbuf->command); + respcmd =le16_to_cpu (resp->command); + result =le16_to_cpu (resp->result); + +if (net_ratelimit ()) +printk (KERN_DEBUG "libertastf: cmd response 0x%04x, seq %d, size %d\n" , + respcmd,le16_to_cpu (resp->seqnum), +le16_to_cpu (resp->size)); + +if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) { +spin_unlock_irqrestore (&priv->driver_lock, flags); + ret =-1 ; + goto done; + } +if (respcmd !=CMD_RET (curcmd)) { +spin_unlock_irqrestore (&priv->driver_lock, flags); + ret =-1 ; + goto done; + } + +if (resp->result ==cpu_to_le16 (0x0004 )) { +/* 0x0004 means -EAGAIN. Drop the response, let it time out +and be resubmitted */ +spin_unlock_irqrestore (&priv->driver_lock, flags); + ret =-1 ; + goto done; + } + +/* Now we got response from FW, cancel the command timer */ +del_timer (&priv->command_timer); + priv->cmd_timed_out =0 ; +if (priv->nr_retries) + priv->nr_retries =0 ; + +/* If the command is not successful, cleanup and return failure */ +if ((result !=0 || !(respcmd &0x8000 ))) { +/* +* Handling errors here +*/ +switch (respcmd) { +case CMD_RET (CMD_GET_HW_SPEC ): +case CMD_RET (CMD_802_11_RESET ): +printk (KERN_DEBUG "libertastf: reset failed\n" ); +break ; + + } +lbtf_complete_command (priv, priv->cur_cmd, result); +spin_unlock_irqrestore (&priv->driver_lock, flags); + + ret =-1 ; + goto done; + } + +spin_unlock_irqrestore (&priv->driver_lock, flags); + +if (priv->cur_cmd && priv->cur_cmd->callback) { + ret = priv->cur_cmd->callback (priv, priv->cur_cmd->callback_arg, + resp); + } +spin_lock_irqsave (&priv->driver_lock, flags); + +if (priv->cur_cmd) { +/* Clean up and Put current command back to cmdfreeq */ +lbtf_complete_command (priv, priv->cur_cmd, result); + } +spin_unlock_irqrestore (&priv->driver_lock, flags); + +done: +mutex_unlock (&priv->lock); +return ret; +}
Signature · 1 line
1.5.4.3