1 /*- 2 * Copyright (c) 2013 The FreeBSD Foundation 3 * All rights reserved. 4 * 5 * This software was developed by Aleksandr Rybalko under sponsorship from the 6 * FreeBSD Foundation. 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 AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/malloc.h> 38 #include <sys/queue.h> 39 #include <sys/fbio.h> 40 #include <dev/vt/vt.h> 41 #include <dev/vt/hw/fb/vt_fb.h> 42 #include <dev/vt/colors/vt_termcolors.h> 43 44 static struct vt_driver vt_fb_driver = { 45 .vd_name = "fb", 46 .vd_init = vt_fb_init, 47 .vd_blank = vt_fb_blank, 48 .vd_bitblt_text = vt_fb_bitblt_text, 49 .vd_bitblt_bmp = vt_fb_bitblt_bitmap, 50 .vd_drawrect = vt_fb_drawrect, 51 .vd_setpixel = vt_fb_setpixel, 52 .vd_postswitch = vt_fb_postswitch, 53 .vd_priority = VD_PRIORITY_GENERIC+10, 54 .vd_fb_ioctl = vt_fb_ioctl, 55 .vd_fb_mmap = vt_fb_mmap, 56 }; 57 58 VT_DRIVER_DECLARE(vt_fb, vt_fb_driver); 59 60 static void 61 vt_fb_mem_wr1(struct fb_info *sc, uint32_t o, uint8_t v) 62 { 63 64 KASSERT((o < sc->fb_size), ("Offset %#08x out of fb size", o)); 65 *(uint8_t *)(sc->fb_vbase + o) = v; 66 } 67 68 static void 69 vt_fb_mem_wr2(struct fb_info *sc, uint32_t o, uint16_t v) 70 { 71 72 KASSERT((o < sc->fb_size), ("Offset %#08x out of fb size", o)); 73 *(uint16_t *)(sc->fb_vbase + o) = v; 74 } 75 76 static void 77 vt_fb_mem_wr4(struct fb_info *sc, uint32_t o, uint32_t v) 78 { 79 80 KASSERT((o < sc->fb_size), ("Offset %#08x out of fb size", o)); 81 *(uint32_t *)(sc->fb_vbase + o) = v; 82 } 83 84 int 85 vt_fb_ioctl(struct vt_device *vd, u_long cmd, caddr_t data, struct thread *td) 86 { 87 struct fb_info *info; 88 int error = 0; 89 90 info = vd->vd_softc; 91 92 switch (cmd) { 93 case FBIOGTYPE: 94 bcopy(info, (struct fbtype *)data, sizeof(struct fbtype)); 95 break; 96 97 case FBIO_GETWINORG: /* get frame buffer window origin */ 98 *(u_int *)data = 0; 99 break; 100 101 case FBIO_GETDISPSTART: /* get display start address */ 102 ((video_display_start_t *)data)->x = 0; 103 ((video_display_start_t *)data)->y = 0; 104 break; 105 106 case FBIO_GETLINEWIDTH: /* get scan line width in bytes */ 107 *(u_int *)data = info->fb_stride; 108 break; 109 110 case FBIO_BLANK: /* blank display */ 111 if (vd->vd_driver->vd_blank == NULL) 112 return (ENODEV); 113 vd->vd_driver->vd_blank(vd, TC_BLACK); 114 break; 115 116 default: 117 error = ENOIOCTL; 118 break; 119 } 120 121 return (error); 122 } 123 124 int 125 vt_fb_mmap(struct vt_device *vd, vm_ooffset_t offset, vm_paddr_t *paddr, 126 int prot, vm_memattr_t *memattr) 127 { 128 struct fb_info *info; 129 130 info = vd->vd_softc; 131 132 if (info->fb_flags & FB_FLAG_NOMMAP) 133 return (ENODEV); 134 135 if (offset >= 0 && offset < info->fb_size) { 136 *paddr = info->fb_pbase + offset; 137 #ifdef VM_MEMATTR_WRITE_COMBINING 138 *memattr = VM_MEMATTR_WRITE_COMBINING; 139 #endif 140 return (0); 141 } 142 143 return (EINVAL); 144 } 145 146 void 147 vt_fb_setpixel(struct vt_device *vd, int x, int y, term_color_t color) 148 { 149 struct fb_info *info; 150 uint32_t c; 151 u_int o; 152 153 info = vd->vd_softc; 154 c = info->fb_cmap[color]; 155 o = info->fb_stride * y + x * FBTYPE_GET_BYTESPP(info); 156 157 if (info->fb_flags & FB_FLAG_NOWRITE) 158 return; 159 160 KASSERT((info->fb_vbase != 0), ("Unmapped framebuffer")); 161 162 switch (FBTYPE_GET_BYTESPP(info)) { 163 case 1: 164 vt_fb_mem_wr1(info, o, c); 165 break; 166 case 2: 167 vt_fb_mem_wr2(info, o, c); 168 break; 169 case 3: 170 vt_fb_mem_wr1(info, o, (c >> 16) & 0xff); 171 vt_fb_mem_wr1(info, o + 1, (c >> 8) & 0xff); 172 vt_fb_mem_wr1(info, o + 2, c & 0xff); 173 break; 174 case 4: 175 vt_fb_mem_wr4(info, o, c); 176 break; 177 default: 178 /* panic? */ 179 return; 180 } 181 182 } 183 184 void 185 vt_fb_drawrect(struct vt_device *vd, int x1, int y1, int x2, int y2, int fill, 186 term_color_t color) 187 { 188 int x, y; 189 190 for (y = y1; y <= y2; y++) { 191 if (fill || (y == y1) || (y == y2)) { 192 for (x = x1; x <= x2; x++) 193 vt_fb_setpixel(vd, x, y, color); 194 } else { 195 vt_fb_setpixel(vd, x1, y, color); 196 vt_fb_setpixel(vd, x2, y, color); 197 } 198 } 199 } 200 201 void 202 vt_fb_blank(struct vt_device *vd, term_color_t color) 203 { 204 struct fb_info *info; 205 uint32_t c; 206 u_int o, h; 207 208 info = vd->vd_softc; 209 c = info->fb_cmap[color]; 210 211 if (info->fb_flags & FB_FLAG_NOWRITE) 212 return; 213 214 KASSERT((info->fb_vbase != 0), ("Unmapped framebuffer")); 215 216 switch (FBTYPE_GET_BYTESPP(info)) { 217 case 1: 218 for (h = 0; h < info->fb_height; h++) 219 for (o = 0; o < info->fb_stride; o++) 220 vt_fb_mem_wr1(info, h*info->fb_stride + o, c); 221 break; 222 case 2: 223 for (h = 0; h < info->fb_height; h++) 224 for (o = 0; o < info->fb_stride; o += 2) 225 vt_fb_mem_wr2(info, h*info->fb_stride + o, c); 226 break; 227 case 3: 228 for (h = 0; h < info->fb_height; h++) 229 for (o = 0; o < info->fb_stride; o += 3) { 230 vt_fb_mem_wr1(info, h*info->fb_stride + o, 231 (c >> 16) & 0xff); 232 vt_fb_mem_wr1(info, h*info->fb_stride + o + 1, 233 (c >> 8) & 0xff); 234 vt_fb_mem_wr1(info, h*info->fb_stride + o + 2, 235 c & 0xff); 236 } 237 break; 238 case 4: 239 for (h = 0; h < info->fb_height; h++) 240 for (o = 0; o < info->fb_stride; o += 4) 241 vt_fb_mem_wr4(info, h*info->fb_stride + o, c); 242 break; 243 default: 244 /* panic? */ 245 return; 246 } 247 } 248 249 void 250 vt_fb_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw, 251 const uint8_t *pattern, const uint8_t *mask, 252 unsigned int width, unsigned int height, 253 unsigned int x, unsigned int y, term_color_t fg, term_color_t bg) 254 { 255 struct fb_info *info; 256 uint32_t fgc, bgc, cc, o; 257 int c, l, bpp, bpl; 258 u_long line; 259 uint8_t b, m; 260 const uint8_t *ch; 261 262 info = vd->vd_softc; 263 bpp = FBTYPE_GET_BYTESPP(info); 264 fgc = info->fb_cmap[fg]; 265 bgc = info->fb_cmap[bg]; 266 b = m = 0; 267 bpl = (width + 7) >> 3; /* Bytes per source line. */ 268 269 if (info->fb_flags & FB_FLAG_NOWRITE) 270 return; 271 272 KASSERT((info->fb_vbase != 0), ("Unmapped framebuffer")); 273 274 line = (info->fb_stride * y) + (x * bpp); 275 for (l = 0; 276 l < height && y + l < vw->vw_draw_area.tr_end.tp_row; 277 l++) { 278 ch = pattern; 279 for (c = 0; 280 c < width && x + c < vw->vw_draw_area.tr_end.tp_col; 281 c++) { 282 if (c % 8 == 0) 283 b = *ch++; 284 else 285 b <<= 1; 286 if (mask != NULL) { 287 if (c % 8 == 0) 288 m = *mask++; 289 else 290 m <<= 1; 291 /* Skip pixel write, if mask has no bit set. */ 292 if ((m & 0x80) == 0) 293 continue; 294 } 295 o = line + (c * bpp); 296 cc = b & 0x80 ? fgc : bgc; 297 298 switch(bpp) { 299 case 1: 300 vt_fb_mem_wr1(info, o, cc); 301 break; 302 case 2: 303 vt_fb_mem_wr2(info, o, cc); 304 break; 305 case 3: 306 /* Packed mode, so unaligned. Byte access. */ 307 vt_fb_mem_wr1(info, o, (cc >> 16) & 0xff); 308 vt_fb_mem_wr1(info, o + 1, (cc >> 8) & 0xff); 309 vt_fb_mem_wr1(info, o + 2, cc & 0xff); 310 break; 311 case 4: 312 vt_fb_mem_wr4(info, o, cc); 313 break; 314 default: 315 /* panic? */ 316 break; 317 } 318 } 319 line += info->fb_stride; 320 pattern += bpl; 321 } 322 } 323 324 void 325 vt_fb_bitblt_text(struct vt_device *vd, const struct vt_window *vw, 326 const term_rect_t *area) 327 { 328 unsigned int col, row, x, y; 329 struct vt_font *vf; 330 term_char_t c; 331 term_color_t fg, bg; 332 const uint8_t *pattern; 333 334 vf = vw->vw_font; 335 336 for (row = area->tr_begin.tp_row; row < area->tr_end.tp_row; ++row) { 337 for (col = area->tr_begin.tp_col; col < area->tr_end.tp_col; 338 ++col) { 339 x = col * vf->vf_width + 340 vw->vw_draw_area.tr_begin.tp_col; 341 y = row * vf->vf_height + 342 vw->vw_draw_area.tr_begin.tp_row; 343 344 c = VTBUF_GET_FIELD(&vw->vw_buf, row, col); 345 pattern = vtfont_lookup(vf, c); 346 vt_determine_colors(c, 347 VTBUF_ISCURSOR(&vw->vw_buf, row, col), &fg, &bg); 348 349 vt_fb_bitblt_bitmap(vd, vw, 350 pattern, NULL, vf->vf_width, vf->vf_height, 351 x, y, fg, bg); 352 } 353 } 354 355 #ifndef SC_NO_CUTPASTE 356 if (!vd->vd_mshown) 357 return; 358 359 term_rect_t drawn_area; 360 361 drawn_area.tr_begin.tp_col = area->tr_begin.tp_col * vf->vf_width; 362 drawn_area.tr_begin.tp_row = area->tr_begin.tp_row * vf->vf_height; 363 drawn_area.tr_end.tp_col = area->tr_end.tp_col * vf->vf_width; 364 drawn_area.tr_end.tp_row = area->tr_end.tp_row * vf->vf_height; 365 366 if (vt_is_cursor_in_area(vd, &drawn_area)) { 367 vt_fb_bitblt_bitmap(vd, vw, 368 vd->vd_mcursor->map, vd->vd_mcursor->mask, 369 vd->vd_mcursor->width, vd->vd_mcursor->height, 370 vd->vd_mx_drawn + vw->vw_draw_area.tr_begin.tp_col, 371 vd->vd_my_drawn + vw->vw_draw_area.tr_begin.tp_row, 372 vd->vd_mcursor_fg, vd->vd_mcursor_bg); 373 } 374 #endif 375 } 376 377 void 378 vt_fb_postswitch(struct vt_device *vd) 379 { 380 struct fb_info *info; 381 382 info = vd->vd_softc; 383 384 if (info->enter != NULL) 385 info->enter(info->fb_priv); 386 } 387 388 static int 389 vt_fb_init_cmap(uint32_t *cmap, int depth) 390 { 391 392 switch (depth) { 393 case 8: 394 return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB, 395 0x7, 5, 0x7, 2, 0x3, 0)); 396 case 15: 397 return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB, 398 0x1f, 10, 0x1f, 5, 0x1f, 0)); 399 case 16: 400 return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB, 401 0x1f, 11, 0x3f, 5, 0x1f, 0)); 402 case 24: 403 case 32: /* Ignore alpha. */ 404 return (vt_generate_cons_palette(cmap, COLOR_FORMAT_RGB, 405 0xff, 16, 0xff, 8, 0xff, 0)); 406 default: 407 return (1); 408 } 409 } 410 411 int 412 vt_fb_init(struct vt_device *vd) 413 { 414 struct fb_info *info; 415 int err; 416 417 info = vd->vd_softc; 418 vd->vd_height = info->fb_height; 419 vd->vd_width = info->fb_width; 420 421 if (info->fb_size == 0) 422 return (CN_DEAD); 423 424 if (info->fb_pbase == 0) 425 info->fb_flags |= FB_FLAG_NOMMAP; 426 427 if (info->fb_cmsize <= 0) { 428 err = vt_fb_init_cmap(info->fb_cmap, FBTYPE_GET_BPP(info)); 429 if (err) 430 return (CN_DEAD); 431 info->fb_cmsize = 16; 432 } 433 434 /* Clear the screen. */ 435 vd->vd_driver->vd_blank(vd, TC_BLACK); 436 437 /* Wakeup screen. KMS need this. */ 438 vt_fb_postswitch(vd); 439 440 return (CN_INTERNAL); 441 } 442 443 int 444 vt_fb_attach(struct fb_info *info) 445 { 446 447 vt_allocate(&vt_fb_driver, info); 448 449 return (0); 450 } 451 452 void 453 vt_fb_resume(void) 454 { 455 456 vt_resume(); 457 } 458 459 void 460 vt_fb_suspend(void) 461 { 462 463 vt_suspend(); 464 } 465