xref: /freebsd/sys/dev/usb/usb_pf.c (revision f5f7c05209ca2c3748fd8b27c5e80ffad49120eb)
1 /* $FreeBSD$ */
2 /*-
3  * Copyright (c) 1990, 1991, 1993
4  *	The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from the Stanford/CMU enet packet filter,
7  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
8  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
9  * Berkeley Laboratory.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 4. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 
36 #ifdef USB_GLOBAL_INCLUDE_FILE
37 #include USB_GLOBAL_INCLUDE_FILE
38 #else
39 #include <sys/param.h>
40 #include <sys/kernel.h>
41 #include <sys/bus.h>
42 #include <sys/fcntl.h>
43 #include <sys/malloc.h>
44 #include <sys/proc.h>
45 #include <sys/socket.h>
46 #include <sys/sockio.h>
47 #include <net/if.h>
48 #include <net/if_types.h>
49 #include <net/if_clone.h>
50 #include <net/bpf.h>
51 #include <sys/sysctl.h>
52 #include <net/route.h>
53 
54 #include <dev/usb/usb.h>
55 #include <dev/usb/usbdi.h>
56 #include <dev/usb/usb_busdma.h>
57 #include <dev/usb/usb_controller.h>
58 #include <dev/usb/usb_core.h>
59 #include <dev/usb/usb_process.h>
60 #include <dev/usb/usb_device.h>
61 #include <dev/usb/usb_bus.h>
62 #include <dev/usb/usb_pf.h>
63 #include <dev/usb/usb_transfer.h>
64 #endif			/* USB_GLOBAL_INCLUDE_FILE */
65 
66 static void usbpf_init(void);
67 static void usbpf_uninit(void);
68 static int usbpf_ioctl(struct ifnet *, u_long, caddr_t);
69 static int usbpf_clone_match(struct if_clone *, const char *);
70 static int usbpf_clone_create(struct if_clone *, char *, size_t, caddr_t);
71 static int usbpf_clone_destroy(struct if_clone *, struct ifnet *);
72 static struct usb_bus *usbpf_ifname2ubus(const char *);
73 static uint32_t usbpf_aggregate_xferflags(struct usb_xfer_flags *);
74 static uint32_t usbpf_aggregate_status(struct usb_xfer_flags_int *);
75 static int usbpf_xfer_frame_is_read(struct usb_xfer *, uint32_t);
76 static uint32_t usbpf_xfer_precompute_size(struct usb_xfer *, int);
77 
78 static struct if_clone *usbpf_cloner;
79 static const char usbusname[] = "usbus";
80 
81 SYSINIT(usbpf_init, SI_SUB_PSEUDO, SI_ORDER_MIDDLE, usbpf_init, NULL);
82 SYSUNINIT(usbpf_uninit, SI_SUB_PSEUDO, SI_ORDER_MIDDLE, usbpf_uninit, NULL);
83 
84 static void
85 usbpf_init(void)
86 {
87 
88 	usbpf_cloner = if_clone_advanced(usbusname, 0, usbpf_clone_match,
89 	    usbpf_clone_create, usbpf_clone_destroy);
90 }
91 
92 static void
93 usbpf_uninit(void)
94 {
95 	int devlcnt;
96 	device_t *devlp;
97 	devclass_t dc;
98 	struct usb_bus *ubus;
99 	int error;
100 	int i;
101 
102 	if_clone_detach(usbpf_cloner);
103 
104 	dc = devclass_find(usbusname);
105 	if (dc == NULL)
106 		return;
107 	error = devclass_get_devices(dc, &devlp, &devlcnt);
108 	if (error)
109 		return;
110 	for (i = 0; i < devlcnt; i++) {
111 		ubus = device_get_softc(devlp[i]);
112 		if (ubus != NULL && ubus->ifp != NULL)
113 			usbpf_clone_destroy(usbpf_cloner, ubus->ifp);
114 	}
115 	free(devlp, M_TEMP);
116 }
117 
118 static int
119 usbpf_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
120 {
121 
122 	/* No configuration allowed. */
123 	return (EINVAL);
124 }
125 
126 static struct usb_bus *
127 usbpf_ifname2ubus(const char *ifname)
128 {
129 	device_t dev;
130 	devclass_t dc;
131 	int unit;
132 	int error;
133 
134 	if (strncmp(ifname, usbusname, sizeof(usbusname) - 1) != 0)
135 		return (NULL);
136 	error = ifc_name2unit(ifname, &unit);
137 	if (error || unit < 0)
138 		return (NULL);
139 	dc = devclass_find(usbusname);
140 	if (dc == NULL)
141 		return (NULL);
142 	dev = devclass_get_device(dc, unit);
143 	if (dev == NULL)
144 		return (NULL);
145 
146 	return (device_get_softc(dev));
147 }
148 
149 static int
150 usbpf_clone_match(struct if_clone *ifc, const char *name)
151 {
152 	struct usb_bus *ubus;
153 
154 	ubus = usbpf_ifname2ubus(name);
155 	if (ubus == NULL)
156 		return (0);
157 	if (ubus->ifp != NULL)
158 		return (0);
159 
160 	return (1);
161 }
162 
163 static int
164 usbpf_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params)
165 {
166 	int error;
167 	int unit;
168 	struct ifnet *ifp;
169 	struct usb_bus *ubus;
170 
171 	error = ifc_name2unit(name, &unit);
172 	if (error)
173 		return (error);
174  	if (unit < 0)
175 		return (EINVAL);
176 
177 	ubus = usbpf_ifname2ubus(name);
178 	if (ubus == NULL)
179 		return (1);
180 	if (ubus->ifp != NULL)
181 		return (1);
182 
183 	error = ifc_alloc_unit(ifc, &unit);
184 	if (error) {
185 		ifc_free_unit(ifc, unit);
186 		device_printf(ubus->parent, "usbpf: Could not allocate "
187 		    "instance\n");
188 		return (error);
189 	}
190 	ifp = ubus->ifp = if_alloc(IFT_USB);
191 	if (ifp == NULL) {
192 		ifc_free_unit(ifc, unit);
193 		device_printf(ubus->parent, "usbpf: Could not allocate "
194 		    "instance\n");
195 		return (ENOSPC);
196 	}
197 	strlcpy(ifp->if_xname, name, sizeof(ifp->if_xname));
198 	ifp->if_softc = ubus;
199 	ifp->if_dname = usbusname;
200 	ifp->if_dunit = unit;
201 	ifp->if_ioctl = usbpf_ioctl;
202 	if_attach(ifp);
203 	ifp->if_flags |= IFF_UP;
204 	rt_ifmsg(ifp);
205 	/*
206 	 * XXX According to the specification of DLT_USB, it indicates
207 	 * packets beginning with USB setup header. But not sure all
208 	 * packets would be.
209 	 */
210 	bpfattach(ifp, DLT_USB, USBPF_HDR_LEN);
211 
212 	return (0);
213 }
214 
215 static int
216 usbpf_clone_destroy(struct if_clone *ifc, struct ifnet *ifp)
217 {
218 	struct usb_bus *ubus;
219 	int unit;
220 
221 	ubus = ifp->if_softc;
222 	unit = ifp->if_dunit;
223 
224 	ubus->ifp = NULL;
225 	bpfdetach(ifp);
226 	if_detach(ifp);
227 	if_free(ifp);
228 	ifc_free_unit(ifc, unit);
229 
230 	return (0);
231 }
232 
233 void
234 usbpf_attach(struct usb_bus *ubus)
235 {
236 
237 	if (bootverbose)
238 		device_printf(ubus->parent, "usbpf: Attached\n");
239 }
240 
241 void
242 usbpf_detach(struct usb_bus *ubus)
243 {
244 
245 	if (ubus->ifp != NULL)
246 		usbpf_clone_destroy(usbpf_cloner, ubus->ifp);
247 	if (bootverbose)
248 		device_printf(ubus->parent, "usbpf: Detached\n");
249 }
250 
251 static uint32_t
252 usbpf_aggregate_xferflags(struct usb_xfer_flags *flags)
253 {
254 	uint32_t val = 0;
255 
256 	if (flags->force_short_xfer == 1)
257 		val |= USBPF_FLAG_FORCE_SHORT_XFER;
258 	if (flags->short_xfer_ok == 1)
259 		val |= USBPF_FLAG_SHORT_XFER_OK;
260 	if (flags->short_frames_ok == 1)
261 		val |= USBPF_FLAG_SHORT_FRAMES_OK;
262 	if (flags->pipe_bof == 1)
263 		val |= USBPF_FLAG_PIPE_BOF;
264 	if (flags->proxy_buffer == 1)
265 		val |= USBPF_FLAG_PROXY_BUFFER;
266 	if (flags->ext_buffer == 1)
267 		val |= USBPF_FLAG_EXT_BUFFER;
268 	if (flags->manual_status == 1)
269 		val |= USBPF_FLAG_MANUAL_STATUS;
270 	if (flags->no_pipe_ok == 1)
271 		val |= USBPF_FLAG_NO_PIPE_OK;
272 	if (flags->stall_pipe == 1)
273 		val |= USBPF_FLAG_STALL_PIPE;
274 	return (val);
275 }
276 
277 static uint32_t
278 usbpf_aggregate_status(struct usb_xfer_flags_int *flags)
279 {
280 	uint32_t val = 0;
281 
282 	if (flags->open == 1)
283 		val |= USBPF_STATUS_OPEN;
284 	if (flags->transferring == 1)
285 		val |= USBPF_STATUS_TRANSFERRING;
286 	if (flags->did_dma_delay == 1)
287 		val |= USBPF_STATUS_DID_DMA_DELAY;
288 	if (flags->did_close == 1)
289 		val |= USBPF_STATUS_DID_CLOSE;
290 	if (flags->draining == 1)
291 		val |= USBPF_STATUS_DRAINING;
292 	if (flags->started == 1)
293 		val |= USBPF_STATUS_STARTED;
294 	if (flags->bandwidth_reclaimed == 1)
295 		val |= USBPF_STATUS_BW_RECLAIMED;
296 	if (flags->control_xfr == 1)
297 		val |= USBPF_STATUS_CONTROL_XFR;
298 	if (flags->control_hdr == 1)
299 		val |= USBPF_STATUS_CONTROL_HDR;
300 	if (flags->control_act == 1)
301 		val |= USBPF_STATUS_CONTROL_ACT;
302 	if (flags->control_stall == 1)
303 		val |= USBPF_STATUS_CONTROL_STALL;
304 	if (flags->short_frames_ok == 1)
305 		val |= USBPF_STATUS_SHORT_FRAMES_OK;
306 	if (flags->short_xfer_ok == 1)
307 		val |= USBPF_STATUS_SHORT_XFER_OK;
308 #if USB_HAVE_BUSDMA
309 	if (flags->bdma_enable == 1)
310 		val |= USBPF_STATUS_BDMA_ENABLE;
311 	if (flags->bdma_no_post_sync == 1)
312 		val |= USBPF_STATUS_BDMA_NO_POST_SYNC;
313 	if (flags->bdma_setup == 1)
314 		val |= USBPF_STATUS_BDMA_SETUP;
315 #endif
316 	if (flags->isochronous_xfr == 1)
317 		val |= USBPF_STATUS_ISOCHRONOUS_XFR;
318 	if (flags->curr_dma_set == 1)
319 		val |= USBPF_STATUS_CURR_DMA_SET;
320 	if (flags->can_cancel_immed == 1)
321 		val |= USBPF_STATUS_CAN_CANCEL_IMMED;
322 	if (flags->doing_callback == 1)
323 		val |= USBPF_STATUS_DOING_CALLBACK;
324 
325 	return (val);
326 }
327 
328 static int
329 usbpf_xfer_frame_is_read(struct usb_xfer *xfer, uint32_t frame)
330 {
331 	int isread;
332 
333 	if ((frame == 0) && (xfer->flags_int.control_xfr != 0) &&
334 	    (xfer->flags_int.control_hdr != 0)) {
335 		/* special case */
336 		if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
337 			/* The device controller writes to memory */
338 			isread = 1;
339 		} else {
340 			/* The host controller reads from memory */
341 			isread = 0;
342 		}
343 	} else {
344 		isread = USB_GET_DATA_ISREAD(xfer);
345 	}
346 	return (isread);
347 }
348 
349 static uint32_t
350 usbpf_xfer_precompute_size(struct usb_xfer *xfer, int type)
351 {
352 	uint32_t totlen;
353 	uint32_t x;
354 	uint32_t nframes;
355 
356 	if (type == USBPF_XFERTAP_SUBMIT)
357 		nframes = xfer->nframes;
358 	else
359 		nframes = xfer->aframes;
360 
361 	totlen = USBPF_HDR_LEN + (USBPF_FRAME_HDR_LEN * nframes);
362 
363 	/* precompute all trace lengths */
364 	for (x = 0; x != nframes; x++) {
365 		if (usbpf_xfer_frame_is_read(xfer, x)) {
366 			if (type != USBPF_XFERTAP_SUBMIT) {
367 				totlen += USBPF_FRAME_ALIGN(
368 				    xfer->frlengths[x]);
369 			}
370 		} else {
371 			if (type == USBPF_XFERTAP_SUBMIT) {
372 				totlen += USBPF_FRAME_ALIGN(
373 				    xfer->frlengths[x]);
374 			}
375 		}
376 	}
377 	return (totlen);
378 }
379 
380 void
381 usbpf_xfertap(struct usb_xfer *xfer, int type)
382 {
383 	struct usb_bus *bus;
384 	struct usbpf_pkthdr *up;
385 	struct usbpf_framehdr *uf;
386 	usb_frlength_t offset;
387 	uint32_t totlen;
388 	uint32_t frame;
389 	uint32_t temp;
390 	uint32_t nframes;
391 	uint32_t x;
392 	uint8_t *buf;
393 	uint8_t *ptr;
394 
395 	bus = xfer->xroot->bus;
396 
397 	/* sanity checks */
398 	if (bus->ifp == NULL)
399 		return;
400 	if (!bpf_peers_present(bus->ifp->if_bpf))
401 		return;
402 
403 	totlen = usbpf_xfer_precompute_size(xfer, type);
404 
405 	if (type == USBPF_XFERTAP_SUBMIT)
406 		nframes = xfer->nframes;
407 	else
408 		nframes = xfer->aframes;
409 
410 	/*
411 	 * XXX TODO XXX
412 	 *
413 	 * When BPF supports it we could pass a fragmented array of
414 	 * buffers avoiding the data copy operation here.
415 	 */
416 	buf = ptr = malloc(totlen, M_TEMP, M_NOWAIT);
417 	if (buf == NULL) {
418 		device_printf(bus->parent, "usbpf: Out of memory\n");
419 		return;
420 	}
421 
422 	up = (struct usbpf_pkthdr *)ptr;
423 	ptr += USBPF_HDR_LEN;
424 
425 	/* fill out header */
426 	temp = device_get_unit(bus->bdev);
427 	up->up_totlen = htole32(totlen);
428 	up->up_busunit = htole32(temp);
429 	up->up_address = xfer->xroot->udev->device_index;
430 	if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
431 		up->up_mode = USBPF_MODE_DEVICE;
432 	else
433 		up->up_mode = USBPF_MODE_HOST;
434 	up->up_type = type;
435 	up->up_xfertype = xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE;
436 	temp = usbpf_aggregate_xferflags(&xfer->flags);
437 	up->up_flags = htole32(temp);
438 	temp = usbpf_aggregate_status(&xfer->flags_int);
439 	up->up_status = htole32(temp);
440 	temp = xfer->error;
441 	up->up_error = htole32(temp);
442 	temp = xfer->interval;
443 	up->up_interval = htole32(temp);
444 	up->up_frames = htole32(nframes);
445 	temp = xfer->max_packet_size;
446 	up->up_packet_size = htole32(temp);
447 	temp = xfer->max_packet_count;
448 	up->up_packet_count = htole32(temp);
449 	temp = xfer->endpointno;
450 	up->up_endpoint = htole32(temp);
451 	up->up_speed = xfer->xroot->udev->speed;
452 
453 	/* clear reserved area */
454 	memset(up->up_reserved, 0, sizeof(up->up_reserved));
455 
456 	/* init offset and frame */
457 	offset = 0;
458 	frame = 0;
459 
460 	/* iterate all the USB frames and copy data, if any */
461 	for (x = 0; x != nframes; x++) {
462 		uint32_t length;
463 		int isread;
464 
465 		/* get length */
466 		length = xfer->frlengths[x];
467 
468 		/* get frame header pointer */
469 		uf = (struct usbpf_framehdr *)ptr;
470 		ptr += USBPF_FRAME_HDR_LEN;
471 
472 		/* fill out packet header */
473 		uf->length = htole32(length);
474 		uf->flags = 0;
475 
476 		/* get information about data read/write */
477 		isread = usbpf_xfer_frame_is_read(xfer, x);
478 
479 		/* check if we need to copy any data */
480 		if (isread) {
481 			if (type == USBPF_XFERTAP_SUBMIT)
482 				length = 0;
483 			else {
484 				uf->flags |= htole32(
485 				    USBPF_FRAMEFLAG_DATA_FOLLOWS);
486 			}
487 		} else {
488 			if (type != USBPF_XFERTAP_SUBMIT)
489 				length = 0;
490 			else {
491 				uf->flags |= htole32(
492 				    USBPF_FRAMEFLAG_DATA_FOLLOWS);
493 			}
494 		}
495 
496 		/* check if data is read direction */
497 		if (isread)
498 			uf->flags |= htole32(USBPF_FRAMEFLAG_READ);
499 
500 		/* copy USB data, if any */
501 		if (length != 0) {
502 			/* copy data */
503 			usbd_copy_out(&xfer->frbuffers[frame],
504 			    offset, ptr, length);
505 
506 			/* align length */
507 			temp = USBPF_FRAME_ALIGN(length);
508 
509 			/* zero pad */
510 			if (temp != length)
511 				memset(ptr + length, 0, temp - length);
512 
513 			ptr += temp;
514 		}
515 
516 		if (xfer->flags_int.isochronous_xfr) {
517 			offset += usbd_xfer_old_frame_length(xfer, x);
518 		} else {
519 			frame ++;
520 		}
521 	}
522 
523 	bpf_tap(bus->ifp->if_bpf, buf, totlen);
524 
525 	free(buf, M_TEMP);
526 }
527