hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wl1251: use wl1251 prefix everywhere 

Last we can change all code prefixes from wl12xx/WL12XX to
wl1251/WL1251.

Signed-off-by: Kalle Valo <kalle.valo@nokia.com>
Reviewed-by: Vidhya Govindan <vidhya.govindan@nokia.com>
Reviewed-by: Luciano Coelho <luciano.coelho@nokia.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Kalle Valo 2009-06-12 14:17:39 +03:00 committed by John W. Linville
parent 1e6f172fcc
commit 80301cdcfe
26 changed files with 1198 additions and 1194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
drivers/net/wireless/wl12xx/wl1251.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008-2009 Nokia Corporation
@ -22,15 +22,15 @@
*
*/
#ifndef __WL12XX_H__
#define __WL12XX_H__
#ifndef __WL1251_H__
#define __WL1251_H__
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/bitops.h>
#include <net/mac80211.h>
#define DRIVER_NAME "wl12xx"
#define DRIVER_NAME "wl1251"
#define DRIVER_PREFIX DRIVER_NAME ": "
enum {
@ -56,25 +56,25 @@ enum {
#define DEBUG_DUMP_LIMIT 1024
#define wl12xx_error(fmt, arg...) \
#define wl1251_error(fmt, arg...) \
printk(KERN_ERR DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
#define wl12xx_warning(fmt, arg...) \
#define wl1251_warning(fmt, arg...) \
printk(KERN_WARNING DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
#define wl12xx_notice(fmt, arg...) \
#define wl1251_notice(fmt, arg...) \
printk(KERN_INFO DRIVER_PREFIX fmt "\n", ##arg)
#define wl12xx_info(fmt, arg...) \
#define wl1251_info(fmt, arg...) \
printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg)
#define wl12xx_debug(level, fmt, arg...) \
#define wl1251_debug(level, fmt, arg...) \
do { \
if (level & DEBUG_LEVEL) \
printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg); \
} while (0)
#define wl12xx_dump(level, prefix, buf, len) \
#define wl1251_dump(level, prefix, buf, len) \
do { \
if (level & DEBUG_LEVEL) \
print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
@ -84,7 +84,7 @@ enum {
0); \
} while (0)
#define wl12xx_dump_ascii(level, prefix, buf, len) \
#define wl1251_dump_ascii(level, prefix, buf, len) \
do { \
if (level & DEBUG_LEVEL) \
print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
@ -94,10 +94,10 @@ enum {
true); \
} while (0)
#define WL12XX_DEFAULT_RX_CONFIG (CFG_UNI_FILTER_EN | \
#define WL1251_DEFAULT_RX_CONFIG (CFG_UNI_FILTER_EN | \
CFG_BSSID_FILTER_EN)
#define WL12XX_DEFAULT_RX_FILTER (CFG_RX_PRSP_EN | \
#define WL1251_DEFAULT_RX_FILTER (CFG_RX_PRSP_EN | \
CFG_RX_MGMT_EN | \
CFG_RX_DATA_EN | \
CFG_RX_CTL_EN | \
@ -105,7 +105,7 @@ enum {
CFG_RX_AUTH_EN | \
CFG_RX_ASSOC_EN)
#define WL12XX_BUSY_WORD_LEN 8
#define WL1251_BUSY_WORD_LEN 8
struct boot_attr {
u32 radio_type;
@ -117,13 +117,13 @@ struct boot_attr {
u32 bugfix;
};
enum wl12xx_state {
WL12XX_STATE_OFF,
WL12XX_STATE_ON,
WL12XX_STATE_PLT,
enum wl1251_state {
WL1251_STATE_OFF,
WL1251_STATE_ON,
WL1251_STATE_PLT,
};
enum wl12xx_partition_type {
enum wl1251_partition_type {
PART_DOWN,
PART_WORK,
PART_DRPW,
@ -131,20 +131,20 @@ enum wl12xx_partition_type {
PART_TABLE_LEN
};
struct wl12xx_partition {
struct wl1251_partition {
u32 size;
u32 start;
};
struct wl12xx_partition_set {
struct wl12xx_partition mem;
struct wl12xx_partition reg;
struct wl1251_partition_set {
struct wl1251_partition mem;
struct wl1251_partition reg;
};
struct wl12xx;
struct wl1251;
/* FIXME: I'm not sure about this structure name */
struct wl12xx_chip {
struct wl1251_chip {
u32 id;
const char *fw_filename;
@ -156,23 +156,23 @@ struct wl12xx_chip {
int intr_cmd_complete;
int intr_init_complete;
int (*op_upload_fw)(struct wl12xx *wl);
int (*op_upload_nvs)(struct wl12xx *wl);
int (*op_boot)(struct wl12xx *wl);
void (*op_set_ecpu_ctrl)(struct wl12xx *wl, u32 flag);
void (*op_target_enable_interrupts)(struct wl12xx *wl);
int (*op_hw_init)(struct wl12xx *wl);
int (*op_plt_init)(struct wl12xx *wl);
void (*op_tx_flush)(struct wl12xx *wl);
void (*op_fw_version)(struct wl12xx *wl);
int (*op_cmd_join)(struct wl12xx *wl, u8 bss_type, u8 dtim_interval,
int (*op_upload_fw)(struct wl1251 *wl);
int (*op_upload_nvs)(struct wl1251 *wl);
int (*op_boot)(struct wl1251 *wl);
void (*op_set_ecpu_ctrl)(struct wl1251 *wl, u32 flag);
void (*op_target_enable_interrupts)(struct wl1251 *wl);
int (*op_hw_init)(struct wl1251 *wl);
int (*op_plt_init)(struct wl1251 *wl);
void (*op_tx_flush)(struct wl1251 *wl);
void (*op_fw_version)(struct wl1251 *wl);
int (*op_cmd_join)(struct wl1251 *wl, u8 bss_type, u8 dtim_interval,
u16 beacon_interval, u8 wait);
struct wl12xx_partition_set *p_table;
struct wl1251_partition_set *p_table;
enum wl12xx_acx_int_reg *acx_reg_table;
};
struct wl12xx_stats {
struct wl1251_stats {
struct acx_statistics *fw_stats;
unsigned long fw_stats_update;
@ -180,7 +180,7 @@ struct wl12xx_stats {
unsigned int excessive_retries;
};
struct wl12xx_debugfs {
struct wl1251_debugfs {
struct dentry *rootdir;
struct dentry *fw_statistics;
@ -281,7 +281,7 @@ struct wl12xx_debugfs {
struct dentry *excessive_retries;
};
struct wl12xx {
struct wl1251 {
struct ieee80211_hw *hw;
bool mac80211_registered;
@ -290,7 +290,7 @@ struct wl12xx {
void (*set_power)(bool enable);
int irq;
enum wl12xx_state state;
enum wl1251_state state;
struct mutex mutex;
int physical_mem_addr;
@ -298,7 +298,7 @@ struct wl12xx {
int virtual_mem_addr;
int virtual_reg_addr;
struct wl12xx_chip chip;
struct wl1251_chip chip;
int cmd_box_addr;
int event_box_addr;
@ -385,31 +385,31 @@ struct wl12xx {
/* in dBm */
int power_level;
struct wl12xx_stats stats;
struct wl12xx_debugfs debugfs;
struct wl1251_stats stats;
struct wl1251_debugfs debugfs;
u32 buffer_32;
u32 buffer_cmd;
u8 buffer_busyword[WL12XX_BUSY_WORD_LEN];
struct wl12xx_rx_descriptor *rx_descriptor;
u8 buffer_busyword[WL1251_BUSY_WORD_LEN];
struct wl1251_rx_descriptor *rx_descriptor;
};
int wl12xx_plt_start(struct wl12xx *wl);
int wl12xx_plt_stop(struct wl12xx *wl);
int wl1251_plt_start(struct wl1251 *wl);
int wl1251_plt_stop(struct wl1251 *wl);
#define DEFAULT_HW_GEN_MODULATION_TYPE CCK_LONG /* Long Preamble */
#define DEFAULT_HW_GEN_TX_RATE RATE_2MBPS
#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */
#define WL12XX_DEFAULT_POWER_LEVEL 20
#define WL1251_DEFAULT_POWER_LEVEL 20
#define WL12XX_TX_QUEUE_MAX_LENGTH 20
#define WL1251_TX_QUEUE_MAX_LENGTH 20
/* Different chips need different sleep times after power on. WL1271 needs
* 200ms, WL1251 needs only 10ms. By default we use 200ms, but as soon as we
* know the chip ID, we change the sleep value in the wl12xx chip structure,
* know the chip ID, we change the sleep value in the wl1251 chip structure,
* so in subsequent power ons, we don't waste more time then needed. */
#define WL12XX_DEFAULT_POWER_ON_SLEEP 200
#define WL1251_DEFAULT_POWER_ON_SLEEP 200
#define CHIP_ID_1251_PG10 (0x7010101)
#define CHIP_ID_1251_PG11 (0x7020101)

229
drivers/net/wireless/wl12xx/wl1251_acx.c
View File

@ -5,18 +5,17 @@
#include <linux/spi/spi.h>
#include "wl1251.h"
#include "wl12xx_80211.h"
#include "reg.h"
#include "wl1251_spi.h"
#include "wl1251_ps.h"
int wl12xx_acx_frame_rates(struct wl12xx *wl, u8 ctrl_rate, u8 ctrl_mod,
int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
u8 mgt_rate, u8 mgt_mod)
{
struct acx_fw_gen_frame_rates *rates;
int ret;
wl12xx_debug(DEBUG_ACX, "acx frame rates");
wl1251_debug(DEBUG_ACX, "acx frame rates");
rates = kzalloc(sizeof(*rates), GFP_KERNEL);
if (!rates) {
@ -29,10 +28,10 @@ int wl12xx_acx_frame_rates(struct wl12xx *wl, u8 ctrl_rate, u8 ctrl_mod,
rates->tx_mgt_frame_rate = mgt_rate;
rates->tx_mgt_frame_mod = mgt_mod;
ret = wl12xx_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
ret = wl1251_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
rates, sizeof(*rates));
if (ret < 0) {
wl12xx_error("Failed to set FW rates and modulation");
wl1251_error("Failed to set FW rates and modulation");
goto out;
}
@ -42,12 +41,12 @@ out:
}
int wl12xx_acx_station_id(struct wl12xx *wl)
int wl1251_acx_station_id(struct wl1251 *wl)
{
struct acx_dot11_station_id *mac;
int ret, i;
wl12xx_debug(DEBUG_ACX, "acx dot11_station_id");
wl1251_debug(DEBUG_ACX, "acx dot11_station_id");
mac = kzalloc(sizeof(*mac), GFP_KERNEL);
if (!mac) {
@ -58,7 +57,7 @@ int wl12xx_acx_station_id(struct wl12xx *wl)
for (i = 0; i < ETH_ALEN; i++)
mac->mac[i] = wl->mac_addr[ETH_ALEN - 1 - i];
ret = wl12xx_cmd_configure(wl, DOT11_STATION_ID, mac, sizeof(*mac));
ret = wl1251_cmd_configure(wl, DOT11_STATION_ID, mac, sizeof(*mac));
if (ret < 0)
goto out;
@ -67,12 +66,12 @@ out:
return ret;
}
int wl12xx_acx_default_key(struct wl12xx *wl, u8 key_id)
int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id)
{
struct acx_dot11_default_key *default_key;
int ret;
wl12xx_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
wl1251_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
if (!default_key) {
@ -82,10 +81,10 @@ int wl12xx_acx_default_key(struct wl12xx *wl, u8 key_id)
default_key->id = key_id;
ret = wl12xx_cmd_configure(wl, DOT11_DEFAULT_KEY,
ret = wl1251_cmd_configure(wl, DOT11_DEFAULT_KEY,
default_key, sizeof(*default_key));
if (ret < 0) {
wl12xx_error("Couldnt set default key");
wl1251_error("Couldnt set default key");
goto out;
}
@ -96,13 +95,13 @@ out:
return ret;
}
int wl12xx_acx_wake_up_conditions(struct wl12xx *wl, u8 wake_up_event,
int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
u8 listen_interval)
{
struct acx_wake_up_condition *wake_up;
int ret;
wl12xx_debug(DEBUG_ACX, "acx wake up conditions");
wl1251_debug(DEBUG_ACX, "acx wake up conditions");
wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
if (!wake_up) {
@ -113,10 +112,10 @@ int wl12xx_acx_wake_up_conditions(struct wl12xx *wl, u8 wake_up_event,
wake_up->wake_up_event = wake_up_event;
wake_up->listen_interval = listen_interval;
ret = wl12xx_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
ret = wl1251_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
wake_up, sizeof(*wake_up));
if (ret < 0) {
wl12xx_warning("could not set wake up conditions: %d", ret);
wl1251_warning("could not set wake up conditions: %d", ret);
goto out;
}
@ -125,12 +124,12 @@ out:
return ret;
}
int wl12xx_acx_sleep_auth(struct wl12xx *wl, u8 sleep_auth)
int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
{
struct acx_sleep_auth *auth;
int ret;
wl12xx_debug(DEBUG_ACX, "acx sleep auth");
wl1251_debug(DEBUG_ACX, "acx sleep auth");
auth = kzalloc(sizeof(*auth), GFP_KERNEL);
if (!auth) {
@ -140,7 +139,7 @@ int wl12xx_acx_sleep_auth(struct wl12xx *wl, u8 sleep_auth)
auth->sleep_auth = sleep_auth;
ret = wl12xx_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
ret = wl1251_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
if (ret < 0)
return ret;
@ -149,12 +148,12 @@ out:
return ret;
}
int wl12xx_acx_fw_version(struct wl12xx *wl, char *buf, size_t len)
int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len)
{
struct acx_revision *rev;
int ret;
wl12xx_debug(DEBUG_ACX, "acx fw rev");
wl1251_debug(DEBUG_ACX, "acx fw rev");
rev = kzalloc(sizeof(*rev), GFP_KERNEL);
if (!rev) {
@ -162,9 +161,9 @@ int wl12xx_acx_fw_version(struct wl12xx *wl, char *buf, size_t len)
goto out;
}
ret = wl12xx_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
ret = wl1251_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
if (ret < 0) {
wl12xx_warning("ACX_FW_REV interrogate failed");
wl1251_warning("ACX_FW_REV interrogate failed");
goto out;
}
@ -183,12 +182,12 @@ out:
return ret;
}
int wl12xx_acx_tx_power(struct wl12xx *wl, int power)
int wl1251_acx_tx_power(struct wl1251 *wl, int power)
{
struct acx_current_tx_power *acx;
int ret;
wl12xx_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
wl1251_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
if (power < 0 || power > 25)
return -EINVAL;
@ -201,9 +200,9 @@ int wl12xx_acx_tx_power(struct wl12xx *wl, int power)
acx->current_tx_power = power * 10;
ret = wl12xx_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
ret = wl1251_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
if (ret < 0) {
wl12xx_warning("configure of tx power failed: %d", ret);
wl1251_warning("configure of tx power failed: %d", ret);
goto out;
}
@ -212,12 +211,12 @@ out:
return ret;
}
int wl12xx_acx_feature_cfg(struct wl12xx *wl)
int wl1251_acx_feature_cfg(struct wl1251 *wl)
{
struct acx_feature_config *feature;
int ret;
wl12xx_debug(DEBUG_ACX, "acx feature cfg");
wl1251_debug(DEBUG_ACX, "acx feature cfg");
feature = kzalloc(sizeof(*feature), GFP_KERNEL);
if (!feature) {
@ -229,10 +228,10 @@ int wl12xx_acx_feature_cfg(struct wl12xx *wl)
feature->data_flow_options = 0;
feature->options = 0;
ret = wl12xx_cmd_configure(wl, ACX_FEATURE_CFG,
ret = wl1251_cmd_configure(wl, ACX_FEATURE_CFG,
feature, sizeof(*feature));
if (ret < 0) {
wl12xx_error("Couldnt set HW encryption");
wl1251_error("Couldnt set HW encryption");
goto out;
}
@ -241,27 +240,27 @@ out:
return ret;
}
int wl12xx_acx_mem_map(struct wl12xx *wl, struct acx_header *mem_map,
int wl1251_acx_mem_map(struct wl1251 *wl, struct acx_header *mem_map,
size_t len)
{
int ret;
wl12xx_debug(DEBUG_ACX, "acx mem map");
wl1251_debug(DEBUG_ACX, "acx mem map");
ret = wl12xx_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
ret = wl1251_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_acx_data_path_params(struct wl12xx *wl,
int wl1251_acx_data_path_params(struct wl1251 *wl,
struct acx_data_path_params_resp *resp)
{
struct acx_data_path_params *params;
int ret;
wl12xx_debug(DEBUG_ACX, "acx data path params");
wl1251_debug(DEBUG_ACX, "acx data path params");
params = kzalloc(sizeof(*params), GFP_KERNEL);
if (!params) {
@ -281,20 +280,20 @@ int wl12xx_acx_data_path_params(struct wl12xx *wl,
params->tx_complete_timeout = DP_TX_COMPLETE_TIME_OUT;
ret = wl12xx_cmd_configure(wl, ACX_DATA_PATH_PARAMS,
ret = wl1251_cmd_configure(wl, ACX_DATA_PATH_PARAMS,
params, sizeof(*params));
if (ret < 0)
goto out;
/* FIXME: shouldn't this be ACX_DATA_PATH_RESP_PARAMS? */
ret = wl12xx_cmd_interrogate(wl, ACX_DATA_PATH_PARAMS,
ret = wl1251_cmd_interrogate(wl, ACX_DATA_PATH_PARAMS,
resp, sizeof(*resp));
if (ret < 0) {
wl12xx_warning("failed to read data path parameters: %d", ret);
wl1251_warning("failed to read data path parameters: %d", ret);
goto out;
} else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) {
wl12xx_warning("data path parameter acx status failed");
wl1251_warning("data path parameter acx status failed");
ret = -EIO;
goto out;
}
@ -304,12 +303,12 @@ out:
return ret;
}
int wl12xx_acx_rx_msdu_life_time(struct wl12xx *wl, u32 life_time)
int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time)
{
struct acx_rx_msdu_lifetime *acx;
int ret;
wl12xx_debug(DEBUG_ACX, "acx rx msdu life time");
wl1251_debug(DEBUG_ACX, "acx rx msdu life time");
acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@ -318,10 +317,10 @@ int wl12xx_acx_rx_msdu_life_time(struct wl12xx *wl, u32 life_time)
}
acx->lifetime = life_time;
ret = wl12xx_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
ret = wl1251_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
acx, sizeof(*acx));
if (ret < 0) {
wl12xx_warning("failed to set rx msdu life time: %d", ret);
wl1251_warning("failed to set rx msdu life time: %d", ret);
goto out;
}
@ -330,12 +329,12 @@ out:
return ret;
}
int wl12xx_acx_rx_config(struct wl12xx *wl, u32 config, u32 filter)
int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)
{
struct acx_rx_config *rx_config;
int ret;
wl12xx_debug(DEBUG_ACX, "acx rx config");
wl1251_debug(DEBUG_ACX, "acx rx config");
rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
if (!rx_config) {
@ -346,10 +345,10 @@ int wl12xx_acx_rx_config(struct wl12xx *wl, u32 config, u32 filter)
rx_config->config_options = config;
rx_config->filter_options = filter;
ret = wl12xx_cmd_configure(wl, ACX_RX_CFG,
ret = wl1251_cmd_configure(wl, ACX_RX_CFG,
rx_config, sizeof(*rx_config));
if (ret < 0) {
wl12xx_warning("failed to set rx config: %d", ret);
wl1251_warning("failed to set rx config: %d", ret);
goto out;
}
@ -358,12 +357,12 @@ out:
return ret;
}
int wl12xx_acx_pd_threshold(struct wl12xx *wl)
int wl1251_acx_pd_threshold(struct wl1251 *wl)
{
struct acx_packet_detection *pd;
int ret;
wl12xx_debug(DEBUG_ACX, "acx data pd threshold");
wl1251_debug(DEBUG_ACX, "acx data pd threshold");
pd = kzalloc(sizeof(*pd), GFP_KERNEL);
if (!pd) {
@ -373,9 +372,9 @@ int wl12xx_acx_pd_threshold(struct wl12xx *wl)
/* FIXME: threshold value not set */
ret = wl12xx_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
ret = wl1251_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
if (ret < 0) {
wl12xx_warning("failed to set pd threshold: %d", ret);
wl1251_warning("failed to set pd threshold: %d", ret);
goto out;
}
@ -384,12 +383,12 @@ out:
return 0;
}
int wl12xx_acx_slot(struct wl12xx *wl, enum acx_slot_type slot_time)
int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time)
{
struct acx_slot *slot;
int ret;
wl12xx_debug(DEBUG_ACX, "acx slot");
wl1251_debug(DEBUG_ACX, "acx slot");
slot = kzalloc(sizeof(*slot), GFP_KERNEL);
if (!slot) {
@ -400,9 +399,9 @@ int wl12xx_acx_slot(struct wl12xx *wl, enum acx_slot_type slot_time)
slot->wone_index = STATION_WONE_INDEX;
slot->slot_time = slot_time;
ret = wl12xx_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
ret = wl1251_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
if (ret < 0) {
wl12xx_warning("failed to set slot time: %d", ret);
wl1251_warning("failed to set slot time: %d", ret);
goto out;
}
@ -411,12 +410,12 @@ out:
return ret;
}
int wl12xx_acx_group_address_tbl(struct wl12xx *wl)
int wl1251_acx_group_address_tbl(struct wl1251 *wl)
{
struct acx_dot11_grp_addr_tbl *acx;
int ret;
wl12xx_debug(DEBUG_ACX, "acx group address tbl");
wl1251_debug(DEBUG_ACX, "acx group address tbl");
acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@ -429,10 +428,10 @@ int wl12xx_acx_group_address_tbl(struct wl12xx *wl)
acx->num_groups = 0;
memset(acx->mac_table, 0, ADDRESS_GROUP_MAX_LEN);
ret = wl12xx_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
ret = wl1251_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
acx, sizeof(*acx));
if (ret < 0) {
wl12xx_warning("failed to set group addr table: %d", ret);
wl1251_warning("failed to set group addr table: %d", ret);
goto out;
}
@ -441,7 +440,7 @@ out:
return ret;
}
int wl12xx_acx_service_period_timeout(struct wl12xx *wl)
int wl1251_acx_service_period_timeout(struct wl1251 *wl)
{
struct acx_rx_timeout *rx_timeout;
int ret;
@ -452,15 +451,15 @@ int wl12xx_acx_service_period_timeout(struct wl12xx *wl)
goto out;
}
wl12xx_debug(DEBUG_ACX, "acx service period timeout");
wl1251_debug(DEBUG_ACX, "acx service period timeout");
rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
ret = wl12xx_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
ret = wl1251_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
rx_timeout, sizeof(*rx_timeout));
if (ret < 0) {
wl12xx_warning("failed to set service period timeout: %d",
wl1251_warning("failed to set service period timeout: %d",
ret);
goto out;
}
@ -470,12 +469,12 @@ out:
return ret;
}
int wl12xx_acx_rts_threshold(struct wl12xx *wl, u16 rts_threshold)
int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold)
{
struct acx_rts_threshold *rts;
int ret;
wl12xx_debug(DEBUG_ACX, "acx rts threshold");
wl1251_debug(DEBUG_ACX, "acx rts threshold");
rts = kzalloc(sizeof(*rts), GFP_KERNEL);
if (!rts) {
@ -485,9 +484,9 @@ int wl12xx_acx_rts_threshold(struct wl12xx *wl, u16 rts_threshold)
rts->threshold = rts_threshold;
ret = wl12xx_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
ret = wl1251_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
if (ret < 0) {
wl12xx_warning("failed to set rts threshold: %d", ret);
wl1251_warning("failed to set rts threshold: %d", ret);
goto out;
}
@ -496,12 +495,12 @@ out:
return ret;
}
int wl12xx_acx_beacon_filter_opt(struct wl12xx *wl)
int wl1251_acx_beacon_filter_opt(struct wl1251 *wl)
{
struct acx_beacon_filter_option *beacon_filter;
int ret;
wl12xx_debug(DEBUG_ACX, "acx beacon filter opt");
wl1251_debug(DEBUG_ACX, "acx beacon filter opt");
beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
if (!beacon_filter) {
@ -512,10 +511,10 @@ int wl12xx_acx_beacon_filter_opt(struct wl12xx *wl)
beacon_filter->enable = 0;
beacon_filter->max_num_beacons = 0;
ret = wl12xx_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
beacon_filter, sizeof(*beacon_filter));
if (ret < 0) {
wl12xx_warning("failed to set beacon filter opt: %d", ret);
wl1251_warning("failed to set beacon filter opt: %d", ret);
goto out;
}
@ -524,12 +523,12 @@ out:
return ret;
}
int wl12xx_acx_beacon_filter_table(struct wl12xx *wl)
int wl1251_acx_beacon_filter_table(struct wl1251 *wl)
{
struct acx_beacon_filter_ie_table *ie_table;
int ret;
wl12xx_debug(DEBUG_ACX, "acx beacon filter table");
wl1251_debug(DEBUG_ACX, "acx beacon filter table");
ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
if (!ie_table) {
@ -540,10 +539,10 @@ int wl12xx_acx_beacon_filter_table(struct wl12xx *wl)
ie_table->num_ie = 0;
memset(ie_table->table, 0, BEACON_FILTER_TABLE_MAX_SIZE);
ret = wl12xx_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
ie_table, sizeof(*ie_table));
if (ret < 0) {
wl12xx_warning("failed to set beacon filter table: %d", ret);
wl1251_warning("failed to set beacon filter table: %d", ret);
goto out;
}
@ -552,12 +551,12 @@ out:
return ret;
}
int wl12xx_acx_sg_enable(struct wl12xx *wl)
int wl1251_acx_sg_enable(struct wl1251 *wl)
{
struct acx_bt_wlan_coex *pta;
int ret;
wl12xx_debug(DEBUG_ACX, "acx sg enable");
wl1251_debug(DEBUG_ACX, "acx sg enable");
pta = kzalloc(sizeof(*pta), GFP_KERNEL);
if (!pta) {
@ -567,9 +566,9 @@ int wl12xx_acx_sg_enable(struct wl12xx *wl)
pta->enable = SG_ENABLE;
ret = wl12xx_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
ret = wl1251_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
if (ret < 0) {
wl12xx_warning("failed to set softgemini enable: %d", ret);
wl1251_warning("failed to set softgemini enable: %d", ret);
goto out;
}
@ -578,12 +577,12 @@ out:
return ret;
}
int wl12xx_acx_sg_cfg(struct wl12xx *wl)
int wl1251_acx_sg_cfg(struct wl1251 *wl)
{
struct acx_bt_wlan_coex_param *param;
int ret;
wl12xx_debug(DEBUG_ACX, "acx sg cfg");
wl1251_debug(DEBUG_ACX, "acx sg cfg");
param = kzalloc(sizeof(*param), GFP_KERNEL);
if (!param) {
@ -621,9 +620,9 @@ int wl12xx_acx_sg_cfg(struct wl12xx *wl)
param->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_DEF;
ret = wl12xx_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
ret = wl1251_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
if (ret < 0) {
wl12xx_warning("failed to set sg config: %d", ret);
wl1251_warning("failed to set sg config: %d", ret);
goto out;
}
@ -632,12 +631,12 @@ out:
return ret;
}
int wl12xx_acx_cca_threshold(struct wl12xx *wl)
int wl1251_acx_cca_threshold(struct wl1251 *wl)
{
struct acx_energy_detection *detection;
int ret;
wl12xx_debug(DEBUG_ACX, "acx cca threshold");
wl1251_debug(DEBUG_ACX, "acx cca threshold");
detection = kzalloc(sizeof(*detection), GFP_KERNEL);
if (!detection) {
@ -648,10 +647,10 @@ int wl12xx_acx_cca_threshold(struct wl12xx *wl)
detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
detection->tx_energy_detection = 0;
ret = wl12xx_cmd_configure(wl, ACX_CCA_THRESHOLD,
ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
detection, sizeof(*detection));
if (ret < 0) {
wl12xx_warning("failed to set cca threshold: %d", ret);
wl1251_warning("failed to set cca threshold: %d", ret);
return ret;
}
@ -660,12 +659,12 @@ out:
return ret;
}
int wl12xx_acx_bcn_dtim_options(struct wl12xx *wl)
int wl1251_acx_bcn_dtim_options(struct wl1251 *wl)
{
struct acx_beacon_broadcast *bb;
int ret;
wl12xx_debug(DEBUG_ACX, "acx bcn dtim options");
wl1251_debug(DEBUG_ACX, "acx bcn dtim options");
bb = kzalloc(sizeof(*bb), GFP_KERNEL);
if (!bb) {
@ -678,9 +677,9 @@ int wl12xx_acx_bcn_dtim_options(struct wl12xx *wl)
bb->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
ret = wl12xx_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
ret = wl1251_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
if (ret < 0) {
wl12xx_warning("failed to set rx config: %d", ret);
wl1251_warning("failed to set rx config: %d", ret);
goto out;
}
@ -689,12 +688,12 @@ out:
return ret;
}
int wl12xx_acx_aid(struct wl12xx *wl, u16 aid)
int wl1251_acx_aid(struct wl1251 *wl, u16 aid)
{
struct acx_aid *acx_aid;
int ret;
wl12xx_debug(DEBUG_ACX, "acx aid");
wl1251_debug(DEBUG_ACX, "acx aid");
acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
if (!acx_aid) {
@ -704,9 +703,9 @@ int wl12xx_acx_aid(struct wl12xx *wl, u16 aid)
acx_aid->aid = aid;
ret = wl12xx_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
ret = wl1251_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
if (ret < 0) {
wl12xx_warning("failed to set aid: %d", ret);
wl1251_warning("failed to set aid: %d", ret);
goto out;
}
@ -715,12 +714,12 @@ out:
return ret;
}
int wl12xx_acx_event_mbox_mask(struct wl12xx *wl, u32 event_mask)
int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask)
{
struct acx_event_mask *mask;
int ret;
wl12xx_debug(DEBUG_ACX, "acx event mbox mask");
wl1251_debug(DEBUG_ACX, "acx event mbox mask");
mask = kzalloc(sizeof(*mask), GFP_KERNEL);
if (!mask) {
@ -733,10 +732,10 @@ int wl12xx_acx_event_mbox_mask(struct wl12xx *wl, u32 event_mask)
mask->event_mask = event_mask;
ret = wl12xx_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
ret = wl1251_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
mask, sizeof(*mask));
if (ret < 0) {
wl12xx_warning("failed to set acx_event_mbox_mask: %d", ret);
wl1251_warning("failed to set acx_event_mbox_mask: %d", ret);
goto out;
}
@ -745,12 +744,12 @@ out:
return ret;
}
int wl12xx_acx_set_preamble(struct wl12xx *wl, enum acx_preamble_type preamble)
int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble)
{
struct acx_preamble *acx;
int ret;
wl12xx_debug(DEBUG_ACX, "acx_set_preamble");
wl1251_debug(DEBUG_ACX, "acx_set_preamble");
acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@ -760,9 +759,9 @@ int wl12xx_acx_set_preamble(struct wl12xx *wl, enum acx_preamble_type preamble)
acx->preamble = preamble;
ret = wl12xx_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
ret = wl1251_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
if (ret < 0) {
wl12xx_warning("Setting of preamble failed: %d", ret);
wl1251_warning("Setting of preamble failed: %d", ret);
goto out;
}
@ -771,13 +770,13 @@ out:
return ret;
}
int wl12xx_acx_cts_protect(struct wl12xx *wl,
int wl1251_acx_cts_protect(struct wl1251 *wl,
enum acx_ctsprotect_type ctsprotect)
{
struct acx_ctsprotect *acx;
int ret;
wl12xx_debug(DEBUG_ACX, "acx_set_ctsprotect");
wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect");
acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@ -787,9 +786,9 @@ int wl12xx_acx_cts_protect(struct wl12xx *wl,
acx->ctsprotect = ctsprotect;
ret = wl12xx_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
ret = wl1251_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
if (ret < 0) {
wl12xx_warning("Setting of ctsprotect failed: %d", ret);
wl1251_warning("Setting of ctsprotect failed: %d", ret);
goto out;
}
@ -798,7 +797,7 @@ out:
return ret;
}
int wl12xx_acx_tsf_info(struct wl12xx *wl, u64 *mactime)
int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime)
{
struct acx_tsf_info *tsf_info;
int ret;
@ -809,10 +808,10 @@ int wl12xx_acx_tsf_info(struct wl12xx *wl, u64 *mactime)
goto out;
}
ret = wl12xx_cmd_interrogate(wl, ACX_TSF_INFO,
ret = wl1251_cmd_interrogate(wl, ACX_TSF_INFO,
tsf_info, sizeof(*tsf_info));
if (ret < 0) {
wl12xx_warning("ACX_FW_REV interrogate failed");
wl1251_warning("ACX_FW_REV interrogate failed");
goto out;
}
@ -824,16 +823,16 @@ out:
return ret;
}
int wl12xx_acx_statistics(struct wl12xx *wl, struct acx_statistics *stats)
int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats)
{
int ret;
wl12xx_debug(DEBUG_ACX, "acx statistics");
wl1251_debug(DEBUG_ACX, "acx statistics");
ret = wl12xx_cmd_interrogate(wl, ACX_STATISTICS, stats,
ret = wl1251_cmd_interrogate(wl, ACX_STATISTICS, stats,
sizeof(*stats));
if (ret < 0) {
wl12xx_warning("acx statistics failed: %d", ret);
wl1251_warning("acx statistics failed: %d", ret);
return -ENOMEM;
}

76
drivers/net/wireless/wl12xx/wl1251_acx.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -22,15 +22,15 @@
*
*/
#ifndef __WL12XX_ACX_H__
#define __WL12XX_ACX_H__
#ifndef __WL1251_ACX_H__
#define __WL1251_ACX_H__
#include "wl1251.h"
#include "wl1251_cmd.h"
/* Target's information element */
struct acx_header {
struct wl12xx_cmd_header cmd;
struct wl1251_cmd_header cmd;
/* acx (or information element) header */
u16 id;
@ -91,15 +91,15 @@ struct acx_revision {
u32 hw_version;
} __attribute__ ((packed));
enum wl12xx_psm_mode {
enum wl1251_psm_mode {
/* Active mode */
WL12XX_PSM_CAM = 0,
WL1251_PSM_CAM = 0,
/* Power save mode */
WL12XX_PSM_PS = 1,
WL1251_PSM_PS = 1,
/* Extreme low power */
WL12XX_PSM_ELP = 2,
WL1251_PSM_ELP = 2,
};
struct acx_sleep_auth {
@ -1108,39 +1108,39 @@ enum {
};
int wl12xx_acx_frame_rates(struct wl12xx *wl, u8 ctrl_rate, u8 ctrl_mod,
int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
u8 mgt_rate, u8 mgt_mod);
int wl12xx_acx_station_id(struct wl12xx *wl);
int wl12xx_acx_default_key(struct wl12xx *wl, u8 key_id);
int wl12xx_acx_wake_up_conditions(struct wl12xx *wl, u8 wake_up_event,
int wl1251_acx_station_id(struct wl1251 *wl);
int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id);
int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
u8 listen_interval);
int wl12xx_acx_sleep_auth(struct wl12xx *wl, u8 sleep_auth);
int wl12xx_acx_fw_version(struct wl12xx *wl, char *buf, size_t len);
int wl12xx_acx_tx_power(struct wl12xx *wl, int power);
int wl12xx_acx_feature_cfg(struct wl12xx *wl);
int wl12xx_acx_mem_map(struct wl12xx *wl,
int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth);
int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len);
int wl1251_acx_tx_power(struct wl1251 *wl, int power);
int wl1251_acx_feature_cfg(struct wl1251 *wl);
int wl1251_acx_mem_map(struct wl1251 *wl,
struct acx_header *mem_map, size_t len);
int wl12xx_acx_data_path_params(struct wl12xx *wl,
int wl1251_acx_data_path_params(struct wl1251 *wl,
struct acx_data_path_params_resp *data_path);
int wl12xx_acx_rx_msdu_life_time(struct wl12xx *wl, u32 life_time);
int wl12xx_acx_rx_config(struct wl12xx *wl, u32 config, u32 filter);
int wl12xx_acx_pd_threshold(struct wl12xx *wl);
int wl12xx_acx_slot(struct wl12xx *wl, enum acx_slot_type slot_time);
int wl12xx_acx_group_address_tbl(struct wl12xx *wl);
int wl12xx_acx_service_period_timeout(struct wl12xx *wl);
int wl12xx_acx_rts_threshold(struct wl12xx *wl, u16 rts_threshold);
int wl12xx_acx_beacon_filter_opt(struct wl12xx *wl);
int wl12xx_acx_beacon_filter_table(struct wl12xx *wl);
int wl12xx_acx_sg_enable(struct wl12xx *wl);
int wl12xx_acx_sg_cfg(struct wl12xx *wl);
int wl12xx_acx_cca_threshold(struct wl12xx *wl);
int wl12xx_acx_bcn_dtim_options(struct wl12xx *wl);
int wl12xx_acx_aid(struct wl12xx *wl, u16 aid);
int wl12xx_acx_event_mbox_mask(struct wl12xx *wl, u32 event_mask);
int wl12xx_acx_set_preamble(struct wl12xx *wl, enum acx_preamble_type preamble);
int wl12xx_acx_cts_protect(struct wl12xx *wl,
int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time);
int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter);
int wl1251_acx_pd_threshold(struct wl1251 *wl);
int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time);
int wl1251_acx_group_address_tbl(struct wl1251 *wl);
int wl1251_acx_service_period_timeout(struct wl1251 *wl);
int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold);
int wl1251_acx_beacon_filter_opt(struct wl1251 *wl);
int wl1251_acx_beacon_filter_table(struct wl1251 *wl);
int wl1251_acx_sg_enable(struct wl1251 *wl);
int wl1251_acx_sg_cfg(struct wl1251 *wl);
int wl1251_acx_cca_threshold(struct wl1251 *wl);
int wl1251_acx_bcn_dtim_options(struct wl1251 *wl);
int wl1251_acx_aid(struct wl1251 *wl, u16 aid);
int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask);
int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble);
int wl1251_acx_cts_protect(struct wl1251 *wl,
enum acx_ctsprotect_type ctsprotect);
int wl12xx_acx_statistics(struct wl12xx *wl, struct acx_statistics *stats);
int wl12xx_acx_tsf_info(struct wl12xx *wl, u64 *mactime);
int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats);
int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime);
#endif /* __WL12XX_ACX_H__ */
#endif /* __WL1251_ACX_H__ */

106
drivers/net/wireless/wl12xx/wl1251_boot.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008 Nokia Corporation
*
@ -28,37 +28,37 @@
#include "wl1251_spi.h"
#include "wl1251_event.h"
static void wl12xx_boot_enable_interrupts(struct wl12xx *wl)
static void wl1251_boot_enable_interrupts(struct wl1251 *wl)
{
enable_irq(wl->irq);
}
void wl12xx_boot_target_enable_interrupts(struct wl12xx *wl)
void wl1251_boot_target_enable_interrupts(struct wl1251 *wl)
{
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
wl12xx_reg_write32(wl, HI_CFG, HI_CFG_DEF_VAL);
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
wl1251_reg_write32(wl, HI_CFG, HI_CFG_DEF_VAL);
}
int wl12xx_boot_soft_reset(struct wl12xx *wl)
int wl1251_boot_soft_reset(struct wl1251 *wl)
{
unsigned long timeout;
u32 boot_data;
/* perform soft reset */
wl12xx_reg_write32(wl, ACX_REG_SLV_SOFT_RESET, ACX_SLV_SOFT_RESET_BIT);
wl1251_reg_write32(wl, ACX_REG_SLV_SOFT_RESET, ACX_SLV_SOFT_RESET_BIT);
/* SOFT_RESET is self clearing */
timeout = jiffies + usecs_to_jiffies(SOFT_RESET_MAX_TIME);
while (1) {
boot_data = wl12xx_reg_read32(wl, ACX_REG_SLV_SOFT_RESET);
wl12xx_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data);
boot_data = wl1251_reg_read32(wl, ACX_REG_SLV_SOFT_RESET);
wl1251_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data);
if ((boot_data & ACX_SLV_SOFT_RESET_BIT) == 0)
break;
if (time_after(jiffies, timeout)) {
/* 1.2 check pWhalBus->uSelfClearTime if the
* timeout was reached */
wl12xx_error("soft reset timeout");
wl1251_error("soft reset timeout");
return -1;
}
@ -66,15 +66,15 @@ int wl12xx_boot_soft_reset(struct wl12xx *wl)
}
/* disable Rx/Tx */
wl12xx_reg_write32(wl, ENABLE, 0x0);
wl1251_reg_write32(wl, ENABLE, 0x0);
/* disable auto calibration on start*/
wl12xx_reg_write32(wl, SPARE_A2, 0xffff);
wl1251_reg_write32(wl, SPARE_A2, 0xffff);
return 0;
}
int wl12xx_boot_init_seq(struct wl12xx *wl)
int wl1251_boot_init_seq(struct wl1251 *wl)
{
u32 scr_pad6, init_data, tmp, elp_cmd, ref_freq;
@ -96,23 +96,23 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
};
/* read NVS params */
scr_pad6 = wl12xx_reg_read32(wl, SCR_PAD6);
wl12xx_debug(DEBUG_BOOT, "scr_pad6 0x%x", scr_pad6);
scr_pad6 = wl1251_reg_read32(wl, SCR_PAD6);
wl1251_debug(DEBUG_BOOT, "scr_pad6 0x%x", scr_pad6);
/* read ELP_CMD */
elp_cmd = wl12xx_reg_read32(wl, ELP_CMD);
wl12xx_debug(DEBUG_BOOT, "elp_cmd 0x%x", elp_cmd);
elp_cmd = wl1251_reg_read32(wl, ELP_CMD);
wl1251_debug(DEBUG_BOOT, "elp_cmd 0x%x", elp_cmd);
/* set the BB calibration time to be 300 usec (PLL_CAL_TIME) */
ref_freq = scr_pad6 & 0x000000FF;
wl12xx_debug(DEBUG_BOOT, "ref_freq 0x%x", ref_freq);
wl1251_debug(DEBUG_BOOT, "ref_freq 0x%x", ref_freq);
wl12xx_reg_write32(wl, PLL_CAL_TIME, 0x9);
wl1251_reg_write32(wl, PLL_CAL_TIME, 0x9);
/*
* PG 1.2: set the clock buffer time to be 210 usec (CLK_BUF_TIME)
*/
wl12xx_reg_write32(wl, CLK_BUF_TIME, 0x6);
wl1251_reg_write32(wl, CLK_BUF_TIME, 0x6);
/*
* set the clock detect feature to work in the restart wu procedure
@ -120,18 +120,18 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
* (ELP_CFG_MODE[13:12])
*/
tmp = ((scr_pad6 & 0x0000FF00) << 4) | 0x00004000;
wl12xx_reg_write32(wl, ELP_CFG_MODE, tmp);
wl1251_reg_write32(wl, ELP_CFG_MODE, tmp);
/* PG 1.2: enable the BB PLL fix. Enable the PLL_LIMP_CLK_EN_CMD */
elp_cmd |= 0x00000040;
wl12xx_reg_write32(wl, ELP_CMD, elp_cmd);
wl1251_reg_write32(wl, ELP_CMD, elp_cmd);
/* PG 1.2: Set the BB PLL stable time to be 1000usec
* (PLL_STABLE_TIME) */
wl12xx_reg_write32(wl, CFG_PLL_SYNC_CNT, 0x20);
wl1251_reg_write32(wl, CFG_PLL_SYNC_CNT, 0x20);
/* PG 1.2: read clock request time */
init_data = wl12xx_reg_read32(wl, CLK_REQ_TIME);
init_data = wl1251_reg_read32(wl, CLK_REQ_TIME);
/*
* PG 1.2: set the clock request time to be ref_clk_settling_time -
@ -141,35 +141,35 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
tmp = init_data - 0x21;
else
tmp = 0;
wl12xx_reg_write32(wl, CLK_REQ_TIME, tmp);
wl1251_reg_write32(wl, CLK_REQ_TIME, tmp);
/* set BB PLL configurations in RF AFE */
wl12xx_reg_write32(wl, 0x003058cc, 0x4B5);
wl1251_reg_write32(wl, 0x003058cc, 0x4B5);
/* set RF_AFE_REG_5 */
wl12xx_reg_write32(wl, 0x003058d4, 0x50);
wl1251_reg_write32(wl, 0x003058d4, 0x50);
/* set RF_AFE_CTRL_REG_2 */
wl12xx_reg_write32(wl, 0x00305948, 0x11c001);
wl1251_reg_write32(wl, 0x00305948, 0x11c001);
/*
* change RF PLL and BB PLL divider for VCO clock and adjust VCO
* bais current(RF_AFE_REG_13)
*/
wl12xx_reg_write32(wl, 0x003058f4, 0x1e);
wl1251_reg_write32(wl, 0x003058f4, 0x1e);
/* set BB PLL configurations */
tmp = LUT[ref_freq][LUT_PARAM_INTEGER_DIVIDER] | 0x00017000;
wl12xx_reg_write32(wl, 0x00305840, tmp);
wl1251_reg_write32(wl, 0x00305840, tmp);
/* set fractional divider according to Appendix C-BB PLL
* Calculations
*/
tmp = LUT[ref_freq][LUT_PARAM_FRACTIONAL_DIVIDER];
wl12xx_reg_write32(wl, 0x00305844, tmp);
wl1251_reg_write32(wl, 0x00305844, tmp);
/* set the initial data for the sigma delta */
wl12xx_reg_write32(wl, 0x00305848, 0x3039);
wl1251_reg_write32(wl, 0x00305848, 0x3039);
/*
* set the accumulator attenuation value, calibration loop1
@ -178,14 +178,14 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
*/
tmp = (LUT[ref_freq][LUT_PARAM_ATTN_BB] << 16) |
(LUT[ref_freq][LUT_PARAM_ALPHA_BB] << 12) | 0x1;
wl12xx_reg_write32(wl, 0x00305854, tmp);
wl1251_reg_write32(wl, 0x00305854, tmp);
/*
* set the calibration stop time after holdoff time expires and set
* settling time HOLD_OFF_TIME_BB
*/
tmp = LUT[ref_freq][LUT_PARAM_STOP_TIME_BB] | 0x000A0000;
wl12xx_reg_write32(wl, 0x00305858, tmp);
wl1251_reg_write32(wl, 0x00305858, tmp);
/*
* set BB PLL Loop filter capacitor3- BB_C3[2:0] and set BB PLL
@ -193,7 +193,7 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
* BB_ILOOPF[7:3]
*/
tmp = LUT[ref_freq][LUT_PARAM_BB_PLL_LOOP_FILTER] | 0x00000030;
wl12xx_reg_write32(wl, 0x003058f8, tmp);
wl1251_reg_write32(wl, 0x003058f8, tmp);
/*
* set regulator output voltage for n divider to
@ -201,10 +201,10 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
* set BB PLL Loop filter capacitor2- BB_C2[7:5], set gain of BB
* PLL auto-call to normal mode- BB_CALGAIN_3DB[8]
*/
wl12xx_reg_write32(wl, 0x003058f0, 0x29);
wl1251_reg_write32(wl, 0x003058f0, 0x29);
/* enable restart wakeup sequence (ELP_CMD[0]) */
wl12xx_reg_write32(wl, ELP_CMD, elp_cmd | 0x1);
wl1251_reg_write32(wl, ELP_CMD, elp_cmd | 0x1);
/* restart sequence completed */
udelay(2000);
@ -212,19 +212,19 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
return 0;
}
int wl12xx_boot_run_firmware(struct wl12xx *wl)
int wl1251_boot_run_firmware(struct wl1251 *wl)
{
int loop, ret;
u32 chip_id, interrupt;
wl->chip.op_set_ecpu_ctrl(wl, ECPU_CONTROL_HALT);
chip_id = wl12xx_reg_read32(wl, CHIP_ID_B);
chip_id = wl1251_reg_read32(wl, CHIP_ID_B);
wl12xx_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id);
wl1251_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id);
if (chip_id != wl->chip.id) {
wl12xx_error("chip id doesn't match after firmware boot");
wl1251_error("chip id doesn't match after firmware boot");
return -EIO;
}
@ -232,41 +232,41 @@ int wl12xx_boot_run_firmware(struct wl12xx *wl)
loop = 0;
while (loop++ < INIT_LOOP) {
udelay(INIT_LOOP_DELAY);
interrupt = wl12xx_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
interrupt = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
if (interrupt == 0xffffffff) {
wl12xx_error("error reading hardware complete "
wl1251_error("error reading hardware complete "
"init indication");
return -EIO;
}
/* check that ACX_INTR_INIT_COMPLETE is enabled */
else if (interrupt & wl->chip.intr_init_complete) {
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
wl->chip.intr_init_complete);
break;
}
}
if (loop >= INIT_LOOP) {
wl12xx_error("timeout waiting for the hardware to "
wl1251_error("timeout waiting for the hardware to "
"complete initialization");
return -EIO;
}
/* get hardware config command mail box */
wl->cmd_box_addr = wl12xx_reg_read32(wl, REG_COMMAND_MAILBOX_PTR);
wl->cmd_box_addr = wl1251_reg_read32(wl, REG_COMMAND_MAILBOX_PTR);
/* get hardware config event mail box */
wl->event_box_addr = wl12xx_reg_read32(wl, REG_EVENT_MAILBOX_PTR);
wl->event_box_addr = wl1251_reg_read32(wl, REG_EVENT_MAILBOX_PTR);
/* set the working partition to its "running" mode offset */
wl12xx_set_partition(wl,
wl1251_set_partition(wl,
wl->chip.p_table[PART_WORK].mem.start,
wl->chip.p_table[PART_WORK].mem.size,
wl->chip.p_table[PART_WORK].reg.start,
wl->chip.p_table[PART_WORK].reg.size);
wl12xx_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x event_box_addr 0x%x",
wl1251_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x event_box_addr 0x%x",
wl->cmd_box_addr, wl->event_box_addr);
wl->chip.op_fw_version(wl);
@ -277,20 +277,20 @@ int wl12xx_boot_run_firmware(struct wl12xx *wl)
*/
/* enable gpio interrupts */
wl12xx_boot_enable_interrupts(wl);
wl1251_boot_enable_interrupts(wl);
wl->chip.op_target_enable_interrupts(wl);
/* unmask all mbox events */
wl->event_mask = 0xffffffff;
ret = wl12xx_event_unmask(wl);
ret = wl1251_event_unmask(wl);
if (ret < 0) {
wl12xx_error("EVENT mask setting failed");
wl1251_error("EVENT mask setting failed");
return ret;
}
wl12xx_event_mbox_config(wl);
wl1251_event_mbox_config(wl);
/* firmware startup completed */
return 0;

10
drivers/net/wireless/wl12xx/wl1251_boot.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008 Nokia Corporation
*
@ -26,10 +26,10 @@
#include "wl1251.h"
int wl12xx_boot_soft_reset(struct wl12xx *wl);
int wl12xx_boot_init_seq(struct wl12xx *wl);
int wl12xx_boot_run_firmware(struct wl12xx *wl);
void wl12xx_boot_target_enable_interrupts(struct wl12xx *wl);
int wl1251_boot_soft_reset(struct wl1251 *wl);
int wl1251_boot_init_seq(struct wl1251 *wl);
int wl1251_boot_run_firmware(struct wl1251 *wl);
void wl1251_boot_target_enable_interrupts(struct wl1251 *wl);
/* number of times we try to read the INIT interrupt */
#define INIT_LOOP 20000

133
drivers/net/wireless/wl12xx/wl1251_cmd.c
View File

@ -5,7 +5,6 @@
#include <linux/spi/spi.h>
#include "wl1251.h"
#include "wl12xx_80211.h"
#include "reg.h"
#include "wl1251_spi.h"
#include "wl1251_ps.h"
@ -19,9 +18,9 @@
* @buf: buffer containing the command, must work with dma
* @len: length of the buffer
*/
int wl12xx_cmd_send(struct wl12xx *wl, u16 id, void *buf, size_t len)
int wl1251_cmd_send(struct wl1251 *wl, u16 id, void *buf, size_t len)
{
struct wl12xx_cmd_header *cmd;
struct wl1251_cmd_header *cmd;
unsigned long timeout;
u32 intr;
int ret = 0;
@ -32,26 +31,26 @@ int wl12xx_cmd_send(struct wl12xx *wl, u16 id, void *buf, size_t len)
WARN_ON(len % 4 != 0);
wl12xx_spi_mem_write(wl, wl->cmd_box_addr, buf, len);
wl1251_spi_mem_write(wl, wl->cmd_box_addr, buf, len);
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);
timeout = jiffies + msecs_to_jiffies(WL12XX_COMMAND_TIMEOUT);
timeout = jiffies + msecs_to_jiffies(WL1251_COMMAND_TIMEOUT);
intr = wl12xx_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
while (!(intr & wl->chip.intr_cmd_complete)) {
if (time_after(jiffies, timeout)) {
wl12xx_error("command complete timeout");
wl1251_error("command complete timeout");
ret = -ETIMEDOUT;
goto out;
}
msleep(1);
intr = wl12xx_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
}
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
wl->chip.intr_cmd_complete);
out:
@ -66,33 +65,33 @@ out:
* @len: length of the buffer
* @answer: is answer needed
*/
int wl12xx_cmd_test(struct wl12xx *wl, void *buf, size_t buf_len, u8 answer)
int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer)
{
int ret;
wl12xx_debug(DEBUG_CMD, "cmd test");
wl1251_debug(DEBUG_CMD, "cmd test");
ret = wl12xx_cmd_send(wl, CMD_TEST, buf, buf_len);
ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len);
if (ret < 0) {
wl12xx_warning("TEST command failed");
wl1251_warning("TEST command failed");
return ret;
}
if (answer) {
struct wl12xx_command *cmd_answer;
struct wl1251_command *cmd_answer;
/*
* The test command got in, we can read the answer.
* The answer would be a wl12xx_command, where the
* The answer would be a wl1251_command, where the
* parameter array contains the actual answer.
*/
wl12xx_spi_mem_read(wl, wl->cmd_box_addr, buf, buf_len);
wl1251_spi_mem_read(wl, wl->cmd_box_addr, buf, buf_len);
cmd_answer = buf;
if (cmd_answer->header.status != CMD_STATUS_SUCCESS)
wl12xx_error("TEST command answer error: %d",
wl1251_error("TEST command answer error: %d",
cmd_answer->header.status);
}
@ -107,30 +106,30 @@ int wl12xx_cmd_test(struct wl12xx *wl, void *buf, size_t buf_len, u8 answer)
* @buf: buffer for the response, including all headers, must work with dma
* @len: lenght of buf
*/
int wl12xx_cmd_interrogate(struct wl12xx *wl, u16 id, void *buf, size_t len)
int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)
{
struct acx_header *acx = buf;
int ret;
wl12xx_debug(DEBUG_CMD, "cmd interrogate");
wl1251_debug(DEBUG_CMD, "cmd interrogate");
acx->id = id;
/* payload length, does not include any headers */
acx->len = len - sizeof(*acx);
ret = wl12xx_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
if (ret < 0) {
wl12xx_error("INTERROGATE command failed");
wl1251_error("INTERROGATE command failed");
goto out;
}
/* the interrogate command got in, we can read the answer */
wl12xx_spi_mem_read(wl, wl->cmd_box_addr, buf, len);
wl1251_spi_mem_read(wl, wl->cmd_box_addr, buf, len);
acx = buf;
if (acx->cmd.status != CMD_STATUS_SUCCESS)
wl12xx_error("INTERROGATE command error: %d",
wl1251_error("INTERROGATE command error: %d",
acx->cmd.status);
out:
@ -145,34 +144,34 @@ out:
* @buf: buffer containing acx, including all headers, must work with dma
* @len: length of buf
*/
int wl12xx_cmd_configure(struct wl12xx *wl, u16 id, void *buf, size_t len)
int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len)
{
struct acx_header *acx = buf;
int ret;
wl12xx_debug(DEBUG_CMD, "cmd configure");
wl1251_debug(DEBUG_CMD, "cmd configure");
acx->id = id;
/* payload length, does not include any headers */
acx->len = len - sizeof(*acx);
ret = wl12xx_cmd_send(wl, CMD_CONFIGURE, acx, len);
ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len);
if (ret < 0) {
wl12xx_warning("CONFIGURE command NOK");
wl1251_warning("CONFIGURE command NOK");
return ret;
}
return 0;
}
int wl12xx_cmd_vbm(struct wl12xx *wl, u8 identity,
int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
void *bitmap, u16 bitmap_len, u8 bitmap_control)
{
struct wl12xx_cmd_vbm_update *vbm;
struct wl1251_cmd_vbm_update *vbm;
int ret;
wl12xx_debug(DEBUG_CMD, "cmd vbm");
wl1251_debug(DEBUG_CMD, "cmd vbm");
vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
if (!vbm) {
@ -183,7 +182,7 @@ int wl12xx_cmd_vbm(struct wl12xx *wl, u8 identity,
/* Count and period will be filled by the target */
vbm->tim.bitmap_ctrl = bitmap_control;
if (bitmap_len > PARTIAL_VBM_MAX) {
wl12xx_warning("cmd vbm len is %d B, truncating to %d",
wl1251_warning("cmd vbm len is %d B, truncating to %d",
bitmap_len, PARTIAL_VBM_MAX);
bitmap_len = PARTIAL_VBM_MAX;
}
@ -193,9 +192,9 @@ int wl12xx_cmd_vbm(struct wl12xx *wl, u8 identity,
vbm->len = cpu_to_le16(bitmap_len + 5);
ret = wl12xx_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
if (ret < 0) {
wl12xx_error("VBM command failed");
wl1251_error("VBM command failed");
goto out;
}
@ -204,13 +203,13 @@ out:
return 0;
}
int wl12xx_cmd_data_path(struct wl12xx *wl, u8 channel, bool enable)
int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
{
struct cmd_enabledisable_path *cmd;
int ret;
u16 cmd_rx, cmd_tx;
wl12xx_debug(DEBUG_CMD, "cmd data path");
wl1251_debug(DEBUG_CMD, "cmd data path");
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@ -228,24 +227,24 @@ int wl12xx_cmd_data_path(struct wl12xx *wl, u8 channel, bool enable)
cmd_tx = CMD_DISABLE_TX;
}
ret = wl12xx_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
if (ret < 0) {
wl12xx_error("rx %s cmd for channel %d failed",
wl1251_error("rx %s cmd for channel %d failed",
enable ? "start" : "stop", channel);
goto out;
}
wl12xx_debug(DEBUG_BOOT, "rx %s cmd channel %d",
wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
enable ? "start" : "stop", channel);
ret = wl12xx_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
if (ret < 0) {
wl12xx_error("tx %s cmd for channel %d failed",
wl1251_error("tx %s cmd for channel %d failed",
enable ? "start" : "stop", channel);
return ret;
}
wl12xx_debug(DEBUG_BOOT, "tx %s cmd channel %d",
wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
enable ? "start" : "stop", channel);
out:
@ -253,7 +252,7 @@ out:
return ret;
}
int wl1251_cmd_join(struct wl12xx *wl, u8 bss_type, u8 dtim_interval,
int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 dtim_interval,
u16 beacon_interval, u8 wait)
{
unsigned long timeout;
@ -268,14 +267,14 @@ int wl1251_cmd_join(struct wl12xx *wl, u8 bss_type, u8 dtim_interval,
}
/* FIXME: this should be in main.c */
ret = wl12xx_acx_frame_rates(wl, DEFAULT_HW_GEN_TX_RATE,
ret = wl1251_acx_frame_rates(wl, DEFAULT_HW_GEN_TX_RATE,
DEFAULT_HW_GEN_MODULATION_TYPE,
wl->tx_mgmt_frm_rate,
wl->tx_mgmt_frm_mod);
if (ret < 0)
goto out;
wl12xx_debug(DEBUG_CMD, "cmd join");
wl1251_debug(DEBUG_CMD, "cmd join");
/* Reverse order BSSID */
bssid = (u8 *) &join->bssid_lsb;
@ -294,9 +293,9 @@ int wl1251_cmd_join(struct wl12xx *wl, u8 bss_type, u8 dtim_interval,
join->channel = wl->channel;
join->ctrl = JOIN_CMD_CTRL_TX_FLUSH;
ret = wl12xx_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
if (ret < 0) {
wl12xx_error("failed to initiate cmd join");
wl1251_error("failed to initiate cmd join");
goto out;
}
@ -314,20 +313,20 @@ out:
return ret;
}
int wl12xx_cmd_ps_mode(struct wl12xx *wl, u8 ps_mode)
int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
{
struct wl12xx_cmd_ps_params *ps_params = NULL;
struct wl1251_cmd_ps_params *ps_params = NULL;
int ret = 0;
/* FIXME: this should be in ps.c */
ret = wl12xx_acx_wake_up_conditions(wl, WAKE_UP_EVENT_DTIM_BITMAP,
ret = wl1251_acx_wake_up_conditions(wl, WAKE_UP_EVENT_DTIM_BITMAP,
wl->listen_int);
if (ret < 0) {
wl12xx_error("couldn't set wake up conditions");
wl1251_error("couldn't set wake up conditions");
goto out;
}
wl12xx_debug(DEBUG_CMD, "cmd set ps mode");
wl1251_debug(DEBUG_CMD, "cmd set ps mode");
ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
if (!ps_params) {
@ -341,10 +340,10 @@ int wl12xx_cmd_ps_mode(struct wl12xx *wl, u8 ps_mode)
ps_params->hang_over_period = 128;
ps_params->null_data_rate = 1; /* 1 Mbps */
ret = wl12xx_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
sizeof(*ps_params));
if (ret < 0) {
wl12xx_error("cmd set_ps_mode failed");
wl1251_error("cmd set_ps_mode failed");
goto out;
}
@ -353,13 +352,13 @@ out:
return ret;
}
int wl12xx_cmd_read_memory(struct wl12xx *wl, u32 addr, void *answer,
int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
size_t len)
{
struct cmd_read_write_memory *cmd;
int ret = 0;
wl12xx_debug(DEBUG_CMD, "cmd read memory");
wl1251_debug(DEBUG_CMD, "cmd read memory");
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@ -373,17 +372,17 @@ int wl12xx_cmd_read_memory(struct wl12xx *wl, u32 addr, void *answer,
cmd->addr = addr;
cmd->size = len;
ret = wl12xx_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
if (ret < 0) {
wl12xx_error("read memory command failed: %d", ret);
wl1251_error("read memory command failed: %d", ret);
goto out;
}
/* the read command got in, we can now read the answer */
wl12xx_spi_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
wl1251_spi_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
if (cmd->header.status != CMD_STATUS_SUCCESS)
wl12xx_error("error in read command result: %d",
wl1251_error("error in read command result: %d",
cmd->header.status);
memcpy(answer, cmd->value, len);
@ -393,17 +392,17 @@ out:
return ret;
}
int wl12xx_cmd_template_set(struct wl12xx *wl, u16 cmd_id,
int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
void *buf, size_t buf_len)
{
struct wl12xx_cmd_packet_template *cmd;
struct wl1251_cmd_packet_template *cmd;
size_t cmd_len;
int ret = 0;
wl12xx_debug(DEBUG_CMD, "cmd template %d", cmd_id);
wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id);
WARN_ON(buf_len > WL12XX_MAX_TEMPLATE_SIZE);
buf_len = min_t(size_t, buf_len, WL12XX_MAX_TEMPLATE_SIZE);
WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4);
cmd = kzalloc(cmd_len, GFP_KERNEL);
@ -417,9 +416,9 @@ int wl12xx_cmd_template_set(struct wl12xx *wl, u16 cmd_id,
if (buf)
memcpy(cmd->data, buf, buf_len);
ret = wl12xx_cmd_send(wl, cmd_id, cmd, cmd_len);
ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len);
if (ret < 0) {
wl12xx_warning("cmd set_template failed: %d", ret);
wl1251_warning("cmd set_template failed: %d", ret);
goto out;
}

78
drivers/net/wireless/wl12xx/wl1251_cmd.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -22,32 +22,32 @@
*
*/
#ifndef __WL12XX_CMD_H__
#define __WL12XX_CMD_H__
#ifndef __WL1251_CMD_H__
#define __WL1251_CMD_H__
#include "wl1251.h"
struct acx_header;
int wl12xx_cmd_send(struct wl12xx *wl, u16 type, void *buf, size_t buf_len);
int wl12xx_cmd_test(struct wl12xx *wl, void *buf, size_t buf_len, u8 answer);
int wl12xx_cmd_interrogate(struct wl12xx *wl, u16 id, void *buf, size_t len);
int wl12xx_cmd_configure(struct wl12xx *wl, u16 id, void *buf, size_t len);
int wl12xx_cmd_vbm(struct wl12xx *wl, u8 identity,
int wl1251_cmd_send(struct wl1251 *wl, u16 type, void *buf, size_t buf_len);
int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer);
int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len);
int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len);
int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
void *bitmap, u16 bitmap_len, u8 bitmap_control);
int wl12xx_cmd_data_path(struct wl12xx *wl, u8 channel, bool enable);
int wl1251_cmd_join(struct wl12xx *wl, u8 bss_type, u8 dtim_interval,
int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable);
int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 dtim_interval,
u16 beacon_interval, u8 wait);
int wl12xx_cmd_ps_mode(struct wl12xx *wl, u8 ps_mode);
int wl12xx_cmd_read_memory(struct wl12xx *wl, u32 addr, void *answer,
int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode);
int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
size_t len);
int wl12xx_cmd_template_set(struct wl12xx *wl, u16 cmd_id,
int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
void *buf, size_t buf_len);
/* unit ms */
#define WL12XX_COMMAND_TIMEOUT 2000
#define WL1251_COMMAND_TIMEOUT 2000
enum wl12xx_commands {
enum wl1251_commands {
CMD_RESET = 0,
CMD_INTERROGATE = 1, /*use this to read information elements*/
CMD_CONFIGURE = 2, /*use this to write information elements*/
@ -95,15 +95,15 @@ enum wl12xx_commands {
#define MAX_CMD_PARAMS 572
struct wl12xx_cmd_header {
struct wl1251_cmd_header {
u16 id;
u16 status;
/* payload */
u8 data[0];
} __attribute__ ((packed));
struct wl12xx_command {
struct wl12xx_cmd_header header;
struct wl1251_command {
struct wl1251_cmd_header header;
u8 parameters[MAX_CMD_PARAMS];
};
@ -145,7 +145,7 @@ enum {
#define MAX_READ_SIZE 256
struct cmd_read_write_memory {
struct wl12xx_cmd_header header;
struct wl1251_cmd_header header;
/* The address of the memory to read from or write to.*/
u32 addr;
@ -214,7 +214,7 @@ struct basic_scan_channel_parameters {
#define SCAN_MAX_NUM_OF_CHANNELS 16
struct cmd_scan {
struct wl12xx_cmd_header header;
struct wl1251_cmd_header header;
struct basic_scan_parameters params;
struct basic_scan_channel_parameters channels[SCAN_MAX_NUM_OF_CHANNELS];
@ -232,7 +232,7 @@ enum {
struct cmd_join {
struct wl12xx_cmd_header header;
struct wl1251_cmd_header header;
u32 bssid_lsb;
u16 bssid_msb;
@ -269,16 +269,16 @@ struct cmd_join {
} __attribute__ ((packed));
struct cmd_enabledisable_path {
struct wl12xx_cmd_header header;
struct wl1251_cmd_header header;
u8 channel;
u8 padding[3];
} __attribute__ ((packed));
#define WL12XX_MAX_TEMPLATE_SIZE 300
#define WL1251_MAX_TEMPLATE_SIZE 300
struct wl12xx_cmd_packet_template {
struct wl12xx_cmd_header header;
struct wl1251_cmd_packet_template {
struct wl1251_cmd_header header;
__le16 size;
u8 data[0];
@ -287,7 +287,7 @@ struct wl12xx_cmd_packet_template {
#define TIM_ELE_ID 5
#define PARTIAL_VBM_MAX 251
struct wl12xx_tim {
struct wl1251_tim {
u8 identity;
u8 length;
u8 dtim_count;
@ -297,20 +297,20 @@ struct wl12xx_tim {
} __attribute__ ((packed));
/* Virtual Bit Map update */
struct wl12xx_cmd_vbm_update {
struct wl12xx_cmd_header header;
struct wl1251_cmd_vbm_update {
struct wl1251_cmd_header header;
__le16 len;
u8 padding[2];
struct wl12xx_tim tim;
struct wl1251_tim tim;
} __attribute__ ((packed));
enum wl12xx_cmd_ps_mode {
enum wl1251_cmd_ps_mode {
STATION_ACTIVE_MODE,
STATION_POWER_SAVE_MODE
};
struct wl12xx_cmd_ps_params {
struct wl12xx_cmd_header header;
struct wl1251_cmd_ps_params {
struct wl1251_cmd_header header;
u8 ps_mode; /* STATION_* */
u8 send_null_data; /* Do we have to send NULL data packet ? */
@ -325,8 +325,8 @@ struct wl12xx_cmd_ps_params {
u8 pad[2];
} __attribute__ ((packed));
struct wl12xx_cmd_trigger_scan_to {
struct wl12xx_cmd_header header;
struct wl1251_cmd_trigger_scan_to {
struct wl1251_cmd_header header;
u32 timeout;
};
@ -340,14 +340,14 @@ struct wl12xx_cmd_trigger_scan_to {
/* When set, disable HW decryption */
#define DF_SNIFF_MODE_ENABLE 0x80
enum wl12xx_cmd_key_action {
enum wl1251_cmd_key_action {
KEY_ADD_OR_REPLACE = 1,
KEY_REMOVE = 2,
KEY_SET_ID = 3,
MAX_KEY_ACTION = 0xffff,
};
enum wl12xx_cmd_key_type {
enum wl1251_cmd_key_type {
KEY_WEP_DEFAULT = 0,
KEY_WEP_ADDR = 1,
KEY_AES_GROUP = 4,
@ -374,8 +374,8 @@ enum wl12xx_cmd_key_type {
*
*/
struct wl12xx_cmd_set_keys {
struct wl12xx_cmd_header header;
struct wl1251_cmd_set_keys {
struct wl1251_cmd_header header;
/* Ignored for default WEP key */
u8 addr[ETH_ALEN];
@ -404,4 +404,4 @@ struct wl12xx_cmd_set_keys {
} __attribute__ ((packed));
#endif /* __WL12XX_CMD_H__ */
#endif /* __WL1251_CMD_H__ */

48
drivers/net/wireless/wl12xx/wl1251_debugfs.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2009 Nokia Corporation
*
@ -30,7 +30,7 @@
#include "wl1251_ps.h"
/* ms */
#define WL12XX_DEBUGFS_STATS_LIFETIME 1000
#define WL1251_DEBUGFS_STATS_LIFETIME 1000
/* debugfs macros idea from mac80211 */
@ -38,7 +38,7 @@
static ssize_t name## _read(struct file *file, char __user *userbuf, \
size_t count, loff_t *ppos) \
{ \
struct wl12xx *wl = file->private_data; \
struct wl1251 *wl = file->private_data; \
char buf[buflen]; \
int res; \
\
@ -48,7 +48,7 @@ static ssize_t name## _read(struct file *file, char __user *userbuf, \
\
static const struct file_operations name## _ops = { \
.read = name## _read, \
.open = wl12xx_open_file_generic, \
.open = wl1251_open_file_generic, \
};
#define DEBUGFS_ADD(name, parent) \
@ -71,11 +71,11 @@ static ssize_t sub## _ ##name## _read(struct file *file, \
char __user *userbuf, \
size_t count, loff_t *ppos) \
{ \
struct wl12xx *wl = file->private_data; \
struct wl1251 *wl = file->private_data; \
char buf[buflen]; \
int res; \
\
wl12xx_debugfs_update_stats(wl); \
wl1251_debugfs_update_stats(wl); \
\
res = scnprintf(buf, buflen, fmt "\n", \
wl->stats.fw_stats->sub.name); \
@ -84,7 +84,7 @@ static ssize_t sub## _ ##name## _read(struct file *file, \
\
static const struct file_operations sub## _ ##name## _ops = { \
.read = sub## _ ##name## _read, \
.open = wl12xx_open_file_generic, \
.open = wl1251_open_file_generic, \
};
#define DEBUGFS_FWSTATS_ADD(sub, name) \
@ -93,30 +93,30 @@ static const struct file_operations sub## _ ##name## _ops = { \
#define DEBUGFS_FWSTATS_DEL(sub, name) \
DEBUGFS_DEL(sub## _ ##name)
static void wl12xx_debugfs_update_stats(struct wl12xx *wl)
static void wl1251_debugfs_update_stats(struct wl1251 *wl)
{
int ret;
mutex_lock(&wl->mutex);
ret = wl12xx_ps_elp_wakeup(wl);
ret = wl1251_ps_elp_wakeup(wl);
if (ret < 0)
goto out;
if (wl->state == WL12XX_STATE_ON &&
if (wl->state == WL1251_STATE_ON &&
time_after(jiffies, wl->stats.fw_stats_update +
msecs_to_jiffies(WL12XX_DEBUGFS_STATS_LIFETIME))) {
wl12xx_acx_statistics(wl, wl->stats.fw_stats);
msecs_to_jiffies(WL1251_DEBUGFS_STATS_LIFETIME))) {
wl1251_acx_statistics(wl, wl->stats.fw_stats);
wl->stats.fw_stats_update = jiffies;
}
wl12xx_ps_elp_sleep(wl);
wl1251_ps_elp_sleep(wl);
out:
mutex_unlock(&wl->mutex);
}
static int wl12xx_open_file_generic(struct inode *inode, struct file *file)
static int wl1251_open_file_generic(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
@ -221,7 +221,7 @@ DEBUGFS_READONLY_FILE(excessive_retries, 20, "%u",
static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
size_t count, loff_t *ppos)
{
struct wl12xx *wl = file->private_data;
struct wl1251 *wl = file->private_data;
u32 queue_len;
char buf[20];
int res;
@ -234,10 +234,10 @@ static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
static const struct file_operations tx_queue_len_ops = {
.read = tx_queue_len_read,
.open = wl12xx_open_file_generic,
.open = wl1251_open_file_generic,
};
static void wl12xx_debugfs_delete_files(struct wl12xx *wl)
static void wl1251_debugfs_delete_files(struct wl1251 *wl)
{
DEBUGFS_FWSTATS_DEL(tx, internal_desc_overflow);
@ -335,7 +335,7 @@ static void wl12xx_debugfs_delete_files(struct wl12xx *wl)
DEBUGFS_DEL(excessive_retries);
}
static int wl12xx_debugfs_add_files(struct wl12xx *wl)
static int wl1251_debugfs_add_files(struct wl1251 *wl)
{
int ret = 0;
@ -436,19 +436,19 @@ static int wl12xx_debugfs_add_files(struct wl12xx *wl)
out:
if (ret < 0)
wl12xx_debugfs_delete_files(wl);
wl1251_debugfs_delete_files(wl);
return ret;
}
void wl12xx_debugfs_reset(struct wl12xx *wl)
void wl1251_debugfs_reset(struct wl1251 *wl)
{
memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
wl->stats.retry_count = 0;
wl->stats.excessive_retries = 0;
}
int wl12xx_debugfs_init(struct wl12xx *wl)
int wl1251_debugfs_init(struct wl1251 *wl)
{
int ret;
@ -479,7 +479,7 @@ int wl12xx_debugfs_init(struct wl12xx *wl)
wl->stats.fw_stats_update = jiffies;
ret = wl12xx_debugfs_add_files(wl);
ret = wl1251_debugfs_add_files(wl);
if (ret < 0)
goto err_file;
@ -502,9 +502,9 @@ err:
return ret;
}
void wl12xx_debugfs_exit(struct wl12xx *wl)
void wl1251_debugfs_exit(struct wl1251 *wl)
{
wl12xx_debugfs_delete_files(wl);
wl1251_debugfs_delete_files(wl);
kfree(wl->stats.fw_stats);
wl->stats.fw_stats = NULL;

14
drivers/net/wireless/wl12xx/wl1251_debugfs.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2009 Nokia Corporation
*
@ -21,13 +21,13 @@
*
*/
#ifndef WL12XX_DEBUGFS_H
#define WL12XX_DEBUGFS_H
#ifndef WL1251_DEBUGFS_H
#define WL1251_DEBUGFS_H
#include "wl1251.h"
int wl12xx_debugfs_init(struct wl12xx *wl);
void wl12xx_debugfs_exit(struct wl12xx *wl);
void wl12xx_debugfs_reset(struct wl12xx *wl);
int wl1251_debugfs_init(struct wl1251 *wl);
void wl1251_debugfs_exit(struct wl1251 *wl);
void wl1251_debugfs_reset(struct wl1251 *wl);
#endif /* WL12XX_DEBUGFS_H */
#endif /* WL1251_DEBUGFS_H */

46
drivers/net/wireless/wl12xx/wl1251_event.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -28,10 +28,10 @@
#include "wl1251_event.h"
#include "wl1251_ps.h"
static int wl12xx_event_scan_complete(struct wl12xx *wl,
static int wl1251_event_scan_complete(struct wl1251 *wl,
struct event_mailbox *mbox)
{
wl12xx_debug(DEBUG_EVENT, "status: 0x%x, channels: %d",
wl1251_debug(DEBUG_EVENT, "status: 0x%x, channels: %d",
mbox->scheduled_scan_status,
mbox->scheduled_scan_channels);
@ -45,34 +45,34 @@ static int wl12xx_event_scan_complete(struct wl12xx *wl,
return 0;
}
static void wl12xx_event_mbox_dump(struct event_mailbox *mbox)
static void wl1251_event_mbox_dump(struct event_mailbox *mbox)
{
wl12xx_debug(DEBUG_EVENT, "MBOX DUMP:");
wl12xx_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
wl12xx_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
wl1251_debug(DEBUG_EVENT, "MBOX DUMP:");
wl1251_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
wl1251_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
}
static int wl12xx_event_process(struct wl12xx *wl, struct event_mailbox *mbox)
static int wl1251_event_process(struct wl1251 *wl, struct event_mailbox *mbox)
{
int ret;
u32 vector;
wl12xx_event_mbox_dump(mbox);
wl1251_event_mbox_dump(mbox);
vector = mbox->events_vector & ~(mbox->events_mask);
wl12xx_debug(DEBUG_EVENT, "vector: 0x%x", vector);
wl1251_debug(DEBUG_EVENT, "vector: 0x%x", vector);
if (vector & SCAN_COMPLETE_EVENT_ID) {
ret = wl12xx_event_scan_complete(wl, mbox);
ret = wl1251_event_scan_complete(wl, mbox);
if (ret < 0)
return ret;
}
if (vector & BSS_LOSE_EVENT_ID) {
wl12xx_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");
wl1251_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");
if (wl->psm_requested && wl->psm) {
ret = wl12xx_ps_set_mode(wl, STATION_ACTIVE_MODE);
ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE);
if (ret < 0)
return ret;
}
@ -81,47 +81,47 @@ static int wl12xx_event_process(struct wl12xx *wl, struct event_mailbox *mbox)
return 0;
}
int wl12xx_event_unmask(struct wl12xx *wl)
int wl1251_event_unmask(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_event_mbox_mask(wl, ~(wl->event_mask));
ret = wl1251_acx_event_mbox_mask(wl, ~(wl->event_mask));
if (ret < 0)
return ret;
return 0;
}
void wl12xx_event_mbox_config(struct wl12xx *wl)
void wl1251_event_mbox_config(struct wl1251 *wl)
{
wl->mbox_ptr[0] = wl12xx_reg_read32(wl, REG_EVENT_MAILBOX_PTR);
wl->mbox_ptr[0] = wl1251_reg_read32(wl, REG_EVENT_MAILBOX_PTR);
wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);
wl12xx_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
wl1251_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
wl->mbox_ptr[0], wl->mbox_ptr[1]);
}
int wl12xx_event_handle(struct wl12xx *wl, u8 mbox_num)
int wl1251_event_handle(struct wl1251 *wl, u8 mbox_num)
{
struct event_mailbox mbox;
int ret;
wl12xx_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);
wl1251_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);
if (mbox_num > 1)
return -EINVAL;
/* first we read the mbox descriptor */
wl12xx_spi_mem_read(wl, wl->mbox_ptr[mbox_num], &mbox,
wl1251_spi_mem_read(wl, wl->mbox_ptr[mbox_num], &mbox,
sizeof(struct event_mailbox));
/* process the descriptor */
ret = wl12xx_event_process(wl, &mbox);
ret = wl1251_event_process(wl, &mbox);
if (ret < 0)
return ret;
/* then we let the firmware know it can go on...*/
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK);
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK);
return 0;
}

12
drivers/net/wireless/wl12xx/wl1251_event.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -22,8 +22,8 @@
*
*/
#ifndef __WL12XX_EVENT_H__
#define __WL12XX_EVENT_H__
#ifndef __WL1251_EVENT_H__
#define __WL1251_EVENT_H__
/*
* Mbox events
@ -114,8 +114,8 @@ struct event_mailbox {
u8 padding[19];
} __attribute__ ((packed));
int wl12xx_event_unmask(struct wl12xx *wl);
void wl12xx_event_mbox_config(struct wl12xx *wl);
int wl12xx_event_handle(struct wl12xx *wl, u8 mbox);
int wl1251_event_unmask(struct wl1251 *wl);
void wl1251_event_mbox_config(struct wl1251 *wl);
int wl1251_event_handle(struct wl1251 *wl, u8 mbox);
#endif

72
drivers/net/wireless/wl12xx/wl1251_init.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2009 Nokia Corporation
*
@ -29,59 +29,59 @@
#include "wl1251_acx.h"
#include "wl1251_cmd.h"
int wl12xx_hw_init_hwenc_config(struct wl12xx *wl)
int wl1251_hw_init_hwenc_config(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_feature_cfg(wl);
ret = wl1251_acx_feature_cfg(wl);
if (ret < 0) {
wl12xx_warning("couldn't set feature config");
wl1251_warning("couldn't set feature config");
return ret;
}
ret = wl12xx_acx_default_key(wl, wl->default_key);
ret = wl1251_acx_default_key(wl, wl->default_key);
if (ret < 0) {
wl12xx_warning("couldn't set default key");
wl1251_warning("couldn't set default key");
return ret;
}
return 0;
}
int wl12xx_hw_init_templates_config(struct wl12xx *wl)
int wl1251_hw_init_templates_config(struct wl1251 *wl)
{
int ret;
u8 partial_vbm[PARTIAL_VBM_MAX];
/* send empty templates for fw memory reservation */
ret = wl12xx_cmd_template_set(wl, CMD_PROBE_REQ, NULL,
ret = wl1251_cmd_template_set(wl, CMD_PROBE_REQ, NULL,
sizeof(struct wl12xx_probe_req_template));
if (ret < 0)
return ret;
ret = wl12xx_cmd_template_set(wl, CMD_NULL_DATA, NULL,
ret = wl1251_cmd_template_set(wl, CMD_NULL_DATA, NULL,
sizeof(struct wl12xx_null_data_template));
if (ret < 0)
return ret;
ret = wl12xx_cmd_template_set(wl, CMD_PS_POLL, NULL,
ret = wl1251_cmd_template_set(wl, CMD_PS_POLL, NULL,
sizeof(struct wl12xx_ps_poll_template));
if (ret < 0)
return ret;
ret = wl12xx_cmd_template_set(wl, CMD_QOS_NULL_DATA, NULL,
ret = wl1251_cmd_template_set(wl, CMD_QOS_NULL_DATA, NULL,
sizeof
(struct wl12xx_qos_null_data_template));
if (ret < 0)
return ret;
ret = wl12xx_cmd_template_set(wl, CMD_PROBE_RESP, NULL,
ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, NULL,
sizeof
(struct wl12xx_probe_resp_template));
if (ret < 0)
return ret;
ret = wl12xx_cmd_template_set(wl, CMD_BEACON, NULL,
ret = wl1251_cmd_template_set(wl, CMD_BEACON, NULL,
sizeof
(struct wl12xx_beacon_template));
if (ret < 0)
@ -89,112 +89,112 @@ int wl12xx_hw_init_templates_config(struct wl12xx *wl)
/* tim templates, first reserve space then allocate an empty one */
memset(partial_vbm, 0, PARTIAL_VBM_MAX);
ret = wl12xx_cmd_vbm(wl, TIM_ELE_ID, partial_vbm, PARTIAL_VBM_MAX, 0);
ret = wl1251_cmd_vbm(wl, TIM_ELE_ID, partial_vbm, PARTIAL_VBM_MAX, 0);
if (ret < 0)
return ret;
ret = wl12xx_cmd_vbm(wl, TIM_ELE_ID, partial_vbm, 1, 0);
ret = wl1251_cmd_vbm(wl, TIM_ELE_ID, partial_vbm, 1, 0);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_rx_config(struct wl12xx *wl, u32 config, u32 filter)
int wl1251_hw_init_rx_config(struct wl1251 *wl, u32 config, u32 filter)
{
int ret;
ret = wl12xx_acx_rx_msdu_life_time(wl, RX_MSDU_LIFETIME_DEF);
ret = wl1251_acx_rx_msdu_life_time(wl, RX_MSDU_LIFETIME_DEF);
if (ret < 0)
return ret;
ret = wl12xx_acx_rx_config(wl, config, filter);
ret = wl1251_acx_rx_config(wl, config, filter);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_phy_config(struct wl12xx *wl)
int wl1251_hw_init_phy_config(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_pd_threshold(wl);
ret = wl1251_acx_pd_threshold(wl);
if (ret < 0)
return ret;
ret = wl12xx_acx_slot(wl, DEFAULT_SLOT_TIME);
ret = wl1251_acx_slot(wl, DEFAULT_SLOT_TIME);
if (ret < 0)
return ret;
ret = wl12xx_acx_group_address_tbl(wl);
ret = wl1251_acx_group_address_tbl(wl);
if (ret < 0)
return ret;
ret = wl12xx_acx_service_period_timeout(wl);
ret = wl1251_acx_service_period_timeout(wl);
if (ret < 0)
return ret;
ret = wl12xx_acx_rts_threshold(wl, RTS_THRESHOLD_DEF);
ret = wl1251_acx_rts_threshold(wl, RTS_THRESHOLD_DEF);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_beacon_filter(struct wl12xx *wl)
int wl1251_hw_init_beacon_filter(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_beacon_filter_opt(wl);
ret = wl1251_acx_beacon_filter_opt(wl);
if (ret < 0)
return ret;
ret = wl12xx_acx_beacon_filter_table(wl);
ret = wl1251_acx_beacon_filter_table(wl);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_pta(struct wl12xx *wl)
int wl1251_hw_init_pta(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_sg_enable(wl);
ret = wl1251_acx_sg_enable(wl);
if (ret < 0)
return ret;
ret = wl12xx_acx_sg_cfg(wl);
ret = wl1251_acx_sg_cfg(wl);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_energy_detection(struct wl12xx *wl)
int wl1251_hw_init_energy_detection(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_cca_threshold(wl);
ret = wl1251_acx_cca_threshold(wl);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_beacon_broadcast(struct wl12xx *wl)
int wl1251_hw_init_beacon_broadcast(struct wl1251 *wl)
{
int ret;
ret = wl12xx_acx_bcn_dtim_options(wl);
ret = wl1251_acx_bcn_dtim_options(wl);
if (ret < 0)
return ret;
return 0;
}
int wl12xx_hw_init_power_auth(struct wl12xx *wl)
int wl1251_hw_init_power_auth(struct wl1251 *wl)
{
return wl12xx_acx_sleep_auth(wl, WL12XX_PSM_CAM);
return wl1251_acx_sleep_auth(wl, WL1251_PSM_CAM);
}

24
drivers/net/wireless/wl12xx/wl1251_init.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2009 Nokia Corporation
*
@ -21,19 +21,19 @@
*
*/
#ifndef __WL12XX_INIT_H__
#define __WL12XX_INIT_H__
#ifndef __WL1251_INIT_H__
#define __WL1251_INIT_H__
#include "wl1251.h"
int wl12xx_hw_init_hwenc_config(struct wl12xx *wl);
int wl12xx_hw_init_templates_config(struct wl12xx *wl);
int wl12xx_hw_init_rx_config(struct wl12xx *wl, u32 config, u32 filter);
int wl12xx_hw_init_phy_config(struct wl12xx *wl);
int wl12xx_hw_init_beacon_filter(struct wl12xx *wl);
int wl12xx_hw_init_pta(struct wl12xx *wl);
int wl12xx_hw_init_energy_detection(struct wl12xx *wl);
int wl12xx_hw_init_beacon_broadcast(struct wl12xx *wl);
int wl12xx_hw_init_power_auth(struct wl12xx *wl);
int wl1251_hw_init_hwenc_config(struct wl1251 *wl);
int wl1251_hw_init_templates_config(struct wl1251 *wl);
int wl1251_hw_init_rx_config(struct wl1251 *wl, u32 config, u32 filter);
int wl1251_hw_init_phy_config(struct wl1251 *wl);
int wl1251_hw_init_beacon_filter(struct wl1251 *wl);
int wl1251_hw_init_pta(struct wl1251 *wl);
int wl1251_hw_init_energy_detection(struct wl1251 *wl);
int wl1251_hw_init_beacon_broadcast(struct wl1251 *wl);
int wl1251_hw_init_power_auth(struct wl1251 *wl);
#endif

477
drivers/net/wireless/wl12xx/wl1251_main.c
View File

File diff suppressed because it is too large Load Diff

390
drivers/net/wireless/wl12xx/wl1251_netlink.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008 Nokia Corporation
*
@ -35,52 +35,52 @@
#include "wl1251_acx.h"
/* FIXME: this should be changed as soon as user space catches up */
#define WL12XX_NL_NAME "wl1251"
#define WL12XX_NL_VERSION 1
#define WL1251_NL_NAME "wl1251"
#define WL1251_NL_VERSION 1
#define WL12XX_MAX_TEST_LENGTH 1024
#define WL12XX_MAX_NVS_LENGTH 1024
#define WL1251_MAX_TEST_LENGTH 1024
#define WL1251_MAX_NVS_LENGTH 1024
enum wl12xx_nl_commands {
WL12XX_NL_CMD_UNSPEC,
WL12XX_NL_CMD_TEST,
WL12XX_NL_CMD_INTERROGATE,
WL12XX_NL_CMD_CONFIGURE,
WL12XX_NL_CMD_PHY_REG_READ,
WL12XX_NL_CMD_NVS_PUSH,
WL12XX_NL_CMD_REG_WRITE,
WL12XX_NL_CMD_REG_READ,
WL12XX_NL_CMD_SET_PLT_MODE,
enum wl1251_nl_commands {
WL1251_NL_CMD_UNSPEC,
WL1251_NL_CMD_TEST,
WL1251_NL_CMD_INTERROGATE,
WL1251_NL_CMD_CONFIGURE,
WL1251_NL_CMD_PHY_REG_READ,
WL1251_NL_CMD_NVS_PUSH,
WL1251_NL_CMD_REG_WRITE,
WL1251_NL_CMD_REG_READ,
WL1251_NL_CMD_SET_PLT_MODE,
__WL12XX_NL_CMD_AFTER_LAST
__WL1251_NL_CMD_AFTER_LAST
};
#define WL12XX_NL_CMD_MAX (__WL12XX_NL_CMD_AFTER_LAST - 1)
#define WL1251_NL_CMD_MAX (__WL1251_NL_CMD_AFTER_LAST - 1)
enum wl12xx_nl_attrs {
WL12XX_NL_ATTR_UNSPEC,
WL12XX_NL_ATTR_IFNAME,
WL12XX_NL_ATTR_CMD_TEST_PARAM,
WL12XX_NL_ATTR_CMD_TEST_ANSWER,
WL12XX_NL_ATTR_CMD_IE,
WL12XX_NL_ATTR_CMD_IE_LEN,
WL12XX_NL_ATTR_CMD_IE_BUFFER,
WL12XX_NL_ATTR_CMD_IE_ANSWER,
WL12XX_NL_ATTR_REG_ADDR,
WL12XX_NL_ATTR_REG_VAL,
WL12XX_NL_ATTR_NVS_BUFFER,
WL12XX_NL_ATTR_NVS_LEN,
WL12XX_NL_ATTR_PLT_MODE,
enum wl1251_nl_attrs {
WL1251_NL_ATTR_UNSPEC,
WL1251_NL_ATTR_IFNAME,
WL1251_NL_ATTR_CMD_TEST_PARAM,
WL1251_NL_ATTR_CMD_TEST_ANSWER,
WL1251_NL_ATTR_CMD_IE,
WL1251_NL_ATTR_CMD_IE_LEN,
WL1251_NL_ATTR_CMD_IE_BUFFER,
WL1251_NL_ATTR_CMD_IE_ANSWER,
WL1251_NL_ATTR_REG_ADDR,
WL1251_NL_ATTR_REG_VAL,
WL1251_NL_ATTR_NVS_BUFFER,
WL1251_NL_ATTR_NVS_LEN,
WL1251_NL_ATTR_PLT_MODE,
__WL12XX_NL_ATTR_AFTER_LAST
__WL1251_NL_ATTR_AFTER_LAST
};
#define WL12XX_NL_ATTR_MAX (__WL12XX_NL_ATTR_AFTER_LAST - 1)
#define WL1251_NL_ATTR_MAX (__WL1251_NL_ATTR_AFTER_LAST - 1)
static struct genl_family wl12xx_nl_family = {
static struct genl_family wl1251_nl_family = {
.id = GENL_ID_GENERATE,
.name = WL12XX_NL_NAME,
.name = WL1251_NL_NAME,
.hdrsize = 0,
.version = WL12XX_NL_VERSION,
.maxattr = WL12XX_NL_ATTR_MAX,
.version = WL1251_NL_VERSION,
.maxattr = WL1251_NL_ATTR_MAX,
};
static struct net_device *ifname_to_netdev(struct net *net,
@ -88,17 +88,17 @@ static struct net_device *ifname_to_netdev(struct net *net,
{
char *ifname;
if (!info->attrs[WL12XX_NL_ATTR_IFNAME])
if (!info->attrs[WL1251_NL_ATTR_IFNAME])
return NULL;
ifname = nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME]);
ifname = nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]);
wl12xx_debug(DEBUG_NETLINK, "Looking for %s", ifname);
wl1251_debug(DEBUG_NETLINK, "Looking for %s", ifname);
return dev_get_by_name(net, ifname);
}
static struct wl12xx *ifname_to_wl12xx(struct net *net, struct genl_info *info)
static struct wl1251 *ifname_to_wl1251(struct net *net, struct genl_info *info)
{
struct net_device *netdev;
struct wireless_dev *wdev;
@ -107,25 +107,25 @@ static struct wl12xx *ifname_to_wl12xx(struct net *net, struct genl_info *info)
netdev = ifname_to_netdev(net, info);
if (netdev == NULL) {
wl12xx_error("Wrong interface");
wl1251_error("Wrong interface");
return NULL;
}
wdev = netdev->ieee80211_ptr;
if (wdev == NULL) {
wl12xx_error("ieee80211_ptr is NULL");
wl1251_error("ieee80211_ptr is NULL");
return NULL;
}
wiphy = wdev->wiphy;
if (wiphy == NULL) {
wl12xx_error("wiphy is NULL");
wl1251_error("wiphy is NULL");
return NULL;
}
hw = wiphy_priv(wiphy);
if (hw == NULL) {
wl12xx_error("hw is NULL");
wl1251_error("hw is NULL");
return NULL;
}
@ -134,20 +134,20 @@ static struct wl12xx *ifname_to_wl12xx(struct net *net, struct genl_info *info)
return hw->priv;
}
static int wl12xx_nl_test_cmd(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_test_cmd(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl12xx_command *cmd;
struct wl1251 *wl;
struct wl1251_command *cmd;
char *buf;
int buf_len, ret, cmd_len;
u8 answer;
if (!info->attrs[WL12XX_NL_ATTR_CMD_TEST_PARAM])
if (!info->attrs[WL1251_NL_ATTR_CMD_TEST_PARAM])
return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
return -EINVAL;
}
@ -155,20 +155,20 @@ static int wl12xx_nl_test_cmd(struct sk_buff *skb, struct genl_info *info)
if (!cmd)
return -ENOMEM;
buf = nla_data(info->attrs[WL12XX_NL_ATTR_CMD_TEST_PARAM]);
buf_len = nla_len(info->attrs[WL12XX_NL_ATTR_CMD_TEST_PARAM]);
answer = nla_get_u8(info->attrs[WL12XX_NL_ATTR_CMD_TEST_ANSWER]);
buf = nla_data(info->attrs[WL1251_NL_ATTR_CMD_TEST_PARAM]);
buf_len = nla_len(info->attrs[WL1251_NL_ATTR_CMD_TEST_PARAM]);
answer = nla_get_u8(info->attrs[WL1251_NL_ATTR_CMD_TEST_ANSWER]);
cmd->header.id = CMD_TEST;
memcpy(cmd->parameters, buf, buf_len);
cmd_len = sizeof(struct wl12xx_cmd_header) + buf_len;
cmd_len = sizeof(struct wl1251_cmd_header) + buf_len;
mutex_lock(&wl->mutex);
ret = wl12xx_cmd_test(wl, cmd, cmd_len, answer);
ret = wl1251_cmd_test(wl, cmd, cmd_len, answer);
mutex_unlock(&wl->mutex);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto out;
}
@ -183,49 +183,49 @@ static int wl12xx_nl_test_cmd(struct sk_buff *skb, struct genl_info *info)
}
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
&wl12xx_nl_family, 0, WL12XX_NL_CMD_TEST);
&wl1251_nl_family, 0, WL1251_NL_CMD_TEST);
if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr);
goto nla_put_failure;
}
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME]));
NLA_PUT(msg, WL12XX_NL_ATTR_CMD_TEST_ANSWER,
NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]));
NLA_PUT(msg, WL1251_NL_ATTR_CMD_TEST_ANSWER,
sizeof(*cmd), cmd);
ret = genlmsg_end(msg, hdr);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
wl12xx_debug(DEBUG_NETLINK, "TEST cmd sent, answer");
wl1251_debug(DEBUG_NETLINK, "TEST cmd sent, answer");
ret = genlmsg_reply(msg, info);
goto out;
nla_put_failure:
nlmsg_free(msg);
} else
wl12xx_debug(DEBUG_NETLINK, "TEST cmd sent");
wl1251_debug(DEBUG_NETLINK, "TEST cmd sent");
out:
kfree(cmd);
return ret;
}
static int wl12xx_nl_interrogate(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_interrogate(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl1251 *wl;
struct sk_buff *msg;
int ret = -ENOBUFS, cmd_ie, cmd_ie_len;
struct wl12xx_command *cmd;
struct wl1251_command *cmd;
void *hdr;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE])
if (!info->attrs[WL1251_NL_ATTR_CMD_IE])
return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE_LEN])
if (!info->attrs[WL1251_NL_ATTR_CMD_IE_LEN])
return -EINVAL;
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
@ -236,45 +236,45 @@ static int wl12xx_nl_interrogate(struct sk_buff *skb, struct genl_info *info)
if (!msg)
return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
ret = -EINVAL;
goto nla_put_failure;
}
/* acx id */
cmd_ie = nla_get_u32(info->attrs[WL12XX_NL_ATTR_CMD_IE]);
cmd_ie = nla_get_u32(info->attrs[WL1251_NL_ATTR_CMD_IE]);
/* maximum length of acx, including all headers */
cmd_ie_len = nla_get_u32(info->attrs[WL12XX_NL_ATTR_CMD_IE_LEN]);
cmd_ie_len = nla_get_u32(info->attrs[WL1251_NL_ATTR_CMD_IE_LEN]);
wl12xx_debug(DEBUG_NETLINK, "Getting IE 0x%x (len %d)",
wl1251_debug(DEBUG_NETLINK, "Getting IE 0x%x (len %d)",
cmd_ie, cmd_ie_len);
mutex_lock(&wl->mutex);
ret = wl12xx_cmd_interrogate(wl, cmd_ie, cmd, cmd_ie_len);
ret = wl1251_cmd_interrogate(wl, cmd_ie, cmd, cmd_ie_len);
mutex_unlock(&wl->mutex);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
&wl12xx_nl_family, 0, WL12XX_NL_CMD_INTERROGATE);
&wl1251_nl_family, 0, WL1251_NL_CMD_INTERROGATE);
if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr);
goto nla_put_failure;
}
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME]));
NLA_PUT(msg, WL12XX_NL_ATTR_CMD_IE_ANSWER, cmd_ie_len, cmd);
NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]));
NLA_PUT(msg, WL1251_NL_ATTR_CMD_IE_ANSWER, cmd_ie_len, cmd);
ret = genlmsg_end(msg, hdr);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
@ -288,36 +288,36 @@ static int wl12xx_nl_interrogate(struct sk_buff *skb, struct genl_info *info)
return ret;
}
static int wl12xx_nl_configure(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_configure(struct sk_buff *skb, struct genl_info *info)
{
int ret = 0, cmd_ie_len, acx_len;
struct acx_header *acx = NULL;
struct sk_buff *msg;
struct wl12xx *wl;
struct wl1251 *wl;
void *cmd_ie;
u16 *id;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE_BUFFER])
if (!info->attrs[WL1251_NL_ATTR_CMD_IE_BUFFER])
return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE_LEN])
if (!info->attrs[WL1251_NL_ATTR_CMD_IE_LEN])
return -EINVAL;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
ret = -EINVAL;
goto nla_put_failure;
}
/* contains the acx header but not the cmd header */
cmd_ie = nla_data(info->attrs[WL12XX_NL_ATTR_CMD_IE_BUFFER]);
cmd_ie = nla_data(info->attrs[WL1251_NL_ATTR_CMD_IE_BUFFER]);
cmd_ie_len = nla_get_u32(info->attrs[WL12XX_NL_ATTR_CMD_IE_LEN]);
cmd_ie_len = nla_get_u32(info->attrs[WL1251_NL_ATTR_CMD_IE_LEN]);
/* acx id is in the first two bytes */
id = cmd_ie;
@ -334,15 +334,15 @@ static int wl12xx_nl_configure(struct sk_buff *skb, struct genl_info *info)
memcpy(&acx->id, cmd_ie, cmd_ie_len);
mutex_lock(&wl->mutex);
ret = wl12xx_cmd_configure(wl, *id, acx, acx_len);
ret = wl1251_cmd_configure(wl, *id, acx, acx_len);
mutex_unlock(&wl->mutex);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
wl12xx_debug(DEBUG_NETLINK, "CONFIGURE cmd sent");
wl1251_debug(DEBUG_NETLINK, "CONFIGURE cmd sent");
nla_put_failure:
kfree(acx);
@ -351,24 +351,24 @@ static int wl12xx_nl_configure(struct sk_buff *skb, struct genl_info *info)
return ret;
}
static int wl12xx_nl_phy_reg_read(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_phy_reg_read(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl1251 *wl;
struct sk_buff *msg;
u32 reg_addr, *reg_value = NULL;
int ret = 0;
void *hdr;
if (!info->attrs[WL12XX_NL_ATTR_REG_ADDR])
if (!info->attrs[WL1251_NL_ATTR_REG_ADDR])
return -EINVAL;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
ret = -EINVAL;
goto nla_put_failure;
}
@ -379,36 +379,36 @@ static int wl12xx_nl_phy_reg_read(struct sk_buff *skb, struct genl_info *info)
goto nla_put_failure;
}
reg_addr = nla_get_u32(info->attrs[WL12XX_NL_ATTR_REG_ADDR]);
reg_addr = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_ADDR]);
wl12xx_debug(DEBUG_NETLINK, "Reading PHY reg 0x%x", reg_addr);
wl1251_debug(DEBUG_NETLINK, "Reading PHY reg 0x%x", reg_addr);
mutex_lock(&wl->mutex);
ret = wl12xx_cmd_read_memory(wl, reg_addr, reg_value,
ret = wl1251_cmd_read_memory(wl, reg_addr, reg_value,
sizeof(*reg_value));
mutex_unlock(&wl->mutex);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
&wl12xx_nl_family, 0, WL12XX_NL_CMD_PHY_REG_READ);
&wl1251_nl_family, 0, WL1251_NL_CMD_PHY_REG_READ);
if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr);
goto nla_put_failure;
}
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME]));
NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]));
NLA_PUT_U32(msg, WL12XX_NL_ATTR_REG_VAL, *reg_value);
NLA_PUT_U32(msg, WL1251_NL_ATTR_REG_VAL, *reg_value);
ret = genlmsg_end(msg, hdr);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
@ -423,27 +423,27 @@ static int wl12xx_nl_phy_reg_read(struct sk_buff *skb, struct genl_info *info)
return ret;
}
static int wl12xx_nl_nvs_push(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_nvs_push(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl1251 *wl;
int ret = 0;
if (!info->attrs[WL12XX_NL_ATTR_NVS_BUFFER])
if (!info->attrs[WL1251_NL_ATTR_NVS_BUFFER])
return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_NVS_LEN])
if (!info->attrs[WL1251_NL_ATTR_NVS_LEN])
return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
return -EINVAL;
}
mutex_lock(&wl->mutex);
wl->nvs_len = nla_get_u32(info->attrs[WL12XX_NL_ATTR_NVS_LEN]);
wl->nvs_len = nla_get_u32(info->attrs[WL1251_NL_ATTR_NVS_LEN]);
if (wl->nvs_len % 4) {
wl12xx_error("NVS size is not multiple of 32: %d", wl->nvs_len);
wl1251_error("NVS size is not multiple of 32: %d", wl->nvs_len);
ret = -EILSEQ;
goto out;
}
@ -453,16 +453,16 @@ static int wl12xx_nl_nvs_push(struct sk_buff *skb, struct genl_info *info)
wl->nvs = kzalloc(wl->nvs_len, GFP_KERNEL);
if (wl->nvs == NULL) {
wl12xx_error("Can't allocate NVS");
wl1251_error("Can't allocate NVS");
ret = -ENOMEM;
goto out;
}
memcpy(wl->nvs,
nla_data(info->attrs[WL12XX_NL_ATTR_NVS_BUFFER]),
nla_data(info->attrs[WL1251_NL_ATTR_NVS_BUFFER]),
wl->nvs_len);
wl12xx_debug(DEBUG_NETLINK, "got NVS from userspace, %d bytes",
wl1251_debug(DEBUG_NETLINK, "got NVS from userspace, %d bytes",
wl->nvs_len);
out:
@ -471,48 +471,48 @@ out:
return ret;
}
static int wl12xx_nl_reg_read(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_reg_read(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl1251 *wl;
u32 addr, val;
int ret = 0;
struct sk_buff *msg;
void *hdr;
if (!info->attrs[WL12XX_NL_ATTR_REG_ADDR])
if (!info->attrs[WL1251_NL_ATTR_REG_ADDR])
return -EINVAL;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
return -EINVAL;
}
addr = nla_get_u32(info->attrs[WL12XX_NL_ATTR_REG_ADDR]);
addr = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_ADDR]);
mutex_lock(&wl->mutex);
val = wl12xx_reg_read32(wl, addr);
val = wl1251_reg_read32(wl, addr);
mutex_unlock(&wl->mutex);
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
&wl12xx_nl_family, 0, WL12XX_NL_CMD_PHY_REG_READ);
&wl1251_nl_family, 0, WL1251_NL_CMD_PHY_REG_READ);
if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr);
goto nla_put_failure;
}
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME]));
NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]));
NLA_PUT_U32(msg, WL12XX_NL_ATTR_REG_VAL, val);
NLA_PUT_U32(msg, WL1251_NL_ATTR_REG_VAL, val);
ret = genlmsg_end(msg, hdr);
if (ret < 0) {
wl12xx_error("%s() failed", __func__);
wl1251_error("%s() failed", __func__);
goto nla_put_failure;
}
@ -524,56 +524,56 @@ static int wl12xx_nl_reg_read(struct sk_buff *skb, struct genl_info *info)
return ret;
}
static int wl12xx_nl_reg_write(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_reg_write(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl1251 *wl;
u32 addr, val;
if (!info->attrs[WL12XX_NL_ATTR_REG_ADDR])
if (!info->attrs[WL1251_NL_ATTR_REG_ADDR])
return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_REG_VAL])
if (!info->attrs[WL1251_NL_ATTR_REG_VAL])
return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
return -EINVAL;
}
addr = nla_get_u32(info->attrs[WL12XX_NL_ATTR_REG_ADDR]);
val = nla_get_u32(info->attrs[WL12XX_NL_ATTR_REG_VAL]);
addr = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_ADDR]);
val = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_VAL]);
mutex_lock(&wl->mutex);
wl12xx_reg_write32(wl, addr, val);
wl1251_reg_write32(wl, addr, val);
mutex_unlock(&wl->mutex);
return 0;
}
static int wl12xx_nl_set_plt_mode(struct sk_buff *skb, struct genl_info *info)
static int wl1251_nl_set_plt_mode(struct sk_buff *skb, struct genl_info *info)
{
struct wl12xx *wl;
struct wl1251 *wl;
u32 val;
int ret;
if (!info->attrs[WL12XX_NL_ATTR_PLT_MODE])
if (!info->attrs[WL1251_NL_ATTR_PLT_MODE])
return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info);
wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) {
wl12xx_error("wl12xx not found");
wl1251_error("wl1251 not found");
return -EINVAL;
}
val = nla_get_u32(info->attrs[WL12XX_NL_ATTR_PLT_MODE]);
val = nla_get_u32(info->attrs[WL1251_NL_ATTR_PLT_MODE]);
switch (val) {
case 0:
ret = wl12xx_plt_stop(wl);
ret = wl1251_plt_stop(wl);
break;
case 1:
ret = wl12xx_plt_start(wl);
ret = wl1251_plt_start(wl);
break;
default:
ret = -EINVAL;
@ -583,97 +583,97 @@ static int wl12xx_nl_set_plt_mode(struct sk_buff *skb, struct genl_info *info)
return ret;
}
static struct nla_policy wl12xx_nl_policy[WL12XX_NL_ATTR_MAX + 1] = {
[WL12XX_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
static struct nla_policy wl1251_nl_policy[WL1251_NL_ATTR_MAX + 1] = {
[WL1251_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
.len = IFNAMSIZ-1 },
[WL12XX_NL_ATTR_CMD_TEST_PARAM] = { .type = NLA_BINARY,
.len = WL12XX_MAX_TEST_LENGTH },
[WL12XX_NL_ATTR_CMD_TEST_ANSWER] = { .type = NLA_U8 },
[WL12XX_NL_ATTR_CMD_IE] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_CMD_IE_LEN] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_CMD_IE_BUFFER] = { .type = NLA_BINARY,
.len = WL12XX_MAX_TEST_LENGTH },
[WL12XX_NL_ATTR_CMD_IE_ANSWER] = { .type = NLA_BINARY,
.len = WL12XX_MAX_TEST_LENGTH },
[WL12XX_NL_ATTR_REG_ADDR] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_REG_VAL] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_NVS_BUFFER] = { .type = NLA_BINARY,
.len = WL12XX_MAX_NVS_LENGTH },
[WL12XX_NL_ATTR_NVS_LEN] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_PLT_MODE] = { .type = NLA_U32 },
[WL1251_NL_ATTR_CMD_TEST_PARAM] = { .type = NLA_BINARY,
.len = WL1251_MAX_TEST_LENGTH },
[WL1251_NL_ATTR_CMD_TEST_ANSWER] = { .type = NLA_U8 },
[WL1251_NL_ATTR_CMD_IE] = { .type = NLA_U32 },
[WL1251_NL_ATTR_CMD_IE_LEN] = { .type = NLA_U32 },
[WL1251_NL_ATTR_CMD_IE_BUFFER] = { .type = NLA_BINARY,
.len = WL1251_MAX_TEST_LENGTH },
[WL1251_NL_ATTR_CMD_IE_ANSWER] = { .type = NLA_BINARY,
.len = WL1251_MAX_TEST_LENGTH },
[WL1251_NL_ATTR_REG_ADDR] = { .type = NLA_U32 },
[WL1251_NL_ATTR_REG_VAL] = { .type = NLA_U32 },
[WL1251_NL_ATTR_NVS_BUFFER] = { .type = NLA_BINARY,
.len = WL1251_MAX_NVS_LENGTH },
[WL1251_NL_ATTR_NVS_LEN] = { .type = NLA_U32 },
[WL1251_NL_ATTR_PLT_MODE] = { .type = NLA_U32 },
};
static struct genl_ops wl12xx_nl_ops[] = {
static struct genl_ops wl1251_nl_ops[] = {
{
.cmd = WL12XX_NL_CMD_TEST,
.doit = wl12xx_nl_test_cmd,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_TEST,
.doit = wl1251_nl_test_cmd,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_INTERROGATE,
.doit = wl12xx_nl_interrogate,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_INTERROGATE,
.doit = wl1251_nl_interrogate,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_CONFIGURE,
.doit = wl12xx_nl_configure,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_CONFIGURE,
.doit = wl1251_nl_configure,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_PHY_REG_READ,
.doit = wl12xx_nl_phy_reg_read,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_PHY_REG_READ,
.doit = wl1251_nl_phy_reg_read,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_NVS_PUSH,
.doit = wl12xx_nl_nvs_push,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_NVS_PUSH,
.doit = wl1251_nl_nvs_push,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_REG_WRITE,
.doit = wl12xx_nl_reg_write,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_REG_WRITE,
.doit = wl1251_nl_reg_write,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_REG_READ,
.doit = wl12xx_nl_reg_read,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_REG_READ,
.doit = wl1251_nl_reg_read,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
{
.cmd = WL12XX_NL_CMD_SET_PLT_MODE,
.doit = wl12xx_nl_set_plt_mode,
.policy = wl12xx_nl_policy,
.cmd = WL1251_NL_CMD_SET_PLT_MODE,
.doit = wl1251_nl_set_plt_mode,
.policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM,
},
};
int wl12xx_nl_register(void)
int wl1251_nl_register(void)
{
int err, i;
err = genl_register_family(&wl12xx_nl_family);
err = genl_register_family(&wl1251_nl_family);
if (err)
return err;
for (i = 0; i < ARRAY_SIZE(wl12xx_nl_ops); i++) {
err = genl_register_ops(&wl12xx_nl_family, &wl12xx_nl_ops[i]);
for (i = 0; i < ARRAY_SIZE(wl1251_nl_ops); i++) {
err = genl_register_ops(&wl1251_nl_family, &wl1251_nl_ops[i]);
if (err)
goto err_out;
}
return 0;
err_out:
genl_unregister_family(&wl12xx_nl_family);
genl_unregister_family(&wl1251_nl_family);
return err;
}
void wl12xx_nl_unregister(void)
void wl1251_nl_unregister(void)
{
genl_unregister_family(&wl12xx_nl_family);
genl_unregister_family(&wl1251_nl_family);
}

12
drivers/net/wireless/wl12xx/wl1251_netlink.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2009 Nokia Corporation
*
@ -21,10 +21,10 @@
*
*/
#ifndef __WL12XX_NETLINK_H__
#define __WL12XX_NETLINK_H__
#ifndef __WL1251_NETLINK_H__
#define __WL1251_NETLINK_H__
int wl12xx_nl_register(void);
void wl12xx_nl_unregister(void);
int wl1251_nl_register(void);
void wl1251_nl_unregister(void);
#endif /* __WL12XX_NETLINK_H__ */
#endif /* __WL1251_NETLINK_H__ */

190
drivers/net/wireless/wl12xx/wl1251_ops.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008-2009 Nokia Corporation
*
@ -35,7 +35,7 @@
#include "wl1251_ps.h"
#include "wl1251_init.h"
static struct wl12xx_partition_set wl1251_part_table[PART_TABLE_LEN] = {
static struct wl1251_partition_set wl1251_part_table[PART_TABLE_LEN] = {
[PART_DOWN] = {
.mem = {
.start = 0x00000000,
@ -75,31 +75,31 @@ static enum wl12xx_acx_int_reg wl1251_acx_reg_table[ACX_REG_TABLE_LEN] = {
[ACX_REG_ECPU_CONTROL] = (REGISTERS_BASE + 0x0804)
};
static int wl1251_upload_firmware(struct wl12xx *wl)
static int wl1251_upload_firmware(struct wl1251 *wl)
{
struct wl12xx_partition_set *p_table = wl->chip.p_table;
struct wl1251_partition_set *p_table = wl->chip.p_table;
int addr, chunk_num, partition_limit;
size_t fw_data_len;
u8 *p;
/* whal_FwCtrl_LoadFwImageSm() */
wl12xx_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x",
wl12xx_reg_read32(wl, CHIP_ID_B));
wl1251_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x",
wl1251_reg_read32(wl, CHIP_ID_B));
/* 10.0 check firmware length and set partition */
fw_data_len = (wl->fw[4] << 24) | (wl->fw[5] << 16) |
(wl->fw[6] << 8) | (wl->fw[7]);
wl12xx_debug(DEBUG_BOOT, "fw_data_len %zu chunk_size %d", fw_data_len,
wl1251_debug(DEBUG_BOOT, "fw_data_len %zu chunk_size %d", fw_data_len,
CHUNK_SIZE);
if ((fw_data_len % 4) != 0) {
wl12xx_error("firmware length not multiple of four");
wl1251_error("firmware length not multiple of four");
return -EIO;
}
wl12xx_set_partition(wl,
wl1251_set_partition(wl,
p_table[PART_DOWN].mem.start,
p_table[PART_DOWN].mem.size,
p_table[PART_DOWN].reg.start,
@ -118,7 +118,7 @@ static int wl1251_upload_firmware(struct wl12xx *wl)
chunk_num * CHUNK_SIZE;
partition_limit = chunk_num * CHUNK_SIZE +
p_table[PART_DOWN].mem.size;
wl12xx_set_partition(wl,
wl1251_set_partition(wl,
addr,
p_table[PART_DOWN].mem.size,
p_table[PART_DOWN].reg.start,
@ -128,9 +128,9 @@ static int wl1251_upload_firmware(struct wl12xx *wl)
/* 10.3 upload the chunk */
addr = p_table[PART_DOWN].mem.start + chunk_num * CHUNK_SIZE;
p = wl->fw + FW_HDR_SIZE + chunk_num * CHUNK_SIZE;
wl12xx_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x",
wl1251_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x",
p, addr);
wl12xx_spi_mem_write(wl, addr, p, CHUNK_SIZE);
wl1251_spi_mem_write(wl, addr, p, CHUNK_SIZE);
chunk_num++;
}
@ -138,14 +138,14 @@ static int wl1251_upload_firmware(struct wl12xx *wl)
/* 10.4 upload the last chunk */
addr = p_table[PART_DOWN].mem.start + chunk_num * CHUNK_SIZE;
p = wl->fw + FW_HDR_SIZE + chunk_num * CHUNK_SIZE;
wl12xx_debug(DEBUG_BOOT, "uploading fw last chunk (%zu B) 0x%p to 0x%x",
wl1251_debug(DEBUG_BOOT, "uploading fw last chunk (%zu B) 0x%p to 0x%x",
fw_data_len % CHUNK_SIZE, p, addr);
wl12xx_spi_mem_write(wl, addr, p, fw_data_len % CHUNK_SIZE);
wl1251_spi_mem_write(wl, addr, p, fw_data_len % CHUNK_SIZE);
return 0;
}
static int wl1251_upload_nvs(struct wl12xx *wl)
static int wl1251_upload_nvs(struct wl1251 *wl)
{
size_t nvs_len, nvs_bytes_written, burst_len;
int nvs_start, i;
@ -181,10 +181,10 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
val = (nvs_ptr[0] | (nvs_ptr[1] << 8)
| (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));
wl12xx_debug(DEBUG_BOOT,
wl1251_debug(DEBUG_BOOT,
"nvs burst write 0x%x: 0x%x",
dest_addr, val);
wl12xx_mem_write32(wl, dest_addr, val);
wl1251_mem_write32(wl, dest_addr, val);
nvs_ptr += 4;
dest_addr += 4;
@ -200,7 +200,7 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
nvs_len = ALIGN(nvs_len, 4);
/* Now we must set the partition correctly */
wl12xx_set_partition(wl, nvs_start,
wl1251_set_partition(wl, nvs_start,
wl->chip.p_table[PART_DOWN].mem.size,
wl->chip.p_table[PART_DOWN].reg.start,
wl->chip.p_table[PART_DOWN].reg.size);
@ -213,10 +213,10 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
val = cpu_to_le32(val);
wl12xx_debug(DEBUG_BOOT,
wl1251_debug(DEBUG_BOOT,
"nvs write table 0x%x: 0x%x",
nvs_start, val);
wl12xx_mem_write32(wl, nvs_start, val);
wl1251_mem_write32(wl, nvs_start, val);
nvs_ptr += 4;
nvs_bytes_written += 4;
@ -226,12 +226,12 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
return 0;
}
static int wl1251_boot(struct wl12xx *wl)
static int wl1251_boot(struct wl1251 *wl)
{
int ret = 0, minor_minor_e2_ver;
u32 tmp, boot_data;
ret = wl12xx_boot_soft_reset(wl);
ret = wl1251_boot_soft_reset(wl);
if (ret < 0)
goto out;
@ -242,39 +242,39 @@ static int wl1251_boot(struct wl12xx *wl)
/* write firmware's last address (ie. it's length) to
* ACX_EEPROMLESS_IND_REG */
wl12xx_reg_write32(wl, ACX_EEPROMLESS_IND_REG, wl->fw_len);
wl1251_reg_write32(wl, ACX_EEPROMLESS_IND_REG, wl->fw_len);
/* 6. read the EEPROM parameters */
tmp = wl12xx_reg_read32(wl, SCR_PAD2);
tmp = wl1251_reg_read32(wl, SCR_PAD2);
/* 7. read bootdata */
wl->boot_attr.radio_type = (tmp & 0x0000FF00) >> 8;
wl->boot_attr.major = (tmp & 0x00FF0000) >> 16;
tmp = wl12xx_reg_read32(wl, SCR_PAD3);
tmp = wl1251_reg_read32(wl, SCR_PAD3);
/* 8. check bootdata and call restart sequence */
wl->boot_attr.minor = (tmp & 0x00FF0000) >> 16;
minor_minor_e2_ver = (tmp & 0xFF000000) >> 24;
wl12xx_debug(DEBUG_BOOT, "radioType 0x%x majorE2Ver 0x%x "
wl1251_debug(DEBUG_BOOT, "radioType 0x%x majorE2Ver 0x%x "
"minorE2Ver 0x%x minor_minor_e2_ver 0x%x",
wl->boot_attr.radio_type, wl->boot_attr.major,
wl->boot_attr.minor, minor_minor_e2_ver);
ret = wl12xx_boot_init_seq(wl);
ret = wl1251_boot_init_seq(wl);
if (ret < 0)
goto out;
/* 9. NVS processing done */
boot_data = wl12xx_reg_read32(wl, ACX_REG_ECPU_CONTROL);
boot_data = wl1251_reg_read32(wl, ACX_REG_ECPU_CONTROL);
wl12xx_debug(DEBUG_BOOT, "halt boot_data 0x%x", boot_data);
wl1251_debug(DEBUG_BOOT, "halt boot_data 0x%x", boot_data);
/* 10. check that ECPU_CONTROL_HALT bits are set in
* pWhalBus->uBootData and start uploading firmware
*/
if ((boot_data & ECPU_CONTROL_HALT) == 0) {
wl12xx_error("boot failed, ECPU_CONTROL_HALT not set");
wl1251_error("boot failed, ECPU_CONTROL_HALT not set");
ret = -EIO;
goto out;
}
@ -284,7 +284,7 @@ static int wl1251_boot(struct wl12xx *wl)
goto out;
/* 10.5 start firmware */
ret = wl12xx_boot_run_firmware(wl);
ret = wl1251_boot_run_firmware(wl);
if (ret < 0)
goto out;
@ -292,12 +292,12 @@ out:
return ret;
}
static int wl1251_mem_cfg(struct wl12xx *wl)
static int wl1251_mem_cfg(struct wl1251 *wl)
{
struct wl1251_acx_config_memory *mem_conf;
int ret, i;
wl12xx_debug(DEBUG_ACX, "wl1251 mem cfg");
wl1251_debug(DEBUG_ACX, "wl1251 mem cfg");
mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
if (!mem_conf) {
@ -327,10 +327,10 @@ static int wl1251_mem_cfg(struct wl12xx *wl)
mem_conf->tx_queue_config[i].attributes = i;
}
ret = wl12xx_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
ret = wl1251_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
sizeof(*mem_conf));
if (ret < 0) {
wl12xx_warning("wl1251 mem config failed: %d", ret);
wl1251_warning("wl1251 mem config failed: %d", ret);
goto out;
}
@ -339,7 +339,7 @@ out:
return ret;
}
static int wl1251_hw_init_mem_config(struct wl12xx *wl)
static int wl1251_hw_init_mem_config(struct wl1251 *wl)
{
int ret;
@ -350,15 +350,15 @@ static int wl1251_hw_init_mem_config(struct wl12xx *wl)
wl->target_mem_map = kzalloc(sizeof(struct wl1251_acx_mem_map),
GFP_KERNEL);
if (!wl->target_mem_map) {
wl12xx_error("couldn't allocate target memory map");
wl1251_error("couldn't allocate target memory map");
return -ENOMEM;
}
/* we now ask for the firmware built memory map */
ret = wl12xx_acx_mem_map(wl, wl->target_mem_map,
ret = wl1251_acx_mem_map(wl, wl->target_mem_map,
sizeof(struct wl1251_acx_mem_map));
if (ret < 0) {
wl12xx_error("couldn't retrieve firmware memory map");
wl1251_error("couldn't retrieve firmware memory map");
kfree(wl->target_mem_map);
wl->target_mem_map = NULL;
return ret;
@ -367,19 +367,19 @@ static int wl1251_hw_init_mem_config(struct wl12xx *wl)
return 0;
}
static void wl1251_set_ecpu_ctrl(struct wl12xx *wl, u32 flag)
static void wl1251_set_ecpu_ctrl(struct wl1251 *wl, u32 flag)
{
u32 cpu_ctrl;
/* 10.5.0 run the firmware (I) */
cpu_ctrl = wl12xx_reg_read32(wl, ACX_REG_ECPU_CONTROL);
cpu_ctrl = wl1251_reg_read32(wl, ACX_REG_ECPU_CONTROL);
/* 10.5.1 run the firmware (II) */
cpu_ctrl &= ~flag;
wl12xx_reg_write32(wl, ACX_REG_ECPU_CONTROL, cpu_ctrl);
wl1251_reg_write32(wl, ACX_REG_ECPU_CONTROL, cpu_ctrl);
}
static void wl1251_target_enable_interrupts(struct wl12xx *wl)
static void wl1251_target_enable_interrupts(struct wl1251 *wl)
{
/* Enable target's interrupts */
wl->intr_mask = WL1251_ACX_INTR_RX0_DATA |
@ -388,60 +388,60 @@ static void wl1251_target_enable_interrupts(struct wl12xx *wl)
WL1251_ACX_INTR_EVENT_A |
WL1251_ACX_INTR_EVENT_B |
WL1251_ACX_INTR_INIT_COMPLETE;
wl12xx_boot_target_enable_interrupts(wl);
wl1251_boot_target_enable_interrupts(wl);
}
static void wl1251_fw_version(struct wl12xx *wl)
static void wl1251_fw_version(struct wl1251 *wl)
{
wl12xx_acx_fw_version(wl, wl->chip.fw_ver, sizeof(wl->chip.fw_ver));
wl1251_acx_fw_version(wl, wl->chip.fw_ver, sizeof(wl->chip.fw_ver));
}
static void wl1251_irq_work(struct work_struct *work)
{
u32 intr;
struct wl12xx *wl =
container_of(work, struct wl12xx, irq_work);
struct wl1251 *wl =
container_of(work, struct wl1251, irq_work);
int ret;
mutex_lock(&wl->mutex);
wl12xx_debug(DEBUG_IRQ, "IRQ work");
wl1251_debug(DEBUG_IRQ, "IRQ work");
if (wl->state == WL12XX_STATE_OFF)
if (wl->state == WL1251_STATE_OFF)
goto out;
ret = wl12xx_ps_elp_wakeup(wl);
ret = wl1251_ps_elp_wakeup(wl);
if (ret < 0)
goto out;
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL);
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL);
intr = wl12xx_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
wl12xx_debug(DEBUG_IRQ, "intr: 0x%x", intr);
intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr);
if (wl->data_path) {
wl->rx_counter =
wl12xx_mem_read32(wl, wl->data_path->rx_control_addr);
wl1251_mem_read32(wl, wl->data_path->rx_control_addr);
/* We handle a frmware bug here */
switch ((wl->rx_counter - wl->rx_handled) & 0xf) {
case 0:
wl12xx_debug(DEBUG_IRQ, "RX: FW and host in sync");
wl1251_debug(DEBUG_IRQ, "RX: FW and host in sync");
intr &= ~WL1251_ACX_INTR_RX0_DATA;
intr &= ~WL1251_ACX_INTR_RX1_DATA;
break;
case 1:
wl12xx_debug(DEBUG_IRQ, "RX: FW +1");
wl1251_debug(DEBUG_IRQ, "RX: FW +1");
intr |= WL1251_ACX_INTR_RX0_DATA;
intr &= ~WL1251_ACX_INTR_RX1_DATA;
break;
case 2:
wl12xx_debug(DEBUG_IRQ, "RX: FW +2");
wl1251_debug(DEBUG_IRQ, "RX: FW +2");
intr |= WL1251_ACX_INTR_RX0_DATA;
intr |= WL1251_ACX_INTR_RX1_DATA;
break;
default:
wl12xx_warning("RX: FW and host out of sync: %d",
wl1251_warning("RX: FW and host out of sync: %d",
wl->rx_counter - wl->rx_handled);
break;
}
@ -449,49 +449,49 @@ static void wl1251_irq_work(struct work_struct *work)
wl->rx_handled = wl->rx_counter;
wl12xx_debug(DEBUG_IRQ, "RX counter: %d", wl->rx_counter);
wl1251_debug(DEBUG_IRQ, "RX counter: %d", wl->rx_counter);
}
intr &= wl->intr_mask;
if (intr == 0) {
wl12xx_debug(DEBUG_IRQ, "INTR is 0");
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_MASK,
wl1251_debug(DEBUG_IRQ, "INTR is 0");
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK,
~(wl->intr_mask));
goto out_sleep;
}
if (intr & WL1251_ACX_INTR_RX0_DATA) {
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA");
wl12xx_rx(wl);
wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA");
wl1251_rx(wl);
}
if (intr & WL1251_ACX_INTR_RX1_DATA) {
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA");
wl12xx_rx(wl);
wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA");
wl1251_rx(wl);
}
if (intr & WL1251_ACX_INTR_TX_RESULT) {
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT");
wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT");
wl1251_tx_complete(wl);
}
if (intr & (WL1251_ACX_INTR_EVENT_A | WL1251_ACX_INTR_EVENT_B)) {
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT (0x%x)", intr);
wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT (0x%x)", intr);
if (intr & WL1251_ACX_INTR_EVENT_A)
wl12xx_event_handle(wl, 0);
wl1251_event_handle(wl, 0);
else
wl12xx_event_handle(wl, 1);
wl1251_event_handle(wl, 1);
}
if (intr & WL1251_ACX_INTR_INIT_COMPLETE)
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_INIT_COMPLETE");
wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_INIT_COMPLETE");
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
out_sleep:
wl12xx_ps_elp_sleep(wl);
wl1251_ps_elp_sleep(wl);
out:
mutex_unlock(&wl->mutex);
@ -529,20 +529,20 @@ static int wl1251_hw_init_txq_fill(u8 qid,
(QOS_TX_LOW_VO_DEF * num_blocks) / 100;
break;
default:
wl12xx_error("Invalid TX queue id: %d", qid);
wl1251_error("Invalid TX queue id: %d", qid);
return -EINVAL;
}
return 0;
}
static int wl1251_hw_init_tx_queue_config(struct wl12xx *wl)
static int wl1251_hw_init_tx_queue_config(struct wl1251 *wl)
{
struct acx_tx_queue_qos_config *config;
struct wl1251_acx_mem_map *wl_mem_map = wl->target_mem_map;
int ret, i;
wl12xx_debug(DEBUG_ACX, "acx tx queue config");
wl1251_debug(DEBUG_ACX, "acx tx queue config");
config = kzalloc(sizeof(*config), GFP_KERNEL);
if (!config) {
@ -556,7 +556,7 @@ static int wl1251_hw_init_tx_queue_config(struct wl12xx *wl)
if (ret < 0)
goto out;
ret = wl12xx_cmd_configure(wl, ACX_TX_QUEUE_CFG,
ret = wl1251_cmd_configure(wl, ACX_TX_QUEUE_CFG,
config, sizeof(*config));
if (ret < 0)
goto out;
@ -567,7 +567,7 @@ out:
return ret;
}
static int wl1251_hw_init_data_path_config(struct wl12xx *wl)
static int wl1251_hw_init_data_path_config(struct wl1251 *wl)
{
int ret;
@ -575,11 +575,11 @@ static int wl1251_hw_init_data_path_config(struct wl12xx *wl)
wl->data_path = kzalloc(sizeof(struct acx_data_path_params_resp),
GFP_KERNEL);
if (!wl->data_path) {
wl12xx_error("Couldnt allocate data path parameters");
wl1251_error("Couldnt allocate data path parameters");
return -ENOMEM;
}
ret = wl12xx_acx_data_path_params(wl, wl->data_path);
ret = wl1251_acx_data_path_params(wl, wl->data_path);
if (ret < 0) {
kfree(wl->data_path);
wl->data_path = NULL;
@ -589,17 +589,17 @@ static int wl1251_hw_init_data_path_config(struct wl12xx *wl)
return 0;
}
static int wl1251_hw_init(struct wl12xx *wl)
static int wl1251_hw_init(struct wl1251 *wl)
{
struct wl1251_acx_mem_map *wl_mem_map;
int ret;
ret = wl12xx_hw_init_hwenc_config(wl);
ret = wl1251_hw_init_hwenc_config(wl);
if (ret < 0)
return ret;
/* Template settings */
ret = wl12xx_hw_init_templates_config(wl);
ret = wl1251_hw_init_templates_config(wl);
if (ret < 0)
return ret;
@ -614,7 +614,7 @@ static int wl1251_hw_init(struct wl12xx *wl)
goto out_free_memmap;
/* RX config */
ret = wl12xx_hw_init_rx_config(wl,
ret = wl1251_hw_init_rx_config(wl,
RX_CFG_PROMISCUOUS | RX_CFG_TSF,
RX_FILTER_OPTION_DEF);
/* RX_CONFIG_OPTION_ANY_DST_ANY_BSS,
@ -628,42 +628,42 @@ static int wl1251_hw_init(struct wl12xx *wl)
goto out_free_data_path;
/* PHY layer config */
ret = wl12xx_hw_init_phy_config(wl);
ret = wl1251_hw_init_phy_config(wl);
if (ret < 0)
goto out_free_data_path;
/* Beacon filtering */
ret = wl12xx_hw_init_beacon_filter(wl);
ret = wl1251_hw_init_beacon_filter(wl);
if (ret < 0)
goto out_free_data_path;
/* Bluetooth WLAN coexistence */
ret = wl12xx_hw_init_pta(wl);
ret = wl1251_hw_init_pta(wl);
if (ret < 0)
goto out_free_data_path;
/* Energy detection */
ret = wl12xx_hw_init_energy_detection(wl);
ret = wl1251_hw_init_energy_detection(wl);
if (ret < 0)
goto out_free_data_path;
/* Beacons and boradcast settings */
ret = wl12xx_hw_init_beacon_broadcast(wl);
ret = wl1251_hw_init_beacon_broadcast(wl);
if (ret < 0)
goto out_free_data_path;
/* Enable data path */
ret = wl12xx_cmd_data_path(wl, wl->channel, 1);
ret = wl1251_cmd_data_path(wl, wl->channel, 1);
if (ret < 0)
goto out_free_data_path;
/* Default power state */
ret = wl12xx_hw_init_power_auth(wl);
ret = wl1251_hw_init_power_auth(wl);
if (ret < 0)
goto out_free_data_path;
wl_mem_map = wl->target_mem_map;
wl12xx_info("%d tx blocks at 0x%x, %d rx blocks at 0x%x",
wl1251_info("%d tx blocks at 0x%x, %d rx blocks at 0x%x",
wl_mem_map->num_tx_mem_blocks,
wl->data_path->tx_control_addr,
wl_mem_map->num_rx_mem_blocks,
@ -680,7 +680,7 @@ static int wl1251_hw_init(struct wl12xx *wl)
return ret;
}
static int wl1251_plt_init(struct wl12xx *wl)
static int wl1251_plt_init(struct wl1251 *wl)
{
int ret;
@ -688,14 +688,14 @@ static int wl1251_plt_init(struct wl12xx *wl)
if (ret < 0)
return ret;
ret = wl12xx_cmd_data_path(wl, wl->channel, 1);
ret = wl1251_cmd_data_path(wl, wl->channel, 1);
if (ret < 0)
return ret;
return 0;
}
void wl1251_setup(struct wl12xx *wl)
void wl1251_setup(struct wl1251 *wl)
{
/* FIXME: Is it better to use strncpy here or is this ok? */
wl->chip.fw_filename = WL1251_FW_NAME;

4
drivers/net/wireless/wl12xx/wl1251_ops.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008 Nokia Corporation
*
@ -34,7 +34,7 @@
#define WL1251_POWER_ON_SLEEP 10 /* in miliseconds */
void wl1251_setup(struct wl12xx *wl);
void wl1251_setup(struct wl1251 *wl);
struct wl1251_acx_memory {

56
drivers/net/wireless/wl12xx/wl1251_ps.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008 Nokia Corporation
*
@ -25,22 +25,22 @@
#include "wl1251_ps.h"
#include "wl1251_spi.h"
#define WL12XX_WAKEUP_TIMEOUT 2000
#define WL1251_WAKEUP_TIMEOUT 2000
/* Routines to toggle sleep mode while in ELP */
void wl12xx_ps_elp_sleep(struct wl12xx *wl)
void wl1251_ps_elp_sleep(struct wl1251 *wl)
{
if (wl->elp || !wl->psm)
return;
wl12xx_debug(DEBUG_PSM, "chip to elp");
wl1251_debug(DEBUG_PSM, "chip to elp");
wl12xx_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_SLEEP);
wl1251_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_SLEEP);
wl->elp = true;
}
int wl12xx_ps_elp_wakeup(struct wl12xx *wl)
int wl1251_ps_elp_wakeup(struct wl1251 *wl)
{
unsigned long timeout;
u32 elp_reg;
@ -48,13 +48,13 @@ int wl12xx_ps_elp_wakeup(struct wl12xx *wl)
if (!wl->elp)
return 0;
wl12xx_debug(DEBUG_PSM, "waking up chip from elp");
wl1251_debug(DEBUG_PSM, "waking up chip from elp");
timeout = jiffies + msecs_to_jiffies(WL12XX_WAKEUP_TIMEOUT);
timeout = jiffies + msecs_to_jiffies(WL1251_WAKEUP_TIMEOUT);
wl12xx_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_WAKE_UP);
wl1251_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_WAKE_UP);
elp_reg = wl12xx_read32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
elp_reg = wl1251_read32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
/*
* FIXME: we should wait for irq from chip but, as a temporary
@ -62,36 +62,36 @@ int wl12xx_ps_elp_wakeup(struct wl12xx *wl)
*/
while (!(elp_reg & ELPCTRL_WLAN_READY)) {
if (time_after(jiffies, timeout)) {
wl12xx_error("elp wakeup timeout");
wl1251_error("elp wakeup timeout");
return -ETIMEDOUT;
}
msleep(1);
elp_reg = wl12xx_read32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
elp_reg = wl1251_read32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
}
wl12xx_debug(DEBUG_PSM, "wakeup time: %u ms",
wl1251_debug(DEBUG_PSM, "wakeup time: %u ms",
jiffies_to_msecs(jiffies) -
(jiffies_to_msecs(timeout) - WL12XX_WAKEUP_TIMEOUT));
(jiffies_to_msecs(timeout) - WL1251_WAKEUP_TIMEOUT));
wl->elp = false;
return 0;
}
static int wl12xx_ps_set_elp(struct wl12xx *wl, bool enable)
static int wl1251_ps_set_elp(struct wl1251 *wl, bool enable)
{
int ret;
if (enable) {
wl12xx_debug(DEBUG_PSM, "sleep auth psm/elp");
wl1251_debug(DEBUG_PSM, "sleep auth psm/elp");
ret = wl12xx_acx_sleep_auth(wl, WL12XX_PSM_ELP);
ret = wl1251_acx_sleep_auth(wl, WL1251_PSM_ELP);
if (ret < 0)
return ret;
wl12xx_ps_elp_sleep(wl);
wl1251_ps_elp_sleep(wl);
} else {
wl12xx_debug(DEBUG_PSM, "sleep auth cam");
wl1251_debug(DEBUG_PSM, "sleep auth cam");
/*
* When the target is in ELP, we can only
@ -100,9 +100,9 @@ static int wl12xx_ps_set_elp(struct wl12xx *wl, bool enable)
* changing the power authorization.
*/
wl12xx_ps_elp_wakeup(wl);
wl1251_ps_elp_wakeup(wl);
ret = wl12xx_acx_sleep_auth(wl, WL12XX_PSM_CAM);
ret = wl1251_acx_sleep_auth(wl, WL1251_PSM_CAM);
if (ret < 0)
return ret;
}
@ -110,18 +110,18 @@ static int wl12xx_ps_set_elp(struct wl12xx *wl, bool enable)
return 0;
}
int wl12xx_ps_set_mode(struct wl12xx *wl, enum wl12xx_cmd_ps_mode mode)
int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_cmd_ps_mode mode)
{
int ret;
switch (mode) {
case STATION_POWER_SAVE_MODE:
wl12xx_debug(DEBUG_PSM, "entering psm");
ret = wl12xx_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE);
wl1251_debug(DEBUG_PSM, "entering psm");
ret = wl1251_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE);
if (ret < 0)
return ret;
ret = wl12xx_ps_set_elp(wl, true);
ret = wl1251_ps_set_elp(wl, true);
if (ret < 0)
return ret;
@ -129,12 +129,12 @@ int wl12xx_ps_set_mode(struct wl12xx *wl, enum wl12xx_cmd_ps_mode mode)
break;
case STATION_ACTIVE_MODE:
default:
wl12xx_debug(DEBUG_PSM, "leaving psm");
ret = wl12xx_ps_set_elp(wl, false);
wl1251_debug(DEBUG_PSM, "leaving psm");
ret = wl1251_ps_set_elp(wl, false);
if (ret < 0)
return ret;
ret = wl12xx_cmd_ps_mode(wl, STATION_ACTIVE_MODE);
ret = wl1251_cmd_ps_mode(wl, STATION_ACTIVE_MODE);
if (ret < 0)
return ret;

14
drivers/net/wireless/wl12xx/wl1251_ps.h
View File

@ -1,8 +1,8 @@
#ifndef __WL12XX_PS_H__
#define __WL12XX_PS_H__
#ifndef __WL1251_PS_H__
#define __WL1251_PS_H__
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -28,9 +28,9 @@
#include "wl1251.h"
#include "wl1251_acx.h"
int wl12xx_ps_set_mode(struct wl12xx *wl, enum wl12xx_cmd_ps_mode mode);
void wl12xx_ps_elp_sleep(struct wl12xx *wl);
int wl12xx_ps_elp_wakeup(struct wl12xx *wl);
int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_cmd_ps_mode mode);
void wl1251_ps_elp_sleep(struct wl1251 *wl);
int wl1251_ps_elp_wakeup(struct wl1251 *wl);
#endif /* __WL12XX_PS_H__ */
#endif /* __WL1251_PS_H__ */

52
drivers/net/wireless/wl12xx/wl1251_rx.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -31,8 +31,8 @@
#include "wl1251_rx.h"
#include "wl1251_acx.h"
static void wl12xx_rx_header(struct wl12xx *wl,
struct wl12xx_rx_descriptor *desc)
static void wl1251_rx_header(struct wl1251 *wl,
struct wl1251_rx_descriptor *desc)
{
u32 rx_packet_ring_addr;
@ -40,11 +40,11 @@ static void wl12xx_rx_header(struct wl12xx *wl,
if (wl->rx_current_buffer)
rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size;
wl12xx_spi_mem_read(wl, rx_packet_ring_addr, desc, sizeof(*desc));
wl1251_spi_mem_read(wl, rx_packet_ring_addr, desc, sizeof(*desc));
}
static void wl12xx_rx_status(struct wl12xx *wl,
struct wl12xx_rx_descriptor *desc,
static void wl1251_rx_status(struct wl1251 *wl,
struct wl1251_rx_descriptor *desc,
struct ieee80211_rx_status *status,
u8 beacon)
{
@ -65,14 +65,14 @@ static void wl12xx_rx_status(struct wl12xx *wl,
* this one must be atomic, while our SPI routines can sleep.
*/
if ((wl->bss_type == BSS_TYPE_IBSS) && beacon) {
ret = wl12xx_acx_tsf_info(wl, &mactime);
ret = wl1251_acx_tsf_info(wl, &mactime);
if (ret == 0)
status->mactime = mactime;
}
status->signal = desc->rssi;
status->qual = (desc->rssi - WL12XX_RX_MIN_RSSI) * 100 /
(WL12XX_RX_MAX_RSSI - WL12XX_RX_MIN_RSSI);
status->qual = (desc->rssi - WL1251_RX_MIN_RSSI) * 100 /
(WL1251_RX_MAX_RSSI - WL1251_RX_MIN_RSSI);
status->qual = min(status->qual, 100);
status->qual = max(status->qual, 0);
@ -103,8 +103,8 @@ static void wl12xx_rx_status(struct wl12xx *wl,
/* FIXME: set status->rate_idx */
}
static void wl12xx_rx_body(struct wl12xx *wl,
struct wl12xx_rx_descriptor *desc)
static void wl1251_rx_body(struct wl1251 *wl,
struct wl1251_rx_descriptor *desc)
{
struct sk_buff *skb;
struct ieee80211_rx_status status;
@ -112,12 +112,12 @@ static void wl12xx_rx_body(struct wl12xx *wl,
u16 length, *fc;
u32 curr_id, last_id_inc, rx_packet_ring_addr;
length = WL12XX_RX_ALIGN(desc->length - PLCP_HEADER_LENGTH);
length = WL1251_RX_ALIGN(desc->length - PLCP_HEADER_LENGTH);
curr_id = (desc->flags & RX_DESC_SEQNUM_MASK) >> RX_DESC_PACKETID_SHIFT;
last_id_inc = (wl->rx_last_id + 1) % (RX_MAX_PACKET_ID + 1);
if (last_id_inc != curr_id) {
wl12xx_warning("curr ID:%d, last ID inc:%d",
wl1251_warning("curr ID:%d, last ID inc:%d",
curr_id, last_id_inc);
wl->rx_last_id = curr_id;
} else {
@ -125,18 +125,18 @@ static void wl12xx_rx_body(struct wl12xx *wl,
}
rx_packet_ring_addr = wl->data_path->rx_packet_ring_addr +
sizeof(struct wl12xx_rx_descriptor) + 20;
sizeof(struct wl1251_rx_descriptor) + 20;
if (wl->rx_current_buffer)
rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size;
skb = dev_alloc_skb(length);
if (!skb) {
wl12xx_error("Couldn't allocate RX frame");
wl1251_error("Couldn't allocate RX frame");
return;
}
rx_buffer = skb_put(skb, length);
wl12xx_spi_mem_read(wl, rx_packet_ring_addr, rx_buffer, length);
wl1251_spi_mem_read(wl, rx_packet_ring_addr, rx_buffer, length);
/* The actual lenght doesn't include the target's alignment */
skb->len = desc->length - PLCP_HEADER_LENGTH;
@ -146,15 +146,15 @@ static void wl12xx_rx_body(struct wl12xx *wl,
if ((*fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON)
beacon = 1;
wl12xx_rx_status(wl, desc, &status, beacon);
wl1251_rx_status(wl, desc, &status, beacon);
wl12xx_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
wl1251_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
beacon ? "beacon" : "");
ieee80211_rx(wl->hw, skb, &status);
}
static void wl12xx_rx_ack(struct wl12xx *wl)
static void wl1251_rx_ack(struct wl1251 *wl)
{
u32 data, addr;
@ -166,30 +166,30 @@ static void wl12xx_rx_ack(struct wl12xx *wl)
data = INTR_TRIG_RX_PROC0;
}
wl12xx_reg_write32(wl, addr, data);
wl1251_reg_write32(wl, addr, data);
/* Toggle buffer ring */
wl->rx_current_buffer = !wl->rx_current_buffer;
}
void wl12xx_rx(struct wl12xx *wl)
void wl1251_rx(struct wl1251 *wl)
{
struct wl12xx_rx_descriptor *rx_desc;
struct wl1251_rx_descriptor *rx_desc;
if (wl->state != WL12XX_STATE_ON)
if (wl->state != WL1251_STATE_ON)
return;
rx_desc = wl->rx_descriptor;
/* We first read the frame's header */
wl12xx_rx_header(wl, rx_desc);
wl1251_rx_header(wl, rx_desc);
/* Now we can read the body */
wl12xx_rx_body(wl, rx_desc);
wl1251_rx_body(wl, rx_desc);
/* Finally, we need to ACK the RX */
wl12xx_rx_ack(wl);
wl1251_rx_ack(wl);
return;
}

20
drivers/net/wireless/wl12xx/wl1251_rx.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -22,8 +22,8 @@
*
*/
#ifndef __WL12XX_RX_H__
#define __WL12XX_RX_H__
#ifndef __WL1251_RX_H__
#define __WL1251_RX_H__
#include <linux/bitops.h>
@ -45,12 +45,12 @@
* 4) The target prepares the next RX packet.
*/
#define WL12XX_RX_MAX_RSSI -30
#define WL12XX_RX_MIN_RSSI -95
#define WL1251_RX_MAX_RSSI -30
#define WL1251_RX_MIN_RSSI -95
#define WL12XX_RX_ALIGN_TO 4
#define WL12XX_RX_ALIGN(len) (((len) + WL12XX_RX_ALIGN_TO - 1) & \
~(WL12XX_RX_ALIGN_TO - 1))
#define WL1251_RX_ALIGN_TO 4
#define WL1251_RX_ALIGN(len) (((len) + WL1251_RX_ALIGN_TO - 1) & \
~(WL1251_RX_ALIGN_TO - 1))
#define SHORT_PREAMBLE_BIT BIT(0)
#define OFDM_RATE_BIT BIT(6)
@ -74,7 +74,7 @@
#define RX_DESC_MIC_FAIL 0x2000
#define RX_DESC_DECRYPT_FAIL 0x4000
struct wl12xx_rx_descriptor {
struct wl1251_rx_descriptor {
u32 timestamp; /* In microseconds */
u16 length; /* Paylod length, including headers */
u16 flags;
@ -119,6 +119,6 @@ struct wl12xx_rx_descriptor {
u8 snr; /* in dB */
} __attribute__ ((packed));
void wl12xx_rx(struct wl12xx *wl);
void wl1251_rx(struct wl1251 *wl);
#endif

107
drivers/net/wireless/wl12xx/wl1251_spi.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (C) 2008 Nokia Corporation
*
@ -26,11 +26,10 @@
#include <linux/spi/spi.h>
#include "wl1251.h"
#include "wl12xx_80211.h"
#include "reg.h"
#include "wl1251_spi.h"
static int wl12xx_translate_reg_addr(struct wl12xx *wl, int addr)
static int wl1251_translate_reg_addr(struct wl1251 *wl, int addr)
{
/* If the address is lower than REGISTERS_BASE, it means that this is
* a chip-specific register address, so look it up in the registers
@ -38,7 +37,7 @@ static int wl12xx_translate_reg_addr(struct wl12xx *wl, int addr)
if (addr < REGISTERS_BASE) {
/* Make sure we don't go over the table */
if (addr >= ACX_REG_TABLE_LEN) {
wl12xx_error("address out of range (%d)", addr);
wl1251_error("address out of range (%d)", addr);
return -EINVAL;
}
addr = wl->chip.acx_reg_table[addr];
@ -47,13 +46,13 @@ static int wl12xx_translate_reg_addr(struct wl12xx *wl, int addr)
return addr - wl->physical_reg_addr + wl->virtual_reg_addr;
}
static int wl12xx_translate_mem_addr(struct wl12xx *wl, int addr)
static int wl1251_translate_mem_addr(struct wl1251 *wl, int addr)
{
return addr - wl->physical_mem_addr + wl->virtual_mem_addr;
}
void wl12xx_spi_reset(struct wl12xx *wl)
void wl1251_spi_reset(struct wl1251 *wl)
{
u8 *cmd;
struct spi_transfer t;
@ -61,7 +60,7 @@ void wl12xx_spi_reset(struct wl12xx *wl)
cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
if (!cmd) {
wl12xx_error("could not allocate cmd for spi reset");
wl1251_error("could not allocate cmd for spi reset");
return;
}
@ -76,10 +75,10 @@ void wl12xx_spi_reset(struct wl12xx *wl)
spi_sync(wl->spi, &m);
wl12xx_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN);
wl1251_dump(DEBUG_SPI, "spi reset -> ", cmd, WSPI_INIT_CMD_LEN);
}
void wl12xx_spi_init(struct wl12xx *wl)
void wl1251_spi_init(struct wl1251 *wl)
{
u8 crc[WSPI_INIT_CMD_CRC_LEN], *cmd;
struct spi_transfer t;
@ -87,7 +86,7 @@ void wl12xx_spi_init(struct wl12xx *wl)
cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
if (!cmd) {
wl12xx_error("could not allocate cmd for spi init");
wl1251_error("could not allocate cmd for spi init");
return;
}
@ -130,7 +129,7 @@ void wl12xx_spi_init(struct wl12xx *wl)
spi_sync(wl->spi, &m);
wl12xx_dump(DEBUG_SPI, "spi init -> ", cmd, WSPI_INIT_CMD_LEN);
wl1251_dump(DEBUG_SPI, "spi init -> ", cmd, WSPI_INIT_CMD_LEN);
}
/* Set the SPI partitions to access the chip addresses
@ -166,18 +165,18 @@ void wl12xx_spi_init(struct wl12xx *wl)
* | |
*
*/
int wl12xx_set_partition(struct wl12xx *wl,
int wl1251_set_partition(struct wl1251 *wl,
u32 mem_start, u32 mem_size,
u32 reg_start, u32 reg_size)
{
struct wl12xx_partition *partition;
struct wl1251_partition *partition;
struct spi_transfer t;
struct spi_message m;
size_t len, cmd_len;
u32 *cmd;
int addr;
cmd_len = sizeof(u32) + 2 * sizeof(struct wl12xx_partition);
cmd_len = sizeof(u32) + 2 * sizeof(struct wl1251_partition);
cmd = kzalloc(cmd_len, GFP_KERNEL);
if (!cmd)
return -ENOMEM;
@ -185,28 +184,28 @@ int wl12xx_set_partition(struct wl12xx *wl,
spi_message_init(&m);
memset(&t, 0, sizeof(t));
partition = (struct wl12xx_partition *) (cmd + 1);
partition = (struct wl1251_partition *) (cmd + 1);
addr = HW_ACCESS_PART0_SIZE_ADDR;
len = 2 * sizeof(struct wl12xx_partition);
len = 2 * sizeof(struct wl1251_partition);
*cmd |= WSPI_CMD_WRITE;
*cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
*cmd |= addr & WSPI_CMD_BYTE_ADDR;
wl12xx_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
mem_start, mem_size);
wl12xx_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
reg_start, reg_size);
/* Make sure that the two partitions together don't exceed the
* address range */
if ((mem_size + reg_size) > HW_ACCESS_MEMORY_MAX_RANGE) {
wl12xx_debug(DEBUG_SPI, "Total size exceeds maximum virtual"
wl1251_debug(DEBUG_SPI, "Total size exceeds maximum virtual"
" address range. Truncating partition[0].");
mem_size = HW_ACCESS_MEMORY_MAX_RANGE - reg_size;
wl12xx_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
mem_start, mem_size);
wl12xx_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
reg_start, reg_size);
}
@ -214,23 +213,23 @@ int wl12xx_set_partition(struct wl12xx *wl,
((mem_start + mem_size) > reg_start)) {
/* Guarantee that the memory partition doesn't overlap the
* registers partition */
wl12xx_debug(DEBUG_SPI, "End of partition[0] is "
wl1251_debug(DEBUG_SPI, "End of partition[0] is "
"overlapping partition[1]. Adjusted.");
mem_size = reg_start - mem_start;
wl12xx_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
mem_start, mem_size);
wl12xx_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
reg_start, reg_size);
} else if ((reg_start < mem_start) &&
((reg_start + reg_size) > mem_start)) {
/* Guarantee that the register partition doesn't overlap the
* memory partition */
wl12xx_debug(DEBUG_SPI, "End of partition[1] is"
wl1251_debug(DEBUG_SPI, "End of partition[1] is"
" overlapping partition[0]. Adjusted.");
reg_size = mem_start - reg_start;
wl12xx_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
mem_start, mem_size);
wl12xx_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
reg_start, reg_size);
}
@ -256,7 +255,7 @@ int wl12xx_set_partition(struct wl12xx *wl,
return 0;
}
void wl12xx_spi_read(struct wl12xx *wl, int addr, void *buf,
void wl1251_spi_read(struct wl1251 *wl, int addr, void *buf,
size_t len, bool fixed)
{
struct spi_transfer t[3];
@ -284,7 +283,7 @@ void wl12xx_spi_read(struct wl12xx *wl, int addr, void *buf,
/* Busy and non busy words read */
t[1].rx_buf = busy_buf;
t[1].len = WL12XX_BUSY_WORD_LEN;
t[1].len = WL1251_BUSY_WORD_LEN;
spi_message_add_tail(&t[1], &m);
t[2].rx_buf = buf;
@ -295,11 +294,11 @@ void wl12xx_spi_read(struct wl12xx *wl, int addr, void *buf,
/* FIXME: check busy words */
wl12xx_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
wl12xx_dump(DEBUG_SPI, "spi_read buf <- ", buf, len);
wl1251_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
wl1251_dump(DEBUG_SPI, "spi_read buf <- ", buf, len);
}
void wl12xx_spi_write(struct wl12xx *wl, int addr, void *buf,
void wl1251_spi_write(struct wl1251 *wl, int addr, void *buf,
size_t len, bool fixed)
{
struct spi_transfer t[2];
@ -329,66 +328,66 @@ void wl12xx_spi_write(struct wl12xx *wl, int addr, void *buf,
spi_sync(wl->spi, &m);
wl12xx_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
wl12xx_dump(DEBUG_SPI, "spi_write buf -> ", buf, len);
wl1251_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
wl1251_dump(DEBUG_SPI, "spi_write buf -> ", buf, len);
}
void wl12xx_spi_mem_read(struct wl12xx *wl, int addr, void *buf,
void wl1251_spi_mem_read(struct wl1251 *wl, int addr, void *buf,
size_t len)
{
int physical;
physical = wl12xx_translate_mem_addr(wl, addr);
physical = wl1251_translate_mem_addr(wl, addr);
wl12xx_spi_read(wl, physical, buf, len, false);
wl1251_spi_read(wl, physical, buf, len, false);
}
void wl12xx_spi_mem_write(struct wl12xx *wl, int addr, void *buf,
void wl1251_spi_mem_write(struct wl1251 *wl, int addr, void *buf,
size_t len)
{
int physical;
physical = wl12xx_translate_mem_addr(wl, addr);
physical = wl1251_translate_mem_addr(wl, addr);
wl12xx_spi_write(wl, physical, buf, len, false);
wl1251_spi_write(wl, physical, buf, len, false);
}
void wl12xx_spi_reg_read(struct wl12xx *wl, int addr, void *buf, size_t len,
void wl1251_spi_reg_read(struct wl1251 *wl, int addr, void *buf, size_t len,
bool fixed)
{
int physical;
physical = wl12xx_translate_reg_addr(wl, addr);
physical = wl1251_translate_reg_addr(wl, addr);
wl12xx_spi_read(wl, physical, buf, len, fixed);
wl1251_spi_read(wl, physical, buf, len, fixed);
}
void wl12xx_spi_reg_write(struct wl12xx *wl, int addr, void *buf, size_t len,
void wl1251_spi_reg_write(struct wl1251 *wl, int addr, void *buf, size_t len,
bool fixed)
{
int physical;
physical = wl12xx_translate_reg_addr(wl, addr);
physical = wl1251_translate_reg_addr(wl, addr);
wl12xx_spi_write(wl, physical, buf, len, fixed);
wl1251_spi_write(wl, physical, buf, len, fixed);
}
u32 wl12xx_mem_read32(struct wl12xx *wl, int addr)
u32 wl1251_mem_read32(struct wl1251 *wl, int addr)
{
return wl12xx_read32(wl, wl12xx_translate_mem_addr(wl, addr));
return wl1251_read32(wl, wl1251_translate_mem_addr(wl, addr));
}
void wl12xx_mem_write32(struct wl12xx *wl, int addr, u32 val)
void wl1251_mem_write32(struct wl1251 *wl, int addr, u32 val)
{
wl12xx_write32(wl, wl12xx_translate_mem_addr(wl, addr), val);
wl1251_write32(wl, wl1251_translate_mem_addr(wl, addr), val);
}
u32 wl12xx_reg_read32(struct wl12xx *wl, int addr)
u32 wl1251_reg_read32(struct wl1251 *wl, int addr)
{
return wl12xx_read32(wl, wl12xx_translate_reg_addr(wl, addr));
return wl1251_read32(wl, wl1251_translate_reg_addr(wl, addr));
}
void wl12xx_reg_write32(struct wl12xx *wl, int addr, u32 val)
void wl1251_reg_write32(struct wl1251 *wl, int addr, u32 val)
{
wl12xx_write32(wl, wl12xx_translate_reg_addr(wl, addr), val);
wl1251_write32(wl, wl1251_translate_reg_addr(wl, addr), val);
}

44
drivers/net/wireless/wl12xx/wl1251_spi.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -22,8 +22,8 @@
*
*/
#ifndef __WL12XX_SPI_H__
#define __WL12XX_SPI_H__
#ifndef __WL1251_SPI_H__
#define __WL1251_SPI_H__
#include "wl1251_cmd.h"
#include "wl1251_acx.h"
@ -66,50 +66,50 @@
#define WSPI_INIT_CMD_LEN 8
#define HW_ACCESS_WSPI_FIXED_BUSY_LEN \
((WL12XX_BUSY_WORD_LEN - 4) / sizeof(u32))
((WL1251_BUSY_WORD_LEN - 4) / sizeof(u32))
#define HW_ACCESS_WSPI_INIT_CMD_MASK 0
/* Raw target IO, address is not translated */
void wl12xx_spi_write(struct wl12xx *wl, int addr, void *buf,
void wl1251_spi_write(struct wl1251 *wl, int addr, void *buf,
size_t len, bool fixed);
void wl12xx_spi_read(struct wl12xx *wl, int addr, void *buf,
void wl1251_spi_read(struct wl1251 *wl, int addr, void *buf,
size_t len, bool fixed);
/* Memory target IO, address is tranlated to partition 0 */
void wl12xx_spi_mem_read(struct wl12xx *wl, int addr, void *buf, size_t len);
void wl12xx_spi_mem_write(struct wl12xx *wl, int addr, void *buf, size_t len);
u32 wl12xx_mem_read32(struct wl12xx *wl, int addr);
void wl12xx_mem_write32(struct wl12xx *wl, int addr, u32 val);
void wl1251_spi_mem_read(struct wl1251 *wl, int addr, void *buf, size_t len);
void wl1251_spi_mem_write(struct wl1251 *wl, int addr, void *buf, size_t len);
u32 wl1251_mem_read32(struct wl1251 *wl, int addr);
void wl1251_mem_write32(struct wl1251 *wl, int addr, u32 val);
/* Registers IO */
void wl12xx_spi_reg_read(struct wl12xx *wl, int addr, void *buf, size_t len,
void wl1251_spi_reg_read(struct wl1251 *wl, int addr, void *buf, size_t len,
bool fixed);
void wl12xx_spi_reg_write(struct wl12xx *wl, int addr, void *buf, size_t len,
void wl1251_spi_reg_write(struct wl1251 *wl, int addr, void *buf, size_t len,
bool fixed);
u32 wl12xx_reg_read32(struct wl12xx *wl, int addr);
void wl12xx_reg_write32(struct wl12xx *wl, int addr, u32 val);
u32 wl1251_reg_read32(struct wl1251 *wl, int addr);
void wl1251_reg_write32(struct wl1251 *wl, int addr, u32 val);
/* INIT and RESET words */
void wl12xx_spi_reset(struct wl12xx *wl);
void wl12xx_spi_init(struct wl12xx *wl);
int wl12xx_set_partition(struct wl12xx *wl,
void wl1251_spi_reset(struct wl1251 *wl);
void wl1251_spi_init(struct wl1251 *wl);
int wl1251_set_partition(struct wl1251 *wl,
u32 part_start, u32 part_size,
u32 reg_start, u32 reg_size);
static inline u32 wl12xx_read32(struct wl12xx *wl, int addr)
static inline u32 wl1251_read32(struct wl1251 *wl, int addr)
{
wl12xx_spi_read(wl, addr, &wl->buffer_32,
wl1251_spi_read(wl, addr, &wl->buffer_32,
sizeof(wl->buffer_32), false);
return wl->buffer_32;
}
static inline void wl12xx_write32(struct wl12xx *wl, int addr, u32 val)
static inline void wl1251_write32(struct wl1251 *wl, int addr, u32 val)
{
wl->buffer_32 = val;
wl12xx_spi_write(wl, addr, &wl->buffer_32,
wl1251_spi_write(wl, addr, &wl->buffer_32,
sizeof(wl->buffer_32), false);
}
#endif /* __WL12XX_SPI_H__ */
#endif /* __WL1251_SPI_H__ */

70
drivers/net/wireless/wl12xx/wl1251_tx.c
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -31,7 +31,7 @@
#include "wl1251_tx.h"
#include "wl1251_ps.h"
static bool wl1251_tx_double_buffer_busy(struct wl12xx *wl, u32 data_out_count)
static bool wl1251_tx_double_buffer_busy(struct wl1251 *wl, u32 data_out_count)
{
int used, data_in_count;
@ -52,13 +52,13 @@ static bool wl1251_tx_double_buffer_busy(struct wl12xx *wl, u32 data_out_count)
return false;
}
static int wl1251_tx_path_status(struct wl12xx *wl)
static int wl1251_tx_path_status(struct wl1251 *wl)
{
u32 status, addr, data_out_count;
bool busy;
addr = wl->data_path->tx_control_addr;
status = wl12xx_mem_read32(wl, addr);
status = wl1251_mem_read32(wl, addr);
data_out_count = status & TX_STATUS_DATA_OUT_COUNT_MASK;
busy = wl1251_tx_double_buffer_busy(wl, data_out_count);
@ -68,7 +68,7 @@ static int wl1251_tx_path_status(struct wl12xx *wl)
return 0;
}
static int wl1251_tx_id(struct wl12xx *wl, struct sk_buff *skb)
static int wl1251_tx_id(struct wl1251 *wl, struct sk_buff *skb)
{
int i;
@ -142,7 +142,7 @@ static void wl1251_tx_frag_block_num(struct tx_double_buffer_desc *tx_hdr)
tx_hdr->num_mem_blocks = mem_blocks;
}
static int wl1251_tx_fill_hdr(struct wl12xx *wl, struct sk_buff *skb,
static int wl1251_tx_fill_hdr(struct wl1251 *wl, struct sk_buff *skb,
struct ieee80211_tx_info *control)
{
struct tx_double_buffer_desc *tx_hdr;
@ -177,7 +177,7 @@ static int wl1251_tx_fill_hdr(struct wl12xx *wl, struct sk_buff *skb,
}
/* We copy the packet to the target */
static int wl1251_tx_send_packet(struct wl12xx *wl, struct sk_buff *skb,
static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb,
struct ieee80211_tx_info *control)
{
struct tx_double_buffer_desc *tx_hdr;
@ -211,7 +211,7 @@ static int wl1251_tx_send_packet(struct wl12xx *wl, struct sk_buff *skb,
*/
if (unlikely((long)skb->data & 0x03)) {
int offset = (4 - (long)skb->data) & 0x03;
wl12xx_debug(DEBUG_TX, "skb offset %d", offset);
wl1251_debug(DEBUG_TX, "skb offset %d", offset);
/* check whether the current skb can be used */
if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) {
@ -221,7 +221,7 @@ static int wl1251_tx_send_packet(struct wl12xx *wl, struct sk_buff *skb,
skb_reserve(skb, offset);
memmove(skb->data, src, skb->len);
} else {
wl12xx_info("No handler, fixme!");
wl1251_info("No handler, fixme!");
return -EINVAL;
}
}
@ -235,15 +235,15 @@ static int wl1251_tx_send_packet(struct wl12xx *wl, struct sk_buff *skb,
else
addr = wl->data_path->tx_packet_ring_addr;
wl12xx_spi_mem_write(wl, addr, skb->data, len);
wl1251_spi_mem_write(wl, addr, skb->data, len);
wl12xx_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u rate 0x%x",
wl1251_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u rate 0x%x",
tx_hdr->id, skb, tx_hdr->length, tx_hdr->rate);
return 0;
}
static void wl1251_tx_trigger(struct wl12xx *wl)
static void wl1251_tx_trigger(struct wl1251 *wl)
{
u32 data, addr;
@ -255,7 +255,7 @@ static void wl1251_tx_trigger(struct wl12xx *wl)
data = INTR_TRIG_TX_PROC0;
}
wl12xx_reg_write32(wl, addr, data);
wl1251_reg_write32(wl, addr, data);
/* Bumping data in */
wl->data_in_count = (wl->data_in_count + 1) &
@ -263,7 +263,7 @@ static void wl1251_tx_trigger(struct wl12xx *wl)
}
/* caller must hold wl->mutex */
static int wl1251_tx_frame(struct wl12xx *wl, struct sk_buff *skb)
static int wl1251_tx_frame(struct wl1251 *wl, struct sk_buff *skb)
{
struct ieee80211_tx_info *info;
int ret = 0;
@ -274,7 +274,7 @@ static int wl1251_tx_frame(struct wl12xx *wl, struct sk_buff *skb)
if (info->control.hw_key) {
idx = info->control.hw_key->hw_key_idx;
if (unlikely(wl->default_key != idx)) {
ret = wl12xx_acx_default_key(wl, idx);
ret = wl1251_acx_default_key(wl, idx);
if (ret < 0)
return ret;
}
@ -299,19 +299,19 @@ static int wl1251_tx_frame(struct wl12xx *wl, struct sk_buff *skb)
void wl1251_tx_work(struct work_struct *work)
{
struct wl12xx *wl = container_of(work, struct wl12xx, tx_work);
struct wl1251 *wl = container_of(work, struct wl1251, tx_work);
struct sk_buff *skb;
bool woken_up = false;
int ret;
mutex_lock(&wl->mutex);
if (unlikely(wl->state == WL12XX_STATE_OFF))
if (unlikely(wl->state == WL1251_STATE_OFF))
goto out;
while ((skb = skb_dequeue(&wl->tx_queue))) {
if (!woken_up) {
ret = wl12xx_ps_elp_wakeup(wl);
ret = wl1251_ps_elp_wakeup(wl);
if (ret < 0)
goto out;
woken_up = true;
@ -320,7 +320,7 @@ void wl1251_tx_work(struct work_struct *work)
ret = wl1251_tx_frame(wl, skb);
if (ret == -EBUSY) {
/* firmware buffer is full, stop queues */
wl12xx_debug(DEBUG_TX, "tx_work: fw buffer full, "
wl1251_debug(DEBUG_TX, "tx_work: fw buffer full, "
"stop queues");
ieee80211_stop_queues(wl->hw);
wl->tx_queue_stopped = true;
@ -334,7 +334,7 @@ void wl1251_tx_work(struct work_struct *work)
out:
if (woken_up)
wl12xx_ps_elp_sleep(wl);
wl1251_ps_elp_sleep(wl);
mutex_unlock(&wl->mutex);
}
@ -367,7 +367,7 @@ static const char *wl1251_tx_parse_status(u8 status)
return buf;
}
static void wl1251_tx_packet_cb(struct wl12xx *wl,
static void wl1251_tx_packet_cb(struct wl1251 *wl,
struct tx_result *result)
{
struct ieee80211_tx_info *info;
@ -377,7 +377,7 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
skb = wl->tx_frames[result->id];
if (skb == NULL) {
wl12xx_error("SKB for packet %d is NULL", result->id);
wl1251_error("SKB for packet %d is NULL", result->id);
return;
}
@ -402,7 +402,7 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
skb_pull(skb, WL1251_TKIP_IV_SPACE);
}
wl12xx_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
wl1251_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
" status 0x%x (%s)",
result->id, skb, result->ack_failures, result->rate,
result->status, wl1251_tx_parse_status(result->status));
@ -413,7 +413,7 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
wl->tx_frames[result->id] = NULL;
if (wl->tx_queue_stopped) {
wl12xx_debug(DEBUG_TX, "cb: queue was stopped");
wl1251_debug(DEBUG_TX, "cb: queue was stopped");
skb = skb_dequeue(&wl->tx_queue);
@ -425,7 +425,7 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
ret = wl1251_tx_frame(wl, skb);
if (ret == -EBUSY) {
/* firmware buffer is still full */
wl12xx_debug(DEBUG_TX, "cb: fw buffer "
wl1251_debug(DEBUG_TX, "cb: fw buffer "
"still full");
skb_queue_head(&wl->tx_queue, skb);
return;
@ -435,23 +435,23 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
}
}
wl12xx_debug(DEBUG_TX, "cb: waking queues");
wl1251_debug(DEBUG_TX, "cb: waking queues");
ieee80211_wake_queues(wl->hw);
wl->tx_queue_stopped = false;
}
}
/* Called upon reception of a TX complete interrupt */
void wl1251_tx_complete(struct wl12xx *wl)
void wl1251_tx_complete(struct wl1251 *wl)
{
int i, result_index, num_complete = 0;
struct tx_result result[FW_TX_CMPLT_BLOCK_SIZE], *result_ptr;
if (unlikely(wl->state != WL12XX_STATE_ON))
if (unlikely(wl->state != WL1251_STATE_ON))
return;
/* First we read the result */
wl12xx_spi_mem_read(wl, wl->data_path->tx_complete_addr,
wl1251_spi_mem_read(wl, wl->data_path->tx_complete_addr,
result, sizeof(result));
result_index = wl->next_tx_complete;
@ -482,7 +482,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
*/
if (result_index > wl->next_tx_complete) {
/* Only 1 write is needed */
wl12xx_spi_mem_write(wl,
wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr +
(wl->next_tx_complete *
sizeof(struct tx_result)),
@ -493,7 +493,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
} else if (result_index < wl->next_tx_complete) {
/* 2 writes are needed */
wl12xx_spi_mem_write(wl,
wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr +
(wl->next_tx_complete *
sizeof(struct tx_result)),
@ -502,7 +502,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
wl->next_tx_complete) *
sizeof(struct tx_result));
wl12xx_spi_mem_write(wl,
wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr,
result,
(num_complete -
@ -512,7 +512,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
} else {
/* We have to write the whole array */
wl12xx_spi_mem_write(wl,
wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr,
result,
FW_TX_CMPLT_BLOCK_SIZE *
@ -525,7 +525,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
}
/* caller must hold wl->mutex */
void wl1251_tx_flush(struct wl12xx *wl)
void wl1251_tx_flush(struct wl1251 *wl)
{
int i;
struct sk_buff *skb;
@ -537,7 +537,7 @@ void wl1251_tx_flush(struct wl12xx *wl)
while ((skb = skb_dequeue(&wl->tx_queue))) {
info = IEEE80211_SKB_CB(skb);
wl12xx_debug(DEBUG_TX, "flushing skb 0x%p", skb);
wl1251_debug(DEBUG_TX, "flushing skb 0x%p", skb);
if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS))
continue;

6
drivers/net/wireless/wl12xx/wl1251_tx.h
View File

@ -1,5 +1,5 @@
/*
* This file is part of wl12xx
* This file is part of wl1251
*
* Copyright (c) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation
@ -210,7 +210,7 @@ struct tx_result {
} __attribute__ ((packed));
void wl1251_tx_work(struct work_struct *work);
void wl1251_tx_complete(struct wl12xx *wl);
void wl1251_tx_flush(struct wl12xx *wl);
void wl1251_tx_complete(struct wl1251 *wl);
void wl1251_tx_flush(struct wl1251 *wl);
#endif