drivers/net/wireless/wl12xx/wl1271_event.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2008-2009 Nokia Corporation
   5  *
   6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23
  24 #include "wl1271.h"
  25 #include "wl1271_reg.h"
  26 #include "wl1271_spi.h"
  27 #include "wl1271_event.h"
  28 #include "wl1271_ps.h"
  29 #include "wl12xx_80211.h"
  30
  31 static int wl1271_event_scan_complete(struct wl1271 *wl,
  32                                       struct event_mailbox *mbox)
  33 {
  34         int size = sizeof(struct wl12xx_probe_req_template);
  35         wl1271_debug(DEBUG_EVENT, "status: 0x%x",
  36                      mbox->scheduled_scan_status);
  37
  38         if (test_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
  39                 if (wl->scan.state == WL1271_SCAN_BAND_DUAL) {
  40                         wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4,
  41                                                 NULL, size);
  42                         /* 2.4 GHz band scanned, scan 5 GHz band, pretend
  43                          * to the wl1271_cmd_scan function that we are not
  44                          * scanning as it checks that.
  45                          */
  46                         clear_bit(WL1271_FLAG_SCANNING, &wl->flags);
  47                         wl1271_cmd_scan(wl, wl->scan.ssid, wl->scan.ssid_len,
  48                                                 wl->scan.active,
  49                                                 wl->scan.high_prio,
  50                                                 WL1271_SCAN_BAND_5_GHZ,
  51                                                 wl->scan.probe_requests);
  52                 } else {
  53                         if (wl->scan.state == WL1271_SCAN_BAND_2_4_GHZ)
  54                                 wl1271_cmd_template_set(wl,
  55                                                 CMD_TEMPL_CFG_PROBE_REQ_2_4,
  56                                                 NULL, size);
  57                         else
  58                                 wl1271_cmd_template_set(wl,
  59                                                 CMD_TEMPL_CFG_PROBE_REQ_5,
  60                                                 NULL, size);
  61
  62                         mutex_unlock(&wl->mutex);
  63                         ieee80211_scan_completed(wl->hw, false);
  64                         mutex_lock(&wl->mutex);
  65                         clear_bit(WL1271_FLAG_SCANNING, &wl->flags);
  66                 }
  67         }
  68         return 0;
  69 }
  70
  71 static int wl1271_event_ps_report(struct wl1271 *wl,
  72                                   struct event_mailbox *mbox,
  73                                   bool *beacon_loss)
  74 {
  75         int ret = 0;
  76
  77         wl1271_debug(DEBUG_EVENT, "ps_status: 0x%x", mbox->ps_status);
  78
  79         switch (mbox->ps_status) {
  80         case EVENT_ENTER_POWER_SAVE_FAIL:
  81                 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
  82                         wl->psm_entry_retry = 0;
  83                         break;
  84                 }
  85
  86                 if (wl->psm_entry_retry < wl->conf.conn.psm_entry_retries) {
  87                         wl->psm_entry_retry++;
  88                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
  89                 } else {
  90                         wl1271_error("PSM entry failed, giving up.\n");
  91                         wl->psm_entry_retry = 0;
  92                 }
  93                 break;
  94         case EVENT_ENTER_POWER_SAVE_SUCCESS:
  95                 wl->psm_entry_retry = 0;
  96                 break;
  97         case EVENT_EXIT_POWER_SAVE_FAIL:
  98                 wl1271_info("PSM exit failed");
  99                 break;
 100         case EVENT_EXIT_POWER_SAVE_SUCCESS:
 101         default:
 102                 break;
 103         }
 104
 105         return ret;
 106 }
 107
 108 static void wl1271_event_mbox_dump(struct event_mailbox *mbox)
 109 {
 110         wl1271_debug(DEBUG_EVENT, "MBOX DUMP:");
 111         wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
 112         wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
 113 }
 114
 115 static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
 116 {
 117         int ret;
 118         u32 vector;
 119         bool beacon_loss = false;
 120
 121         wl1271_event_mbox_dump(mbox);
 122
 123         vector = le32_to_cpu(mbox->events_vector);
 124         vector &= ~(le32_to_cpu(mbox->events_mask));
 125         wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector);
 126
 127         if (vector & SCAN_COMPLETE_EVENT_ID) {
 128                 ret = wl1271_event_scan_complete(wl, mbox);
 129                 if (ret < 0)
 130                         return ret;
 131         }
 132
 133         /*
 134          * The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon
 135          * filtering) is enabled. Without PSM, the stack will receive all
 136          * beacons and can detect beacon loss by itself.
 137          */
 138         if (vector & BSS_LOSE_EVENT_ID &&
 139             test_bit(WL1271_FLAG_PSM, &wl->flags)) {
 140                 wl1271_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");
 141
 142                 /* indicate to the stack, that beacons have been lost */
 143                 beacon_loss = true;
 144         }
 145
 146         if (vector & PS_REPORT_EVENT_ID) {
 147                 wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT");
 148                 ret = wl1271_event_ps_report(wl, mbox, &beacon_loss);
 149                 if (ret < 0)
 150                         return ret;
 151         }
 152
 153         if (wl->vif && beacon_loss) {
 154                 /* Obviously, it's dangerous to release the mutex while
 155                    we are holding many of the variables in the wl struct.
 156                    That's why it's done last in the function, and care must
 157                    be taken that nothing more is done after this function
 158                    returns. */
 159                 mutex_unlock(&wl->mutex);
 160                 ieee80211_beacon_loss(wl->vif);
 161                 mutex_lock(&wl->mutex);
 162         }
 163
 164         return 0;
 165 }
 166
 167 int wl1271_event_unmask(struct wl1271 *wl)
 168 {
 169         int ret;
 170
 171         ret = wl1271_acx_event_mbox_mask(wl, ~(wl->event_mask));
 172         if (ret < 0)
 173                 return ret;
 174
 175         return 0;
 176 }
 177
 178 void wl1271_event_mbox_config(struct wl1271 *wl)
 179 {
 180         wl->mbox_ptr[0] = wl1271_spi_read32(wl, REG_EVENT_MAILBOX_PTR);
 181         wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);
 182
 183         wl1271_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
 184                      wl->mbox_ptr[0], wl->mbox_ptr[1]);
 185 }
 186
 187 int wl1271_event_handle(struct wl1271 *wl, u8 mbox_num)
 188 {
 189         struct event_mailbox mbox;
 190         int ret;
 191
 192         wl1271_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);
 193
 194         if (mbox_num > 1)
 195                 return -EINVAL;
 196
 197         /* first we read the mbox descriptor */
 198         wl1271_spi_read(wl, wl->mbox_ptr[mbox_num], &mbox,
 199                         sizeof(struct event_mailbox), false);
 200
 201         /* process the descriptor */
 202         ret = wl1271_event_process(wl, &mbox);
 203         if (ret < 0)
 204                 return ret;
 205
 206         /* then we let the firmware know it can go on...*/
 207         wl1271_spi_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK);
 208
 209         return 0;
 210 }