1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 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/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/systm.h> 35 #include <sys/fbio.h> 36 37 #include <dev/vt/vt.h> 38 #include <dev/vt/hw/fb/vt_fb.h> 39 #include <dev/vt/colors/vt_termcolors.h> 40 41 #include <vm/vm.h> 42 #include <vm/pmap.h> 43 44 #include <machine/bus.h> 45 #ifdef __sparc64__ 46 #include <machine/bus_private.h> 47 #endif 48 49 #include <dev/ofw/openfirm.h> 50 #include <dev/ofw/ofw_bus.h> 51 #include <dev/ofw/ofw_pci.h> 52 53 struct ofwfb_softc { 54 struct fb_info fb; 55 56 phandle_t sc_node; 57 ihandle_t sc_handle; 58 bus_space_tag_t sc_memt; 59 int iso_palette; 60 }; 61 62 static void ofwfb_initialize(struct vt_device *vd); 63 static vd_probe_t ofwfb_probe; 64 static vd_init_t ofwfb_init; 65 static vd_bitblt_text_t ofwfb_bitblt_text; 66 static vd_bitblt_bmp_t ofwfb_bitblt_bitmap; 67 68 static const struct vt_driver vt_ofwfb_driver = { 69 .vd_name = "ofwfb", 70 .vd_probe = ofwfb_probe, 71 .vd_init = ofwfb_init, 72 .vd_blank = vt_fb_blank, 73 .vd_bitblt_text = ofwfb_bitblt_text, 74 .vd_bitblt_bmp = ofwfb_bitblt_bitmap, 75 .vd_fb_ioctl = vt_fb_ioctl, 76 .vd_fb_mmap = vt_fb_mmap, 77 .vd_priority = VD_PRIORITY_GENERIC+1, 78 }; 79 80 static unsigned char ofw_colors[16] = { 81 /* See "16-color Text Extension" Open Firmware document, page 4 */ 82 0, 4, 2, 6, 1, 5, 3, 7, 83 8, 12, 10, 14, 9, 13, 11, 15 84 }; 85 86 static struct ofwfb_softc ofwfb_conssoftc; 87 VT_DRIVER_DECLARE(vt_ofwfb, vt_ofwfb_driver); 88 89 static int 90 ofwfb_probe(struct vt_device *vd) 91 { 92 phandle_t chosen, node; 93 ihandle_t stdout; 94 char type[64]; 95 96 chosen = OF_finddevice("/chosen"); 97 OF_getprop(chosen, "stdout", &stdout, sizeof(stdout)); 98 node = OF_instance_to_package(stdout); 99 if (node == -1) { 100 /* 101 * The "/chosen/stdout" does not exist try 102 * using "screen" directly. 103 */ 104 node = OF_finddevice("screen"); 105 } 106 OF_getprop(node, "device_type", type, sizeof(type)); 107 if (strcmp(type, "display") != 0) 108 return (CN_DEAD); 109 110 /* Looks OK... */ 111 return (CN_INTERNAL); 112 } 113 114 static void 115 ofwfb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw, 116 const uint8_t *pattern, const uint8_t *mask, 117 unsigned int width, unsigned int height, 118 unsigned int x, unsigned int y, term_color_t fg, term_color_t bg) 119 { 120 struct fb_info *sc = vd->vd_softc; 121 u_long line; 122 uint32_t fgc, bgc; 123 int c, l; 124 uint8_t b, m; 125 union { 126 uint32_t l; 127 uint8_t c[4]; 128 } ch1, ch2; 129 130 #ifdef __powerpc__ 131 /* Deal with unmapped framebuffers */ 132 if (sc->fb_flags & FB_FLAG_NOWRITE) { 133 if (pmap_bootstrapped) { 134 sc->fb_flags &= ~FB_FLAG_NOWRITE; 135 ofwfb_initialize(vd); 136 } else { 137 return; 138 } 139 } 140 #endif 141 142 fgc = sc->fb_cmap[fg]; 143 bgc = sc->fb_cmap[bg]; 144 b = m = 0; 145 146 if (((struct ofwfb_softc *)vd->vd_softc)->iso_palette) { 147 fg = ofw_colors[fg]; 148 bg = ofw_colors[bg]; 149 } 150 151 line = (sc->fb_stride * y) + x * sc->fb_bpp/8; 152 if (mask == NULL && sc->fb_bpp == 8 && (width % 8 == 0)) { 153 /* Don't try to put off screen pixels */ 154 if (((x + width) > vd->vd_width) || ((y + height) > 155 vd->vd_height)) 156 return; 157 158 for (; height > 0; height--) { 159 for (c = 0; c < width; c += 8) { 160 b = *pattern++; 161 162 /* 163 * Assume that there is more background than 164 * foreground in characters and init accordingly 165 */ 166 ch1.l = ch2.l = (bg << 24) | (bg << 16) | 167 (bg << 8) | bg; 168 169 /* 170 * Calculate 2 x 4-chars at a time, and then 171 * write these out. 172 */ 173 if (b & 0x80) ch1.c[0] = fg; 174 if (b & 0x40) ch1.c[1] = fg; 175 if (b & 0x20) ch1.c[2] = fg; 176 if (b & 0x10) ch1.c[3] = fg; 177 178 if (b & 0x08) ch2.c[0] = fg; 179 if (b & 0x04) ch2.c[1] = fg; 180 if (b & 0x02) ch2.c[2] = fg; 181 if (b & 0x01) ch2.c[3] = fg; 182 183 *(uint32_t *)(sc->fb_vbase + line + c) = ch1.l; 184 *(uint32_t *)(sc->fb_vbase + line + c + 4) = 185 ch2.l; 186 } 187 line += sc->fb_stride; 188 } 189 } else { 190 for (l = 0; 191 l < height && y + l < vw->vw_draw_area.tr_end.tp_row; 192 l++) { 193 for (c = 0; 194 c < width && x + c < vw->vw_draw_area.tr_end.tp_col; 195 c++) { 196 if (c % 8 == 0) 197 b = *pattern++; 198 else 199 b <<= 1; 200 if (mask != NULL) { 201 if (c % 8 == 0) 202 m = *mask++; 203 else 204 m <<= 1; 205 /* Skip pixel write, if mask not set. */ 206 if ((m & 0x80) == 0) 207 continue; 208 } 209 switch(sc->fb_bpp) { 210 case 8: 211 *(uint8_t *)(sc->fb_vbase + line + c) = 212 b & 0x80 ? fg : bg; 213 break; 214 case 32: 215 *(uint32_t *)(sc->fb_vbase + line + 4*c) 216 = (b & 0x80) ? fgc : bgc; 217 break; 218 default: 219 /* panic? */ 220 break; 221 } 222 } 223 line += sc->fb_stride; 224 } 225 } 226 } 227 228 void 229 ofwfb_bitblt_text(struct vt_device *vd, const struct vt_window *vw, 230 const term_rect_t *area) 231 { 232 unsigned int col, row, x, y; 233 struct vt_font *vf; 234 term_char_t c; 235 term_color_t fg, bg; 236 const uint8_t *pattern; 237 238 vf = vw->vw_font; 239 240 for (row = area->tr_begin.tp_row; row < area->tr_end.tp_row; ++row) { 241 for (col = area->tr_begin.tp_col; col < area->tr_end.tp_col; 242 ++col) { 243 x = col * vf->vf_width + 244 vw->vw_draw_area.tr_begin.tp_col; 245 y = row * vf->vf_height + 246 vw->vw_draw_area.tr_begin.tp_row; 247 248 c = VTBUF_GET_FIELD(&vw->vw_buf, row, col); 249 pattern = vtfont_lookup(vf, c); 250 vt_determine_colors(c, 251 VTBUF_ISCURSOR(&vw->vw_buf, row, col), &fg, &bg); 252 253 ofwfb_bitblt_bitmap(vd, vw, 254 pattern, NULL, vf->vf_width, vf->vf_height, 255 x, y, fg, bg); 256 } 257 } 258 259 #ifndef SC_NO_CUTPASTE 260 if (!vd->vd_mshown) 261 return; 262 263 term_rect_t drawn_area; 264 265 drawn_area.tr_begin.tp_col = area->tr_begin.tp_col * vf->vf_width; 266 drawn_area.tr_begin.tp_row = area->tr_begin.tp_row * vf->vf_height; 267 drawn_area.tr_end.tp_col = area->tr_end.tp_col * vf->vf_width; 268 drawn_area.tr_end.tp_row = area->tr_end.tp_row * vf->vf_height; 269 270 if (vt_is_cursor_in_area(vd, &drawn_area)) { 271 ofwfb_bitblt_bitmap(vd, vw, 272 vd->vd_mcursor->map, vd->vd_mcursor->mask, 273 vd->vd_mcursor->width, vd->vd_mcursor->height, 274 vd->vd_mx_drawn + vw->vw_draw_area.tr_begin.tp_col, 275 vd->vd_my_drawn + vw->vw_draw_area.tr_begin.tp_row, 276 vd->vd_mcursor_fg, vd->vd_mcursor_bg); 277 } 278 #endif 279 } 280 281 static void 282 ofwfb_initialize(struct vt_device *vd) 283 { 284 struct ofwfb_softc *sc = vd->vd_softc; 285 int i, err; 286 cell_t retval; 287 uint32_t oldpix; 288 289 sc->fb.fb_cmsize = 16; 290 291 if (sc->fb.fb_flags & FB_FLAG_NOWRITE) 292 return; 293 294 /* 295 * Set up the color map 296 */ 297 298 sc->iso_palette = 0; 299 switch (sc->fb.fb_bpp) { 300 case 8: 301 vt_generate_cons_palette(sc->fb.fb_cmap, COLOR_FORMAT_RGB, 255, 302 16, 255, 8, 255, 0); 303 304 for (i = 0; i < 16; i++) { 305 err = OF_call_method("color!", sc->sc_handle, 4, 1, 306 (cell_t)((sc->fb.fb_cmap[i] >> 16) & 0xff), 307 (cell_t)((sc->fb.fb_cmap[i] >> 8) & 0xff), 308 (cell_t)((sc->fb.fb_cmap[i] >> 0) & 0xff), 309 (cell_t)i, &retval); 310 if (err) 311 break; 312 } 313 if (i != 16) 314 sc->iso_palette = 1; 315 316 break; 317 318 case 32: 319 /* 320 * We bypass the usual bus_space_() accessors here, mostly 321 * for performance reasons. In particular, we don't want 322 * any barrier operations that may be performed and handle 323 * endianness slightly different. Figure out the host-view 324 * endianness of the frame buffer. 325 */ 326 oldpix = bus_space_read_4(sc->sc_memt, sc->fb.fb_vbase, 0); 327 bus_space_write_4(sc->sc_memt, sc->fb.fb_vbase, 0, 0xff000000); 328 if (*(uint8_t *)(sc->fb.fb_vbase) == 0xff) 329 vt_generate_cons_palette(sc->fb.fb_cmap, 330 COLOR_FORMAT_RGB, 255, 0, 255, 8, 255, 16); 331 else 332 vt_generate_cons_palette(sc->fb.fb_cmap, 333 COLOR_FORMAT_RGB, 255, 16, 255, 8, 255, 0); 334 bus_space_write_4(sc->sc_memt, sc->fb.fb_vbase, 0, oldpix); 335 break; 336 337 default: 338 panic("Unknown color space depth %d", sc->fb.fb_bpp); 339 break; 340 } 341 } 342 343 static int 344 ofwfb_init(struct vt_device *vd) 345 { 346 struct ofwfb_softc *sc; 347 char type[64]; 348 phandle_t chosen; 349 phandle_t node; 350 uint32_t depth, height, width, stride; 351 uint32_t fb_phys; 352 int i, len; 353 #ifdef __sparc64__ 354 static struct bus_space_tag ofwfb_memt[1]; 355 bus_addr_t phys; 356 int space; 357 #endif 358 359 /* Initialize softc */ 360 vd->vd_softc = sc = &ofwfb_conssoftc; 361 362 chosen = OF_finddevice("/chosen"); 363 OF_getprop(chosen, "stdout", &sc->sc_handle, sizeof(ihandle_t)); 364 node = OF_instance_to_package(sc->sc_handle); 365 if (node == -1) { 366 /* 367 * The "/chosen/stdout" does not exist try 368 * using "screen" directly. 369 */ 370 node = OF_finddevice("screen"); 371 sc->sc_handle = OF_open("screen"); 372 } 373 OF_getprop(node, "device_type", type, sizeof(type)); 374 if (strcmp(type, "display") != 0) 375 return (CN_DEAD); 376 377 /* Keep track of the OF node */ 378 sc->sc_node = node; 379 380 /* 381 * Try to use a 32-bit framebuffer if possible. This may be 382 * unimplemented and fail. That's fine -- it just means we are 383 * stuck with the defaults. 384 */ 385 OF_call_method("set-depth", sc->sc_handle, 1, 1, (cell_t)32, &i); 386 387 /* Make sure we have needed properties */ 388 if (OF_getproplen(node, "height") != sizeof(height) || 389 OF_getproplen(node, "width") != sizeof(width) || 390 OF_getproplen(node, "depth") != sizeof(depth) || 391 OF_getproplen(node, "linebytes") != sizeof(sc->fb.fb_stride)) 392 return (CN_DEAD); 393 394 /* Only support 8 and 32-bit framebuffers */ 395 OF_getprop(node, "depth", &depth, sizeof(depth)); 396 if (depth != 8 && depth != 32) 397 return (CN_DEAD); 398 sc->fb.fb_bpp = sc->fb.fb_depth = depth; 399 400 OF_getprop(node, "height", &height, sizeof(height)); 401 OF_getprop(node, "width", &width, sizeof(width)); 402 OF_getprop(node, "linebytes", &stride, sizeof(stride)); 403 404 sc->fb.fb_height = height; 405 sc->fb.fb_width = width; 406 sc->fb.fb_stride = stride; 407 sc->fb.fb_size = sc->fb.fb_height * sc->fb.fb_stride; 408 409 /* 410 * Grab the physical address of the framebuffer, and then map it 411 * into our memory space. If the MMU is not yet up, it will be 412 * remapped for us when relocation turns on. 413 */ 414 if (OF_getproplen(node, "address") == sizeof(fb_phys)) { 415 /* XXX We assume #address-cells is 1 at this point. */ 416 OF_getprop(node, "address", &fb_phys, sizeof(fb_phys)); 417 418 #if defined(__powerpc__) 419 sc->sc_memt = &bs_be_tag; 420 bus_space_map(sc->sc_memt, fb_phys, sc->fb.fb_size, 421 BUS_SPACE_MAP_PREFETCHABLE, &sc->fb.fb_vbase); 422 #elif defined(__sparc64__) 423 OF_decode_addr(node, 0, &space, &phys); 424 sc->sc_memt = &ofwfb_memt[0]; 425 sc->fb.fb_vbase = 426 sparc64_fake_bustag(space, fb_phys, sc->sc_memt); 427 #elif defined(__arm__) 428 sc->sc_memt = fdtbus_bs_tag; 429 bus_space_map(sc->sc_memt, sc->fb.fb_pbase, sc->fb.fb_size, 430 BUS_SPACE_MAP_PREFETCHABLE, 431 (bus_space_handle_t *)&sc->fb.fb_vbase); 432 #else 433 #error Unsupported platform! 434 #endif 435 436 sc->fb.fb_pbase = fb_phys; 437 } else { 438 /* 439 * Some IBM systems don't have an address property. Try to 440 * guess the framebuffer region from the assigned addresses. 441 * This is ugly, but there doesn't seem to be an alternative. 442 * Linux does the same thing. 443 */ 444 445 struct ofw_pci_register pciaddrs[8]; 446 int num_pciaddrs = 0; 447 448 /* 449 * Get the PCI addresses of the adapter, if present. The node 450 * may be the child of the PCI device: in that case, try the 451 * parent for the assigned-addresses property. 452 */ 453 len = OF_getprop(node, "assigned-addresses", pciaddrs, 454 sizeof(pciaddrs)); 455 if (len == -1) { 456 len = OF_getprop(OF_parent(node), "assigned-addresses", 457 pciaddrs, sizeof(pciaddrs)); 458 } 459 if (len == -1) 460 len = 0; 461 num_pciaddrs = len / sizeof(struct ofw_pci_register); 462 463 fb_phys = num_pciaddrs; 464 for (i = 0; i < num_pciaddrs; i++) { 465 /* If it is too small, not the framebuffer */ 466 if (pciaddrs[i].size_lo < sc->fb.fb_stride * height) 467 continue; 468 /* If it is not memory, it isn't either */ 469 if (!(pciaddrs[i].phys_hi & 470 OFW_PCI_PHYS_HI_SPACE_MEM32)) 471 continue; 472 473 /* This could be the framebuffer */ 474 fb_phys = i; 475 476 /* If it is prefetchable, it certainly is */ 477 if (pciaddrs[i].phys_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) 478 break; 479 } 480 481 if (fb_phys == num_pciaddrs) /* No candidates found */ 482 return (CN_DEAD); 483 484 #if defined(__powerpc__) 485 OF_decode_addr(node, fb_phys, &sc->sc_memt, &sc->fb.fb_vbase, 486 NULL); 487 sc->fb.fb_pbase = sc->fb.fb_vbase; /* 1:1 mapped */ 488 #ifdef __powerpc64__ 489 /* Real mode under a hypervisor probably doesn't cover FB */ 490 if (!(mfmsr() & (PSL_HV | PSL_DR))) 491 sc->fb.fb_flags |= FB_FLAG_NOWRITE; 492 #endif 493 #else 494 /* No ability to interpret assigned-addresses otherwise */ 495 return (CN_DEAD); 496 #endif 497 } 498 499 500 ofwfb_initialize(vd); 501 vt_fb_init(vd); 502 503 return (CN_INTERNAL); 504 } 505 506