1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * g_ffs.c -- user mode file system API for USB composite function controllers 4 * 5 * Copyright (C) 2010 Samsung Electronics 6 * Author: Michal Nazarewicz <mina86@mina86.com> 7 */ 8 9 #define pr_fmt(fmt) "g_ffs: " fmt 10 11 #include <linux/module.h> 12 13 #if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS 14 #include <linux/netdevice.h> 15 16 # if defined USB_ETH_RNDIS 17 # undef USB_ETH_RNDIS 18 # endif 19 # ifdef CONFIG_USB_FUNCTIONFS_RNDIS 20 # define USB_ETH_RNDIS y 21 # endif 22 23 # include "u_ecm.h" 24 # include "u_gether.h" 25 # ifdef USB_ETH_RNDIS 26 # include "u_rndis.h" 27 # include "rndis.h" 28 # endif 29 # include "u_ether.h" 30 31 USB_ETHERNET_MODULE_PARAMETERS(); 32 33 # ifdef CONFIG_USB_FUNCTIONFS_ETH 34 static int eth_bind_config(struct usb_configuration *c); 35 static struct usb_function_instance *fi_ecm; 36 static struct usb_function *f_ecm; 37 static struct usb_function_instance *fi_geth; 38 static struct usb_function *f_geth; 39 # endif 40 # ifdef CONFIG_USB_FUNCTIONFS_RNDIS 41 static int bind_rndis_config(struct usb_configuration *c); 42 static struct usb_function_instance *fi_rndis; 43 static struct usb_function *f_rndis; 44 # endif 45 #endif 46 47 #include "u_fs.h" 48 49 #define DRIVER_NAME "g_ffs" 50 #define DRIVER_DESC "USB Function Filesystem" 51 #define DRIVER_VERSION "24 Aug 2004" 52 53 MODULE_DESCRIPTION(DRIVER_DESC); 54 MODULE_AUTHOR("Michal Nazarewicz"); 55 MODULE_LICENSE("GPL"); 56 57 #define GFS_VENDOR_ID 0x1d6b /* Linux Foundation */ 58 #define GFS_PRODUCT_ID 0x0105 /* FunctionFS Gadget */ 59 60 #define GFS_MAX_DEVS 10 61 62 USB_GADGET_COMPOSITE_OPTIONS(); 63 64 static struct usb_device_descriptor gfs_dev_desc = { 65 .bLength = sizeof gfs_dev_desc, 66 .bDescriptorType = USB_DT_DEVICE, 67 68 /* .bcdUSB = DYNAMIC */ 69 .bDeviceClass = USB_CLASS_PER_INTERFACE, 70 71 .idVendor = cpu_to_le16(GFS_VENDOR_ID), 72 .idProduct = cpu_to_le16(GFS_PRODUCT_ID), 73 }; 74 75 static char *func_names[GFS_MAX_DEVS]; 76 static unsigned int func_num; 77 78 module_param_named(bDeviceClass, gfs_dev_desc.bDeviceClass, byte, 0644); 79 MODULE_PARM_DESC(bDeviceClass, "USB Device class"); 80 module_param_named(bDeviceSubClass, gfs_dev_desc.bDeviceSubClass, byte, 0644); 81 MODULE_PARM_DESC(bDeviceSubClass, "USB Device subclass"); 82 module_param_named(bDeviceProtocol, gfs_dev_desc.bDeviceProtocol, byte, 0644); 83 MODULE_PARM_DESC(bDeviceProtocol, "USB Device protocol"); 84 module_param_array_named(functions, func_names, charp, &func_num, 0); 85 MODULE_PARM_DESC(functions, "USB Functions list"); 86 87 static const struct usb_descriptor_header *gfs_otg_desc[2]; 88 89 /* String IDs are assigned dynamically */ 90 static struct usb_string gfs_strings[] = { 91 [USB_GADGET_MANUFACTURER_IDX].s = "", 92 [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC, 93 [USB_GADGET_SERIAL_IDX].s = "", 94 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 95 { .s = "FunctionFS + RNDIS" }, 96 #endif 97 #ifdef CONFIG_USB_FUNCTIONFS_ETH 98 { .s = "FunctionFS + ECM" }, 99 #endif 100 #ifdef CONFIG_USB_FUNCTIONFS_GENERIC 101 { .s = "FunctionFS" }, 102 #endif 103 { } /* end of list */ 104 }; 105 106 static struct usb_gadget_strings *gfs_dev_strings[] = { 107 &(struct usb_gadget_strings) { 108 .language = 0x0409, /* en-us */ 109 .strings = gfs_strings, 110 }, 111 NULL, 112 }; 113 114 struct gfs_configuration { 115 struct usb_configuration c; 116 int (*eth)(struct usb_configuration *c); 117 int num; 118 }; 119 120 static struct gfs_configuration gfs_configurations[] = { 121 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 122 { 123 .eth = bind_rndis_config, 124 }, 125 #endif 126 127 #ifdef CONFIG_USB_FUNCTIONFS_ETH 128 { 129 .eth = eth_bind_config, 130 }, 131 #endif 132 133 #ifdef CONFIG_USB_FUNCTIONFS_GENERIC 134 { 135 }, 136 #endif 137 }; 138 139 static void *functionfs_acquire_dev(struct ffs_dev *dev); 140 static void functionfs_release_dev(struct ffs_dev *dev); 141 static int functionfs_ready_callback(struct ffs_data *ffs); 142 static void functionfs_closed_callback(struct ffs_data *ffs); 143 static int gfs_bind(struct usb_composite_dev *cdev); 144 static int gfs_unbind(struct usb_composite_dev *cdev); 145 static int gfs_do_config(struct usb_configuration *c); 146 147 148 static struct usb_composite_driver gfs_driver = { 149 .name = DRIVER_NAME, 150 .dev = &gfs_dev_desc, 151 .strings = gfs_dev_strings, 152 .max_speed = USB_SPEED_SUPER, 153 .bind = gfs_bind, 154 .unbind = gfs_unbind, 155 }; 156 157 static unsigned int missing_funcs; 158 static bool gfs_registered; 159 static bool gfs_single_func; 160 static struct usb_function_instance **fi_ffs; 161 static struct usb_function **f_ffs[] = { 162 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 163 NULL, 164 #endif 165 166 #ifdef CONFIG_USB_FUNCTIONFS_ETH 167 NULL, 168 #endif 169 170 #ifdef CONFIG_USB_FUNCTIONFS_GENERIC 171 NULL, 172 #endif 173 }; 174 175 #define N_CONF ARRAY_SIZE(f_ffs) 176 177 static int __init gfs_init(void) 178 { 179 struct f_fs_opts *opts; 180 int i; 181 int ret = 0; 182 183 ENTER(); 184 185 if (func_num < 2) { 186 gfs_single_func = true; 187 func_num = 1; 188 } 189 190 /* 191 * Allocate in one chunk for easier maintenance 192 */ 193 f_ffs[0] = kcalloc(func_num * N_CONF, sizeof(*f_ffs), GFP_KERNEL); 194 if (!f_ffs[0]) { 195 ret = -ENOMEM; 196 goto no_func; 197 } 198 for (i = 1; i < N_CONF; ++i) 199 f_ffs[i] = f_ffs[0] + i * func_num; 200 201 fi_ffs = kcalloc(func_num, sizeof(*fi_ffs), GFP_KERNEL); 202 if (!fi_ffs) { 203 ret = -ENOMEM; 204 goto no_func; 205 } 206 207 for (i = 0; i < func_num; i++) { 208 fi_ffs[i] = usb_get_function_instance("ffs"); 209 if (IS_ERR(fi_ffs[i])) { 210 ret = PTR_ERR(fi_ffs[i]); 211 --i; 212 goto no_dev; 213 } 214 opts = to_f_fs_opts(fi_ffs[i]); 215 if (gfs_single_func) 216 ret = ffs_single_dev(opts->dev); 217 else 218 ret = ffs_name_dev(opts->dev, func_names[i]); 219 if (ret) 220 goto no_dev; 221 opts->dev->ffs_ready_callback = functionfs_ready_callback; 222 opts->dev->ffs_closed_callback = functionfs_closed_callback; 223 opts->dev->ffs_acquire_dev_callback = functionfs_acquire_dev; 224 opts->dev->ffs_release_dev_callback = functionfs_release_dev; 225 opts->no_configfs = true; 226 } 227 228 missing_funcs = func_num; 229 230 return 0; 231 no_dev: 232 while (i >= 0) 233 usb_put_function_instance(fi_ffs[i--]); 234 kfree(fi_ffs); 235 no_func: 236 kfree(f_ffs[0]); 237 return ret; 238 } 239 module_init(gfs_init); 240 241 static void __exit gfs_exit(void) 242 { 243 int i; 244 245 ENTER(); 246 247 if (gfs_registered) 248 usb_composite_unregister(&gfs_driver); 249 gfs_registered = false; 250 251 kfree(f_ffs[0]); 252 253 for (i = 0; i < func_num; i++) 254 usb_put_function_instance(fi_ffs[i]); 255 256 kfree(fi_ffs); 257 } 258 module_exit(gfs_exit); 259 260 static void *functionfs_acquire_dev(struct ffs_dev *dev) 261 { 262 if (!try_module_get(THIS_MODULE)) 263 return ERR_PTR(-ENOENT); 264 265 return NULL; 266 } 267 268 static void functionfs_release_dev(struct ffs_dev *dev) 269 { 270 module_put(THIS_MODULE); 271 } 272 273 /* 274 * The caller of this function takes ffs_lock 275 */ 276 static int functionfs_ready_callback(struct ffs_data *ffs) 277 { 278 int ret = 0; 279 280 if (--missing_funcs) 281 return 0; 282 283 if (gfs_registered) 284 return -EBUSY; 285 286 gfs_registered = true; 287 288 ret = usb_composite_probe(&gfs_driver); 289 if (unlikely(ret < 0)) { 290 ++missing_funcs; 291 gfs_registered = false; 292 } 293 294 return ret; 295 } 296 297 /* 298 * The caller of this function takes ffs_lock 299 */ 300 static void functionfs_closed_callback(struct ffs_data *ffs) 301 { 302 missing_funcs++; 303 304 if (gfs_registered) 305 usb_composite_unregister(&gfs_driver); 306 gfs_registered = false; 307 } 308 309 /* 310 * It is assumed that gfs_bind is called from a context where ffs_lock is held 311 */ 312 static int gfs_bind(struct usb_composite_dev *cdev) 313 { 314 #if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS 315 struct net_device *net; 316 #endif 317 int ret, i; 318 319 ENTER(); 320 321 if (missing_funcs) 322 return -ENODEV; 323 #if defined CONFIG_USB_FUNCTIONFS_ETH 324 if (can_support_ecm(cdev->gadget)) { 325 struct f_ecm_opts *ecm_opts; 326 327 fi_ecm = usb_get_function_instance("ecm"); 328 if (IS_ERR(fi_ecm)) 329 return PTR_ERR(fi_ecm); 330 ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst); 331 net = ecm_opts->net; 332 } else { 333 struct f_gether_opts *geth_opts; 334 335 fi_geth = usb_get_function_instance("geth"); 336 if (IS_ERR(fi_geth)) 337 return PTR_ERR(fi_geth); 338 geth_opts = container_of(fi_geth, struct f_gether_opts, 339 func_inst); 340 net = geth_opts->net; 341 } 342 #endif 343 344 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 345 { 346 fi_rndis = usb_get_function_instance("rndis"); 347 if (IS_ERR(fi_rndis)) { 348 ret = PTR_ERR(fi_rndis); 349 goto error; 350 } 351 #ifndef CONFIG_USB_FUNCTIONFS_ETH 352 net = container_of(fi_rndis, struct f_rndis_opts, 353 func_inst)->net; 354 #endif 355 } 356 #endif 357 358 #if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS 359 gether_set_qmult(net, qmult); 360 if (!gether_set_host_addr(net, host_addr)) 361 pr_info("using host ethernet address: %s", host_addr); 362 if (!gether_set_dev_addr(net, dev_addr)) 363 pr_info("using self ethernet address: %s", dev_addr); 364 #endif 365 366 #if defined CONFIG_USB_FUNCTIONFS_RNDIS && defined CONFIG_USB_FUNCTIONFS_ETH 367 gether_set_gadget(net, cdev->gadget); 368 ret = gether_register_netdev(net); 369 if (ret) 370 goto error_rndis; 371 372 if (can_support_ecm(cdev->gadget)) { 373 struct f_ecm_opts *ecm_opts; 374 375 ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst); 376 ecm_opts->bound = true; 377 } else { 378 struct f_gether_opts *geth_opts; 379 380 geth_opts = container_of(fi_geth, struct f_gether_opts, 381 func_inst); 382 geth_opts->bound = true; 383 } 384 385 rndis_borrow_net(fi_rndis, net); 386 #endif 387 388 /* TODO: gstrings_attach? */ 389 ret = usb_string_ids_tab(cdev, gfs_strings); 390 if (unlikely(ret < 0)) 391 goto error_rndis; 392 gfs_dev_desc.iProduct = gfs_strings[USB_GADGET_PRODUCT_IDX].id; 393 394 if (gadget_is_otg(cdev->gadget) && !gfs_otg_desc[0]) { 395 struct usb_descriptor_header *usb_desc; 396 397 usb_desc = usb_otg_descriptor_alloc(cdev->gadget); 398 if (!usb_desc) 399 goto error_rndis; 400 usb_otg_descriptor_init(cdev->gadget, usb_desc); 401 gfs_otg_desc[0] = usb_desc; 402 gfs_otg_desc[1] = NULL; 403 } 404 405 for (i = 0; i < ARRAY_SIZE(gfs_configurations); ++i) { 406 struct gfs_configuration *c = gfs_configurations + i; 407 int sid = USB_GADGET_FIRST_AVAIL_IDX + i; 408 409 c->c.label = gfs_strings[sid].s; 410 c->c.iConfiguration = gfs_strings[sid].id; 411 c->c.bConfigurationValue = 1 + i; 412 c->c.bmAttributes = USB_CONFIG_ATT_SELFPOWER; 413 414 c->num = i; 415 416 ret = usb_add_config(cdev, &c->c, gfs_do_config); 417 if (unlikely(ret < 0)) 418 goto error_unbind; 419 } 420 usb_composite_overwrite_options(cdev, &coverwrite); 421 return 0; 422 423 /* TODO */ 424 error_unbind: 425 kfree(gfs_otg_desc[0]); 426 gfs_otg_desc[0] = NULL; 427 error_rndis: 428 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 429 usb_put_function_instance(fi_rndis); 430 error: 431 #endif 432 #if defined CONFIG_USB_FUNCTIONFS_ETH 433 if (can_support_ecm(cdev->gadget)) 434 usb_put_function_instance(fi_ecm); 435 else 436 usb_put_function_instance(fi_geth); 437 #endif 438 return ret; 439 } 440 441 /* 442 * It is assumed that gfs_unbind is called from a context where ffs_lock is held 443 */ 444 static int gfs_unbind(struct usb_composite_dev *cdev) 445 { 446 int i; 447 448 ENTER(); 449 450 451 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 452 usb_put_function(f_rndis); 453 usb_put_function_instance(fi_rndis); 454 #endif 455 456 #if defined CONFIG_USB_FUNCTIONFS_ETH 457 if (can_support_ecm(cdev->gadget)) { 458 usb_put_function(f_ecm); 459 usb_put_function_instance(fi_ecm); 460 } else { 461 usb_put_function(f_geth); 462 usb_put_function_instance(fi_geth); 463 } 464 #endif 465 for (i = 0; i < N_CONF * func_num; ++i) 466 usb_put_function(*(f_ffs[0] + i)); 467 468 kfree(gfs_otg_desc[0]); 469 gfs_otg_desc[0] = NULL; 470 471 return 0; 472 } 473 474 /* 475 * It is assumed that gfs_do_config is called from a context where 476 * ffs_lock is held 477 */ 478 static int gfs_do_config(struct usb_configuration *c) 479 { 480 struct gfs_configuration *gc = 481 container_of(c, struct gfs_configuration, c); 482 int i; 483 int ret; 484 485 if (missing_funcs) 486 return -ENODEV; 487 488 if (gadget_is_otg(c->cdev->gadget)) { 489 c->descriptors = gfs_otg_desc; 490 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; 491 } 492 493 if (gc->eth) { 494 ret = gc->eth(c); 495 if (unlikely(ret < 0)) 496 return ret; 497 } 498 499 for (i = 0; i < func_num; i++) { 500 f_ffs[gc->num][i] = usb_get_function(fi_ffs[i]); 501 if (IS_ERR(f_ffs[gc->num][i])) { 502 ret = PTR_ERR(f_ffs[gc->num][i]); 503 goto error; 504 } 505 ret = usb_add_function(c, f_ffs[gc->num][i]); 506 if (ret < 0) { 507 usb_put_function(f_ffs[gc->num][i]); 508 goto error; 509 } 510 } 511 512 /* 513 * After previous do_configs there may be some invalid 514 * pointers in c->interface array. This happens every time 515 * a user space function with fewer interfaces than a user 516 * space function that was run before the new one is run. The 517 * compasit's set_config() assumes that if there is no more 518 * then MAX_CONFIG_INTERFACES interfaces in a configuration 519 * then there is a NULL pointer after the last interface in 520 * c->interface array. We need to make sure this is true. 521 */ 522 if (c->next_interface_id < ARRAY_SIZE(c->interface)) 523 c->interface[c->next_interface_id] = NULL; 524 525 return 0; 526 error: 527 while (--i >= 0) { 528 if (!IS_ERR(f_ffs[gc->num][i])) 529 usb_remove_function(c, f_ffs[gc->num][i]); 530 usb_put_function(f_ffs[gc->num][i]); 531 } 532 return ret; 533 } 534 535 #ifdef CONFIG_USB_FUNCTIONFS_ETH 536 537 static int eth_bind_config(struct usb_configuration *c) 538 { 539 int status = 0; 540 541 if (can_support_ecm(c->cdev->gadget)) { 542 f_ecm = usb_get_function(fi_ecm); 543 if (IS_ERR(f_ecm)) 544 return PTR_ERR(f_ecm); 545 546 status = usb_add_function(c, f_ecm); 547 if (status < 0) 548 usb_put_function(f_ecm); 549 550 } else { 551 f_geth = usb_get_function(fi_geth); 552 if (IS_ERR(f_geth)) 553 return PTR_ERR(f_geth); 554 555 status = usb_add_function(c, f_geth); 556 if (status < 0) 557 usb_put_function(f_geth); 558 } 559 return status; 560 } 561 562 #endif 563 564 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS 565 566 static int bind_rndis_config(struct usb_configuration *c) 567 { 568 int status = 0; 569 570 f_rndis = usb_get_function(fi_rndis); 571 if (IS_ERR(f_rndis)) 572 return PTR_ERR(f_rndis); 573 574 status = usb_add_function(c, f_rndis); 575 if (status < 0) 576 usb_put_function(f_rndis); 577 578 return status; 579 } 580 581 #endif 582