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 (wl->scanning) {
  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                         wl->scanning = false;
  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                         wl->scanning = false;
  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 (!wl->psm) {
  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                         *beacon_loss = true;
  93                 }
  94                 break;
  95         case EVENT_ENTER_POWER_SAVE_SUCCESS:
  96                 wl->psm_entry_retry = 0;
  97                 break;
  98         case EVENT_EXIT_POWER_SAVE_FAIL:
  99                 wl1271_info("PSM exit failed");
 100                 break;
 101         case EVENT_EXIT_POWER_SAVE_SUCCESS:
 102         default:
 103                 break;
 104         }
 105
 106         return ret;
 107 }
 108
 109 static void wl1271_event_mbox_dump(struct event_mailbox *mbox)
 110 {
 111         wl1271_debug(DEBUG_EVENT, "MBOX DUMP:");
 112         wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
 113         wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
 114 }
 115
 116 static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
 117 {
 118         int ret;
 119         u32 vector;
 120         bool beacon_loss = false;
 121
 122         wl1271_event_mbox_dump(mbox);
 123
 124         vector = le32_to_cpu(mbox->events_vector);
 125         vector &= ~(le32_to_cpu(mbox->events_mask));
 126         wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector);
 127
 128         if (vector & SCAN_COMPLETE_EVENT_ID) {
 129                 ret = wl1271_event_scan_complete(wl, mbox);
 130                 if (ret < 0)
 131                         return ret;
 132         }
 133
 134         /*
 135          * The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon
 136          * filtering) is enabled. Without PSM, the stack will receive all
 137          * beacons and can detect beacon loss by itself.
 138          */
 139         if (vector & BSS_LOSE_EVENT_ID && wl->psm) {
 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 (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, bool do_ack)
 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         if (do_ack)
 208                 wl1271_spi_write32(wl, ACX_REG_INTERRUPT_TRIG,
 209                                    INTR_TRIG_EVENT_ACK);
 210
 211         return 0;
 212 }