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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008-2009 Nokia Corporation * Copyright (C) 2008-2009 Nokia Corporation
@ -22,15 +22,15 @@
* *
*/ */
#ifndef __WL12XX_H__ #ifndef __WL1251_H__
#define __WL12XX_H__ #define __WL1251_H__
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/list.h> #include <linux/list.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <net/mac80211.h> #include <net/mac80211.h>
#define DRIVER_NAME "wl12xx" #define DRIVER_NAME "wl1251"
#define DRIVER_PREFIX DRIVER_NAME ": " #define DRIVER_PREFIX DRIVER_NAME ": "
enum { enum {
@ -56,25 +56,25 @@ enum {
#define DEBUG_DUMP_LIMIT 1024 #define DEBUG_DUMP_LIMIT 1024
#define wl12xx_error(fmt, arg...) \ #define wl1251_error(fmt, arg...) \
printk(KERN_ERR DRIVER_PREFIX "ERROR " fmt "\n", ##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) 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) 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) printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg)
#define wl12xx_debug(level, fmt, arg...) \ #define wl1251_debug(level, fmt, arg...) \
do { \ do { \
if (level & DEBUG_LEVEL) \ if (level & DEBUG_LEVEL) \
printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg); \ printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg); \
} while (0) } while (0)
#define wl12xx_dump(level, prefix, buf, len) \ #define wl1251_dump(level, prefix, buf, len) \
do { \ do { \
if (level & DEBUG_LEVEL) \ if (level & DEBUG_LEVEL) \
print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \ print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
@ -84,7 +84,7 @@ enum {
0); \ 0); \
} while (0) } while (0)
#define wl12xx_dump_ascii(level, prefix, buf, len) \ #define wl1251_dump_ascii(level, prefix, buf, len) \
do { \ do { \
if (level & DEBUG_LEVEL) \ if (level & DEBUG_LEVEL) \
print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \ print_hex_dump(KERN_DEBUG, DRIVER_PREFIX prefix, \
@ -94,10 +94,10 @@ enum {
true); \ true); \
} while (0) } while (0)
#define WL12XX_DEFAULT_RX_CONFIG (CFG_UNI_FILTER_EN | \ #define WL1251_DEFAULT_RX_CONFIG (CFG_UNI_FILTER_EN | \
CFG_BSSID_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_MGMT_EN | \
CFG_RX_DATA_EN | \ CFG_RX_DATA_EN | \
CFG_RX_CTL_EN | \ CFG_RX_CTL_EN | \
@ -105,7 +105,7 @@ enum {
CFG_RX_AUTH_EN | \ CFG_RX_AUTH_EN | \
CFG_RX_ASSOC_EN) CFG_RX_ASSOC_EN)
#define WL12XX_BUSY_WORD_LEN 8 #define WL1251_BUSY_WORD_LEN 8
struct boot_attr { struct boot_attr {
u32 radio_type; u32 radio_type;
@ -117,13 +117,13 @@ struct boot_attr {
u32 bugfix; u32 bugfix;
}; };
enum wl12xx_state { enum wl1251_state {
WL12XX_STATE_OFF, WL1251_STATE_OFF,
WL12XX_STATE_ON, WL1251_STATE_ON,
WL12XX_STATE_PLT, WL1251_STATE_PLT,
}; };
enum wl12xx_partition_type { enum wl1251_partition_type {
PART_DOWN, PART_DOWN,
PART_WORK, PART_WORK,
PART_DRPW, PART_DRPW,
@ -131,20 +131,20 @@ enum wl12xx_partition_type {
PART_TABLE_LEN PART_TABLE_LEN
}; };
struct wl12xx_partition { struct wl1251_partition {
u32 size; u32 size;
u32 start; u32 start;
}; };
struct wl12xx_partition_set { struct wl1251_partition_set {
struct wl12xx_partition mem; struct wl1251_partition mem;
struct wl12xx_partition reg; struct wl1251_partition reg;
}; };
struct wl12xx; struct wl1251;
/* FIXME: I'm not sure about this structure name */ /* FIXME: I'm not sure about this structure name */
struct wl12xx_chip { struct wl1251_chip {
u32 id; u32 id;
const char *fw_filename; const char *fw_filename;
@ -156,23 +156,23 @@ struct wl12xx_chip {
int intr_cmd_complete; int intr_cmd_complete;
int intr_init_complete; int intr_init_complete;
int (*op_upload_fw)(struct wl12xx *wl); int (*op_upload_fw)(struct wl1251 *wl);
int (*op_upload_nvs)(struct wl12xx *wl); int (*op_upload_nvs)(struct wl1251 *wl);
int (*op_boot)(struct wl12xx *wl); int (*op_boot)(struct wl1251 *wl);
void (*op_set_ecpu_ctrl)(struct wl12xx *wl, u32 flag); void (*op_set_ecpu_ctrl)(struct wl1251 *wl, u32 flag);
void (*op_target_enable_interrupts)(struct wl12xx *wl); void (*op_target_enable_interrupts)(struct wl1251 *wl);
int (*op_hw_init)(struct wl12xx *wl); int (*op_hw_init)(struct wl1251 *wl);
int (*op_plt_init)(struct wl12xx *wl); int (*op_plt_init)(struct wl1251 *wl);
void (*op_tx_flush)(struct wl12xx *wl); void (*op_tx_flush)(struct wl1251 *wl);
void (*op_fw_version)(struct wl12xx *wl); void (*op_fw_version)(struct wl1251 *wl);
int (*op_cmd_join)(struct wl12xx *wl, u8 bss_type, u8 dtim_interval, int (*op_cmd_join)(struct wl1251 *wl, u8 bss_type, u8 dtim_interval,
u16 beacon_interval, u8 wait); 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; enum wl12xx_acx_int_reg *acx_reg_table;
}; };
struct wl12xx_stats { struct wl1251_stats {
struct acx_statistics *fw_stats; struct acx_statistics *fw_stats;
unsigned long fw_stats_update; unsigned long fw_stats_update;
@ -180,7 +180,7 @@ struct wl12xx_stats {
unsigned int excessive_retries; unsigned int excessive_retries;
}; };
struct wl12xx_debugfs { struct wl1251_debugfs {
struct dentry *rootdir; struct dentry *rootdir;
struct dentry *fw_statistics; struct dentry *fw_statistics;
@ -281,7 +281,7 @@ struct wl12xx_debugfs {
struct dentry *excessive_retries; struct dentry *excessive_retries;
}; };
struct wl12xx { struct wl1251 {
struct ieee80211_hw *hw; struct ieee80211_hw *hw;
bool mac80211_registered; bool mac80211_registered;
@ -290,7 +290,7 @@ struct wl12xx {
void (*set_power)(bool enable); void (*set_power)(bool enable);
int irq; int irq;
enum wl12xx_state state; enum wl1251_state state;
struct mutex mutex; struct mutex mutex;
int physical_mem_addr; int physical_mem_addr;
@ -298,7 +298,7 @@ struct wl12xx {
int virtual_mem_addr; int virtual_mem_addr;
int virtual_reg_addr; int virtual_reg_addr;
struct wl12xx_chip chip; struct wl1251_chip chip;
int cmd_box_addr; int cmd_box_addr;
int event_box_addr; int event_box_addr;
@ -385,31 +385,31 @@ struct wl12xx {
/* in dBm */ /* in dBm */
int power_level; int power_level;
struct wl12xx_stats stats; struct wl1251_stats stats;
struct wl12xx_debugfs debugfs; struct wl1251_debugfs debugfs;
u32 buffer_32; u32 buffer_32;
u32 buffer_cmd; u32 buffer_cmd;
u8 buffer_busyword[WL12XX_BUSY_WORD_LEN]; u8 buffer_busyword[WL1251_BUSY_WORD_LEN];
struct wl12xx_rx_descriptor *rx_descriptor; struct wl1251_rx_descriptor *rx_descriptor;
}; };
int wl12xx_plt_start(struct wl12xx *wl); int wl1251_plt_start(struct wl1251 *wl);
int wl12xx_plt_stop(struct wl12xx *wl); int wl1251_plt_stop(struct wl1251 *wl);
#define DEFAULT_HW_GEN_MODULATION_TYPE CCK_LONG /* Long Preamble */ #define DEFAULT_HW_GEN_MODULATION_TYPE CCK_LONG /* Long Preamble */
#define DEFAULT_HW_GEN_TX_RATE RATE_2MBPS #define DEFAULT_HW_GEN_TX_RATE RATE_2MBPS
#define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */ #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 /* 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 * 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. */ * 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_PG10 (0x7010101)
#define CHIP_ID_1251_PG11 (0x7020101) #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 <linux/spi/spi.h>
#include "wl1251.h" #include "wl1251.h"
#include "wl12xx_80211.h"
#include "reg.h" #include "reg.h"
#include "wl1251_spi.h" #include "wl1251_spi.h"
#include "wl1251_ps.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) u8 mgt_rate, u8 mgt_mod)
{ {
struct acx_fw_gen_frame_rates *rates; struct acx_fw_gen_frame_rates *rates;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx frame rates"); wl1251_debug(DEBUG_ACX, "acx frame rates");
rates = kzalloc(sizeof(*rates), GFP_KERNEL); rates = kzalloc(sizeof(*rates), GFP_KERNEL);
if (!rates) { 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_rate = mgt_rate;
rates->tx_mgt_frame_mod = mgt_mod; 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)); rates, sizeof(*rates));
if (ret < 0) { if (ret < 0) {
wl12xx_error("Failed to set FW rates and modulation"); wl1251_error("Failed to set FW rates and modulation");
goto out; 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; struct acx_dot11_station_id *mac;
int ret, i; 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); mac = kzalloc(sizeof(*mac), GFP_KERNEL);
if (!mac) { if (!mac) {
@ -58,7 +57,7 @@ int wl12xx_acx_station_id(struct wl12xx *wl)
for (i = 0; i < ETH_ALEN; i++) for (i = 0; i < ETH_ALEN; i++)
mac->mac[i] = wl->mac_addr[ETH_ALEN - 1 - 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) if (ret < 0)
goto out; goto out;
@ -67,12 +66,12 @@ out:
return ret; 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; struct acx_dot11_default_key *default_key;
int ret; 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); default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
if (!default_key) { if (!default_key) {
@ -82,10 +81,10 @@ int wl12xx_acx_default_key(struct wl12xx *wl, u8 key_id)
default_key->id = 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)); default_key, sizeof(*default_key));
if (ret < 0) { if (ret < 0) {
wl12xx_error("Couldnt set default key"); wl1251_error("Couldnt set default key");
goto out; goto out;
} }
@ -96,13 +95,13 @@ out:
return ret; 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) u8 listen_interval)
{ {
struct acx_wake_up_condition *wake_up; struct acx_wake_up_condition *wake_up;
int ret; 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); wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
if (!wake_up) { 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->wake_up_event = wake_up_event;
wake_up->listen_interval = listen_interval; 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)); wake_up, sizeof(*wake_up));
if (ret < 0) { 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; goto out;
} }
@ -125,12 +124,12 @@ out:
return ret; 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; struct acx_sleep_auth *auth;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx sleep auth"); wl1251_debug(DEBUG_ACX, "acx sleep auth");
auth = kzalloc(sizeof(*auth), GFP_KERNEL); auth = kzalloc(sizeof(*auth), GFP_KERNEL);
if (!auth) { if (!auth) {
@ -140,7 +139,7 @@ int wl12xx_acx_sleep_auth(struct wl12xx *wl, u8 sleep_auth)
auth->sleep_auth = 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) if (ret < 0)
return ret; return ret;
@ -149,12 +148,12 @@ out:
return ret; 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; struct acx_revision *rev;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx fw rev"); wl1251_debug(DEBUG_ACX, "acx fw rev");
rev = kzalloc(sizeof(*rev), GFP_KERNEL); rev = kzalloc(sizeof(*rev), GFP_KERNEL);
if (!rev) { if (!rev) {
@ -162,9 +161,9 @@ int wl12xx_acx_fw_version(struct wl12xx *wl, char *buf, size_t len)
goto out; 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) { if (ret < 0) {
wl12xx_warning("ACX_FW_REV interrogate failed"); wl1251_warning("ACX_FW_REV interrogate failed");
goto out; goto out;
} }
@ -183,12 +182,12 @@ out:
return ret; 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; struct acx_current_tx_power *acx;
int ret; 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) if (power < 0 || power > 25)
return -EINVAL; return -EINVAL;
@ -201,9 +200,9 @@ int wl12xx_acx_tx_power(struct wl12xx *wl, int power)
acx->current_tx_power = power * 10; 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) { if (ret < 0) {
wl12xx_warning("configure of tx power failed: %d", ret); wl1251_warning("configure of tx power failed: %d", ret);
goto out; goto out;
} }
@ -212,12 +211,12 @@ out:
return ret; return ret;
} }
int wl12xx_acx_feature_cfg(struct wl12xx *wl) int wl1251_acx_feature_cfg(struct wl1251 *wl)
{ {
struct acx_feature_config *feature; struct acx_feature_config *feature;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx feature cfg"); wl1251_debug(DEBUG_ACX, "acx feature cfg");
feature = kzalloc(sizeof(*feature), GFP_KERNEL); feature = kzalloc(sizeof(*feature), GFP_KERNEL);
if (!feature) { if (!feature) {
@ -229,10 +228,10 @@ int wl12xx_acx_feature_cfg(struct wl12xx *wl)
feature->data_flow_options = 0; feature->data_flow_options = 0;
feature->options = 0; feature->options = 0;
ret = wl12xx_cmd_configure(wl, ACX_FEATURE_CFG, ret = wl1251_cmd_configure(wl, ACX_FEATURE_CFG,
feature, sizeof(*feature)); feature, sizeof(*feature));
if (ret < 0) { if (ret < 0) {
wl12xx_error("Couldnt set HW encryption"); wl1251_error("Couldnt set HW encryption");
goto out; goto out;
} }
@ -241,27 +240,27 @@ out:
return ret; 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) size_t len)
{ {
int ret; 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) if (ret < 0)
return ret; return ret;
return 0; 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_resp *resp)
{ {
struct acx_data_path_params *params; struct acx_data_path_params *params;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx data path params"); wl1251_debug(DEBUG_ACX, "acx data path params");
params = kzalloc(sizeof(*params), GFP_KERNEL); params = kzalloc(sizeof(*params), GFP_KERNEL);
if (!params) { if (!params) {
@ -281,20 +280,20 @@ int wl12xx_acx_data_path_params(struct wl12xx *wl,
params->tx_complete_timeout = DP_TX_COMPLETE_TIME_OUT; 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)); params, sizeof(*params));
if (ret < 0) if (ret < 0)
goto out; goto out;
/* FIXME: shouldn't this be ACX_DATA_PATH_RESP_PARAMS? */ /* 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)); resp, sizeof(*resp));
if (ret < 0) { 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; goto out;
} else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) { } 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; ret = -EIO;
goto out; goto out;
} }
@ -304,12 +303,12 @@ out:
return ret; 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; struct acx_rx_msdu_lifetime *acx;
int ret; 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); acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) { if (!acx) {
@ -318,10 +317,10 @@ int wl12xx_acx_rx_msdu_life_time(struct wl12xx *wl, u32 life_time)
} }
acx->lifetime = 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)); acx, sizeof(*acx));
if (ret < 0) { 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; goto out;
} }
@ -330,12 +329,12 @@ out:
return ret; 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; struct acx_rx_config *rx_config;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx rx config"); wl1251_debug(DEBUG_ACX, "acx rx config");
rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL); rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
if (!rx_config) { 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->config_options = config;
rx_config->filter_options = filter; 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)); rx_config, sizeof(*rx_config));
if (ret < 0) { if (ret < 0) {
wl12xx_warning("failed to set rx config: %d", ret); wl1251_warning("failed to set rx config: %d", ret);
goto out; goto out;
} }
@ -358,12 +357,12 @@ out:
return ret; return ret;
} }
int wl12xx_acx_pd_threshold(struct wl12xx *wl) int wl1251_acx_pd_threshold(struct wl1251 *wl)
{ {
struct acx_packet_detection *pd; struct acx_packet_detection *pd;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx data pd threshold"); wl1251_debug(DEBUG_ACX, "acx data pd threshold");
pd = kzalloc(sizeof(*pd), GFP_KERNEL); pd = kzalloc(sizeof(*pd), GFP_KERNEL);
if (!pd) { if (!pd) {
@ -373,9 +372,9 @@ int wl12xx_acx_pd_threshold(struct wl12xx *wl)
/* FIXME: threshold value not set */ /* 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) { if (ret < 0) {
wl12xx_warning("failed to set pd threshold: %d", ret); wl1251_warning("failed to set pd threshold: %d", ret);
goto out; goto out;
} }
@ -384,12 +383,12 @@ out:
return 0; 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; struct acx_slot *slot;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx slot"); wl1251_debug(DEBUG_ACX, "acx slot");
slot = kzalloc(sizeof(*slot), GFP_KERNEL); slot = kzalloc(sizeof(*slot), GFP_KERNEL);
if (!slot) { 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->wone_index = STATION_WONE_INDEX;
slot->slot_time = slot_time; 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) { if (ret < 0) {
wl12xx_warning("failed to set slot time: %d", ret); wl1251_warning("failed to set slot time: %d", ret);
goto out; goto out;
} }
@ -411,12 +410,12 @@ out:
return ret; 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; struct acx_dot11_grp_addr_tbl *acx;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx group address tbl"); wl1251_debug(DEBUG_ACX, "acx group address tbl");
acx = kzalloc(sizeof(*acx), GFP_KERNEL); acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) { if (!acx) {
@ -429,10 +428,10 @@ int wl12xx_acx_group_address_tbl(struct wl12xx *wl)
acx->num_groups = 0; acx->num_groups = 0;
memset(acx->mac_table, 0, ADDRESS_GROUP_MAX_LEN); 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)); acx, sizeof(*acx));
if (ret < 0) { 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; goto out;
} }
@ -441,7 +440,7 @@ out:
return ret; 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; struct acx_rx_timeout *rx_timeout;
int ret; int ret;
@ -452,15 +451,15 @@ int wl12xx_acx_service_period_timeout(struct wl12xx *wl)
goto out; 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->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_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)); rx_timeout, sizeof(*rx_timeout));
if (ret < 0) { if (ret < 0) {
wl12xx_warning("failed to set service period timeout: %d", wl1251_warning("failed to set service period timeout: %d",
ret); ret);
goto out; goto out;
} }
@ -470,12 +469,12 @@ out:
return ret; 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; struct acx_rts_threshold *rts;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx rts threshold"); wl1251_debug(DEBUG_ACX, "acx rts threshold");
rts = kzalloc(sizeof(*rts), GFP_KERNEL); rts = kzalloc(sizeof(*rts), GFP_KERNEL);
if (!rts) { if (!rts) {
@ -485,9 +484,9 @@ int wl12xx_acx_rts_threshold(struct wl12xx *wl, u16 rts_threshold)
rts->threshold = 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) { if (ret < 0) {
wl12xx_warning("failed to set rts threshold: %d", ret); wl1251_warning("failed to set rts threshold: %d", ret);
goto out; goto out;
} }
@ -496,12 +495,12 @@ out:
return ret; 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; struct acx_beacon_filter_option *beacon_filter;
int ret; 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); beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
if (!beacon_filter) { if (!beacon_filter) {
@ -512,10 +511,10 @@ int wl12xx_acx_beacon_filter_opt(struct wl12xx *wl)
beacon_filter->enable = 0; beacon_filter->enable = 0;
beacon_filter->max_num_beacons = 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)); beacon_filter, sizeof(*beacon_filter));
if (ret < 0) { 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; goto out;
} }
@ -524,12 +523,12 @@ out:
return ret; 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; struct acx_beacon_filter_ie_table *ie_table;
int ret; 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); ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
if (!ie_table) { if (!ie_table) {
@ -540,10 +539,10 @@ int wl12xx_acx_beacon_filter_table(struct wl12xx *wl)
ie_table->num_ie = 0; ie_table->num_ie = 0;
memset(ie_table->table, 0, BEACON_FILTER_TABLE_MAX_SIZE); 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)); ie_table, sizeof(*ie_table));
if (ret < 0) { 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; goto out;
} }
@ -552,12 +551,12 @@ out:
return ret; return ret;
} }
int wl12xx_acx_sg_enable(struct wl12xx *wl) int wl1251_acx_sg_enable(struct wl1251 *wl)
{ {
struct acx_bt_wlan_coex *pta; struct acx_bt_wlan_coex *pta;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx sg enable"); wl1251_debug(DEBUG_ACX, "acx sg enable");
pta = kzalloc(sizeof(*pta), GFP_KERNEL); pta = kzalloc(sizeof(*pta), GFP_KERNEL);
if (!pta) { if (!pta) {
@ -567,9 +566,9 @@ int wl12xx_acx_sg_enable(struct wl12xx *wl)
pta->enable = SG_ENABLE; 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) { if (ret < 0) {
wl12xx_warning("failed to set softgemini enable: %d", ret); wl1251_warning("failed to set softgemini enable: %d", ret);
goto out; goto out;
} }
@ -578,12 +577,12 @@ out:
return ret; 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; struct acx_bt_wlan_coex_param *param;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx sg cfg"); wl1251_debug(DEBUG_ACX, "acx sg cfg");
param = kzalloc(sizeof(*param), GFP_KERNEL); param = kzalloc(sizeof(*param), GFP_KERNEL);
if (!param) { 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->pta_auto_mode_enable = PTA_AUTO_MODE_NO_CTS_DEF;
param->bt_hp_respected_num = PTA_BT_HP_RESPECTED_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) { if (ret < 0) {
wl12xx_warning("failed to set sg config: %d", ret); wl1251_warning("failed to set sg config: %d", ret);
goto out; goto out;
} }
@ -632,12 +631,12 @@ out:
return ret; return ret;
} }
int wl12xx_acx_cca_threshold(struct wl12xx *wl) int wl1251_acx_cca_threshold(struct wl1251 *wl)
{ {
struct acx_energy_detection *detection; struct acx_energy_detection *detection;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx cca threshold"); wl1251_debug(DEBUG_ACX, "acx cca threshold");
detection = kzalloc(sizeof(*detection), GFP_KERNEL); detection = kzalloc(sizeof(*detection), GFP_KERNEL);
if (!detection) { if (!detection) {
@ -648,10 +647,10 @@ int wl12xx_acx_cca_threshold(struct wl12xx *wl)
detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D; detection->rx_cca_threshold = CCA_THRSH_DISABLE_ENERGY_D;
detection->tx_energy_detection = 0; detection->tx_energy_detection = 0;
ret = wl12xx_cmd_configure(wl, ACX_CCA_THRESHOLD, ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
detection, sizeof(*detection)); detection, sizeof(*detection));
if (ret < 0) { if (ret < 0) {
wl12xx_warning("failed to set cca threshold: %d", ret); wl1251_warning("failed to set cca threshold: %d", ret);
return ret; return ret;
} }
@ -660,12 +659,12 @@ out:
return ret; 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; struct acx_beacon_broadcast *bb;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx bcn dtim options"); wl1251_debug(DEBUG_ACX, "acx bcn dtim options");
bb = kzalloc(sizeof(*bb), GFP_KERNEL); bb = kzalloc(sizeof(*bb), GFP_KERNEL);
if (!bb) { 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->rx_broadcast_in_ps = RX_BROADCAST_IN_PS_DEF_VALUE;
bb->ps_poll_threshold = CONSECUTIVE_PS_POLL_FAILURE_DEF; 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) { if (ret < 0) {
wl12xx_warning("failed to set rx config: %d", ret); wl1251_warning("failed to set rx config: %d", ret);
goto out; goto out;
} }
@ -689,12 +688,12 @@ out:
return ret; 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; struct acx_aid *acx_aid;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx aid"); wl1251_debug(DEBUG_ACX, "acx aid");
acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL); acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
if (!acx_aid) { if (!acx_aid) {
@ -704,9 +703,9 @@ int wl12xx_acx_aid(struct wl12xx *wl, u16 aid)
acx_aid->aid = 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) { if (ret < 0) {
wl12xx_warning("failed to set aid: %d", ret); wl1251_warning("failed to set aid: %d", ret);
goto out; goto out;
} }
@ -715,12 +714,12 @@ out:
return ret; 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; struct acx_event_mask *mask;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx event mbox mask"); wl1251_debug(DEBUG_ACX, "acx event mbox mask");
mask = kzalloc(sizeof(*mask), GFP_KERNEL); mask = kzalloc(sizeof(*mask), GFP_KERNEL);
if (!mask) { if (!mask) {
@ -733,10 +732,10 @@ int wl12xx_acx_event_mbox_mask(struct wl12xx *wl, u32 event_mask)
mask->event_mask = 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)); mask, sizeof(*mask));
if (ret < 0) { 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; goto out;
} }
@ -745,12 +744,12 @@ out:
return ret; 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; struct acx_preamble *acx;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx_set_preamble"); wl1251_debug(DEBUG_ACX, "acx_set_preamble");
acx = kzalloc(sizeof(*acx), GFP_KERNEL); acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) { if (!acx) {
@ -760,9 +759,9 @@ int wl12xx_acx_set_preamble(struct wl12xx *wl, enum acx_preamble_type preamble)
acx->preamble = 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) { if (ret < 0) {
wl12xx_warning("Setting of preamble failed: %d", ret); wl1251_warning("Setting of preamble failed: %d", ret);
goto out; goto out;
} }
@ -771,13 +770,13 @@ out:
return ret; return ret;
} }
int wl12xx_acx_cts_protect(struct wl12xx *wl, int wl1251_acx_cts_protect(struct wl1251 *wl,
enum acx_ctsprotect_type ctsprotect) enum acx_ctsprotect_type ctsprotect)
{ {
struct acx_ctsprotect *acx; struct acx_ctsprotect *acx;
int ret; int ret;
wl12xx_debug(DEBUG_ACX, "acx_set_ctsprotect"); wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect");
acx = kzalloc(sizeof(*acx), GFP_KERNEL); acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) { if (!acx) {
@ -787,9 +786,9 @@ int wl12xx_acx_cts_protect(struct wl12xx *wl,
acx->ctsprotect = ctsprotect; 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) { if (ret < 0) {
wl12xx_warning("Setting of ctsprotect failed: %d", ret); wl1251_warning("Setting of ctsprotect failed: %d", ret);
goto out; goto out;
} }
@ -798,7 +797,7 @@ out:
return ret; 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; struct acx_tsf_info *tsf_info;
int ret; int ret;
@ -809,10 +808,10 @@ int wl12xx_acx_tsf_info(struct wl12xx *wl, u64 *mactime)
goto out; goto out;
} }
ret = wl12xx_cmd_interrogate(wl, ACX_TSF_INFO, ret = wl1251_cmd_interrogate(wl, ACX_TSF_INFO,
tsf_info, sizeof(*tsf_info)); tsf_info, sizeof(*tsf_info));
if (ret < 0) { if (ret < 0) {
wl12xx_warning("ACX_FW_REV interrogate failed"); wl1251_warning("ACX_FW_REV interrogate failed");
goto out; goto out;
} }
@ -824,16 +823,16 @@ out:
return ret; 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; 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)); sizeof(*stats));
if (ret < 0) { if (ret < 0) {
wl12xx_warning("acx statistics failed: %d", ret); wl1251_warning("acx statistics failed: %d", ret);
return -ENOMEM; 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -22,15 +22,15 @@
* *
*/ */
#ifndef __WL12XX_ACX_H__ #ifndef __WL1251_ACX_H__
#define __WL12XX_ACX_H__ #define __WL1251_ACX_H__
#include "wl1251.h" #include "wl1251.h"
#include "wl1251_cmd.h" #include "wl1251_cmd.h"
/* Target's information element */ /* Target's information element */
struct acx_header { struct acx_header {
struct wl12xx_cmd_header cmd; struct wl1251_cmd_header cmd;
/* acx (or information element) header */ /* acx (or information element) header */
u16 id; u16 id;
@ -91,15 +91,15 @@ struct acx_revision {
u32 hw_version; u32 hw_version;
} __attribute__ ((packed)); } __attribute__ ((packed));
enum wl12xx_psm_mode { enum wl1251_psm_mode {
/* Active mode */ /* Active mode */
WL12XX_PSM_CAM = 0, WL1251_PSM_CAM = 0,
/* Power save mode */ /* Power save mode */
WL12XX_PSM_PS = 1, WL1251_PSM_PS = 1,
/* Extreme low power */ /* Extreme low power */
WL12XX_PSM_ELP = 2, WL1251_PSM_ELP = 2,
}; };
struct acx_sleep_auth { 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); u8 mgt_rate, u8 mgt_mod);
int wl12xx_acx_station_id(struct wl12xx *wl); int wl1251_acx_station_id(struct wl1251 *wl);
int wl12xx_acx_default_key(struct wl12xx *wl, u8 key_id); int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id);
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); u8 listen_interval);
int wl12xx_acx_sleep_auth(struct wl12xx *wl, u8 sleep_auth); int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth);
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);
int wl12xx_acx_tx_power(struct wl12xx *wl, int power); int wl1251_acx_tx_power(struct wl1251 *wl, int power);
int wl12xx_acx_feature_cfg(struct wl12xx *wl); int wl1251_acx_feature_cfg(struct wl1251 *wl);
int wl12xx_acx_mem_map(struct wl12xx *wl, int wl1251_acx_mem_map(struct wl1251 *wl,
struct acx_header *mem_map, size_t len); 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); struct acx_data_path_params_resp *data_path);
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);
int wl12xx_acx_rx_config(struct wl12xx *wl, u32 config, u32 filter); int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter);
int wl12xx_acx_pd_threshold(struct wl12xx *wl); int wl1251_acx_pd_threshold(struct wl1251 *wl);
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);
int wl12xx_acx_group_address_tbl(struct wl12xx *wl); int wl1251_acx_group_address_tbl(struct wl1251 *wl);
int wl12xx_acx_service_period_timeout(struct wl12xx *wl); int wl1251_acx_service_period_timeout(struct wl1251 *wl);
int wl12xx_acx_rts_threshold(struct wl12xx *wl, u16 rts_threshold); int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold);
int wl12xx_acx_beacon_filter_opt(struct wl12xx *wl); int wl1251_acx_beacon_filter_opt(struct wl1251 *wl);
int wl12xx_acx_beacon_filter_table(struct wl12xx *wl); int wl1251_acx_beacon_filter_table(struct wl1251 *wl);
int wl12xx_acx_sg_enable(struct wl12xx *wl); int wl1251_acx_sg_enable(struct wl1251 *wl);
int wl12xx_acx_sg_cfg(struct wl12xx *wl); int wl1251_acx_sg_cfg(struct wl1251 *wl);
int wl12xx_acx_cca_threshold(struct wl12xx *wl); int wl1251_acx_cca_threshold(struct wl1251 *wl);
int wl12xx_acx_bcn_dtim_options(struct wl12xx *wl); int wl1251_acx_bcn_dtim_options(struct wl1251 *wl);
int wl12xx_acx_aid(struct wl12xx *wl, u16 aid); int wl1251_acx_aid(struct wl1251 *wl, u16 aid);
int wl12xx_acx_event_mbox_mask(struct wl12xx *wl, u32 event_mask); int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask);
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);
int wl12xx_acx_cts_protect(struct wl12xx *wl, int wl1251_acx_cts_protect(struct wl1251 *wl,
enum acx_ctsprotect_type ctsprotect); enum acx_ctsprotect_type ctsprotect);
int wl12xx_acx_statistics(struct wl12xx *wl, struct acx_statistics *stats); int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats);
int wl12xx_acx_tsf_info(struct wl12xx *wl, u64 *mactime); 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 * Copyright (C) 2008 Nokia Corporation
* *
@ -28,37 +28,37 @@
#include "wl1251_spi.h" #include "wl1251_spi.h"
#include "wl1251_event.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); 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)); wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask));
wl12xx_reg_write32(wl, HI_CFG, HI_CFG_DEF_VAL); 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; unsigned long timeout;
u32 boot_data; u32 boot_data;
/* perform soft reset */ /* 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 */ /* SOFT_RESET is self clearing */
timeout = jiffies + usecs_to_jiffies(SOFT_RESET_MAX_TIME); timeout = jiffies + usecs_to_jiffies(SOFT_RESET_MAX_TIME);
while (1) { while (1) {
boot_data = wl12xx_reg_read32(wl, ACX_REG_SLV_SOFT_RESET); boot_data = wl1251_reg_read32(wl, ACX_REG_SLV_SOFT_RESET);
wl12xx_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data); wl1251_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data);
if ((boot_data & ACX_SLV_SOFT_RESET_BIT) == 0) if ((boot_data & ACX_SLV_SOFT_RESET_BIT) == 0)
break; break;
if (time_after(jiffies, timeout)) { if (time_after(jiffies, timeout)) {
/* 1.2 check pWhalBus->uSelfClearTime if the /* 1.2 check pWhalBus->uSelfClearTime if the
* timeout was reached */ * timeout was reached */
wl12xx_error("soft reset timeout"); wl1251_error("soft reset timeout");
return -1; return -1;
} }
@ -66,15 +66,15 @@ int wl12xx_boot_soft_reset(struct wl12xx *wl)
} }
/* disable Rx/Tx */ /* disable Rx/Tx */
wl12xx_reg_write32(wl, ENABLE, 0x0); wl1251_reg_write32(wl, ENABLE, 0x0);
/* disable auto calibration on start*/ /* disable auto calibration on start*/
wl12xx_reg_write32(wl, SPARE_A2, 0xffff); wl1251_reg_write32(wl, SPARE_A2, 0xffff);
return 0; 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; 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 */ /* read NVS params */
scr_pad6 = wl12xx_reg_read32(wl, SCR_PAD6); scr_pad6 = wl1251_reg_read32(wl, SCR_PAD6);
wl12xx_debug(DEBUG_BOOT, "scr_pad6 0x%x", scr_pad6); wl1251_debug(DEBUG_BOOT, "scr_pad6 0x%x", scr_pad6);
/* read ELP_CMD */ /* read ELP_CMD */
elp_cmd = wl12xx_reg_read32(wl, ELP_CMD); elp_cmd = wl1251_reg_read32(wl, ELP_CMD);
wl12xx_debug(DEBUG_BOOT, "elp_cmd 0x%x", elp_cmd); wl1251_debug(DEBUG_BOOT, "elp_cmd 0x%x", elp_cmd);
/* set the BB calibration time to be 300 usec (PLL_CAL_TIME) */ /* set the BB calibration time to be 300 usec (PLL_CAL_TIME) */
ref_freq = scr_pad6 & 0x000000FF; 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) * 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 * 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]) * (ELP_CFG_MODE[13:12])
*/ */
tmp = ((scr_pad6 & 0x0000FF00) << 4) | 0x00004000; 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 */ /* PG 1.2: enable the BB PLL fix. Enable the PLL_LIMP_CLK_EN_CMD */
elp_cmd |= 0x00000040; 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 /* PG 1.2: Set the BB PLL stable time to be 1000usec
* (PLL_STABLE_TIME) */ * (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 */ /* 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 - * 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; tmp = init_data - 0x21;
else else
tmp = 0; 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 */ /* set BB PLL configurations in RF AFE */
wl12xx_reg_write32(wl, 0x003058cc, 0x4B5); wl1251_reg_write32(wl, 0x003058cc, 0x4B5);
/* set RF_AFE_REG_5 */ /* set RF_AFE_REG_5 */
wl12xx_reg_write32(wl, 0x003058d4, 0x50); wl1251_reg_write32(wl, 0x003058d4, 0x50);
/* set RF_AFE_CTRL_REG_2 */ /* 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 * change RF PLL and BB PLL divider for VCO clock and adjust VCO
* bais current(RF_AFE_REG_13) * bais current(RF_AFE_REG_13)
*/ */
wl12xx_reg_write32(wl, 0x003058f4, 0x1e); wl1251_reg_write32(wl, 0x003058f4, 0x1e);
/* set BB PLL configurations */ /* set BB PLL configurations */
tmp = LUT[ref_freq][LUT_PARAM_INTEGER_DIVIDER] | 0x00017000; 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 /* set fractional divider according to Appendix C-BB PLL
* Calculations * Calculations
*/ */
tmp = LUT[ref_freq][LUT_PARAM_FRACTIONAL_DIVIDER]; 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 */ /* 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 * 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) | tmp = (LUT[ref_freq][LUT_PARAM_ATTN_BB] << 16) |
(LUT[ref_freq][LUT_PARAM_ALPHA_BB] << 12) | 0x1; (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 * set the calibration stop time after holdoff time expires and set
* settling time HOLD_OFF_TIME_BB * settling time HOLD_OFF_TIME_BB
*/ */
tmp = LUT[ref_freq][LUT_PARAM_STOP_TIME_BB] | 0x000A0000; 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 * 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] * BB_ILOOPF[7:3]
*/ */
tmp = LUT[ref_freq][LUT_PARAM_BB_PLL_LOOP_FILTER] | 0x00000030; 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 * 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 * set BB PLL Loop filter capacitor2- BB_C2[7:5], set gain of BB
* PLL auto-call to normal mode- BB_CALGAIN_3DB[8] * 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]) */ /* 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 */ /* restart sequence completed */
udelay(2000); udelay(2000);
@ -212,19 +212,19 @@ int wl12xx_boot_init_seq(struct wl12xx *wl)
return 0; return 0;
} }
int wl12xx_boot_run_firmware(struct wl12xx *wl) int wl1251_boot_run_firmware(struct wl1251 *wl)
{ {
int loop, ret; int loop, ret;
u32 chip_id, interrupt; u32 chip_id, interrupt;
wl->chip.op_set_ecpu_ctrl(wl, ECPU_CONTROL_HALT); 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) { 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; return -EIO;
} }
@ -232,41 +232,41 @@ int wl12xx_boot_run_firmware(struct wl12xx *wl)
loop = 0; loop = 0;
while (loop++ < INIT_LOOP) { while (loop++ < INIT_LOOP) {
udelay(INIT_LOOP_DELAY); 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) { if (interrupt == 0xffffffff) {
wl12xx_error("error reading hardware complete " wl1251_error("error reading hardware complete "
"init indication"); "init indication");
return -EIO; return -EIO;
} }
/* check that ACX_INTR_INIT_COMPLETE is enabled */ /* check that ACX_INTR_INIT_COMPLETE is enabled */
else if (interrupt & wl->chip.intr_init_complete) { 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); wl->chip.intr_init_complete);
break; break;
} }
} }
if (loop >= INIT_LOOP) { if (loop >= INIT_LOOP) {
wl12xx_error("timeout waiting for the hardware to " wl1251_error("timeout waiting for the hardware to "
"complete initialization"); "complete initialization");
return -EIO; return -EIO;
} }
/* get hardware config command mail box */ /* 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 */ /* 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 */ /* 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.start,
wl->chip.p_table[PART_WORK].mem.size, wl->chip.p_table[PART_WORK].mem.size,
wl->chip.p_table[PART_WORK].reg.start, wl->chip.p_table[PART_WORK].reg.start,
wl->chip.p_table[PART_WORK].reg.size); 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->cmd_box_addr, wl->event_box_addr);
wl->chip.op_fw_version(wl); wl->chip.op_fw_version(wl);
@ -277,20 +277,20 @@ int wl12xx_boot_run_firmware(struct wl12xx *wl)
*/ */
/* enable gpio interrupts */ /* enable gpio interrupts */
wl12xx_boot_enable_interrupts(wl); wl1251_boot_enable_interrupts(wl);
wl->chip.op_target_enable_interrupts(wl); wl->chip.op_target_enable_interrupts(wl);
/* unmask all mbox events */ /* unmask all mbox events */
wl->event_mask = 0xffffffff; wl->event_mask = 0xffffffff;
ret = wl12xx_event_unmask(wl); ret = wl1251_event_unmask(wl);
if (ret < 0) { if (ret < 0) {
wl12xx_error("EVENT mask setting failed"); wl1251_error("EVENT mask setting failed");
return ret; return ret;
} }
wl12xx_event_mbox_config(wl); wl1251_event_mbox_config(wl);
/* firmware startup completed */ /* firmware startup completed */
return 0; 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 * Copyright (C) 2008 Nokia Corporation
* *
@ -26,10 +26,10 @@
#include "wl1251.h" #include "wl1251.h"
int wl12xx_boot_soft_reset(struct wl12xx *wl); int wl1251_boot_soft_reset(struct wl1251 *wl);
int wl12xx_boot_init_seq(struct wl12xx *wl); int wl1251_boot_init_seq(struct wl1251 *wl);
int wl12xx_boot_run_firmware(struct wl12xx *wl); int wl1251_boot_run_firmware(struct wl1251 *wl);
void wl12xx_boot_target_enable_interrupts(struct wl12xx *wl); void wl1251_boot_target_enable_interrupts(struct wl1251 *wl);
/* number of times we try to read the INIT interrupt */ /* number of times we try to read the INIT interrupt */
#define INIT_LOOP 20000 #define INIT_LOOP 20000

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

