1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2011 Nathan Whitehorn
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/param.h>
30#include <sys/kernel.h>
31#include <sys/systm.h>
32#include <sys/fbio.h>
33
34#include <dev/vt/vt.h>
35#include <dev/vt/hw/fb/vt_fb.h>
36#include <dev/vt/colors/vt_termcolors.h>
37
38#include <vm/vm.h>
39#include <vm/pmap.h>
40
41#include <machine/bus.h>
42#include <machine/cpu.h>
43
44#include <dev/ofw/openfirm.h>
45#include <dev/ofw/ofw_bus.h>
46#include <dev/ofw/ofw_pci.h>
47#include <dev/ofw/ofw_subr.h>
48
49struct ofwfb_softc {
50	struct fb_info	fb;
51
52	phandle_t	sc_node;
53	ihandle_t	sc_handle;
54	bus_space_tag_t	sc_memt;
55	int		iso_palette;
56	int		argb;
57	int		endian_flip;
58	uint32_t	vendor_id;
59};
60
61#define PCI_VID_NVIDIA	0x10de	/* NVIDIA Corporation */
62#define PCI_VID_ASPEED	0x1a03	/* ASPEED Technology, Inc. */
63
64static void ofwfb_initialize(struct vt_device *vd);
65static vd_probe_t	ofwfb_probe;
66static vd_init_t	ofwfb_init;
67static vd_bitblt_text_t	ofwfb_bitblt_text;
68static vd_bitblt_bmp_t	ofwfb_bitblt_bitmap;
69
70static const struct vt_driver vt_ofwfb_driver = {
71	.vd_name	= "ofwfb",
72	.vd_probe	= ofwfb_probe,
73	.vd_init	= ofwfb_init,
74	.vd_blank	= vt_fb_blank,
75	.vd_bitblt_text	= ofwfb_bitblt_text,
76	.vd_bitblt_bmp	= ofwfb_bitblt_bitmap,
77	.vd_fb_ioctl	= vt_fb_ioctl,
78	.vd_fb_mmap	= vt_fb_mmap,
79	.vd_priority	= VD_PRIORITY_GENERIC+1,
80};
81
82static unsigned char ofw_colors[16] = {
83	/* See "16-color Text Extension" Open Firmware document, page 4 */
84	0, 4, 2, 6, 1, 5, 3, 7,
85	8, 12, 10, 14, 9, 13, 11, 15
86};
87
88static struct ofwfb_softc ofwfb_conssoftc;
89VT_DRIVER_DECLARE(vt_ofwfb, vt_ofwfb_driver);
90
91static int
92ofwfb_probe(struct vt_device *vd)
93{
94	int disabled;
95	phandle_t chosen, node;
96	ihandle_t stdout;
97	char buf[64];
98
99	disabled = 0;
100	TUNABLE_INT_FETCH("hw.ofwfb.disable", &disabled);
101	if (disabled)
102		return (CN_DEAD);
103
104	chosen = OF_finddevice("/chosen");
105	if (chosen == -1)
106		return (CN_DEAD);
107
108	node = -1;
109	if (OF_getencprop(chosen, "stdout", &stdout, sizeof(stdout)) ==
110	    sizeof(stdout))
111		node = OF_instance_to_package(stdout);
112	if (node == -1)
113		if (OF_getprop(chosen, "stdout-path", buf, sizeof(buf)) > 0)
114			node = OF_finddevice(buf);
115	if (node == -1) {
116		/*
117		 * The "/chosen/stdout" does not exist try
118		 * using "screen" directly.
119		 */
120		node = OF_finddevice("screen");
121	}
122	OF_getprop(node, "device_type", buf, sizeof(buf));
123	if (strcmp(buf, "display") != 0)
124		return (CN_DEAD);
125
126	/* Looks OK... */
127	return (CN_INTERNAL);
128}
129
130static void
131ofwfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw,
132    const uint8_t *pattern, const uint8_t *mask,
133    unsigned int width, unsigned int height,
134    unsigned int x, unsigned int y, term_color_t fg, term_color_t bg)
135{
136	struct fb_info *sc = vd->vd_softc;
137	u_long line;
138	uint32_t fgc, bgc;
139	int c, l;
140	uint8_t b, m;
141	union {
142		uint32_t l;
143		uint8_t	 c[4];
144	} ch1, ch2;
145
146#ifdef __powerpc__
147	/* Deal with unmapped framebuffers */
148	if (sc->fb_flags & FB_FLAG_NOWRITE) {
149		if (pmap_bootstrapped) {
150			sc->fb_flags &= ~FB_FLAG_NOWRITE;
151			ofwfb_initialize(vd);
152			vd->vd_driver->vd_blank(vd, TC_BLACK);
153		} else {
154			return;
155		}
156	}
157#endif
158
159	fgc = sc->fb_cmap[fg];
160	bgc = sc->fb_cmap[bg];
161	b = m = 0;
162
163	if (((struct ofwfb_softc *)vd->vd_softc)->iso_palette) {
164		fg = ofw_colors[fg];
165		bg = ofw_colors[bg];
166	}
167
168	line = (sc->fb_stride * y) + x * sc->fb_bpp/8;
169	if (mask == NULL && sc->fb_bpp == 8 && (width % 8 == 0)) {
170		/* Don't try to put off screen pixels */
171		if (((x + width) > vd->vd_width) || ((y + height) >
172		    vd->vd_height))
173			return;
174
175		for (; height > 0; height--) {
176			for (c = 0; c < width; c += 8) {
177				b = *pattern++;
178
179				/*
180				 * Assume that there is more background than
181				 * foreground in characters and init accordingly
182				 */
183				ch1.l = ch2.l = (bg << 24) | (bg << 16) |
184				    (bg << 8) | bg;
185
186				/*
187				 * Calculate 2 x 4-chars at a time, and then
188				 * write these out.
189				 */
190				if (b & 0x80) ch1.c[0] = fg;
191				if (b & 0x40) ch1.c[1] = fg;
192				if (b & 0x20) ch1.c[2] = fg;
193				if (b & 0x10) ch1.c[3] = fg;
194
195				if (b & 0x08) ch2.c[0] = fg;
196				if (b & 0x04) ch2.c[1] = fg;
197				if (b & 0x02) ch2.c[2] = fg;
198				if (b & 0x01) ch2.c[3] = fg;
199
200				*(uint32_t *)(sc->fb_vbase + line + c) = ch1.l;
201				*(uint32_t *)(sc->fb_vbase + line + c + 4) =
202				    ch2.l;
203			}
204			line += sc->fb_stride;
205		}
206	} else {
207		for (l = 0;
208		    l < height && y + l < vw->vw_draw_area.tr_end.tp_row;
209		    l++) {
210			for (c = 0;
211			    c < width && x + c < vw->vw_draw_area.tr_end.tp_col;
212			    c++) {
213				if (c % 8 == 0)
214					b = *pattern++;
215				else
216					b <<= 1;
217				if (mask != NULL) {
218					if (c % 8 == 0)
219						m = *mask++;
220					else
221						m <<= 1;
222					/* Skip pixel write, if mask not set. */
223					if ((m & 0x80) == 0)
224						continue;
225				}
226				switch(sc->fb_bpp) {
227				case 8:
228					*(uint8_t *)(sc->fb_vbase + line + c) =
229					    b & 0x80 ? fg : bg;
230					break;
231				case 32:
232					*(uint32_t *)(sc->fb_vbase + line + 4*c)
233					    = (b & 0x80) ? fgc : bgc;
234					break;
235				default:
236					/* panic? */
237					break;
238				}
239			}
240			line += sc->fb_stride;
241		}
242	}
243}
244
245void
246ofwfb_bitblt_text(struct vt_device *vd, const struct vt_window *vw,
247    const term_rect_t *area)
248{
249	unsigned int col, row, x, y;
250	struct vt_font *vf;
251	term_char_t c;
252	term_color_t fg, bg;
253	const uint8_t *pattern;
254
255	vf = vw->vw_font;
256
257	for (row = area->tr_begin.tp_row; row < area->tr_end.tp_row; ++row) {
258		for (col = area->tr_begin.tp_col; col < area->tr_end.tp_col;
259		    ++col) {
260			x = col * vf->vf_width +
261			    vw->vw_draw_area.tr_begin.tp_col;
262			y = row * vf->vf_height +
263			    vw->vw_draw_area.tr_begin.tp_row;
264
265			c = VTBUF_GET_FIELD(&vw->vw_buf, row, col);
266			pattern = vtfont_lookup(vf, c);
267			vt_determine_colors(c,
268			    VTBUF_ISCURSOR(&vw->vw_buf, row, col), &fg, &bg);
269
270			ofwfb_bitblt_bitmap(vd, vw,
271			    pattern, NULL, vf->vf_width, vf->vf_height,
272			    x, y, fg, bg);
273		}
274	}
275
276#ifndef SC_NO_CUTPASTE
277	if (!vd->vd_mshown)
278		return;
279
280	term_rect_t drawn_area;
281
282	drawn_area.tr_begin.tp_col = area->tr_begin.tp_col * vf->vf_width;
283	drawn_area.tr_begin.tp_row = area->tr_begin.tp_row * vf->vf_height;
284	drawn_area.tr_end.tp_col = area->tr_end.tp_col * vf->vf_width;
285	drawn_area.tr_end.tp_row = area->tr_end.tp_row * vf->vf_height;
286
287	if (vt_is_cursor_in_area(vd, &drawn_area)) {
288		ofwfb_bitblt_bitmap(vd, vw,
289		    vd->vd_mcursor->map, vd->vd_mcursor->mask,
290		    vd->vd_mcursor->width, vd->vd_mcursor->height,
291		    vd->vd_mx_drawn + vw->vw_draw_area.tr_begin.tp_col,
292		    vd->vd_my_drawn + vw->vw_draw_area.tr_begin.tp_row,
293		    vd->vd_mcursor_fg, vd->vd_mcursor_bg);
294	}
295#endif
296}
297
298
299/*
300 * Decode OpenFirmware/IEEE 1275-1994 "ranges" property
301 *
302 * XXX: this is similar to ofw_pcib_fill_ranges but cannot use it here because
303 *      it's not possible to allocate memory at the moment this is funcion is
304 *      used. Since there are other similar functions dealing with "ranges"
305 *      property, a proper refactoring is suggested.
306 */
307static uint64_t
308decode_pci_ranges_host_addr(phandle_t pcinode)
309{
310	struct simplebus_range {
311		uint64_t bus;
312		uint64_t host;
313		uint64_t size;
314	};
315
316	struct simplebus_range ranges[4];
317	int nranges, host_address_cells;
318	pcell_t acells, scells;
319	cell_t base_ranges[64];
320
321	ssize_t nbase_ranges;
322	int i, j, k;
323
324	if (!OF_hasprop(pcinode, "ranges"))
325		return (0);
326
327	if (OF_getencprop(pcinode, "#address-cells", &acells, sizeof(acells)) !=
328	    sizeof(acells))
329		return (0);
330
331	if (OF_getencprop(pcinode, "#size-cells", &scells, sizeof(scells)) !=
332		sizeof(scells))
333		return (0);
334
335	if (OF_searchencprop(OF_parent(pcinode), "#address-cells",
336		&host_address_cells, sizeof(host_address_cells)) !=
337		sizeof(host_address_cells))
338		return (0);
339
340	nbase_ranges = OF_getproplen(pcinode, "ranges");
341	nranges = nbase_ranges / sizeof(cell_t) / (acells + host_address_cells + scells);
342
343	/* prevent buffer overflow during iteration */
344	if (nranges > sizeof(ranges) / sizeof(ranges[0]))
345		nranges = sizeof(ranges) / sizeof(ranges[0]);
346
347	/* decode range value and return the first valid address */
348	OF_getencprop(pcinode, "ranges", base_ranges, nbase_ranges);
349	for (i = 0, j = 0; i < nranges; i++) {
350		ranges[i].bus = 0;
351		for (k = 0; k < acells; k++) {
352			ranges[i].bus <<= 32;
353			ranges[i].bus |= base_ranges[j++];
354		}
355
356		ranges[i].host = 0;
357		for (k = 0; k < host_address_cells; k++) {
358			ranges[i].host <<= 32;
359			ranges[i].host |= base_ranges[j++];
360		}
361		ranges[i].size = 0;
362		for (k = 0; k < scells; k++) {
363			ranges[i].size <<= 32;
364			ranges[i].size |= base_ranges[j++];
365		}
366
367		if (ranges[i].host != 0)
368			return (ranges[i].host);
369	}
370
371	return (0);
372}
373
374static bus_addr_t
375find_pci_host_address(phandle_t node)
376{
377	uint64_t addr;
378
379	/*
380	 * According to IEEE STD 1275, if property "ranges" exists but has a
381	 * zero-length property value, the child address space is identical
382	 * to the parent address space.
383	 */
384	while (node) {
385		if (OF_hasprop(node, "ranges")) {
386			addr = decode_pci_ranges_host_addr(node);
387			if (addr != 0)
388				return ((bus_addr_t)addr);
389		}
390		node = OF_parent(node);
391	}
392
393	return (0);
394}
395
396static void
397ofwfb_initialize(struct vt_device *vd)
398{
399	struct ofwfb_softc *sc = vd->vd_softc;
400	int i, err, r, g, b;
401	cell_t retval;
402
403	sc->fb.fb_cmsize = 16;
404
405	if (sc->fb.fb_flags & FB_FLAG_NOWRITE)
406		return;
407
408	/*
409	 * Set up the color map
410	 */
411
412	sc->iso_palette = 0;
413	switch (sc->fb.fb_bpp) {
414	case 8:
415		/*
416		 * No color format issues here, since we are passing the RGB
417		 * components separately to Open Firmware.
418		 */
419		vt_config_cons_colors(&sc->fb, COLOR_FORMAT_RGB, 255,
420		    16, 255, 8, 255, 0);
421
422		for (i = 0; i < 16; i++) {
423			err = OF_call_method("color!", sc->sc_handle, 4, 1,
424			    (cell_t)((sc->fb.fb_cmap[i] >> 16) & 0xff),
425			    (cell_t)((sc->fb.fb_cmap[i] >> 8) & 0xff),
426			    (cell_t)((sc->fb.fb_cmap[i] >> 0) & 0xff),
427			    (cell_t)i, &retval);
428			if (err)
429				break;
430		}
431		if (i != 16)
432			sc->iso_palette = 1;
433
434		break;
435
436	case 32:
437		/*
438		 * There are two main color formats in use.
439		 * ARGB32 is used mainly on hardware that was designed for
440		 * LE systems, and RGBA32 is used mainly on hardware designed
441		 * for BE systems.
442		 *
443		 * PowerMacs use either, depending on the video card option.
444		 * NVidia cards tend to be RGBA32, and ATI cards tend to be ARGB32.
445		 *
446		 * There is no good way to determine the correct option, as this
447		 * is independent of endian swapping.
448		 */
449		if (sc->vendor_id == PCI_VID_NVIDIA)
450			sc->argb = 0;
451		else
452			sc->argb = 1;
453
454		TUNABLE_INT_FETCH("hw.ofwfb.argb32_pixel", &sc->argb);
455		if (sc->endian_flip) {
456			if (sc->argb)
457				r = 8, g = 16, b = 24;
458			else
459				r = 24, g = 16, b = 8;
460		} else {
461			if (sc->argb)
462				r = 16, g = 8, b = 0;
463			else
464				r = 0, g = 8, b = 16;
465		}
466		vt_config_cons_colors(&sc->fb,
467		    COLOR_FORMAT_RGB, 255, r, 255, g, 255, b);
468		break;
469
470	default:
471		panic("Unknown color space depth %d", sc->fb.fb_bpp);
472		break;
473        }
474}
475
476static int
477ofwfb_init(struct vt_device *vd)
478{
479	struct ofwfb_softc *sc;
480	char buf[64];
481	phandle_t chosen;
482	phandle_t node;
483	pcell_t depth, height, width, stride;
484	uint32_t vendor_id = 0;
485	cell_t adr[2];
486	uint64_t user_phys;
487	bus_addr_t fb_phys;
488	bus_size_t fb_phys_size;
489	int i, j, len;
490
491	/* Initialize softc */
492	vd->vd_softc = sc = &ofwfb_conssoftc;
493
494	node = -1;
495	chosen = OF_finddevice("/chosen");
496	if (OF_getencprop(chosen, "stdout", &sc->sc_handle,
497	    sizeof(ihandle_t)) == sizeof(ihandle_t))
498		node = OF_instance_to_package(sc->sc_handle);
499	if (node == -1)
500		/* Try "/chosen/stdout-path" now */
501		if (OF_getprop(chosen, "stdout-path", buf, sizeof(buf)) > 0) {
502			node = OF_finddevice(buf);
503			if (node != -1)
504				sc->sc_handle = OF_open(buf);
505		}
506	if (node == -1) {
507		/*
508		 * The "/chosen/stdout" does not exist try
509		 * using "screen" directly.
510		 */
511		node = OF_finddevice("screen");
512		sc->sc_handle = OF_open("screen");
513	}
514	OF_getprop(node, "device_type", buf, sizeof(buf));
515	if (strcmp(buf, "display") != 0)
516		return (CN_DEAD);
517
518	/*
519	 * Retrieve vendor-id from /chosen parent node, usually pointing to
520	 * video card device. This is used to select pixel format later on
521	 * ofwfb_initialize()
522	 */
523	if (OF_getencprop(OF_parent(node), "vendor-id", &vendor_id,
524	    sizeof(vendor_id)) == sizeof(vendor_id))
525		sc->vendor_id = vendor_id;
526
527	/* Keep track of the OF node */
528	sc->sc_node = node;
529
530	/*
531	 * Try to use a 32-bit framebuffer if possible. This may be
532	 * unimplemented and fail. That's fine -- it just means we are
533	 * stuck with the defaults.
534	 */
535	OF_call_method("set-depth", sc->sc_handle, 1, 1, (cell_t)32, &i);
536
537	/* Make sure we have needed properties */
538	if (OF_getproplen(node, "height") != sizeof(height) ||
539	    OF_getproplen(node, "width") != sizeof(width) ||
540	    OF_getproplen(node, "depth") != sizeof(depth))
541		return (CN_DEAD);
542
543	/* Only support 8 and 32-bit framebuffers */
544	OF_getencprop(node, "depth", &depth, sizeof(depth));
545	if (depth != 8 && depth != 32)
546		return (CN_DEAD);
547	sc->fb.fb_bpp = sc->fb.fb_depth = depth;
548
549	OF_getencprop(node, "height", &height, sizeof(height));
550	OF_getencprop(node, "width", &width, sizeof(width));
551	if (OF_getencprop(node, "linebytes", &stride, sizeof(stride)) !=
552	    sizeof(stride))
553		stride = width*depth/8;
554
555
556	sc->fb.fb_height = height;
557	sc->fb.fb_width = width;
558	sc->fb.fb_stride = stride;
559	sc->fb.fb_size = sc->fb.fb_height * sc->fb.fb_stride;
560	sc->endian_flip = 0;
561
562#if defined(__powerpc__)
563	if (OF_hasprop(node, "little-endian")) {
564		sc->sc_memt = &bs_le_tag;
565#if BYTE_ORDER == BIG_ENDIAN
566		sc->endian_flip = 1;
567#endif
568        } else if (OF_hasprop(node, "big-endian")) {
569		sc->sc_memt = &bs_be_tag;
570#if BYTE_ORDER == LITTLE_ENDIAN
571		sc->endian_flip = 1;
572#endif
573	}
574	else {
575		/* Assume the framebuffer is in native endian. */
576#if BYTE_ORDER == BIG_ENDIAN
577		sc->sc_memt = &bs_be_tag;
578#else
579		sc->sc_memt = &bs_le_tag;
580#endif
581	}
582#elif defined(__arm__)
583	sc->sc_memt = fdtbus_bs_tag;
584#else
585	#error Unsupported platform!
586#endif
587
588
589	/*
590	 * Grab the physical address of the framebuffer, and then map it
591	 * into our memory space. If the MMU is not yet up, it will be
592	 * remapped for us when relocation turns on.
593	 *
594	 * The ASPEED driver on recent petitboot versions doesn't expose the
595	 * physical address of framebuffer anymore for security. So it should
596	 * retrieve the address from PCI device properties.
597	 */
598	user_phys = 0;
599	TUNABLE_UINT64_FETCH("hw.ofwfb.physaddr", &user_phys);
600
601	if (user_phys)
602		sc->fb.fb_pbase = (vm_paddr_t)user_phys;
603	else if (sc->vendor_id == PCI_VID_ASPEED)
604		sc->fb.fb_pbase = find_pci_host_address(node);
605	else if (OF_hasprop(node, "address")) {
606
607		switch (OF_getproplen(node, "address")) {
608		case 4:
609			OF_getencprop(node, "address", adr, 4);
610			fb_phys = adr[0];
611			break;
612		case 8:
613			OF_getencprop(node, "address", adr, 8);
614			fb_phys = ((uint64_t)adr[0] << 32) | adr[1];
615			break;
616		default:
617			/* Bad property? */
618			return (CN_DEAD);
619		}
620
621		sc->fb.fb_pbase = (vm_paddr_t)fb_phys;
622	} else {
623#if defined(__powerpc__)
624		/*
625		 * Some IBM systems don't have an address property. Try to
626		 * guess the framebuffer region from the assigned addresses.
627		 * This is ugly, but there doesn't seem to be an alternative.
628		 * Linux does the same thing.
629		 */
630
631		struct ofw_pci_register pciaddrs[8];
632		int num_pciaddrs = 0;
633
634		/*
635		 * Get the PCI addresses of the adapter, if present. The node
636		 * may be the child of the PCI device: in that case, try the
637		 * parent for the assigned-addresses property.
638		 */
639		len = OF_getencprop(node, "assigned-addresses",
640		    (pcell_t *)pciaddrs, sizeof(pciaddrs));
641		if (len == -1) {
642			len = OF_getencprop(OF_parent(node), "assigned-addresses",
643			    (pcell_t *)pciaddrs, sizeof(pciaddrs));
644		}
645		if (len == -1)
646			len = 0;
647		num_pciaddrs = len / sizeof(struct ofw_pci_register);
648
649		j = num_pciaddrs;
650		for (i = 0; i < num_pciaddrs; i++) {
651			/* If it is too small, not the framebuffer */
652			if (pciaddrs[i].size_lo < sc->fb.fb_stride * height)
653				continue;
654			/* If it is not memory, it isn't either */
655			if (!(pciaddrs[i].phys_hi &
656			    OFW_PCI_PHYS_HI_SPACE_MEM32))
657				continue;
658
659			/* This could be the framebuffer */
660			j = i;
661
662			/* If it is prefetchable, it certainly is */
663			if (pciaddrs[i].phys_hi & OFW_PCI_PHYS_HI_PREFETCHABLE)
664				break;
665		}
666
667		if (j == num_pciaddrs) /* No candidates found */
668			return (CN_DEAD);
669
670		if (ofw_reg_to_paddr(node, j, &fb_phys, &fb_phys_size, NULL) < 0)
671			return (CN_DEAD);
672
673		sc->fb.fb_pbase = (vm_paddr_t)fb_phys;
674#else
675		/* No ability to interpret assigned-addresses otherwise */
676		return (CN_DEAD);
677#endif
678        }
679
680	if (!sc->fb.fb_pbase)
681		return (CN_DEAD);
682
683	bus_space_map(sc->sc_memt, sc->fb.fb_pbase, sc->fb.fb_size,
684	    BUS_SPACE_MAP_PREFETCHABLE,
685	    (bus_space_handle_t *)&sc->fb.fb_vbase);
686
687	#if defined(__powerpc__)
688	/*
689	 * If we are running on PowerPC in real mode (supported only on AIM
690	 * CPUs), the frame buffer may be inaccessible (real mode does not
691	 * necessarily cover all RAM) and may also be mapped with the wrong
692	 * cache properties (all real mode accesses are assumed cacheable).
693	 * Just don't write to it for the time being.
694	 */
695	if (!(cpu_features & PPC_FEATURE_BOOKE) && !(mfmsr() & PSL_DR))
696		sc->fb.fb_flags |= FB_FLAG_NOWRITE;
697	#endif
698	ofwfb_initialize(vd);
699	vt_fb_init(vd);
700
701	return (CN_INTERNAL);
702}
703