drivers/net/wireless/brcm80211/brcmfmac/fweh.c

   1 /*
   2  * Copyright (c) 2012 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include <linux/netdevice.h>
  17
  18 #include "brcmu_wifi.h"
  19 #include "brcmu_utils.h"
  20
  21 #include "dhd.h"
  22 #include "dhd_dbg.h"
  23 #include "fweh.h"
  24 #include "fwil.h"
  25
  26 /**
  27  * struct brcm_ethhdr - broadcom specific ether header.
  28  *
  29  * @subtype: subtype for this packet.
  30  * @length: TODO: length of appended data.
  31  * @version: version indication.
  32  * @oui: OUI of this packet.
  33  * @usr_subtype: subtype for this OUI.
  34  */
  35 struct brcm_ethhdr {
  36         __be16 subtype;
  37         __be16 length;
  38         u8 version;
  39         u8 oui[3];
  40         __be16 usr_subtype;
  41 } __packed;
  42
  43 struct brcmf_event_msg_be {
  44         __be16 version;
  45         __be16 flags;
  46         __be32 event_type;
  47         __be32 status;
  48         __be32 reason;
  49         __be32 auth_type;
  50         __be32 datalen;
  51         u8 addr[ETH_ALEN];
  52         char ifname[IFNAMSIZ];
  53         u8 ifidx;
  54         u8 bsscfgidx;
  55 } __packed;
  56
  57 /**
  58  * struct brcmf_event - contents of broadcom event packet.
  59  *
  60  * @eth: standard ether header.
  61  * @hdr: broadcom specific ether header.
  62  * @msg: common part of the actual event message.
  63  */
  64 struct brcmf_event {
  65         struct ethhdr eth;
  66         struct brcm_ethhdr hdr;
  67         struct brcmf_event_msg_be msg;
  68 } __packed;
  69
  70 /**
  71  * struct brcmf_fweh_queue_item - event item on event queue.
  72  *
  73  * @q: list element for queuing.
  74  * @code: event code.
  75  * @ifidx: interface index related to this event.
  76  * @ifaddr: ethernet address for interface.
  77  * @emsg: common parameters of the firmware event message.
  78  * @data: event specific data part of the firmware event.
  79  */
  80 struct brcmf_fweh_queue_item {
  81         struct list_head q;
  82         enum brcmf_fweh_event_code code;
  83         u8 ifidx;
  84         u8 ifaddr[ETH_ALEN];
  85         struct brcmf_event_msg_be emsg;
  86         u8 data[0];
  87 };
  88
  89 /**
  90  * struct brcmf_fweh_event_name - code, name mapping entry.
  91  */
  92 struct brcmf_fweh_event_name {
  93         enum brcmf_fweh_event_code code;
  94         const char *name;
  95 };
  96
  97 #ifdef DEBUG
  98 /* array for mapping code to event name */
  99 static struct brcmf_fweh_event_name fweh_event_names[] = {
 100         { BRCMF_E_SET_SSID, "SET_SSID" },
 101         { BRCMF_E_JOIN, "JOIN" },
 102         { BRCMF_E_START, "START" },
 103         { BRCMF_E_AUTH, "AUTH" },
 104         { BRCMF_E_AUTH_IND, "AUTH_IND" },
 105         { BRCMF_E_DEAUTH, "DEAUTH" },
 106         { BRCMF_E_DEAUTH_IND, "DEAUTH_IND" },
 107         { BRCMF_E_ASSOC, "ASSOC" },
 108         { BRCMF_E_ASSOC_IND, "ASSOC_IND" },
 109         { BRCMF_E_REASSOC, "REASSOC" },
 110         { BRCMF_E_REASSOC_IND, "REASSOC_IND" },
 111         { BRCMF_E_DISASSOC, "DISASSOC" },
 112         { BRCMF_E_DISASSOC_IND, "DISASSOC_IND" },
 113         { BRCMF_E_QUIET_START, "START_QUIET" },
 114         { BRCMF_E_QUIET_END, "END_QUIET" },
 115         { BRCMF_E_BEACON_RX, "BEACON_RX" },
 116         { BRCMF_E_LINK, "LINK" },
 117         { BRCMF_E_MIC_ERROR, "MIC_ERROR" },
 118         { BRCMF_E_NDIS_LINK, "NDIS_LINK" },
 119         { BRCMF_E_ROAM, "ROAM" },
 120         { BRCMF_E_TXFAIL, "TXFAIL" },
 121         { BRCMF_E_PMKID_CACHE, "PMKID_CACHE" },
 122         { BRCMF_E_RETROGRADE_TSF, "RETROGRADE_TSF" },
 123         { BRCMF_E_PRUNE, "PRUNE" },
 124         { BRCMF_E_AUTOAUTH, "AUTOAUTH" },
 125         { BRCMF_E_EAPOL_MSG, "EAPOL_MSG" },
 126         { BRCMF_E_SCAN_COMPLETE, "SCAN_COMPLETE" },
 127         { BRCMF_E_ADDTS_IND, "ADDTS_IND" },
 128         { BRCMF_E_DELTS_IND, "DELTS_IND" },
 129         { BRCMF_E_BCNSENT_IND, "BCNSENT_IND" },
 130         { BRCMF_E_BCNRX_MSG, "BCNRX_MSG" },
 131         { BRCMF_E_BCNLOST_MSG, "BCNLOST_MSG" },
 132         { BRCMF_E_ROAM_PREP, "ROAM_PREP" },
 133         { BRCMF_E_PFN_NET_FOUND, "PNO_NET_FOUND" },
 134         { BRCMF_E_PFN_NET_LOST, "PNO_NET_LOST" },
 135         { BRCMF_E_RESET_COMPLETE, "RESET_COMPLETE" },
 136         { BRCMF_E_JOIN_START, "JOIN_START" },
 137         { BRCMF_E_ROAM_START, "ROAM_START" },
 138         { BRCMF_E_ASSOC_START, "ASSOC_START" },
 139         { BRCMF_E_IBSS_ASSOC, "IBSS_ASSOC" },
 140         { BRCMF_E_RADIO, "RADIO" },
 141         { BRCMF_E_PSM_WATCHDOG, "PSM_WATCHDOG" },
 142         { BRCMF_E_PROBREQ_MSG, "PROBREQ_MSG" },
 143         { BRCMF_E_SCAN_CONFIRM_IND, "SCAN_CONFIRM_IND" },
 144         { BRCMF_E_PSK_SUP, "PSK_SUP" },
 145         { BRCMF_E_COUNTRY_CODE_CHANGED, "COUNTRY_CODE_CHANGED" },
 146         { BRCMF_E_EXCEEDED_MEDIUM_TIME, "EXCEEDED_MEDIUM_TIME" },
 147         { BRCMF_E_ICV_ERROR, "ICV_ERROR" },
 148         { BRCMF_E_UNICAST_DECODE_ERROR, "UNICAST_DECODE_ERROR" },
 149         { BRCMF_E_MULTICAST_DECODE_ERROR, "MULTICAST_DECODE_ERROR" },
 150         { BRCMF_E_TRACE, "TRACE" },
 151         { BRCMF_E_IF, "IF" },
 152         { BRCMF_E_RSSI, "RSSI" },
 153         { BRCMF_E_PFN_SCAN_COMPLETE, "PFN_SCAN_COMPLETE" },
 154         { BRCMF_E_EXTLOG_MSG, "EXTLOG_MSG" },
 155         { BRCMF_E_ACTION_FRAME, "ACTION_FRAME" },
 156         { BRCMF_E_ACTION_FRAME_COMPLETE, "ACTION_FRAME_COMPLETE" },
 157         { BRCMF_E_PRE_ASSOC_IND, "PRE_ASSOC_IND" },
 158         { BRCMF_E_PRE_REASSOC_IND, "PRE_REASSOC_IND" },
 159         { BRCMF_E_CHANNEL_ADOPTED, "CHANNEL_ADOPTED" },
 160         { BRCMF_E_AP_STARTED, "AP_STARTED" },
 161         { BRCMF_E_DFS_AP_STOP, "DFS_AP_STOP" },
 162         { BRCMF_E_DFS_AP_RESUME, "DFS_AP_RESUME" },
 163         { BRCMF_E_ESCAN_RESULT, "ESCAN_RESULT" },
 164         { BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE, "ACTION_FRM_OFF_CHAN_CMPLT" },
 165         { BRCMF_E_DCS_REQUEST, "DCS_REQUEST" },
 166         { BRCMF_E_FIFO_CREDIT_MAP, "FIFO_CREDIT_MAP"}
 167 };
 168
 169 /**
 170  * brcmf_fweh_event_name() - returns name for given event code.
 171  *
 172  * @code: code to lookup.
 173  */
 174 static const char *brcmf_fweh_event_name(enum brcmf_fweh_event_code code)
 175 {
 176         int i;
 177         for (i = 0; i < ARRAY_SIZE(fweh_event_names); i++) {
 178                 if (fweh_event_names[i].code == code)
 179                         return fweh_event_names[i].name;
 180         }
 181         return "unknown";
 182 }
 183 #else
 184 static const char *brcmf_fweh_event_name(enum brcmf_fweh_event_code code)
 185 {
 186         return "nodebug";
 187 }
 188 #endif
 189
 190 /**
 191  * brcmf_fweh_queue_event() - create and queue event.
 192  *
 193  * @fweh: firmware event handling info.
 194  * @event: event queue entry.
 195  */
 196 static void brcmf_fweh_queue_event(struct brcmf_fweh_info *fweh,
 197                                    struct brcmf_fweh_queue_item *event)
 198 {
 199         ulong flags;
 200
 201         spin_lock_irqsave(&fweh->evt_q_lock, flags);
 202         list_add_tail(&event->q, &fweh->event_q);
 203         spin_unlock_irqrestore(&fweh->evt_q_lock, flags);
 204         schedule_work(&fweh->event_work);
 205 }
 206
 207 static int brcmf_fweh_call_event_handler(struct brcmf_if *ifp,
 208                                          enum brcmf_fweh_event_code code,
 209                                          struct brcmf_event_msg *emsg,
 210                                          void *data)
 211 {
 212         struct brcmf_fweh_info *fweh;
 213         int err = -EINVAL;
 214
 215         if (ifp) {
 216                 fweh = &ifp->drvr->fweh;
 217
 218                 /* handle the event if valid interface and handler */
 219                 if (ifp->ndev && fweh->evt_handler[code])
 220                         err = fweh->evt_handler[code](ifp, emsg, data);
 221                 else
 222                         brcmf_dbg(ERROR, "unhandled event %d ignored\n", code);
 223         } else {
 224                 brcmf_dbg(ERROR, "no interface object\n");
 225         }
 226         return err;
 227 }
 228
 229 /**
 230  * brcmf_fweh_handle_if_event() - handle IF event.
 231  *
 232  * @drvr: driver information object.
 233  * @item: queue entry.
 234  * @ifpp: interface object (may change upon ADD action).
 235  */
 236 static void brcmf_fweh_handle_if_event(struct brcmf_pub *drvr,
 237                                        struct brcmf_event_msg *emsg,
 238                                        void *data)
 239 {
 240         struct brcmf_if_event *ifevent = data;
 241         struct brcmf_if *ifp;
 242         int err = 0;
 243
 244         brcmf_dbg(EVENT, "action: %u idx: %u bsscfg: %u flags: %u\n",
 245                   ifevent->action, ifevent->ifidx,
 246                   ifevent->bssidx, ifevent->flags);
 247
 248         if (ifevent->ifidx >= BRCMF_MAX_IFS) {
 249                 brcmf_dbg(ERROR, "invalid interface index: %u\n",
 250                           ifevent->ifidx);
 251                 return;
 252         }
 253
 254         ifp = drvr->iflist[ifevent->ifidx];
 255
 256         if (ifevent->action == BRCMF_E_IF_ADD) {
 257                 brcmf_dbg(EVENT, "adding %s (%pM)\n", emsg->ifname,
 258                           emsg->addr);
 259                 ifp = brcmf_add_if(drvr, ifevent->ifidx, ifevent->bssidx,
 260                                    emsg->ifname, emsg->addr);
 261                 if (IS_ERR(ifp))
 262                         return;
 263
 264                 if (!drvr->fweh.evt_handler[BRCMF_E_IF])
 265                         err = brcmf_net_attach(ifp);
 266         }
 267
 268         err = brcmf_fweh_call_event_handler(ifp, emsg->event_code, emsg, data);
 269
 270         if (ifevent->action == BRCMF_E_IF_DEL)
 271                 brcmf_del_if(drvr, ifevent->ifidx);
 272 }
 273
 274 /**
 275  * brcmf_fweh_dequeue_event() - get event from the queue.
 276  *
 277  * @fweh: firmware event handling info.
 278  */
 279 static struct brcmf_fweh_queue_item *
 280 brcmf_fweh_dequeue_event(struct brcmf_fweh_info *fweh)
 281 {
 282         struct brcmf_fweh_queue_item *event = NULL;
 283         ulong flags;
 284
 285         spin_lock_irqsave(&fweh->evt_q_lock, flags);
 286         if (!list_empty(&fweh->event_q)) {
 287                 event = list_first_entry(&fweh->event_q,
 288                                          struct brcmf_fweh_queue_item, q);
 289                 list_del(&event->q);
 290         }
 291         spin_unlock_irqrestore(&fweh->evt_q_lock, flags);
 292
 293         return event;
 294 }
 295
 296 /**
 297  * brcmf_fweh_event_worker() - firmware event worker.
 298  *
 299  * @work: worker object.
 300  */
 301 static void brcmf_fweh_event_worker(struct work_struct *work)
 302 {
 303         struct brcmf_pub *drvr;
 304         struct brcmf_if *ifp;
 305         struct brcmf_fweh_info *fweh;
 306         struct brcmf_fweh_queue_item *event;
 307         int err = 0;
 308         struct brcmf_event_msg_be *emsg_be;
 309         struct brcmf_event_msg emsg;
 310
 311         fweh = container_of(work, struct brcmf_fweh_info, event_work);
 312         drvr = container_of(fweh, struct brcmf_pub, fweh);
 313
 314         while ((event = brcmf_fweh_dequeue_event(fweh))) {
 315                 ifp = drvr->iflist[event->ifidx];
 316
 317                 brcmf_dbg(EVENT, "event %s (%u) ifidx %u bsscfg %u addr %pM:\n",
 318                           brcmf_fweh_event_name(event->code), event->code,
 319                           event->emsg.ifidx, event->emsg.bsscfgidx,
 320                           event->emsg.addr);
 321
 322                 /* convert event message */
 323                 emsg_be = &event->emsg;
 324                 emsg.version = be16_to_cpu(emsg_be->version);
 325                 emsg.flags = be16_to_cpu(emsg_be->flags);
 326                 emsg.event_code = event->code;
 327                 emsg.status = be32_to_cpu(emsg_be->status);
 328                 emsg.reason = be32_to_cpu(emsg_be->reason);
 329                 emsg.auth_type = be32_to_cpu(emsg_be->auth_type);
 330                 emsg.datalen = be32_to_cpu(emsg_be->datalen);
 331                 memcpy(emsg.addr, emsg_be->addr, ETH_ALEN);
 332                 memcpy(emsg.ifname, emsg_be->ifname, sizeof(emsg.ifname));
 333                 emsg.ifidx = emsg_be->ifidx;
 334                 emsg.bsscfgidx = emsg_be->bsscfgidx;
 335
 336                 brcmf_dbg(EVENT, "  version %u flags %u status %u reason %u\n",
 337                           emsg.version, emsg.flags, emsg.status, emsg.reason);
 338                 brcmf_dbg_hex_dump(BRCMF_EVENT_ON(), event->data,
 339                                    min_t(u32, emsg.datalen, 64),
 340                                    "appended:");
 341
 342                 /* special handling of interface event */
 343                 if (event->code == BRCMF_E_IF) {
 344                         brcmf_fweh_handle_if_event(drvr, &emsg, event->data);
 345                         goto event_free;
 346                 }
 347
 348                 err = brcmf_fweh_call_event_handler(ifp, event->code, &emsg,
 349                                                     event->data);
 350                 if (err) {
 351                         brcmf_dbg(ERROR, "event handler failed (%d)\n",
 352                                   event->code);
 353                         err = 0;
 354                 }
 355 event_free:
 356                 kfree(event);
 357         }
 358 }
 359
 360 /**
 361  * brcmf_fweh_attach() - initialize firmware event handling.
 362  *
 363  * @drvr: driver information object.
 364  */
 365 void brcmf_fweh_attach(struct brcmf_pub *drvr)
 366 {
 367         struct brcmf_fweh_info *fweh = &drvr->fweh;
 368         INIT_WORK(&fweh->event_work, brcmf_fweh_event_worker);
 369         spin_lock_init(&fweh->evt_q_lock);
 370         INIT_LIST_HEAD(&fweh->event_q);
 371 }
 372
 373 /**
 374  * brcmf_fweh_detach() - cleanup firmware event handling.
 375  *
 376  * @drvr: driver information object.
 377  */
 378 void brcmf_fweh_detach(struct brcmf_pub *drvr)
 379 {
 380         struct brcmf_fweh_info *fweh = &drvr->fweh;
 381         struct brcmf_if *ifp = drvr->iflist[0];
 382         s8 eventmask[BRCMF_EVENTING_MASK_LEN];
 383
 384         if (ifp) {
 385                 /* clear all events */
 386                 memset(eventmask, 0, BRCMF_EVENTING_MASK_LEN);
 387                 (void)brcmf_fil_iovar_data_set(ifp, "event_msgs",
 388                                                eventmask,
 389                                                BRCMF_EVENTING_MASK_LEN);
 390         }
 391         /* cancel the worker */
 392         cancel_work_sync(&fweh->event_work);
 393         WARN_ON(!list_empty(&fweh->event_q));
 394         memset(fweh->evt_handler, 0, sizeof(fweh->evt_handler));
 395 }
 396
 397 /**
 398  * brcmf_fweh_register() - register handler for given event code.
 399  *
 400  * @drvr: driver information object.
 401  * @code: event code.
 402  * @handler: handler for the given event code.
 403  */
 404 int brcmf_fweh_register(struct brcmf_pub *drvr, enum brcmf_fweh_event_code code,
 405                         brcmf_fweh_handler_t handler)
 406 {
 407         if (drvr->fweh.evt_handler[code]) {
 408                 brcmf_dbg(ERROR, "event code %d already registered\n", code);
 409                 return -ENOSPC;
 410         }
 411         drvr->fweh.evt_handler[code] = handler;
 412         brcmf_dbg(TRACE, "event handler registered for %s\n",
 413                   brcmf_fweh_event_name(code));
 414         return 0;
 415 }
 416
 417 /**
 418  * brcmf_fweh_unregister() - remove handler for given code.
 419  *
 420  * @drvr: driver information object.
 421  * @code: event code.
 422  */
 423 void brcmf_fweh_unregister(struct brcmf_pub *drvr,
 424                            enum brcmf_fweh_event_code code)
 425 {
 426         brcmf_dbg(TRACE, "event handler cleared for %s\n",
 427                   brcmf_fweh_event_name(code));
 428         drvr->fweh.evt_handler[code] = NULL;
 429 }
 430
 431 /**
 432  * brcmf_fweh_activate_events() - enables firmware events registered.
 433  *
 434  * @ifp: primary interface object.
 435  */
 436 int brcmf_fweh_activate_events(struct brcmf_if *ifp)
 437 {
 438         int i, err;
 439         s8 eventmask[BRCMF_EVENTING_MASK_LEN];
 440
 441         for (i = 0; i < BRCMF_E_LAST; i++) {
 442                 if (ifp->drvr->fweh.evt_handler[i]) {
 443                         brcmf_dbg(EVENT, "enable event %s\n",
 444                                   brcmf_fweh_event_name(i));
 445                         setbit(eventmask, i);
 446                 }
 447         }
 448
 449         /* want to handle IF event as well */
 450         brcmf_dbg(EVENT, "enable event IF\n");
 451         setbit(eventmask, BRCMF_E_IF);
 452
 453         err = brcmf_fil_iovar_data_set(ifp, "event_msgs",
 454                                        eventmask, BRCMF_EVENTING_MASK_LEN);
 455         if (err)
 456                 brcmf_dbg(ERROR, "Set event_msgs error (%d)\n", err);
 457
 458         return err;
 459 }
 460
 461 /**
 462  * brcmf_fweh_process_event() - process skb as firmware event.
 463  *
 464  * @drvr: driver information object.
 465  * @event_packet: event packet to process.
 466  * @ifidx: index of the firmware interface (may change).
 467  *
 468  * If the packet buffer contains a firmware event message it will
 469  * dispatch the event to a registered handler (using worker).
 470  */
 471 void brcmf_fweh_process_event(struct brcmf_pub *drvr,
 472                               struct brcmf_event *event_packet, u8 *ifidx)
 473 {
 474         enum brcmf_fweh_event_code code;
 475         struct brcmf_fweh_info *fweh = &drvr->fweh;
 476         struct brcmf_fweh_queue_item *event;
 477         gfp_t alloc_flag = GFP_KERNEL;
 478         void *data;
 479         u32 datalen;
 480
 481         /* get event info */
 482         code = get_unaligned_be32(&event_packet->msg.event_type);
 483         datalen = get_unaligned_be32(&event_packet->msg.datalen);
 484         *ifidx = event_packet->msg.ifidx;
 485         data = &event_packet[1];
 486
 487         if (code >= BRCMF_E_LAST)
 488                 return;
 489
 490         if (code != BRCMF_E_IF && !fweh->evt_handler[code])
 491                 return;
 492
 493         if (in_interrupt())
 494                 alloc_flag = GFP_ATOMIC;
 495
 496         event = kzalloc(sizeof(*event) + datalen, alloc_flag);
 497         if (!event)
 498                 return;
 499
 500         event->code = code;
 501         event->ifidx = *ifidx;
 502
 503         /* use memcpy to get aligned event message */
 504         memcpy(&event->emsg, &event_packet->msg, sizeof(event->emsg));
 505         memcpy(event->data, data, datalen);
 506         memcpy(event->ifaddr, event_packet->eth.h_dest, ETH_ALEN);
 507
 508         brcmf_fweh_queue_event(fweh, event);
 509 }