1 /* 2 * multi.c -- Multifunction Composite driver 3 * 4 * Copyright (C) 2008 David Brownell 5 * Copyright (C) 2008 Nokia Corporation 6 * Copyright (C) 2009 Samsung Electronics 7 * Author: Michal Nazarewicz (mina86@mina86.com) 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 */ 14 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/netdevice.h> 19 20 #include "u_serial.h" 21 #if defined USB_ETH_RNDIS 22 # undef USB_ETH_RNDIS 23 #endif 24 #ifdef CONFIG_USB_G_MULTI_RNDIS 25 # define USB_ETH_RNDIS y 26 #endif 27 28 29 #define DRIVER_DESC "Multifunction Composite Gadget" 30 31 MODULE_DESCRIPTION(DRIVER_DESC); 32 MODULE_AUTHOR("Michal Nazarewicz"); 33 MODULE_LICENSE("GPL"); 34 35 36 #include "f_mass_storage.h" 37 38 #include "u_ecm.h" 39 #ifdef USB_ETH_RNDIS 40 # include "u_rndis.h" 41 # include "rndis.h" 42 #endif 43 #include "u_ether.h" 44 45 USB_GADGET_COMPOSITE_OPTIONS(); 46 47 USB_ETHERNET_MODULE_PARAMETERS(); 48 49 /***************************** Device Descriptor ****************************/ 50 51 #define MULTI_VENDOR_NUM 0x1d6b /* Linux Foundation */ 52 #define MULTI_PRODUCT_NUM 0x0104 /* Multifunction Composite Gadget */ 53 54 55 enum { 56 __MULTI_NO_CONFIG, 57 #ifdef CONFIG_USB_G_MULTI_RNDIS 58 MULTI_RNDIS_CONFIG_NUM, 59 #endif 60 #ifdef CONFIG_USB_G_MULTI_CDC 61 MULTI_CDC_CONFIG_NUM, 62 #endif 63 }; 64 65 66 static struct usb_device_descriptor device_desc = { 67 .bLength = sizeof device_desc, 68 .bDescriptorType = USB_DT_DEVICE, 69 70 .bcdUSB = cpu_to_le16(0x0200), 71 72 .bDeviceClass = USB_CLASS_MISC /* 0xEF */, 73 .bDeviceSubClass = 2, 74 .bDeviceProtocol = 1, 75 76 /* Vendor and product id can be overridden by module parameters. */ 77 .idVendor = cpu_to_le16(MULTI_VENDOR_NUM), 78 .idProduct = cpu_to_le16(MULTI_PRODUCT_NUM), 79 }; 80 81 static const struct usb_descriptor_header *otg_desc[2]; 82 83 enum { 84 MULTI_STRING_RNDIS_CONFIG_IDX = USB_GADGET_FIRST_AVAIL_IDX, 85 MULTI_STRING_CDC_CONFIG_IDX, 86 }; 87 88 static struct usb_string strings_dev[] = { 89 [USB_GADGET_MANUFACTURER_IDX].s = "", 90 [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC, 91 [USB_GADGET_SERIAL_IDX].s = "", 92 [MULTI_STRING_RNDIS_CONFIG_IDX].s = "Multifunction with RNDIS", 93 [MULTI_STRING_CDC_CONFIG_IDX].s = "Multifunction with CDC ECM", 94 { } /* end of list */ 95 }; 96 97 static struct usb_gadget_strings *dev_strings[] = { 98 &(struct usb_gadget_strings){ 99 .language = 0x0409, /* en-us */ 100 .strings = strings_dev, 101 }, 102 NULL, 103 }; 104 105 106 107 108 /****************************** Configurations ******************************/ 109 110 static struct fsg_module_parameters fsg_mod_data = { .stall = 1 }; 111 #ifdef CONFIG_USB_GADGET_DEBUG_FILES 112 113 static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS; 114 115 #else 116 117 /* 118 * Number of buffers we will use. 119 * 2 is usually enough for good buffering pipeline 120 */ 121 #define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS 122 123 #endif /* CONFIG_USB_GADGET_DEBUG_FILES */ 124 125 FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data); 126 127 static struct usb_function_instance *fi_acm; 128 static struct usb_function_instance *fi_msg; 129 130 /********** RNDIS **********/ 131 132 #ifdef USB_ETH_RNDIS 133 static struct usb_function_instance *fi_rndis; 134 static struct usb_function *f_acm_rndis; 135 static struct usb_function *f_rndis; 136 static struct usb_function *f_msg_rndis; 137 138 static int rndis_do_config(struct usb_configuration *c) 139 { 140 struct fsg_opts *fsg_opts; 141 int ret; 142 143 if (gadget_is_otg(c->cdev->gadget)) { 144 c->descriptors = otg_desc; 145 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; 146 } 147 148 f_rndis = usb_get_function(fi_rndis); 149 if (IS_ERR(f_rndis)) 150 return PTR_ERR(f_rndis); 151 152 ret = usb_add_function(c, f_rndis); 153 if (ret < 0) 154 goto err_func_rndis; 155 156 f_acm_rndis = usb_get_function(fi_acm); 157 if (IS_ERR(f_acm_rndis)) { 158 ret = PTR_ERR(f_acm_rndis); 159 goto err_func_acm; 160 } 161 162 ret = usb_add_function(c, f_acm_rndis); 163 if (ret) 164 goto err_conf; 165 166 f_msg_rndis = usb_get_function(fi_msg); 167 if (IS_ERR(f_msg_rndis)) { 168 ret = PTR_ERR(f_msg_rndis); 169 goto err_fsg; 170 } 171 172 fsg_opts = fsg_opts_from_func_inst(fi_msg); 173 ret = fsg_common_run_thread(fsg_opts->common); 174 if (ret) 175 goto err_run; 176 177 ret = usb_add_function(c, f_msg_rndis); 178 if (ret) 179 goto err_run; 180 181 return 0; 182 err_run: 183 usb_put_function(f_msg_rndis); 184 err_fsg: 185 usb_remove_function(c, f_acm_rndis); 186 err_conf: 187 usb_put_function(f_acm_rndis); 188 err_func_acm: 189 usb_remove_function(c, f_rndis); 190 err_func_rndis: 191 usb_put_function(f_rndis); 192 return ret; 193 } 194 195 static __ref int rndis_config_register(struct usb_composite_dev *cdev) 196 { 197 static struct usb_configuration config = { 198 .bConfigurationValue = MULTI_RNDIS_CONFIG_NUM, 199 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 200 }; 201 202 config.label = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].s; 203 config.iConfiguration = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].id; 204 205 return usb_add_config(cdev, &config, rndis_do_config); 206 } 207 208 #else 209 210 static __ref int rndis_config_register(struct usb_composite_dev *cdev) 211 { 212 return 0; 213 } 214 215 #endif 216 217 218 /********** CDC ECM **********/ 219 220 #ifdef CONFIG_USB_G_MULTI_CDC 221 static struct usb_function_instance *fi_ecm; 222 static struct usb_function *f_acm_multi; 223 static struct usb_function *f_ecm; 224 static struct usb_function *f_msg_multi; 225 226 static int cdc_do_config(struct usb_configuration *c) 227 { 228 struct fsg_opts *fsg_opts; 229 int ret; 230 231 if (gadget_is_otg(c->cdev->gadget)) { 232 c->descriptors = otg_desc; 233 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; 234 } 235 236 f_ecm = usb_get_function(fi_ecm); 237 if (IS_ERR(f_ecm)) 238 return PTR_ERR(f_ecm); 239 240 ret = usb_add_function(c, f_ecm); 241 if (ret < 0) 242 goto err_func_ecm; 243 244 /* implicit port_num is zero */ 245 f_acm_multi = usb_get_function(fi_acm); 246 if (IS_ERR(f_acm_multi)) { 247 ret = PTR_ERR(f_acm_multi); 248 goto err_func_acm; 249 } 250 251 ret = usb_add_function(c, f_acm_multi); 252 if (ret) 253 goto err_conf; 254 255 f_msg_multi = usb_get_function(fi_msg); 256 if (IS_ERR(f_msg_multi)) { 257 ret = PTR_ERR(f_msg_multi); 258 goto err_fsg; 259 } 260 261 fsg_opts = fsg_opts_from_func_inst(fi_msg); 262 ret = fsg_common_run_thread(fsg_opts->common); 263 if (ret) 264 goto err_run; 265 266 ret = usb_add_function(c, f_msg_multi); 267 if (ret) 268 goto err_run; 269 270 return 0; 271 err_run: 272 usb_put_function(f_msg_multi); 273 err_fsg: 274 usb_remove_function(c, f_acm_multi); 275 err_conf: 276 usb_put_function(f_acm_multi); 277 err_func_acm: 278 usb_remove_function(c, f_ecm); 279 err_func_ecm: 280 usb_put_function(f_ecm); 281 return ret; 282 } 283 284 static __ref int cdc_config_register(struct usb_composite_dev *cdev) 285 { 286 static struct usb_configuration config = { 287 .bConfigurationValue = MULTI_CDC_CONFIG_NUM, 288 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 289 }; 290 291 config.label = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].s; 292 config.iConfiguration = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].id; 293 294 return usb_add_config(cdev, &config, cdc_do_config); 295 } 296 297 #else 298 299 static __ref int cdc_config_register(struct usb_composite_dev *cdev) 300 { 301 return 0; 302 } 303 304 #endif 305 306 307 308 /****************************** Gadget Bind ******************************/ 309 310 static int __ref multi_bind(struct usb_composite_dev *cdev) 311 { 312 struct usb_gadget *gadget = cdev->gadget; 313 #ifdef CONFIG_USB_G_MULTI_CDC 314 struct f_ecm_opts *ecm_opts; 315 #endif 316 #ifdef USB_ETH_RNDIS 317 struct f_rndis_opts *rndis_opts; 318 #endif 319 struct fsg_opts *fsg_opts; 320 struct fsg_config config; 321 int status; 322 323 if (!can_support_ecm(cdev->gadget)) { 324 dev_err(&gadget->dev, "controller '%s' not usable\n", 325 gadget->name); 326 return -EINVAL; 327 } 328 329 #ifdef CONFIG_USB_G_MULTI_CDC 330 fi_ecm = usb_get_function_instance("ecm"); 331 if (IS_ERR(fi_ecm)) 332 return PTR_ERR(fi_ecm); 333 334 ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst); 335 336 gether_set_qmult(ecm_opts->net, qmult); 337 if (!gether_set_host_addr(ecm_opts->net, host_addr)) 338 pr_info("using host ethernet address: %s", host_addr); 339 if (!gether_set_dev_addr(ecm_opts->net, dev_addr)) 340 pr_info("using self ethernet address: %s", dev_addr); 341 #endif 342 343 #ifdef USB_ETH_RNDIS 344 fi_rndis = usb_get_function_instance("rndis"); 345 if (IS_ERR(fi_rndis)) { 346 status = PTR_ERR(fi_rndis); 347 goto fail; 348 } 349 350 rndis_opts = container_of(fi_rndis, struct f_rndis_opts, func_inst); 351 352 gether_set_qmult(rndis_opts->net, qmult); 353 if (!gether_set_host_addr(rndis_opts->net, host_addr)) 354 pr_info("using host ethernet address: %s", host_addr); 355 if (!gether_set_dev_addr(rndis_opts->net, dev_addr)) 356 pr_info("using self ethernet address: %s", dev_addr); 357 #endif 358 359 #if (defined CONFIG_USB_G_MULTI_CDC && defined USB_ETH_RNDIS) 360 /* 361 * If both ecm and rndis are selected then: 362 * 1) rndis borrows the net interface from ecm 363 * 2) since the interface is shared it must not be bound 364 * twice - in ecm's _and_ rndis' binds, so do it here. 365 */ 366 gether_set_gadget(ecm_opts->net, cdev->gadget); 367 status = gether_register_netdev(ecm_opts->net); 368 if (status) 369 goto fail0; 370 371 rndis_borrow_net(fi_rndis, ecm_opts->net); 372 ecm_opts->bound = true; 373 #endif 374 375 /* set up serial link layer */ 376 fi_acm = usb_get_function_instance("acm"); 377 if (IS_ERR(fi_acm)) { 378 status = PTR_ERR(fi_acm); 379 goto fail0; 380 } 381 382 /* set up mass storage function */ 383 fi_msg = usb_get_function_instance("mass_storage"); 384 if (IS_ERR(fi_msg)) { 385 status = PTR_ERR(fi_msg); 386 goto fail1; 387 } 388 fsg_config_from_params(&config, &fsg_mod_data, fsg_num_buffers); 389 fsg_opts = fsg_opts_from_func_inst(fi_msg); 390 391 fsg_opts->no_configfs = true; 392 status = fsg_common_set_num_buffers(fsg_opts->common, fsg_num_buffers); 393 if (status) 394 goto fail2; 395 396 status = fsg_common_set_cdev(fsg_opts->common, cdev, config.can_stall); 397 if (status) 398 goto fail_set_cdev; 399 400 fsg_common_set_sysfs(fsg_opts->common, true); 401 status = fsg_common_create_luns(fsg_opts->common, &config); 402 if (status) 403 goto fail_set_cdev; 404 405 fsg_common_set_inquiry_string(fsg_opts->common, config.vendor_name, 406 config.product_name); 407 408 /* allocate string IDs */ 409 status = usb_string_ids_tab(cdev, strings_dev); 410 if (unlikely(status < 0)) 411 goto fail_string_ids; 412 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; 413 414 if (gadget_is_otg(gadget) && !otg_desc[0]) { 415 struct usb_descriptor_header *usb_desc; 416 417 usb_desc = usb_otg_descriptor_alloc(gadget); 418 if (!usb_desc) 419 goto fail_string_ids; 420 usb_otg_descriptor_init(gadget, usb_desc); 421 otg_desc[0] = usb_desc; 422 otg_desc[1] = NULL; 423 } 424 425 /* register configurations */ 426 status = rndis_config_register(cdev); 427 if (unlikely(status < 0)) 428 goto fail_otg_desc; 429 430 status = cdc_config_register(cdev); 431 if (unlikely(status < 0)) 432 goto fail_otg_desc; 433 usb_composite_overwrite_options(cdev, &coverwrite); 434 435 /* we're done */ 436 dev_info(&gadget->dev, DRIVER_DESC "\n"); 437 return 0; 438 439 440 /* error recovery */ 441 fail_otg_desc: 442 kfree(otg_desc[0]); 443 otg_desc[0] = NULL; 444 fail_string_ids: 445 fsg_common_remove_luns(fsg_opts->common); 446 fail_set_cdev: 447 fsg_common_free_buffers(fsg_opts->common); 448 fail2: 449 usb_put_function_instance(fi_msg); 450 fail1: 451 usb_put_function_instance(fi_acm); 452 fail0: 453 #ifdef USB_ETH_RNDIS 454 usb_put_function_instance(fi_rndis); 455 fail: 456 #endif 457 #ifdef CONFIG_USB_G_MULTI_CDC 458 usb_put_function_instance(fi_ecm); 459 #endif 460 return status; 461 } 462 463 static int multi_unbind(struct usb_composite_dev *cdev) 464 { 465 #ifdef CONFIG_USB_G_MULTI_CDC 466 usb_put_function(f_msg_multi); 467 #endif 468 #ifdef USB_ETH_RNDIS 469 usb_put_function(f_msg_rndis); 470 #endif 471 usb_put_function_instance(fi_msg); 472 #ifdef CONFIG_USB_G_MULTI_CDC 473 usb_put_function(f_acm_multi); 474 #endif 475 #ifdef USB_ETH_RNDIS 476 usb_put_function(f_acm_rndis); 477 #endif 478 usb_put_function_instance(fi_acm); 479 #ifdef USB_ETH_RNDIS 480 usb_put_function(f_rndis); 481 usb_put_function_instance(fi_rndis); 482 #endif 483 #ifdef CONFIG_USB_G_MULTI_CDC 484 usb_put_function(f_ecm); 485 usb_put_function_instance(fi_ecm); 486 #endif 487 kfree(otg_desc[0]); 488 otg_desc[0] = NULL; 489 490 return 0; 491 } 492 493 494 /****************************** Some noise ******************************/ 495 496 497 static struct usb_composite_driver multi_driver = { 498 .name = "g_multi", 499 .dev = &device_desc, 500 .strings = dev_strings, 501 .max_speed = USB_SPEED_HIGH, 502 .bind = multi_bind, 503 .unbind = multi_unbind, 504 .needs_serial = 1, 505 }; 506 507 module_usb_composite_driver(multi_driver); 508