1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (C) 2010 Nathan Whitehorn
5 * Copyright (C) 2011 glevand (geoffrey.levand@mail.ru)
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
26 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/module.h>
36 #include <sys/malloc.h>
37 #include <sys/bus.h>
38 #include <sys/clock.h>
39 #include <sys/cpu.h>
40 #include <sys/resource.h>
41 #include <sys/rman.h>
42
43 #include <vm/vm.h>
44 #include <vm/pmap.h>
45
46 #include <machine/bus.h>
47 #include <machine/platform.h>
48 #include <machine/resource.h>
49
50 #include "ps3bus.h"
51 #include "ps3-hvcall.h"
52 #include "iommu_if.h"
53 #include "clock_if.h"
54
55 static void ps3bus_identify(driver_t *, device_t);
56 static int ps3bus_probe(device_t);
57 static int ps3bus_attach(device_t);
58 static int ps3bus_print_child(device_t dev, device_t child);
59 static int ps3bus_read_ivar(device_t bus, device_t child, int which,
60 uintptr_t *result);
61 static struct resource *ps3bus_alloc_resource(device_t bus, device_t child,
62 int type, int *rid, rman_res_t start, rman_res_t end,
63 rman_res_t count, u_int flags);
64 static int ps3bus_activate_resource(device_t bus, device_t child, int type,
65 int rid, struct resource *res);
66 static bus_dma_tag_t ps3bus_get_dma_tag(device_t dev, device_t child);
67 static int ps3_iommu_map(device_t dev, bus_dma_segment_t *segs, int *nsegs, bus_addr_t min, bus_addr_t max, bus_size_t alignment,
68 bus_addr_t boundary, void *cookie);
69 static int ps3_iommu_unmap(device_t dev, bus_dma_segment_t *segs,
70 int nsegs, void *cookie);
71 static int ps3_gettime(device_t dev, struct timespec *ts);
72 static int ps3_settime(device_t dev, struct timespec *ts);
73
74 struct ps3bus_devinfo {
75 int bus;
76 int dev;
77 uint64_t bustype;
78 uint64_t devtype;
79 int busidx;
80 int devidx;
81
82 struct resource_list resources;
83 bus_dma_tag_t dma_tag;
84
85 struct mtx iommu_mtx;
86 bus_addr_t dma_base[4];
87 };
88
89 static MALLOC_DEFINE(M_PS3BUS, "ps3bus", "PS3 system bus device information");
90
91 enum ps3bus_irq_type {
92 SB_IRQ = 2,
93 OHCI_IRQ = 3,
94 EHCI_IRQ = 4,
95 };
96
97 enum ps3bus_reg_type {
98 OHCI_REG = 3,
99 EHCI_REG = 4,
100 };
101
102 static device_method_t ps3bus_methods[] = {
103 /* Device interface */
104 DEVMETHOD(device_identify, ps3bus_identify),
105 DEVMETHOD(device_probe, ps3bus_probe),
106 DEVMETHOD(device_attach, ps3bus_attach),
107
108 /* Bus interface */
109 DEVMETHOD(bus_add_child, bus_generic_add_child),
110 DEVMETHOD(bus_get_dma_tag, ps3bus_get_dma_tag),
111 DEVMETHOD(bus_print_child, ps3bus_print_child),
112 DEVMETHOD(bus_read_ivar, ps3bus_read_ivar),
113 DEVMETHOD(bus_alloc_resource, ps3bus_alloc_resource),
114 DEVMETHOD(bus_activate_resource, ps3bus_activate_resource),
115 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
116 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
117
118 /* IOMMU interface */
119 DEVMETHOD(iommu_map, ps3_iommu_map),
120 DEVMETHOD(iommu_unmap, ps3_iommu_unmap),
121
122 /* Clock interface */
123 DEVMETHOD(clock_gettime, ps3_gettime),
124 DEVMETHOD(clock_settime, ps3_settime),
125
126 DEVMETHOD_END
127 };
128
129 struct ps3bus_softc {
130 struct rman sc_mem_rman;
131 struct rman sc_intr_rman;
132 struct mem_region *regions;
133 int rcount;
134 };
135
136 static driver_t ps3bus_driver = {
137 "ps3bus",
138 ps3bus_methods,
139 sizeof(struct ps3bus_softc)
140 };
141
142 static devclass_t ps3bus_devclass;
143
144 DRIVER_MODULE(ps3bus, nexus, ps3bus_driver, ps3bus_devclass, 0, 0);
145
146 static void
147 ps3bus_identify(driver_t *driver, device_t parent)
148 {
149 if (strcmp(installed_platform(), "ps3") != 0)
150 return;
151
152 if (device_find_child(parent, "ps3bus", -1) == NULL)
153 BUS_ADD_CHILD(parent, 0, "ps3bus", 0);
154 }
155
156 static int
157 ps3bus_probe(device_t dev)
158 {
159 /* Do not attach to any OF nodes that may be present */
160
161 device_set_desc(dev, "Playstation 3 System Bus");
162
163 return (BUS_PROBE_NOWILDCARD);
164 }
165
166 static void
167 ps3bus_resources_init(struct rman *rm, int bus_index, int dev_index,
168 struct ps3bus_devinfo *dinfo)
169 {
170 uint64_t irq_type, irq, outlet;
171 uint64_t reg_type, paddr, len;
172 uint64_t ppe, junk;
173 int i, result;
174 int thread;
175
176 resource_list_init(&dinfo->resources);
177
178 lv1_get_logical_ppe_id(&ppe);
179 thread = 32 - fls(mfctrl());
180
181 /* Scan for interrupts */
182 for (i = 0; i < 10; i++) {
183 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
184 (lv1_repository_string("bus") >> 32) | bus_index,
185 lv1_repository_string("dev") | dev_index,
186 lv1_repository_string("intr") | i, 0, &irq_type, &irq);
187
188 if (result != 0)
189 break;
190
191 switch (irq_type) {
192 case SB_IRQ:
193 lv1_construct_event_receive_port(&outlet);
194 lv1_connect_irq_plug_ext(ppe, thread, outlet, outlet,
195 0);
196 lv1_connect_interrupt_event_receive_port(dinfo->bus,
197 dinfo->dev, outlet, irq);
198 break;
199 case OHCI_IRQ:
200 case EHCI_IRQ:
201 lv1_construct_io_irq_outlet(irq, &outlet);
202 lv1_connect_irq_plug_ext(ppe, thread, outlet, outlet,
203 0);
204 break;
205 default:
206 printf("Unknown IRQ type %ld for device %d.%d\n",
207 irq_type, dinfo->bus, dinfo->dev);
208 break;
209 }
210
211 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i,
212 outlet, outlet, 1);
213 }
214
215 /* Scan for registers */
216 for (i = 0; i < 10; i++) {
217 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
218 (lv1_repository_string("bus") >> 32) | bus_index,
219 lv1_repository_string("dev") | dev_index,
220 lv1_repository_string("reg") | i,
221 lv1_repository_string("type"), ®_type, &junk);
222
223 if (result != 0)
224 break;
225
226 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
227 (lv1_repository_string("bus") >> 32) | bus_index,
228 lv1_repository_string("dev") | dev_index,
229 lv1_repository_string("reg") | i,
230 lv1_repository_string("data"), &paddr, &len);
231
232 result = lv1_map_device_mmio_region(dinfo->bus, dinfo->dev,
233 paddr, len, 12 /* log_2(4 KB) */, &paddr);
234
235 if (result != 0) {
236 printf("Mapping registers failed for device "
237 "%d.%d (%ld.%ld): %d\n", dinfo->bus, dinfo->dev,
238 dinfo->bustype, dinfo->devtype, result);
239 continue;
240 }
241
242 rman_manage_region(rm, paddr, paddr + len - 1);
243 resource_list_add(&dinfo->resources, SYS_RES_MEMORY, i,
244 paddr, paddr + len, len);
245 }
246 }
247
248 static void
249 ps3bus_resources_init_by_type(struct rman *rm, int bus_index, int dev_index,
250 uint64_t irq_type, uint64_t reg_type, struct ps3bus_devinfo *dinfo)
251 {
252 uint64_t _irq_type, irq, outlet;
253 uint64_t _reg_type, paddr, len;
254 uint64_t ppe, junk;
255 int i, result;
256 int thread;
257
258 resource_list_init(&dinfo->resources);
259
260 lv1_get_logical_ppe_id(&ppe);
261 thread = 32 - fls(mfctrl());
262
263 /* Scan for interrupts */
264 for (i = 0; i < 10; i++) {
265 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
266 (lv1_repository_string("bus") >> 32) | bus_index,
267 lv1_repository_string("dev") | dev_index,
268 lv1_repository_string("intr") | i, 0, &_irq_type, &irq);
269
270 if (result != 0)
271 break;
272
273 if (_irq_type != irq_type)
274 continue;
275
276 lv1_construct_io_irq_outlet(irq, &outlet);
277 lv1_connect_irq_plug_ext(ppe, thread, outlet, outlet,
278 0);
279 resource_list_add(&dinfo->resources, SYS_RES_IRQ, i,
280 outlet, outlet, 1);
281 }
282
283 /* Scan for registers */
284 for (i = 0; i < 10; i++) {
285 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
286 (lv1_repository_string("bus") >> 32) | bus_index,
287 lv1_repository_string("dev") | dev_index,
288 lv1_repository_string("reg") | i,
289 lv1_repository_string("type"), &_reg_type, &junk);
290
291 if (result != 0)
292 break;
293
294 if (_reg_type != reg_type)
295 continue;
296
297 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
298 (lv1_repository_string("bus") >> 32) | bus_index,
299 lv1_repository_string("dev") | dev_index,
300 lv1_repository_string("reg") | i,
301 lv1_repository_string("data"), &paddr, &len);
302
303 result = lv1_map_device_mmio_region(dinfo->bus, dinfo->dev,
304 paddr, len, 12 /* log_2(4 KB) */, &paddr);
305
306 if (result != 0) {
307 printf("Mapping registers failed for device "
308 "%d.%d (%ld.%ld): %d\n", dinfo->bus, dinfo->dev,
309 dinfo->bustype, dinfo->devtype, result);
310 break;
311 }
312
313 rman_manage_region(rm, paddr, paddr + len - 1);
314 resource_list_add(&dinfo->resources, SYS_RES_MEMORY, i,
315 paddr, paddr + len, len);
316 }
317 }
318
319 static int
320 ps3bus_attach(device_t self)
321 {
322 struct ps3bus_softc *sc;
323 struct ps3bus_devinfo *dinfo;
324 int bus_index, dev_index, result;
325 uint64_t bustype, bus, devs;
326 uint64_t dev, devtype;
327 uint64_t junk;
328 device_t cdev;
329
330 sc = device_get_softc(self);
331 sc->sc_mem_rman.rm_type = RMAN_ARRAY;
332 sc->sc_mem_rman.rm_descr = "PS3Bus Memory Mapped I/O";
333 sc->sc_intr_rman.rm_type = RMAN_ARRAY;
334 sc->sc_intr_rman.rm_descr = "PS3Bus Interrupts";
335 rman_init(&sc->sc_mem_rman);
336 rman_init(&sc->sc_intr_rman);
337 rman_manage_region(&sc->sc_intr_rman, 0, ~0);
338
339 /* Get memory regions for DMA */
340 mem_regions(&sc->regions, &sc->rcount, NULL, NULL);
341
342 /*
343 * Probe all the PS3's buses.
344 */
345
346 for (bus_index = 0; bus_index < 5; bus_index++) {
347 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
348 (lv1_repository_string("bus") >> 32) | bus_index,
349 lv1_repository_string("type"), 0, 0, &bustype, &junk);
350
351 if (result != 0)
352 continue;
353
354 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
355 (lv1_repository_string("bus") >> 32) | bus_index,
356 lv1_repository_string("id"), 0, 0, &bus, &junk);
357
358 if (result != 0)
359 continue;
360
361 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
362 (lv1_repository_string("bus") >> 32) | bus_index,
363 lv1_repository_string("num_dev"), 0, 0, &devs, &junk);
364
365 for (dev_index = 0; dev_index < devs; dev_index++) {
366 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
367 (lv1_repository_string("bus") >> 32) | bus_index,
368 lv1_repository_string("dev") | dev_index,
369 lv1_repository_string("type"), 0, &devtype, &junk);
370
371 if (result != 0)
372 continue;
373
374 result = lv1_get_repository_node_value(PS3_LPAR_ID_PME,
375 (lv1_repository_string("bus") >> 32) | bus_index,
376 lv1_repository_string("dev") | dev_index,
377 lv1_repository_string("id"), 0, &dev, &junk);
378
379 if (result != 0)
380 continue;
381
382 switch (devtype) {
383 case PS3_DEVTYPE_USB:
384 /* USB device has OHCI and EHCI USB host controllers */
385
386 lv1_open_device(bus, dev, 0);
387
388 /* OHCI host controller */
389
390 dinfo = malloc(sizeof(*dinfo), M_PS3BUS,
391 M_WAITOK | M_ZERO);
392
393 dinfo->bus = bus;
394 dinfo->dev = dev;
395 dinfo->bustype = bustype;
396 dinfo->devtype = devtype;
397 dinfo->busidx = bus_index;
398 dinfo->devidx = dev_index;
399
400 ps3bus_resources_init_by_type(&sc->sc_mem_rman, bus_index,
401 dev_index, OHCI_IRQ, OHCI_REG, dinfo);
402
403 cdev = device_add_child(self, "ohci", -1);
404 if (cdev == NULL) {
405 device_printf(self,
406 "device_add_child failed\n");
407 free(dinfo, M_PS3BUS);
408 continue;
409 }
410
411 mtx_init(&dinfo->iommu_mtx, "iommu", NULL, MTX_DEF);
412 device_set_ivars(cdev, dinfo);
413
414 /* EHCI host controller */
415
416 dinfo = malloc(sizeof(*dinfo), M_PS3BUS,
417 M_WAITOK | M_ZERO);
418
419 dinfo->bus = bus;
420 dinfo->dev = dev;
421 dinfo->bustype = bustype;
422 dinfo->devtype = devtype;
423 dinfo->busidx = bus_index;
424 dinfo->devidx = dev_index;
425
426 ps3bus_resources_init_by_type(&sc->sc_mem_rman, bus_index,
427 dev_index, EHCI_IRQ, EHCI_REG, dinfo);
428
429 cdev = device_add_child(self, "ehci", -1);
430 if (cdev == NULL) {
431 device_printf(self,
432 "device_add_child failed\n");
433 free(dinfo, M_PS3BUS);
434 continue;
435 }
436
437 mtx_init(&dinfo->iommu_mtx, "iommu", NULL, MTX_DEF);
438 device_set_ivars(cdev, dinfo);
439 break;
440 default:
441 dinfo = malloc(sizeof(*dinfo), M_PS3BUS,
442 M_WAITOK | M_ZERO);
443
444 dinfo->bus = bus;
445 dinfo->dev = dev;
446 dinfo->bustype = bustype;
447 dinfo->devtype = devtype;
448 dinfo->busidx = bus_index;
449 dinfo->devidx = dev_index;
450
451 if (dinfo->bustype == PS3_BUSTYPE_SYSBUS ||
452 dinfo->bustype == PS3_BUSTYPE_STORAGE)
453 lv1_open_device(bus, dev, 0);
454
455 ps3bus_resources_init(&sc->sc_mem_rman, bus_index,
456 dev_index, dinfo);
457
458 cdev = device_add_child(self, NULL, -1);
459 if (cdev == NULL) {
460 device_printf(self,
461 "device_add_child failed\n");
462 free(dinfo, M_PS3BUS);
463 continue;
464 }
465
466 mtx_init(&dinfo->iommu_mtx, "iommu", NULL, MTX_DEF);
467 device_set_ivars(cdev, dinfo);
468 }
469 }
470 }
471
472 clock_register(self, 1000);
473
474 return (bus_generic_attach(self));
475 }
476
477 static int
478 ps3bus_print_child(device_t dev, device_t child)
479 {
480 struct ps3bus_devinfo *dinfo = device_get_ivars(child);
481 int retval = 0;
482
483 retval += bus_print_child_header(dev, child);
484 retval += resource_list_print_type(&dinfo->resources, "mem",
485 SYS_RES_MEMORY, "%#jx");
486 retval += resource_list_print_type(&dinfo->resources, "irq",
487 SYS_RES_IRQ, "%jd");
488
489 retval += bus_print_child_footer(dev, child);
490
491 return (retval);
492 }
493
494 static int
495 ps3bus_read_ivar(device_t bus, device_t child, int which, uintptr_t *result)
496 {
497 struct ps3bus_devinfo *dinfo = device_get_ivars(child);
498
499 switch (which) {
500 case PS3BUS_IVAR_BUS:
501 *result = dinfo->bus;
502 break;
503 case PS3BUS_IVAR_DEVICE:
504 *result = dinfo->dev;
505 break;
506 case PS3BUS_IVAR_BUSTYPE:
507 *result = dinfo->bustype;
508 break;
509 case PS3BUS_IVAR_DEVTYPE:
510 *result = dinfo->devtype;
511 break;
512 case PS3BUS_IVAR_BUSIDX:
513 *result = dinfo->busidx;
514 break;
515 case PS3BUS_IVAR_DEVIDX:
516 *result = dinfo->devidx;
517 break;
518 default:
519 return (EINVAL);
520 }
521
522 return (0);
523 }
524
525 static struct resource *
526 ps3bus_alloc_resource(device_t bus, device_t child, int type, int *rid,
527 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
528 {
529 struct ps3bus_devinfo *dinfo;
530 struct ps3bus_softc *sc;
531 int needactivate;
532 struct resource *rv;
533 struct rman *rm;
534 rman_res_t adjstart, adjend, adjcount;
535 struct resource_list_entry *rle;
536
537 sc = device_get_softc(bus);
538 dinfo = device_get_ivars(child);
539 needactivate = flags & RF_ACTIVE;
540 flags &= ~RF_ACTIVE;
541
542 switch (type) {
543 case SYS_RES_MEMORY:
544 rle = resource_list_find(&dinfo->resources, SYS_RES_MEMORY,
545 *rid);
546 if (rle == NULL) {
547 device_printf(bus, "no rle for %s memory %d\n",
548 device_get_nameunit(child), *rid);
549 return (NULL);
550 }
551
552 if (start < rle->start)
553 adjstart = rle->start;
554 else if (start > rle->end)
555 adjstart = rle->end;
556 else
557 adjstart = start;
558
559 if (end < rle->start)
560 adjend = rle->start;
561 else if (end > rle->end)
562 adjend = rle->end;
563 else
564 adjend = end;
565
566 adjcount = adjend - adjstart;
567
568 rm = &sc->sc_mem_rman;
569 break;
570 case SYS_RES_IRQ:
571 rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ,
572 *rid);
573 rm = &sc->sc_intr_rman;
574 adjstart = rle->start;
575 adjcount = ulmax(count, rle->count);
576 adjend = ulmax(rle->end, rle->start + adjcount - 1);
577 break;
578 default:
579 device_printf(bus, "unknown resource request from %s\n",
580 device_get_nameunit(child));
581 return (NULL);
582 }
583
584 rv = rman_reserve_resource(rm, adjstart, adjend, adjcount, flags,
585 child);
586 if (rv == NULL) {
587 device_printf(bus,
588 "failed to reserve resource %#lx - %#lx (%#lx)"
589 " for %s\n", adjstart, adjend, adjcount,
590 device_get_nameunit(child));
591 return (NULL);
592 }
593
594 rman_set_rid(rv, *rid);
595
596 if (needactivate) {
597 if (bus_activate_resource(child, type, *rid, rv) != 0) {
598 device_printf(bus,
599 "failed to activate resource for %s\n",
600 device_get_nameunit(child));
601 rman_release_resource(rv);
602 return (NULL);
603 }
604 }
605
606 return (rv);
607 }
608
609 static int
610 ps3bus_activate_resource(device_t bus, device_t child, int type, int rid,
611 struct resource *res)
612 {
613 void *p;
614
615 if (type == SYS_RES_IRQ)
616 return (bus_activate_resource(bus, type, rid, res));
617
618 if (type == SYS_RES_MEMORY) {
619 vm_offset_t start;
620
621 start = (vm_offset_t) rman_get_start(res);
622
623 if (bootverbose)
624 printf("ps3 mapdev: start %zx, len %ld\n", start,
625 rman_get_size(res));
626
627 p = pmap_mapdev(start, (vm_size_t) rman_get_size(res));
628 if (p == NULL)
629 return (ENOMEM);
630 rman_set_virtual(res, p);
631 rman_set_bustag(res, &bs_be_tag);
632 rman_set_bushandle(res, (rman_res_t)p);
633 }
634
635 return (rman_activate_resource(res));
636 }
637
638 static bus_dma_tag_t
639 ps3bus_get_dma_tag(device_t dev, device_t child)
640 {
641 struct ps3bus_devinfo *dinfo = device_get_ivars(child);
642 struct ps3bus_softc *sc = device_get_softc(dev);
643 int i, err, flags, pagesize;
644
645 if (dinfo->bustype != PS3_BUSTYPE_SYSBUS &&
646 dinfo->bustype != PS3_BUSTYPE_STORAGE)
647 return (bus_get_dma_tag(dev));
648
649 mtx_lock(&dinfo->iommu_mtx);
650 if (dinfo->dma_tag != NULL) {
651 mtx_unlock(&dinfo->iommu_mtx);
652 return (dinfo->dma_tag);
653 }
654
655 flags = 0; /* 32-bit mode */
656 if (dinfo->bustype == PS3_BUSTYPE_SYSBUS &&
657 dinfo->devtype == PS3_DEVTYPE_USB)
658 flags = 2; /* 8-bit mode */
659
660 pagesize = 24; /* log_2(16 MB) */
661 if (dinfo->bustype == PS3_BUSTYPE_STORAGE)
662 pagesize = 12; /* 4 KB */
663
664 for (i = 0; i < sc->rcount; i++) {
665 err = lv1_allocate_device_dma_region(dinfo->bus, dinfo->dev,
666 sc->regions[i].mr_size, pagesize, flags,
667 &dinfo->dma_base[i]);
668 if (err != 0) {
669 device_printf(child,
670 "could not allocate DMA region %d: %d\n", i, err);
671 goto fail;
672 }
673
674 err = lv1_map_device_dma_region(dinfo->bus, dinfo->dev,
675 sc->regions[i].mr_start, dinfo->dma_base[i],
676 sc->regions[i].mr_size,
677 0xf800000000000800UL /* Cell Handbook Figure 7.3.4.1 */);
678 if (err != 0) {
679 device_printf(child,
680 "could not map DMA region %d: %d\n", i, err);
681 goto fail;
682 }
683 }
684
685 err = bus_dma_tag_create(bus_get_dma_tag(dev),
686 1, 0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
687 NULL, NULL, BUS_SPACE_MAXSIZE, 0, BUS_SPACE_MAXSIZE,
688 0, NULL, NULL, &dinfo->dma_tag);
689
690 /*
691 * Note: storage devices have IOMMU mappings set up by the hypervisor,
692 * but use physical, non-translated addresses. The above IOMMU
693 * initialization is necessary for the hypervisor to be able to set up
694 * the mappings, but actual DMA mappings should not use the IOMMU
695 * routines.
696 */
697 if (dinfo->bustype != PS3_BUSTYPE_STORAGE)
698 bus_dma_tag_set_iommu(dinfo->dma_tag, dev, dinfo);
699
700 fail:
701 mtx_unlock(&dinfo->iommu_mtx);
702
703 if (err)
704 return (NULL);
705
706 return (dinfo->dma_tag);
707 }
708
709 static int
710 ps3_iommu_map(device_t dev, bus_dma_segment_t *segs, int *nsegs,
711 bus_addr_t min, bus_addr_t max, bus_size_t alignment, bus_addr_t boundary,
712 void *cookie)
713 {
714 struct ps3bus_devinfo *dinfo = cookie;
715 struct ps3bus_softc *sc = device_get_softc(dev);
716 int i, j;
717
718 for (i = 0; i < *nsegs; i++) {
719 for (j = 0; j < sc->rcount; j++) {
720 if (segs[i].ds_addr >= sc->regions[j].mr_start &&
721 segs[i].ds_addr < sc->regions[j].mr_start +
722 sc->regions[j].mr_size)
723 break;
724 }
725 KASSERT(j < sc->rcount,
726 ("Trying to map address %#lx not in physical memory",
727 segs[i].ds_addr));
728
729 segs[i].ds_addr = dinfo->dma_base[j] +
730 (segs[i].ds_addr - sc->regions[j].mr_start);
731 }
732
733 return (0);
734 }
735
736 static int
737 ps3_iommu_unmap(device_t dev, bus_dma_segment_t *segs, int nsegs, void *cookie)
738 {
739
740 return (0);
741 }
742
743 #define Y2K 946684800
744
745 static int
746 ps3_gettime(device_t dev, struct timespec *ts)
747 {
748 uint64_t rtc, tb;
749 int result;
750
751 result = lv1_get_rtc(&rtc, &tb);
752 if (result)
753 return (result);
754
755 ts->tv_sec = rtc + Y2K;
756 ts->tv_nsec = 0;
757 return (0);
758 }
759
760 static int
761 ps3_settime(device_t dev, struct timespec *ts)
762 {
763 return (-1);
764 }
765
Cache object: c6892e75562a29aad28f6c1020e10918
|