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 "tracepoint.h"
  24 #include "fwsignal.h"
  25 #include "fweh.h"
  26 #include "fwil.h"
  27
  28 /**
  29  * struct brcmf_fweh_queue_item - event item on event queue.
  30  *
  31  * @q: list element for queuing.
  32  * @code: event code.
  33  * @ifidx: interface index related to this event.
  34  * @ifaddr: ethernet address for interface.
  35  * @emsg: common parameters of the firmware event message.
  36  * @data: event specific data part of the firmware event.
  37  */
  38 struct brcmf_fweh_queue_item {
  39         struct list_head q;
  40         enum brcmf_fweh_event_code code;
  41         u8 ifidx;
  42         u8 ifaddr[ETH_ALEN];
  43         struct brcmf_event_msg_be emsg;
  44         u32 datalen;
  45         u8 data[0];
  46 };
  47
  48 /**
  49  * struct brcmf_fweh_event_name - code, name mapping entry.
  50  */
  51 struct brcmf_fweh_event_name {
  52         enum brcmf_fweh_event_code code;
  53         const char *name;
  54 };
  55
  56 #ifdef DEBUG
  57 #define BRCMF_ENUM_DEF(id, val) \
  58         { val, #id },
  59
  60 /* array for mapping code to event name */
  61 static struct brcmf_fweh_event_name fweh_event_names[] = {
  62         BRCMF_FWEH_EVENT_ENUM_DEFLIST
  63 };
  64 #undef BRCMF_ENUM_DEF
  65
  66 /**
  67  * brcmf_fweh_event_name() - returns name for given event code.
  68  *
  69  * @code: code to lookup.
  70  */
  71 static const char *brcmf_fweh_event_name(enum brcmf_fweh_event_code code)
  72 {
  73         int i;
  74         for (i = 0; i < ARRAY_SIZE(fweh_event_names); i++) {
  75                 if (fweh_event_names[i].code == code)
  76                         return fweh_event_names[i].name;
  77         }
  78         return "unknown";
  79 }
  80 #else
  81 static const char *brcmf_fweh_event_name(enum brcmf_fweh_event_code code)
  82 {
  83         return "nodebug";
  84 }
  85 #endif
  86
  87 /**
  88  * brcmf_fweh_queue_event() - create and queue event.
  89  *
  90  * @fweh: firmware event handling info.
  91  * @event: event queue entry.
  92  */
  93 static void brcmf_fweh_queue_event(struct brcmf_fweh_info *fweh,
  94                                    struct brcmf_fweh_queue_item *event)
  95 {
  96         ulong flags;
  97
  98         spin_lock_irqsave(&fweh->evt_q_lock, flags);
  99         list_add_tail(&event->q, &fweh->event_q);
 100         spin_unlock_irqrestore(&fweh->evt_q_lock, flags);
 101         schedule_work(&fweh->event_work);
 102 }
 103
 104 static int brcmf_fweh_call_event_handler(struct brcmf_if *ifp,
 105                                          enum brcmf_fweh_event_code code,
 106                                          struct brcmf_event_msg *emsg,
 107                                          void *data)
 108 {
 109         struct brcmf_fweh_info *fweh;
 110         int err = -EINVAL;
 111
 112         if (ifp) {
 113                 fweh = &ifp->drvr->fweh;
 114
 115                 /* handle the event if valid interface and handler */
 116                 if (fweh->evt_handler[code])
 117                         err = fweh->evt_handler[code](ifp, emsg, data);
 118                 else
 119                         brcmf_err("unhandled event %d ignored\n", code);
 120         } else {
 121                 brcmf_err("no interface object\n");
 122         }
 123         return err;
 124 }
 125
 126 /**
 127  * brcmf_fweh_handle_if_event() - handle IF event.
 128  *
 129  * @drvr: driver information object.
 130  * @item: queue entry.
 131  * @ifpp: interface object (may change upon ADD action).
 132  */
 133 static void brcmf_fweh_handle_if_event(struct brcmf_pub *drvr,
 134                                        struct brcmf_event_msg *emsg,
 135                                        void *data)
 136 {
 137         struct brcmf_if_event *ifevent = data;
 138         struct brcmf_if *ifp;
 139         int err = 0;
 140
 141         brcmf_dbg(EVENT, "action: %u idx: %u bsscfg: %u flags: %u role: %u\n",
 142                   ifevent->action, ifevent->ifidx, ifevent->bssidx,
 143                   ifevent->flags, ifevent->role);
 144
 145         /* The P2P Device interface event must not be ignored
 146          * contrary to what firmware tells us. The only way to
 147          * distinguish the P2P Device is by looking at the ifidx
 148          * and bssidx received.
 149          */
 150         if (!(ifevent->ifidx == 0 && ifevent->bssidx == 1) &&
 151             (ifevent->flags & BRCMF_E_IF_FLAG_NOIF)) {
 152                 brcmf_dbg(EVENT, "event can be ignored\n");
 153                 return;
 154         }
 155         if (ifevent->ifidx >= BRCMF_MAX_IFS) {
 156                 brcmf_err("invalid interface index: %u\n",
 157                           ifevent->ifidx);
 158                 return;
 159         }
 160
 161         ifp = drvr->iflist[ifevent->bssidx];
 162
 163         if (ifevent->action == BRCMF_E_IF_ADD) {
 164                 brcmf_dbg(EVENT, "adding %s (%pM)\n", emsg->ifname,
 165                           emsg->addr);
 166                 ifp = brcmf_add_if(drvr, ifevent->bssidx, ifevent->ifidx,
 167                                    emsg->ifname, emsg->addr);
 168                 if (IS_ERR(ifp))
 169                         return;
 170                 brcmf_fws_add_interface(ifp);
 171                 if (!drvr->fweh.evt_handler[BRCMF_E_IF])
 172                         if (brcmf_net_attach(ifp, false) < 0)
 173                                 return;
 174         }
 175
 176         if (ifp && ifevent->action == BRCMF_E_IF_CHANGE)
 177                 brcmf_fws_reset_interface(ifp);
 178
 179         err = brcmf_fweh_call_event_handler(ifp, emsg->event_code, emsg, data);
 180
 181         if (ifp && ifevent->action == BRCMF_E_IF_DEL) {
 182                 brcmf_fws_del_interface(ifp);
 183                 brcmf_del_if(drvr, ifevent->bssidx);
 184         }
 185 }
 186
 187 /**
 188  * brcmf_fweh_dequeue_event() - get event from the queue.
 189  *
 190  * @fweh: firmware event handling info.
 191  */
 192 static struct brcmf_fweh_queue_item *
 193 brcmf_fweh_dequeue_event(struct brcmf_fweh_info *fweh)
 194 {
 195         struct brcmf_fweh_queue_item *event = NULL;
 196         ulong flags;
 197
 198         spin_lock_irqsave(&fweh->evt_q_lock, flags);
 199         if (!list_empty(&fweh->event_q)) {
 200                 event = list_first_entry(&fweh->event_q,
 201                                          struct brcmf_fweh_queue_item, q);
 202                 list_del(&event->q);
 203         }
 204         spin_unlock_irqrestore(&fweh->evt_q_lock, flags);
 205
 206         return event;
 207 }
 208
 209 /**
 210  * brcmf_fweh_event_worker() - firmware event worker.
 211  *
 212  * @work: worker object.
 213  */
 214 static void brcmf_fweh_event_worker(struct work_struct *work)
 215 {
 216         struct brcmf_pub *drvr;
 217         struct brcmf_if *ifp;
 218         struct brcmf_fweh_info *fweh;
 219         struct brcmf_fweh_queue_item *event;
 220         int err = 0;
 221         struct brcmf_event_msg_be *emsg_be;
 222         struct brcmf_event_msg emsg;
 223
 224         fweh = container_of(work, struct brcmf_fweh_info, event_work);
 225         drvr = container_of(fweh, struct brcmf_pub, fweh);
 226
 227         while ((event = brcmf_fweh_dequeue_event(fweh))) {
 228                 brcmf_dbg(EVENT, "event %s (%u) ifidx %u bsscfg %u addr %pM\n",
 229                           brcmf_fweh_event_name(event->code), event->code,
 230                           event->emsg.ifidx, event->emsg.bsscfgidx,
 231                           event->emsg.addr);
 232
 233                 /* convert event message */
 234                 emsg_be = &event->emsg;
 235                 emsg.version = be16_to_cpu(emsg_be->version);
 236                 emsg.flags = be16_to_cpu(emsg_be->flags);
 237                 emsg.event_code = event->code;
 238                 emsg.status = be32_to_cpu(emsg_be->status);
 239                 emsg.reason = be32_to_cpu(emsg_be->reason);
 240                 emsg.auth_type = be32_to_cpu(emsg_be->auth_type);
 241                 emsg.datalen = be32_to_cpu(emsg_be->datalen);
 242                 memcpy(emsg.addr, emsg_be->addr, ETH_ALEN);
 243                 memcpy(emsg.ifname, emsg_be->ifname, sizeof(emsg.ifname));
 244                 emsg.ifidx = emsg_be->ifidx;
 245                 emsg.bsscfgidx = emsg_be->bsscfgidx;
 246
 247                 brcmf_dbg(EVENT, "  version %u flags %u status %u reason %u\n",
 248                           emsg.version, emsg.flags, emsg.status, emsg.reason);
 249                 brcmf_dbg_hex_dump(BRCMF_EVENT_ON(), event->data,
 250                                    min_t(u32, emsg.datalen, 64),
 251                                    "event payload, len=%d\n", emsg.datalen);
 252                 if (emsg.datalen > event->datalen) {
 253                         brcmf_err("event invalid length header=%d, msg=%d\n",
 254                                   event->datalen, emsg.datalen);
 255                         goto event_free;
 256                 }
 257
 258                 /* special handling of interface event */
 259                 if (event->code == BRCMF_E_IF) {
 260                         brcmf_fweh_handle_if_event(drvr, &emsg, event->data);
 261                         goto event_free;
 262                 }
 263
 264                 ifp = drvr->iflist[emsg.bsscfgidx];
 265                 err = brcmf_fweh_call_event_handler(ifp, event->code, &emsg,
 266                                                     event->data);
 267                 if (err) {
 268                         brcmf_err("event handler failed (%d)\n",
 269                                   event->code);
 270                         err = 0;
 271                 }
 272 event_free:
 273                 kfree(event);
 274         }
 275 }
 276
 277 /**
 278  * brcmf_fweh_attach() - initialize firmware event handling.
 279  *
 280  * @drvr: driver information object.
 281  */
 282 void brcmf_fweh_attach(struct brcmf_pub *drvr)
 283 {
 284         struct brcmf_fweh_info *fweh = &drvr->fweh;
 285         INIT_WORK(&fweh->event_work, brcmf_fweh_event_worker);
 286         spin_lock_init(&fweh->evt_q_lock);
 287         INIT_LIST_HEAD(&fweh->event_q);
 288 }
 289
 290 /**
 291  * brcmf_fweh_detach() - cleanup firmware event handling.
 292  *
 293  * @drvr: driver information object.
 294  */
 295 void brcmf_fweh_detach(struct brcmf_pub *drvr)
 296 {
 297         struct brcmf_fweh_info *fweh = &drvr->fweh;
 298         struct brcmf_if *ifp = drvr->iflist[0];
 299         s8 eventmask[BRCMF_EVENTING_MASK_LEN];
 300
 301         if (ifp) {
 302                 /* clear all events */
 303                 memset(eventmask, 0, BRCMF_EVENTING_MASK_LEN);
 304                 (void)brcmf_fil_iovar_data_set(ifp, "event_msgs",
 305                                                eventmask,
 306                                                BRCMF_EVENTING_MASK_LEN);
 307         }
 308         /* cancel the worker */
 309         cancel_work_sync(&fweh->event_work);
 310         WARN_ON(!list_empty(&fweh->event_q));
 311         memset(fweh->evt_handler, 0, sizeof(fweh->evt_handler));
 312 }
 313
 314 /**
 315  * brcmf_fweh_register() - register handler for given event code.
 316  *
 317  * @drvr: driver information object.
 318  * @code: event code.
 319  * @handler: handler for the given event code.
 320  */
 321 int brcmf_fweh_register(struct brcmf_pub *drvr, enum brcmf_fweh_event_code code,
 322                         brcmf_fweh_handler_t handler)
 323 {
 324         if (drvr->fweh.evt_handler[code]) {
 325                 brcmf_err("event code %d already registered\n", code);
 326                 return -ENOSPC;
 327         }
 328         drvr->fweh.evt_handler[code] = handler;
 329         brcmf_dbg(TRACE, "event handler registered for %s\n",
 330                   brcmf_fweh_event_name(code));
 331         return 0;
 332 }
 333
 334 /**
 335  * brcmf_fweh_unregister() - remove handler for given code.
 336  *
 337  * @drvr: driver information object.
 338  * @code: event code.
 339  */
 340 void brcmf_fweh_unregister(struct brcmf_pub *drvr,
 341                            enum brcmf_fweh_event_code code)
 342 {
 343         brcmf_dbg(TRACE, "event handler cleared for %s\n",
 344                   brcmf_fweh_event_name(code));
 345         drvr->fweh.evt_handler[code] = NULL;
 346 }
 347
 348 /**
 349  * brcmf_fweh_activate_events() - enables firmware events registered.
 350  *
 351  * @ifp: primary interface object.
 352  */
 353 int brcmf_fweh_activate_events(struct brcmf_if *ifp)
 354 {
 355         int i, err;
 356         s8 eventmask[BRCMF_EVENTING_MASK_LEN];
 357
 358         for (i = 0; i < BRCMF_E_LAST; i++) {
 359                 if (ifp->drvr->fweh.evt_handler[i]) {
 360                         brcmf_dbg(EVENT, "enable event %s\n",
 361                                   brcmf_fweh_event_name(i));
 362                         setbit(eventmask, i);
 363                 }
 364         }
 365
 366         /* want to handle IF event as well */
 367         brcmf_dbg(EVENT, "enable event IF\n");
 368         setbit(eventmask, BRCMF_E_IF);
 369
 370         err = brcmf_fil_iovar_data_set(ifp, "event_msgs",
 371                                        eventmask, BRCMF_EVENTING_MASK_LEN);
 372         if (err)
 373                 brcmf_err("Set event_msgs error (%d)\n", err);
 374
 375         return err;
 376 }
 377
 378 /**
 379  * brcmf_fweh_process_event() - process skb as firmware event.
 380  *
 381  * @drvr: driver information object.
 382  * @event_packet: event packet to process.
 383  *
 384  * If the packet buffer contains a firmware event message it will
 385  * dispatch the event to a registered handler (using worker).
 386  */
 387 void brcmf_fweh_process_event(struct brcmf_pub *drvr,
 388                               struct brcmf_event *event_packet,
 389                               u32 packet_len)
 390 {
 391         enum brcmf_fweh_event_code code;
 392         struct brcmf_fweh_info *fweh = &drvr->fweh;
 393         struct brcmf_fweh_queue_item *event;
 394         gfp_t alloc_flag = GFP_KERNEL;
 395         void *data;
 396         u32 datalen;
 397
 398         /* get event info */
 399         code = get_unaligned_be32(&event_packet->msg.event_type);
 400         datalen = get_unaligned_be32(&event_packet->msg.datalen);
 401         data = &event_packet[1];
 402
 403         if (code >= BRCMF_E_LAST)
 404                 return;
 405
 406         if (code != BRCMF_E_IF && !fweh->evt_handler[code])
 407                 return;
 408
 409         if (datalen > BRCMF_DCMD_MAXLEN ||
 410             datalen + sizeof(*event_packet) > packet_len)
 411                 return;
 412
 413         if (in_interrupt())
 414                 alloc_flag = GFP_ATOMIC;
 415
 416         event = kzalloc(sizeof(*event) + datalen, alloc_flag);
 417         if (!event)
 418                 return;
 419
 420         event->code = code;
 421         event->ifidx = event_packet->msg.ifidx;
 422
 423         /* use memcpy to get aligned event message */
 424         memcpy(&event->emsg, &event_packet->msg, sizeof(event->emsg));
 425         memcpy(event->data, data, datalen);
 426         event->datalen = datalen;
 427         memcpy(event->ifaddr, event_packet->eth.h_dest, ETH_ALEN);
 428
 429         brcmf_fweh_queue_event(fweh, event);
 430 }