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                 wl1271_debug(DEBUG_PSM, "PSM entry failed");
  82
  83                 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
  84                         /* remain in active mode */
  85                         wl->psm_entry_retry = 0;
  86                         break;
  87                 }
  88
  89                 if (wl->psm_entry_retry < wl->conf.conn.psm_entry_retries) {
  90                         wl->psm_entry_retry++;
  91                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
  92                                                  true);
  93                 } else {
  94                         wl1271_error("PSM entry failed, giving up.\n");
  95                         /* make sure the firmware goes into active mode */
  96                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
  97                                                  false);
  98                         wl->psm_entry_retry = 0;
  99                 }
 100                 break;
 101         case EVENT_ENTER_POWER_SAVE_SUCCESS:
 102                 wl->psm_entry_retry = 0;
 103
 104                 /* enable beacon filtering */
 105                 ret = wl1271_acx_beacon_filter_opt(wl, true);
 106                 if (ret < 0)
 107                         break;
 108
 109                 /* enable beacon early termination */
 110                 ret = wl1271_acx_bet_enable(wl, true);
 111                 if (ret < 0)
 112                         break;
 113
 114                 /* go to extremely low power mode */
 115                 wl1271_ps_elp_sleep(wl);
 116                 if (ret < 0)
 117                         break;
 118                 break;
 119         case EVENT_EXIT_POWER_SAVE_FAIL:
 120                 wl1271_debug(DEBUG_PSM, "PSM exit failed");
 121
 122                 if (test_bit(WL1271_FLAG_PSM, &wl->flags)) {
 123                         wl->psm_entry_retry = 0;
 124                         break;
 125                 }
 126
 127                 /* make sure the firmware goes to active mode */
 128                 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
 129                                          false);
 130                 break;
 131         case EVENT_EXIT_POWER_SAVE_SUCCESS:
 132         default:
 133                 break;
 134         }
 135
 136         return ret;
 137 }
 138
 139 static void wl1271_event_mbox_dump(struct event_mailbox *mbox)
 140 {
 141         wl1271_debug(DEBUG_EVENT, "MBOX DUMP:");
 142         wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
 143         wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
 144 }
 145
 146 static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
 147 {
 148         int ret;
 149         u32 vector;
 150         bool beacon_loss = false;
 151
 152         wl1271_event_mbox_dump(mbox);
 153
 154         vector = le32_to_cpu(mbox->events_vector);
 155         vector &= ~(le32_to_cpu(mbox->events_mask));
 156         wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector);
 157
 158         if (vector & SCAN_COMPLETE_EVENT_ID) {
 159                 ret = wl1271_event_scan_complete(wl, mbox);
 160                 if (ret < 0)
 161                         return ret;
 162         }
 163
 164         /*
 165          * The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon
 166          * filtering) is enabled. Without PSM, the stack will receive all
 167          * beacons and can detect beacon loss by itself.
 168          */
 169         if (vector & BSS_LOSE_EVENT_ID &&
 170             test_bit(WL1271_FLAG_PSM, &wl->flags)) {
 171                 wl1271_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");
 172
 173                 /* indicate to the stack, that beacons have been lost */
 174                 beacon_loss = true;
 175         }
 176
 177         if (vector & PS_REPORT_EVENT_ID) {
 178                 wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT");
 179                 ret = wl1271_event_ps_report(wl, mbox, &beacon_loss);
 180                 if (ret < 0)
 181                         return ret;
 182         }
 183
 184         if (wl->vif && beacon_loss) {
 185                 /* Obviously, it's dangerous to release the mutex while
 186                    we are holding many of the variables in the wl struct.
 187                    That's why it's done last in the function, and care must
 188                    be taken that nothing more is done after this function
 189                    returns. */
 190                 mutex_unlock(&wl->mutex);
 191                 ieee80211_beacon_loss(wl->vif);
 192                 mutex_lock(&wl->mutex);
 193         }
 194
 195         return 0;
 196 }
 197
 198 int wl1271_event_unmask(struct wl1271 *wl)
 199 {
 200         int ret;
 201
 202         ret = wl1271_acx_event_mbox_mask(wl, ~(wl->event_mask));
 203         if (ret < 0)
 204                 return ret;
 205
 206         return 0;
 207 }
 208
 209 void wl1271_event_mbox_config(struct wl1271 *wl)
 210 {
 211         wl->mbox_ptr[0] = wl1271_spi_read32(wl, REG_EVENT_MAILBOX_PTR);
 212         wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);
 213
 214         wl1271_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
 215                      wl->mbox_ptr[0], wl->mbox_ptr[1]);
 216 }
 217
 218 int wl1271_event_handle(struct wl1271 *wl, u8 mbox_num)
 219 {
 220         struct event_mailbox mbox;
 221         int ret;
 222
 223         wl1271_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);
 224
 225         if (mbox_num > 1)
 226                 return -EINVAL;
 227
 228         /* first we read the mbox descriptor */
 229         wl1271_spi_read(wl, wl->mbox_ptr[mbox_num], &mbox,
 230                         sizeof(struct event_mailbox), false);
 231
 232         /* process the descriptor */
 233         ret = wl1271_event_process(wl, &mbox);
 234         if (ret < 0)
 235                 return ret;
 236
 237         /* then we let the firmware know it can go on...*/
 238         wl1271_spi_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK);
 239
 240         return 0;
 241 }