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 = DYNAMIC */ 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 int ret; 141 142 if (gadget_is_otg(c->cdev->gadget)) { 143 c->descriptors = otg_desc; 144 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; 145 } 146 147 f_rndis = usb_get_function(fi_rndis); 148 if (IS_ERR(f_rndis)) 149 return PTR_ERR(f_rndis); 150 151 ret = usb_add_function(c, f_rndis); 152 if (ret < 0) 153 goto err_func_rndis; 154 155 f_acm_rndis = usb_get_function(fi_acm); 156 if (IS_ERR(f_acm_rndis)) { 157 ret = PTR_ERR(f_acm_rndis); 158 goto err_func_acm; 159 } 160 161 ret = usb_add_function(c, f_acm_rndis); 162 if (ret) 163 goto err_conf; 164 165 f_msg_rndis = usb_get_function(fi_msg); 166 if (IS_ERR(f_msg_rndis)) { 167 ret = PTR_ERR(f_msg_rndis); 168 goto err_fsg; 169 } 170 171 ret = usb_add_function(c, f_msg_rndis); 172 if (ret) 173 goto err_run; 174 175 return 0; 176 err_run: 177 usb_put_function(f_msg_rndis); 178 err_fsg: 179 usb_remove_function(c, f_acm_rndis); 180 err_conf: 181 usb_put_function(f_acm_rndis); 182 err_func_acm: 183 usb_remove_function(c, f_rndis); 184 err_func_rndis: 185 usb_put_function(f_rndis); 186 return ret; 187 } 188 189 static __ref int rndis_config_register(struct usb_composite_dev *cdev) 190 { 191 static struct usb_configuration config = { 192 .bConfigurationValue = MULTI_RNDIS_CONFIG_NUM, 193 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 194 }; 195 196 config.label = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].s; 197 config.iConfiguration = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].id; 198 199 return usb_add_config(cdev, &config, rndis_do_config); 200 } 201 202 #else 203 204 static __ref int rndis_config_register(struct usb_composite_dev *cdev) 205 { 206 return 0; 207 } 208 209 #endif 210 211 212 /********** CDC ECM **********/ 213 214 #ifdef CONFIG_USB_G_MULTI_CDC 215 static struct usb_function_instance *fi_ecm; 216 static struct usb_function *f_acm_multi; 217 static struct usb_function *f_ecm; 218 static struct usb_function *f_msg_multi; 219 220 static int cdc_do_config(struct usb_configuration *c) 221 { 222 int ret; 223 224 if (gadget_is_otg(c->cdev->gadget)) { 225 c->descriptors = otg_desc; 226 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; 227 } 228 229 f_ecm = usb_get_function(fi_ecm); 230 if (IS_ERR(f_ecm)) 231 return PTR_ERR(f_ecm); 232 233 ret = usb_add_function(c, f_ecm); 234 if (ret < 0) 235 goto err_func_ecm; 236 237 /* implicit port_num is zero */ 238 f_acm_multi = usb_get_function(fi_acm); 239 if (IS_ERR(f_acm_multi)) { 240 ret = PTR_ERR(f_acm_multi); 241 goto err_func_acm; 242 } 243 244 ret = usb_add_function(c, f_acm_multi); 245 if (ret) 246 goto err_conf; 247 248 f_msg_multi = usb_get_function(fi_msg); 249 if (IS_ERR(f_msg_multi)) { 250 ret = PTR_ERR(f_msg_multi); 251 goto err_fsg; 252 } 253 254 ret = usb_add_function(c, f_msg_multi); 255 if (ret) 256 goto err_run; 257 258 return 0; 259 err_run: 260 usb_put_function(f_msg_multi); 261 err_fsg: 262 usb_remove_function(c, f_acm_multi); 263 err_conf: 264 usb_put_function(f_acm_multi); 265 err_func_acm: 266 usb_remove_function(c, f_ecm); 267 err_func_ecm: 268 usb_put_function(f_ecm); 269 return ret; 270 } 271 272 static __ref int cdc_config_register(struct usb_composite_dev *cdev) 273 { 274 static struct usb_configuration config = { 275 .bConfigurationValue = MULTI_CDC_CONFIG_NUM, 276 .bmAttributes = USB_CONFIG_ATT_SELFPOWER, 277 }; 278 279 config.label = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].s; 280 config.iConfiguration = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].id; 281 282 return usb_add_config(cdev, &config, cdc_do_config); 283 } 284 285 #else 286 287 static __ref int cdc_config_register(struct usb_composite_dev *cdev) 288 { 289 return 0; 290 } 291 292 #endif 293 294 295 296 /****************************** Gadget Bind ******************************/ 297 298 static int __ref multi_bind(struct usb_composite_dev *cdev) 299 { 300 struct usb_gadget *gadget = cdev->gadget; 301 #ifdef CONFIG_USB_G_MULTI_CDC 302 struct f_ecm_opts *ecm_opts; 303 #endif 304 #ifdef USB_ETH_RNDIS 305 struct f_rndis_opts *rndis_opts; 306 #endif 307 struct fsg_opts *fsg_opts; 308 struct fsg_config config; 309 int status; 310 311 if (!can_support_ecm(cdev->gadget)) { 312 dev_err(&gadget->dev, "controller '%s' not usable\n", 313 gadget->name); 314 return -EINVAL; 315 } 316 317 #ifdef CONFIG_USB_G_MULTI_CDC 318 fi_ecm = usb_get_function_instance("ecm"); 319 if (IS_ERR(fi_ecm)) 320 return PTR_ERR(fi_ecm); 321 322 ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst); 323 324 gether_set_qmult(ecm_opts->net, qmult); 325 if (!gether_set_host_addr(ecm_opts->net, host_addr)) 326 pr_info("using host ethernet address: %s", host_addr); 327 if (!gether_set_dev_addr(ecm_opts->net, dev_addr)) 328 pr_info("using self ethernet address: %s", dev_addr); 329 #endif 330 331 #ifdef USB_ETH_RNDIS 332 fi_rndis = usb_get_function_instance("rndis"); 333 if (IS_ERR(fi_rndis)) { 334 status = PTR_ERR(fi_rndis); 335 goto fail; 336 } 337 338 rndis_opts = container_of(fi_rndis, struct f_rndis_opts, func_inst); 339 340 gether_set_qmult(rndis_opts->net, qmult); 341 if (!gether_set_host_addr(rndis_opts->net, host_addr)) 342 pr_info("using host ethernet address: %s", host_addr); 343 if (!gether_set_dev_addr(rndis_opts->net, dev_addr)) 344 pr_info("using self ethernet address: %s", dev_addr); 345 #endif 346 347 #if (defined CONFIG_USB_G_MULTI_CDC && defined USB_ETH_RNDIS) 348 /* 349 * If both ecm and rndis are selected then: 350 * 1) rndis borrows the net interface from ecm 351 * 2) since the interface is shared it must not be bound 352 * twice - in ecm's _and_ rndis' binds, so do it here. 353 */ 354 gether_set_gadget(ecm_opts->net, cdev->gadget); 355 status = gether_register_netdev(ecm_opts->net); 356 if (status) 357 goto fail0; 358 359 rndis_borrow_net(fi_rndis, ecm_opts->net); 360 ecm_opts->bound = true; 361 #endif 362 363 /* set up serial link layer */ 364 fi_acm = usb_get_function_instance("acm"); 365 if (IS_ERR(fi_acm)) { 366 status = PTR_ERR(fi_acm); 367 goto fail0; 368 } 369 370 /* set up mass storage function */ 371 fi_msg = usb_get_function_instance("mass_storage"); 372 if (IS_ERR(fi_msg)) { 373 status = PTR_ERR(fi_msg); 374 goto fail1; 375 } 376 fsg_config_from_params(&config, &fsg_mod_data, fsg_num_buffers); 377 fsg_opts = fsg_opts_from_func_inst(fi_msg); 378 379 fsg_opts->no_configfs = true; 380 status = fsg_common_set_num_buffers(fsg_opts->common, fsg_num_buffers); 381 if (status) 382 goto fail2; 383 384 status = fsg_common_set_cdev(fsg_opts->common, cdev, config.can_stall); 385 if (status) 386 goto fail_set_cdev; 387 388 fsg_common_set_sysfs(fsg_opts->common, true); 389 status = fsg_common_create_luns(fsg_opts->common, &config); 390 if (status) 391 goto fail_set_cdev; 392 393 fsg_common_set_inquiry_string(fsg_opts->common, config.vendor_name, 394 config.product_name); 395 396 /* allocate string IDs */ 397 status = usb_string_ids_tab(cdev, strings_dev); 398 if (unlikely(status < 0)) 399 goto fail_string_ids; 400 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; 401 402 if (gadget_is_otg(gadget) && !otg_desc[0]) { 403 struct usb_descriptor_header *usb_desc; 404 405 usb_desc = usb_otg_descriptor_alloc(gadget); 406 if (!usb_desc) 407 goto fail_string_ids; 408 usb_otg_descriptor_init(gadget, usb_desc); 409 otg_desc[0] = usb_desc; 410 otg_desc[1] = NULL; 411 } 412 413 /* register configurations */ 414 status = rndis_config_register(cdev); 415 if (unlikely(status < 0)) 416 goto fail_otg_desc; 417 418 status = cdc_config_register(cdev); 419 if (unlikely(status < 0)) 420 goto fail_otg_desc; 421 usb_composite_overwrite_options(cdev, &coverwrite); 422 423 /* we're done */ 424 dev_info(&gadget->dev, DRIVER_DESC "\n"); 425 return 0; 426 427 428 /* error recovery */ 429 fail_otg_desc: 430 kfree(otg_desc[0]); 431 otg_desc[0] = NULL; 432 fail_string_ids: 433 fsg_common_remove_luns(fsg_opts->common); 434 fail_set_cdev: 435 fsg_common_free_buffers(fsg_opts->common); 436 fail2: 437 usb_put_function_instance(fi_msg); 438 fail1: 439 usb_put_function_instance(fi_acm); 440 fail0: 441 #ifdef USB_ETH_RNDIS 442 usb_put_function_instance(fi_rndis); 443 fail: 444 #endif 445 #ifdef CONFIG_USB_G_MULTI_CDC 446 usb_put_function_instance(fi_ecm); 447 #endif 448 return status; 449 } 450 451 static int multi_unbind(struct usb_composite_dev *cdev) 452 { 453 #ifdef CONFIG_USB_G_MULTI_CDC 454 usb_put_function(f_msg_multi); 455 #endif 456 #ifdef USB_ETH_RNDIS 457 usb_put_function(f_msg_rndis); 458 #endif 459 usb_put_function_instance(fi_msg); 460 #ifdef CONFIG_USB_G_MULTI_CDC 461 usb_put_function(f_acm_multi); 462 #endif 463 #ifdef USB_ETH_RNDIS 464 usb_put_function(f_acm_rndis); 465 #endif 466 usb_put_function_instance(fi_acm); 467 #ifdef USB_ETH_RNDIS 468 usb_put_function(f_rndis); 469 usb_put_function_instance(fi_rndis); 470 #endif 471 #ifdef CONFIG_USB_G_MULTI_CDC 472 usb_put_function(f_ecm); 473 usb_put_function_instance(fi_ecm); 474 #endif 475 kfree(otg_desc[0]); 476 otg_desc[0] = NULL; 477 478 return 0; 479 } 480 481 482 /****************************** Some noise ******************************/ 483 484 485 static struct usb_composite_driver multi_driver = { 486 .name = "g_multi", 487 .dev = &device_desc, 488 .strings = dev_strings, 489 .max_speed = USB_SPEED_HIGH, 490 .bind = multi_bind, 491 .unbind = multi_unbind, 492 .needs_serial = 1, 493 }; 494 495 module_usb_composite_driver(multi_driver); 496