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