1 /*- 2 * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer as 10 * the first lines of this file unmodified. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * $FreeBSD: src/sys/dev/syscons/scvtb.c,v 1.5.2.1 2001/07/16 05:21:23 yokota Exp $ 27 * $DragonFly: src/sys/dev/misc/syscons/scvtb.c,v 1.4 2004/05/13 19:44:33 dillon Exp $ 28 */ 29 30 #include "opt_syscons.h" 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/malloc.h> 35 36 #include <machine/console.h> 37 #include <machine/md_var.h> 38 39 #include <dev/video/fb/fbreg.h> 40 #include "syscons.h" 41 42 #define vtb_wrap(vtb, at, offset) \ 43 (((at) + (offset) + (vtb)->vtb_size)%(vtb)->vtb_size) 44 45 void 46 sc_vtb_init(sc_vtb_t *vtb, int type, int cols, int rows, void *buf, int wait) 47 { 48 vtb->vtb_flags = 0; 49 vtb->vtb_type = type; 50 vtb->vtb_cols = cols; 51 vtb->vtb_rows = rows; 52 vtb->vtb_size = cols*rows; 53 vtb->vtb_buffer = NULL; 54 vtb->vtb_tail = 0; 55 56 switch (type) { 57 case VTB_MEMORY: 58 case VTB_RINGBUFFER: 59 if ((buf == NULL) && (cols*rows != 0)) { 60 vtb->vtb_buffer = (vm_offset_t) 61 malloc(cols*rows*sizeof(u_int16_t), 62 M_DEVBUF, 63 (wait) ? M_WAITOK : M_NOWAIT); 64 if (vtb->vtb_buffer != NULL) { 65 bzero((void *)sc_vtb_pointer(vtb, 0), 66 cols*rows*sizeof(u_int16_t)); 67 vtb->vtb_flags |= VTB_ALLOCED; 68 } 69 } else { 70 vtb->vtb_buffer = (vm_offset_t)buf; 71 } 72 vtb->vtb_flags |= VTB_VALID; 73 break; 74 case VTB_FRAMEBUFFER: 75 vtb->vtb_buffer = (vm_offset_t)buf; 76 vtb->vtb_flags |= VTB_VALID; 77 break; 78 default: 79 break; 80 } 81 } 82 83 void 84 sc_vtb_destroy(sc_vtb_t *vtb) 85 { 86 vm_offset_t p; 87 88 vtb->vtb_cols = 0; 89 vtb->vtb_rows = 0; 90 vtb->vtb_size = 0; 91 vtb->vtb_tail = 0; 92 93 p = vtb->vtb_buffer; 94 vtb->vtb_buffer = NULL; 95 switch (vtb->vtb_type) { 96 case VTB_MEMORY: 97 case VTB_RINGBUFFER: 98 if ((vtb->vtb_flags & VTB_ALLOCED) && (p != NULL)) 99 free((void *)p, M_DEVBUF); 100 break; 101 default: 102 break; 103 } 104 vtb->vtb_flags = 0; 105 vtb->vtb_type = VTB_INVALID; 106 } 107 108 size_t 109 sc_vtb_size(int cols, int rows) 110 { 111 return (size_t)(cols*rows*sizeof(u_int16_t)); 112 } 113 114 int 115 sc_vtb_getc(sc_vtb_t *vtb, int at) 116 { 117 if (vtb->vtb_type == VTB_FRAMEBUFFER) 118 return (readw(sc_vtb_pointer(vtb, at)) & 0x00ff); 119 else 120 return (*(u_int16_t *)sc_vtb_pointer(vtb, at) & 0x00ff); 121 } 122 123 int 124 sc_vtb_geta(sc_vtb_t *vtb, int at) 125 { 126 if (vtb->vtb_type == VTB_FRAMEBUFFER) 127 return (readw(sc_vtb_pointer(vtb, at)) & 0xff00); 128 else 129 return (*(u_int16_t *)sc_vtb_pointer(vtb, at) & 0xff00); 130 } 131 132 void 133 sc_vtb_putc(sc_vtb_t *vtb, int at, int c, int a) 134 { 135 if (vtb->vtb_type == VTB_FRAMEBUFFER) 136 writew(sc_vtb_pointer(vtb, at), a | c); 137 else 138 *(u_int16_t *)sc_vtb_pointer(vtb, at) = a | c; 139 } 140 141 vm_offset_t 142 sc_vtb_putchar(sc_vtb_t *vtb, vm_offset_t p, int c, int a) 143 { 144 if (vtb->vtb_type == VTB_FRAMEBUFFER) 145 writew(p, a | c); 146 else 147 *(u_int16_t *)p = a | c; 148 return (p + sizeof(u_int16_t)); 149 } 150 151 vm_offset_t 152 sc_vtb_pointer(sc_vtb_t *vtb, int at) 153 { 154 return (vtb->vtb_buffer + sizeof(u_int16_t)*(at)); 155 } 156 157 int 158 sc_vtb_pos(sc_vtb_t *vtb, int pos, int offset) 159 { 160 return ((pos + offset + vtb->vtb_size)%vtb->vtb_size); 161 } 162 163 void 164 sc_vtb_clear(sc_vtb_t *vtb, int c, int attr) 165 { 166 if (vtb->vtb_type == VTB_FRAMEBUFFER) 167 fillw_io(attr | c, sc_vtb_pointer(vtb, 0), vtb->vtb_size); 168 else 169 fillw(attr | c, (void *)sc_vtb_pointer(vtb, 0), vtb->vtb_size); 170 } 171 172 void 173 sc_vtb_copy(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int to, int count) 174 { 175 /* XXX if both are VTB_VRAMEBUFFER... */ 176 if (vtb2->vtb_type == VTB_FRAMEBUFFER) { 177 bcopy_toio(sc_vtb_pointer(vtb1, from), 178 sc_vtb_pointer(vtb2, to), 179 count*sizeof(u_int16_t)); 180 } else if (vtb1->vtb_type == VTB_FRAMEBUFFER) { 181 bcopy_fromio(sc_vtb_pointer(vtb1, from), 182 sc_vtb_pointer(vtb2, to), 183 count*sizeof(u_int16_t)); 184 } else { 185 bcopy((void *)sc_vtb_pointer(vtb1, from), 186 (void *)sc_vtb_pointer(vtb2, to), 187 count*sizeof(u_int16_t)); 188 } 189 } 190 191 void 192 sc_vtb_append(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int count) 193 { 194 int len; 195 196 if (vtb2->vtb_type != VTB_RINGBUFFER) 197 return; 198 199 while (count > 0) { 200 len = imin(count, vtb2->vtb_size - vtb2->vtb_tail); 201 if (vtb1->vtb_type == VTB_FRAMEBUFFER) { 202 bcopy_fromio(sc_vtb_pointer(vtb1, from), 203 sc_vtb_pointer(vtb2, vtb2->vtb_tail), 204 len*sizeof(u_int16_t)); 205 } else { 206 bcopy((void *)sc_vtb_pointer(vtb1, from), 207 (void *)sc_vtb_pointer(vtb2, vtb2->vtb_tail), 208 len*sizeof(u_int16_t)); 209 } 210 from += len; 211 count -= len; 212 vtb2->vtb_tail = vtb_wrap(vtb2, vtb2->vtb_tail, len); 213 } 214 } 215 216 void 217 sc_vtb_seek(sc_vtb_t *vtb, int pos) 218 { 219 vtb->vtb_tail = pos%vtb->vtb_size; 220 } 221 222 void 223 sc_vtb_erase(sc_vtb_t *vtb, int at, int count, int c, int attr) 224 { 225 if (at + count > vtb->vtb_size) 226 count = vtb->vtb_size - at; 227 if (vtb->vtb_type == VTB_FRAMEBUFFER) 228 fillw_io(attr | c, sc_vtb_pointer(vtb, at), count); 229 else 230 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at), count); 231 } 232 233 void 234 sc_vtb_move(sc_vtb_t *vtb, int from, int to, int count) 235 { 236 if (from + count > vtb->vtb_size) 237 count = vtb->vtb_size - from; 238 if (to + count > vtb->vtb_size) 239 count = vtb->vtb_size - to; 240 if (count <= 0) 241 return; 242 if (vtb->vtb_type == VTB_FRAMEBUFFER) { 243 bcopy_io(sc_vtb_pointer(vtb, from), 244 sc_vtb_pointer(vtb, to), count*sizeof(u_int16_t)); 245 } else { 246 bcopy((void *)sc_vtb_pointer(vtb, from), 247 (void *)sc_vtb_pointer(vtb, to), count*sizeof(u_int16_t)); 248 } 249 } 250 251 void 252 sc_vtb_delete(sc_vtb_t *vtb, int at, int count, int c, int attr) 253 { 254 int len; 255 256 if (at + count > vtb->vtb_size) 257 count = vtb->vtb_size - at; 258 len = vtb->vtb_size - at - count; 259 if (len > 0) { 260 if (vtb->vtb_type == VTB_FRAMEBUFFER) { 261 bcopy_io(sc_vtb_pointer(vtb, at + count), 262 sc_vtb_pointer(vtb, at), 263 len*sizeof(u_int16_t)); 264 } else { 265 bcopy((void *)sc_vtb_pointer(vtb, at + count), 266 (void *)sc_vtb_pointer(vtb, at), 267 len*sizeof(u_int16_t)); 268 } 269 } 270 if (vtb->vtb_type == VTB_FRAMEBUFFER) 271 fillw_io(attr | c, sc_vtb_pointer(vtb, at + len), 272 vtb->vtb_size - at - len); 273 else 274 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at + len), 275 vtb->vtb_size - at - len); 276 } 277 278 void 279 sc_vtb_ins(sc_vtb_t *vtb, int at, int count, int c, int attr) 280 { 281 if (at + count > vtb->vtb_size) { 282 count = vtb->vtb_size - at; 283 } else { 284 if (vtb->vtb_type == VTB_FRAMEBUFFER) { 285 bcopy_io(sc_vtb_pointer(vtb, at), 286 sc_vtb_pointer(vtb, at + count), 287 (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 288 } else { 289 bcopy((void *)sc_vtb_pointer(vtb, at), 290 (void *)sc_vtb_pointer(vtb, at + count), 291 (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 292 } 293 } 294 if (vtb->vtb_type == VTB_FRAMEBUFFER) 295 fillw_io(attr | c, sc_vtb_pointer(vtb, at), count); 296 else 297 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at), count); 298 } 299