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/export.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/err.h>
26 #include <linux/slab.h>
29 #include <asm/lv1call.h>
30 #include <asm/firmware.h>
31 #include <asm/cell-regs.h>
35 static struct device ps3_system_bus
= {
36 .init_name
= "ps3_system",
39 /* FIXME: need device usage counters! */
42 int sb_11
; /* usb 0 */
43 int sb_12
; /* usb 0 */
47 static int ps3_is_device(struct ps3_system_bus_device
*dev
, u64 bus_id
,
50 return dev
->bus_id
== bus_id
&& dev
->dev_id
== dev_id
;
53 static int ps3_open_hv_device_sb(struct ps3_system_bus_device
*dev
)
58 mutex_lock(&usage_hack
.mutex
);
60 if (ps3_is_device(dev
, 1, 1)) {
62 if (usage_hack
.sb_11
> 1) {
68 if (ps3_is_device(dev
, 1, 2)) {
70 if (usage_hack
.sb_12
> 1) {
76 result
= lv1_open_device(dev
->bus_id
, dev
->dev_id
, 0);
79 pr_debug("%s:%d: lv1_open_device failed: %s\n", __func__
,
80 __LINE__
, ps3_result(result
));
85 mutex_unlock(&usage_hack
.mutex
);
89 static int ps3_close_hv_device_sb(struct ps3_system_bus_device
*dev
)
94 mutex_lock(&usage_hack
.mutex
);
96 if (ps3_is_device(dev
, 1, 1)) {
98 if (usage_hack
.sb_11
) {
104 if (ps3_is_device(dev
, 1, 2)) {
106 if (usage_hack
.sb_12
) {
112 result
= lv1_close_device(dev
->bus_id
, dev
->dev_id
);
116 mutex_unlock(&usage_hack
.mutex
);
120 static int ps3_open_hv_device_gpu(struct ps3_system_bus_device
*dev
)
124 mutex_lock(&usage_hack
.mutex
);
127 if (usage_hack
.gpu
> 1) {
132 result
= lv1_gpu_open(0);
135 pr_debug("%s:%d: lv1_gpu_open failed: %s\n", __func__
,
136 __LINE__
, ps3_result(result
));
141 mutex_unlock(&usage_hack
.mutex
);
145 static int ps3_close_hv_device_gpu(struct ps3_system_bus_device
*dev
)
149 mutex_lock(&usage_hack
.mutex
);
152 if (usage_hack
.gpu
) {
157 result
= lv1_gpu_close();
161 mutex_unlock(&usage_hack
.mutex
);
165 int ps3_open_hv_device(struct ps3_system_bus_device
*dev
)
168 pr_debug("%s:%d: match_id: %u\n", __func__
, __LINE__
, dev
->match_id
);
170 switch (dev
->match_id
) {
171 case PS3_MATCH_ID_EHCI
:
172 case PS3_MATCH_ID_OHCI
:
173 case PS3_MATCH_ID_GELIC
:
174 case PS3_MATCH_ID_STOR_DISK
:
175 case PS3_MATCH_ID_STOR_ROM
:
176 case PS3_MATCH_ID_STOR_FLASH
:
177 return ps3_open_hv_device_sb(dev
);
179 case PS3_MATCH_ID_SOUND
:
180 case PS3_MATCH_ID_GPU
:
181 return ps3_open_hv_device_gpu(dev
);
183 case PS3_MATCH_ID_AV_SETTINGS
:
184 case PS3_MATCH_ID_SYSTEM_MANAGER
:
185 pr_debug("%s:%d: unsupported match_id: %u\n", __func__
,
186 __LINE__
, dev
->match_id
);
187 pr_debug("%s:%d: bus_id: %llu\n", __func__
, __LINE__
,
196 pr_debug("%s:%d: unknown match_id: %u\n", __func__
, __LINE__
,
201 EXPORT_SYMBOL_GPL(ps3_open_hv_device
);
203 int ps3_close_hv_device(struct ps3_system_bus_device
*dev
)
206 pr_debug("%s:%d: match_id: %u\n", __func__
, __LINE__
, dev
->match_id
);
208 switch (dev
->match_id
) {
209 case PS3_MATCH_ID_EHCI
:
210 case PS3_MATCH_ID_OHCI
:
211 case PS3_MATCH_ID_GELIC
:
212 case PS3_MATCH_ID_STOR_DISK
:
213 case PS3_MATCH_ID_STOR_ROM
:
214 case PS3_MATCH_ID_STOR_FLASH
:
215 return ps3_close_hv_device_sb(dev
);
217 case PS3_MATCH_ID_SOUND
:
218 case PS3_MATCH_ID_GPU
:
219 return ps3_close_hv_device_gpu(dev
);
221 case PS3_MATCH_ID_AV_SETTINGS
:
222 case PS3_MATCH_ID_SYSTEM_MANAGER
:
223 pr_debug("%s:%d: unsupported match_id: %u\n", __func__
,
224 __LINE__
, dev
->match_id
);
225 pr_debug("%s:%d: bus_id: %llu\n", __func__
, __LINE__
,
234 pr_debug("%s:%d: unknown match_id: %u\n", __func__
, __LINE__
,
239 EXPORT_SYMBOL_GPL(ps3_close_hv_device
);
241 #define dump_mmio_region(_a) _dump_mmio_region(_a, __func__, __LINE__)
242 static void _dump_mmio_region(const struct ps3_mmio_region
* r
,
243 const char* func
, int line
)
245 pr_debug("%s:%d: dev %llu:%llu\n", func
, line
, r
->dev
->bus_id
,
247 pr_debug("%s:%d: bus_addr %lxh\n", func
, line
, r
->bus_addr
);
248 pr_debug("%s:%d: len %lxh\n", func
, line
, r
->len
);
249 pr_debug("%s:%d: lpar_addr %lxh\n", func
, line
, r
->lpar_addr
);
252 static int ps3_sb_mmio_region_create(struct ps3_mmio_region
*r
)
257 result
= lv1_map_device_mmio_region(r
->dev
->bus_id
, r
->dev
->dev_id
,
258 r
->bus_addr
, r
->len
, r
->page_size
, &lpar_addr
);
259 r
->lpar_addr
= lpar_addr
;
262 pr_debug("%s:%d: lv1_map_device_mmio_region failed: %s\n",
263 __func__
, __LINE__
, ps3_result(result
));
271 static int ps3_ioc0_mmio_region_create(struct ps3_mmio_region
*r
)
273 /* device specific; do nothing currently */
277 int ps3_mmio_region_create(struct ps3_mmio_region
*r
)
279 return r
->mmio_ops
->create(r
);
281 EXPORT_SYMBOL_GPL(ps3_mmio_region_create
);
283 static int ps3_sb_free_mmio_region(struct ps3_mmio_region
*r
)
288 result
= lv1_unmap_device_mmio_region(r
->dev
->bus_id
, r
->dev
->dev_id
,
292 pr_debug("%s:%d: lv1_unmap_device_mmio_region failed: %s\n",
293 __func__
, __LINE__
, ps3_result(result
));
299 static int ps3_ioc0_free_mmio_region(struct ps3_mmio_region
*r
)
301 /* device specific; do nothing currently */
306 int ps3_free_mmio_region(struct ps3_mmio_region
*r
)
308 return r
->mmio_ops
->free(r
);
311 EXPORT_SYMBOL_GPL(ps3_free_mmio_region
);
313 static const struct ps3_mmio_region_ops ps3_mmio_sb_region_ops
= {
314 .create
= ps3_sb_mmio_region_create
,
315 .free
= ps3_sb_free_mmio_region
318 static const struct ps3_mmio_region_ops ps3_mmio_ioc0_region_ops
= {
319 .create
= ps3_ioc0_mmio_region_create
,
320 .free
= ps3_ioc0_free_mmio_region
323 int ps3_mmio_region_init(struct ps3_system_bus_device
*dev
,
324 struct ps3_mmio_region
*r
, unsigned long bus_addr
, unsigned long len
,
325 enum ps3_mmio_page_size page_size
)
328 r
->bus_addr
= bus_addr
;
330 r
->page_size
= page_size
;
331 switch (dev
->dev_type
) {
332 case PS3_DEVICE_TYPE_SB
:
333 r
->mmio_ops
= &ps3_mmio_sb_region_ops
;
335 case PS3_DEVICE_TYPE_IOC0
:
336 r
->mmio_ops
= &ps3_mmio_ioc0_region_ops
;
344 EXPORT_SYMBOL_GPL(ps3_mmio_region_init
);
346 static int ps3_system_bus_match(struct device
*_dev
,
347 struct device_driver
*_drv
)
350 struct ps3_system_bus_driver
*drv
= ps3_drv_to_system_bus_drv(_drv
);
351 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
353 if (!dev
->match_sub_id
)
354 result
= dev
->match_id
== drv
->match_id
;
356 result
= dev
->match_sub_id
== drv
->match_sub_id
&&
357 dev
->match_id
== drv
->match_id
;
360 pr_info("%s:%d: dev=%u.%u(%s), drv=%u.%u(%s): match\n",
362 dev
->match_id
, dev
->match_sub_id
, dev_name(&dev
->core
),
363 drv
->match_id
, drv
->match_sub_id
, drv
->core
.name
);
365 pr_debug("%s:%d: dev=%u.%u(%s), drv=%u.%u(%s): miss\n",
367 dev
->match_id
, dev
->match_sub_id
, dev_name(&dev
->core
),
368 drv
->match_id
, drv
->match_sub_id
, drv
->core
.name
);
373 static int ps3_system_bus_probe(struct device
*_dev
)
376 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
377 struct ps3_system_bus_driver
*drv
;
380 dev_dbg(_dev
, "%s:%d\n", __func__
, __LINE__
);
382 drv
= ps3_system_bus_dev_to_system_bus_drv(dev
);
386 result
= drv
->probe(dev
);
388 pr_debug("%s:%d: %s no probe method\n", __func__
, __LINE__
,
389 dev_name(&dev
->core
));
391 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, dev_name(&dev
->core
));
395 static int ps3_system_bus_remove(struct device
*_dev
)
398 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
399 struct ps3_system_bus_driver
*drv
;
402 dev_dbg(_dev
, "%s:%d\n", __func__
, __LINE__
);
404 drv
= ps3_system_bus_dev_to_system_bus_drv(dev
);
408 result
= drv
->remove(dev
);
410 dev_dbg(&dev
->core
, "%s:%d %s: no remove method\n",
411 __func__
, __LINE__
, drv
->core
.name
);
413 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, dev_name(&dev
->core
));
417 static void ps3_system_bus_shutdown(struct device
*_dev
)
419 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
420 struct ps3_system_bus_driver
*drv
;
424 dev_dbg(&dev
->core
, " -> %s:%d: match_id %d\n", __func__
, __LINE__
,
427 if (!dev
->core
.driver
) {
428 dev_dbg(&dev
->core
, "%s:%d: no driver bound\n", __func__
,
433 drv
= ps3_system_bus_dev_to_system_bus_drv(dev
);
437 dev_dbg(&dev
->core
, "%s:%d: %s -> %s\n", __func__
, __LINE__
,
438 dev_name(&dev
->core
), drv
->core
.name
);
442 else if (drv
->remove
) {
443 dev_dbg(&dev
->core
, "%s:%d %s: no shutdown, calling remove\n",
444 __func__
, __LINE__
, drv
->core
.name
);
447 dev_dbg(&dev
->core
, "%s:%d %s: no shutdown method\n",
448 __func__
, __LINE__
, drv
->core
.name
);
452 dev_dbg(&dev
->core
, " <- %s:%d\n", __func__
, __LINE__
);
455 static int ps3_system_bus_uevent(struct device
*_dev
, struct kobj_uevent_env
*env
)
457 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
459 if (add_uevent_var(env
, "MODALIAS=ps3:%d:%d", dev
->match_id
,
465 static ssize_t
modalias_show(struct device
*_dev
, struct device_attribute
*a
,
468 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
469 int len
= snprintf(buf
, PAGE_SIZE
, "ps3:%d:%d\n", dev
->match_id
,
472 return (len
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : len
;
475 static struct device_attribute ps3_system_bus_dev_attrs
[] = {
480 struct bus_type ps3_system_bus_type
= {
481 .name
= "ps3_system_bus",
482 .match
= ps3_system_bus_match
,
483 .uevent
= ps3_system_bus_uevent
,
484 .probe
= ps3_system_bus_probe
,
485 .remove
= ps3_system_bus_remove
,
486 .shutdown
= ps3_system_bus_shutdown
,
487 .dev_attrs
= ps3_system_bus_dev_attrs
,
490 static int __init
ps3_system_bus_init(void)
494 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
497 pr_debug(" -> %s:%d\n", __func__
, __LINE__
);
499 mutex_init(&usage_hack
.mutex
);
501 result
= device_register(&ps3_system_bus
);
504 result
= bus_register(&ps3_system_bus_type
);
507 pr_debug(" <- %s:%d\n", __func__
, __LINE__
);
511 core_initcall(ps3_system_bus_init
);
513 /* Allocates a contiguous real buffer and creates mappings over it.
514 * Returns the virtual address of the buffer and sets dma_handle
515 * to the dma address (mapping) of the first page.
517 static void * ps3_alloc_coherent(struct device
*_dev
, size_t size
,
518 dma_addr_t
*dma_handle
, gfp_t flag
)
521 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
522 unsigned long virt_addr
;
524 flag
&= ~(__GFP_DMA
| __GFP_HIGHMEM
);
527 virt_addr
= __get_free_pages(flag
, get_order(size
));
530 pr_debug("%s:%d: get_free_pages failed\n", __func__
, __LINE__
);
534 result
= ps3_dma_map(dev
->d_region
, virt_addr
, size
, dma_handle
,
535 CBE_IOPTE_PP_W
| CBE_IOPTE_PP_R
|
536 CBE_IOPTE_SO_RW
| CBE_IOPTE_M
);
539 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
540 __func__
, __LINE__
, result
);
541 BUG_ON("check region type");
545 return (void*)virt_addr
;
548 free_pages(virt_addr
, get_order(size
));
554 static void ps3_free_coherent(struct device
*_dev
, size_t size
, void *vaddr
,
555 dma_addr_t dma_handle
)
557 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
559 ps3_dma_unmap(dev
->d_region
, dma_handle
, size
);
560 free_pages((unsigned long)vaddr
, get_order(size
));
563 /* Creates TCEs for a user provided buffer. The user buffer must be
564 * contiguous real kernel storage (not vmalloc). The address passed here
565 * comprises a page address and offset into that page. The dma_addr_t
566 * returned will point to the same byte within the page as was passed in.
569 static dma_addr_t
ps3_sb_map_page(struct device
*_dev
, struct page
*page
,
570 unsigned long offset
, size_t size
, enum dma_data_direction direction
,
571 struct dma_attrs
*attrs
)
573 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
576 void *ptr
= page_address(page
) + offset
;
578 result
= ps3_dma_map(dev
->d_region
, (unsigned long)ptr
, size
,
580 CBE_IOPTE_PP_R
| CBE_IOPTE_PP_W
|
581 CBE_IOPTE_SO_RW
| CBE_IOPTE_M
);
584 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
585 __func__
, __LINE__
, result
);
591 static dma_addr_t
ps3_ioc0_map_page(struct device
*_dev
, struct page
*page
,
592 unsigned long offset
, size_t size
,
593 enum dma_data_direction direction
,
594 struct dma_attrs
*attrs
)
596 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
600 void *ptr
= page_address(page
) + offset
;
602 iopte_flag
= CBE_IOPTE_M
;
604 case DMA_BIDIRECTIONAL
:
605 iopte_flag
|= CBE_IOPTE_PP_R
| CBE_IOPTE_PP_W
| CBE_IOPTE_SO_RW
;
608 iopte_flag
|= CBE_IOPTE_PP_R
| CBE_IOPTE_SO_R
;
610 case DMA_FROM_DEVICE
:
611 iopte_flag
|= CBE_IOPTE_PP_W
| CBE_IOPTE_SO_RW
;
617 result
= ps3_dma_map(dev
->d_region
, (unsigned long)ptr
, size
,
618 &bus_addr
, iopte_flag
);
621 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
622 __func__
, __LINE__
, result
);
627 static void ps3_unmap_page(struct device
*_dev
, dma_addr_t dma_addr
,
628 size_t size
, enum dma_data_direction direction
, struct dma_attrs
*attrs
)
630 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
633 result
= ps3_dma_unmap(dev
->d_region
, dma_addr
, size
);
636 pr_debug("%s:%d: ps3_dma_unmap failed (%d)\n",
637 __func__
, __LINE__
, result
);
641 static int ps3_sb_map_sg(struct device
*_dev
, struct scatterlist
*sgl
,
642 int nents
, enum dma_data_direction direction
, struct dma_attrs
*attrs
)
644 #if defined(CONFIG_PS3_DYNAMIC_DMA)
648 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
649 struct scatterlist
*sg
;
652 for_each_sg(sgl
, sg
, nents
, i
) {
653 int result
= ps3_dma_map(dev
->d_region
, sg_phys(sg
),
654 sg
->length
, &sg
->dma_address
, 0);
657 pr_debug("%s:%d: ps3_dma_map failed (%d)\n",
658 __func__
, __LINE__
, result
);
662 sg
->dma_length
= sg
->length
;
669 static int ps3_ioc0_map_sg(struct device
*_dev
, struct scatterlist
*sg
,
671 enum dma_data_direction direction
,
672 struct dma_attrs
*attrs
)
678 static void ps3_sb_unmap_sg(struct device
*_dev
, struct scatterlist
*sg
,
679 int nents
, enum dma_data_direction direction
, struct dma_attrs
*attrs
)
681 #if defined(CONFIG_PS3_DYNAMIC_DMA)
686 static void ps3_ioc0_unmap_sg(struct device
*_dev
, struct scatterlist
*sg
,
687 int nents
, enum dma_data_direction direction
,
688 struct dma_attrs
*attrs
)
693 static int ps3_dma_supported(struct device
*_dev
, u64 mask
)
695 return mask
>= DMA_BIT_MASK(32);
698 static struct dma_map_ops ps3_sb_dma_ops
= {
699 .alloc_coherent
= ps3_alloc_coherent
,
700 .free_coherent
= ps3_free_coherent
,
701 .map_sg
= ps3_sb_map_sg
,
702 .unmap_sg
= ps3_sb_unmap_sg
,
703 .dma_supported
= ps3_dma_supported
,
704 .map_page
= ps3_sb_map_page
,
705 .unmap_page
= ps3_unmap_page
,
708 static struct dma_map_ops ps3_ioc0_dma_ops
= {
709 .alloc_coherent
= ps3_alloc_coherent
,
710 .free_coherent
= ps3_free_coherent
,
711 .map_sg
= ps3_ioc0_map_sg
,
712 .unmap_sg
= ps3_ioc0_unmap_sg
,
713 .dma_supported
= ps3_dma_supported
,
714 .map_page
= ps3_ioc0_map_page
,
715 .unmap_page
= ps3_unmap_page
,
719 * ps3_system_bus_release_device - remove a device from the system bus
722 static void ps3_system_bus_release_device(struct device
*_dev
)
724 struct ps3_system_bus_device
*dev
= ps3_dev_to_system_bus_dev(_dev
);
729 * ps3_system_bus_device_register - add a device to the system bus
731 * ps3_system_bus_device_register() expects the dev object to be allocated
732 * dynamically by the caller. The system bus takes ownership of the dev
733 * object and frees the object in ps3_system_bus_release_device().
736 int ps3_system_bus_device_register(struct ps3_system_bus_device
*dev
)
739 static unsigned int dev_ioc0_count
;
740 static unsigned int dev_sb_count
;
741 static unsigned int dev_vuart_count
;
742 static unsigned int dev_lpm_count
;
744 if (!dev
->core
.parent
)
745 dev
->core
.parent
= &ps3_system_bus
;
746 dev
->core
.bus
= &ps3_system_bus_type
;
747 dev
->core
.release
= ps3_system_bus_release_device
;
749 switch (dev
->dev_type
) {
750 case PS3_DEVICE_TYPE_IOC0
:
751 dev
->core
.archdata
.dma_ops
= &ps3_ioc0_dma_ops
;
752 dev_set_name(&dev
->core
, "ioc0_%02x", ++dev_ioc0_count
);
754 case PS3_DEVICE_TYPE_SB
:
755 dev
->core
.archdata
.dma_ops
= &ps3_sb_dma_ops
;
756 dev_set_name(&dev
->core
, "sb_%02x", ++dev_sb_count
);
759 case PS3_DEVICE_TYPE_VUART
:
760 dev_set_name(&dev
->core
, "vuart_%02x", ++dev_vuart_count
);
762 case PS3_DEVICE_TYPE_LPM
:
763 dev_set_name(&dev
->core
, "lpm_%02x", ++dev_lpm_count
);
769 dev
->core
.of_node
= NULL
;
770 set_dev_node(&dev
->core
, 0);
772 pr_debug("%s:%d add %s\n", __func__
, __LINE__
, dev_name(&dev
->core
));
774 result
= device_register(&dev
->core
);
778 EXPORT_SYMBOL_GPL(ps3_system_bus_device_register
);
780 int ps3_system_bus_driver_register(struct ps3_system_bus_driver
*drv
)
784 pr_debug(" -> %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
786 if (!firmware_has_feature(FW_FEATURE_PS3_LV1
))
789 drv
->core
.bus
= &ps3_system_bus_type
;
791 result
= driver_register(&drv
->core
);
792 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
796 EXPORT_SYMBOL_GPL(ps3_system_bus_driver_register
);
798 void ps3_system_bus_driver_unregister(struct ps3_system_bus_driver
*drv
)
800 pr_debug(" -> %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
801 driver_unregister(&drv
->core
);
802 pr_debug(" <- %s:%d: %s\n", __func__
, __LINE__
, drv
->core
.name
);
805 EXPORT_SYMBOL_GPL(ps3_system_bus_driver_unregister
);