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