Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rx.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved.
4  *
5  * Portions of this file are derived from the ipw3945 project, as well
6  * as portions of the ieee80211 subsystem header files.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of version 2 of the GNU General Public License as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along with
18  * this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20  *
21  * The full GNU General Public License is included in this distribution in the
22  * file called LICENSE.
23  *
24  * Contact Information:
25  * Intel Linux Wireless <[email protected]>
26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27  *
28  *****************************************************************************/
29 #include <linux/sched.h>
30 #include <linux/wait.h>
31 #include <linux/gfp.h>
32 
33 #include "iwl-prph.h"
34 #include "iwl-io.h"
35 #include "internal.h"
36 #include "iwl-op-mode.h"
37 
38 /******************************************************************************
39  *
40  * RX path functions
41  *
42  ******************************************************************************/
43 
44 /*
45  * Rx theory of operation
46  *
47  * Driver allocates a circular buffer of Receive Buffer Descriptors (RBDs),
48  * each of which point to Receive Buffers to be filled by the NIC. These get
49  * used not only for Rx frames, but for any command response or notification
50  * from the NIC. The driver and NIC manage the Rx buffers by means
51  * of indexes into the circular buffer.
52  *
53  * Rx Queue Indexes
54  * The host/firmware share two index registers for managing the Rx buffers.
55  *
56  * The READ index maps to the first position that the firmware may be writing
57  * to -- the driver can read up to (but not including) this position and get
58  * good data.
59  * The READ index is managed by the firmware once the card is enabled.
60  *
61  * The WRITE index maps to the last position the driver has read from -- the
62  * position preceding WRITE is the last slot the firmware can place a packet.
63  *
64  * The queue is empty (no good data) if WRITE = READ - 1, and is full if
65  * WRITE = READ.
66  *
67  * During initialization, the host sets up the READ queue position to the first
68  * INDEX position, and WRITE to the last (READ - 1 wrapped)
69  *
70  * When the firmware places a packet in a buffer, it will advance the READ index
71  * and fire the RX interrupt. The driver can then query the READ index and
72  * process as many packets as possible, moving the WRITE index forward as it
73  * resets the Rx queue buffers with new memory.
74  *
75  * The management in the driver is as follows:
76  * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free. When
77  * iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
78  * to replenish the iwl->rxq->rx_free.
79  * + In iwl_rx_replenish (scheduled) if 'processed' != 'read' then the
80  * iwl->rxq is replenished and the READ INDEX is updated (updating the
81  * 'processed' and 'read' driver indexes as well)
82  * + A received packet is processed and handed to the kernel network stack,
83  * detached from the iwl->rxq. The driver 'processed' index is updated.
84  * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
85  * list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
86  * INDEX is not incremented and iwl->status(RX_STALLED) is set. If there
87  * were enough free buffers and RX_STALLED is set it is cleared.
88  *
89  *
90  * Driver sequence:
91  *
92  * iwl_rx_queue_alloc() Allocates rx_free
93  * iwl_rx_replenish() Replenishes rx_free list from rx_used, and calls
94  * iwl_rx_queue_restock
95  * iwl_rx_queue_restock() Moves available buffers from rx_free into Rx
96  * queue, updates firmware pointers, and updates
97  * the WRITE index. If insufficient rx_free buffers
98  * are available, schedules iwl_rx_replenish
99  *
100  * -- enable interrupts --
101  * ISR - iwl_rx() Detach iwl_rx_mem_buffers from pool up to the
102  * READ INDEX, detaching the SKB from the pool.
103  * Moves the packet buffer from queue to rx_used.
104  * Calls iwl_rx_queue_restock to refill any empty
105  * slots.
106  * ...
107  *
108  */
109 
113 static int iwl_rx_queue_space(const struct iwl_rx_queue *q)
114 {
115  int s = q->read - q->write;
116  if (s <= 0)
117  s += RX_QUEUE_SIZE;
118  /* keep some buffer to not confuse full and empty queue */
119  s -= 2;
120  if (s < 0)
121  s = 0;
122  return s;
123 }
124 
129  struct iwl_rx_queue *q)
130 {
131  unsigned long flags;
132  u32 reg;
133 
134  spin_lock_irqsave(&q->lock, flags);
135 
136  if (q->need_update == 0)
137  goto exit_unlock;
138 
139  if (trans->cfg->base_params->shadow_reg_enable) {
140  /* shadow register enabled */
141  /* Device expects a multiple of 8 */
142  q->write_actual = (q->write & ~0x7);
143  iwl_write32(trans, FH_RSCSR_CHNL0_WPTR, q->write_actual);
144  } else {
145  struct iwl_trans_pcie *trans_pcie =
147 
148  /* If power-saving is in use, make sure device is awake */
149  if (test_bit(STATUS_TPOWER_PMI, &trans_pcie->status)) {
150  reg = iwl_read32(trans, CSR_UCODE_DRV_GP1);
151 
153  IWL_DEBUG_INFO(trans,
154  "Rx queue requesting wakeup,"
155  " GP1 = 0x%x\n", reg);
156  iwl_set_bit(trans, CSR_GP_CNTRL,
158  goto exit_unlock;
159  }
160 
161  q->write_actual = (q->write & ~0x7);
163  q->write_actual);
164 
165  /* Else device is assumed to be awake */
166  } else {
167  /* Device expects a multiple of 8 */
168  q->write_actual = (q->write & ~0x7);
170  q->write_actual);
171  }
172  }
173  q->need_update = 0;
174 
175  exit_unlock:
176  spin_unlock_irqrestore(&q->lock, flags);
177 }
178 
182 static inline __le32 iwl_dma_addr2rbd_ptr(dma_addr_t dma_addr)
183 {
184  return cpu_to_le32((u32)(dma_addr >> 8));
185 }
186 
198 static void iwl_rx_queue_restock(struct iwl_trans *trans)
199 {
200  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
201  struct iwl_rx_queue *rxq = &trans_pcie->rxq;
202  struct list_head *element;
203  struct iwl_rx_mem_buffer *rxb;
204  unsigned long flags;
205 
206  /*
207  * If the device isn't enabled - not need to try to add buffers...
208  * This can happen when we stop the device and still have an interrupt
209  * pending. We stop the APM before we sync the interrupts / tasklets
210  * because we have to (see comment there). On the other hand, since
211  * the APM is stopped, we cannot access the HW (in particular not prph).
212  * So don't try to restock if the APM has been already stopped.
213  */
214  if (!test_bit(STATUS_DEVICE_ENABLED, &trans_pcie->status))
215  return;
216 
217  spin_lock_irqsave(&rxq->lock, flags);
218  while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
219  /* The overwritten rxb must be a used one */
220  rxb = rxq->queue[rxq->write];
221  BUG_ON(rxb && rxb->page);
222 
223  /* Get next free Rx buffer, remove from free list */
224  element = rxq->rx_free.next;
225  rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
226  list_del(element);
227 
228  /* Point to Rx buffer via next RBD in circular buffer */
229  rxq->bd[rxq->write] = iwl_dma_addr2rbd_ptr(rxb->page_dma);
230  rxq->queue[rxq->write] = rxb;
231  rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
232  rxq->free_count--;
233  }
234  spin_unlock_irqrestore(&rxq->lock, flags);
235  /* If the pre-allocated buffer pool is dropping low, schedule to
236  * refill it */
237  if (rxq->free_count <= RX_LOW_WATERMARK)
238  schedule_work(&trans_pcie->rx_replenish);
239 
240  /* If we've added more space for the firmware to place data, tell it.
241  * Increment device's write pointer in multiples of 8. */
242  if (rxq->write_actual != (rxq->write & ~0x7)) {
243  spin_lock_irqsave(&rxq->lock, flags);
244  rxq->need_update = 1;
245  spin_unlock_irqrestore(&rxq->lock, flags);
246  iwl_rx_queue_update_write_ptr(trans, rxq);
247  }
248 }
249 
250 /*
251  * iwl_rx_allocate - allocate a page for each used RBD
252  *
253  * A used RBD is an Rx buffer that has been given to the stack. To use it again
254  * a page must be allocated and the RBD must point to the page. This function
255  * doesn't change the HW pointer but handles the list of pages that is used by
256  * iwl_rx_queue_restock. The latter function will update the HW to use the newly
257  * allocated buffers.
258  */
259 static void iwl_rx_allocate(struct iwl_trans *trans, gfp_t priority)
260 {
261  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
262  struct iwl_rx_queue *rxq = &trans_pcie->rxq;
263  struct list_head *element;
264  struct iwl_rx_mem_buffer *rxb;
265  struct page *page;
266  unsigned long flags;
268 
269  while (1) {
270  spin_lock_irqsave(&rxq->lock, flags);
271  if (list_empty(&rxq->rx_used)) {
272  spin_unlock_irqrestore(&rxq->lock, flags);
273  return;
274  }
275  spin_unlock_irqrestore(&rxq->lock, flags);
276 
277  if (rxq->free_count > RX_LOW_WATERMARK)
278  gfp_mask |= __GFP_NOWARN;
279 
280  if (trans_pcie->rx_page_order > 0)
281  gfp_mask |= __GFP_COMP;
282 
283  /* Alloc a new receive buffer */
284  page = alloc_pages(gfp_mask, trans_pcie->rx_page_order);
285  if (!page) {
286  if (net_ratelimit())
287  IWL_DEBUG_INFO(trans, "alloc_pages failed, "
288  "order: %d\n",
289  trans_pcie->rx_page_order);
290 
291  if ((rxq->free_count <= RX_LOW_WATERMARK) &&
292  net_ratelimit())
293  IWL_CRIT(trans, "Failed to alloc_pages with %s."
294  "Only %u free buffers remaining.\n",
295  priority == GFP_ATOMIC ?
296  "GFP_ATOMIC" : "GFP_KERNEL",
297  rxq->free_count);
298  /* We don't reschedule replenish work here -- we will
299  * call the restock method and if it still needs
300  * more buffers it will schedule replenish */
301  return;
302  }
303 
304  spin_lock_irqsave(&rxq->lock, flags);
305 
306  if (list_empty(&rxq->rx_used)) {
307  spin_unlock_irqrestore(&rxq->lock, flags);
308  __free_pages(page, trans_pcie->rx_page_order);
309  return;
310  }
311  element = rxq->rx_used.next;
312  rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
313  list_del(element);
314 
315  spin_unlock_irqrestore(&rxq->lock, flags);
316 
317  BUG_ON(rxb->page);
318  rxb->page = page;
319  /* Get physical address of the RB */
320  rxb->page_dma =
321  dma_map_page(trans->dev, page, 0,
322  PAGE_SIZE << trans_pcie->rx_page_order,
324  if (dma_mapping_error(trans->dev, rxb->page_dma)) {
325  rxb->page = NULL;
326  spin_lock_irqsave(&rxq->lock, flags);
327  list_add(&rxb->list, &rxq->rx_used);
328  spin_unlock_irqrestore(&rxq->lock, flags);
329  __free_pages(page, trans_pcie->rx_page_order);
330  return;
331  }
332  /* dma address must be no more than 36 bits */
333  BUG_ON(rxb->page_dma & ~DMA_BIT_MASK(36));
334  /* and also 256 byte aligned! */
335  BUG_ON(rxb->page_dma & DMA_BIT_MASK(8));
336 
337  spin_lock_irqsave(&rxq->lock, flags);
338 
339  list_add_tail(&rxb->list, &rxq->rx_free);
340  rxq->free_count++;
341 
342  spin_unlock_irqrestore(&rxq->lock, flags);
343  }
344 }
345 
346 /*
347  * iwl_rx_replenish - Move all used buffers from rx_used to rx_free
348  *
349  * When moving to rx_free an page is allocated for the slot.
350  *
351  * Also restock the Rx queue via iwl_rx_queue_restock.
352  * This is called as a scheduled work item (except for during initialization)
353  */
354 void iwl_rx_replenish(struct iwl_trans *trans)
355 {
356  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
357  unsigned long flags;
358 
359  iwl_rx_allocate(trans, GFP_KERNEL);
360 
361  spin_lock_irqsave(&trans_pcie->irq_lock, flags);
362  iwl_rx_queue_restock(trans);
363  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
364 }
365 
366 static void iwl_rx_replenish_now(struct iwl_trans *trans)
367 {
368  iwl_rx_allocate(trans, GFP_ATOMIC);
369 
370  iwl_rx_queue_restock(trans);
371 }
372 
374 {
375  struct iwl_trans_pcie *trans_pcie =
377 
378  iwl_rx_replenish(trans_pcie->trans);
379 }
380 
381 static void iwl_rx_handle_rxbuf(struct iwl_trans *trans,
382  struct iwl_rx_mem_buffer *rxb)
383 {
384  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
385  struct iwl_rx_queue *rxq = &trans_pcie->rxq;
386  struct iwl_tx_queue *txq = &trans_pcie->txq[trans_pcie->cmd_queue];
387  unsigned long flags;
388  bool page_stolen = false;
389  int max_len = PAGE_SIZE << trans_pcie->rx_page_order;
390  u32 offset = 0;
391 
392  if (WARN_ON(!rxb))
393  return;
394 
395  dma_unmap_page(trans->dev, rxb->page_dma, max_len, DMA_FROM_DEVICE);
396 
397  while (offset + sizeof(u32) + sizeof(struct iwl_cmd_header) < max_len) {
398  struct iwl_rx_packet *pkt;
399  struct iwl_device_cmd *cmd;
400  u16 sequence;
401  bool reclaim;
402  int index, cmd_index, err, len;
403  struct iwl_rx_cmd_buffer rxcb = {
404  ._offset = offset,
405  ._page = rxb->page,
406  ._page_stolen = false,
407  .truesize = max_len,
408  };
409 
410  pkt = rxb_addr(&rxcb);
411 
413  break;
414 
415  IWL_DEBUG_RX(trans, "cmd at offset %d: %s (0x%.2x)\n",
416  rxcb._offset,
417  trans_pcie_get_cmd_string(trans_pcie, pkt->hdr.cmd),
418  pkt->hdr.cmd);
419 
421  len += sizeof(u32); /* account for status word */
422  trace_iwlwifi_dev_rx(trans->dev, pkt, len);
423 
424  /* Reclaim a command buffer only if this packet is a response
425  * to a (driver-originated) command.
426  * If the packet (e.g. Rx frame) originated from uCode,
427  * there is no command buffer to reclaim.
428  * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
429  * but apparently a few don't get set; catch them here. */
430  reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME);
431  if (reclaim) {
432  int i;
433 
434  for (i = 0; i < trans_pcie->n_no_reclaim_cmds; i++) {
435  if (trans_pcie->no_reclaim_cmds[i] ==
436  pkt->hdr.cmd) {
437  reclaim = false;
438  break;
439  }
440  }
441  }
442 
443  sequence = le16_to_cpu(pkt->hdr.sequence);
444  index = SEQ_TO_INDEX(sequence);
445  cmd_index = get_cmd_index(&txq->q, index);
446 
447  if (reclaim) {
449  ent = &txq->entries[cmd_index];
450  cmd = ent->copy_cmd;
451  WARN_ON_ONCE(!cmd && ent->meta.flags & CMD_WANT_HCMD);
452  } else {
453  cmd = NULL;
454  }
455 
456  err = iwl_op_mode_rx(trans->op_mode, &rxcb, cmd);
457 
458  if (reclaim) {
459  /* The original command isn't needed any more */
460  kfree(txq->entries[cmd_index].copy_cmd);
461  txq->entries[cmd_index].copy_cmd = NULL;
462  }
463 
464  /*
465  * After here, we should always check rxcb._page_stolen,
466  * if it is true then one of the handlers took the page.
467  */
468 
469  if (reclaim) {
470  /* Invoke any callbacks, transfer the buffer to caller,
471  * and fire off the (possibly) blocking
472  * iwl_trans_send_cmd()
473  * as we reclaim the driver command queue */
474  if (!rxcb._page_stolen)
475  iwl_tx_cmd_complete(trans, &rxcb, err);
476  else
477  IWL_WARN(trans, "Claim null rxb?\n");
478  }
479 
480  page_stolen |= rxcb._page_stolen;
481  offset += ALIGN(len, FH_RSCSR_FRAME_ALIGN);
482  }
483 
484  /* page was stolen from us -- free our reference */
485  if (page_stolen) {
486  __free_pages(rxb->page, trans_pcie->rx_page_order);
487  rxb->page = NULL;
488  }
489 
490  /* Reuse the page if possible. For notification packets and
491  * SKBs that fail to Rx correctly, add them back into the
492  * rx_free list for reuse later. */
493  spin_lock_irqsave(&rxq->lock, flags);
494  if (rxb->page != NULL) {
495  rxb->page_dma =
496  dma_map_page(trans->dev, rxb->page, 0,
497  PAGE_SIZE << trans_pcie->rx_page_order,
499  if (dma_mapping_error(trans->dev, rxb->page_dma)) {
500  /*
501  * free the page(s) as well to not break
502  * the invariant that the items on the used
503  * list have no page(s)
504  */
505  __free_pages(rxb->page, trans_pcie->rx_page_order);
506  rxb->page = NULL;
507  list_add_tail(&rxb->list, &rxq->rx_used);
508  } else {
509  list_add_tail(&rxb->list, &rxq->rx_free);
510  rxq->free_count++;
511  }
512  } else
513  list_add_tail(&rxb->list, &rxq->rx_used);
514  spin_unlock_irqrestore(&rxq->lock, flags);
515 }
516 
524 static void iwl_rx_handle(struct iwl_trans *trans)
525 {
526  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
527  struct iwl_rx_queue *rxq = &trans_pcie->rxq;
528  u32 r, i;
529  u8 fill_rx = 0;
530  u32 count = 8;
531  int total_empty;
532 
533  /* uCode's read index (stored in shared DRAM) indicates the last Rx
534  * buffer that the driver may process (last buffer filled by ucode). */
535  r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
536  i = rxq->read;
537 
538  /* Rx interrupt, but nothing sent from uCode */
539  if (i == r)
540  IWL_DEBUG_RX(trans, "HW = SW = %d\n", r);
541 
542  /* calculate total frames need to be restock after handling RX */
543  total_empty = r - rxq->write_actual;
544  if (total_empty < 0)
545  total_empty += RX_QUEUE_SIZE;
546 
547  if (total_empty > (RX_QUEUE_SIZE / 2))
548  fill_rx = 1;
549 
550  while (i != r) {
551  struct iwl_rx_mem_buffer *rxb;
552 
553  rxb = rxq->queue[i];
554  rxq->queue[i] = NULL;
555 
556  IWL_DEBUG_RX(trans, "rxbuf: HW = %d, SW = %d (%p)\n",
557  r, i, rxb);
558  iwl_rx_handle_rxbuf(trans, rxb);
559 
560  i = (i + 1) & RX_QUEUE_MASK;
561  /* If there are a lot of unused frames,
562  * restock the Rx queue so ucode wont assert. */
563  if (fill_rx) {
564  count++;
565  if (count >= 8) {
566  rxq->read = i;
567  iwl_rx_replenish_now(trans);
568  count = 0;
569  }
570  }
571  }
572 
573  /* Backtrack one entry */
574  rxq->read = i;
575  if (fill_rx)
576  iwl_rx_replenish_now(trans);
577  else
578  iwl_rx_queue_restock(trans);
579 }
580 
584 static void iwl_irq_handle_error(struct iwl_trans *trans)
585 {
586  /* W/A for WiFi/WiMAX coex and WiMAX own the RF */
587  if (trans->cfg->internal_wimax_coex &&
588  (!(iwl_read_prph(trans, APMG_CLK_CTRL_REG) &
592  struct iwl_trans_pcie *trans_pcie =
594 
595  clear_bit(STATUS_HCMD_ACTIVE, &trans_pcie->status);
596  iwl_op_mode_wimax_active(trans->op_mode);
597  wake_up(&trans->wait_command_queue);
598  return;
599  }
600 
601  iwl_dump_csr(trans);
602  iwl_dump_fh(trans, NULL);
603 
604  iwl_op_mode_nic_error(trans->op_mode);
605 }
606 
607 /* tasklet for iwlagn interrupt */
608 void iwl_irq_tasklet(struct iwl_trans *trans)
609 {
610  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
611  struct isr_statistics *isr_stats = &trans_pcie->isr_stats;
612  u32 inta = 0;
613  u32 handled = 0;
614  unsigned long flags;
615  u32 i;
616 #ifdef CONFIG_IWLWIFI_DEBUG
617  u32 inta_mask;
618 #endif
619 
620  spin_lock_irqsave(&trans_pcie->irq_lock, flags);
621 
622  /* Ack/clear/reset pending uCode interrupts.
623  * Note: Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
624  */
625  /* There is a hardware bug in the interrupt mask function that some
626  * interrupts (i.e. CSR_INT_BIT_SCD) can still be generated even if
627  * they are disabled in the CSR_INT_MASK register. Furthermore the
628  * ICT interrupt handling mechanism has another bug that might cause
629  * these unmasked interrupts fail to be detected. We workaround the
630  * hardware bugs here by ACKing all the possible interrupts so that
631  * interrupt coalescing can still be achieved.
632  */
633  iwl_write32(trans, CSR_INT,
634  trans_pcie->inta | ~trans_pcie->inta_mask);
635 
636  inta = trans_pcie->inta;
637 
638 #ifdef CONFIG_IWLWIFI_DEBUG
639  if (iwl_have_debug_level(IWL_DL_ISR)) {
640  /* just for debug */
641  inta_mask = iwl_read32(trans, CSR_INT_MASK);
642  IWL_DEBUG_ISR(trans, "inta 0x%08x, enabled 0x%08x\n",
643  inta, inta_mask);
644  }
645 #endif
646 
647  /* saved interrupt in inta variable now we can reset trans_pcie->inta */
648  trans_pcie->inta = 0;
649 
650  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
651 
652  /* Now service all interrupt bits discovered above. */
653  if (inta & CSR_INT_BIT_HW_ERR) {
654  IWL_ERR(trans, "Hardware error detected. Restarting.\n");
655 
656  /* Tell the device to stop sending interrupts */
657  iwl_disable_interrupts(trans);
658 
659  isr_stats->hw++;
660  iwl_irq_handle_error(trans);
661 
662  handled |= CSR_INT_BIT_HW_ERR;
663 
664  return;
665  }
666 
667 #ifdef CONFIG_IWLWIFI_DEBUG
668  if (iwl_have_debug_level(IWL_DL_ISR)) {
669  /* NIC fires this, but we don't use it, redundant with WAKEUP */
670  if (inta & CSR_INT_BIT_SCD) {
671  IWL_DEBUG_ISR(trans, "Scheduler finished to transmit "
672  "the frame/frames.\n");
673  isr_stats->sch++;
674  }
675 
676  /* Alive notification via Rx interrupt will do the real work */
677  if (inta & CSR_INT_BIT_ALIVE) {
678  IWL_DEBUG_ISR(trans, "Alive interrupt\n");
679  isr_stats->alive++;
680  }
681  }
682 #endif
683  /* Safely ignore these bits for debug checks below */
684  inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
685 
686  /* HW RF KILL switch toggled */
687  if (inta & CSR_INT_BIT_RF_KILL) {
688  bool hw_rfkill;
689 
690  hw_rfkill = iwl_is_rfkill_set(trans);
691  IWL_WARN(trans, "RF_KILL bit toggled to %s.\n",
692  hw_rfkill ? "disable radio" : "enable radio");
693 
694  isr_stats->rfkill++;
695 
696  iwl_op_mode_hw_rf_kill(trans->op_mode, hw_rfkill);
697 
698  handled |= CSR_INT_BIT_RF_KILL;
699  }
700 
701  /* Chip got too hot and stopped itself */
702  if (inta & CSR_INT_BIT_CT_KILL) {
703  IWL_ERR(trans, "Microcode CT kill error detected.\n");
704  isr_stats->ctkill++;
705  handled |= CSR_INT_BIT_CT_KILL;
706  }
707 
708  /* Error detected by uCode */
709  if (inta & CSR_INT_BIT_SW_ERR) {
710  IWL_ERR(trans, "Microcode SW error detected. "
711  " Restarting 0x%X.\n", inta);
712  isr_stats->sw++;
713  iwl_irq_handle_error(trans);
714  handled |= CSR_INT_BIT_SW_ERR;
715  }
716 
717  /* uCode wakes up after power-down sleep */
718  if (inta & CSR_INT_BIT_WAKEUP) {
719  IWL_DEBUG_ISR(trans, "Wakeup interrupt\n");
720  iwl_rx_queue_update_write_ptr(trans, &trans_pcie->rxq);
721  for (i = 0; i < trans->cfg->base_params->num_of_queues; i++)
723  &trans_pcie->txq[i]);
724 
725  isr_stats->wakeup++;
726 
727  handled |= CSR_INT_BIT_WAKEUP;
728  }
729 
730  /* All uCode command responses, including Tx command responses,
731  * Rx "responses" (frame-received notification), and other
732  * notifications from uCode come through here*/
733  if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX |
735  IWL_DEBUG_ISR(trans, "Rx interrupt\n");
736  if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
737  handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
738  iwl_write32(trans, CSR_FH_INT_STATUS,
740  }
741  if (inta & CSR_INT_BIT_RX_PERIODIC) {
742  handled |= CSR_INT_BIT_RX_PERIODIC;
743  iwl_write32(trans,
744  CSR_INT, CSR_INT_BIT_RX_PERIODIC);
745  }
746  /* Sending RX interrupt require many steps to be done in the
747  * the device:
748  * 1- write interrupt to current index in ICT table.
749  * 2- dma RX frame.
750  * 3- update RX shared data to indicate last write index.
751  * 4- send interrupt.
752  * This could lead to RX race, driver could receive RX interrupt
753  * but the shared data changes does not reflect this;
754  * periodic interrupt will detect any dangling Rx activity.
755  */
756 
757  /* Disable periodic interrupt; we use it as just a one-shot. */
758  iwl_write8(trans, CSR_INT_PERIODIC_REG,
760 
761  iwl_rx_handle(trans);
762 
763  /*
764  * Enable periodic interrupt in 8 msec only if we received
765  * real RX interrupt (instead of just periodic int), to catch
766  * any dangling Rx interrupt. If it was just the periodic
767  * interrupt, there was no dangling Rx activity, and no need
768  * to extend the periodic interrupt; one-shot is enough.
769  */
770  if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX))
771  iwl_write8(trans, CSR_INT_PERIODIC_REG,
773 
774  isr_stats->rx++;
775  }
776 
777  /* This "Tx" DMA channel is used only for loading uCode */
778  if (inta & CSR_INT_BIT_FH_TX) {
779  iwl_write32(trans, CSR_FH_INT_STATUS, CSR_FH_INT_TX_MASK);
780  IWL_DEBUG_ISR(trans, "uCode load interrupt\n");
781  isr_stats->tx++;
782  handled |= CSR_INT_BIT_FH_TX;
783  /* Wake up uCode load routine, now that load is complete */
784  trans_pcie->ucode_write_complete = true;
785  wake_up(&trans_pcie->ucode_write_waitq);
786  }
787 
788  if (inta & ~handled) {
789  IWL_ERR(trans, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
790  isr_stats->unhandled++;
791  }
792 
793  if (inta & ~(trans_pcie->inta_mask)) {
794  IWL_WARN(trans, "Disabled INTA bits 0x%08x were pending\n",
795  inta & ~trans_pcie->inta_mask);
796  }
797 
798  /* Re-enable all interrupts */
799  /* only Re-enable if disabled by irq */
800  if (test_bit(STATUS_INT_ENABLED, &trans_pcie->status))
801  iwl_enable_interrupts(trans);
802  /* Re-enable RF_KILL if it occurred */
803  else if (handled & CSR_INT_BIT_RF_KILL)
804  iwl_enable_rfkill_int(trans);
805 }
806 
807 /******************************************************************************
808  *
809  * ICT functions
810  *
811  ******************************************************************************/
812 
813 /* a device (PCI-E) page is 4096 bytes long */
814 #define ICT_SHIFT 12
815 #define ICT_SIZE (1 << ICT_SHIFT)
816 #define ICT_COUNT (ICT_SIZE / sizeof(u32))
817 
818 /* Free dram table */
819 void iwl_free_isr_ict(struct iwl_trans *trans)
820 {
821  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
822 
823  if (trans_pcie->ict_tbl) {
825  trans_pcie->ict_tbl,
826  trans_pcie->ict_tbl_dma);
827  trans_pcie->ict_tbl = NULL;
828  trans_pcie->ict_tbl_dma = 0;
829  }
830 }
831 
832 
833 /*
834  * allocate dram shared table, it is an aligned memory
835  * block of ICT_SIZE.
836  * also reset all data related to ICT table interrupt.
837  */
838 int iwl_alloc_isr_ict(struct iwl_trans *trans)
839 {
840  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
841 
842  trans_pcie->ict_tbl =
844  &trans_pcie->ict_tbl_dma,
845  GFP_KERNEL);
846  if (!trans_pcie->ict_tbl)
847  return -ENOMEM;
848 
849  /* just an API sanity check ... it is guaranteed to be aligned */
850  if (WARN_ON(trans_pcie->ict_tbl_dma & (ICT_SIZE - 1))) {
851  iwl_free_isr_ict(trans);
852  return -EINVAL;
853  }
854 
855  IWL_DEBUG_ISR(trans, "ict dma addr %Lx\n",
856  (unsigned long long)trans_pcie->ict_tbl_dma);
857 
858  IWL_DEBUG_ISR(trans, "ict vir addr %p\n", trans_pcie->ict_tbl);
859 
860  /* reset table and index to all 0 */
861  memset(trans_pcie->ict_tbl, 0, ICT_SIZE);
862  trans_pcie->ict_index = 0;
863 
864  /* add periodic RX interrupt */
865  trans_pcie->inta_mask |= CSR_INT_BIT_RX_PERIODIC;
866  return 0;
867 }
868 
869 /* Device is going up inform it about using ICT interrupt table,
870  * also we need to tell the driver to start using ICT interrupt.
871  */
872 void iwl_reset_ict(struct iwl_trans *trans)
873 {
874  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
875  u32 val;
876  unsigned long flags;
877 
878  if (!trans_pcie->ict_tbl)
879  return;
880 
881  spin_lock_irqsave(&trans_pcie->irq_lock, flags);
882  iwl_disable_interrupts(trans);
883 
884  memset(trans_pcie->ict_tbl, 0, ICT_SIZE);
885 
886  val = trans_pcie->ict_tbl_dma >> ICT_SHIFT;
887 
890 
891  IWL_DEBUG_ISR(trans, "CSR_DRAM_INT_TBL_REG =0x%x\n", val);
892 
893  iwl_write32(trans, CSR_DRAM_INT_TBL_REG, val);
894  trans_pcie->use_ict = true;
895  trans_pcie->ict_index = 0;
896  iwl_write32(trans, CSR_INT, trans_pcie->inta_mask);
897  iwl_enable_interrupts(trans);
898  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
899 }
900 
901 /* Device is going down disable ict interrupt usage */
902 void iwl_disable_ict(struct iwl_trans *trans)
903 {
904  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
905  unsigned long flags;
906 
907  spin_lock_irqsave(&trans_pcie->irq_lock, flags);
908  trans_pcie->use_ict = false;
909  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
910 }
911 
912 /* legacy (non-ICT) ISR. Assumes that trans_pcie->irq_lock is held */
913 static irqreturn_t iwl_isr(int irq, void *data)
914 {
915  struct iwl_trans *trans = data;
916  struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
917  u32 inta, inta_mask;
918 #ifdef CONFIG_IWLWIFI_DEBUG
919  u32 inta_fh;
920 #endif
921 
922  lockdep_assert_held(&trans_pcie->irq_lock);
923 
924  trace_iwlwifi_dev_irq(trans->dev);
925 
926  /* Disable (but don't clear!) interrupts here to avoid
927  * back-to-back ISRs and sporadic interrupts from our NIC.
928  * If we have something to service, the tasklet will re-enable ints.
929  * If we *don't* have something, we'll re-enable before leaving here. */
930  inta_mask = iwl_read32(trans, CSR_INT_MASK); /* just for debug */
931  iwl_write32(trans, CSR_INT_MASK, 0x00000000);
932 
933  /* Discover which interrupts are active/pending */
934  inta = iwl_read32(trans, CSR_INT);
935 
936  /* Ignore interrupt if there's nothing in NIC to service.
937  * This may be due to IRQ shared with another device,
938  * or due to sporadic interrupts thrown from our NIC. */
939  if (!inta) {
940  IWL_DEBUG_ISR(trans, "Ignore interrupt, inta == 0\n");
941  goto none;
942  }
943 
944  if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
945  /* Hardware disappeared. It might have already raised
946  * an interrupt */
947  IWL_WARN(trans, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
948  return IRQ_HANDLED;
949  }
950 
951 #ifdef CONFIG_IWLWIFI_DEBUG
952  if (iwl_have_debug_level(IWL_DL_ISR)) {
953  inta_fh = iwl_read32(trans, CSR_FH_INT_STATUS);
954  IWL_DEBUG_ISR(trans, "ISR inta 0x%08x, enabled 0x%08x, "
955  "fh 0x%08x\n", inta, inta_mask, inta_fh);
956  }
957 #endif
958 
959  trans_pcie->inta |= inta;
960  /* iwl_irq_tasklet() will service interrupts and re-enable them */
961  if (likely(inta))
962  tasklet_schedule(&trans_pcie->irq_tasklet);
963  else if (test_bit(STATUS_INT_ENABLED, &trans_pcie->status) &&
964  !trans_pcie->inta)
965  iwl_enable_interrupts(trans);
966 
967 none:
968  /* re-enable interrupts here since we don't have anything to service. */
969  /* only Re-enable if disabled by irq and no schedules tasklet. */
970  if (test_bit(STATUS_INT_ENABLED, &trans_pcie->status) &&
971  !trans_pcie->inta)
972  iwl_enable_interrupts(trans);
973 
974  return IRQ_NONE;
975 }
976 
977 /* interrupt handler using ict table, with this interrupt driver will
978  * stop using INTA register to get device's interrupt, reading this register
979  * is expensive, device will write interrupts in ICT dram table, increment
980  * index then will fire interrupt to driver, driver will OR all ICT table
981  * entries from current index up to table entry with 0 value. the result is
982  * the interrupt we need to service, driver will set the entries back to 0 and
983  * set index.
984  */
985 irqreturn_t iwl_isr_ict(int irq, void *data)
986 {
987  struct iwl_trans *trans = data;
988  struct iwl_trans_pcie *trans_pcie;
989  u32 inta, inta_mask;
990  u32 val = 0;
991  u32 read;
992  unsigned long flags;
993 
994  if (!trans)
995  return IRQ_NONE;
996 
997  trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
998 
999  spin_lock_irqsave(&trans_pcie->irq_lock, flags);
1000 
1001  /* dram interrupt table not set yet,
1002  * use legacy interrupt.
1003  */
1004  if (unlikely(!trans_pcie->use_ict)) {
1005  irqreturn_t ret = iwl_isr(irq, data);
1006  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
1007  return ret;
1008  }
1009 
1010  trace_iwlwifi_dev_irq(trans->dev);
1011 
1012 
1013  /* Disable (but don't clear!) interrupts here to avoid
1014  * back-to-back ISRs and sporadic interrupts from our NIC.
1015  * If we have something to service, the tasklet will re-enable ints.
1016  * If we *don't* have something, we'll re-enable before leaving here.
1017  */
1018  inta_mask = iwl_read32(trans, CSR_INT_MASK); /* just for debug */
1019  iwl_write32(trans, CSR_INT_MASK, 0x00000000);
1020 
1021 
1022  /* Ignore interrupt if there's nothing in NIC to service.
1023  * This may be due to IRQ shared with another device,
1024  * or due to sporadic interrupts thrown from our NIC. */
1025  read = le32_to_cpu(trans_pcie->ict_tbl[trans_pcie->ict_index]);
1026  trace_iwlwifi_dev_ict_read(trans->dev, trans_pcie->ict_index, read);
1027  if (!read) {
1028  IWL_DEBUG_ISR(trans, "Ignore interrupt, inta == 0\n");
1029  goto none;
1030  }
1031 
1032  /*
1033  * Collect all entries up to the first 0, starting from ict_index;
1034  * note we already read at ict_index.
1035  */
1036  do {
1037  val |= read;
1038  IWL_DEBUG_ISR(trans, "ICT index %d value 0x%08X\n",
1039  trans_pcie->ict_index, read);
1040  trans_pcie->ict_tbl[trans_pcie->ict_index] = 0;
1041  trans_pcie->ict_index =
1042  iwl_queue_inc_wrap(trans_pcie->ict_index, ICT_COUNT);
1043 
1044  read = le32_to_cpu(trans_pcie->ict_tbl[trans_pcie->ict_index]);
1045  trace_iwlwifi_dev_ict_read(trans->dev, trans_pcie->ict_index,
1046  read);
1047  } while (read);
1048 
1049  /* We should not get this value, just ignore it. */
1050  if (val == 0xffffffff)
1051  val = 0;
1052 
1053  /*
1054  * this is a w/a for a h/w bug. the h/w bug may cause the Rx bit
1055  * (bit 15 before shifting it to 31) to clear when using interrupt
1056  * coalescing. fortunately, bits 18 and 19 stay set when this happens
1057  * so we use them to decide on the real state of the Rx bit.
1058  * In order words, bit 15 is set if bit 18 or bit 19 are set.
1059  */
1060  if (val & 0xC0000)
1061  val |= 0x8000;
1062 
1063  inta = (0xff & val) | ((0xff00 & val) << 16);
1064  IWL_DEBUG_ISR(trans, "ISR inta 0x%08x, enabled 0x%08x ict 0x%08x\n",
1065  inta, inta_mask, val);
1066 
1067  inta &= trans_pcie->inta_mask;
1068  trans_pcie->inta |= inta;
1069 
1070  /* iwl_irq_tasklet() will service interrupts and re-enable them */
1071  if (likely(inta))
1072  tasklet_schedule(&trans_pcie->irq_tasklet);
1073  else if (test_bit(STATUS_INT_ENABLED, &trans_pcie->status) &&
1074  !trans_pcie->inta) {
1075  /* Allow interrupt if was disabled by this handler and
1076  * no tasklet was schedules, We should not enable interrupt,
1077  * tasklet will enable it.
1078  */
1079  iwl_enable_interrupts(trans);
1080  }
1081 
1082  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
1083  return IRQ_HANDLED;
1084 
1085  none:
1086  /* re-enable interrupts here since we don't have anything to service.
1087  * only Re-enable if disabled by irq.
1088  */
1089  if (test_bit(STATUS_INT_ENABLED, &trans_pcie->status) &&
1090  !trans_pcie->inta)
1091  iwl_enable_interrupts(trans);
1092 
1093  spin_unlock_irqrestore(&trans_pcie->irq_lock, flags);
1094  return IRQ_NONE;
1095 }