release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/net/wireless/iwlwifi/iwl-agn-ict.c

   1 /******************************************************************************
   2  *
   3  * GPL LICENSE SUMMARY
   4  *
   5  * Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  19  * USA
  20  *
  21  * The full GNU General Public License is included in this distribution
  22  * in the file called LICENSE.GPL.
  23  *
  24  * Contact Information:
  25  *  Intel Linux Wireless <ilw@linux.intel.com>
  26  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27  *****************************************************************************/
  28
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/etherdevice.h>
  32 #include <linux/sched.h>
  33 #include <linux/gfp.h>
  34 #include <net/mac80211.h>
  35
  36 #include "iwl-dev.h"
  37 #include "iwl-core.h"
  38 #include "iwl-agn.h"
  39 #include "iwl-helpers.h"
  40
  41 #define ICT_COUNT (PAGE_SIZE/sizeof(u32))
  42
  43 /* Free dram table */
  44 void iwl_free_isr_ict(struct iwl_priv *priv)
  45 {
  46         if (priv->_agn.ict_tbl_vir) {
  47                 dma_free_coherent(&priv->pci_dev->dev,
  48                                   (sizeof(u32) * ICT_COUNT) + PAGE_SIZE,
  49                                   priv->_agn.ict_tbl_vir,
  50                                   priv->_agn.ict_tbl_dma);
  51                 priv->_agn.ict_tbl_vir = NULL;
  52         }
  53 }
  54
  55
  56 /* allocate dram shared table it is a PAGE_SIZE aligned
  57  * also reset all data related to ICT table interrupt.
  58  */
  59 int iwl_alloc_isr_ict(struct iwl_priv *priv)
  60 {
  61
  62         if (priv->cfg->use_isr_legacy)
  63                 return 0;
  64         /* allocate shrared data table */
  65         priv->_agn.ict_tbl_vir =
  66                 dma_alloc_coherent(&priv->pci_dev->dev,
  67                                    (sizeof(u32) * ICT_COUNT) + PAGE_SIZE,
  68                                    &priv->_agn.ict_tbl_dma, GFP_KERNEL);
  69         if (!priv->_agn.ict_tbl_vir)
  70                 return -ENOMEM;
  71
  72         /* align table to PAGE_SIZE boundry */
  73         priv->_agn.aligned_ict_tbl_dma = ALIGN(priv->_agn.ict_tbl_dma, PAGE_SIZE);
  74
  75         IWL_DEBUG_ISR(priv, "ict dma addr %Lx dma aligned %Lx diff %d\n",
  76                              (unsigned long long)priv->_agn.ict_tbl_dma,
  77                              (unsigned long long)priv->_agn.aligned_ict_tbl_dma,
  78                         (int)(priv->_agn.aligned_ict_tbl_dma - priv->_agn.ict_tbl_dma));
  79
  80         priv->_agn.ict_tbl =  priv->_agn.ict_tbl_vir +
  81                           (priv->_agn.aligned_ict_tbl_dma - priv->_agn.ict_tbl_dma);
  82
  83         IWL_DEBUG_ISR(priv, "ict vir addr %p vir aligned %p diff %d\n",
  84                              priv->_agn.ict_tbl, priv->_agn.ict_tbl_vir,
  85                         (int)(priv->_agn.aligned_ict_tbl_dma - priv->_agn.ict_tbl_dma));
  86
  87         /* reset table and index to all 0 */
  88         memset(priv->_agn.ict_tbl_vir,0, (sizeof(u32) * ICT_COUNT) + PAGE_SIZE);
  89         priv->_agn.ict_index = 0;
  90
  91         /* add periodic RX interrupt */
  92         priv->inta_mask |= CSR_INT_BIT_RX_PERIODIC;
  93         return 0;
  94 }
  95
  96 /* Device is going up inform it about using ICT interrupt table,
  97  * also we need to tell the driver to start using ICT interrupt.
  98  */
  99 int iwl_reset_ict(struct iwl_priv *priv)
 100 {
 101         u32 val;
 102         unsigned long flags;
 103
 104         if (!priv->_agn.ict_tbl_vir)
 105                 return 0;
 106
 107         spin_lock_irqsave(&priv->lock, flags);
 108         iwl_disable_interrupts(priv);
 109
 110         memset(&priv->_agn.ict_tbl[0], 0, sizeof(u32) * ICT_COUNT);
 111
 112         val = priv->_agn.aligned_ict_tbl_dma >> PAGE_SHIFT;
 113
 114         val |= CSR_DRAM_INT_TBL_ENABLE;
 115         val |= CSR_DRAM_INIT_TBL_WRAP_CHECK;
 116
 117         IWL_DEBUG_ISR(priv, "CSR_DRAM_INT_TBL_REG =0x%X "
 118                         "aligned dma address %Lx\n",
 119                         val, (unsigned long long)priv->_agn.aligned_ict_tbl_dma);
 120
 121         iwl_write32(priv, CSR_DRAM_INT_TBL_REG, val);
 122         priv->_agn.use_ict = true;
 123         priv->_agn.ict_index = 0;
 124         iwl_write32(priv, CSR_INT, priv->inta_mask);
 125         iwl_enable_interrupts(priv);
 126         spin_unlock_irqrestore(&priv->lock, flags);
 127
 128         return 0;
 129 }
 130
 131 /* Device is going down disable ict interrupt usage */
 132 void iwl_disable_ict(struct iwl_priv *priv)
 133 {
 134         unsigned long flags;
 135
 136         spin_lock_irqsave(&priv->lock, flags);
 137         priv->_agn.use_ict = false;
 138         spin_unlock_irqrestore(&priv->lock, flags);
 139 }
 140
 141 static irqreturn_t iwl_isr(int irq, void *data)
 142 {
 143         struct iwl_priv *priv = data;
 144         u32 inta, inta_mask;
 145         unsigned long flags;
 146 #ifdef CONFIG_IWLWIFI_DEBUG
 147         u32 inta_fh;
 148 #endif
 149         if (!priv)
 150                 return IRQ_NONE;
 151
 152         spin_lock_irqsave(&priv->lock, flags);
 153
 154         /* Disable (but don't clear!) interrupts here to avoid
 155          *    back-to-back ISRs and sporadic interrupts from our NIC.
 156          * If we have something to service, the tasklet will re-enable ints.
 157          * If we *don't* have something, we'll re-enable before leaving here. */
 158         inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
 159         iwl_write32(priv, CSR_INT_MASK, 0x00000000);
 160
 161         /* Discover which interrupts are active/pending */
 162         inta = iwl_read32(priv, CSR_INT);
 163
 164         /* Ignore interrupt if there's nothing in NIC to service.
 165          * This may be due to IRQ shared with another device,
 166          * or due to sporadic interrupts thrown from our NIC. */
 167         if (!inta) {
 168                 IWL_DEBUG_ISR(priv, "Ignore interrupt, inta == 0\n");
 169                 goto none;
 170         }
 171
 172         if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
 173                 /* Hardware disappeared. It might have already raised
 174                  * an interrupt */
 175                 IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
 176                 goto unplugged;
 177         }
 178
 179 #ifdef CONFIG_IWLWIFI_DEBUG
 180         if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
 181                 inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
 182                 IWL_DEBUG_ISR(priv, "ISR inta 0x%08x, enabled 0x%08x, "
 183                               "fh 0x%08x\n", inta, inta_mask, inta_fh);
 184         }
 185 #endif
 186
 187         priv->_agn.inta |= inta;
 188         /* iwl_irq_tasklet() will service interrupts and re-enable them */
 189         if (likely(inta))
 190                 tasklet_schedule(&priv->irq_tasklet);
 191         else if (test_bit(STATUS_INT_ENABLED, &priv->status) && !priv->_agn.inta)
 192                 iwl_enable_interrupts(priv);
 193
 194  unplugged:
 195         spin_unlock_irqrestore(&priv->lock, flags);
 196         return IRQ_HANDLED;
 197
 198  none:
 199         /* re-enable interrupts here since we don't have anything to service. */
 200         /* only Re-enable if diabled by irq  and no schedules tasklet. */
 201         if (test_bit(STATUS_INT_ENABLED, &priv->status) && !priv->_agn.inta)
 202                 iwl_enable_interrupts(priv);
 203
 204         spin_unlock_irqrestore(&priv->lock, flags);
 205         return IRQ_NONE;
 206 }
 207
 208 /* interrupt handler using ict table, with this interrupt driver will
 209  * stop using INTA register to get device's interrupt, reading this register
 210  * is expensive, device will write interrupts in ICT dram table, increment
 211  * index then will fire interrupt to driver, driver will OR all ICT table
 212  * entries from current index up to table entry with 0 value. the result is
 213  * the interrupt we need to service, driver will set the entries back to 0 and
 214  * set index.
 215  */
 216 irqreturn_t iwl_isr_ict(int irq, void *data)
 217 {
 218         struct iwl_priv *priv = data;
 219         u32 inta, inta_mask;
 220         u32 val = 0;
 221         unsigned long flags;
 222
 223         if (!priv)
 224                 return IRQ_NONE;
 225
 226         /* dram interrupt table not set yet,
 227          * use legacy interrupt.
 228          */
 229         if (!priv->_agn.use_ict)
 230                 return iwl_isr(irq, data);
 231
 232         spin_lock_irqsave(&priv->lock, flags);
 233
 234         /* Disable (but don't clear!) interrupts here to avoid
 235          * back-to-back ISRs and sporadic interrupts from our NIC.
 236          * If we have something to service, the tasklet will re-enable ints.
 237          * If we *don't* have something, we'll re-enable before leaving here.
 238          */
 239         inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
 240         iwl_write32(priv, CSR_INT_MASK, 0x00000000);
 241
 242
 243         /* Ignore interrupt if there's nothing in NIC to service.
 244          * This may be due to IRQ shared with another device,
 245          * or due to sporadic interrupts thrown from our NIC. */
 246         if (!priv->_agn.ict_tbl[priv->_agn.ict_index]) {
 247                 IWL_DEBUG_ISR(priv, "Ignore interrupt, inta == 0\n");
 248                 goto none;
 249         }
 250
 251         /* read all entries that not 0 start with ict_index */
 252         while (priv->_agn.ict_tbl[priv->_agn.ict_index]) {
 253
 254                 val |= le32_to_cpu(priv->_agn.ict_tbl[priv->_agn.ict_index]);
 255                 IWL_DEBUG_ISR(priv, "ICT index %d value 0x%08X\n",
 256                                 priv->_agn.ict_index,
 257                                 le32_to_cpu(priv->_agn.ict_tbl[priv->_agn.ict_index]));
 258                 priv->_agn.ict_tbl[priv->_agn.ict_index] = 0;
 259                 priv->_agn.ict_index = iwl_queue_inc_wrap(priv->_agn.ict_index,
 260                                                      ICT_COUNT);
 261
 262         }
 263
 264         /* We should not get this value, just ignore it. */
 265         if (val == 0xffffffff)
 266                 val = 0;
 267
 268         /*
 269          * this is a w/a for a h/w bug. the h/w bug may cause the Rx bit
 270          * (bit 15 before shifting it to 31) to clear when using interrupt
 271          * coalescing. fortunately, bits 18 and 19 stay set when this happens
 272          * so we use them to decide on the real state of the Rx bit.
 273          * In order words, bit 15 is set if bit 18 or bit 19 are set.
 274          */
 275         if (val & 0xC0000)
 276                 val |= 0x8000;
 277
 278         inta = (0xff & val) | ((0xff00 & val) << 16);
 279         IWL_DEBUG_ISR(priv, "ISR inta 0x%08x, enabled 0x%08x ict 0x%08x\n",
 280                         inta, inta_mask, val);
 281
 282         inta &= priv->inta_mask;
 283         priv->_agn.inta |= inta;
 284
 285         /* iwl_irq_tasklet() will service interrupts and re-enable them */
 286         if (likely(inta))
 287                 tasklet_schedule(&priv->irq_tasklet);
 288         else if (test_bit(STATUS_INT_ENABLED, &priv->status) && !priv->_agn.inta) {
 289                 /* Allow interrupt if was disabled by this handler and
 290                  * no tasklet was schedules, We should not enable interrupt,
 291                  * tasklet will enable it.
 292                  */
 293                 iwl_enable_interrupts(priv);
 294         }
 295
 296         spin_unlock_irqrestore(&priv->lock, flags);
 297         return IRQ_HANDLED;
 298
 299  none:
 300         /* re-enable interrupts here since we don't have anything to service.
 301          * only Re-enable if disabled by irq.
 302          */
 303         if (test_bit(STATUS_INT_ENABLED, &priv->status) && !priv->_agn.inta)
 304                 iwl_enable_interrupts(priv);
 305
 306         spin_unlock_irqrestore(&priv->lock, flags);
 307         return IRQ_NONE;
 308 }