1 /* 2 * PS3 device registration routines. 3 * 4 * Copyright (C) 2007 Sony Computer Entertainment Inc. 5 * Copyright 2007 Sony Corp. 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; version 2 of the License. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #include <linux/delay.h> 22 #include <linux/freezer.h> 23 #include <linux/kernel.h> 24 #include <linux/kthread.h> 25 #include <linux/init.h> 26 27 #include <asm/firmware.h> 28 #include <asm/lv1call.h> 29 #include <asm/ps3stor.h> 30 31 #include "platform.h" 32 33 /** 34 * ps3_setup_gelic_device - Setup and register a gelic device instance. 35 * 36 * Allocates memory for a struct ps3_system_bus_device instance, initialises the 37 * structure members, and registers the device instance with the system bus. 38 */ 39 40 static int __init ps3_setup_gelic_device( 41 const struct ps3_repository_device *repo) 42 { 43 int result; 44 struct layout { 45 struct ps3_system_bus_device dev; 46 struct ps3_dma_region d_region; 47 } *p; 48 49 pr_debug(" -> %s:%d\n", __func__, __LINE__); 50 51 BUG_ON(repo->bus_type != PS3_BUS_TYPE_SB); 52 BUG_ON(repo->dev_type != PS3_DEV_TYPE_SB_GELIC); 53 54 p = kzalloc(sizeof(struct layout), GFP_KERNEL); 55 56 if (!p) { 57 result = -ENOMEM; 58 goto fail_malloc; 59 } 60 61 p->dev.match_id = PS3_MATCH_ID_GELIC; 62 p->dev.dev_type = PS3_DEVICE_TYPE_SB; 63 p->dev.bus_id = repo->bus_id; 64 p->dev.dev_id = repo->dev_id; 65 p->dev.d_region = &p->d_region; 66 67 result = ps3_repository_find_interrupt(repo, 68 PS3_INTERRUPT_TYPE_EVENT_PORT, &p->dev.interrupt_id); 69 70 if (result) { 71 pr_debug("%s:%d ps3_repository_find_interrupt failed\n", 72 __func__, __LINE__); 73 goto fail_find_interrupt; 74 } 75 76 BUG_ON(p->dev.interrupt_id != 0); 77 78 result = ps3_dma_region_init(&p->dev, p->dev.d_region, PS3_DMA_64K, 79 PS3_DMA_OTHER, NULL, 0); 80 81 if (result) { 82 pr_debug("%s:%d ps3_dma_region_init failed\n", 83 __func__, __LINE__); 84 goto fail_dma_init; 85 } 86 87 result = ps3_system_bus_device_register(&p->dev); 88 89 if (result) { 90 pr_debug("%s:%d ps3_system_bus_device_register failed\n", 91 __func__, __LINE__); 92 goto fail_device_register; 93 } 94 95 pr_debug(" <- %s:%d\n", __func__, __LINE__); 96 return result; 97 98 fail_device_register: 99 fail_dma_init: 100 fail_find_interrupt: 101 kfree(p); 102 fail_malloc: 103 pr_debug(" <- %s:%d: fail.\n", __func__, __LINE__); 104 return result; 105 } 106 107 static int __init_refok ps3_setup_uhc_device( 108 const struct ps3_repository_device *repo, enum ps3_match_id match_id, 109 enum ps3_interrupt_type interrupt_type, enum ps3_reg_type reg_type) 110 { 111 int result; 112 struct layout { 113 struct ps3_system_bus_device dev; 114 struct ps3_dma_region d_region; 115 struct ps3_mmio_region m_region; 116 } *p; 117 u64 bus_addr; 118 u64 len; 119 120 pr_debug(" -> %s:%d\n", __func__, __LINE__); 121 122 BUG_ON(repo->bus_type != PS3_BUS_TYPE_SB); 123 BUG_ON(repo->dev_type != PS3_DEV_TYPE_SB_USB); 124 125 p = kzalloc(sizeof(struct layout), GFP_KERNEL); 126 127 if (!p) { 128 result = -ENOMEM; 129 goto fail_malloc; 130 } 131 132 p->dev.match_id = match_id; 133 p->dev.dev_type = PS3_DEVICE_TYPE_SB; 134 p->dev.bus_id = repo->bus_id; 135 p->dev.dev_id = repo->dev_id; 136 p->dev.d_region = &p->d_region; 137 p->dev.m_region = &p->m_region; 138 139 result = ps3_repository_find_interrupt(repo, 140 interrupt_type, &p->dev.interrupt_id); 141 142 if (result) { 143 pr_debug("%s:%d ps3_repository_find_interrupt failed\n", 144 __func__, __LINE__); 145 goto fail_find_interrupt; 146 } 147 148 result = ps3_repository_find_reg(repo, reg_type, 149 &bus_addr, &len); 150 151 if (result) { 152 pr_debug("%s:%d ps3_repository_find_reg failed\n", 153 __func__, __LINE__); 154 goto fail_find_reg; 155 } 156 157 result = ps3_dma_region_init(&p->dev, p->dev.d_region, PS3_DMA_64K, 158 PS3_DMA_INTERNAL, NULL, 0); 159 160 if (result) { 161 pr_debug("%s:%d ps3_dma_region_init failed\n", 162 __func__, __LINE__); 163 goto fail_dma_init; 164 } 165 166 result = ps3_mmio_region_init(&p->dev, p->dev.m_region, bus_addr, len, 167 PS3_MMIO_4K); 168 169 if (result) { 170 pr_debug("%s:%d ps3_mmio_region_init failed\n", 171 __func__, __LINE__); 172 goto fail_mmio_init; 173 } 174 175 result = ps3_system_bus_device_register(&p->dev); 176 177 if (result) { 178 pr_debug("%s:%d ps3_system_bus_device_register failed\n", 179 __func__, __LINE__); 180 goto fail_device_register; 181 } 182 183 pr_debug(" <- %s:%d\n", __func__, __LINE__); 184 return result; 185 186 fail_device_register: 187 fail_mmio_init: 188 fail_dma_init: 189 fail_find_reg: 190 fail_find_interrupt: 191 kfree(p); 192 fail_malloc: 193 pr_debug(" <- %s:%d: fail.\n", __func__, __LINE__); 194 return result; 195 } 196 197 static int __init ps3_setup_ehci_device( 198 const struct ps3_repository_device *repo) 199 { 200 return ps3_setup_uhc_device(repo, PS3_MATCH_ID_EHCI, 201 PS3_INTERRUPT_TYPE_SB_EHCI, PS3_REG_TYPE_SB_EHCI); 202 } 203 204 static int __init ps3_setup_ohci_device( 205 const struct ps3_repository_device *repo) 206 { 207 return ps3_setup_uhc_device(repo, PS3_MATCH_ID_OHCI, 208 PS3_INTERRUPT_TYPE_SB_OHCI, PS3_REG_TYPE_SB_OHCI); 209 } 210 211 static int __init ps3_setup_vuart_device(enum ps3_match_id match_id, 212 unsigned int port_number) 213 { 214 int result; 215 struct layout { 216 struct ps3_system_bus_device dev; 217 } *p; 218 219 pr_debug(" -> %s:%d: match_id %u, port %u\n", __func__, __LINE__, 220 match_id, port_number); 221 222 p = kzalloc(sizeof(struct layout), GFP_KERNEL); 223 224 if (!p) 225 return -ENOMEM; 226 227 p->dev.match_id = match_id; 228 p->dev.dev_type = PS3_DEVICE_TYPE_VUART; 229 p->dev.port_number = port_number; 230 231 result = ps3_system_bus_device_register(&p->dev); 232 233 if (result) 234 pr_debug("%s:%d ps3_system_bus_device_register failed\n", 235 __func__, __LINE__); 236 237 pr_debug(" <- %s:%d\n", __func__, __LINE__); 238 return result; 239 } 240 241 static int ps3stor_wait_for_completion(u64 dev_id, u64 tag, 242 unsigned int timeout) 243 { 244 int result = -1; 245 unsigned int retries = 0; 246 u64 status; 247 248 for (retries = 0; retries < timeout; retries++) { 249 result = lv1_storage_check_async_status(dev_id, tag, &status); 250 if (!result) 251 break; 252 253 msleep(1); 254 } 255 256 if (result) 257 pr_debug("%s:%u: check_async_status: %s, status %lx\n", 258 __func__, __LINE__, ps3_result(result), status); 259 260 return result; 261 } 262 263 /** 264 * ps3_storage_wait_for_device - Wait for a storage device to become ready. 265 * @repo: The repository device to wait for. 266 * 267 * Uses the hypervisor's storage device notification mechanism to wait until 268 * a storage device is ready. The device notification mechanism uses a 269 * psuedo device (id = -1) to asynchronously notify the guest when storage 270 * devices become ready. The notification device has a block size of 512 271 * bytes. 272 */ 273 274 static int ps3_storage_wait_for_device(const struct ps3_repository_device *repo) 275 { 276 int error = -ENODEV; 277 int result; 278 const u64 notification_dev_id = (u64)-1LL; 279 const unsigned int timeout = HZ; 280 u64 lpar; 281 u64 tag; 282 void *buf; 283 enum ps3_notify_type { 284 notify_device_ready = 0, 285 notify_region_probe = 1, 286 notify_region_update = 2, 287 }; 288 struct { 289 u64 operation_code; /* must be zero */ 290 u64 event_mask; /* OR of 1UL << enum ps3_notify_type */ 291 } *notify_cmd; 292 struct { 293 u64 event_type; /* enum ps3_notify_type */ 294 u64 bus_id; 295 u64 dev_id; 296 u64 dev_type; 297 u64 dev_port; 298 } *notify_event; 299 300 pr_debug(" -> %s:%u: (%u:%u:%u)\n", __func__, __LINE__, repo->bus_id, 301 repo->dev_id, repo->dev_type); 302 303 buf = kzalloc(512, GFP_KERNEL); 304 if (!buf) 305 return -ENOMEM; 306 307 lpar = ps3_mm_phys_to_lpar(__pa(buf)); 308 notify_cmd = buf; 309 notify_event = buf; 310 311 result = lv1_open_device(repo->bus_id, notification_dev_id, 0); 312 if (result) { 313 printk(KERN_ERR "%s:%u: lv1_open_device %s\n", __func__, 314 __LINE__, ps3_result(result)); 315 goto fail_free; 316 } 317 318 /* Setup and write the request for device notification. */ 319 320 notify_cmd->operation_code = 0; /* must be zero */ 321 notify_cmd->event_mask = 1UL << notify_region_probe; 322 323 result = lv1_storage_write(notification_dev_id, 0, 0, 1, 0, lpar, 324 &tag); 325 if (result) { 326 printk(KERN_ERR "%s:%u: write failed %s\n", __func__, __LINE__, 327 ps3_result(result)); 328 goto fail_close; 329 } 330 331 /* Wait for the write completion */ 332 333 result = ps3stor_wait_for_completion(notification_dev_id, tag, 334 timeout); 335 if (result) { 336 printk(KERN_ERR "%s:%u: write not completed %s\n", __func__, 337 __LINE__, ps3_result(result)); 338 goto fail_close; 339 } 340 341 /* Loop here processing the requested notification events. */ 342 343 while (1) { 344 memset(notify_event, 0, sizeof(*notify_event)); 345 346 result = lv1_storage_read(notification_dev_id, 0, 0, 1, 0, 347 lpar, &tag); 348 if (result) { 349 printk(KERN_ERR "%s:%u: write failed %s\n", __func__, 350 __LINE__, ps3_result(result)); 351 break; 352 } 353 354 result = ps3stor_wait_for_completion(notification_dev_id, tag, 355 timeout); 356 if (result) { 357 printk(KERN_ERR "%s:%u: read not completed %s\n", 358 __func__, __LINE__, ps3_result(result)); 359 break; 360 } 361 362 pr_debug("%s:%d: notify event (%u:%u:%u): event_type 0x%lx, " 363 "port %lu\n", __func__, __LINE__, repo->bus_index, 364 repo->dev_index, repo->dev_type, 365 notify_event->event_type, notify_event->dev_port); 366 367 if (notify_event->event_type != notify_region_probe || 368 notify_event->bus_id != repo->bus_id) { 369 pr_debug("%s:%u: bad notify_event: event %lu, " 370 "dev_id %lu, dev_type %lu\n", 371 __func__, __LINE__, notify_event->event_type, 372 notify_event->dev_id, notify_event->dev_type); 373 break; 374 } 375 376 if (notify_event->dev_id == repo->dev_id && 377 notify_event->dev_type == repo->dev_type) { 378 pr_debug("%s:%u: device ready (%u:%u:%u)\n", __func__, 379 __LINE__, repo->bus_index, repo->dev_index, 380 repo->dev_type); 381 error = 0; 382 break; 383 } 384 385 if (notify_event->dev_id == repo->dev_id && 386 notify_event->dev_type == PS3_DEV_TYPE_NOACCESS) { 387 pr_debug("%s:%u: no access: dev_id %u\n", __func__, 388 __LINE__, repo->dev_id); 389 break; 390 } 391 } 392 393 fail_close: 394 lv1_close_device(repo->bus_id, notification_dev_id); 395 fail_free: 396 kfree(buf); 397 pr_debug(" <- %s:%u\n", __func__, __LINE__); 398 return error; 399 } 400 401 static int ps3_setup_storage_dev(const struct ps3_repository_device *repo, 402 enum ps3_match_id match_id) 403 { 404 int result; 405 struct ps3_storage_device *p; 406 u64 port, blk_size, num_blocks; 407 unsigned int num_regions, i; 408 409 pr_debug(" -> %s:%u: match_id %u\n", __func__, __LINE__, match_id); 410 411 result = ps3_repository_read_stor_dev_info(repo->bus_index, 412 repo->dev_index, &port, 413 &blk_size, &num_blocks, 414 &num_regions); 415 if (result) { 416 printk(KERN_ERR "%s:%u: _read_stor_dev_info failed %d\n", 417 __func__, __LINE__, result); 418 return -ENODEV; 419 } 420 421 pr_debug("%s:%u: (%u:%u:%u): port %lu blk_size %lu num_blocks %lu " 422 "num_regions %u\n", __func__, __LINE__, repo->bus_index, 423 repo->dev_index, repo->dev_type, port, blk_size, num_blocks, 424 num_regions); 425 426 p = kzalloc(sizeof(struct ps3_storage_device) + 427 num_regions * sizeof(struct ps3_storage_region), 428 GFP_KERNEL); 429 if (!p) { 430 result = -ENOMEM; 431 goto fail_malloc; 432 } 433 434 p->sbd.match_id = match_id; 435 p->sbd.dev_type = PS3_DEVICE_TYPE_SB; 436 p->sbd.bus_id = repo->bus_id; 437 p->sbd.dev_id = repo->dev_id; 438 p->sbd.d_region = &p->dma_region; 439 p->blk_size = blk_size; 440 p->num_regions = num_regions; 441 442 result = ps3_repository_find_interrupt(repo, 443 PS3_INTERRUPT_TYPE_EVENT_PORT, 444 &p->sbd.interrupt_id); 445 if (result) { 446 printk(KERN_ERR "%s:%u: find_interrupt failed %d\n", __func__, 447 __LINE__, result); 448 result = -ENODEV; 449 goto fail_find_interrupt; 450 } 451 452 /* FIXME: Arrange to only do this on a 'cold' boot */ 453 454 result = ps3_storage_wait_for_device(repo); 455 if (result) { 456 printk(KERN_ERR "%s:%u: storage_notification failed %d\n", 457 __func__, __LINE__, result); 458 result = -ENODEV; 459 goto fail_probe_notification; 460 } 461 462 for (i = 0; i < num_regions; i++) { 463 unsigned int id; 464 u64 start, size; 465 466 result = ps3_repository_read_stor_dev_region(repo->bus_index, 467 repo->dev_index, 468 i, &id, &start, 469 &size); 470 if (result) { 471 printk(KERN_ERR 472 "%s:%u: read_stor_dev_region failed %d\n", 473 __func__, __LINE__, result); 474 result = -ENODEV; 475 goto fail_read_region; 476 } 477 pr_debug("%s:%u: region %u: id %u start %lu size %lu\n", 478 __func__, __LINE__, i, id, start, size); 479 480 p->regions[i].id = id; 481 p->regions[i].start = start; 482 p->regions[i].size = size; 483 } 484 485 result = ps3_system_bus_device_register(&p->sbd); 486 if (result) { 487 pr_debug("%s:%u ps3_system_bus_device_register failed\n", 488 __func__, __LINE__); 489 goto fail_device_register; 490 } 491 492 pr_debug(" <- %s:%u\n", __func__, __LINE__); 493 return 0; 494 495 fail_device_register: 496 fail_read_region: 497 fail_probe_notification: 498 fail_find_interrupt: 499 kfree(p); 500 fail_malloc: 501 pr_debug(" <- %s:%u: fail.\n", __func__, __LINE__); 502 return result; 503 } 504 505 static int __init ps3_register_vuart_devices(void) 506 { 507 int result; 508 unsigned int port_number; 509 510 pr_debug(" -> %s:%d\n", __func__, __LINE__); 511 512 result = ps3_repository_read_vuart_av_port(&port_number); 513 if (result) 514 port_number = 0; /* av default */ 515 516 result = ps3_setup_vuart_device(PS3_MATCH_ID_AV_SETTINGS, port_number); 517 WARN_ON(result); 518 519 result = ps3_repository_read_vuart_sysmgr_port(&port_number); 520 if (result) 521 port_number = 2; /* sysmgr default */ 522 523 result = ps3_setup_vuart_device(PS3_MATCH_ID_SYSTEM_MANAGER, 524 port_number); 525 WARN_ON(result); 526 527 pr_debug(" <- %s:%d\n", __func__, __LINE__); 528 return result; 529 } 530 531 static int __init ps3_register_sound_devices(void) 532 { 533 int result; 534 struct layout { 535 struct ps3_system_bus_device dev; 536 struct ps3_dma_region d_region; 537 struct ps3_mmio_region m_region; 538 } *p; 539 540 pr_debug(" -> %s:%d\n", __func__, __LINE__); 541 542 p = kzalloc(sizeof(*p), GFP_KERNEL); 543 if (!p) 544 return -ENOMEM; 545 546 p->dev.match_id = PS3_MATCH_ID_SOUND; 547 p->dev.dev_type = PS3_DEVICE_TYPE_IOC0; 548 p->dev.d_region = &p->d_region; 549 p->dev.m_region = &p->m_region; 550 551 result = ps3_system_bus_device_register(&p->dev); 552 553 if (result) 554 pr_debug("%s:%d ps3_system_bus_device_register failed\n", 555 __func__, __LINE__); 556 557 pr_debug(" <- %s:%d\n", __func__, __LINE__); 558 return result; 559 } 560 561 static int __init ps3_register_graphics_devices(void) 562 { 563 int result; 564 struct layout { 565 struct ps3_system_bus_device dev; 566 } *p; 567 568 pr_debug(" -> %s:%d\n", __func__, __LINE__); 569 570 p = kzalloc(sizeof(struct layout), GFP_KERNEL); 571 572 if (!p) 573 return -ENOMEM; 574 575 p->dev.match_id = PS3_MATCH_ID_GRAPHICS; 576 p->dev.dev_type = PS3_DEVICE_TYPE_IOC0; 577 578 result = ps3_system_bus_device_register(&p->dev); 579 580 if (result) 581 pr_debug("%s:%d ps3_system_bus_device_register failed\n", 582 __func__, __LINE__); 583 584 pr_debug(" <- %s:%d\n", __func__, __LINE__); 585 return result; 586 } 587 588 /** 589 * ps3_register_repository_device - Register a device from the repositiory info. 590 * 591 */ 592 593 static int ps3_register_repository_device( 594 const struct ps3_repository_device *repo) 595 { 596 int result; 597 598 switch (repo->dev_type) { 599 case PS3_DEV_TYPE_SB_GELIC: 600 result = ps3_setup_gelic_device(repo); 601 if (result) { 602 pr_debug("%s:%d ps3_setup_gelic_device failed\n", 603 __func__, __LINE__); 604 } 605 break; 606 case PS3_DEV_TYPE_SB_USB: 607 608 /* Each USB device has both an EHCI and an OHCI HC */ 609 610 result = ps3_setup_ehci_device(repo); 611 612 if (result) { 613 pr_debug("%s:%d ps3_setup_ehci_device failed\n", 614 __func__, __LINE__); 615 } 616 617 result = ps3_setup_ohci_device(repo); 618 619 if (result) { 620 pr_debug("%s:%d ps3_setup_ohci_device failed\n", 621 __func__, __LINE__); 622 } 623 break; 624 case PS3_DEV_TYPE_STOR_DISK: 625 result = ps3_setup_storage_dev(repo, PS3_MATCH_ID_STOR_DISK); 626 627 /* Some devices are not accessable from the Other OS lpar. */ 628 if (result == -ENODEV) { 629 result = 0; 630 pr_debug("%s:%u: not accessable\n", __func__, 631 __LINE__); 632 } 633 634 if (result) 635 pr_debug("%s:%u ps3_setup_storage_dev failed\n", 636 __func__, __LINE__); 637 break; 638 639 case PS3_DEV_TYPE_STOR_ROM: 640 result = ps3_setup_storage_dev(repo, PS3_MATCH_ID_STOR_ROM); 641 if (result) 642 pr_debug("%s:%u ps3_setup_storage_dev failed\n", 643 __func__, __LINE__); 644 break; 645 646 case PS3_DEV_TYPE_STOR_FLASH: 647 result = ps3_setup_storage_dev(repo, PS3_MATCH_ID_STOR_FLASH); 648 if (result) 649 pr_debug("%s:%u ps3_setup_storage_dev failed\n", 650 __func__, __LINE__); 651 break; 652 653 default: 654 result = 0; 655 pr_debug("%s:%u: unsupported dev_type %u\n", __func__, __LINE__, 656 repo->dev_type); 657 } 658 659 return result; 660 } 661 662 /** 663 * ps3_probe_thread - Background repository probing at system startup. 664 * 665 * This implementation only supports background probing on a single bus. 666 */ 667 668 static int ps3_probe_thread(void *data) 669 { 670 struct ps3_repository_device *repo = data; 671 int result; 672 unsigned int ms = 250; 673 674 pr_debug(" -> %s:%u: kthread started\n", __func__, __LINE__); 675 676 do { 677 try_to_freeze(); 678 679 pr_debug("%s:%u: probing...\n", __func__, __LINE__); 680 681 do { 682 result = ps3_repository_find_device(repo); 683 684 if (result == -ENODEV) 685 pr_debug("%s:%u: nothing new\n", __func__, 686 __LINE__); 687 else if (result) 688 pr_debug("%s:%u: find device error.\n", 689 __func__, __LINE__); 690 else { 691 pr_debug("%s:%u: found device (%u:%u:%u)\n", 692 __func__, __LINE__, repo->bus_index, 693 repo->dev_index, repo->dev_type); 694 ps3_register_repository_device(repo); 695 ps3_repository_bump_device(repo); 696 ms = 250; 697 } 698 } while (!result); 699 700 pr_debug("%s:%u: ms %u\n", __func__, __LINE__, ms); 701 702 if ( ms > 60000) 703 break; 704 705 msleep_interruptible(ms); 706 707 /* An exponential backoff. */ 708 ms <<= 1; 709 710 } while (!kthread_should_stop()); 711 712 pr_debug(" <- %s:%u: kthread finished\n", __func__, __LINE__); 713 714 return 0; 715 } 716 717 /** 718 * ps3_start_probe_thread - Starts the background probe thread. 719 * 720 */ 721 722 static int __init ps3_start_probe_thread(enum ps3_bus_type bus_type) 723 { 724 int result; 725 struct task_struct *task; 726 static struct ps3_repository_device repo; /* must be static */ 727 728 pr_debug(" -> %s:%d\n", __func__, __LINE__); 729 730 memset(&repo, 0, sizeof(repo)); 731 732 repo.bus_type = bus_type; 733 734 result = ps3_repository_find_bus(repo.bus_type, 0, &repo.bus_index); 735 736 if (result) { 737 printk(KERN_ERR "%s: Cannot find bus (%d)\n", __func__, result); 738 return -ENODEV; 739 } 740 741 result = ps3_repository_read_bus_id(repo.bus_index, &repo.bus_id); 742 743 if (result) { 744 printk(KERN_ERR "%s: read_bus_id failed %d\n", __func__, 745 result); 746 return -ENODEV; 747 } 748 749 task = kthread_run(ps3_probe_thread, &repo, "ps3-probe-%u", bus_type); 750 751 if (IS_ERR(task)) { 752 result = PTR_ERR(task); 753 printk(KERN_ERR "%s: kthread_run failed %d\n", __func__, 754 result); 755 return result; 756 } 757 758 pr_debug(" <- %s:%d\n", __func__, __LINE__); 759 return 0; 760 } 761 762 /** 763 * ps3_register_devices - Probe the system and register devices found. 764 * 765 * A device_initcall() routine. 766 */ 767 768 static int __init ps3_register_devices(void) 769 { 770 int result; 771 772 if (!firmware_has_feature(FW_FEATURE_PS3_LV1)) 773 return -ENODEV; 774 775 pr_debug(" -> %s:%d\n", __func__, __LINE__); 776 777 /* ps3_repository_dump_bus_info(); */ 778 779 result = ps3_start_probe_thread(PS3_BUS_TYPE_STORAGE); 780 781 ps3_register_vuart_devices(); 782 783 ps3_register_graphics_devices(); 784 785 ps3_repository_find_devices(PS3_BUS_TYPE_SB, 786 ps3_register_repository_device); 787 788 ps3_register_sound_devices(); 789 790 pr_debug(" <- %s:%d\n", __func__, __LINE__); 791 return 0; 792 } 793 794 device_initcall(ps3_register_devices); 795