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 */ 60struct 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 */ 92static 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, 97 work); 98 struct wahc *wa = nw->wa; 99 struct wa_notif_hdr *notif_hdr; 100 size_t size; 101 102 struct device *dev = &wa->usb_iface->dev; 103 104#if 0 105 /* FIXME: need to check for this??? */ 106 if (usb_hcd->state == HC_STATE_QUIESCING) /* Going down? */ 107 goto out; /* screw it */ 108#endif 109 atomic_dec(&wa->notifs_queued); /* Throttling ctl */ 110 dev = &wa->usb_iface->dev; 111 size = nw->size; 112 itr = nw->data; 113 114 while (size) { 115 if (size < sizeof(*notif_hdr)) { 116 missing = sizeof(*notif_hdr) - size; 117 goto exhausted_buffer; 118 } 119 notif_hdr = itr; 120 if (size < notif_hdr->bLength) 121 goto exhausted_buffer; 122 itr += notif_hdr->bLength; 123 size -= notif_hdr->bLength; 124 /* Dispatch the notification [don't use itr or size!] */ 125 switch (notif_hdr->bNotifyType) { 126 case HWA_NOTIF_DN: { 127 struct hwa_notif_dn *hwa_dn; 128 hwa_dn = container_of(notif_hdr, struct hwa_notif_dn, 129 hdr); 130 wusbhc_handle_dn(wa->wusb, hwa_dn->bSourceDeviceAddr, 131 hwa_dn->dndata, 132 notif_hdr->bLength - sizeof(*hwa_dn)); 133 break; 134 } 135 case WA_NOTIF_TRANSFER: 136 wa_handle_notif_xfer(wa, notif_hdr); 137 break; 138 case HWA_NOTIF_BPST_ADJ: 139 break; /* no action needed for BPST ADJ. */ 140 case DWA_NOTIF_RWAKE: 141 case DWA_NOTIF_PORTSTATUS: 142 /* FIXME: unimplemented WA NOTIFs */ 143 /* fallthru */ 144 default: 145 dev_err(dev, "HWA: unknown notification 0x%x, " 146 "%zu bytes; discarding\n", 147 notif_hdr->bNotifyType, 148 (size_t)notif_hdr->bLength); 149 break; 150 } 151 } 152out: 153 wa_put(wa); 154 kfree(nw); 155 return; 156 157 /* THIS SHOULD NOT HAPPEN 158 * 159 * Buffer exahusted with partial data remaining; just warn and 160 * discard the data, as this should not happen. 161 */ 162exhausted_buffer: 163 dev_warn(dev, "HWA: device sent short notification, " 164 "%d bytes missing; discarding %d bytes.\n", 165 missing, (int)size); 166 goto out; 167} 168 169/* 170 * Deliver incoming WA notifications to the wusbwa workqueue 171 * 172 * @wa: Pointer the Wire Adapter Controller Data Streaming 173 * instance (part of an 'struct usb_hcd'). 174 * @size: Size of the received buffer 175 * @returns 0 if ok, < 0 errno code on error. 176 * 177 * The input buffer is @wa->nep_buffer, with @size bytes 178 * (guaranteed to fit in the allocated space, 179 * @wa->nep_buffer_size). 180 */ 181static int wa_nep_queue(struct wahc *wa, size_t size) 182{ 183 int result = 0; 184 struct device *dev = &wa->usb_iface->dev; 185 struct wa_notif_work *nw; 186 187 /* dev_fnstart(dev, "(wa %p, size %zu)\n", wa, size); */ 188 BUG_ON(size > wa->nep_buffer_size); 189 if (size == 0) 190 goto out; 191 if (atomic_read(&wa->notifs_queued) > 200) { 192 if (printk_ratelimit()) 193 dev_err(dev, "Too many notifications queued, " 194 "throttling back\n"); 195 goto out; 196 } 197 nw = kzalloc(sizeof(*nw) + size, GFP_ATOMIC); 198 if (nw == NULL) { 199 if (printk_ratelimit()) 200 dev_err(dev, "No memory to queue notification\n"); 201 goto out; 202 } 203 INIT_WORK(&nw->work, wa_notif_dispatch); 204 nw->wa = wa_get(wa); 205 nw->size = size; 206 memcpy(nw->data, wa->nep_buffer, size); 207 atomic_inc(&wa->notifs_queued); /* Throttling ctl */ 208 queue_work(wusbd, &nw->work); 209out: 210 /* dev_fnend(dev, "(wa %p, size %zu) = result\n", wa, size, result); */ 211 return result; 212} 213 214/* 215 * Callback for the notification event endpoint 216 * 217 * Check's that everything is fine and then passes the data to be 218 * queued to the workqueue. 219 */ 220static void wa_nep_cb(struct urb *urb) 221{ 222 int result; 223 struct wahc *wa = urb->context; 224 struct device *dev = &wa->usb_iface->dev; 225 226 switch (result = urb->status) { 227 case 0: 228 result = wa_nep_queue(wa, urb->actual_length); 229 if (result < 0) 230 dev_err(dev, "NEP: unable to process notification(s): " 231 "%d\n", result); 232 break; 233 case -ECONNRESET: /* Not an error, but a controlled situation; */ 234 case -ENOENT: /* (we killed the URB)...so, no broadcast */ 235 case -ESHUTDOWN: 236 dev_dbg(dev, "NEP: going down %d\n", urb->status); 237 goto out; 238 default: /* On general errors, we retry unless it gets ugly */ 239 if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS, 240 EDC_ERROR_TIMEFRAME)) { 241 dev_err(dev, "NEP: URB max acceptable errors " 242 "exceeded, resetting device\n"); 243 wa_reset_all(wa); 244 goto out; 245 } 246 dev_err(dev, "NEP: URB error %d\n", urb->status); 247 } 248 result = wa_nep_arm(wa, GFP_ATOMIC); 249 if (result < 0) { 250 dev_err(dev, "NEP: cannot submit URB: %d\n", result); 251 wa_reset_all(wa); 252 } 253out: 254 return; 255} 256 257/* 258 * Initialize @wa's notification and event's endpoint stuff 259 * 260 * This includes the allocating the read buffer, the context ID 261 * allocation bitmap, the URB and submitting the URB. 262 */ 263int wa_nep_create(struct wahc *wa, struct usb_interface *iface) 264{ 265 int result; 266 struct usb_endpoint_descriptor *epd; 267 struct usb_device *usb_dev = interface_to_usbdev(iface); 268 struct device *dev = &iface->dev; 269 270 edc_init(&wa->nep_edc); 271 epd = &iface->cur_altsetting->endpoint[0].desc; 272 wa->nep_buffer_size = 1024; 273 wa->nep_buffer = kmalloc(wa->nep_buffer_size, GFP_KERNEL); 274 if (wa->nep_buffer == NULL) { 275 dev_err(dev, 276 "Unable to allocate notification's read buffer\n"); 277 goto error_nep_buffer; 278 } 279 wa->nep_urb = usb_alloc_urb(0, GFP_KERNEL); 280 if (wa->nep_urb == NULL) { 281 dev_err(dev, "Unable to allocate notification URB\n"); 282 goto error_urb_alloc; 283 } 284 usb_fill_int_urb(wa->nep_urb, usb_dev, 285 usb_rcvintpipe(usb_dev, epd->bEndpointAddress), 286 wa->nep_buffer, wa->nep_buffer_size, 287 wa_nep_cb, wa, epd->bInterval); 288 result = wa_nep_arm(wa, GFP_KERNEL); 289 if (result < 0) { 290 dev_err(dev, "Cannot submit notification URB: %d\n", result); 291 goto error_nep_arm; 292 } 293 return 0; 294 295error_nep_arm: 296 usb_free_urb(wa->nep_urb); 297error_urb_alloc: 298 kfree(wa->nep_buffer); 299error_nep_buffer: 300 return -ENOMEM; 301} 302 303void wa_nep_destroy(struct wahc *wa) 304{ 305 wa_nep_disarm(wa); 306 usb_free_urb(wa->nep_urb); 307 kfree(wa->nep_buffer); 308} 309