AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity

rt2x00: Clean up USB vendor request buffer functions.

Browse Source 
There is no need to force the separation between a buffer USB vendor
request that does fit the CSR cache and one that doesn't onto the
callers. This is something that the rt2x00usb_vendor_request_buff
function can figure out by itself.
Combine the rt2x00usb_vendor_request_buff and
rt2x00usb_vendor_request_large_buff functions into a single one, as
both of them were equivalent for small buffers anyway.

Signed-off-by: Gertjan van Wingerde <gwingerde@gmail.com>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
This commit is contained in:
Gertjan van Wingerde 2010-06-03 10:51:51 +02:00 committed by Ivo van Doorn
parent a903ae004a
commit 96b61bafe2
5 changed files with 14 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
drivers/net/wireless/rt2x00/rt2500usb.c
View File

@ -345,7 +345,6 @@ static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev,
struct rt2x00lib_crypto *crypto, struct rt2x00lib_crypto *crypto,
struct ieee80211_key_conf *key) struct ieee80211_key_conf *key)
{ {
int timeout;
u32 mask; u32 mask;
u16 reg; u16 reg;
@ -367,18 +366,8 @@ static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev,
key->hw_key_idx += reg ? ffz(reg) : 0; key->hw_key_idx += reg ? ffz(reg) : 0;
/* rt2500usb_register_multiwrite(rt2x00dev, reg,
* The encryption key doesn't fit within the CSR cache, crypto->key, sizeof(crypto->key));
* this means we should allocate it separately and use
* rt2x00usb_vendor_request() to send the key to the hardware.
*/
reg = KEY_ENTRY(key->hw_key_idx);
timeout = REGISTER_TIMEOUT32(sizeof(crypto->key));
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE,
USB_VENDOR_REQUEST_OUT, reg,
crypto->key,
sizeof(crypto->key),
timeout);
/* /*
* The driver does not support the IV/EIV generation * The driver does not support the IV/EIV generation

13
drivers/net/wireless/rt2x00/rt2800usb.c
View File

@ -169,11 +169,8 @@ static int rt2800usb_load_firmware(struct rt2x00_dev *rt2x00dev,
/* /*
* Write firmware to device. * Write firmware to device.
*/ */
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, rt2800_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE,
USB_VENDOR_REQUEST_OUT, data + offset, length);
FIRMWARE_IMAGE_BASE,
data + offset, length,
REGISTER_TIMEOUT32(length));
rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0);
rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0);
@ -478,10 +475,8 @@ static void rt2800usb_write_beacon(struct queue_entry *entry,
* Write entire beacon with descriptor to register. * Write entire beacon with descriptor to register.
*/ */
beacon_base = HW_BEACON_OFFSET(entry->entry_idx); beacon_base = HW_BEACON_OFFSET(entry->entry_idx);
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, rt2800_register_multiwrite(rt2x00dev, beacon_base,
USB_VENDOR_REQUEST_OUT, beacon_base, entry->skb->data, entry->skb->len);
entry->skb->data, entry->skb->len,
REGISTER_TIMEOUT32(entry->skb->len));
/* /*
* Enable beaconing again. * Enable beaconing again.

22
drivers/net/wireless/rt2x00/rt2x00usb.c
View File

@ -112,26 +112,6 @@ int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev,
const u8 request, const u8 requesttype, const u8 request, const u8 requesttype,
const u16 offset, void *buffer, const u16 offset, void *buffer,
const u16 buffer_length, const int timeout) const u16 buffer_length, const int timeout)
{
int status;
mutex_lock(&rt2x00dev->csr_mutex);
status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
requesttype, offset, buffer,
buffer_length, timeout);
mutex_unlock(&rt2x00dev->csr_mutex);
return status;
}
EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
int rt2x00usb_vendor_request_large_buff(struct rt2x00_dev *rt2x00dev,
const u8 request, const u8 requesttype,
const u16 offset, const void *buffer,
const u16 buffer_length,
const int timeout)
{ {
int status = 0; int status = 0;
unsigned char *tb; unsigned char *tb;
@ -157,7 +137,7 @@ int rt2x00usb_vendor_request_large_buff(struct rt2x00_dev *rt2x00dev,
return status; return status;
} }
EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_large_buff); EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev, int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
const unsigned int offset, const unsigned int offset,

19
drivers/net/wireless/rt2x00/rt2x00usb.h
View File

@ -166,25 +166,6 @@ int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
const u16 offset, void *buffer, const u16 offset, void *buffer,
const u16 buffer_length, const int timeout); const u16 buffer_length, const int timeout);
/**
* rt2x00usb_vendor_request_large_buff - Send register command to device (buffered)
* @rt2x00dev: Pointer to &struct rt2x00_dev
* @request: USB vendor command (See &enum rt2x00usb_vendor_request)
* @requesttype: Request type &USB_VENDOR_REQUEST_*
* @offset: Register start offset to perform action on
* @buffer: Buffer where information will be read/written to by device
* @buffer_length: Size of &buffer
* @timeout: Operation timeout
*
* This function is used to transfer register data in blocks larger
* then CSR_CACHE_SIZE. Use for firmware upload, keys and beacons.
*/
int rt2x00usb_vendor_request_large_buff(struct rt2x00_dev *rt2x00dev,
const u8 request, const u8 requesttype,
const u16 offset, const void *buffer,
const u16 buffer_length,
const int timeout);
/** /**
* rt2x00usb_vendor_request_sw - Send single register command to device * rt2x00usb_vendor_request_sw - Send single register command to device
* @rt2x00dev: Pointer to &struct rt2x00_dev * @rt2x00dev: Pointer to &struct rt2x00_dev

32
drivers/net/wireless/rt2x00/rt73usb.c
View File

@ -270,7 +270,6 @@ static int rt73usb_config_shared_key(struct rt2x00_dev *rt2x00dev,
{ {
struct hw_key_entry key_entry; struct hw_key_entry key_entry;
struct rt2x00_field32 field; struct rt2x00_field32 field;
int timeout;
u32 mask; u32 mask;
u32 reg; u32 reg;
@ -306,12 +305,8 @@ static int rt73usb_config_shared_key(struct rt2x00_dev *rt2x00dev,
sizeof(key_entry.rx_mic)); sizeof(key_entry.rx_mic));
reg = SHARED_KEY_ENTRY(key->hw_key_idx); reg = SHARED_KEY_ENTRY(key->hw_key_idx);
timeout = REGISTER_TIMEOUT32(sizeof(key_entry)); rt2x00usb_register_multiwrite(rt2x00dev, reg,
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, &key_entry, sizeof(key_entry));
USB_VENDOR_REQUEST_OUT, reg,
&key_entry,
sizeof(key_entry),
timeout);
/* /*
* The cipher types are stored over 2 registers. * The cipher types are stored over 2 registers.
@ -372,7 +367,6 @@ static int rt73usb_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
{ {
struct hw_pairwise_ta_entry addr_entry; struct hw_pairwise_ta_entry addr_entry;
struct hw_key_entry key_entry; struct hw_key_entry key_entry;
int timeout;
u32 mask; u32 mask;
u32 reg; u32 reg;
@ -407,17 +401,11 @@ static int rt73usb_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
sizeof(key_entry.rx_mic)); sizeof(key_entry.rx_mic));
reg = PAIRWISE_KEY_ENTRY(key->hw_key_idx); reg = PAIRWISE_KEY_ENTRY(key->hw_key_idx);
timeout = REGISTER_TIMEOUT32(sizeof(key_entry)); rt2x00usb_register_multiwrite(rt2x00dev, reg,
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, &key_entry, sizeof(key_entry));
USB_VENDOR_REQUEST_OUT, reg,
&key_entry,
sizeof(key_entry),
timeout);
/* /*
* Send the address and cipher type to the hardware register. * Send the address and cipher type to the hardware register.
* This data fits within the CSR cache size, so we can use
* rt2x00usb_register_multiwrite() directly.
*/ */
memset(&addr_entry, 0, sizeof(addr_entry)); memset(&addr_entry, 0, sizeof(addr_entry));
memcpy(&addr_entry, crypto->address, ETH_ALEN); memcpy(&addr_entry, crypto->address, ETH_ALEN);
@ -1092,11 +1080,7 @@ static int rt73usb_load_firmware(struct rt2x00_dev *rt2x00dev,
/* /*
* Write firmware to device. * Write firmware to device.
*/ */
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, rt2x00usb_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE, data, len);
USB_VENDOR_REQUEST_OUT,
FIRMWARE_IMAGE_BASE,
data, len,
REGISTER_TIMEOUT32(len));
/* /*
* Send firmware request to device to load firmware, * Send firmware request to device to load firmware,
@ -1548,10 +1532,8 @@ static void rt73usb_write_beacon(struct queue_entry *entry,
* Write entire beacon with descriptor to register. * Write entire beacon with descriptor to register.
*/ */
beacon_base = HW_BEACON_OFFSET(entry->entry_idx); beacon_base = HW_BEACON_OFFSET(entry->entry_idx);
rt2x00usb_vendor_request_large_buff(rt2x00dev, USB_MULTI_WRITE, rt2x00usb_register_multiwrite(rt2x00dev, beacon_base,
USB_VENDOR_REQUEST_OUT, beacon_base, entry->skb->data, entry->skb->len);
entry->skb->data, entry->skb->len,
REGISTER_TIMEOUT32(entry->skb->len));
/* /*
* Enable beaconing again. * Enable beaconing again.