Date: Thu, 3 Jul 2008 20:14:02 GMT From: Hans Petter Selasky <hselasky@FreeBSD.org> To: Perforce Change Reviews <perforce@FreeBSD.org> Subject: PERFORCE change 144567 for review Message-ID: <200807032014.m63KE2OV014759@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=144567 Change 144567 by hselasky@hselasky_laptop001 on 2008/07/03 20:13:05 Finished new USB image module. - mostly symbol renaming Affected files ... .. //depot/projects/usb/src/sys/dev/usb2/image/usb2_image.c#1 add .. //depot/projects/usb/src/sys/dev/usb2/image/usb2_image.h#1 add .. //depot/projects/usb/src/sys/dev/usb2/image/uscanner2.c#2 edit .. //depot/projects/usb/src/sys/modules/usb2/image/Makefile#2 edit Differences ... ==== //depot/projects/usb/src/sys/dev/usb2/image/uscanner2.c#2 (text+ko) ==== @@ -45,41 +45,36 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/kernel.h> -#include <sys/fcntl.h> +#include <dev/usb2/include/usb2_devid.h> +#include <dev/usb2/include/usb2_standard.h> +#include <dev/usb2/include/usb2_mfunc.h> +#include <dev/usb2/include/usb2_error.h> -#include <dev/usb/usb_port.h> -#include <dev/usb/usb.h> -#include <dev/usb/usb_subr.h> +#define USB_DEBUG_VAR uscanner_debug -#include "usbdevs.h" +#include <dev/usb2/core/usb2_core.h> +#include <dev/usb2/core/usb2_debug.h> +#include <dev/usb2/core/usb2_process.h> +#include <dev/usb2/core/usb2_config_td.h> +#include <dev/usb2/core/usb2_request.h> +#include <dev/usb2/core/usb2_lookup.h> +#include <dev/usb2/core/usb2_util.h> +#include <dev/usb2/core/usb2_busdma.h> +#include <dev/usb2/core/usb2_mbuf.h> +#include <dev/usb2/core/usb2_dev.h> -/* - * uscanner debugging statements. - */ #ifdef USB_DEBUG static int uscanner_debug = 0; -SYSCTL_NODE(_hw_usb, OID_AUTO, uscanner, CTLFLAG_RW, 0, "USB uscanner"); -SYSCTL_INT(_hw_usb_uscanner, OID_AUTO, uscanner, CTLFLAG_RW, &uscanner_debug, +SYSCTL_NODE(_hw_usb2, OID_AUTO, uscanner, CTLFLAG_RW, 0, "USB uscanner"); +SYSCTL_INT(_hw_usb2_uscanner, OID_AUTO, uscanner, CTLFLAG_RW, &uscanner_debug, 0, "uscanner debug level"); - -#define DPRINTF(n, fmt, ...) do { \ - if (uscanner_debug > (n)) { \ - printf("%s: " fmt, __FUNCTION__ \ - ,## __VA_ARGS__); \ - } \ - } while (0) -#else -#define DPRINTF(...) #endif /* * uscanner transfers macros definition. */ -#define USCANNER_BSIZE (1 << 16) +#define USCANNER_BSIZE (1 << 15) #define USCANNER_IFQ_MAXLEN 2 #define USCANNER_N_TRANSFER 4 @@ -94,19 +89,11 @@ */ #define USCANNER_FLAG_KEEP_OPEN 0x04 - /* - * uscanner driver specific structures. - */ -struct uscanner_info { - struct usb_devno devno; - uint8_t flags; -}; - struct uscanner_softc { - struct usb_cdev sc_cdev; + struct usb2_fifo_sc sc_fifo; struct mtx sc_mtx; - struct usbd_xfer *sc_xfer[USCANNER_N_TRANSFER]; + struct usb2_xfer *sc_xfer[USCANNER_N_TRANSFER]; uint8_t sc_flags; /* Used to prevent stalls */ }; @@ -121,33 +108,42 @@ /* * Prototypes for xfer transfer callbacks. */ -static usbd_callback_t uscanner_read_callback; -static usbd_callback_t uscanner_read_clear_stall_callback; -static usbd_callback_t uscanner_write_callback; -static usbd_callback_t uscanner_write_clear_stall_callback; +static usb2_callback_t uscanner_read_callback; +static usb2_callback_t uscanner_read_clear_stall_callback; +static usb2_callback_t uscanner_write_callback; +static usb2_callback_t uscanner_write_clear_stall_callback; /* * Prototypes for the character device handling routines. */ -static int32_t -uscanner_open(struct usb_cdev *cdev, int32_t fflags, - int32_t devtype, struct thread *td); -static void uscanner_start_read(struct usb_cdev *cdev); -static void uscanner_start_write(struct usb_cdev *cdev); -static void uscanner_stop_read(struct usb_cdev *cdev); -static void uscanner_stop_write(struct usb_cdev *cdev); +static usb2_fifo_close_t uscanner_close; +static usb2_fifo_cmd_t uscanner_start_read; +static usb2_fifo_cmd_t uscanner_start_write; +static usb2_fifo_cmd_t uscanner_stop_read; +static usb2_fifo_cmd_t uscanner_stop_write; +static usb2_fifo_open_t uscanner_open; + +static struct usb2_fifo_methods uscanner_fifo_methods = { + .f_close = &uscanner_close, + .f_open = &uscanner_open, + .f_start_read = &uscanner_start_read, + .f_start_write = &uscanner_start_write, + .f_stop_read = &uscanner_stop_read, + .f_stop_write = &uscanner_stop_write, + .basename[0] = "uscanner", +}; /* * xfer transfers array. Resolve-stalling callbacks are marked as control * transfers. */ -static const struct usbd_config uscanner_config[USCANNER_N_TRANSFER] = { +static const struct usb2_config uscanner_config[USCANNER_N_TRANSFER] = { [0] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, .mh.bufsize = USCANNER_BSIZE, - .mh.flags = {.pipe_bof = 1,.proxy_buffer = 1,.force_short_xfer = 1,}, + .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,.proxy_buffer = 1,.force_short_xfer = 1,}, .mh.callback = &uscanner_write_callback, }, @@ -164,7 +160,7 @@ .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(usb_device_request_t), + .mh.bufsize = sizeof(struct usb2_device_request), .mh.flags = {}, .mh.callback = &uscanner_write_clear_stall_callback, .mh.timeout = 1000, @@ -175,7 +171,7 @@ .type = UE_CONTROL, .endpoint = 0x00, .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(usb_device_request_t), + .mh.bufsize = sizeof(struct usb2_device_request), .mh.flags = {}, .mh.callback = &uscanner_read_clear_stall_callback, .mh.timeout = 1000, @@ -198,190 +194,166 @@ .size = sizeof(struct uscanner_softc), }; -DRIVER_MODULE(uscanner, uhub, uscanner_driver, uscanner_devclass, usbd_driver_load, 0); -MODULE_DEPEND(uscanner, usb, 1, 1, 1); +DRIVER_MODULE(uscanner, ushub, uscanner_driver, uscanner_devclass, NULL, 0); +MODULE_DEPEND(uscanner, usb2_core, 1, 1, 1); /* - * USB scanners probing array. It determines flags too. + * USB scanners device IDs */ -static const struct uscanner_info uscanner_devs[] = { +static const struct usb2_device_id uscanner_devs[] = { /* Acer */ - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_320U}, 0}, - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_640U}, 0}, - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_640BT}, 0}, - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_620U}, 0}, - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_1240U}, 0}, - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_C310U}, 0}, - {{USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_4300U}, 0}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_320U, 0)}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_640U, 0)}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_640BT, 0)}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_620U, 0)}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_1240U, 0)}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_C310U, 0)}, + {USB_VPI(USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_4300U, 0)}, /* AGFA */ - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1236U}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1212U}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1212U2}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANTOUCH}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE40}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE50}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE20}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE25}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE26}, 0}, - {{USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE52}, 0}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1236U, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1212U, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1212U2, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANTOUCH, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE40, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE50, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE20, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE25, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE26, 0)}, + {USB_VPI(USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE52, 0)}, /* Avision */ - {{USB_VENDOR_AVISION, USB_PRODUCT_AVISION_1200U}, 0}, + {USB_VPI(USB_VENDOR_AVISION, USB_PRODUCT_AVISION_1200U, 0)}, /* Canon */ - {{USB_VENDOR_CANON, USB_PRODUCT_CANON_N656U}, 0}, - {{USB_VENDOR_CANON, USB_PRODUCT_CANON_N676U}, 0}, - {{USB_VENDOR_CANON, USB_PRODUCT_CANON_N1220U}, 0}, - {{USB_VENDOR_CANON, USB_PRODUCT_CANON_D660U}, 0}, - {{USB_VENDOR_CANON, USB_PRODUCT_CANON_N1240U}, 0}, - {{USB_VENDOR_CANON, USB_PRODUCT_CANON_LIDE25}, 0}, + {USB_VPI(USB_VENDOR_CANON, USB_PRODUCT_CANON_N656U, 0)}, + {USB_VPI(USB_VENDOR_CANON, USB_PRODUCT_CANON_N676U, 0)}, + {USB_VPI(USB_VENDOR_CANON, USB_PRODUCT_CANON_N1220U, 0)}, + {USB_VPI(USB_VENDOR_CANON, USB_PRODUCT_CANON_D660U, 0)}, + {USB_VPI(USB_VENDOR_CANON, USB_PRODUCT_CANON_N1240U, 0)}, + {USB_VPI(USB_VENDOR_CANON, USB_PRODUCT_CANON_LIDE25, 0)}, /* Epson */ - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_636}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_610}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1200}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1240}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1250}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1270}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1600}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1640}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_640U}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1650}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1660}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1670}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1260}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_RX425}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_3200}, USCANNER_FLAG_KEEP_OPEN}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_GT9700F}, USCANNER_FLAG_KEEP_OPEN}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_CX5400}, 0}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_636, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_610, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1200, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1240, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1250, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1270, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1600, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1640, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_640U, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1650, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1660, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1670, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1260, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_RX425, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_3200, USCANNER_FLAG_KEEP_OPEN)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_GT9700F, USCANNER_FLAG_KEEP_OPEN)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_CX5400, 0)}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_GT9300UF}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_2480}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_3500}, USCANNER_FLAG_KEEP_OPEN}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_3590}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_4200}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_4800}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_4990}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_5000}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_6000}, 0}, - {{USB_VENDOR_EPSON, USB_PRODUCT_EPSON_DX8400}, 0}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_GT9300UF, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_2480, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_3500, USCANNER_FLAG_KEEP_OPEN)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_3590, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_4200, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_4800, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_4990, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_5000, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_6000, 0)}, + {USB_VPI(USB_VENDOR_EPSON, USB_PRODUCT_EPSON_DX8400, 0)}, /* HP */ - {{USB_VENDOR_HP, USB_PRODUCT_HP_2200C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_3300C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_3400CSE}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_4100C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_4200C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_4300C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_4670V}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_S20}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_5200C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_5300C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_5400C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_6200C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_6300C}, 0}, - {{USB_VENDOR_HP, USB_PRODUCT_HP_82x0C}, 0}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_2200C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_3300C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_3400CSE, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_4100C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_4200C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_4300C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_4670V, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_S20, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_5200C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_5300C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_5400C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_6200C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_6300C, 0)}, + {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_82x0C, 0)}, /* Kye */ - {{USB_VENDOR_KYE, USB_PRODUCT_KYE_VIVIDPRO}, 0}, + {USB_VPI(USB_VENDOR_KYE, USB_PRODUCT_KYE_VIVIDPRO, 0)}, /* Microtek */ - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_X6U}, 0}, - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_336CX}, 0}, - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_336CX2}, 0}, - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_C6}, 0}, - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6USL}, 0}, - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6USL2}, 0}, - {{USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6UL}, 0}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_X6U, 0)}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_336CX, 0)}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_336CX2, 0)}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_C6, 0)}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6USL, 0)}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6USL2, 0)}, + {USB_VPI(USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6UL, 0)}, /* Minolta */ - {{USB_VENDOR_MINOLTA, USB_PRODUCT_MINOLTA_5400}, 0}, + {USB_VPI(USB_VENDOR_MINOLTA, USB_PRODUCT_MINOLTA_5400, 0)}, /* Mustek */ - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200CU}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_BEARPAW1200F}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_BEARPAW1200TA}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_600USB}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_600CU}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200USB}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200UB}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200USBPLUS}, 0}, - {{USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200CUPLUS}, 0}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200CU, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_BEARPAW1200F, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_BEARPAW1200TA, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_600USB, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_600CU, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200USB, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200UB, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200USBPLUS, 0)}, + {USB_VPI(USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200CUPLUS, 0)}, /* National */ - {{USB_VENDOR_NATIONAL, USB_PRODUCT_NATIONAL_BEARPAW1200}, 0}, - {{USB_VENDOR_NATIONAL, USB_PRODUCT_NATIONAL_BEARPAW2400}, 0}, + {USB_VPI(USB_VENDOR_NATIONAL, USB_PRODUCT_NATIONAL_BEARPAW1200, 0)}, + {USB_VPI(USB_VENDOR_NATIONAL, USB_PRODUCT_NATIONAL_BEARPAW2400, 0)}, /* Nikon */ - {{USB_VENDOR_NIKON, USB_PRODUCT_NIKON_LS40}, 0}, + {USB_VPI(USB_VENDOR_NIKON, USB_PRODUCT_NIKON_LS40, 0)}, /* Primax */ - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2X300}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E300}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2300}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E3002}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_9600}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_600U}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_6200}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_19200}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_1200U}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G600}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_636I}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2600}, 0}, - {{USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E600}, 0}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2X300, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E300, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2300, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E3002, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_9600, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_600U, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_6200, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_19200, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_1200U, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G600, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_636I, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2600, 0)}, + {USB_VPI(USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E600, 0)}, /* Scanlogic */ - {{USB_VENDOR_SCANLOGIC, USB_PRODUCT_SCANLOGIC_336CX}, 0}, + {USB_VPI(USB_VENDOR_SCANLOGIC, USB_PRODUCT_SCANLOGIC_336CX, 0)}, /* Ultima */ - {{USB_VENDOR_ULTIMA, USB_PRODUCT_ULTIMA_1200UBPLUS}, 0}, + {USB_VPI(USB_VENDOR_ULTIMA, USB_PRODUCT_ULTIMA_1200UBPLUS, 0)}, /* UMAX */ - {{USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA1220U}, 0}, - {{USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA1236U}, 0}, - {{USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2000U}, 0}, - {{USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2100U}, 0}, - {{USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2200U}, 0}, - {{USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA3400}, 0}, + {USB_VPI(USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA1220U, 0)}, + {USB_VPI(USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA1236U, 0)}, + {USB_VPI(USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2000U, 0)}, + {USB_VPI(USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2100U, 0)}, + {USB_VPI(USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2200U, 0)}, + {USB_VPI(USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA3400, 0)}, /* Visioneer */ - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_3000}, 0}, - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_5300}, 0}, - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_7600}, 0}, - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_6100}, 0}, - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_6200}, 0}, - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_8100}, 0}, - {{USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_8600}, 0} + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_3000, 0)}, + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_5300, 0)}, + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_7600, 0)}, + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_6100, 0)}, + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_6200, 0)}, + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_8100, 0)}, + {USB_VPI(USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_8600, 0)} }; /* - * It returns vendor and product ids. - */ -static inline const struct uscanner_info * -uscanner_lookup(uint16_t v, uint16_t p) -{ - return ((const struct uscanner_info *)usb_lookup(uscanner_devs, v, p)); -} - -/* * uscanner device probing method. */ static int uscanner_probe(device_t dev) { - struct usb_attach_arg *uaa; - usb_interface_descriptor_t *id; + struct usb2_attach_arg *uaa; DPRINTF(10, "\n"); uaa = device_get_ivars(dev); - if (uaa->usb_mode != USB_MODE_HOST) { - return (UMATCH_NONE); + if (uaa->usb2_mode != USB_MODE_HOST) { + return (ENXIO); } - if (uaa->iface == NULL) { - return (UMATCH_NONE); + /* Give other class drivers a chance for multifunctional scanners. */ + if (uaa->use_generic == 0) { + return (ENXIO); } - id = usbd_get_interface_descriptor(uaa->iface); - if (id == NULL) { - return (UMATCH_NONE); - } - /* - * There isn't a specific UICLASS for scanners, many vendors use - * UICLASS_VENDOR, so detecting the right interface is not so easy. - * But certainly we can exclude PRINTER and MASS - which some - * multifunction devices implement. - */ - if ((id->bInterfaceClass == UICLASS_PRINTER) || - (id->bInterfaceClass == UICLASS_MASS)) { - return (UMATCH_NONE); - } - return ((uscanner_lookup(uaa->vendor, uaa->product) != NULL) ? - UMATCH_VENDOR_PRODUCT : UMATCH_NONE); + return (usb2_lookup_id_by_uaa(uscanner_devs, sizeof(uscanner_devs), uaa)); } /* @@ -390,11 +362,9 @@ static int uscanner_attach(device_t dev) { - struct usb_attach_arg *uaa; + struct usb2_attach_arg *uaa; struct uscanner_softc *sc; - const char *p_buf[2]; - char buf[32]; - int32_t unit; + int unit; int error; uaa = device_get_ivars(dev); @@ -402,46 +372,34 @@ unit = device_get_unit(dev); /* - * A first path softc structure filling. sc_cdev and - * sc_xfer are filled later with appropriate functions. + * A first path softc structure filling. sc_fifo and + * sc_xfer are initialised later. */ - sc->sc_flags = uscanner_lookup(uaa->vendor, uaa->product)->flags; + sc->sc_flags = USB_GET_DRIVER_INFO(uaa); mtx_init(&(sc->sc_mtx), "uscanner mutex", NULL, MTX_DEF | MTX_RECURSE); /* * Announce the device: */ - usbd_set_device_desc(dev); + device_set_usb2_desc(dev); /* * Setup the transfer. */ - if ((error = usbd_transfer_setup(uaa->device, &(uaa->iface_index), sc->sc_xfer, + if ((error = usb2_transfer_setup(uaa->device, &(uaa->info.bIfaceIndex), sc->sc_xfer, uscanner_config, USCANNER_N_TRANSFER, sc, &(sc->sc_mtx)))) { device_printf(dev, "could not setup transfers, " - "error=%s\n", usbd_errstr(error)); + "error=%s\n", usb2_errstr(error)); goto detach; } - /* - * Setup the character device for USB scanner. - */ - snprintf(buf, sizeof(buf), "uscanner%u", unit); - p_buf[0] = buf; - p_buf[1] = NULL; + /* set interface permissions */ + usb2_set_iface_perm(uaa->device, uaa->info.bIfaceIndex, + UID_ROOT, GID_OPERATOR, 0644); - sc->sc_cdev.sc_start_read = &uscanner_start_read; - sc->sc_cdev.sc_stop_read = &uscanner_stop_read; - sc->sc_cdev.sc_start_write = &uscanner_start_write; - sc->sc_cdev.sc_stop_write = &uscanner_stop_write; - sc->sc_cdev.sc_open = &uscanner_open; - sc->sc_cdev.sc_flags |= (USB_CDEV_FLAG_WAKEUP_RD_IMMED | - USB_CDEV_FLAG_WAKEUP_WR_IMMED); - - if ((error = usb_cdev_attach(&(sc->sc_cdev), sc, &(sc->sc_mtx), p_buf, - UID_ROOT, GID_OPERATOR, 0644, USCANNER_BSIZE, USCANNER_IFQ_MAXLEN, - USCANNER_BSIZE, USCANNER_IFQ_MAXLEN))) { - device_printf(dev, "error setting the " - "char device!\n"); + error = usb2_fifo_attach(uaa->device, sc, &(sc->sc_mtx), + &uscanner_fifo_methods, &(sc->sc_fifo), + unit, 0 - 1, uaa->info.bIfaceIndex); + if (error) { goto detach; } return (0); @@ -461,8 +419,8 @@ sc = device_get_softc(dev); - usb_cdev_detach(&(sc->sc_cdev)); - usbd_transfer_unsetup(sc->sc_xfer, USCANNER_N_TRANSFER); + usb2_fifo_detach(&(sc->sc_fifo)); + usb2_transfer_unsetup(sc->sc_xfer, USCANNER_N_TRANSFER); mtx_destroy(&(sc->sc_mtx)); return (0); @@ -472,56 +430,57 @@ * Reading callback. Implemented as an "in" bulk transfer. */ static void -uscanner_read_callback(struct usbd_xfer *xfer) +uscanner_read_callback(struct usb2_xfer *xfer) { struct uscanner_softc *sc; - struct usbd_mbuf *m; + struct usb2_fifo *f; sc = xfer->priv_sc; + f = sc->sc_fifo.fp[USB_FIFO_RX]; - switch (USBD_GET_STATE(xfer)) { - case USBD_ST_TRANSFERRED: - usb_cdev_put_data(&(sc->sc_cdev), xfer->frbuffers, 0, + switch (USB_GET_STATE(xfer)) { + case USB_ST_TRANSFERRED: + usb2_fifo_put_data(f, xfer->frbuffers, 0, xfer->actlen, 1); - case USBD_ST_SETUP: + case USB_ST_SETUP: /* * If reading is in stall, just jump to clear stall callback and * solve the situation. */ if (sc->sc_flags & USCANNER_FLAG_READ_STALL) { - usbd_transfer_start(sc->sc_xfer[3]); - return; + usb2_transfer_start(sc->sc_xfer[3]); + break; } - USBD_IF_POLL(&(sc->sc_cdev).sc_rdq_free, m); - if (m) { + if (usb2_fifo_put_bytes_max(f) != 0) { xfer->frlengths[0] = xfer->max_data_length; - usbd_start_hardware(xfer); + usb2_start_hardware(xfer); } - return; + break; default: /* Error */ - if (xfer->error != USBD_ERR_CANCELLED) { + if (xfer->error != USB_ERR_CANCELLED) { sc->sc_flags |= USCANNER_FLAG_READ_STALL; - usbd_transfer_start(sc->sc_xfer[3]); + usb2_transfer_start(sc->sc_xfer[3]); } - return; + break; } + return; } /* * Removing stall on reading callback. */ static void -uscanner_read_clear_stall_callback(struct usbd_xfer *xfer) +uscanner_read_clear_stall_callback(struct usb2_xfer *xfer) { struct uscanner_softc *sc = xfer->priv_sc; - struct usbd_xfer *xfer_other = sc->sc_xfer[1]; + struct usb2_xfer *xfer_other = sc->sc_xfer[1]; - if (usbd_clear_stall_callback(xfer, xfer_other)) { + if (usb2_clear_stall_callback(xfer, xfer_other)) { DPRINTF(0, "stall cleared\n"); sc->sc_flags &= ~USCANNER_FLAG_READ_STALL; - usbd_transfer_start(xfer_other); + usb2_transfer_start(xfer_other); } return; } @@ -530,56 +489,59 @@ * Writing callback. Implemented as an "out" bulk transfer. */ static void -uscanner_write_callback(struct usbd_xfer *xfer) +uscanner_write_callback(struct usb2_xfer *xfer) { struct uscanner_softc *sc; + struct usb2_fifo *f; uint32_t actlen; sc = xfer->priv_sc; + f = sc->sc_fifo.fp[USB_FIFO_TX]; - switch (USBD_GET_STATE(xfer)) { - case USBD_ST_SETUP: - case USBD_ST_TRANSFERRED: + switch (USB_GET_STATE(xfer)) { + case USB_ST_SETUP: + case USB_ST_TRANSFERRED: /* * If writing is in stall, just jump to clear stall callback and * solve the situation. */ if (sc->sc_flags & USCANNER_FLAG_WRITE_STALL) { - usbd_transfer_start(sc->sc_xfer[2]); - return; + usb2_transfer_start(sc->sc_xfer[2]); + break; } /* * Write datas, setup and perform hardware transfer. */ - if (usb_cdev_get_data(&(sc->sc_cdev), xfer->frbuffers, 0, + if (usb2_fifo_get_data(f, xfer->frbuffers, 0, xfer->max_data_length, &actlen, 0)) { xfer->frlengths[0] = actlen; - usbd_start_hardware(xfer); + usb2_start_hardware(xfer); } - return; + break; default: /* Error */ - if (xfer->error != USBD_ERR_CANCELLED) { + if (xfer->error != USB_ERR_CANCELLED) { sc->sc_flags |= USCANNER_FLAG_WRITE_STALL; - usbd_transfer_start(sc->sc_xfer[2]); + usb2_transfer_start(sc->sc_xfer[2]); } - return; + break; } + return; } /* * Removing stall on writing callback. */ static void -uscanner_write_clear_stall_callback(struct usbd_xfer *xfer) +uscanner_write_clear_stall_callback(struct usb2_xfer *xfer) { struct uscanner_softc *sc = xfer->priv_sc; - struct usbd_xfer *xfer_other = sc->sc_xfer[0]; + struct usb2_xfer *xfer_other = sc->sc_xfer[0]; - if (usbd_clear_stall_callback(xfer, xfer_other)) { + if (usb2_clear_stall_callback(xfer, xfer_other)) { DPRINTF(0, "stall cleared\n"); sc->sc_flags &= ~USCANNER_FLAG_WRITE_STALL; - usbd_transfer_start(xfer_other); + usb2_transfer_start(xfer_other); } return; } @@ -587,13 +549,12 @@ /* * uscanner character device opening method. */ -static int32_t -uscanner_open(struct usb_cdev *cdev, int32_t fflags, int32_t devtype, - struct thread *td) +static int +uscanner_open(struct usb2_fifo *fifo, int fflags, struct thread *td) { struct uscanner_softc *sc; - sc = cdev->sc_priv_ptr; + sc = fifo->priv_sc0; if (!(sc->sc_flags & USCANNER_FLAG_KEEP_OPEN)) { if (fflags & FWRITE) { @@ -603,55 +564,78 @@ sc->sc_flags |= USCANNER_FLAG_READ_STALL; } } + if (fflags & FREAD) { + if (usb2_fifo_alloc_buffer(fifo, + sc->sc_xfer[1]->max_data_length, + USCANNER_IFQ_MAXLEN)) { + return (ENOMEM); + } + } + if (fflags & FWRITE) { + if (usb2_fifo_alloc_buffer(fifo, + sc->sc_xfer[0]->max_data_length, + USCANNER_IFQ_MAXLEN)) { + return (ENOMEM); + } + } return (0); } +static void +uscanner_close(struct usb2_fifo *fifo, int fflags, struct thread *td) +{ + if (fflags & (FREAD | FWRITE)) { + usb2_fifo_free_buffer(fifo); + } + return; +} + /* * uscanner character device start reading method. */ static void -uscanner_start_read(struct usb_cdev *cdev) +uscanner_start_read(struct usb2_fifo *fifo) { struct uscanner_softc *sc; - sc = cdev->sc_priv_ptr; - usbd_transfer_start(sc->sc_xfer[1]); + sc = fifo->priv_sc0; + usb2_transfer_start(sc->sc_xfer[1]); } /* * uscanner character device start writing method. */ static void -uscanner_start_write(struct usb_cdev *cdev) +uscanner_start_write(struct usb2_fifo *fifo) { struct uscanner_softc *sc; - sc = cdev->sc_priv_ptr; - usbd_transfer_start(sc->sc_xfer[0]); + sc = fifo->priv_sc0; + usb2_transfer_start(sc->sc_xfer[0]); } /* * uscanner character device stop reading method. */ static void -uscanner_stop_read(struct usb_cdev *cdev) +uscanner_stop_read(struct usb2_fifo *fifo) { struct uscanner_softc *sc; - sc = cdev->sc_priv_ptr; - usbd_transfer_stop(sc->sc_xfer[3]); - usbd_transfer_stop(sc->sc_xfer[1]); + sc = fifo->priv_sc0; + usb2_transfer_stop(sc->sc_xfer[3]); + usb2_transfer_stop(sc->sc_xfer[1]); } /* * uscanner character device stop writing method. */ static void -uscanner_stop_write(struct usb_cdev *cdev) +uscanner_stop_write(struct usb2_fifo *fifo) { struct uscanner_softc *sc; - sc = cdev->sc_priv_ptr; - usbd_transfer_stop(sc->sc_xfer[2]); - usbd_transfer_stop(sc->sc_xfer[0]); + sc = fifo->priv_sc0; + usb2_transfer_stop(sc->sc_xfer[2]); + usb2_transfer_stop(sc->sc_xfer[0]); } ==== //depot/projects/usb/src/sys/modules/usb2/image/Makefile#2 (text+ko) ==== @@ -1,0 +1,13 @@ +S= ${.CURDIR}/../../.. + +.PATH: $S/dev/usb2/image + +KMOD= usb2_image +SRCS= +SRCS+= bus_if.h usb2_if.h device_if.h vnode_if.h +SRCS+= opt_usb.h opt_bus.h + +SRCS+= usb2_image.c +SRCS+= uscanner2.c + +.include <bsd.kmod.mk>
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200807032014.m63KE2OV014759>