1/* 2 * firmware_class.c - Multi purpose firmware loading support 3 * 4 * Copyright (c) 2003 Manuel Estrada Sainz 5 * 6 * Please see Documentation/firmware_class/ for more information. 7 * 8 */ 9 10#include <linux/capability.h> 11#include <linux/device.h> 12#include <linux/module.h> 13#include <linux/init.h> 14#include <linux/timer.h> 15#include <linux/vmalloc.h> 16#include <linux/interrupt.h> 17#include <linux/bitops.h> 18#include <linux/mutex.h> 19#include <linux/kthread.h> 20#include <linux/highmem.h> 21#include <linux/firmware.h> 22#include <linux/slab.h> 23 24#define to_dev(obj) container_of(obj, struct device, kobj) 25 26MODULE_AUTHOR("Manuel Estrada Sainz"); 27MODULE_DESCRIPTION("Multi purpose firmware loading support"); 28MODULE_LICENSE("GPL"); 29 30/* Builtin firmware support */ 31 32#ifdef CONFIG_FW_LOADER 33 34extern struct builtin_fw __start_builtin_fw[]; 35extern struct builtin_fw __end_builtin_fw[]; 36 37static bool fw_get_builtin_firmware(struct firmware *fw, const char *name) 38{ 39 struct builtin_fw *b_fw; 40 41 for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) { 42 if (strcmp(name, b_fw->name) == 0) { 43 fw->size = b_fw->size; 44 fw->data = b_fw->data; 45 return true; 46 } 47 } 48 49 return false; 50} 51 52static bool fw_is_builtin_firmware(const struct firmware *fw) 53{ 54 struct builtin_fw *b_fw; 55 56 for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) 57 if (fw->data == b_fw->data) 58 return true; 59 60 return false; 61} 62 63#else /* Module case - no builtin firmware support */ 64 65static inline bool fw_get_builtin_firmware(struct firmware *fw, const char *name) 66{ 67 return false; 68} 69 70static inline bool fw_is_builtin_firmware(const struct firmware *fw) 71{ 72 return false; 73} 74#endif 75 76enum { 77 FW_STATUS_LOADING, 78 FW_STATUS_DONE, 79 FW_STATUS_ABORT, 80}; 81 82static int loading_timeout = 60; /* In seconds */ 83 84/* fw_lock could be moved to 'struct firmware_priv' but since it is just 85 * guarding for corner cases a global lock should be OK */ 86static DEFINE_MUTEX(fw_lock); 87 88struct firmware_priv { 89 struct completion completion; 90 struct firmware *fw; 91 unsigned long status; 92 struct page **pages; 93 int nr_pages; 94 int page_array_size; 95 struct timer_list timeout; 96 struct device dev; 97 bool nowait; 98 char fw_id[]; 99}; 100 101static struct firmware_priv *to_firmware_priv(struct device *dev) 102{ 103 return container_of(dev, struct firmware_priv, dev); 104} 105 106static void fw_load_abort(struct firmware_priv *fw_priv) 107{ 108 set_bit(FW_STATUS_ABORT, &fw_priv->status); 109 wmb(); 110 complete(&fw_priv->completion); 111} 112 113static ssize_t firmware_timeout_show(struct class *class, 114 struct class_attribute *attr, 115 char *buf) 116{ 117 return sprintf(buf, "%d\n", loading_timeout); 118} 119 120/** 121 * firmware_timeout_store - set number of seconds to wait for firmware 122 * @class: device class pointer 123 * @attr: device attribute pointer 124 * @buf: buffer to scan for timeout value 125 * @count: number of bytes in @buf 126 * 127 * Sets the number of seconds to wait for the firmware. Once 128 * this expires an error will be returned to the driver and no 129 * firmware will be provided. 130 * 131 * Note: zero means 'wait forever'. 132 **/ 133static ssize_t firmware_timeout_store(struct class *class, 134 struct class_attribute *attr, 135 const char *buf, size_t count) 136{ 137 loading_timeout = simple_strtol(buf, NULL, 10); 138 if (loading_timeout < 0) 139 loading_timeout = 0; 140 141 return count; 142} 143 144static struct class_attribute firmware_class_attrs[] = { 145 __ATTR(timeout, S_IWUSR | S_IRUGO, 146 firmware_timeout_show, firmware_timeout_store), 147 __ATTR_NULL 148}; 149 150static void fw_dev_release(struct device *dev) 151{ 152 struct firmware_priv *fw_priv = to_firmware_priv(dev); 153 int i; 154 155 for (i = 0; i < fw_priv->nr_pages; i++) 156 __free_page(fw_priv->pages[i]); 157 kfree(fw_priv->pages); 158 kfree(fw_priv); 159 160 module_put(THIS_MODULE); 161} 162 163static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env) 164{ 165 struct firmware_priv *fw_priv = to_firmware_priv(dev); 166 167 if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id)) 168 return -ENOMEM; 169 if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout)) 170 return -ENOMEM; 171 if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait)) 172 return -ENOMEM; 173 174 return 0; 175} 176 177static struct class firmware_class = { 178 .name = "firmware", 179 .class_attrs = firmware_class_attrs, 180 .dev_uevent = firmware_uevent, 181 .dev_release = fw_dev_release, 182}; 183 184static ssize_t firmware_loading_show(struct device *dev, 185 struct device_attribute *attr, char *buf) 186{ 187 struct firmware_priv *fw_priv = to_firmware_priv(dev); 188 int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status); 189 190 return sprintf(buf, "%d\n", loading); 191} 192 193static void firmware_free_data(const struct firmware *fw) 194{ 195 int i; 196 vunmap(fw->data); 197 if (fw->pages) { 198 for (i = 0; i < PFN_UP(fw->size); i++) 199 __free_page(fw->pages[i]); 200 kfree(fw->pages); 201 } 202} 203 204/* Some architectures don't have PAGE_KERNEL_RO */ 205#ifndef PAGE_KERNEL_RO 206#define PAGE_KERNEL_RO PAGE_KERNEL 207#endif 208/** 209 * firmware_loading_store - set value in the 'loading' control file 210 * @dev: device pointer 211 * @attr: device attribute pointer 212 * @buf: buffer to scan for loading control value 213 * @count: number of bytes in @buf 214 * 215 * The relevant values are: 216 * 217 * 1: Start a load, discarding any previous partial load. 218 * 0: Conclude the load and hand the data to the driver code. 219 * -1: Conclude the load with an error and discard any written data. 220 **/ 221static ssize_t firmware_loading_store(struct device *dev, 222 struct device_attribute *attr, 223 const char *buf, size_t count) 224{ 225 struct firmware_priv *fw_priv = to_firmware_priv(dev); 226 int loading = simple_strtol(buf, NULL, 10); 227 int i; 228 229 switch (loading) { 230 case 1: 231 mutex_lock(&fw_lock); 232 if (!fw_priv->fw) { 233 mutex_unlock(&fw_lock); 234 break; 235 } 236 firmware_free_data(fw_priv->fw); 237 memset(fw_priv->fw, 0, sizeof(struct firmware)); 238 /* If the pages are not owned by 'struct firmware' */ 239 for (i = 0; i < fw_priv->nr_pages; i++) 240 __free_page(fw_priv->pages[i]); 241 kfree(fw_priv->pages); 242 fw_priv->pages = NULL; 243 fw_priv->page_array_size = 0; 244 fw_priv->nr_pages = 0; 245 set_bit(FW_STATUS_LOADING, &fw_priv->status); 246 mutex_unlock(&fw_lock); 247 break; 248 case 0: 249 if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) { 250 vunmap(fw_priv->fw->data); 251 fw_priv->fw->data = vmap(fw_priv->pages, 252 fw_priv->nr_pages, 253 0, PAGE_KERNEL_RO); 254 if (!fw_priv->fw->data) { 255 dev_err(dev, "%s: vmap() failed\n", __func__); 256 goto err; 257 } 258 /* Pages are now owned by 'struct firmware' */ 259 fw_priv->fw->pages = fw_priv->pages; 260 fw_priv->pages = NULL; 261 262 fw_priv->page_array_size = 0; 263 fw_priv->nr_pages = 0; 264 complete(&fw_priv->completion); 265 clear_bit(FW_STATUS_LOADING, &fw_priv->status); 266 break; 267 } 268 /* fallthrough */ 269 default: 270 dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading); 271 /* fallthrough */ 272 case -1: 273 err: 274 fw_load_abort(fw_priv); 275 break; 276 } 277 278 return count; 279} 280 281static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store); 282 283static ssize_t firmware_data_read(struct file *filp, struct kobject *kobj, 284 struct bin_attribute *bin_attr, 285 char *buffer, loff_t offset, size_t count) 286{ 287 struct device *dev = to_dev(kobj); 288 struct firmware_priv *fw_priv = to_firmware_priv(dev); 289 struct firmware *fw; 290 ssize_t ret_count; 291 292 mutex_lock(&fw_lock); 293 fw = fw_priv->fw; 294 if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) { 295 ret_count = -ENODEV; 296 goto out; 297 } 298 if (offset > fw->size) { 299 ret_count = 0; 300 goto out; 301 } 302 if (count > fw->size - offset) 303 count = fw->size - offset; 304 305 ret_count = count; 306 307 while (count) { 308 void *page_data; 309 int page_nr = offset >> PAGE_SHIFT; 310 int page_ofs = offset & (PAGE_SIZE-1); 311 int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count); 312 313 page_data = kmap(fw_priv->pages[page_nr]); 314 315 memcpy(buffer, page_data + page_ofs, page_cnt); 316 317 kunmap(fw_priv->pages[page_nr]); 318 buffer += page_cnt; 319 offset += page_cnt; 320 count -= page_cnt; 321 } 322out: 323 mutex_unlock(&fw_lock); 324 return ret_count; 325} 326 327static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size) 328{ 329 int pages_needed = ALIGN(min_size, PAGE_SIZE) >> PAGE_SHIFT; 330 331 /* If the array of pages is too small, grow it... */ 332 if (fw_priv->page_array_size < pages_needed) { 333 int new_array_size = max(pages_needed, 334 fw_priv->page_array_size * 2); 335 struct page **new_pages; 336 337 new_pages = kmalloc(new_array_size * sizeof(void *), 338 GFP_KERNEL); 339 if (!new_pages) { 340 fw_load_abort(fw_priv); 341 return -ENOMEM; 342 } 343 memcpy(new_pages, fw_priv->pages, 344 fw_priv->page_array_size * sizeof(void *)); 345 memset(&new_pages[fw_priv->page_array_size], 0, sizeof(void *) * 346 (new_array_size - fw_priv->page_array_size)); 347 kfree(fw_priv->pages); 348 fw_priv->pages = new_pages; 349 fw_priv->page_array_size = new_array_size; 350 } 351 352 while (fw_priv->nr_pages < pages_needed) { 353 fw_priv->pages[fw_priv->nr_pages] = 354 alloc_page(GFP_KERNEL | __GFP_HIGHMEM); 355 356 if (!fw_priv->pages[fw_priv->nr_pages]) { 357 fw_load_abort(fw_priv); 358 return -ENOMEM; 359 } 360 fw_priv->nr_pages++; 361 } 362 return 0; 363} 364 365/** 366 * firmware_data_write - write method for firmware 367 * @filp: open sysfs file 368 * @kobj: kobject for the device 369 * @bin_attr: bin_attr structure 370 * @buffer: buffer being written 371 * @offset: buffer offset for write in total data store area 372 * @count: buffer size 373 * 374 * Data written to the 'data' attribute will be later handed to 375 * the driver as a firmware image. 376 **/ 377static ssize_t firmware_data_write(struct file *filp, struct kobject *kobj, 378 struct bin_attribute *bin_attr, 379 char *buffer, loff_t offset, size_t count) 380{ 381 struct device *dev = to_dev(kobj); 382 struct firmware_priv *fw_priv = to_firmware_priv(dev); 383 struct firmware *fw; 384 ssize_t retval; 385 386 if (!capable(CAP_SYS_RAWIO)) 387 return -EPERM; 388 389 mutex_lock(&fw_lock); 390 fw = fw_priv->fw; 391 if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) { 392 retval = -ENODEV; 393 goto out; 394 } 395 retval = fw_realloc_buffer(fw_priv, offset + count); 396 if (retval) 397 goto out; 398 399 retval = count; 400 401 while (count) { 402 void *page_data; 403 int page_nr = offset >> PAGE_SHIFT; 404 int page_ofs = offset & (PAGE_SIZE - 1); 405 int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count); 406 407 page_data = kmap(fw_priv->pages[page_nr]); 408 409 memcpy(page_data + page_ofs, buffer, page_cnt); 410 411 kunmap(fw_priv->pages[page_nr]); 412 buffer += page_cnt; 413 offset += page_cnt; 414 count -= page_cnt; 415 } 416 417 fw->size = max_t(size_t, offset, fw->size); 418out: 419 mutex_unlock(&fw_lock); 420 return retval; 421} 422 423static struct bin_attribute firmware_attr_data = { 424 .attr = { .name = "data", .mode = 0644 }, 425 .size = 0, 426 .read = firmware_data_read, 427 .write = firmware_data_write, 428}; 429 430static void firmware_class_timeout(u_long data) 431{ 432 struct firmware_priv *fw_priv = (struct firmware_priv *) data; 433 434 fw_load_abort(fw_priv); 435} 436 437static struct firmware_priv * 438fw_create_instance(struct firmware *firmware, const char *fw_name, 439 struct device *device, bool uevent, bool nowait) 440{ 441 struct firmware_priv *fw_priv; 442 struct device *f_dev; 443 int error; 444 445 fw_priv = kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL); 446 if (!fw_priv) { 447 dev_err(device, "%s: kmalloc failed\n", __func__); 448 error = -ENOMEM; 449 goto err_out; 450 } 451 452 fw_priv->fw = firmware; 453 fw_priv->nowait = nowait; 454 strcpy(fw_priv->fw_id, fw_name); 455 init_completion(&fw_priv->completion); 456 setup_timer(&fw_priv->timeout, 457 firmware_class_timeout, (u_long) fw_priv); 458 459 f_dev = &fw_priv->dev; 460 461 device_initialize(f_dev); 462 dev_set_name(f_dev, "%s", dev_name(device)); 463 f_dev->parent = device; 464 f_dev->class = &firmware_class; 465 466 dev_set_uevent_suppress(f_dev, true); 467 468 /* Need to pin this module until class device is destroyed */ 469 __module_get(THIS_MODULE); 470 471 error = device_add(f_dev); 472 if (error) { 473 dev_err(device, "%s: device_register failed\n", __func__); 474 goto err_put_dev; 475 } 476 477 error = device_create_bin_file(f_dev, &firmware_attr_data); 478 if (error) { 479 dev_err(device, "%s: sysfs_create_bin_file failed\n", __func__); 480 goto err_del_dev; 481 } 482 483 error = device_create_file(f_dev, &dev_attr_loading); 484 if (error) { 485 dev_err(device, "%s: device_create_file failed\n", __func__); 486 goto err_del_bin_attr; 487 } 488 489 if (uevent) 490 dev_set_uevent_suppress(f_dev, false); 491 492 return fw_priv; 493 494err_del_bin_attr: 495 device_remove_bin_file(f_dev, &firmware_attr_data); 496err_del_dev: 497 device_del(f_dev); 498err_put_dev: 499 put_device(f_dev); 500err_out: 501 return ERR_PTR(error); 502} 503 504static void fw_destroy_instance(struct firmware_priv *fw_priv) 505{ 506 struct device *f_dev = &fw_priv->dev; 507 508 device_remove_file(f_dev, &dev_attr_loading); 509 device_remove_bin_file(f_dev, &firmware_attr_data); 510 device_unregister(f_dev); 511} 512 513static int _request_firmware(const struct firmware **firmware_p, 514 const char *name, struct device *device, 515 bool uevent, bool nowait) 516{ 517 struct firmware_priv *fw_priv; 518 struct firmware *firmware; 519 int retval = 0; 520 521 if (!firmware_p) 522 return -EINVAL; 523 524 *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL); 525 if (!firmware) { 526 dev_err(device, "%s: kmalloc(struct firmware) failed\n", 527 __func__); 528 retval = -ENOMEM; 529 goto out; 530 } 531 532 if (fw_get_builtin_firmware(firmware, name)) { 533 dev_dbg(device, "firmware: using built-in firmware %s\n", name); 534 return 0; 535 } 536 537 if (uevent) 538 dev_dbg(device, "firmware: requesting %s\n", name); 539 540 fw_priv = fw_create_instance(firmware, name, device, uevent, nowait); 541 if (IS_ERR(fw_priv)) { 542 retval = PTR_ERR(fw_priv); 543 goto out; 544 } 545 546 if (uevent) { 547 if (loading_timeout > 0) 548 mod_timer(&fw_priv->timeout, 549 round_jiffies_up(jiffies + 550 loading_timeout * HZ)); 551 552 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD); 553 } 554 555 wait_for_completion(&fw_priv->completion); 556 557 set_bit(FW_STATUS_DONE, &fw_priv->status); 558 del_timer_sync(&fw_priv->timeout); 559 560 mutex_lock(&fw_lock); 561 if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status)) 562 retval = -ENOENT; 563 fw_priv->fw = NULL; 564 mutex_unlock(&fw_lock); 565 566 fw_destroy_instance(fw_priv); 567 568out: 569 if (retval) { 570 release_firmware(firmware); 571 *firmware_p = NULL; 572 } 573 574 return retval; 575} 576 577/** 578 * request_firmware: - send firmware request and wait for it 579 * @firmware_p: pointer to firmware image 580 * @name: name of firmware file 581 * @device: device for which firmware is being loaded 582 * 583 * @firmware_p will be used to return a firmware image by the name 584 * of @name for device @device. 585 * 586 * Should be called from user context where sleeping is allowed. 587 * 588 * @name will be used as $FIRMWARE in the uevent environment and 589 * should be distinctive enough not to be confused with any other 590 * firmware image for this or any other device. 591 **/ 592int 593request_firmware(const struct firmware **firmware_p, const char *name, 594 struct device *device) 595{ 596 int uevent = 1; 597 return _request_firmware(firmware_p, name, device, uevent, false); 598} 599 600/** 601 * release_firmware: - release the resource associated with a firmware image 602 * @fw: firmware resource to release 603 **/ 604void release_firmware(const struct firmware *fw) 605{ 606 if (fw) { 607 if (!fw_is_builtin_firmware(fw)) 608 firmware_free_data(fw); 609 kfree(fw); 610 } 611} 612 613/* Async support */ 614struct firmware_work { 615 struct work_struct work; 616 struct module *module; 617 const char *name; 618 struct device *device; 619 void *context; 620 void (*cont)(const struct firmware *fw, void *context); 621 int uevent; 622}; 623 624static int request_firmware_work_func(void *arg) 625{ 626 struct firmware_work *fw_work = arg; 627 const struct firmware *fw; 628 int ret; 629 630 if (!arg) { 631 WARN_ON(1); 632 return 0; 633 } 634 635 ret = _request_firmware(&fw, fw_work->name, fw_work->device, 636 fw_work->uevent, true); 637 fw_work->cont(fw, fw_work->context); 638 639 module_put(fw_work->module); 640 kfree(fw_work); 641 642 return ret; 643} 644 645/** 646 * request_firmware_nowait - asynchronous version of request_firmware 647 * @module: module requesting the firmware 648 * @uevent: sends uevent to copy the firmware image if this flag 649 * is non-zero else the firmware copy must be done manually. 650 * @name: name of firmware file 651 * @device: device for which firmware is being loaded 652 * @gfp: allocation flags 653 * @context: will be passed over to @cont, and 654 * @fw may be %NULL if firmware request fails. 655 * @cont: function will be called asynchronously when the firmware 656 * request is over. 657 * 658 * Asynchronous variant of request_firmware() for user contexts where 659 * it is not possible to sleep for long time. It can't be called 660 * in atomic contexts. 661 **/ 662int 663request_firmware_nowait( 664 struct module *module, int uevent, 665 const char *name, struct device *device, gfp_t gfp, void *context, 666 void (*cont)(const struct firmware *fw, void *context)) 667{ 668 struct task_struct *task; 669 struct firmware_work *fw_work; 670 671 fw_work = kzalloc(sizeof (struct firmware_work), gfp); 672 if (!fw_work) 673 return -ENOMEM; 674 675 fw_work->module = module; 676 fw_work->name = name; 677 fw_work->device = device; 678 fw_work->context = context; 679 fw_work->cont = cont; 680 fw_work->uevent = uevent; 681 682 if (!try_module_get(module)) { 683 kfree(fw_work); 684 return -EFAULT; 685 } 686 687 task = kthread_run(request_firmware_work_func, fw_work, 688 "firmware/%s", name); 689 if (IS_ERR(task)) { 690 fw_work->cont(NULL, fw_work->context); 691 module_put(fw_work->module); 692 kfree(fw_work); 693 return PTR_ERR(task); 694 } 695 696 return 0; 697} 698 699static int __init firmware_class_init(void) 700{ 701 return class_register(&firmware_class); 702} 703 704static void __exit firmware_class_exit(void) 705{ 706 class_unregister(&firmware_class); 707} 708 709fs_initcall(firmware_class_init); 710module_exit(firmware_class_exit); 711 712EXPORT_SYMBOL(release_firmware); 713EXPORT_SYMBOL(request_firmware); 714EXPORT_SYMBOL(request_firmware_nowait); 715