@ -5,7 +5,6 @@
#include <linux/spi/spi.h> #include <linux/spi/spi.h>
#include "wl1251.h" #include "wl1251.h"
#include "wl12xx_80211.h"
#include "reg.h" #include "reg.h"
#include "wl1251_spi.h" #include "wl1251_spi.h"
#include "wl1251_ps.h" #include "wl1251_ps.h"
@ -19,9 +18,9 @@
* @buf: buffer containing the command, must work with dma * @buf: buffer containing the command, must work with dma
* @len: length of the buffer * @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; unsigned long timeout;
u32 intr; u32 intr;
int ret = 0; 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); 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)) { while (!(intr & wl->chip.intr_cmd_complete)) {
if (time_after(jiffies, timeout)) { if (time_after(jiffies, timeout)) {
wl12xx_error("command complete timeout"); wl1251_error("command complete timeout");
ret = -ETIMEDOUT; ret = -ETIMEDOUT;
goto out; goto out;
} }
msleep(1); 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); wl->chip.intr_cmd_complete);
out: out:
@ -66,33 +65,33 @@ out:
* @len: length of the buffer * @len: length of the buffer
* @answer: is answer needed * @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; 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) { if (ret < 0) {
wl12xx_warning("TEST command failed"); wl1251_warning("TEST command failed");
return ret; return ret;
} }
if (answer) { if (answer) {
struct wl12xx_command *cmd_answer; struct wl1251_command *cmd_answer;
/* /*
* The test command got in, we can read the 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. * 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; cmd_answer = buf;
if (cmd_answer->header.status != CMD_STATUS_SUCCESS) 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); 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 * @buf: buffer for the response, including all headers, must work with dma
* @len: lenght of buf * @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; struct acx_header *acx = buf;
int ret; int ret;
wl12xx_debug(DEBUG_CMD, "cmd interrogate"); wl1251_debug(DEBUG_CMD, "cmd interrogate");
acx->id = id; acx->id = id;
/* payload length, does not include any headers */ /* payload length, does not include any headers */
acx->len = len - sizeof(*acx); 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) { if (ret < 0) {
wl12xx_error("INTERROGATE command failed"); wl1251_error("INTERROGATE command failed");
goto out; goto out;
} }
/* the interrogate command got in, we can read the answer */ /* 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; acx = buf;
if (acx->cmd.status != CMD_STATUS_SUCCESS) if (acx->cmd.status != CMD_STATUS_SUCCESS)
wl12xx_error("INTERROGATE command error: %d", wl1251_error("INTERROGATE command error: %d",
acx->cmd.status); acx->cmd.status);
out: out:
@ -145,34 +144,34 @@ out:
* @buf: buffer containing acx, including all headers, must work with dma * @buf: buffer containing acx, including all headers, must work with dma
* @len: length of buf * @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; struct acx_header *acx = buf;
int ret; int ret;
wl12xx_debug(DEBUG_CMD, "cmd configure"); wl1251_debug(DEBUG_CMD, "cmd configure");
acx->id = id; acx->id = id;
/* payload length, does not include any headers */ /* payload length, does not include any headers */
acx->len = len - sizeof(*acx); 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) { if (ret < 0) {
wl12xx_warning("CONFIGURE command NOK"); wl1251_warning("CONFIGURE command NOK");
return ret; return ret;
} }
return 0; 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) void *bitmap, u16 bitmap_len, u8 bitmap_control)
{ {
struct wl12xx_cmd_vbm_update *vbm; struct wl1251_cmd_vbm_update *vbm;
int ret; int ret;
wl12xx_debug(DEBUG_CMD, "cmd vbm"); wl1251_debug(DEBUG_CMD, "cmd vbm");
vbm = kzalloc(sizeof(*vbm), GFP_KERNEL); vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
if (!vbm) { if (!vbm) {
@ -183,7 +182,7 @@ int wl12xx_cmd_vbm(struct wl12xx *wl, u8 identity,
/* Count and period will be filled by the target */ /* Count and period will be filled by the target */
vbm->tim.bitmap_ctrl = bitmap_control; vbm->tim.bitmap_ctrl = bitmap_control;
if (bitmap_len > PARTIAL_VBM_MAX) { 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);
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); 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) { if (ret < 0) {
wl12xx_error("VBM command failed"); wl1251_error("VBM command failed");
goto out; goto out;
} }
@ -204,13 +203,13 @@ out:
return 0; 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; struct cmd_enabledisable_path *cmd;
int ret; int ret;
u16 cmd_rx, cmd_tx; 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); cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) { if (!cmd) {
@ -228,24 +227,24 @@ int wl12xx_cmd_data_path(struct wl12xx *wl, u8 channel, bool enable)
cmd_tx = CMD_DISABLE_TX; 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) { 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); enable ? "start" : "stop", channel);
goto out; goto out;
} }
wl12xx_debug(DEBUG_BOOT, "rx %s cmd channel %d", wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
enable ? "start" : "stop", channel); 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) { 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); enable ? "start" : "stop", channel);
return ret; return ret;
} }
wl12xx_debug(DEBUG_BOOT, "tx %s cmd channel %d", wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
enable ? "start" : "stop", channel); enable ? "start" : "stop", channel);
out: out:
@ -253,7 +252,7 @@ out:
return ret; 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) u16 beacon_interval, u8 wait)
{ {
unsigned long timeout; 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 */ /* 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, DEFAULT_HW_GEN_MODULATION_TYPE,
wl->tx_mgmt_frm_rate, wl->tx_mgmt_frm_rate,
wl->tx_mgmt_frm_mod); wl->tx_mgmt_frm_mod);
if (ret < 0) if (ret < 0)
goto out; goto out;
wl12xx_debug(DEBUG_CMD, "cmd join"); wl1251_debug(DEBUG_CMD, "cmd join");
/* Reverse order BSSID */ /* Reverse order BSSID */
bssid = (u8 *) &join->bssid_lsb; 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->channel = wl->channel;
join->ctrl = JOIN_CMD_CTRL_TX_FLUSH; 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) { if (ret < 0) {
wl12xx_error("failed to initiate cmd join"); wl1251_error("failed to initiate cmd join");
goto out; goto out;
} }
@ -314,20 +313,20 @@ out:
return ret; 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; int ret = 0;
/* FIXME: this should be in ps.c */ /* 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); wl->listen_int);
if (ret < 0) { if (ret < 0) {
wl12xx_error("couldn't set wake up conditions"); wl1251_error("couldn't set wake up conditions");
goto out; 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); ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
if (!ps_params) { 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->hang_over_period = 128;
ps_params->null_data_rate = 1; /* 1 Mbps */ 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)); sizeof(*ps_params));
if (ret < 0) { if (ret < 0) {
wl12xx_error("cmd set_ps_mode failed"); wl1251_error("cmd set_ps_mode failed");
goto out; goto out;
} }
@ -353,13 +352,13 @@ out:
return ret; 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) size_t len)
{ {
struct cmd_read_write_memory *cmd; struct cmd_read_write_memory *cmd;
int ret = 0; int ret = 0;
wl12xx_debug(DEBUG_CMD, "cmd read memory"); wl1251_debug(DEBUG_CMD, "cmd read memory");
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) { if (!cmd) {
@ -373,17 +372,17 @@ int wl12xx_cmd_read_memory(struct wl12xx *wl, u32 addr, void *answer,
cmd->addr = addr; cmd->addr = addr;
cmd->size = len; 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) { if (ret < 0) {
wl12xx_error("read memory command failed: %d", ret); wl1251_error("read memory command failed: %d", ret);
goto out; goto out;
} }
/* the read command got in, we can now read the answer */ /* 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) 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); cmd->header.status);
memcpy(answer, cmd->value, len); memcpy(answer, cmd->value, len);
@ -393,17 +392,17 @@ out:
return ret; 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) void *buf, size_t buf_len)
{ {
struct wl12xx_cmd_packet_template *cmd; struct wl1251_cmd_packet_template *cmd;
size_t cmd_len; size_t cmd_len;
int ret = 0; 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); WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
buf_len = min_t(size_t, buf_len, WL12XX_MAX_TEMPLATE_SIZE); buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4); cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4);
cmd = kzalloc(cmd_len, GFP_KERNEL); cmd = kzalloc(cmd_len, GFP_KERNEL);
@ -417,9 +416,9 @@ int wl12xx_cmd_template_set(struct wl12xx *wl, u16 cmd_id,
if (buf) if (buf)
memcpy(cmd->data, buf, buf_len); 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) { if (ret < 0) {
wl12xx_warning("cmd set_template failed: %d", ret); wl1251_warning("cmd set_template failed: %d", ret);
goto out; 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -22,32 +22,32 @@
* *
*/ */
#ifndef __WL12XX_CMD_H__ #ifndef __WL1251_CMD_H__
#define __WL12XX_CMD_H__ #define __WL1251_CMD_H__
#include "wl1251.h" #include "wl1251.h"
struct acx_header; struct acx_header;
int wl12xx_cmd_send(struct wl12xx *wl, u16 type, void *buf, size_t buf_len); int wl1251_cmd_send(struct wl1251 *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 wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer);
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);
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);
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); void *bitmap, u16 bitmap_len, u8 bitmap_control);
int wl12xx_cmd_data_path(struct wl12xx *wl, u8 channel, bool enable); int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable);
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); u16 beacon_interval, u8 wait);
int wl12xx_cmd_ps_mode(struct wl12xx *wl, u8 ps_mode); int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode);
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); 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); void *buf, size_t buf_len);
/* unit ms */ /* unit ms */
#define WL12XX_COMMAND_TIMEOUT 2000 #define WL1251_COMMAND_TIMEOUT 2000
enum wl12xx_commands { enum wl1251_commands {
CMD_RESET = 0, CMD_RESET = 0,
CMD_INTERROGATE = 1, /*use this to read information elements*/ CMD_INTERROGATE = 1, /*use this to read information elements*/
CMD_CONFIGURE = 2, /*use this to write information elements*/ CMD_CONFIGURE = 2, /*use this to write information elements*/
@ -95,15 +95,15 @@ enum wl12xx_commands {
#define MAX_CMD_PARAMS 572 #define MAX_CMD_PARAMS 572
struct wl12xx_cmd_header { struct wl1251_cmd_header {
u16 id; u16 id;
u16 status; u16 status;
/* payload */ /* payload */
u8 data[0]; u8 data[0];
} __attribute__ ((packed)); } __attribute__ ((packed));
struct wl12xx_command { struct wl1251_command {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
u8 parameters[MAX_CMD_PARAMS]; u8 parameters[MAX_CMD_PARAMS];
}; };
@ -145,7 +145,7 @@ enum {
#define MAX_READ_SIZE 256 #define MAX_READ_SIZE 256
struct cmd_read_write_memory { 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.*/ /* The address of the memory to read from or write to.*/
u32 addr; u32 addr;
@ -214,7 +214,7 @@ struct basic_scan_channel_parameters {
#define SCAN_MAX_NUM_OF_CHANNELS 16 #define SCAN_MAX_NUM_OF_CHANNELS 16
struct cmd_scan { struct cmd_scan {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
struct basic_scan_parameters params; struct basic_scan_parameters params;
struct basic_scan_channel_parameters channels[SCAN_MAX_NUM_OF_CHANNELS]; struct basic_scan_channel_parameters channels[SCAN_MAX_NUM_OF_CHANNELS];
@ -232,7 +232,7 @@ enum {
struct cmd_join { struct cmd_join {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
u32 bssid_lsb; u32 bssid_lsb;
u16 bssid_msb; u16 bssid_msb;
@ -269,16 +269,16 @@ struct cmd_join {
} __attribute__ ((packed)); } __attribute__ ((packed));
struct cmd_enabledisable_path { struct cmd_enabledisable_path {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
u8 channel; u8 channel;
u8 padding[3]; u8 padding[3];
} __attribute__ ((packed)); } __attribute__ ((packed));
#define WL12XX_MAX_TEMPLATE_SIZE 300 #define WL1251_MAX_TEMPLATE_SIZE 300
struct wl12xx_cmd_packet_template { struct wl1251_cmd_packet_template {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
__le16 size; __le16 size;
u8 data[0]; u8 data[0];
@ -287,7 +287,7 @@ struct wl12xx_cmd_packet_template {
#define TIM_ELE_ID 5 #define TIM_ELE_ID 5
#define PARTIAL_VBM_MAX 251 #define PARTIAL_VBM_MAX 251
struct wl12xx_tim { struct wl1251_tim {
u8 identity; u8 identity;
u8 length; u8 length;
u8 dtim_count; u8 dtim_count;
@ -297,20 +297,20 @@ struct wl12xx_tim {
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Virtual Bit Map update */ /* Virtual Bit Map update */
struct wl12xx_cmd_vbm_update { struct wl1251_cmd_vbm_update {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
__le16 len; __le16 len;
u8 padding[2]; u8 padding[2];
struct wl12xx_tim tim; struct wl1251_tim tim;
} __attribute__ ((packed)); } __attribute__ ((packed));
enum wl12xx_cmd_ps_mode { enum wl1251_cmd_ps_mode {
STATION_ACTIVE_MODE, STATION_ACTIVE_MODE,
STATION_POWER_SAVE_MODE STATION_POWER_SAVE_MODE
}; };
struct wl12xx_cmd_ps_params { struct wl1251_cmd_ps_params {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
u8 ps_mode; /* STATION_* */ u8 ps_mode; /* STATION_* */
u8 send_null_data; /* Do we have to send NULL data packet ? */ u8 send_null_data; /* Do we have to send NULL data packet ? */
@ -325,8 +325,8 @@ struct wl12xx_cmd_ps_params {
u8 pad[2]; u8 pad[2];
} __attribute__ ((packed)); } __attribute__ ((packed));
struct wl12xx_cmd_trigger_scan_to { struct wl1251_cmd_trigger_scan_to {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
u32 timeout; u32 timeout;
}; };
@ -340,14 +340,14 @@ struct wl12xx_cmd_trigger_scan_to {
/* When set, disable HW decryption */ /* When set, disable HW decryption */
#define DF_SNIFF_MODE_ENABLE 0x80 #define DF_SNIFF_MODE_ENABLE 0x80
enum wl12xx_cmd_key_action { enum wl1251_cmd_key_action {
KEY_ADD_OR_REPLACE = 1, KEY_ADD_OR_REPLACE = 1,
KEY_REMOVE = 2, KEY_REMOVE = 2,
KEY_SET_ID = 3, KEY_SET_ID = 3,
MAX_KEY_ACTION = 0xffff, MAX_KEY_ACTION = 0xffff,
}; };
enum wl12xx_cmd_key_type { enum wl1251_cmd_key_type {
KEY_WEP_DEFAULT = 0, KEY_WEP_DEFAULT = 0,
KEY_WEP_ADDR = 1, KEY_WEP_ADDR = 1,
KEY_AES_GROUP = 4, KEY_AES_GROUP = 4,
@ -374,8 +374,8 @@ enum wl12xx_cmd_key_type {
* *
*/ */
struct wl12xx_cmd_set_keys { struct wl1251_cmd_set_keys {
struct wl12xx_cmd_header header; struct wl1251_cmd_header header;
/* Ignored for default WEP key */ /* Ignored for default WEP key */
u8 addr[ETH_ALEN]; u8 addr[ETH_ALEN];
@ -404,4 +404,4 @@ struct wl12xx_cmd_set_keys {
} __attribute__ ((packed)); } __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 * Copyright (C) 2009 Nokia Corporation
* *
@ -30,7 +30,7 @@
#include "wl1251_ps.h" #include "wl1251_ps.h"
/* ms */ /* ms */
#define WL12XX_DEBUGFS_STATS_LIFETIME 1000 #define WL1251_DEBUGFS_STATS_LIFETIME 1000
/* debugfs macros idea from mac80211 */ /* debugfs macros idea from mac80211 */
@ -38,7 +38,7 @@
static ssize_t name## _read(struct file *file, char __user *userbuf, \ static ssize_t name## _read(struct file *file, char __user *userbuf, \
size_t count, loff_t *ppos) \ size_t count, loff_t *ppos) \
{ \ { \
struct wl12xx *wl = file->private_data; \ struct wl1251 *wl = file->private_data; \
char buf[buflen]; \ char buf[buflen]; \
int res; \ int res; \
\ \
@ -48,7 +48,7 @@ static ssize_t name## _read(struct file *file, char __user *userbuf, \
\ \
static const struct file_operations name## _ops = { \ static const struct file_operations name## _ops = { \
.read = name## _read, \ .read = name## _read, \
.open = wl12xx_open_file_generic, \ .open = wl1251_open_file_generic, \
}; };
#define DEBUGFS_ADD(name, parent) \ #define DEBUGFS_ADD(name, parent) \
@ -71,11 +71,11 @@ static ssize_t sub## _ ##name## _read(struct file *file, \
char __user *userbuf, \ char __user *userbuf, \
size_t count, loff_t *ppos) \ size_t count, loff_t *ppos) \
{ \ { \
struct wl12xx *wl = file->private_data; \ struct wl1251 *wl = file->private_data; \
char buf[buflen]; \ char buf[buflen]; \
int res; \ int res; \
\ \
wl12xx_debugfs_update_stats(wl); \ wl1251_debugfs_update_stats(wl); \
\ \
res = scnprintf(buf, buflen, fmt "\n", \ res = scnprintf(buf, buflen, fmt "\n", \
wl->stats.fw_stats->sub.name); \ 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 = { \ static const struct file_operations sub## _ ##name## _ops = { \
.read = sub## _ ##name## _read, \ .read = sub## _ ##name## _read, \
.open = wl12xx_open_file_generic, \ .open = wl1251_open_file_generic, \
}; };
#define DEBUGFS_FWSTATS_ADD(sub, name) \ #define DEBUGFS_FWSTATS_ADD(sub, name) \
@ -93,30 +93,30 @@ static const struct file_operations sub## _ ##name## _ops = { \
#define DEBUGFS_FWSTATS_DEL(sub, name) \ #define DEBUGFS_FWSTATS_DEL(sub, name) \
DEBUGFS_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; int ret;
mutex_lock(&wl->mutex); mutex_lock(&wl->mutex);
ret = wl12xx_ps_elp_wakeup(wl); ret = wl1251_ps_elp_wakeup(wl);
if (ret < 0) if (ret < 0)
goto out; goto out;
if (wl->state == WL12XX_STATE_ON && if (wl->state == WL1251_STATE_ON &&
time_after(jiffies, wl->stats.fw_stats_update + time_after(jiffies, wl->stats.fw_stats_update +
msecs_to_jiffies(WL12XX_DEBUGFS_STATS_LIFETIME))) { msecs_to_jiffies(WL1251_DEBUGFS_STATS_LIFETIME))) {
wl12xx_acx_statistics(wl, wl->stats.fw_stats); wl1251_acx_statistics(wl, wl->stats.fw_stats);
wl->stats.fw_stats_update = jiffies; wl->stats.fw_stats_update = jiffies;
} }
wl12xx_ps_elp_sleep(wl); wl1251_ps_elp_sleep(wl);
out: out:
mutex_unlock(&wl->mutex); 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; file->private_data = inode->i_private;
return 0; 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, static ssize_t tx_queue_len_read(struct file *file, char __user *userbuf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct wl12xx *wl = file->private_data; struct wl1251 *wl = file->private_data;
u32 queue_len; u32 queue_len;
char buf[20]; char buf[20];
int res; 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 = { static const struct file_operations tx_queue_len_ops = {
.read = tx_queue_len_read, .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); DEBUGFS_FWSTATS_DEL(tx, internal_desc_overflow);
@ -335,7 +335,7 @@ static void wl12xx_debugfs_delete_files(struct wl12xx *wl)
DEBUGFS_DEL(excessive_retries); 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; int ret = 0;
@ -436,19 +436,19 @@ static int wl12xx_debugfs_add_files(struct wl12xx *wl)
out: out:
if (ret < 0) if (ret < 0)
wl12xx_debugfs_delete_files(wl); wl1251_debugfs_delete_files(wl);
return ret; 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)); memset(wl->stats.fw_stats, 0, sizeof(*wl->stats.fw_stats));
wl->stats.retry_count = 0; wl->stats.retry_count = 0;
wl->stats.excessive_retries = 0; wl->stats.excessive_retries = 0;
} }
int wl12xx_debugfs_init(struct wl12xx *wl) int wl1251_debugfs_init(struct wl1251 *wl)
{ {
int ret; int ret;
@ -479,7 +479,7 @@ int wl12xx_debugfs_init(struct wl12xx *wl)
wl->stats.fw_stats_update = jiffies; wl->stats.fw_stats_update = jiffies;
ret = wl12xx_debugfs_add_files(wl); ret = wl1251_debugfs_add_files(wl);
if (ret < 0) if (ret < 0)
goto err_file; goto err_file;
@ -502,9 +502,9 @@ err:
return ret; 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); kfree(wl->stats.fw_stats);
wl->stats.fw_stats = NULL; 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 * Copyright (C) 2009 Nokia Corporation
* *
@ -21,13 +21,13 @@
* *
*/ */
#ifndef WL12XX_DEBUGFS_H #ifndef WL1251_DEBUGFS_H
#define WL12XX_DEBUGFS_H #define WL1251_DEBUGFS_H
#include "wl1251.h" #include "wl1251.h"
int wl12xx_debugfs_init(struct wl12xx *wl); int wl1251_debugfs_init(struct wl1251 *wl);
void wl12xx_debugfs_exit(struct wl12xx *wl); void wl1251_debugfs_exit(struct wl1251 *wl);
void wl12xx_debugfs_reset(struct wl12xx *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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -28,10 +28,10 @@
#include "wl1251_event.h" #include "wl1251_event.h"
#include "wl1251_ps.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) 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_status,
mbox->scheduled_scan_channels); mbox->scheduled_scan_channels);
@ -45,34 +45,34 @@ static int wl12xx_event_scan_complete(struct wl12xx *wl,
return 0; 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:"); wl1251_debug(DEBUG_EVENT, "MBOX DUMP:");
wl12xx_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector); wl1251_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
wl12xx_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask); 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; int ret;
u32 vector; u32 vector;
wl12xx_event_mbox_dump(mbox); wl1251_event_mbox_dump(mbox);
vector = mbox->events_vector & ~(mbox->events_mask); 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) { if (vector & SCAN_COMPLETE_EVENT_ID) {
ret = wl12xx_event_scan_complete(wl, mbox); ret = wl1251_event_scan_complete(wl, mbox);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
if (vector & BSS_LOSE_EVENT_ID) { 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) { 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) if (ret < 0)
return ret; return ret;
} }
@ -81,47 +81,47 @@ static int wl12xx_event_process(struct wl12xx *wl, struct event_mailbox *mbox)
return 0; return 0;
} }
int wl12xx_event_unmask(struct wl12xx *wl) int wl1251_event_unmask(struct wl1251 *wl)
{ {
int ret; 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) if (ret < 0)
return ret; return ret;
return 0; 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); 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]); 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; struct event_mailbox mbox;
int ret; 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) if (mbox_num > 1)
return -EINVAL; return -EINVAL;
/* first we read the mbox descriptor */ /* 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)); sizeof(struct event_mailbox));
/* process the descriptor */ /* process the descriptor */
ret = wl12xx_event_process(wl, &mbox); ret = wl1251_event_process(wl, &mbox);
if (ret < 0) if (ret < 0)
return ret; return ret;
/* then we let the firmware know it can go on...*/ /* 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; 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -22,8 +22,8 @@
* *
*/ */
#ifndef __WL12XX_EVENT_H__ #ifndef __WL1251_EVENT_H__
#define __WL12XX_EVENT_H__ #define __WL1251_EVENT_H__
/* /*
* Mbox events * Mbox events
@ -114,8 +114,8 @@ struct event_mailbox {
u8 padding[19]; u8 padding[19];
} __attribute__ ((packed)); } __attribute__ ((packed));
int wl12xx_event_unmask(struct wl12xx *wl); int wl1251_event_unmask(struct wl1251 *wl);
void wl12xx_event_mbox_config(struct wl12xx *wl); void wl1251_event_mbox_config(struct wl1251 *wl);
int wl12xx_event_handle(struct wl12xx *wl, u8 mbox); int wl1251_event_handle(struct wl1251 *wl, u8 mbox);
#endif #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 * Copyright (C) 2009 Nokia Corporation
* *
@ -29,59 +29,59 @@
#include "wl1251_acx.h" #include "wl1251_acx.h"
#include "wl1251_cmd.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; int ret;
ret = wl12xx_acx_feature_cfg(wl); ret = wl1251_acx_feature_cfg(wl);
if (ret < 0) { if (ret < 0) {
wl12xx_warning("couldn't set feature config"); wl1251_warning("couldn't set feature config");
return ret; return ret;
} }
ret = wl12xx_acx_default_key(wl, wl->default_key); ret = wl1251_acx_default_key(wl, wl->default_key);
if (ret < 0) { if (ret < 0) {
wl12xx_warning("couldn't set default key"); wl1251_warning("couldn't set default key");
return ret; return ret;
} }
return 0; return 0;
} }
int wl12xx_hw_init_templates_config(struct wl12xx *wl) int wl1251_hw_init_templates_config(struct wl1251 *wl)
{ {
int ret; int ret;
u8 partial_vbm[PARTIAL_VBM_MAX]; u8 partial_vbm[PARTIAL_VBM_MAX];
/* send empty templates for fw memory reservation */ /* 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)); sizeof(struct wl12xx_probe_req_template));
if (ret < 0) if (ret < 0)
return ret; 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)); sizeof(struct wl12xx_null_data_template));
if (ret < 0) if (ret < 0)
return ret; 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)); sizeof(struct wl12xx_ps_poll_template));
if (ret < 0) if (ret < 0)
return ret; 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 sizeof
(struct wl12xx_qos_null_data_template)); (struct wl12xx_qos_null_data_template));
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_cmd_template_set(wl, CMD_PROBE_RESP, NULL, ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, NULL,
sizeof sizeof
(struct wl12xx_probe_resp_template)); (struct wl12xx_probe_resp_template));
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_cmd_template_set(wl, CMD_BEACON, NULL, ret = wl1251_cmd_template_set(wl, CMD_BEACON, NULL,
sizeof sizeof
(struct wl12xx_beacon_template)); (struct wl12xx_beacon_template));
if (ret < 0) 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 */ /* tim templates, first reserve space then allocate an empty one */
memset(partial_vbm, 0, PARTIAL_VBM_MAX); 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) if (ret < 0)
return ret; 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) if (ret < 0)
return ret; return ret;
return 0; 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; 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) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_rx_config(wl, config, filter); ret = wl1251_acx_rx_config(wl, config, filter);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; return 0;
} }
int wl12xx_hw_init_phy_config(struct wl12xx *wl) int wl1251_hw_init_phy_config(struct wl1251 *wl)
{ {
int ret; int ret;
ret = wl12xx_acx_pd_threshold(wl); ret = wl1251_acx_pd_threshold(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_slot(wl, DEFAULT_SLOT_TIME); ret = wl1251_acx_slot(wl, DEFAULT_SLOT_TIME);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_group_address_tbl(wl); ret = wl1251_acx_group_address_tbl(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_service_period_timeout(wl); ret = wl1251_acx_service_period_timeout(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_rts_threshold(wl, RTS_THRESHOLD_DEF); ret = wl1251_acx_rts_threshold(wl, RTS_THRESHOLD_DEF);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; return 0;
} }
int wl12xx_hw_init_beacon_filter(struct wl12xx *wl) int wl1251_hw_init_beacon_filter(struct wl1251 *wl)
{ {
int ret; int ret;
ret = wl12xx_acx_beacon_filter_opt(wl); ret = wl1251_acx_beacon_filter_opt(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_beacon_filter_table(wl); ret = wl1251_acx_beacon_filter_table(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; return 0;
} }
int wl12xx_hw_init_pta(struct wl12xx *wl) int wl1251_hw_init_pta(struct wl1251 *wl)
{ {
int ret; int ret;
ret = wl12xx_acx_sg_enable(wl); ret = wl1251_acx_sg_enable(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_acx_sg_cfg(wl); ret = wl1251_acx_sg_cfg(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; return 0;
} }
int wl12xx_hw_init_energy_detection(struct wl12xx *wl) int wl1251_hw_init_energy_detection(struct wl1251 *wl)
{ {
int ret; int ret;
ret = wl12xx_acx_cca_threshold(wl); ret = wl1251_acx_cca_threshold(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; return 0;
} }
int wl12xx_hw_init_beacon_broadcast(struct wl12xx *wl) int wl1251_hw_init_beacon_broadcast(struct wl1251 *wl)
{ {
int ret; int ret;
ret = wl12xx_acx_bcn_dtim_options(wl); ret = wl1251_acx_bcn_dtim_options(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; 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 * Copyright (C) 2009 Nokia Corporation
* *
@ -21,19 +21,19 @@
* *
*/ */
#ifndef __WL12XX_INIT_H__ #ifndef __WL1251_INIT_H__
#define __WL12XX_INIT_H__ #define __WL1251_INIT_H__
#include "wl1251.h" #include "wl1251.h"
int wl12xx_hw_init_hwenc_config(struct wl12xx *wl); int wl1251_hw_init_hwenc_config(struct wl1251 *wl);
int wl12xx_hw_init_templates_config(struct wl12xx *wl); int wl1251_hw_init_templates_config(struct wl1251 *wl);
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 wl12xx_hw_init_phy_config(struct wl12xx *wl); int wl1251_hw_init_phy_config(struct wl1251 *wl);
int wl12xx_hw_init_beacon_filter(struct wl12xx *wl); int wl1251_hw_init_beacon_filter(struct wl1251 *wl);
int wl12xx_hw_init_pta(struct wl12xx *wl); int wl1251_hw_init_pta(struct wl1251 *wl);
int wl12xx_hw_init_energy_detection(struct wl12xx *wl); int wl1251_hw_init_energy_detection(struct wl1251 *wl);
int wl12xx_hw_init_beacon_broadcast(struct wl12xx *wl); int wl1251_hw_init_beacon_broadcast(struct wl1251 *wl);
int wl12xx_hw_init_power_auth(struct wl12xx *wl); int wl1251_hw_init_power_auth(struct wl1251 *wl);
#endif #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 * Copyright (C) 2008 Nokia Corporation
* *
@ -35,52 +35,52 @@
#include "wl1251_acx.h" #include "wl1251_acx.h"
/* FIXME: this should be changed as soon as user space catches up */ /* FIXME: this should be changed as soon as user space catches up */
#define WL12XX_NL_NAME "wl1251" #define WL1251_NL_NAME "wl1251"
#define WL12XX_NL_VERSION 1 #define WL1251_NL_VERSION 1
#define WL12XX_MAX_TEST_LENGTH 1024 #define WL1251_MAX_TEST_LENGTH 1024
#define WL12XX_MAX_NVS_LENGTH 1024 #define WL1251_MAX_NVS_LENGTH 1024
enum wl12xx_nl_commands { enum wl1251_nl_commands {
WL12XX_NL_CMD_UNSPEC, WL1251_NL_CMD_UNSPEC,
WL12XX_NL_CMD_TEST, WL1251_NL_CMD_TEST,
WL12XX_NL_CMD_INTERROGATE, WL1251_NL_CMD_INTERROGATE,
WL12XX_NL_CMD_CONFIGURE, WL1251_NL_CMD_CONFIGURE,
WL12XX_NL_CMD_PHY_REG_READ, WL1251_NL_CMD_PHY_REG_READ,
WL12XX_NL_CMD_NVS_PUSH, WL1251_NL_CMD_NVS_PUSH,
WL12XX_NL_CMD_REG_WRITE, WL1251_NL_CMD_REG_WRITE,
WL12XX_NL_CMD_REG_READ, WL1251_NL_CMD_REG_READ,
WL12XX_NL_CMD_SET_PLT_MODE, 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 { enum wl1251_nl_attrs {
WL12XX_NL_ATTR_UNSPEC, WL1251_NL_ATTR_UNSPEC,
WL12XX_NL_ATTR_IFNAME, WL1251_NL_ATTR_IFNAME,
WL12XX_NL_ATTR_CMD_TEST_PARAM, WL1251_NL_ATTR_CMD_TEST_PARAM,
WL12XX_NL_ATTR_CMD_TEST_ANSWER, WL1251_NL_ATTR_CMD_TEST_ANSWER,
WL12XX_NL_ATTR_CMD_IE, WL1251_NL_ATTR_CMD_IE,
WL12XX_NL_ATTR_CMD_IE_LEN, WL1251_NL_ATTR_CMD_IE_LEN,
WL12XX_NL_ATTR_CMD_IE_BUFFER, WL1251_NL_ATTR_CMD_IE_BUFFER,
WL12XX_NL_ATTR_CMD_IE_ANSWER, WL1251_NL_ATTR_CMD_IE_ANSWER,
WL12XX_NL_ATTR_REG_ADDR, WL1251_NL_ATTR_REG_ADDR,
WL12XX_NL_ATTR_REG_VAL, WL1251_NL_ATTR_REG_VAL,
WL12XX_NL_ATTR_NVS_BUFFER, WL1251_NL_ATTR_NVS_BUFFER,
WL12XX_NL_ATTR_NVS_LEN, WL1251_NL_ATTR_NVS_LEN,
WL12XX_NL_ATTR_PLT_MODE, 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, .id = GENL_ID_GENERATE,
.name = WL12XX_NL_NAME, .name = WL1251_NL_NAME,
.hdrsize = 0, .hdrsize = 0,
.version = WL12XX_NL_VERSION, .version = WL1251_NL_VERSION,
.maxattr = WL12XX_NL_ATTR_MAX, .maxattr = WL1251_NL_ATTR_MAX,
}; };
static struct net_device *ifname_to_netdev(struct net *net, 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; char *ifname;
if (!info->attrs[WL12XX_NL_ATTR_IFNAME]) if (!info->attrs[WL1251_NL_ATTR_IFNAME])
return NULL; 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); 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 net_device *netdev;
struct wireless_dev *wdev; 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); netdev = ifname_to_netdev(net, info);
if (netdev == NULL) { if (netdev == NULL) {
wl12xx_error("Wrong interface"); wl1251_error("Wrong interface");
return NULL; return NULL;
} }
wdev = netdev->ieee80211_ptr; wdev = netdev->ieee80211_ptr;
if (wdev == NULL) { if (wdev == NULL) {
wl12xx_error("ieee80211_ptr is NULL"); wl1251_error("ieee80211_ptr is NULL");
return NULL; return NULL;
} }
wiphy = wdev->wiphy; wiphy = wdev->wiphy;
if (wiphy == NULL) { if (wiphy == NULL) {
wl12xx_error("wiphy is NULL"); wl1251_error("wiphy is NULL");
return NULL; return NULL;
} }
hw = wiphy_priv(wiphy); hw = wiphy_priv(wiphy);
if (hw == NULL) { if (hw == NULL) {
wl12xx_error("hw is NULL"); wl1251_error("hw is NULL");
return NULL; return NULL;
} }
@ -134,20 +134,20 @@ static struct wl12xx *ifname_to_wl12xx(struct net *net, struct genl_info *info)
return hw->priv; 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 wl1251 *wl;
struct wl12xx_command *cmd; struct wl1251_command *cmd;
char *buf; char *buf;
int buf_len, ret, cmd_len; int buf_len, ret, cmd_len;
u8 answer; u8 answer;
if (!info->attrs[WL12XX_NL_ATTR_CMD_TEST_PARAM]) if (!info->attrs[WL1251_NL_ATTR_CMD_TEST_PARAM])
return -EINVAL; return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
return -EINVAL; return -EINVAL;
} }
@ -155,20 +155,20 @@ static int wl12xx_nl_test_cmd(struct sk_buff *skb, struct genl_info *info)
if (!cmd) if (!cmd)
return -ENOMEM; return -ENOMEM;
buf = nla_data(info->attrs[WL12XX_NL_ATTR_CMD_TEST_PARAM]); buf = nla_data(info->attrs[WL1251_NL_ATTR_CMD_TEST_PARAM]);
buf_len = nla_len(info->attrs[WL12XX_NL_ATTR_CMD_TEST_PARAM]); buf_len = nla_len(info->attrs[WL1251_NL_ATTR_CMD_TEST_PARAM]);
answer = nla_get_u8(info->attrs[WL12XX_NL_ATTR_CMD_TEST_ANSWER]); answer = nla_get_u8(info->attrs[WL1251_NL_ATTR_CMD_TEST_ANSWER]);
cmd->header.id = CMD_TEST; cmd->header.id = CMD_TEST;
memcpy(cmd->parameters, buf, buf_len); 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); 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); mutex_unlock(&wl->mutex);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto out; 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, 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)) { if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr); ret = PTR_ERR(hdr);
goto nla_put_failure; goto nla_put_failure;
} }
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME, NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME])); nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]));
NLA_PUT(msg, WL12XX_NL_ATTR_CMD_TEST_ANSWER, NLA_PUT(msg, WL1251_NL_ATTR_CMD_TEST_ANSWER,
sizeof(*cmd), cmd); sizeof(*cmd), cmd);
ret = genlmsg_end(msg, hdr); ret = genlmsg_end(msg, hdr);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; 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); ret = genlmsg_reply(msg, info);
goto out; goto out;
nla_put_failure: nla_put_failure:
nlmsg_free(msg); nlmsg_free(msg);
} else } else
wl12xx_debug(DEBUG_NETLINK, "TEST cmd sent"); wl1251_debug(DEBUG_NETLINK, "TEST cmd sent");
out: out:
kfree(cmd); kfree(cmd);
return ret; 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; struct sk_buff *msg;
int ret = -ENOBUFS, cmd_ie, cmd_ie_len; int ret = -ENOBUFS, cmd_ie, cmd_ie_len;
struct wl12xx_command *cmd; struct wl1251_command *cmd;
void *hdr; void *hdr;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE]) if (!info->attrs[WL1251_NL_ATTR_CMD_IE])
return -EINVAL; return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE_LEN]) if (!info->attrs[WL1251_NL_ATTR_CMD_IE_LEN])
return -EINVAL; return -EINVAL;
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 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) if (!msg)
return -ENOMEM; return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
ret = -EINVAL; ret = -EINVAL;
goto nla_put_failure; goto nla_put_failure;
} }
/* acx id */ /* 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 */ /* 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); cmd_ie, cmd_ie_len);
mutex_lock(&wl->mutex); 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); mutex_unlock(&wl->mutex);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; goto nla_put_failure;
} }
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, 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)) { if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr); ret = PTR_ERR(hdr);
goto nla_put_failure; goto nla_put_failure;
} }
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME, NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_NL_ATTR_IFNAME])); nla_data(info->attrs[WL1251_NL_ATTR_IFNAME]));
NLA_PUT(msg, WL12XX_NL_ATTR_CMD_IE_ANSWER, cmd_ie_len, cmd); NLA_PUT(msg, WL1251_NL_ATTR_CMD_IE_ANSWER, cmd_ie_len, cmd);
ret = genlmsg_end(msg, hdr); ret = genlmsg_end(msg, hdr);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; goto nla_put_failure;
} }
@ -288,36 +288,36 @@ static int wl12xx_nl_interrogate(struct sk_buff *skb, struct genl_info *info)
return ret; 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; int ret = 0, cmd_ie_len, acx_len;
struct acx_header *acx = NULL; struct acx_header *acx = NULL;
struct sk_buff *msg; struct sk_buff *msg;
struct wl12xx *wl; struct wl1251 *wl;
void *cmd_ie; void *cmd_ie;
u16 *id; u16 *id;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE_BUFFER]) if (!info->attrs[WL1251_NL_ATTR_CMD_IE_BUFFER])
return -EINVAL; return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_CMD_IE_LEN]) if (!info->attrs[WL1251_NL_ATTR_CMD_IE_LEN])
return -EINVAL; return -EINVAL;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg) if (!msg)
return -ENOMEM; return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
ret = -EINVAL; ret = -EINVAL;
goto nla_put_failure; goto nla_put_failure;
} }
/* contains the acx header but not the cmd header */ /* 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 */ /* acx id is in the first two bytes */
id = cmd_ie; 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); memcpy(&acx->id, cmd_ie, cmd_ie_len);
mutex_lock(&wl->mutex); 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); mutex_unlock(&wl->mutex);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; goto nla_put_failure;
} }
wl12xx_debug(DEBUG_NETLINK, "CONFIGURE cmd sent"); wl1251_debug(DEBUG_NETLINK, "CONFIGURE cmd sent");
nla_put_failure: nla_put_failure:
kfree(acx); kfree(acx);
@ -351,24 +351,24 @@ static int wl12xx_nl_configure(struct sk_buff *skb, struct genl_info *info)
return ret; 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; struct sk_buff *msg;
u32 reg_addr, *reg_value = NULL; u32 reg_addr, *reg_value = NULL;
int ret = 0; int ret = 0;
void *hdr; void *hdr;
if (!info->attrs[WL12XX_NL_ATTR_REG_ADDR]) if (!info->attrs[WL1251_NL_ATTR_REG_ADDR])
return -EINVAL; return -EINVAL;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg) if (!msg)
return -ENOMEM; return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
ret = -EINVAL; ret = -EINVAL;
goto nla_put_failure; 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; 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); 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)); sizeof(*reg_value));
mutex_unlock(&wl->mutex); mutex_unlock(&wl->mutex);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; goto nla_put_failure;
} }
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, 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)) { if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr); ret = PTR_ERR(hdr);
goto nla_put_failure; goto nla_put_failure;
} }
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME, NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_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); ret = genlmsg_end(msg, hdr);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; 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; 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; int ret = 0;
if (!info->attrs[WL12XX_NL_ATTR_NVS_BUFFER]) if (!info->attrs[WL1251_NL_ATTR_NVS_BUFFER])
return -EINVAL; return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_NVS_LEN]) if (!info->attrs[WL1251_NL_ATTR_NVS_LEN])
return -EINVAL; return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
return -EINVAL; return -EINVAL;
} }
mutex_lock(&wl->mutex); 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) { 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; ret = -EILSEQ;
goto out; 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); wl->nvs = kzalloc(wl->nvs_len, GFP_KERNEL);
if (wl->nvs == NULL) { if (wl->nvs == NULL) {
wl12xx_error("Can't allocate NVS"); wl1251_error("Can't allocate NVS");
ret = -ENOMEM; ret = -ENOMEM;
goto out; goto out;
} }
memcpy(wl->nvs, memcpy(wl->nvs,
nla_data(info->attrs[WL12XX_NL_ATTR_NVS_BUFFER]), nla_data(info->attrs[WL1251_NL_ATTR_NVS_BUFFER]),
wl->nvs_len); 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); wl->nvs_len);
out: out:
@ -471,48 +471,48 @@ out:
return ret; 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; u32 addr, val;
int ret = 0; int ret = 0;
struct sk_buff *msg; struct sk_buff *msg;
void *hdr; void *hdr;
if (!info->attrs[WL12XX_NL_ATTR_REG_ADDR]) if (!info->attrs[WL1251_NL_ATTR_REG_ADDR])
return -EINVAL; return -EINVAL;
msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
if (!msg) if (!msg)
return -ENOMEM; return -ENOMEM;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
return -EINVAL; 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); mutex_lock(&wl->mutex);
val = wl12xx_reg_read32(wl, addr); val = wl1251_reg_read32(wl, addr);
mutex_unlock(&wl->mutex); mutex_unlock(&wl->mutex);
hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, 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)) { if (IS_ERR(hdr)) {
ret = PTR_ERR(hdr); ret = PTR_ERR(hdr);
goto nla_put_failure; goto nla_put_failure;
} }
NLA_PUT_STRING(msg, WL12XX_NL_ATTR_IFNAME, NLA_PUT_STRING(msg, WL1251_NL_ATTR_IFNAME,
nla_data(info->attrs[WL12XX_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); ret = genlmsg_end(msg, hdr);
if (ret < 0) { if (ret < 0) {
wl12xx_error("%s() failed", __func__); wl1251_error("%s() failed", __func__);
goto nla_put_failure; goto nla_put_failure;
} }
@ -524,56 +524,56 @@ static int wl12xx_nl_reg_read(struct sk_buff *skb, struct genl_info *info)
return ret; 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; u32 addr, val;
if (!info->attrs[WL12XX_NL_ATTR_REG_ADDR]) if (!info->attrs[WL1251_NL_ATTR_REG_ADDR])
return -EINVAL; return -EINVAL;
if (!info->attrs[WL12XX_NL_ATTR_REG_VAL]) if (!info->attrs[WL1251_NL_ATTR_REG_VAL])
return -EINVAL; return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
return -EINVAL; return -EINVAL;
} }
addr = nla_get_u32(info->attrs[WL12XX_NL_ATTR_REG_ADDR]); addr = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_ADDR]);
val = nla_get_u32(info->attrs[WL12XX_NL_ATTR_REG_VAL]); val = nla_get_u32(info->attrs[WL1251_NL_ATTR_REG_VAL]);
mutex_lock(&wl->mutex); mutex_lock(&wl->mutex);
wl12xx_reg_write32(wl, addr, val); wl1251_reg_write32(wl, addr, val);
mutex_unlock(&wl->mutex); mutex_unlock(&wl->mutex);
return 0; 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; u32 val;
int ret; int ret;
if (!info->attrs[WL12XX_NL_ATTR_PLT_MODE]) if (!info->attrs[WL1251_NL_ATTR_PLT_MODE])
return -EINVAL; return -EINVAL;
wl = ifname_to_wl12xx(&init_net, info); wl = ifname_to_wl1251(&init_net, info);
if (wl == NULL) { if (wl == NULL) {
wl12xx_error("wl12xx not found"); wl1251_error("wl1251 not found");
return -EINVAL; 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) { switch (val) {
case 0: case 0:
ret = wl12xx_plt_stop(wl); ret = wl1251_plt_stop(wl);
break; break;
case 1: case 1:
ret = wl12xx_plt_start(wl); ret = wl1251_plt_start(wl);
break; break;
default: default:
ret = -EINVAL; ret = -EINVAL;
@ -583,97 +583,97 @@ static int wl12xx_nl_set_plt_mode(struct sk_buff *skb, struct genl_info *info)
return ret; return ret;
} }
static struct nla_policy wl12xx_nl_policy[WL12XX_NL_ATTR_MAX + 1] = { static struct nla_policy wl1251_nl_policy[WL1251_NL_ATTR_MAX + 1] = {
[WL12XX_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING, [WL1251_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
.len = IFNAMSIZ-1 }, .len = IFNAMSIZ-1 },
[WL12XX_NL_ATTR_CMD_TEST_PARAM] = { .type = NLA_BINARY, [WL1251_NL_ATTR_CMD_TEST_PARAM] = { .type = NLA_BINARY,
.len = WL12XX_MAX_TEST_LENGTH }, .len = WL1251_MAX_TEST_LENGTH },
[WL12XX_NL_ATTR_CMD_TEST_ANSWER] = { .type = NLA_U8 }, [WL1251_NL_ATTR_CMD_TEST_ANSWER] = { .type = NLA_U8 },
[WL12XX_NL_ATTR_CMD_IE] = { .type = NLA_U32 }, [WL1251_NL_ATTR_CMD_IE] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_CMD_IE_LEN] = { .type = NLA_U32 }, [WL1251_NL_ATTR_CMD_IE_LEN] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_CMD_IE_BUFFER] = { .type = NLA_BINARY, [WL1251_NL_ATTR_CMD_IE_BUFFER] = { .type = NLA_BINARY,
.len = WL12XX_MAX_TEST_LENGTH }, .len = WL1251_MAX_TEST_LENGTH },
[WL12XX_NL_ATTR_CMD_IE_ANSWER] = { .type = NLA_BINARY, [WL1251_NL_ATTR_CMD_IE_ANSWER] = { .type = NLA_BINARY,
.len = WL12XX_MAX_TEST_LENGTH }, .len = WL1251_MAX_TEST_LENGTH },
[WL12XX_NL_ATTR_REG_ADDR] = { .type = NLA_U32 }, [WL1251_NL_ATTR_REG_ADDR] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_REG_VAL] = { .type = NLA_U32 }, [WL1251_NL_ATTR_REG_VAL] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_NVS_BUFFER] = { .type = NLA_BINARY, [WL1251_NL_ATTR_NVS_BUFFER] = { .type = NLA_BINARY,
.len = WL12XX_MAX_NVS_LENGTH }, .len = WL1251_MAX_NVS_LENGTH },
[WL12XX_NL_ATTR_NVS_LEN] = { .type = NLA_U32 }, [WL1251_NL_ATTR_NVS_LEN] = { .type = NLA_U32 },
[WL12XX_NL_ATTR_PLT_MODE] = { .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, .cmd = WL1251_NL_CMD_TEST,
.doit = wl12xx_nl_test_cmd, .doit = wl1251_nl_test_cmd,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_INTERROGATE, .cmd = WL1251_NL_CMD_INTERROGATE,
.doit = wl12xx_nl_interrogate, .doit = wl1251_nl_interrogate,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_CONFIGURE, .cmd = WL1251_NL_CMD_CONFIGURE,
.doit = wl12xx_nl_configure, .doit = wl1251_nl_configure,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_PHY_REG_READ, .cmd = WL1251_NL_CMD_PHY_REG_READ,
.doit = wl12xx_nl_phy_reg_read, .doit = wl1251_nl_phy_reg_read,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_NVS_PUSH, .cmd = WL1251_NL_CMD_NVS_PUSH,
.doit = wl12xx_nl_nvs_push, .doit = wl1251_nl_nvs_push,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_REG_WRITE, .cmd = WL1251_NL_CMD_REG_WRITE,
.doit = wl12xx_nl_reg_write, .doit = wl1251_nl_reg_write,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_REG_READ, .cmd = WL1251_NL_CMD_REG_READ,
.doit = wl12xx_nl_reg_read, .doit = wl1251_nl_reg_read,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
{ {
.cmd = WL12XX_NL_CMD_SET_PLT_MODE, .cmd = WL1251_NL_CMD_SET_PLT_MODE,
.doit = wl12xx_nl_set_plt_mode, .doit = wl1251_nl_set_plt_mode,
.policy = wl12xx_nl_policy, .policy = wl1251_nl_policy,
.flags = GENL_ADMIN_PERM, .flags = GENL_ADMIN_PERM,
}, },
}; };
int wl12xx_nl_register(void) int wl1251_nl_register(void)
{ {
int err, i; int err, i;
err = genl_register_family(&wl12xx_nl_family); err = genl_register_family(&wl1251_nl_family);
if (err) if (err)
return err; return err;
for (i = 0; i < ARRAY_SIZE(wl12xx_nl_ops); i++) { for (i = 0; i < ARRAY_SIZE(wl1251_nl_ops); i++) {
err = genl_register_ops(&wl12xx_nl_family, &wl12xx_nl_ops[i]); err = genl_register_ops(&wl1251_nl_family, &wl1251_nl_ops[i]);
if (err) if (err)
goto err_out; goto err_out;
} }
return 0; return 0;
err_out: err_out:
genl_unregister_family(&wl12xx_nl_family); genl_unregister_family(&wl1251_nl_family);
return err; 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 * Copyright (C) 2009 Nokia Corporation
* *
@ -21,10 +21,10 @@
* *
*/ */
#ifndef __WL12XX_NETLINK_H__ #ifndef __WL1251_NETLINK_H__
#define __WL12XX_NETLINK_H__ #define __WL1251_NETLINK_H__
int wl12xx_nl_register(void); int wl1251_nl_register(void);
void wl12xx_nl_unregister(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 * Copyright (C) 2008-2009 Nokia Corporation
* *
@ -35,7 +35,7 @@
#include "wl1251_ps.h" #include "wl1251_ps.h"
#include "wl1251_init.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] = { [PART_DOWN] = {
.mem = { .mem = {
.start = 0x00000000, .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) [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; int addr, chunk_num, partition_limit;
size_t fw_data_len; size_t fw_data_len;
u8 *p; u8 *p;
/* whal_FwCtrl_LoadFwImageSm() */ /* whal_FwCtrl_LoadFwImageSm() */
wl12xx_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x", wl1251_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x",
wl12xx_reg_read32(wl, CHIP_ID_B)); wl1251_reg_read32(wl, CHIP_ID_B));
/* 10.0 check firmware length and set partition */ /* 10.0 check firmware length and set partition */
fw_data_len = (wl->fw[4] << 24) | (wl->fw[5] << 16) | fw_data_len = (wl->fw[4] << 24) | (wl->fw[5] << 16) |
(wl->fw[6] << 8) | (wl->fw[7]); (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); CHUNK_SIZE);
if ((fw_data_len % 4) != 0) { if ((fw_data_len % 4) != 0) {
wl12xx_error("firmware length not multiple of four"); wl1251_error("firmware length not multiple of four");
return -EIO; return -EIO;
} }
wl12xx_set_partition(wl, wl1251_set_partition(wl,
p_table[PART_DOWN].mem.start, p_table[PART_DOWN].mem.start,
p_table[PART_DOWN].mem.size, p_table[PART_DOWN].mem.size,
p_table[PART_DOWN].reg.start, p_table[PART_DOWN].reg.start,
@ -118,7 +118,7 @@ static int wl1251_upload_firmware(struct wl12xx *wl)
chunk_num * CHUNK_SIZE; chunk_num * CHUNK_SIZE;
partition_limit = chunk_num * CHUNK_SIZE + partition_limit = chunk_num * CHUNK_SIZE +
p_table[PART_DOWN].mem.size; p_table[PART_DOWN].mem.size;
wl12xx_set_partition(wl, wl1251_set_partition(wl,
addr, addr,
p_table[PART_DOWN].mem.size, p_table[PART_DOWN].mem.size,
p_table[PART_DOWN].reg.start, p_table[PART_DOWN].reg.start,
@ -128,9 +128,9 @@ static int wl1251_upload_firmware(struct wl12xx *wl)
/* 10.3 upload the chunk */ /* 10.3 upload the chunk */
addr = p_table[PART_DOWN].mem.start + chunk_num * CHUNK_SIZE; addr = p_table[PART_DOWN].mem.start + chunk_num * CHUNK_SIZE;
p = wl->fw + FW_HDR_SIZE + 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); p, addr);
wl12xx_spi_mem_write(wl, addr, p, CHUNK_SIZE); wl1251_spi_mem_write(wl, addr, p, CHUNK_SIZE);
chunk_num++; chunk_num++;
} }
@ -138,14 +138,14 @@ static int wl1251_upload_firmware(struct wl12xx *wl)
/* 10.4 upload the last chunk */ /* 10.4 upload the last chunk */
addr = p_table[PART_DOWN].mem.start + chunk_num * CHUNK_SIZE; addr = p_table[PART_DOWN].mem.start + chunk_num * CHUNK_SIZE;
p = wl->fw + FW_HDR_SIZE + 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); 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; 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; size_t nvs_len, nvs_bytes_written, burst_len;
int nvs_start, i; int nvs_start, i;
@ -181,10 +181,10 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
val = (nvs_ptr[0] | (nvs_ptr[1] << 8) val = (nvs_ptr[0] | (nvs_ptr[1] << 8)
| (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24)); | (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));
wl12xx_debug(DEBUG_BOOT, wl1251_debug(DEBUG_BOOT,
"nvs burst write 0x%x: 0x%x", "nvs burst write 0x%x: 0x%x",
dest_addr, val); dest_addr, val);
wl12xx_mem_write32(wl, dest_addr, val); wl1251_mem_write32(wl, dest_addr, val);
nvs_ptr += 4; nvs_ptr += 4;
dest_addr += 4; dest_addr += 4;
@ -200,7 +200,7 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
nvs_len = ALIGN(nvs_len, 4); nvs_len = ALIGN(nvs_len, 4);
/* Now we must set the partition correctly */ /* 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].mem.size,
wl->chip.p_table[PART_DOWN].reg.start, wl->chip.p_table[PART_DOWN].reg.start,
wl->chip.p_table[PART_DOWN].reg.size); 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); val = cpu_to_le32(val);
wl12xx_debug(DEBUG_BOOT, wl1251_debug(DEBUG_BOOT,
"nvs write table 0x%x: 0x%x", "nvs write table 0x%x: 0x%x",
nvs_start, val); nvs_start, val);
wl12xx_mem_write32(wl, nvs_start, val); wl1251_mem_write32(wl, nvs_start, val);
nvs_ptr += 4; nvs_ptr += 4;
nvs_bytes_written += 4; nvs_bytes_written += 4;
@ -226,12 +226,12 @@ static int wl1251_upload_nvs(struct wl12xx *wl)
return 0; return 0;
} }
static int wl1251_boot(struct wl12xx *wl) static int wl1251_boot(struct wl1251 *wl)
{ {
int ret = 0, minor_minor_e2_ver; int ret = 0, minor_minor_e2_ver;
u32 tmp, boot_data; u32 tmp, boot_data;
ret = wl12xx_boot_soft_reset(wl); ret = wl1251_boot_soft_reset(wl);
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -242,39 +242,39 @@ static int wl1251_boot(struct wl12xx *wl)
/* write firmware's last address (ie. it's length) to /* write firmware's last address (ie. it's length) to
* ACX_EEPROMLESS_IND_REG */ * 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 */ /* 6. read the EEPROM parameters */
tmp = wl12xx_reg_read32(wl, SCR_PAD2); tmp = wl1251_reg_read32(wl, SCR_PAD2);
/* 7. read bootdata */ /* 7. read bootdata */
wl->boot_attr.radio_type = (tmp & 0x0000FF00) >> 8; wl->boot_attr.radio_type = (tmp & 0x0000FF00) >> 8;
wl->boot_attr.major = (tmp & 0x00FF0000) >> 16; 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 */ /* 8. check bootdata and call restart sequence */
wl->boot_attr.minor = (tmp & 0x00FF0000) >> 16; wl->boot_attr.minor = (tmp & 0x00FF0000) >> 16;
minor_minor_e2_ver = (tmp & 0xFF000000) >> 24; 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", "minorE2Ver 0x%x minor_minor_e2_ver 0x%x",
wl->boot_attr.radio_type, wl->boot_attr.major, wl->boot_attr.radio_type, wl->boot_attr.major,
wl->boot_attr.minor, minor_minor_e2_ver); wl->boot_attr.minor, minor_minor_e2_ver);
ret = wl12xx_boot_init_seq(wl); ret = wl1251_boot_init_seq(wl);
if (ret < 0) if (ret < 0)
goto out; goto out;
/* 9. NVS processing done */ /* 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 /* 10. check that ECPU_CONTROL_HALT bits are set in
* pWhalBus->uBootData and start uploading firmware * pWhalBus->uBootData and start uploading firmware
*/ */
if ((boot_data & ECPU_CONTROL_HALT) == 0) { 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; ret = -EIO;
goto out; goto out;
} }
@ -284,7 +284,7 @@ static int wl1251_boot(struct wl12xx *wl)
goto out; goto out;
/* 10.5 start firmware */ /* 10.5 start firmware */
ret = wl12xx_boot_run_firmware(wl); ret = wl1251_boot_run_firmware(wl);
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -292,12 +292,12 @@ out:
return ret; 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; struct wl1251_acx_config_memory *mem_conf;
int ret, i; 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); mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
if (!mem_conf) { if (!mem_conf) {
@ -327,10 +327,10 @@ static int wl1251_mem_cfg(struct wl12xx *wl)
mem_conf->tx_queue_config[i].attributes = i; 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)); sizeof(*mem_conf));
if (ret < 0) { if (ret < 0) {
wl12xx_warning("wl1251 mem config failed: %d", ret); wl1251_warning("wl1251 mem config failed: %d", ret);
goto out; goto out;
} }
@ -339,7 +339,7 @@ out:
return ret; return ret;
} }
static int wl1251_hw_init_mem_config(struct wl12xx *wl) static int wl1251_hw_init_mem_config(struct wl1251 *wl)
{ {
int ret; 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), wl->target_mem_map = kzalloc(sizeof(struct wl1251_acx_mem_map),
GFP_KERNEL); GFP_KERNEL);
if (!wl->target_mem_map) { if (!wl->target_mem_map) {
wl12xx_error("couldn't allocate target memory map"); wl1251_error("couldn't allocate target memory map");
return -ENOMEM; return -ENOMEM;
} }
/* we now ask for the firmware built memory map */ /* 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)); sizeof(struct wl1251_acx_mem_map));
if (ret < 0) { if (ret < 0) {
wl12xx_error("couldn't retrieve firmware memory map"); wl1251_error("couldn't retrieve firmware memory map");
kfree(wl->target_mem_map); kfree(wl->target_mem_map);
wl->target_mem_map = NULL; wl->target_mem_map = NULL;
return ret; return ret;
@ -367,19 +367,19 @@ static int wl1251_hw_init_mem_config(struct wl12xx *wl)
return 0; 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; u32 cpu_ctrl;
/* 10.5.0 run the firmware (I) */ /* 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) */ /* 10.5.1 run the firmware (II) */
cpu_ctrl &= ~flag; 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 */ /* Enable target's interrupts */
wl->intr_mask = WL1251_ACX_INTR_RX0_DATA | 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_A |
WL1251_ACX_INTR_EVENT_B | WL1251_ACX_INTR_EVENT_B |
WL1251_ACX_INTR_INIT_COMPLETE; 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) static void wl1251_irq_work(struct work_struct *work)
{ {
u32 intr; u32 intr;
struct wl12xx *wl = struct wl1251 *wl =
container_of(work, struct wl12xx, irq_work); container_of(work, struct wl1251, irq_work);
int ret; int ret;
mutex_lock(&wl->mutex); 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; goto out;
ret = wl12xx_ps_elp_wakeup(wl); ret = wl1251_ps_elp_wakeup(wl);
if (ret < 0) if (ret < 0)
goto out; 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); intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
wl12xx_debug(DEBUG_IRQ, "intr: 0x%x", intr); wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr);
if (wl->data_path) { if (wl->data_path) {
wl->rx_counter = 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 */ /* We handle a frmware bug here */
switch ((wl->rx_counter - wl->rx_handled) & 0xf) { switch ((wl->rx_counter - wl->rx_handled) & 0xf) {
case 0: 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_RX0_DATA;
intr &= ~WL1251_ACX_INTR_RX1_DATA; intr &= ~WL1251_ACX_INTR_RX1_DATA;
break; break;
case 1: 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_RX0_DATA;
intr &= ~WL1251_ACX_INTR_RX1_DATA; intr &= ~WL1251_ACX_INTR_RX1_DATA;
break; break;
case 2: 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_RX0_DATA;
intr |= WL1251_ACX_INTR_RX1_DATA; intr |= WL1251_ACX_INTR_RX1_DATA;
break; break;
default: 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); wl->rx_counter - wl->rx_handled);
break; break;
} }
@ -449,49 +449,49 @@ static void wl1251_irq_work(struct work_struct *work)
wl->rx_handled = wl->rx_counter; 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; intr &= wl->intr_mask;
if (intr == 0) { if (intr == 0) {
wl12xx_debug(DEBUG_IRQ, "INTR is 0"); wl1251_debug(DEBUG_IRQ, "INTR is 0");
wl12xx_reg_write32(wl, ACX_REG_INTERRUPT_MASK, wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK,
~(wl->intr_mask)); ~(wl->intr_mask));
goto out_sleep; goto out_sleep;
} }
if (intr & WL1251_ACX_INTR_RX0_DATA) { if (intr & WL1251_ACX_INTR_RX0_DATA) {
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA"); wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA");
wl12xx_rx(wl); wl1251_rx(wl);
} }
if (intr & WL1251_ACX_INTR_RX1_DATA) { if (intr & WL1251_ACX_INTR_RX1_DATA) {
wl12xx_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA"); wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA");
wl12xx_rx(wl); wl1251_rx(wl);
} }
if (intr & WL1251_ACX_INTR_TX_RESULT) { 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); wl1251_tx_complete(wl);
} }
if (intr & (WL1251_ACX_INTR_EVENT_A | WL1251_ACX_INTR_EVENT_B)) { 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) if (intr & WL1251_ACX_INTR_EVENT_A)
wl12xx_event_handle(wl, 0); wl1251_event_handle(wl, 0);
else else
wl12xx_event_handle(wl, 1); wl1251_event_handle(wl, 1);
} }
if (intr & WL1251_ACX_INTR_INIT_COMPLETE) 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: out_sleep:
wl12xx_ps_elp_sleep(wl); wl1251_ps_elp_sleep(wl);
out: out:
mutex_unlock(&wl->mutex); 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; (QOS_TX_LOW_VO_DEF * num_blocks) / 100;
break; break;
default: default:
wl12xx_error("Invalid TX queue id: %d", qid); wl1251_error("Invalid TX queue id: %d", qid);
return -EINVAL; return -EINVAL;
} }
return 0; 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 acx_tx_queue_qos_config *config;
struct wl1251_acx_mem_map *wl_mem_map = wl->target_mem_map; struct wl1251_acx_mem_map *wl_mem_map = wl->target_mem_map;
int ret, i; 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); config = kzalloc(sizeof(*config), GFP_KERNEL);
if (!config) { if (!config) {
@ -556,7 +556,7 @@ static int wl1251_hw_init_tx_queue_config(struct wl12xx *wl)
if (ret < 0) if (ret < 0)
goto out; goto out;
ret = wl12xx_cmd_configure(wl, ACX_TX_QUEUE_CFG, ret = wl1251_cmd_configure(wl, ACX_TX_QUEUE_CFG,
config, sizeof(*config)); config, sizeof(*config));
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -567,7 +567,7 @@ out:
return ret; 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; 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), wl->data_path = kzalloc(sizeof(struct acx_data_path_params_resp),
GFP_KERNEL); GFP_KERNEL);
if (!wl->data_path) { if (!wl->data_path) {
wl12xx_error("Couldnt allocate data path parameters"); wl1251_error("Couldnt allocate data path parameters");
return -ENOMEM; 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) { if (ret < 0) {
kfree(wl->data_path); kfree(wl->data_path);
wl->data_path = NULL; wl->data_path = NULL;
@ -589,17 +589,17 @@ static int wl1251_hw_init_data_path_config(struct wl12xx *wl)
return 0; 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; struct wl1251_acx_mem_map *wl_mem_map;
int ret; int ret;
ret = wl12xx_hw_init_hwenc_config(wl); ret = wl1251_hw_init_hwenc_config(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
/* Template settings */ /* Template settings */
ret = wl12xx_hw_init_templates_config(wl); ret = wl1251_hw_init_templates_config(wl);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -614,7 +614,7 @@ static int wl1251_hw_init(struct wl12xx *wl)
goto out_free_memmap; goto out_free_memmap;
/* RX config */ /* RX config */
ret = wl12xx_hw_init_rx_config(wl, ret = wl1251_hw_init_rx_config(wl,
RX_CFG_PROMISCUOUS | RX_CFG_TSF, RX_CFG_PROMISCUOUS | RX_CFG_TSF,
RX_FILTER_OPTION_DEF); RX_FILTER_OPTION_DEF);
/* RX_CONFIG_OPTION_ANY_DST_ANY_BSS, /* RX_CONFIG_OPTION_ANY_DST_ANY_BSS,
@ -628,42 +628,42 @@ static int wl1251_hw_init(struct wl12xx *wl)
goto out_free_data_path; goto out_free_data_path;
/* PHY layer config */ /* PHY layer config */
ret = wl12xx_hw_init_phy_config(wl); ret = wl1251_hw_init_phy_config(wl);
if (ret < 0) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
/* Beacon filtering */ /* Beacon filtering */
ret = wl12xx_hw_init_beacon_filter(wl); ret = wl1251_hw_init_beacon_filter(wl);
if (ret < 0) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
/* Bluetooth WLAN coexistence */ /* Bluetooth WLAN coexistence */
ret = wl12xx_hw_init_pta(wl); ret = wl1251_hw_init_pta(wl);
if (ret < 0) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
/* Energy detection */ /* Energy detection */
ret = wl12xx_hw_init_energy_detection(wl); ret = wl1251_hw_init_energy_detection(wl);
if (ret < 0) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
/* Beacons and boradcast settings */ /* Beacons and boradcast settings */
ret = wl12xx_hw_init_beacon_broadcast(wl); ret = wl1251_hw_init_beacon_broadcast(wl);
if (ret < 0) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
/* Enable 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) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
/* Default power state */ /* Default power state */
ret = wl12xx_hw_init_power_auth(wl); ret = wl1251_hw_init_power_auth(wl);
if (ret < 0) if (ret < 0)
goto out_free_data_path; goto out_free_data_path;
wl_mem_map = wl->target_mem_map; 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_mem_map->num_tx_mem_blocks,
wl->data_path->tx_control_addr, wl->data_path->tx_control_addr,
wl_mem_map->num_rx_mem_blocks, wl_mem_map->num_rx_mem_blocks,
@ -680,7 +680,7 @@ static int wl1251_hw_init(struct wl12xx *wl)
return ret; return ret;
} }
static int wl1251_plt_init(struct wl12xx *wl) static int wl1251_plt_init(struct wl1251 *wl)
{ {
int ret; int ret;
@ -688,14 +688,14 @@ static int wl1251_plt_init(struct wl12xx *wl)
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_cmd_data_path(wl, wl->channel, 1); ret = wl1251_cmd_data_path(wl, wl->channel, 1);
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; 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? */ /* FIXME: Is it better to use strncpy here or is this ok? */
wl->chip.fw_filename = WL1251_FW_NAME; 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 * Copyright (C) 2008 Nokia Corporation
* *
@ -34,7 +34,7 @@
#define WL1251_POWER_ON_SLEEP 10 /* in miliseconds */ #define WL1251_POWER_ON_SLEEP 10 /* in miliseconds */
void wl1251_setup(struct wl12xx *wl); void wl1251_setup(struct wl1251 *wl);
struct wl1251_acx_memory { 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 * Copyright (C) 2008 Nokia Corporation
* *
@ -25,22 +25,22 @@
#include "wl1251_ps.h" #include "wl1251_ps.h"
#include "wl1251_spi.h" #include "wl1251_spi.h"
#define WL12XX_WAKEUP_TIMEOUT 2000 #define WL1251_WAKEUP_TIMEOUT 2000
/* Routines to toggle sleep mode while in ELP */ /* 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) if (wl->elp || !wl->psm)
return; 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; wl->elp = true;
} }
int wl12xx_ps_elp_wakeup(struct wl12xx *wl) int wl1251_ps_elp_wakeup(struct wl1251 *wl)
{ {
unsigned long timeout; unsigned long timeout;
u32 elp_reg; u32 elp_reg;
@ -48,13 +48,13 @@ int wl12xx_ps_elp_wakeup(struct wl12xx *wl)
if (!wl->elp) if (!wl->elp)
return 0; 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 * 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)) { while (!(elp_reg & ELPCTRL_WLAN_READY)) {
if (time_after(jiffies, timeout)) { if (time_after(jiffies, timeout)) {
wl12xx_error("elp wakeup timeout"); wl1251_error("elp wakeup timeout");
return -ETIMEDOUT; return -ETIMEDOUT;
} }
msleep(1); 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(jiffies) -
(jiffies_to_msecs(timeout) - WL12XX_WAKEUP_TIMEOUT)); (jiffies_to_msecs(timeout) - WL1251_WAKEUP_TIMEOUT));
wl->elp = false; wl->elp = false;
return 0; 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; int ret;
if (enable) { 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) if (ret < 0)
return ret; return ret;
wl12xx_ps_elp_sleep(wl); wl1251_ps_elp_sleep(wl);
} else { } else {
wl12xx_debug(DEBUG_PSM, "sleep auth cam"); wl1251_debug(DEBUG_PSM, "sleep auth cam");
/* /*
* When the target is in ELP, we can only * 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. * 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) if (ret < 0)
return ret; return ret;
} }
@ -110,18 +110,18 @@ static int wl12xx_ps_set_elp(struct wl12xx *wl, bool enable)
return 0; 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; int ret;
switch (mode) { switch (mode) {
case STATION_POWER_SAVE_MODE: case STATION_POWER_SAVE_MODE:
wl12xx_debug(DEBUG_PSM, "entering psm"); wl1251_debug(DEBUG_PSM, "entering psm");
ret = wl12xx_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE); ret = wl1251_cmd_ps_mode(wl, STATION_POWER_SAVE_MODE);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_ps_set_elp(wl, true); ret = wl1251_ps_set_elp(wl, true);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -129,12 +129,12 @@ int wl12xx_ps_set_mode(struct wl12xx *wl, enum wl12xx_cmd_ps_mode mode)
break; break;
case STATION_ACTIVE_MODE: case STATION_ACTIVE_MODE:
default: default:
wl12xx_debug(DEBUG_PSM, "leaving psm"); wl1251_debug(DEBUG_PSM, "leaving psm");
ret = wl12xx_ps_set_elp(wl, false); ret = wl1251_ps_set_elp(wl, false);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = wl12xx_cmd_ps_mode(wl, STATION_ACTIVE_MODE); ret = wl1251_cmd_ps_mode(wl, STATION_ACTIVE_MODE);
if (ret < 0) if (ret < 0)
return ret; return ret;

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

@ -1,8 +1,8 @@
#ifndef __WL12XX_PS_H__ #ifndef __WL1251_PS_H__
#define __WL12XX_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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -28,9 +28,9 @@
#include "wl1251.h" #include "wl1251.h"
#include "wl1251_acx.h" #include "wl1251_acx.h"
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);
void wl12xx_ps_elp_sleep(struct wl12xx *wl); void wl1251_ps_elp_sleep(struct wl1251 *wl);
int wl12xx_ps_elp_wakeup(struct wl12xx *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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -31,8 +31,8 @@
#include "wl1251_rx.h" #include "wl1251_rx.h"
#include "wl1251_acx.h" #include "wl1251_acx.h"
static void wl12xx_rx_header(struct wl12xx *wl, static void wl1251_rx_header(struct wl1251 *wl,
struct wl12xx_rx_descriptor *desc) struct wl1251_rx_descriptor *desc)
{ {
u32 rx_packet_ring_addr; u32 rx_packet_ring_addr;
@ -40,11 +40,11 @@ static void wl12xx_rx_header(struct wl12xx *wl,
if (wl->rx_current_buffer) if (wl->rx_current_buffer)
rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size; 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, static void wl1251_rx_status(struct wl1251 *wl,
struct wl12xx_rx_descriptor *desc, struct wl1251_rx_descriptor *desc,
struct ieee80211_rx_status *status, struct ieee80211_rx_status *status,
u8 beacon) 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. * this one must be atomic, while our SPI routines can sleep.
*/ */
if ((wl->bss_type == BSS_TYPE_IBSS) && beacon) { 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) if (ret == 0)
status->mactime = mactime; status->mactime = mactime;
} }
status->signal = desc->rssi; status->signal = desc->rssi;
status->qual = (desc->rssi - WL12XX_RX_MIN_RSSI) * 100 / status->qual = (desc->rssi - WL1251_RX_MIN_RSSI) * 100 /
(WL12XX_RX_MAX_RSSI - WL12XX_RX_MIN_RSSI); (WL1251_RX_MAX_RSSI - WL1251_RX_MIN_RSSI);
status->qual = min(status->qual, 100); status->qual = min(status->qual, 100);
status->qual = max(status->qual, 0); status->qual = max(status->qual, 0);
@ -103,8 +103,8 @@ static void wl12xx_rx_status(struct wl12xx *wl,
/* FIXME: set status->rate_idx */ /* FIXME: set status->rate_idx */
} }
static void wl12xx_rx_body(struct wl12xx *wl, static void wl1251_rx_body(struct wl1251 *wl,
struct wl12xx_rx_descriptor *desc) struct wl1251_rx_descriptor *desc)
{ {
struct sk_buff *skb; struct sk_buff *skb;
struct ieee80211_rx_status status; struct ieee80211_rx_status status;
@ -112,12 +112,12 @@ static void wl12xx_rx_body(struct wl12xx *wl,
u16 length, *fc; u16 length, *fc;
u32 curr_id, last_id_inc, rx_packet_ring_addr; 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; 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); last_id_inc = (wl->rx_last_id + 1) % (RX_MAX_PACKET_ID + 1);
if (last_id_inc != curr_id) { 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); curr_id, last_id_inc);
wl->rx_last_id = curr_id; wl->rx_last_id = curr_id;
} else { } else {
@ -125,18 +125,18 @@ static void wl12xx_rx_body(struct wl12xx *wl,
} }
rx_packet_ring_addr = wl->data_path->rx_packet_ring_addr + 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) if (wl->rx_current_buffer)
rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size; rx_packet_ring_addr += wl->data_path->rx_packet_ring_chunk_size;
skb = dev_alloc_skb(length); skb = dev_alloc_skb(length);
if (!skb) { if (!skb) {
wl12xx_error("Couldn't allocate RX frame"); wl1251_error("Couldn't allocate RX frame");
return; return;
} }
rx_buffer = skb_put(skb, length); 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 */ /* The actual lenght doesn't include the target's alignment */
skb->len = desc->length - PLCP_HEADER_LENGTH; 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) if ((*fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON)
beacon = 1; 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" : ""); beacon ? "beacon" : "");
ieee80211_rx(wl->hw, skb, &status); 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; u32 data, addr;
@ -166,30 +166,30 @@ static void wl12xx_rx_ack(struct wl12xx *wl)
data = INTR_TRIG_RX_PROC0; data = INTR_TRIG_RX_PROC0;
} }
wl12xx_reg_write32(wl, addr, data); wl1251_reg_write32(wl, addr, data);
/* Toggle buffer ring */ /* Toggle buffer ring */
wl->rx_current_buffer = !wl->rx_current_buffer; 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; return;
rx_desc = wl->rx_descriptor; rx_desc = wl->rx_descriptor;
/* We first read the frame's header */ /* 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 */ /* 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 */ /* Finally, we need to ACK the RX */
wl12xx_rx_ack(wl); wl1251_rx_ack(wl);
return; 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -22,8 +22,8 @@
* *
*/ */
#ifndef __WL12XX_RX_H__ #ifndef __WL1251_RX_H__
#define __WL12XX_RX_H__ #define __WL1251_RX_H__
#include <linux/bitops.h> #include <linux/bitops.h>
@ -45,12 +45,12 @@
* 4) The target prepares the next RX packet. * 4) The target prepares the next RX packet.
*/ */
#define WL12XX_RX_MAX_RSSI -30 #define WL1251_RX_MAX_RSSI -30
#define WL12XX_RX_MIN_RSSI -95 #define WL1251_RX_MIN_RSSI -95
#define WL12XX_RX_ALIGN_TO 4 #define WL1251_RX_ALIGN_TO 4
#define WL12XX_RX_ALIGN(len) (((len) + WL12XX_RX_ALIGN_TO - 1) & \ #define WL1251_RX_ALIGN(len) (((len) + WL1251_RX_ALIGN_TO - 1) & \
~(WL12XX_RX_ALIGN_TO - 1)) ~(WL1251_RX_ALIGN_TO - 1))
#define SHORT_PREAMBLE_BIT BIT(0) #define SHORT_PREAMBLE_BIT BIT(0)
#define OFDM_RATE_BIT BIT(6) #define OFDM_RATE_BIT BIT(6)
@ -74,7 +74,7 @@
#define RX_DESC_MIC_FAIL 0x2000 #define RX_DESC_MIC_FAIL 0x2000
#define RX_DESC_DECRYPT_FAIL 0x4000 #define RX_DESC_DECRYPT_FAIL 0x4000
struct wl12xx_rx_descriptor { struct wl1251_rx_descriptor {
u32 timestamp; /* In microseconds */ u32 timestamp; /* In microseconds */
u16 length; /* Paylod length, including headers */ u16 length; /* Paylod length, including headers */
u16 flags; u16 flags;
@ -119,6 +119,6 @@ struct wl12xx_rx_descriptor {
u8 snr; /* in dB */ u8 snr; /* in dB */
} __attribute__ ((packed)); } __attribute__ ((packed));
void wl12xx_rx(struct wl12xx *wl); void wl1251_rx(struct wl1251 *wl);
#endif #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 * Copyright (C) 2008 Nokia Corporation
* *
@ -26,11 +26,10 @@
#include <linux/spi/spi.h> #include <linux/spi/spi.h>
#include "wl1251.h" #include "wl1251.h"
#include "wl12xx_80211.h"
#include "reg.h" #include "reg.h"
#include "wl1251_spi.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 /* 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 * 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) { if (addr < REGISTERS_BASE) {
/* Make sure we don't go over the table */ /* Make sure we don't go over the table */
if (addr >= ACX_REG_TABLE_LEN) { if (addr >= ACX_REG_TABLE_LEN) {
wl12xx_error("address out of range (%d)", addr); wl1251_error("address out of range (%d)", addr);
return -EINVAL; return -EINVAL;
} }
addr = wl->chip.acx_reg_table[addr]; 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; 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; 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; u8 *cmd;
struct spi_transfer t; struct spi_transfer t;
@ -61,7 +60,7 @@ void wl12xx_spi_reset(struct wl12xx *wl)
cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL); cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
if (!cmd) { if (!cmd) {
wl12xx_error("could not allocate cmd for spi reset"); wl1251_error("could not allocate cmd for spi reset");
return; return;
} }
@ -76,10 +75,10 @@ void wl12xx_spi_reset(struct wl12xx *wl)
spi_sync(wl->spi, &m); 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; u8 crc[WSPI_INIT_CMD_CRC_LEN], *cmd;
struct spi_transfer t; struct spi_transfer t;
@ -87,7 +86,7 @@ void wl12xx_spi_init(struct wl12xx *wl)
cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL); cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
if (!cmd) { if (!cmd) {
wl12xx_error("could not allocate cmd for spi init"); wl1251_error("could not allocate cmd for spi init");
return; return;
} }
@ -130,7 +129,7 @@ void wl12xx_spi_init(struct wl12xx *wl)
spi_sync(wl->spi, &m); 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 /* 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 mem_start, u32 mem_size,
u32 reg_start, u32 reg_size) u32 reg_start, u32 reg_size)
{ {
struct wl12xx_partition *partition; struct wl1251_partition *partition;
struct spi_transfer t; struct spi_transfer t;
struct spi_message m; struct spi_message m;
size_t len, cmd_len; size_t len, cmd_len;
u32 *cmd; u32 *cmd;
int addr; 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); cmd = kzalloc(cmd_len, GFP_KERNEL);
if (!cmd) if (!cmd)
return -ENOMEM; return -ENOMEM;
@ -185,28 +184,28 @@ int wl12xx_set_partition(struct wl12xx *wl,
spi_message_init(&m); spi_message_init(&m);
memset(&t, 0, sizeof(t)); memset(&t, 0, sizeof(t));
partition = (struct wl12xx_partition *) (cmd + 1); partition = (struct wl1251_partition *) (cmd + 1);
addr = HW_ACCESS_PART0_SIZE_ADDR; addr = HW_ACCESS_PART0_SIZE_ADDR;
len = 2 * sizeof(struct wl12xx_partition); len = 2 * sizeof(struct wl1251_partition);
*cmd |= WSPI_CMD_WRITE; *cmd |= WSPI_CMD_WRITE;
*cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH; *cmd |= (len << WSPI_CMD_BYTE_LENGTH_OFFSET) & WSPI_CMD_BYTE_LENGTH;
*cmd |= addr & WSPI_CMD_BYTE_ADDR; *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); 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); reg_start, reg_size);
/* Make sure that the two partitions together don't exceed the /* Make sure that the two partitions together don't exceed the
* address range */ * address range */
if ((mem_size + reg_size) > HW_ACCESS_MEMORY_MAX_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]."); " address range. Truncating partition[0].");
mem_size = HW_ACCESS_MEMORY_MAX_RANGE - reg_size; 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); 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); reg_start, reg_size);
} }
@ -214,23 +213,23 @@ int wl12xx_set_partition(struct wl12xx *wl,
((mem_start + mem_size) > reg_start)) { ((mem_start + mem_size) > reg_start)) {
/* Guarantee that the memory partition doesn't overlap the /* Guarantee that the memory partition doesn't overlap the
* registers partition */ * registers partition */
wl12xx_debug(DEBUG_SPI, "End of partition[0] is " wl1251_debug(DEBUG_SPI, "End of partition[0] is "
"overlapping partition[1]. Adjusted."); "overlapping partition[1]. Adjusted.");
mem_size = reg_start - mem_start; 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); 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); reg_start, reg_size);
} else if ((reg_start < mem_start) && } else if ((reg_start < mem_start) &&
((reg_start + reg_size) > mem_start)) { ((reg_start + reg_size) > mem_start)) {
/* Guarantee that the register partition doesn't overlap the /* Guarantee that the register partition doesn't overlap the
* memory partition */ * memory partition */
wl12xx_debug(DEBUG_SPI, "End of partition[1] is" wl1251_debug(DEBUG_SPI, "End of partition[1] is"
" overlapping partition[0]. Adjusted."); " overlapping partition[0]. Adjusted.");
reg_size = mem_start - reg_start; 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); 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); reg_start, reg_size);
} }
@ -256,7 +255,7 @@ int wl12xx_set_partition(struct wl12xx *wl,
return 0; 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) size_t len, bool fixed)
{ {
struct spi_transfer t[3]; 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 */ /* Busy and non busy words read */
t[1].rx_buf = busy_buf; 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); spi_message_add_tail(&t[1], &m);
t[2].rx_buf = buf; t[2].rx_buf = buf;
@ -295,11 +294,11 @@ void wl12xx_spi_read(struct wl12xx *wl, int addr, void *buf,
/* FIXME: check busy words */ /* FIXME: check busy words */
wl12xx_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd)); wl1251_dump(DEBUG_SPI, "spi_read cmd -> ", cmd, sizeof(*cmd));
wl12xx_dump(DEBUG_SPI, "spi_read buf <- ", buf, len); 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) size_t len, bool fixed)
{ {
struct spi_transfer t[2]; 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); spi_sync(wl->spi, &m);
wl12xx_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd)); wl1251_dump(DEBUG_SPI, "spi_write cmd -> ", cmd, sizeof(*cmd));
wl12xx_dump(DEBUG_SPI, "spi_write buf -> ", buf, len); 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) size_t len)
{ {
int physical; 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) size_t len)
{ {
int physical; 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) bool fixed)
{ {
int physical; 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) bool fixed)
{ {
int physical; 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -22,8 +22,8 @@
* *
*/ */
#ifndef __WL12XX_SPI_H__ #ifndef __WL1251_SPI_H__
#define __WL12XX_SPI_H__ #define __WL1251_SPI_H__
#include "wl1251_cmd.h" #include "wl1251_cmd.h"
#include "wl1251_acx.h" #include "wl1251_acx.h"
@ -66,50 +66,50 @@
#define WSPI_INIT_CMD_LEN 8 #define WSPI_INIT_CMD_LEN 8
#define HW_ACCESS_WSPI_FIXED_BUSY_LEN \ #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 #define HW_ACCESS_WSPI_INIT_CMD_MASK 0
/* Raw target IO, address is not translated */ /* 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); 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); size_t len, bool fixed);
/* Memory target IO, address is tranlated to partition 0 */ /* 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 wl1251_spi_mem_read(struct wl1251 *wl, int addr, void *buf, size_t len);
void wl12xx_spi_mem_write(struct wl12xx *wl, int addr, void *buf, size_t len); void wl1251_spi_mem_write(struct wl1251 *wl, int addr, void *buf, size_t len);
u32 wl12xx_mem_read32(struct wl12xx *wl, int addr); u32 wl1251_mem_read32(struct wl1251 *wl, int addr);
void wl12xx_mem_write32(struct wl12xx *wl, int addr, u32 val); void wl1251_mem_write32(struct wl1251 *wl, int addr, u32 val);
/* Registers IO */ /* 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); 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); bool fixed);
u32 wl12xx_reg_read32(struct wl12xx *wl, int addr); u32 wl1251_reg_read32(struct wl1251 *wl, int addr);
void wl12xx_reg_write32(struct wl12xx *wl, int addr, u32 val); void wl1251_reg_write32(struct wl1251 *wl, int addr, u32 val);
/* INIT and RESET words */ /* INIT and RESET words */
void wl12xx_spi_reset(struct wl12xx *wl); void wl1251_spi_reset(struct wl1251 *wl);
void wl12xx_spi_init(struct wl12xx *wl); void wl1251_spi_init(struct wl1251 *wl);
int wl12xx_set_partition(struct wl12xx *wl, int wl1251_set_partition(struct wl1251 *wl,
u32 part_start, u32 part_size, u32 part_start, u32 part_size,
u32 reg_start, u32 reg_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); sizeof(wl->buffer_32), false);
return wl->buffer_32; 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; 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); 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -31,7 +31,7 @@
#include "wl1251_tx.h" #include "wl1251_tx.h"
#include "wl1251_ps.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; 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; 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; u32 status, addr, data_out_count;
bool busy; bool busy;
addr = wl->data_path->tx_control_addr; 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; data_out_count = status & TX_STATUS_DATA_OUT_COUNT_MASK;
busy = wl1251_tx_double_buffer_busy(wl, data_out_count); 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; 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; 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; 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 ieee80211_tx_info *control)
{ {
struct tx_double_buffer_desc *tx_hdr; 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 */ /* 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 ieee80211_tx_info *control)
{ {
struct tx_double_buffer_desc *tx_hdr; 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)) { if (unlikely((long)skb->data & 0x03)) {
int offset = (4 - (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 */ /* check whether the current skb can be used */
if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) { 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); skb_reserve(skb, offset);
memmove(skb->data, src, skb->len); memmove(skb->data, src, skb->len);
} else { } else {
wl12xx_info("No handler, fixme!"); wl1251_info("No handler, fixme!");
return -EINVAL; return -EINVAL;
} }
} }
@ -235,15 +235,15 @@ static int wl1251_tx_send_packet(struct wl12xx *wl, struct sk_buff *skb,
else else
addr = wl->data_path->tx_packet_ring_addr; 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); tx_hdr->id, skb, tx_hdr->length, tx_hdr->rate);
return 0; return 0;
} }
static void wl1251_tx_trigger(struct wl12xx *wl) static void wl1251_tx_trigger(struct wl1251 *wl)
{ {
u32 data, addr; u32 data, addr;
@ -255,7 +255,7 @@ static void wl1251_tx_trigger(struct wl12xx *wl)
data = INTR_TRIG_TX_PROC0; data = INTR_TRIG_TX_PROC0;
} }
wl12xx_reg_write32(wl, addr, data); wl1251_reg_write32(wl, addr, data);
/* Bumping data in */ /* Bumping data in */
wl->data_in_count = (wl->data_in_count + 1) & 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 */ /* 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; struct ieee80211_tx_info *info;
int ret = 0; int ret = 0;
@ -274,7 +274,7 @@ static int wl1251_tx_frame(struct wl12xx *wl, struct sk_buff *skb)
if (info->control.hw_key) { if (info->control.hw_key) {
idx = info->control.hw_key->hw_key_idx; idx = info->control.hw_key->hw_key_idx;
if (unlikely(wl->default_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) if (ret < 0)
return ret; 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) 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; struct sk_buff *skb;
bool woken_up = false; bool woken_up = false;
int ret; int ret;
mutex_lock(&wl->mutex); mutex_lock(&wl->mutex);
if (unlikely(wl->state == WL12XX_STATE_OFF)) if (unlikely(wl->state == WL1251_STATE_OFF))
goto out; goto out;
while ((skb = skb_dequeue(&wl->tx_queue))) { while ((skb = skb_dequeue(&wl->tx_queue))) {
if (!woken_up) { if (!woken_up) {
ret = wl12xx_ps_elp_wakeup(wl); ret = wl1251_ps_elp_wakeup(wl);
if (ret < 0) if (ret < 0)
goto out; goto out;
woken_up = true; woken_up = true;
@ -320,7 +320,7 @@ void wl1251_tx_work(struct work_struct *work)
ret = wl1251_tx_frame(wl, skb); ret = wl1251_tx_frame(wl, skb);
if (ret == -EBUSY) { if (ret == -EBUSY) {
/* firmware buffer is full, stop queues */ /* 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"); "stop queues");
ieee80211_stop_queues(wl->hw); ieee80211_stop_queues(wl->hw);
wl->tx_queue_stopped = true; wl->tx_queue_stopped = true;
@ -334,7 +334,7 @@ void wl1251_tx_work(struct work_struct *work)
out: out:
if (woken_up) if (woken_up)
wl12xx_ps_elp_sleep(wl); wl1251_ps_elp_sleep(wl);
mutex_unlock(&wl->mutex); mutex_unlock(&wl->mutex);
} }
@ -367,7 +367,7 @@ static const char *wl1251_tx_parse_status(u8 status)
return buf; 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 tx_result *result)
{ {
struct ieee80211_tx_info *info; struct ieee80211_tx_info *info;
@ -377,7 +377,7 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
skb = wl->tx_frames[result->id]; skb = wl->tx_frames[result->id];
if (skb == NULL) { if (skb == NULL) {
wl12xx_error("SKB for packet %d is NULL", result->id); wl1251_error("SKB for packet %d is NULL", result->id);
return; return;
} }
@ -402,7 +402,7 @@ static void wl1251_tx_packet_cb(struct wl12xx *wl,
skb_pull(skb, WL1251_TKIP_IV_SPACE); 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)", " status 0x%x (%s)",
result->id, skb, result->ack_failures, result->rate, result->id, skb, result->ack_failures, result->rate,
result->status, wl1251_tx_parse_status(result->status)); 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; wl->tx_frames[result->id] = NULL;
if (wl->tx_queue_stopped) { 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); 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); ret = wl1251_tx_frame(wl, skb);
if (ret == -EBUSY) { if (ret == -EBUSY) {
/* firmware buffer is still full */ /* firmware buffer is still full */
wl12xx_debug(DEBUG_TX, "cb: fw buffer " wl1251_debug(DEBUG_TX, "cb: fw buffer "
"still full"); "still full");
skb_queue_head(&wl->tx_queue, skb); skb_queue_head(&wl->tx_queue, skb);
return; 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); ieee80211_wake_queues(wl->hw);
wl->tx_queue_stopped = false; wl->tx_queue_stopped = false;
} }
} }
/* Called upon reception of a TX complete interrupt */ /* 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; int i, result_index, num_complete = 0;
struct tx_result result[FW_TX_CMPLT_BLOCK_SIZE], *result_ptr; 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; return;
/* First we read the result */ /* 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, sizeof(result));
result_index = wl->next_tx_complete; result_index = wl->next_tx_complete;
@ -482,7 +482,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
*/ */
if (result_index > wl->next_tx_complete) { if (result_index > wl->next_tx_complete) {
/* Only 1 write is needed */ /* Only 1 write is needed */
wl12xx_spi_mem_write(wl, wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr + wl->data_path->tx_complete_addr +
(wl->next_tx_complete * (wl->next_tx_complete *
sizeof(struct tx_result)), sizeof(struct tx_result)),
@ -493,7 +493,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
} else if (result_index < wl->next_tx_complete) { } else if (result_index < wl->next_tx_complete) {
/* 2 writes are needed */ /* 2 writes are needed */
wl12xx_spi_mem_write(wl, wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr + wl->data_path->tx_complete_addr +
(wl->next_tx_complete * (wl->next_tx_complete *
sizeof(struct tx_result)), sizeof(struct tx_result)),
@ -502,7 +502,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
wl->next_tx_complete) * wl->next_tx_complete) *
sizeof(struct tx_result)); sizeof(struct tx_result));
wl12xx_spi_mem_write(wl, wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr, wl->data_path->tx_complete_addr,
result, result,
(num_complete - (num_complete -
@ -512,7 +512,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
} else { } else {
/* We have to write the whole array */ /* We have to write the whole array */
wl12xx_spi_mem_write(wl, wl1251_spi_mem_write(wl,
wl->data_path->tx_complete_addr, wl->data_path->tx_complete_addr,
result, result,
FW_TX_CMPLT_BLOCK_SIZE * FW_TX_CMPLT_BLOCK_SIZE *
@ -525,7 +525,7 @@ void wl1251_tx_complete(struct wl12xx *wl)
} }
/* caller must hold wl->mutex */ /* caller must hold wl->mutex */
void wl1251_tx_flush(struct wl12xx *wl) void wl1251_tx_flush(struct wl1251 *wl)
{ {
int i; int i;
struct sk_buff *skb; struct sk_buff *skb;
@ -537,7 +537,7 @@ void wl1251_tx_flush(struct wl12xx *wl)
while ((skb = skb_dequeue(&wl->tx_queue))) { while ((skb = skb_dequeue(&wl->tx_queue))) {
info = IEEE80211_SKB_CB(skb); 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)) if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS))
continue; 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) 1998-2007 Texas Instruments Incorporated
* Copyright (C) 2008 Nokia Corporation * Copyright (C) 2008 Nokia Corporation
@ -210,7 +210,7 @@ struct tx_result {
} __attribute__ ((packed)); } __attribute__ ((packed));
void wl1251_tx_work(struct work_struct *work); void wl1251_tx_work(struct work_struct *work);
void wl1251_tx_complete(struct wl12xx *wl); void wl1251_tx_complete(struct wl1251 *wl);
void wl1251_tx_flush(struct wl12xx *wl); void wl1251_tx_flush(struct wl1251 *wl);
#endif #endif