2 * PS3 system bus driver.
4 * Copyright (C) 2006 Sony Computer Entertainment Inc.
5 * Copyright 2006 Sony Corp.
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.
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.
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
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/err.h>
28 #include <asm/lv1call.h>
29 #include <asm/firmware.h>
33 static struct device ps3_system_bus
= {
34 .bus_id
= "ps3_system",
37 /* FIXME: need device usage counters! */
40 int sb_11
; /* usb 0 */
41 int sb_12
; /* usb 0 */
45 static int ps3_is_device(struct ps3_system_bus_device
*dev
, u64 bus_id
,
48 return dev
->bus_id
== bus_id
&& dev
->dev_id
== dev_id
;
51 static int ps3_open_hv_device_sb(struct ps3_system_bus_device
*dev
)
56 mutex_lock(&usage_hack
.mutex
);
58 if (ps3_is_device(dev
, 1, 1)) {
60 if (usage_hack
.sb_11
> 1) {
66 if (ps3_is_device(dev
, 1, 2)) {
68 if (usage_hack
.sb_12
> 1) {
74 result
= lv1_open_device(dev
->bus_id
, dev
->dev_id
, 0);
77 pr_debug("%s:%d: lv1_open_device failed: %s\n", __func__
,
78 __LINE__
, ps3_result(result
));
83 mutex_unlock(&usage_hack
.mutex
);
87 static int ps3_close_hv_device_sb(struct ps3_system_bus_device
*dev
)
92 mutex_lock(&usage_hack
.mutex
);
94 if (ps3_is_device(dev
, 1, 1)) {
96 if (usage_hack
.sb_11
) {
102 if (ps3_is_device(dev
, 1, 2)) {
104 if (usage_hack
.sb_12
) {
110 result
= lv1_close_device(dev
->bus_id
, dev
->dev_id
);
114 mutex_unlock(&usage_hack
.mutex
);
118 static int ps3_open_hv_device_gpu(struct ps3_system_bus_device
*dev
)
122 mutex_lock(&usage_hack
.mutex
);
125 if (usage_hack
.gpu
> 1) {
130 result
= lv1_gpu_open(0);
133 pr_debug("%s:%d: lv1_gpu_open failed: %s\n", __func__
,
134 __LINE__
, ps3_result(result
));
139 mutex_unlock(&usage_hack
.mutex
);
143 static int ps3_close_hv_device_gpu(struct ps3_system_bus_device
*dev
)
147 mutex_lock(&usage_hack
.mutex
);
150 if (usage_hack
.gpu
) {
155 result
= lv1_gpu_close();
159 mutex_unlock(&usage_hack
.mutex
);
163 int ps3_open_hv_device(struct ps3_system_bus_device
*dev
)
166 pr_debug("%s:%d: match_id: %u\n", __func__
, __LINE__
, dev
->match_id
);
168 switch (dev
->match_id
) {
169 case PS3_MATCH_ID_EHCI
:
170 case PS3_MATCH_ID_OHCI
:
171 case PS3_MATCH_ID_GELIC
:
172 case PS3_MATCH_ID_STOR_DISK
:
173 case PS3_MATCH_ID_STOR_ROM
:
174 case PS3_MATCH_ID_STOR_FLASH
:
175 return ps3_open_hv_device_sb(dev
);
177 case PS3_MATCH_ID_SOUND
:
178 case PS3_MATCH_ID_GRAPHICS
:
179 return ps3_open_hv_device_gpu(dev
);
181 case PS3_MATCH_ID_AV_SETTINGS
:
182 case PS3_MATCH_ID_SYSTEM_MANAGER
:
183 pr_debug("%s:%d: unsupported match_id: %u\n", __func__
,
184 __LINE__
, dev
->match_id
);
185 pr_debug("%s:%d: bus_id: %lu\n", __func__
, __LINE__
,
194 pr_debug("%s:%d: unknown match_id: %u\n", __func__
, __LINE__
,
199 EXPORT_SYMBOL_GPL(ps3_open_hv_device
);
201 int ps3_close_hv_device(struct ps3_system_bus_device
*dev
)
204 pr_debug("%s:%d: match_id: %u\n", __func__
, __LINE__
, dev
->match_id
);
206 switch (dev
->match_id
) {
207 case PS3_MATCH_ID_EHCI
:
208 case PS3_MATCH_ID_OHCI
:
209 case PS3_MATCH_ID_GELIC
:
210 case PS3_MATCH_ID_STOR_DISK
:
211 case PS3_MATCH_ID_STOR_ROM
:
212 case PS3_MATCH_ID_STOR_FLASH
:
213 return ps3_close_hv_device_sb(dev
);
215 case PS3_MATCH_ID_SOUND
:
216 case PS3_MATCH_ID_GRAPHICS
:
217 return ps3_close_hv_device_gpu(dev
);
219 case PS3_MATCH_ID_AV_SETTINGS
:
220 case PS3_MATCH_ID_SYSTEM_MANAGER
:
221 pr_debug("%s:%d: unsupported match_id: %u\n", __func__
,
222 __LINE__
, dev
->match_id
);
223 pr_debug("%s:%d: bus_id: %lu\n", __func__
, __LINE__
,
232 pr_debug("%s:%d: unknown match_id: %u\n", __func__
, __LINE__
,
237 EXPORT_SYMBOL_GPL(ps3_close_hv_device
);
239 #define dump_mmio_region(_a) _dump_mmio_region(_a, __func__, __LINE__)
240 static void _dump_mmio_region(const struct ps3_mmio_region
* r
,
241 const char* func
, int line
)
243 pr_debug("%s:%d: dev %lu:%lu\n", func
, line
, r
->dev
->bus_id
,
245 pr_debug("%s:%d: bus_addr %lxh\n", func
, line
, r
->bus_addr
);
246 pr_debug("%s:%d: len %lxh\n", func
, line
, r
->len
);
247 pr_debug("%s:%d: lpar_addr %lxh\n", func
, line
, r
->lpar_addr
);
250 static int ps3_sb_mmio_region_create(struct ps3_mmio_region
*r
)
254 result
= lv1_map_device_mmio_region(r
->dev
->bus_id
, r
->dev
->dev_id
,
255 r
->bus_addr
, r
->len
, r
->page_size
, &r
->lpar_addr
);
258 pr_debug("%s:%d: lv1_map_device_mmio_region failed: %s\n",
259 __func__
, __LINE__
, ps3_result(result
));
267 static int ps3_ioc0_mmio_region_create(struct ps3_mmio_region
*r
)
269 /* device specific; do nothing currently */
273 int ps3_mmio_region_create(struct ps3_mmio_region
*r
)
275 return r
->mmio_ops
->create(r
);
277 EXPORT_SYMBOL_GPL(ps3_mmio_region_create
);
279 static int ps3_sb_free_mmio_region(struct ps3_mmio_region
*r
)
285 result
= lv1_unmap_device_mmio_region(r
->dev
->bus_id
, r
->dev
->dev_id
,
289 pr_debug("%s:%d: lv1_unmap_device_mmio_region failed: %s\n",
290 __func__
, __LINE__
, ps3_result(result
));
296 static int ps3_ioc0_free_mmio_region(struct ps3_mmio_region
*r
)
298 /* device specific; do nothing currently */
303 int ps3_free_mmio_region(struct ps3_mmio_region
*r
)
305 return r
->mmio_ops
->free(r
);
308 EXPORT_SYMBOL_GPL(ps3_free_mmio_region
);
310 static const struct ps3_mmio_region_ops ps3_mmio_sb_region_ops
= {
311 .create
= ps3_sb_mmio_region_create
,
312 .free
= ps3_sb_free_mmio_region
315 static const struct ps3_mmio_region_ops ps3_mmio_ioc0_region_ops
= {
316 .create
= ps3_ioc0_mmio_region_create
,
317 .free
= ps3_ioc0_free_mmio_region
320 int ps3_mmio_region_init(struct ps3_system_bus_device
*dev
,
321 struct ps3_mmio_region
*r
, unsigned long bus_addr
, unsigned long len
,
322 enum ps3_mmio_page_size page_size
)
325 r
->bus_addr
= bus_addr
;
327 r
->page_size
= page_size
;
328 switch (dev
->dev_type
) {
329 case PS3_DEVICE_TYPE_SB
:
330 r
->mmio_ops
= &ps3_mmio_sb_region_ops
;
332 case PS3_DEVICE_TYPE_IOC0
:
333 r
->mmio_ops
= &ps3_mmio_ioc0_region_ops
;
341 EXPORT_SYMBOL_GPL(ps3_mmio_region_init
);
343 static int ps3_system_bus_match(struct device
*_dev
,
344 struct device_driver
*_drv
)
347 struct ps3_system_bus_driver
*drv
= ps3_drv_to_system_bus_drv(_drv
);
348 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
350 result
= dev
->match_id
== drv
->match_id
;
353 pr_info("%s:%d: dev=%u(%s), drv=%u(%s): match\n", __func__
,
354 __LINE__
, dev
->match_id
, dev
->core
.bus_id
,
355 drv
->match_id
, drv
->core
.name
);
357 pr_debug("%s:%d: dev=%u(%s), drv=%u(%s): miss\n", __func__
,
358 __LINE__
, dev
->match_id
, dev
->core
.bus_id
,
359 drv
->match_id
, drv
->core
.name
);
363 static int ps3_system_bus_probe(struct device
*_dev
)
366 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
367 struct ps3_system_bus_driver
*drv
;
370 pr_debug(" -> %s:%d: %s\n", __func__
, __LINE__
, _dev
->bus_id
);
372 drv
= ps3_system_bus_dev_to_system_bus_drv(dev
);
376 result
= drv
->probe(dev
);
378 pr_debug("%s:%d: %s no probe method\n", __func__
, __LINE__
,
381 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, dev
->core
.bus_id
);
385 static int ps3_system_bus_remove(struct device
*_dev
)
388 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
389 struct ps3_system_bus_driver
*drv
;
392 pr_debug(" -> %s:%d: %s\n", __func__
, __LINE__
, _dev
->bus_id
);
394 drv
= ps3_system_bus_dev_to_system_bus_drv(dev
);
398 result
= drv
->remove(dev
);
400 dev_dbg(&dev
->core
, "%s:%d %s: no remove method\n",
401 __func__
, __LINE__
, drv
->core
.name
);
403 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, dev
->core
.bus_id
);
407 static void ps3_system_bus_shutdown(struct device
*_dev
)
409 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
410 struct ps3_system_bus_driver
*drv
;
414 dev_dbg(&dev
->core
, " -> %s:%d: match_id %d\n", __func__
, __LINE__
,
417 if (!dev
->core
.driver
) {
418 dev_dbg(&dev
->core
, "%s:%d: no driver bound\n", __func__
,
423 drv
= ps3_system_bus_dev_to_system_bus_drv(dev
);
427 dev_dbg(&dev
->core
, "%s:%d: %s -> %s\n", __func__
, __LINE__
,
428 dev
->core
.bus_id
, drv
->core
.name
);
432 else if (drv
->remove
) {
433 dev_dbg(&dev
->core
, "%s:%d %s: no shutdown, calling remove\n",
434 __func__
, __LINE__
, drv
->core
.name
);
437 dev_dbg(&dev
->core
, "%s:%d %s: no shutdown method\n",
438 __func__
, __LINE__
, drv
->core
.name
);
442 dev_dbg(&dev
->core
, " <- %s:%d\n", __func__
, __LINE__
);
445 static int ps3_system_bus_uevent(struct device
*_dev
, struct kobj_uevent_env
*env
)
447 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
449 if (add_uevent_var(env
, "MODALIAS=ps3:%d", dev
->match_id
))
454 static ssize_t
modalias_show(struct device
*_dev
, struct device_attribute
*a
,
457 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
458 int len
= snprintf(buf
, PAGE_SIZE
, "ps3:%d\n", dev
->match_id
);
460 return (len
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : len
;
463 static struct device_attribute ps3_system_bus_dev_attrs
[] = {
468 struct bus_type ps3_system_bus_type
= {
469 .name
= "ps3_system_bus",
470 .match
= ps3_system_bus_match
,
471 .uevent
= ps3_system_bus_uevent
,
472 .probe
= ps3_system_bus_probe
,
473 .remove
= ps3_system_bus_remove
,
474 .shutdown
= ps3_system_bus_shutdown
,
475 .dev_attrs
= ps3_system_bus_dev_attrs
,
478 static int __init
ps3_system_bus_init(void)
482 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
485 pr_debug(" -> %s:%d\n", __func__
, __LINE__
);
487 mutex_init(&usage_hack
.mutex
);
489 result
= device_register(&ps3_system_bus
);
492 result
= bus_register(&ps3_system_bus_type
);
495 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
499 core_initcall(ps3_system_bus_init
);
501 /* Allocates a contiguous real buffer and creates mappings over it.
502 * Returns the virtual address of the buffer and sets dma_handle
503 * to the dma address (mapping) of the first page.
505 static void * ps3_alloc_coherent(struct device
*_dev
, size_t size
,
506 dma_addr_t
*dma_handle
, gfp_t flag
)
509 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
510 unsigned long virt_addr
;
512 flag
&= ~(__GFP_DMA
| __GFP_HIGHMEM
);
515 virt_addr
= __get_free_pages(flag
, get_order(size
));
518 pr_debug("%s:%d: get_free_pages failed\n", __func__
, __LINE__
);
522 result
= ps3_dma_map(dev
->d_region
, virt_addr
, size
, dma_handle
,
523 IOPTE_PP_W
| IOPTE_PP_R
| IOPTE_SO_RW
| IOPTE_M
);
526 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
527 __func__
, __LINE__
, result
);
528 BUG_ON("check region type");
532 return (void*)virt_addr
;
535 free_pages(virt_addr
, get_order(size
));
541 static void ps3_free_coherent(struct device
*_dev
, size_t size
, void *vaddr
,
542 dma_addr_t dma_handle
)
544 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
546 ps3_dma_unmap(dev
->d_region
, dma_handle
, size
);
547 free_pages((unsigned long)vaddr
, get_order(size
));
550 /* Creates TCEs for a user provided buffer. The user buffer must be
551 * contiguous real kernel storage (not vmalloc). The address of the buffer
552 * passed here is the kernel (virtual) address of the buffer. The buffer
553 * need not be page aligned, the dma_addr_t returned will point to the same
554 * byte within the page as vaddr.
557 static dma_addr_t
ps3_sb_map_single(struct device
*_dev
, void *ptr
, size_t size
,
558 enum dma_data_direction direction
)
560 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
562 unsigned long bus_addr
;
564 result
= ps3_dma_map(dev
->d_region
, (unsigned long)ptr
, size
,
566 IOPTE_PP_R
| IOPTE_PP_W
| IOPTE_SO_RW
| IOPTE_M
);
569 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
570 __func__
, __LINE__
, result
);
576 static dma_addr_t
ps3_ioc0_map_single(struct device
*_dev
, void *ptr
,
578 enum dma_data_direction direction
)
580 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
582 unsigned long bus_addr
;
585 iopte_flag
= IOPTE_M
;
587 case DMA_BIDIRECTIONAL
:
588 iopte_flag
|= IOPTE_PP_R
| IOPTE_PP_W
| IOPTE_SO_RW
;
591 iopte_flag
|= IOPTE_PP_R
| IOPTE_SO_R
;
593 case DMA_FROM_DEVICE
:
594 iopte_flag
|= IOPTE_PP_W
| IOPTE_SO_RW
;
600 result
= ps3_dma_map(dev
->d_region
, (unsigned long)ptr
, size
,
601 &bus_addr
, iopte_flag
);
604 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
605 __func__
, __LINE__
, result
);
610 static void ps3_unmap_single(struct device
*_dev
, dma_addr_t dma_addr
,
611 size_t size
, enum dma_data_direction direction
)
613 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
616 result
= ps3_dma_unmap(dev
->d_region
, dma_addr
, size
);
619 pr_debug("%s:%d: ps3_dma_unmap failed (%d)\n",
620 __func__
, __LINE__
, result
);
624 static int ps3_sb_map_sg(struct device
*_dev
, struct scatterlist
*sgl
,
625 int nents
, enum dma_data_direction direction
)
627 #if defined(CONFIG_PS3_DYNAMIC_DMA)
631 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
632 struct scatterlist
*sg
;
635 for_each_sg(sgl
, sg
, nents
, i
) {
636 int result
= ps3_dma_map(dev
->d_region
, sg_phys(sg
),
637 sg
->length
, &sg
->dma_address
, 0);
640 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
641 __func__
, __LINE__
, result
);
645 sg
->dma_length
= sg
->length
;
652 static int ps3_ioc0_map_sg(struct device
*_dev
, struct scatterlist
*sg
,
654 enum dma_data_direction direction
)
660 static void ps3_sb_unmap_sg(struct device
*_dev
, struct scatterlist
*sg
,
661 int nents
, enum dma_data_direction direction
)
663 #if defined(CONFIG_PS3_DYNAMIC_DMA)
668 static void ps3_ioc0_unmap_sg(struct device
*_dev
, struct scatterlist
*sg
,
669 int nents
, enum dma_data_direction direction
)
674 static int ps3_dma_supported(struct device
*_dev
, u64 mask
)
676 return mask
>= DMA_32BIT_MASK
;
679 static struct dma_mapping_ops ps3_sb_dma_ops
= {
680 .alloc_coherent
= ps3_alloc_coherent
,
681 .free_coherent
= ps3_free_coherent
,
682 .map_single
= ps3_sb_map_single
,
683 .unmap_single
= ps3_unmap_single
,
684 .map_sg
= ps3_sb_map_sg
,
685 .unmap_sg
= ps3_sb_unmap_sg
,
686 .dma_supported
= ps3_dma_supported
689 static struct dma_mapping_ops ps3_ioc0_dma_ops
= {
690 .alloc_coherent
= ps3_alloc_coherent
,
691 .free_coherent
= ps3_free_coherent
,
692 .map_single
= ps3_ioc0_map_single
,
693 .unmap_single
= ps3_unmap_single
,
694 .map_sg
= ps3_ioc0_map_sg
,
695 .unmap_sg
= ps3_ioc0_unmap_sg
,
696 .dma_supported
= ps3_dma_supported
700 * ps3_system_bus_release_device - remove a device from the system bus
703 static void ps3_system_bus_release_device(struct device
*_dev
)
705 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
710 * ps3_system_bus_device_register - add a device to the system bus
712 * ps3_system_bus_device_register() expects the dev object to be allocated
713 * dynamically by the caller. The system bus takes ownership of the dev
714 * object and frees the object in ps3_system_bus_release_device().
717 int ps3_system_bus_device_register(struct ps3_system_bus_device
*dev
)
720 static unsigned int dev_ioc0_count
;
721 static unsigned int dev_sb_count
;
722 static unsigned int dev_vuart_count
;
723 static unsigned int dev_lpm_count
;
725 if (!dev
->core
.parent
)
726 dev
->core
.parent
= &ps3_system_bus
;
727 dev
->core
.bus
= &ps3_system_bus_type
;
728 dev
->core
.release
= ps3_system_bus_release_device
;
730 switch (dev
->dev_type
) {
731 case PS3_DEVICE_TYPE_IOC0
:
732 dev
->core
.archdata
.dma_ops
= &ps3_ioc0_dma_ops
;
733 snprintf(dev
->core
.bus_id
, sizeof(dev
->core
.bus_id
),
734 "ioc0_%02x", ++dev_ioc0_count
);
736 case PS3_DEVICE_TYPE_SB
:
737 dev
->core
.archdata
.dma_ops
= &ps3_sb_dma_ops
;
738 snprintf(dev
->core
.bus_id
, sizeof(dev
->core
.bus_id
),
739 "sb_%02x", ++dev_sb_count
);
742 case PS3_DEVICE_TYPE_VUART
:
743 snprintf(dev
->core
.bus_id
, sizeof(dev
->core
.bus_id
),
744 "vuart_%02x", ++dev_vuart_count
);
746 case PS3_DEVICE_TYPE_LPM
:
747 snprintf(dev
->core
.bus_id
, sizeof(dev
->core
.bus_id
),
748 "lpm_%02x", ++dev_lpm_count
);
754 dev
->core
.archdata
.of_node
= NULL
;
755 dev
->core
.archdata
.numa_node
= 0;
757 pr_debug("%s:%d add %s\n", __func__
, __LINE__
, dev
->core
.bus_id
);
759 result
= device_register(&dev
->core
);
763 EXPORT_SYMBOL_GPL(ps3_system_bus_device_register
);
765 int ps3_system_bus_driver_register(struct ps3_system_bus_driver
*drv
)
769 pr_debug(" -> %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
771 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
774 drv
->core
.bus
= &ps3_system_bus_type
;
776 result
= driver_register(&drv
->core
);
777 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
781 EXPORT_SYMBOL_GPL(ps3_system_bus_driver_register
);
783 void ps3_system_bus_driver_unregister(struct ps3_system_bus_driver
*drv
)
785 pr_debug(" -> %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
786 driver_unregister(&drv
->core
);
787 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
790 EXPORT_SYMBOL_GPL(ps3_system_bus_driver_unregister
);