2 * Copyright (c) 1990, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from the Stanford/CMU enet packet filter,
6 * (net/enet.c) distributed as part of 4.3BSD, and code contributed
7 * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 4. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
37 #include <sys/param.h>
38 #include <sys/kernel.h>
40 #include <sys/fcntl.h>
41 #include <sys/malloc.h>
43 #include <sys/socket.h>
44 #include <sys/sockio.h>
46 #include <net/if_types.h>
48 #include <sys/sysctl.h>
50 #include <dev/usb/usb.h>
51 #include <dev/usb/usbdi.h>
52 #include <dev/usb/usb_busdma.h>
53 #include <dev/usb/usb_controller.h>
54 #include <dev/usb/usb_core.h>
55 #include <dev/usb/usb_process.h>
56 #include <dev/usb/usb_device.h>
57 #include <dev/usb/usb_bus.h>
58 #include <dev/usb/usb_pf.h>
59 #include <dev/usb/usb_transfer.h>
63 SYSCTL_INT(_hw_usb, OID_AUTO, no_pf, CTLFLAG_RW,
64 &usb_no_pf, 0, "Set to disable USB packet filtering");
66 TUNABLE_INT("hw.usb.no_pf", &usb_no_pf);
69 usbpf_attach(struct usb_bus *ubus)
78 ifp = ubus->ifp = if_alloc(IFT_USB);
80 device_printf(ubus->parent, "usbpf: Could not allocate "
85 if_initname(ifp, "usbus", device_get_unit(ubus->bdev));
86 ifp->if_flags = IFF_CANTCONFIG;
91 * XXX According to the specification of DLT_USB, it indicates
92 * packets beginning with USB setup header. But not sure all
95 bpfattach(ifp, DLT_USB, USBPF_HDR_LEN);
98 device_printf(ubus->parent, "usbpf: Attached\n");
102 usbpf_detach(struct usb_bus *ubus)
104 struct ifnet *ifp = ubus->ifp;
116 usbpf_aggregate_xferflags(struct usb_xfer_flags *flags)
120 if (flags->force_short_xfer == 1)
121 val |= USBPF_FLAG_FORCE_SHORT_XFER;
122 if (flags->short_xfer_ok == 1)
123 val |= USBPF_FLAG_SHORT_XFER_OK;
124 if (flags->short_frames_ok == 1)
125 val |= USBPF_FLAG_SHORT_FRAMES_OK;
126 if (flags->pipe_bof == 1)
127 val |= USBPF_FLAG_PIPE_BOF;
128 if (flags->proxy_buffer == 1)
129 val |= USBPF_FLAG_PROXY_BUFFER;
130 if (flags->ext_buffer == 1)
131 val |= USBPF_FLAG_EXT_BUFFER;
132 if (flags->manual_status == 1)
133 val |= USBPF_FLAG_MANUAL_STATUS;
134 if (flags->no_pipe_ok == 1)
135 val |= USBPF_FLAG_NO_PIPE_OK;
136 if (flags->stall_pipe == 1)
137 val |= USBPF_FLAG_STALL_PIPE;
142 usbpf_aggregate_status(struct usb_xfer_flags_int *flags)
146 if (flags->open == 1)
147 val |= USBPF_STATUS_OPEN;
148 if (flags->transferring == 1)
149 val |= USBPF_STATUS_TRANSFERRING;
150 if (flags->did_dma_delay == 1)
151 val |= USBPF_STATUS_DID_DMA_DELAY;
152 if (flags->did_close == 1)
153 val |= USBPF_STATUS_DID_CLOSE;
154 if (flags->draining == 1)
155 val |= USBPF_STATUS_DRAINING;
156 if (flags->started == 1)
157 val |= USBPF_STATUS_STARTED;
158 if (flags->bandwidth_reclaimed == 1)
159 val |= USBPF_STATUS_BW_RECLAIMED;
160 if (flags->control_xfr == 1)
161 val |= USBPF_STATUS_CONTROL_XFR;
162 if (flags->control_hdr == 1)
163 val |= USBPF_STATUS_CONTROL_HDR;
164 if (flags->control_act == 1)
165 val |= USBPF_STATUS_CONTROL_ACT;
166 if (flags->control_stall == 1)
167 val |= USBPF_STATUS_CONTROL_STALL;
168 if (flags->short_frames_ok == 1)
169 val |= USBPF_STATUS_SHORT_FRAMES_OK;
170 if (flags->short_xfer_ok == 1)
171 val |= USBPF_STATUS_SHORT_XFER_OK;
173 if (flags->bdma_enable == 1)
174 val |= USBPF_STATUS_BDMA_ENABLE;
175 if (flags->bdma_no_post_sync == 1)
176 val |= USBPF_STATUS_BDMA_NO_POST_SYNC;
177 if (flags->bdma_setup == 1)
178 val |= USBPF_STATUS_BDMA_SETUP;
180 if (flags->isochronous_xfr == 1)
181 val |= USBPF_STATUS_ISOCHRONOUS_XFR;
182 if (flags->curr_dma_set == 1)
183 val |= USBPF_STATUS_CURR_DMA_SET;
184 if (flags->can_cancel_immed == 1)
185 val |= USBPF_STATUS_CAN_CANCEL_IMMED;
186 if (flags->doing_callback == 1)
187 val |= USBPF_STATUS_DOING_CALLBACK;
193 usbpf_xfer_frame_is_read(struct usb_xfer *xfer, uint32_t frame)
197 if ((frame == 0) && (xfer->flags_int.control_xfr != 0) &&
198 (xfer->flags_int.control_hdr != 0)) {
200 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
201 /* The device controller writes to memory */
204 /* The host controller reads from memory */
208 isread = USB_GET_DATA_ISREAD(xfer);
214 usbpf_xfer_precompute_size(struct usb_xfer *xfer, int type)
220 if (type == USBPF_XFERTAP_SUBMIT)
221 nframes = xfer->nframes;
223 nframes = xfer->aframes;
225 totlen = USBPF_HDR_LEN + (USBPF_FRAME_HDR_LEN * nframes);
227 /* precompute all trace lengths */
228 for (x = 0; x != nframes; x++) {
229 if (usbpf_xfer_frame_is_read(xfer, x)) {
230 if (type != USBPF_XFERTAP_SUBMIT) {
231 totlen += USBPF_FRAME_ALIGN(
235 if (type == USBPF_XFERTAP_SUBMIT) {
236 totlen += USBPF_FRAME_ALIGN(
245 usbpf_xfertap(struct usb_xfer *xfer, int type)
248 struct usbpf_pkthdr *up;
249 struct usbpf_framehdr *uf;
250 usb_frlength_t offset;
259 bus = xfer->xroot->bus;
264 if (bus->ifp == NULL || bus->ifp->if_bpf == NULL)
266 if (!bpf_peers_present(bus->ifp->if_bpf))
269 totlen = usbpf_xfer_precompute_size(xfer, type);
271 if (type == USBPF_XFERTAP_SUBMIT)
272 nframes = xfer->nframes;
274 nframes = xfer->aframes;
279 * When BPF supports it we could pass a fragmented array of
280 * buffers avoiding the data copy operation here.
282 buf = ptr = malloc(totlen, M_TEMP, M_NOWAIT);
284 device_printf(bus->parent, "usbpf: Out of memory\n");
288 up = (struct usbpf_pkthdr *)ptr;
289 ptr += USBPF_HDR_LEN;
291 /* fill out header */
292 temp = device_get_unit(bus->bdev);
293 up->up_totlen = htole32(totlen);
294 up->up_busunit = htole32(temp);
295 up->up_address = xfer->xroot->udev->device_index;
296 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
297 up->up_mode = USBPF_MODE_DEVICE;
299 up->up_mode = USBPF_MODE_HOST;
301 up->up_xfertype = xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE;
302 temp = usbpf_aggregate_xferflags(&xfer->flags);
303 up->up_flags = htole32(temp);
304 temp = usbpf_aggregate_status(&xfer->flags_int);
305 up->up_status = htole32(temp);
307 up->up_error = htole32(temp);
308 temp = xfer->interval;
309 up->up_interval = htole32(temp);
310 up->up_frames = htole32(nframes);
311 temp = xfer->max_packet_size;
312 up->up_packet_size = htole32(temp);
313 temp = xfer->max_packet_count;
314 up->up_packet_count = htole32(temp);
315 temp = xfer->endpointno;
316 up->up_endpoint = htole32(temp);
317 up->up_speed = xfer->xroot->udev->speed;
319 /* clear reserved area */
320 memset(up->up_reserved, 0, sizeof(up->up_reserved));
322 /* init offset and frame */
326 /* iterate all the USB frames and copy data, if any */
327 for (x = 0; x != nframes; x++) {
332 length = xfer->frlengths[x];
334 /* get frame header pointer */
335 uf = (struct usbpf_framehdr *)ptr;
336 ptr += USBPF_FRAME_HDR_LEN;
338 /* fill out packet header */
339 uf->length = htole32(length);
342 /* get information about data read/write */
343 isread = usbpf_xfer_frame_is_read(xfer, x);
345 /* check if we need to copy any data */
347 if (type == USBPF_XFERTAP_SUBMIT)
350 uf->flags |= htole32(
351 USBPF_FRAMEFLAG_DATA_FOLLOWS);
354 if (type != USBPF_XFERTAP_SUBMIT)
357 uf->flags |= htole32(
358 USBPF_FRAMEFLAG_DATA_FOLLOWS);
362 /* check if data is read direction */
364 uf->flags |= htole32(USBPF_FRAMEFLAG_READ);
366 /* copy USB data, if any */
369 usbd_copy_out(&xfer->frbuffers[frame],
370 offset, ptr, length);
373 temp = USBPF_FRAME_ALIGN(length);
377 memset(ptr + length, 0, temp - length);
382 if (xfer->flags_int.isochronous_xfr) {
383 offset += usbd_xfer_old_frame_length(xfer, x);
389 bpf_tap(bus->ifp->if_bpf, buf, totlen);