Pileus Git - ~andy/linux/blob - drivers/usb/wusbcore/wa-nep.c

   1 /*
   2  * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
   3  * Notification EndPoint support
   4  *
   5  * Copyright (C) 2006 Intel Corporation
   6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.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 version
  10  * 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU 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 Street, Fifth Floor, Boston, MA
  20  * 02110-1301, USA.
  21  *
  22  *
  23  * This part takes care of getting the notification from the hw
  24  * only and dispatching through wusbwad into
  25  * wa_notif_dispatch. Handling is done there.
  26  *
  27  * WA notifications are limited in size; most of them are three or
  28  * four bytes long, and the longest is the HWA Device Notification,
  29  * which would not exceed 38 bytes (DNs are limited in payload to 32
  30  * bytes plus 3 bytes header (WUSB1.0[7.6p2]), plus 3 bytes HWA
  31  * header (WUSB1.0[8.5.4.2]).
  32  *
  33  * It is not clear if more than one Device Notification can be packed
  34  * in a HWA Notification, I assume no because of the wording in
  35  * WUSB1.0[8.5.4.2]. In any case, the bigger any notification could
  36  * get is 256 bytes (as the bLength field is a byte).
  37  *
  38  * So what we do is we have this buffer and read into it; when a
  39  * notification arrives we schedule work to a specific, single thread
  40  * workqueue (so notifications are serialized) and copy the
  41  * notification data. After scheduling the work, we rearm the read from
  42  * the notification endpoint.
  43  *
  44  * Entry points here are:
  45  *
  46  * wa_nep_[create|destroy]()   To initialize/release this subsystem
  47  *
  48  * wa_nep_cb()                 Callback for the notification
  49  *                                endpoint; when data is ready, this
  50  *                                does the dispatching.
  51  */
  52 #include <linux/workqueue.h>
  53 #include <linux/ctype.h>
  54 #include <linux/slab.h>
  55
  56 #include "wa-hc.h"
  57 #include "wusbhc.h"
  58
  59 /* Structure for queueing notifications to the workqueue */
  60 struct wa_notif_work {
  61         struct work_struct work;
  62         struct wahc *wa;
  63         size_t size;
  64         u8 data[];
  65 };
  66
  67 /*
  68  * Process incoming notifications from the WA's Notification EndPoint
  69  * [the wuswad daemon, basically]
  70  *
  71  * @_nw:        Pointer to a descriptor which has the pointer to the
  72  *              @wa, the size of the buffer and the work queue
  73  *              structure (so we can free all when done).
  74  * @returns     0 if ok, < 0 errno code on error.
  75  *
  76  * All notifications follow the same format; they need to start with a
  77  * 'struct wa_notif_hdr' header, so it is easy to parse through
  78  * them. We just break the buffer in individual notifications (the
  79  * standard doesn't say if it can be done or is forbidden, so we are
  80  * cautious) and dispatch each.
  81  *
  82  * So the handling layers are is:
  83  *
  84  *   WA specific notification (from NEP)
  85  *      Device Notification Received -> wa_handle_notif_dn()
  86  *        WUSB Device notification generic handling
  87  *      BPST Adjustment -> wa_handle_notif_bpst_adj()
  88  *      ... -> ...
  89  *
  90  * @wa has to be referenced
  91  */
  92 static void wa_notif_dispatch(struct work_struct *ws)
  93 {
  94         void *itr;
  95         u8 missing = 0;
  96         struct wa_notif_work *nw = container_of(ws, struct wa_notif_work, work);
  97         struct wahc *wa = nw->wa;
  98         struct wa_notif_hdr *notif_hdr;
  99         size_t size;
 100
 101         struct device *dev = &wa->usb_iface->dev;
 102
 103 #if 0
 104         /* FIXME: need to check for this??? */
 105         if (usb_hcd->state == HC_STATE_QUIESCING)       /* Going down? */
 106                 goto out;                               /* screw it */
 107 #endif
 108         atomic_dec(&wa->notifs_queued);         /* Throttling ctl */
 109         dev = &wa->usb_iface->dev;
 110         size = nw->size;
 111         itr = nw->data;
 112
 113         while (size) {
 114                 if (size < sizeof(*notif_hdr)) {
 115                         missing = sizeof(*notif_hdr) - size;
 116                         goto exhausted_buffer;
 117                 }
 118                 notif_hdr = itr;
 119                 if (size < notif_hdr->bLength)
 120                         goto exhausted_buffer;
 121                 itr += notif_hdr->bLength;
 122                 size -= notif_hdr->bLength;
 123                 /* Dispatch the notification [don't use itr or size!] */
 124                 switch (notif_hdr->bNotifyType) {
 125                 case HWA_NOTIF_DN: {
 126                         struct hwa_notif_dn *hwa_dn;
 127                         hwa_dn = container_of(notif_hdr, struct hwa_notif_dn,
 128                                               hdr);
 129                         wusbhc_handle_dn(wa->wusb, hwa_dn->bSourceDeviceAddr,
 130                                          hwa_dn->dndata,
 131                                          notif_hdr->bLength - sizeof(*hwa_dn));
 132                         break;
 133                 }
 134                 case WA_NOTIF_TRANSFER:
 135                         wa_handle_notif_xfer(wa, notif_hdr);
 136                         break;
 137                 case HWA_NOTIF_BPST_ADJ:
 138                         break; /* no action needed for BPST ADJ. */
 139                 case DWA_NOTIF_RWAKE:
 140                 case DWA_NOTIF_PORTSTATUS:
 141                         /* FIXME: unimplemented WA NOTIFs */
 142                         /* fallthru */
 143                 default:
 144                         dev_err(dev, "HWA: unknown notification 0x%x, "
 145                                 "%zu bytes; discarding\n",
 146                                 notif_hdr->bNotifyType,
 147                                 (size_t)notif_hdr->bLength);
 148                         break;
 149                 }
 150         }
 151 out:
 152         wa_put(wa);
 153         kfree(nw);
 154         return;
 155
 156         /* THIS SHOULD NOT HAPPEN
 157          *
 158          * Buffer exahusted with partial data remaining; just warn and
 159          * discard the data, as this should not happen.
 160          */
 161 exhausted_buffer:
 162         dev_warn(dev, "HWA: device sent short notification, "
 163                  "%d bytes missing; discarding %d bytes.\n",
 164                  missing, (int)size);
 165         goto out;
 166 }
 167
 168 /*
 169  * Deliver incoming WA notifications to the wusbwa workqueue
 170  *
 171  * @wa: Pointer the Wire Adapter Controller Data Streaming
 172  *              instance (part of an 'struct usb_hcd').
 173  * @size:       Size of the received buffer
 174  * @returns     0 if ok, < 0 errno code on error.
 175  *
 176  * The input buffer is @wa->nep_buffer, with @size bytes
 177  * (guaranteed to fit in the allocated space,
 178  * @wa->nep_buffer_size).
 179  */
 180 static int wa_nep_queue(struct wahc *wa, size_t size)
 181 {
 182         int result = 0;
 183         struct device *dev = &wa->usb_iface->dev;
 184         struct wa_notif_work *nw;
 185
 186         /* dev_fnstart(dev, "(wa %p, size %zu)\n", wa, size); */
 187         BUG_ON(size > wa->nep_buffer_size);
 188         if (size == 0)
 189                 goto out;
 190         if (atomic_read(&wa->notifs_queued) > 200) {
 191                 if (printk_ratelimit())
 192                         dev_err(dev, "Too many notifications queued, "
 193                                 "throttling back\n");
 194                 goto out;
 195         }
 196         nw = kzalloc(sizeof(*nw) + size, GFP_ATOMIC);
 197         if (nw == NULL) {
 198                 if (printk_ratelimit())
 199                         dev_err(dev, "No memory to queue notification\n");
 200                 goto out;
 201         }
 202         INIT_WORK(&nw->work, wa_notif_dispatch);
 203         nw->wa = wa_get(wa);
 204         nw->size = size;
 205         memcpy(nw->data, wa->nep_buffer, size);
 206         atomic_inc(&wa->notifs_queued);         /* Throttling ctl */
 207         queue_work(wusbd, &nw->work);
 208 out:
 209         /* dev_fnend(dev, "(wa %p, size %zu) = result\n", wa, size, result); */
 210         return result;
 211 }
 212
 213 /*
 214  * Callback for the notification event endpoint
 215  *
 216  * Check's that everything is fine and then passes the data to be
 217  * queued to the workqueue.
 218  */
 219 static void wa_nep_cb(struct urb *urb)
 220 {
 221         int result;
 222         struct wahc *wa = urb->context;
 223         struct device *dev = &wa->usb_iface->dev;
 224
 225         switch (result = urb->status) {
 226         case 0:
 227                 result = wa_nep_queue(wa, urb->actual_length);
 228                 if (result < 0)
 229                         dev_err(dev, "NEP: unable to process notification(s): "
 230                                 "%d\n", result);
 231                 break;
 232         case -ECONNRESET:       /* Not an error, but a controlled situation; */
 233         case -ENOENT:           /* (we killed the URB)...so, no broadcast */
 234         case -ESHUTDOWN:
 235                 dev_dbg(dev, "NEP: going down %d\n", urb->status);
 236                 goto out;
 237         default:        /* On general errors, we retry unless it gets ugly */
 238                 if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
 239                             EDC_ERROR_TIMEFRAME)) {
 240                         dev_err(dev, "NEP: URB max acceptable errors "
 241                                 "exceeded, resetting device\n");
 242                         wa_reset_all(wa);
 243                         goto out;
 244                 }
 245                 dev_err(dev, "NEP: URB error %d\n", urb->status);
 246         }
 247         result = wa_nep_arm(wa, GFP_ATOMIC);
 248         if (result < 0) {
 249                 dev_err(dev, "NEP: cannot submit URB: %d\n", result);
 250                 wa_reset_all(wa);
 251         }
 252 out:
 253         return;
 254 }
 255
 256 /*
 257  * Initialize @wa's notification and event's endpoint stuff
 258  *
 259  * This includes the allocating the read buffer, the context ID
 260  * allocation bitmap, the URB and submitting the URB.
 261  */
 262 int wa_nep_create(struct wahc *wa, struct usb_interface *iface)
 263 {
 264         int result;
 265         struct usb_endpoint_descriptor *epd;
 266         struct usb_device *usb_dev = interface_to_usbdev(iface);
 267         struct device *dev = &iface->dev;
 268
 269         edc_init(&wa->nep_edc);
 270         epd = &iface->cur_altsetting->endpoint[0].desc;
 271         wa->nep_buffer_size = 1024;
 272         wa->nep_buffer = kmalloc(wa->nep_buffer_size, GFP_KERNEL);
 273         if (wa->nep_buffer == NULL) {
 274                 dev_err(dev, "Unable to allocate notification's read buffer\n");
 275                 goto error_nep_buffer;
 276         }
 277         wa->nep_urb = usb_alloc_urb(0, GFP_KERNEL);
 278         if (wa->nep_urb == NULL) {
 279                 dev_err(dev, "Unable to allocate notification URB\n");
 280                 goto error_urb_alloc;
 281         }
 282         usb_fill_int_urb(wa->nep_urb, usb_dev,
 283                          usb_rcvintpipe(usb_dev, epd->bEndpointAddress),
 284                          wa->nep_buffer, wa->nep_buffer_size,
 285                          wa_nep_cb, wa, epd->bInterval);
 286         result = wa_nep_arm(wa, GFP_KERNEL);
 287         if (result < 0) {
 288                 dev_err(dev, "Cannot submit notification URB: %d\n", result);
 289                 goto error_nep_arm;
 290         }
 291         return 0;
 292
 293 error_nep_arm:
 294         usb_free_urb(wa->nep_urb);
 295 error_urb_alloc:
 296         kfree(wa->nep_buffer);
 297 error_nep_buffer:
 298         return -ENOMEM;
 299 }
 300
 301 void wa_nep_destroy(struct wahc *wa)
 302 {
 303         wa_nep_disarm(wa);
 304         usb_free_urb(wa->nep_urb);
 305         kfree(wa->nep_buffer);
 306 }