renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-29 23:53:55 +08:00
Code

rt2x00: use helper to check capability/requirement

Browse Source 
Use rt2x00_has_cap_flag macro to check rt2x00dev->cap_flags.

Signed-off-by: Fred Chou <fred.chou.nd@gmail.com>
Acked-by: Stanislaw Gruszka <sgruszka@redhat.com>
Signed-off-by: Kalle Valo <kvalo@codeaurora.org>
This commit is contained in:
Fred Chou 2014-12-26 16:19:18 +08:00 committed by Kalle Valo
parent c20e7789be
commit b9d305cc47
6 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/net/wireless/rt2x00/rt2x00config.c
View File

@ -240,7 +240,7 @@ void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
rt2x00dev->rf_channel = libconf.rf.channel; rt2x00dev->rf_channel = libconf.rf.channel;
} }
if (test_bit(REQUIRE_PS_AUTOWAKE, &rt2x00dev->cap_flags) && if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_PS_AUTOWAKE) &&
(ieee80211_flags & IEEE80211_CONF_CHANGE_PS)) (ieee80211_flags & IEEE80211_CONF_CHANGE_PS))
cancel_delayed_work_sync(&rt2x00dev->autowakeup_work); cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
@ -257,7 +257,7 @@ void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
rt2x00link_reset_tuner(rt2x00dev, false); rt2x00link_reset_tuner(rt2x00dev, false);
if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) && if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
test_bit(REQUIRE_PS_AUTOWAKE, &rt2x00dev->cap_flags) && rt2x00_has_cap_flag(rt2x00dev, REQUIRE_PS_AUTOWAKE) &&
(ieee80211_flags & IEEE80211_CONF_CHANGE_PS) && (ieee80211_flags & IEEE80211_CONF_CHANGE_PS) &&
(conf->flags & IEEE80211_CONF_PS)) { (conf->flags & IEEE80211_CONF_PS)) {
beacon_diff = (long)jiffies - (long)rt2x00dev->last_beacon; beacon_diff = (long)jiffies - (long)rt2x00dev->last_beacon;

18
drivers/net/wireless/rt2x00/rt2x00dev.c
View File

@ -351,7 +351,7 @@ void rt2x00lib_txdone(struct queue_entry *entry,
/* /*
* Remove L2 padding which was added during * Remove L2 padding which was added during
*/ */
if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
rt2x00queue_remove_l2pad(entry->skb, header_length); rt2x00queue_remove_l2pad(entry->skb, header_length);
/* /*
@ -460,7 +460,7 @@ void rt2x00lib_txdone(struct queue_entry *entry,
* send the status report back. * send the status report back.
*/ */
if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) { if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
if (test_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TASKLET_CONTEXT))
ieee80211_tx_status(rt2x00dev->hw, entry->skb); ieee80211_tx_status(rt2x00dev->hw, entry->skb);
else else
ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb); ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
@ -1056,9 +1056,9 @@ static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
/* /*
* Take TX headroom required for alignment into account. * Take TX headroom required for alignment into account.
*/ */
if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE; rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
else if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags)) else if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA))
rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE; rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
/* /*
@ -1069,7 +1069,7 @@ static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
/* /*
* Allocate tx status FIFO for driver use. * Allocate tx status FIFO for driver use.
*/ */
if (test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags)) { if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO)) {
/* /*
* Allocate the txstatus fifo. In the worst case the tx * Allocate the txstatus fifo. In the worst case the tx
* status fifo has to hold the tx status of all entries * status fifo has to hold the tx status of all entries
@ -1131,7 +1131,7 @@ static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
/* /*
* Stop rfkill polling. * Stop rfkill polling.
*/ */
if (test_bit(REQUIRE_DELAYED_RFKILL, &rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
rt2x00rfkill_unregister(rt2x00dev); rt2x00rfkill_unregister(rt2x00dev);
/* /*
@ -1173,7 +1173,7 @@ static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
/* /*
* Start rfkill polling. * Start rfkill polling.
*/ */
if (test_bit(REQUIRE_DELAYED_RFKILL, &rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
rt2x00rfkill_register(rt2x00dev); rt2x00rfkill_register(rt2x00dev);
return 0; return 0;
@ -1389,7 +1389,7 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
/* /*
* Start rfkill polling. * Start rfkill polling.
*/ */
if (!test_bit(REQUIRE_DELAYED_RFKILL, &rt2x00dev->cap_flags)) if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
rt2x00rfkill_register(rt2x00dev); rt2x00rfkill_register(rt2x00dev);
return 0; return 0;
@ -1408,7 +1408,7 @@ void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
/* /*
* Stop rfkill polling. * Stop rfkill polling.
*/ */
if (!test_bit(REQUIRE_DELAYED_RFKILL, &rt2x00dev->cap_flags)) if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
rt2x00rfkill_unregister(rt2x00dev); rt2x00rfkill_unregister(rt2x00dev);
/* /*

2
drivers/net/wireless/rt2x00/rt2x00firmware.c
View File

@ -96,7 +96,7 @@ int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev)
{ {
int retval; int retval;
if (!test_bit(REQUIRE_FIRMWARE, &rt2x00dev->cap_flags)) if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_FIRMWARE))
return 0; return 0;
if (!rt2x00dev->fw) { if (!rt2x00dev->fw) {

2
drivers/net/wireless/rt2x00/rt2x00mac.c
View File

@ -119,7 +119,7 @@ void rt2x00mac_tx(struct ieee80211_hw *hw,
* Use the ATIM queue if appropriate and present. * Use the ATIM queue if appropriate and present.
*/ */
if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM && if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM &&
test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags)) rt2x00_has_cap_flag(rt2x00dev, REQUIRE_ATIM_QUEUE))
qid = QID_ATIM; qid = QID_ATIM;
queue = rt2x00queue_get_tx_queue(rt2x00dev, qid); queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);

18
drivers/net/wireless/rt2x00/rt2x00queue.c
View File

@ -85,7 +85,7 @@ struct sk_buff *rt2x00queue_alloc_rxskb(struct queue_entry *entry, gfp_t gfp)
memset(skbdesc, 0, sizeof(*skbdesc)); memset(skbdesc, 0, sizeof(*skbdesc));
skbdesc->entry = entry; skbdesc->entry = entry;
if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags)) { if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA)) {
dma_addr_t skb_dma; dma_addr_t skb_dma;
skb_dma = dma_map_single(rt2x00dev->dev, skb->data, skb->len, skb_dma = dma_map_single(rt2x00dev->dev, skb->data, skb->len,
@ -198,7 +198,7 @@ static void rt2x00queue_create_tx_descriptor_seq(struct rt2x00_dev *rt2x00dev,
__set_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags); __set_bit(ENTRY_TXD_GENERATE_SEQ, &txdesc->flags);
if (!test_bit(REQUIRE_SW_SEQNO, &rt2x00dev->cap_flags)) { if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_SW_SEQNO)) {
/* /*
* rt2800 has a H/W (or F/W) bug, device incorrectly increase * rt2800 has a H/W (or F/W) bug, device incorrectly increase
* seqno on retransmited data (non-QOS) frames. To workaround * seqno on retransmited data (non-QOS) frames. To workaround
@ -484,7 +484,7 @@ static void rt2x00queue_create_tx_descriptor(struct rt2x00_dev *rt2x00dev,
rt2x00crypto_create_tx_descriptor(rt2x00dev, skb, txdesc); rt2x00crypto_create_tx_descriptor(rt2x00dev, skb, txdesc);
rt2x00queue_create_tx_descriptor_seq(rt2x00dev, skb, txdesc); rt2x00queue_create_tx_descriptor_seq(rt2x00dev, skb, txdesc);
if (test_bit(REQUIRE_HT_TX_DESC, &rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_HT_TX_DESC))
rt2x00queue_create_tx_descriptor_ht(rt2x00dev, skb, txdesc, rt2x00queue_create_tx_descriptor_ht(rt2x00dev, skb, txdesc,
sta, hwrate); sta, hwrate);
else else
@ -526,7 +526,7 @@ static int rt2x00queue_write_tx_data(struct queue_entry *entry,
/* /*
* Map the skb to DMA. * Map the skb to DMA.
*/ */
if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags) && if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA) &&
rt2x00queue_map_txskb(entry)) rt2x00queue_map_txskb(entry))
return -ENOMEM; return -ENOMEM;
@ -646,7 +646,7 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
*/ */
if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc.flags) && if (test_bit(ENTRY_TXD_ENCRYPT, &txdesc.flags) &&
!test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc.flags)) { !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc.flags)) {
if (test_bit(REQUIRE_COPY_IV, &queue->rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(queue->rt2x00dev, REQUIRE_COPY_IV))
rt2x00crypto_tx_copy_iv(skb, &txdesc); rt2x00crypto_tx_copy_iv(skb, &txdesc);
else else
rt2x00crypto_tx_remove_iv(skb, &txdesc); rt2x00crypto_tx_remove_iv(skb, &txdesc);
@ -660,9 +660,9 @@ int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
* PCI and USB devices, while header alignment only is valid * PCI and USB devices, while header alignment only is valid
* for PCI devices. * for PCI devices.
*/ */
if (test_bit(REQUIRE_L2PAD, &queue->rt2x00dev->cap_flags)) if (rt2x00_has_cap_flag(queue->rt2x00dev, REQUIRE_L2PAD))
rt2x00queue_insert_l2pad(skb, txdesc.header_length); rt2x00queue_insert_l2pad(skb, txdesc.header_length);
else if (test_bit(REQUIRE_DMA, &queue->rt2x00dev->cap_flags)) else if (rt2x00_has_cap_flag(queue->rt2x00dev, REQUIRE_DMA))
rt2x00queue_align_frame(skb); rt2x00queue_align_frame(skb);
/* /*
@ -1178,7 +1178,7 @@ int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev)
if (status) if (status)
goto exit; goto exit;
if (test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags)) { if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_ATIM_QUEUE)) {
status = rt2x00queue_alloc_entries(rt2x00dev->atim); status = rt2x00queue_alloc_entries(rt2x00dev->atim);
if (status) if (status)
goto exit; goto exit;
@ -1234,7 +1234,7 @@ int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev)
struct data_queue *queue; struct data_queue *queue;
enum data_queue_qid qid; enum data_queue_qid qid;
unsigned int req_atim = unsigned int req_atim =
!!test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags); rt2x00_has_cap_flag(rt2x00dev, REQUIRE_ATIM_QUEUE);
/* /*
* We need the following queues: * We need the following queues:

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

@ -274,7 +274,7 @@ static void rt2x00usb_interrupt_txdone(struct urb *urb)
* Schedule the delayed work for reading the TX status * Schedule the delayed work for reading the TX status
* from the device. * from the device.
*/ */
if (!test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags) || if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO) ||
!kfifo_is_empty(&rt2x00dev->txstatus_fifo)) !kfifo_is_empty(&rt2x00dev->txstatus_fifo))
queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work); queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work);
} }
@ -456,7 +456,7 @@ static bool rt2x00usb_flush_entry(struct queue_entry *entry, void *data)
* Kill guardian urb (if required by driver). * Kill guardian urb (if required by driver).
*/ */
if ((entry->queue->qid == QID_BEACON) && if ((entry->queue->qid == QID_BEACON) &&
(test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags))) (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_BEACON_GUARD)))
usb_kill_urb(bcn_priv->guardian_urb); usb_kill_urb(bcn_priv->guardian_urb);
return false; return false;
@ -655,7 +655,7 @@ static int rt2x00usb_alloc_entries(struct data_queue *queue)
* then we are done. * then we are done.
*/ */
if (queue->qid != QID_BEACON || if (queue->qid != QID_BEACON ||
!test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags)) !rt2x00_has_cap_flag(rt2x00dev, REQUIRE_BEACON_GUARD))
return 0; return 0;
for (i = 0; i < queue->limit; i++) { for (i = 0; i < queue->limit; i++) {
@ -690,7 +690,7 @@ static void rt2x00usb_free_entries(struct data_queue *queue)
* then we are done. * then we are done.
*/ */
if (queue->qid != QID_BEACON || if (queue->qid != QID_BEACON ||
!test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags)) !rt2x00_has_cap_flag(rt2x00dev, REQUIRE_BEACON_GUARD))
return; return;
for (i = 0; i < queue->limit; i++) { for (i = 0; i < queue->limit; i++) {