Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / arch / powerpc / platforms / ps3 / device-init.c
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);