1 /* 2 * zero.c -- Gadget Zero, for USB development 3 * 4 * Copyright (C) 2003-2008 David Brownell 5 * Copyright (C) 2008 by Nokia Corporation 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 */ 12 13 /* 14 * Gadget Zero only needs two bulk endpoints, and is an example of how you 15 * can write a hardware-agnostic gadget driver running inside a USB device. 16 * Some hardware details are visible, but don't affect most of the driver. 17 * 18 * Use it with the Linux host/master side "usbtest" driver to get a basic 19 * functional test of your device-side usb stack, or with "usb-skeleton". 20 * 21 * It supports two similar configurations. One sinks whatever the usb host 22 * writes, and in return sources zeroes. The other loops whatever the host 23 * writes back, so the host can read it. 24 * 25 * Many drivers will only have one configuration, letting them be much 26 * simpler if they also don't support high speed operation (like this 27 * driver does). 28 * 29 * Why is *this* driver using two configurations, rather than setting up 30 * two interfaces with different functions? To help verify that multiple 31 * configuration infrastructure is working correctly; also, so that it can 32 * work with low capability USB controllers without four bulk endpoints. 33 */ 34 35 /* 36 * driver assumes self-powered hardware, and 37 * has no way for users to trigger remote wakeup. 38 */ 39 40 /* #define VERBOSE_DEBUG */ 41 42 #include <linux/kernel.h> 43 #include <linux/slab.h> 44 #include <linux/device.h> 45 #include <linux/module.h> 46 #include <linux/err.h> 47 #include <linux/usb/composite.h> 48 49 #include "g_zero.h" 50 /*-------------------------------------------------------------------------*/ 51 USB_GADGET_COMPOSITE_OPTIONS(); 52 53 #define DRIVER_VERSION "Cinco de Mayo 2008" 54 55 static const char longname[] = "Gadget Zero"; 56 57 /* 58 * Normally the "loopback" configuration is second (index 1) so 59 * it's not the default. Here's where to change that order, to 60 * work better with hosts where config changes are problematic or 61 * controllers (like original superh) that only support one config. 62 */ 63 static bool loopdefault = 0; 64 module_param(loopdefault, bool, S_IRUGO|S_IWUSR); 65 66 static struct usb_zero_options gzero_options = { 67 .isoc_interval = GZERO_ISOC_INTERVAL, 68 .isoc_maxpacket = GZERO_ISOC_MAXPACKET, 69 .bulk_buflen = GZERO_BULK_BUFLEN, 70 .qlen = GZERO_QLEN, 71 .ss_bulk_qlen = GZERO_SS_BULK_QLEN, 72 .ss_iso_qlen = GZERO_SS_ISO_QLEN, 73 }; 74 75 /*-------------------------------------------------------------------------*/ 76 77 /* Thanks to NetChip Technologies for donating this product ID. 78 * 79 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!! 80 * Instead: allocate your own, using normal USB-IF procedures. 81 */ 82 #ifndef CONFIG_USB_ZERO_HNPTEST 83 #define DRIVER_VENDOR_NUM 0x0525 /* NetChip */ 84 #define DRIVER_PRODUCT_NUM 0xa4a0 /* Linux-USB "Gadget Zero" */ 85 #define DEFAULT_AUTORESUME 0 86 #else 87 #define DRIVER_VENDOR_NUM 0x1a0a /* OTG test device IDs */ 88 #define DRIVER_PRODUCT_NUM 0xbadd 89 #define DEFAULT_AUTORESUME 5 90 #endif 91 92 /* If the optional "autoresume" mode is enabled, it provides good 93 * functional coverage for the "USBCV" test harness from USB-IF. 94 * It's always set if OTG mode is enabled. 95 */ 96 static unsigned autoresume = DEFAULT_AUTORESUME; 97 module_param(autoresume, uint, S_IRUGO); 98 MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup"); 99 100 /* Maximum Autoresume time */ 101 static unsigned max_autoresume; 102 module_param(max_autoresume, uint, S_IRUGO); 103 MODULE_PARM_DESC(max_autoresume, "maximum seconds before remote wakeup"); 104 105 /* Interval between two remote wakeups */ 106 static unsigned autoresume_interval_ms; 107 module_param(autoresume_interval_ms, uint, S_IRUGO); 108 MODULE_PARM_DESC(autoresume_interval_ms, 109 "milliseconds to increase successive wakeup delays"); 110 111 static unsigned autoresume_step_ms; 112 /*-------------------------------------------------------------------------*/ 113 114 static struct usb_device_descriptor device_desc = { 115 .bLength = sizeof device_desc, 116 .bDescriptorType = USB_DT_DEVICE, 117 118 /* .bcdUSB = DYNAMIC */ 119 .bDeviceClass = USB_CLASS_VENDOR_SPEC, 120 121 .idVendor = cpu_to_le16(DRIVER_VENDOR_NUM), 122 .idProduct = cpu_to_le16(DRIVER_PRODUCT_NUM), 123 .bNumConfigurations = 2, 124 }; 125 126 static const struct usb_descriptor_header *otg_desc[2]; 127 128 /* string IDs are assigned dynamically */ 129 /* default serial number takes at least two packets */ 130 static char serial[] = "0123456789.0123456789.0123456789"; 131 132 #define USB_GZERO_SS_DESC (USB_GADGET_FIRST_AVAIL_IDX + 0) 133 #define USB_GZERO_LB_DESC (USB_GADGET_FIRST_AVAIL_IDX + 1) 134 135 static struct usb_string strings_dev[] = { 136 [USB_GADGET_MANUFACTURER_IDX].s = "", 137 [USB_GADGET_PRODUCT_IDX].s = longname, 138 [USB_GADGET_SERIAL_IDX].s = serial, 139 [USB_GZERO_SS_DESC].s = "source and sink data", 140 [USB_GZERO_LB_DESC].s = "loop input to output", 141 { } /* end of list */ 142 }; 143 144 static struct usb_gadget_strings stringtab_dev = { 145 .language = 0x0409, /* en-us */ 146 .strings = strings_dev, 147 }; 148 149 static struct usb_gadget_strings *dev_strings[] = { 150 &stringtab_dev, 151 NULL, 152 }; 153 154 /*-------------------------------------------------------------------------*/ 155 156 static struct timer_list autoresume_timer; 157 158 static void zero_autoresume(unsigned long _c) 159 { 160 struct usb_composite_dev *cdev = (void *)_c; 161 struct usb_gadget *g = cdev->gadget; 162 163 /* unconfigured devices can't issue wakeups */ 164 if (!cdev->config) 165 return; 166 167 /* Normally the host would be woken up for something 168 * more significant than just a timer firing; likely 169 * because of some direct user request. 170 */ 171 if (g->speed != USB_SPEED_UNKNOWN) { 172 int status = usb_gadget_wakeup(g); 173 INFO(cdev, "%s --> %d\n", __func__, status); 174 } 175 } 176 177 static void zero_suspend(struct usb_composite_dev *cdev) 178 { 179 if (cdev->gadget->speed == USB_SPEED_UNKNOWN) 180 return; 181 182 if (autoresume) { 183 if (max_autoresume && 184 (autoresume_step_ms > max_autoresume * 1000)) 185 autoresume_step_ms = autoresume * 1000; 186 187 mod_timer(&autoresume_timer, jiffies + 188 msecs_to_jiffies(autoresume_step_ms)); 189 DBG(cdev, "suspend, wakeup in %d milliseconds\n", 190 autoresume_step_ms); 191 192 autoresume_step_ms += autoresume_interval_ms; 193 } else 194 DBG(cdev, "%s\n", __func__); 195 } 196 197 static void zero_resume(struct usb_composite_dev *cdev) 198 { 199 DBG(cdev, "%s\n", __func__); 200 del_timer(&autoresume_timer); 201 } 202 203 /*-------------------------------------------------------------------------*/ 204 205 static struct usb_configuration loopback_driver = { 206 .label = "loopback", 207 .bConfigurationValue = 2, 208 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 209 /* .iConfiguration = DYNAMIC */ 210 }; 211 212 static struct usb_function *func_ss; 213 static struct usb_function_instance *func_inst_ss; 214 215 static int ss_config_setup(struct usb_configuration *c, 216 const struct usb_ctrlrequest *ctrl) 217 { 218 switch (ctrl->bRequest) { 219 case 0x5b: 220 case 0x5c: 221 return func_ss->setup(func_ss, ctrl); 222 default: 223 return -EOPNOTSUPP; 224 } 225 } 226 227 static struct usb_configuration sourcesink_driver = { 228 .label = "source/sink", 229 .setup = ss_config_setup, 230 .bConfigurationValue = 3, 231 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 232 /* .iConfiguration = DYNAMIC */ 233 }; 234 235 module_param_named(buflen, gzero_options.bulk_buflen, uint, 0); 236 module_param_named(pattern, gzero_options.pattern, uint, S_IRUGO|S_IWUSR); 237 MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63, 2 = none"); 238 239 module_param_named(isoc_interval, gzero_options.isoc_interval, uint, 240 S_IRUGO|S_IWUSR); 241 MODULE_PARM_DESC(isoc_interval, "1 - 16"); 242 243 module_param_named(isoc_maxpacket, gzero_options.isoc_maxpacket, uint, 244 S_IRUGO|S_IWUSR); 245 MODULE_PARM_DESC(isoc_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)"); 246 247 module_param_named(isoc_mult, gzero_options.isoc_mult, uint, S_IRUGO|S_IWUSR); 248 MODULE_PARM_DESC(isoc_mult, "0 - 2 (hs/ss only)"); 249 250 module_param_named(isoc_maxburst, gzero_options.isoc_maxburst, uint, 251 S_IRUGO|S_IWUSR); 252 MODULE_PARM_DESC(isoc_maxburst, "0 - 15 (ss only)"); 253 254 static struct usb_function *func_lb; 255 static struct usb_function_instance *func_inst_lb; 256 257 module_param_named(qlen, gzero_options.qlen, uint, S_IRUGO|S_IWUSR); 258 MODULE_PARM_DESC(qlen, "depth of loopback queue"); 259 260 module_param_named(ss_bulk_qlen, gzero_options.ss_bulk_qlen, uint, 261 S_IRUGO|S_IWUSR); 262 MODULE_PARM_DESC(bulk_qlen, "depth of sourcesink queue for bulk transfer"); 263 264 module_param_named(ss_iso_qlen, gzero_options.ss_iso_qlen, uint, 265 S_IRUGO|S_IWUSR); 266 MODULE_PARM_DESC(iso_qlen, "depth of sourcesink queue for iso transfer"); 267 268 static int zero_bind(struct usb_composite_dev *cdev) 269 { 270 struct f_ss_opts *ss_opts; 271 struct f_lb_opts *lb_opts; 272 int status; 273 274 /* Allocate string descriptor numbers ... note that string 275 * contents can be overridden by the composite_dev glue. 276 */ 277 status = usb_string_ids_tab(cdev, strings_dev); 278 if (status < 0) 279 return status; 280 281 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; 282 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; 283 device_desc.iSerialNumber = strings_dev[USB_GADGET_SERIAL_IDX].id; 284 285 setup_timer(&autoresume_timer, zero_autoresume, (unsigned long) cdev); 286 287 func_inst_ss = usb_get_function_instance("SourceSink"); 288 if (IS_ERR(func_inst_ss)) 289 return PTR_ERR(func_inst_ss); 290 291 ss_opts = container_of(func_inst_ss, struct f_ss_opts, func_inst); 292 ss_opts->pattern = gzero_options.pattern; 293 ss_opts->isoc_interval = gzero_options.isoc_interval; 294 ss_opts->isoc_maxpacket = gzero_options.isoc_maxpacket; 295 ss_opts->isoc_mult = gzero_options.isoc_mult; 296 ss_opts->isoc_maxburst = gzero_options.isoc_maxburst; 297 ss_opts->bulk_buflen = gzero_options.bulk_buflen; 298 ss_opts->bulk_qlen = gzero_options.ss_bulk_qlen; 299 ss_opts->iso_qlen = gzero_options.ss_iso_qlen; 300 301 func_ss = usb_get_function(func_inst_ss); 302 if (IS_ERR(func_ss)) { 303 status = PTR_ERR(func_ss); 304 goto err_put_func_inst_ss; 305 } 306 307 func_inst_lb = usb_get_function_instance("Loopback"); 308 if (IS_ERR(func_inst_lb)) { 309 status = PTR_ERR(func_inst_lb); 310 goto err_put_func_ss; 311 } 312 313 lb_opts = container_of(func_inst_lb, struct f_lb_opts, func_inst); 314 lb_opts->bulk_buflen = gzero_options.bulk_buflen; 315 lb_opts->qlen = gzero_options.qlen; 316 317 func_lb = usb_get_function(func_inst_lb); 318 if (IS_ERR(func_lb)) { 319 status = PTR_ERR(func_lb); 320 goto err_put_func_inst_lb; 321 } 322 323 sourcesink_driver.iConfiguration = strings_dev[USB_GZERO_SS_DESC].id; 324 loopback_driver.iConfiguration = strings_dev[USB_GZERO_LB_DESC].id; 325 326 /* support autoresume for remote wakeup testing */ 327 sourcesink_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP; 328 loopback_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP; 329 sourcesink_driver.descriptors = NULL; 330 loopback_driver.descriptors = NULL; 331 if (autoresume) { 332 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; 333 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; 334 autoresume_step_ms = autoresume * 1000; 335 } 336 337 /* support OTG systems */ 338 if (gadget_is_otg(cdev->gadget)) { 339 if (!otg_desc[0]) { 340 struct usb_descriptor_header *usb_desc; 341 342 usb_desc = usb_otg_descriptor_alloc(cdev->gadget); 343 if (!usb_desc) { 344 status = -ENOMEM; 345 goto err_conf_flb; 346 } 347 usb_otg_descriptor_init(cdev->gadget, usb_desc); 348 otg_desc[0] = usb_desc; 349 otg_desc[1] = NULL; 350 } 351 sourcesink_driver.descriptors = otg_desc; 352 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; 353 loopback_driver.descriptors = otg_desc; 354 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; 355 } 356 357 /* Register primary, then secondary configuration. Note that 358 * SH3 only allows one config... 359 */ 360 if (loopdefault) { 361 usb_add_config_only(cdev, &loopback_driver); 362 usb_add_config_only(cdev, &sourcesink_driver); 363 } else { 364 usb_add_config_only(cdev, &sourcesink_driver); 365 usb_add_config_only(cdev, &loopback_driver); 366 } 367 status = usb_add_function(&sourcesink_driver, func_ss); 368 if (status) 369 goto err_free_otg_desc; 370 371 usb_ep_autoconfig_reset(cdev->gadget); 372 status = usb_add_function(&loopback_driver, func_lb); 373 if (status) 374 goto err_free_otg_desc; 375 376 usb_ep_autoconfig_reset(cdev->gadget); 377 usb_composite_overwrite_options(cdev, &coverwrite); 378 379 INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname); 380 381 return 0; 382 383 err_free_otg_desc: 384 kfree(otg_desc[0]); 385 otg_desc[0] = NULL; 386 err_conf_flb: 387 usb_put_function(func_lb); 388 func_lb = NULL; 389 err_put_func_inst_lb: 390 usb_put_function_instance(func_inst_lb); 391 func_inst_lb = NULL; 392 err_put_func_ss: 393 usb_put_function(func_ss); 394 func_ss = NULL; 395 err_put_func_inst_ss: 396 usb_put_function_instance(func_inst_ss); 397 func_inst_ss = NULL; 398 return status; 399 } 400 401 static int zero_unbind(struct usb_composite_dev *cdev) 402 { 403 del_timer_sync(&autoresume_timer); 404 if (!IS_ERR_OR_NULL(func_ss)) 405 usb_put_function(func_ss); 406 usb_put_function_instance(func_inst_ss); 407 if (!IS_ERR_OR_NULL(func_lb)) 408 usb_put_function(func_lb); 409 usb_put_function_instance(func_inst_lb); 410 kfree(otg_desc[0]); 411 otg_desc[0] = NULL; 412 413 return 0; 414 } 415 416 static struct usb_composite_driver zero_driver = { 417 .name = "zero", 418 .dev = &device_desc, 419 .strings = dev_strings, 420 .max_speed = USB_SPEED_SUPER, 421 .bind = zero_bind, 422 .unbind = zero_unbind, 423 .suspend = zero_suspend, 424 .resume = zero_resume, 425 }; 426 427 module_usb_composite_driver(zero_driver); 428 429 MODULE_AUTHOR("David Brownell"); 430 MODULE_LICENSE("GPL"); 431