drivers/video/vidconsole-uclass.c

   1 /*
   2  * Copyright (c) 2015 Google, Inc
   3  * (C) Copyright 2001-2015
   4  * DENX Software Engineering -- wd@denx.de
   5  * Compulab Ltd - http://compulab.co.il/
   6  * Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <linux/ctype.h>
  13 #include <dm.h>
  14 #include <video.h>
  15 #include <video_console.h>
  16 #include <video_font.h>         /* Bitmap font for code page 437 */
  17
  18 /*
  19  * Structure to describe a console color
  20  */
  21 struct vid_rgb {
  22         u32 r;
  23         u32 g;
  24         u32 b;
  25 };
  26
  27 /* By default we scroll by a single line */
  28 #ifndef CONFIG_CONSOLE_SCROLL_LINES
  29 #define CONFIG_CONSOLE_SCROLL_LINES 1
  30 #endif
  31
  32 int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch)
  33 {
  34         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  35
  36         if (!ops->putc_xy)
  37                 return -ENOSYS;
  38         return ops->putc_xy(dev, x, y, ch);
  39 }
  40
  41 int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
  42                          uint count)
  43 {
  44         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  45
  46         if (!ops->move_rows)
  47                 return -ENOSYS;
  48         return ops->move_rows(dev, rowdst, rowsrc, count);
  49 }
  50
  51 int vidconsole_set_row(struct udevice *dev, uint row, int clr)
  52 {
  53         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  54
  55         if (!ops->set_row)
  56                 return -ENOSYS;
  57         return ops->set_row(dev, row, clr);
  58 }
  59
  60 static int vidconsole_entry_start(struct udevice *dev)
  61 {
  62         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  63
  64         if (!ops->entry_start)
  65                 return -ENOSYS;
  66         return ops->entry_start(dev);
  67 }
  68
  69 /* Move backwards one space */
  70 static int vidconsole_back(struct udevice *dev)
  71 {
  72         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
  73         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  74         int ret;
  75
  76         if (ops->backspace) {
  77                 ret = ops->backspace(dev);
  78                 if (ret != -ENOSYS)
  79                         return ret;
  80         }
  81
  82         priv->xcur_frac -= VID_TO_POS(priv->x_charsize);
  83         if (priv->xcur_frac < priv->xstart_frac) {
  84                 priv->xcur_frac = (priv->cols - 1) *
  85                         VID_TO_POS(priv->x_charsize);
  86                 priv->ycur -= priv->y_charsize;
  87                 if (priv->ycur < 0)
  88                         priv->ycur = 0;
  89         }
  90         video_sync(dev->parent);
  91
  92         return 0;
  93 }
  94
  95 /* Move to a newline, scrolling the display if necessary */
  96 static void vidconsole_newline(struct udevice *dev)
  97 {
  98         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
  99         struct udevice *vid_dev = dev->parent;
 100         struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
 101         const int rows = CONFIG_CONSOLE_SCROLL_LINES;
 102         int i;
 103
 104         priv->xcur_frac = priv->xstart_frac;
 105         priv->ycur += priv->y_charsize;
 106
 107         /* Check if we need to scroll the terminal */
 108         if ((priv->ycur + priv->y_charsize) / priv->y_charsize > priv->rows) {
 109                 vidconsole_move_rows(dev, 0, rows, priv->rows - rows);
 110                 for (i = 0; i < rows; i++)
 111                         vidconsole_set_row(dev, priv->rows - i - 1,
 112                                            vid_priv->colour_bg);
 113                 priv->ycur -= rows * priv->y_charsize;
 114         }
 115         priv->last_ch = 0;
 116
 117         video_sync(dev->parent);
 118 }
 119
 120 static const struct vid_rgb colors[VID_COLOR_COUNT] = {
 121         { 0x00, 0x00, 0x00 },  /* black */
 122         { 0xc0, 0x00, 0x00 },  /* red */
 123         { 0x00, 0xc0, 0x00 },  /* green */
 124         { 0xc0, 0x60, 0x00 },  /* brown */
 125         { 0x00, 0x00, 0xc0 },  /* blue */
 126         { 0xc0, 0x00, 0xc0 },  /* magenta */
 127         { 0x00, 0xc0, 0xc0 },  /* cyan */
 128         { 0xc0, 0xc0, 0xc0 },  /* light gray */
 129         { 0x80, 0x80, 0x80 },  /* gray */
 130         { 0xff, 0x00, 0x00 },  /* bright red */
 131         { 0x00, 0xff, 0x00 },  /* bright green */
 132         { 0xff, 0xff, 0x00 },  /* yellow */
 133         { 0x00, 0x00, 0xff },  /* bright blue */
 134         { 0xff, 0x00, 0xff },  /* bright magenta */
 135         { 0x00, 0xff, 0xff },  /* bright cyan */
 136         { 0xff, 0xff, 0xff },  /* white */
 137 };
 138
 139 u32 vid_console_color(struct video_priv *priv, unsigned int idx)
 140 {
 141         switch (priv->bpix) {
 142         case VIDEO_BPP16:
 143                 return ((colors[idx].r >> 3) << 11) |
 144                        ((colors[idx].g >> 2) <<  5) |
 145                        ((colors[idx].b >> 3) <<  0);
 146         case VIDEO_BPP32:
 147                 return (colors[idx].r << 16) |
 148                        (colors[idx].g <<  8) |
 149                        (colors[idx].b <<  0);
 150         default:
 151                 /*
 152                  * For unknown bit arrangements just support
 153                  * black and white.
 154                  */
 155                 if (idx)
 156                         return 0xffffff; /* white */
 157                 else
 158                         return 0x000000; /* black */
 159         }
 160 }
 161
 162 static char *parsenum(char *s, int *num)
 163 {
 164         char *end;
 165         *num = simple_strtol(s, &end, 10);
 166         return end;
 167 }
 168
 169 /*
 170  * Process a character while accumulating an escape string.  Chars are
 171  * accumulated into escape_buf until the end of escape sequence is
 172  * found, at which point the sequence is parsed and processed.
 173  */
 174 static void vidconsole_escape_char(struct udevice *dev, char ch)
 175 {
 176         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 177
 178         if (!IS_ENABLED(CONFIG_VIDEO_ANSI))
 179                 goto error;
 180
 181         /* Sanity checking for bogus ESC sequences: */
 182         if (priv->escape_len >= sizeof(priv->escape_buf))
 183                 goto error;
 184         if (priv->escape_len == 0 && ch != '[')
 185                 goto error;
 186
 187         priv->escape_buf[priv->escape_len++] = ch;
 188
 189         /*
 190          * Escape sequences are terminated by a letter, so keep
 191          * accumulating until we get one:
 192          */
 193         if (!isalpha(ch))
 194                 return;
 195
 196         /*
 197          * clear escape mode first, otherwise things will get highly
 198          * surprising if you hit any debug prints that come back to
 199          * this console.
 200          */
 201         priv->escape = 0;
 202
 203         switch (ch) {
 204         case 'H':
 205         case 'f': {
 206                 int row, col;
 207                 char *s = priv->escape_buf;
 208
 209                 /*
 210                  * Set cursor position: [%d;%df or [%d;%dH
 211                  */
 212                 s++;    /* [ */
 213                 s = parsenum(s, &row);
 214                 s++;    /* ; */
 215                 s = parsenum(s, &col);
 216
 217                 priv->ycur = row * priv->y_charsize;
 218                 priv->xcur_frac = priv->xstart_frac +
 219                         VID_TO_POS(col * priv->x_charsize);
 220
 221                 break;
 222         }
 223         case 'J': {
 224                 int mode;
 225
 226                 /*
 227                  * Clear part/all screen:
 228                  *   [J or [0J - clear screen from cursor down
 229                  *   [1J       - clear screen from cursor up
 230                  *   [2J       - clear entire screen
 231                  *
 232                  * TODO we really only handle entire-screen case, others
 233                  * probably require some additions to video-uclass (and
 234                  * are not really needed yet by efi_console)
 235                  */
 236                 parsenum(priv->escape_buf + 1, &mode);
 237
 238                 if (mode == 2) {
 239                         video_clear(dev->parent);
 240                         video_sync(dev->parent);
 241                         priv->ycur = 0;
 242                         priv->xcur_frac = priv->xstart_frac;
 243                 } else {
 244                         debug("unsupported clear mode: %d\n", mode);
 245                 }
 246                 break;
 247         }
 248         case 'm': {
 249                 struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
 250                 char *s = priv->escape_buf;
 251                 char *end = &priv->escape_buf[priv->escape_len];
 252
 253                 /*
 254                  * Set graphics mode: [%d;...;%dm
 255                  *
 256                  * Currently only supports the color attributes:
 257                  *
 258                  * Foreground Colors:
 259                  *
 260                  *   30 Black
 261                  *   31 Red
 262                  *   32 Green
 263                  *   33 Yellow
 264                  *   34 Blue
 265                  *   35 Magenta
 266                  *   36 Cyan
 267                  *   37 White
 268                  *
 269                  * Background Colors:
 270                  *
 271                  *   40 Black
 272                  *   41 Red
 273                  *   42 Green
 274                  *   43 Yellow
 275                  *   44 Blue
 276                  *   45 Magenta
 277                  *   46 Cyan
 278                  *   47 White
 279                  */
 280
 281                 s++;    /* [ */
 282                 while (s < end) {
 283                         int val;
 284
 285                         s = parsenum(s, &val);
 286                         s++;
 287
 288                         switch (val) {
 289                         case 0:
 290                                 /* all attributes off */
 291                                 video_set_default_colors(vid_priv);
 292                                 break;
 293                         case 1:
 294                                 /* bold */
 295                                 vid_priv->fg_col_idx |= 8;
 296                                 vid_priv->colour_fg = vid_console_color(
 297                                                 vid_priv, vid_priv->fg_col_idx);
 298                                 break;
 299                         case 30 ... 37:
 300                                 /* foreground color */
 301                                 vid_priv->fg_col_idx &= ~7;
 302                                 vid_priv->fg_col_idx |= val - 30;
 303                                 vid_priv->colour_fg = vid_console_color(
 304                                                 vid_priv, vid_priv->fg_col_idx);
 305                                 break;
 306                         case 40 ... 47:
 307                                 /* background color */
 308                                 vid_priv->colour_bg = vid_console_color(
 309                                                         vid_priv, val - 40);
 310                                 break;
 311                         default:
 312                                 /* ignore unsupported SGR parameter */
 313                                 break;
 314                         }
 315                 }
 316
 317                 break;
 318         }
 319         default:
 320                 debug("unrecognized escape sequence: %*s\n",
 321                       priv->escape_len, priv->escape_buf);
 322         }
 323
 324         return;
 325
 326 error:
 327         /* something went wrong, just revert to normal mode: */
 328         priv->escape = 0;
 329 }
 330
 331 int vidconsole_put_char(struct udevice *dev, char ch)
 332 {
 333         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 334         int ret;
 335
 336         if (priv->escape) {
 337                 vidconsole_escape_char(dev, ch);
 338                 return 0;
 339         }
 340
 341         switch (ch) {
 342         case '\x1b':
 343                 priv->escape_len = 0;
 344                 priv->escape = 1;
 345                 break;
 346         case '\a':
 347                 /* beep */
 348                 break;
 349         case '\r':
 350                 priv->xcur_frac = priv->xstart_frac;
 351                 break;
 352         case '\n':
 353                 vidconsole_newline(dev);
 354                 vidconsole_entry_start(dev);
 355                 break;
 356         case '\t':      /* Tab (8 chars alignment) */
 357                 priv->xcur_frac = ((priv->xcur_frac / priv->tab_width_frac)
 358                                 + 1) * priv->tab_width_frac;
 359
 360                 if (priv->xcur_frac >= priv->xsize_frac)
 361                         vidconsole_newline(dev);
 362                 break;
 363         case '\b':
 364                 vidconsole_back(dev);
 365                 priv->last_ch = 0;
 366                 break;
 367         default:
 368                 /*
 369                  * Failure of this function normally indicates an unsupported
 370                  * colour depth. Check this and return an error to help with
 371                  * diagnosis.
 372                  */
 373                 ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
 374                 if (ret == -EAGAIN) {
 375                         vidconsole_newline(dev);
 376                         ret = vidconsole_putc_xy(dev, priv->xcur_frac,
 377                                                  priv->ycur, ch);
 378                 }
 379                 if (ret < 0)
 380                         return ret;
 381                 priv->xcur_frac += ret;
 382                 priv->last_ch = ch;
 383                 if (priv->xcur_frac >= priv->xsize_frac)
 384                         vidconsole_newline(dev);
 385                 break;
 386         }
 387
 388         return 0;
 389 }
 390
 391 static void vidconsole_putc(struct stdio_dev *sdev, const char ch)
 392 {
 393         struct udevice *dev = sdev->priv;
 394
 395         vidconsole_put_char(dev, ch);
 396         video_sync(dev->parent);
 397 }
 398
 399 static void vidconsole_puts(struct stdio_dev *sdev, const char *s)
 400 {
 401         struct udevice *dev = sdev->priv;
 402
 403         while (*s)
 404                 vidconsole_put_char(dev, *s++);
 405         video_sync(dev->parent);
 406 }
 407
 408 /* Set up the number of rows and colours (rotated drivers override this) */
 409 static int vidconsole_pre_probe(struct udevice *dev)
 410 {
 411         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 412         struct udevice *vid = dev->parent;
 413         struct video_priv *vid_priv = dev_get_uclass_priv(vid);
 414
 415         priv->xsize_frac = VID_TO_POS(vid_priv->xsize);
 416
 417         return 0;
 418 }
 419
 420 /* Register the device with stdio */
 421 static int vidconsole_post_probe(struct udevice *dev)
 422 {
 423         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 424         struct stdio_dev *sdev = &priv->sdev;
 425
 426         if (!priv->tab_width_frac)
 427                 priv->tab_width_frac = VID_TO_POS(priv->x_charsize) * 8;
 428
 429         if (dev->seq) {
 430                 snprintf(sdev->name, sizeof(sdev->name), "vidconsole%d",
 431                          dev->seq);
 432         } else {
 433                 strcpy(sdev->name, "vidconsole");
 434         }
 435
 436         sdev->flags = DEV_FLAGS_OUTPUT;
 437         sdev->putc = vidconsole_putc;
 438         sdev->puts = vidconsole_puts;
 439         sdev->priv = dev;
 440
 441         return stdio_register(sdev);
 442 }
 443
 444 UCLASS_DRIVER(vidconsole) = {
 445         .id             = UCLASS_VIDEO_CONSOLE,
 446         .name           = "vidconsole0",
 447         .pre_probe      = vidconsole_pre_probe,
 448         .post_probe     = vidconsole_post_probe,
 449         .per_device_auto_alloc_size     = sizeof(struct vidconsole_priv),
 450 };
 451
 452 void vidconsole_position_cursor(struct udevice *dev, unsigned col, unsigned row)
 453 {
 454         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 455         struct udevice *vid_dev = dev->parent;
 456         struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
 457
 458         priv->xcur_frac = VID_TO_POS(min_t(short, col, vid_priv->xsize - 1));
 459         priv->ycur = min_t(short, row, vid_priv->ysize - 1);
 460 }
 461
 462 static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
 463                               char *const argv[])
 464 {
 465         unsigned int col, row;
 466         struct udevice *dev;
 467
 468         if (argc != 3)
 469                 return CMD_RET_USAGE;
 470
 471         if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
 472                 return CMD_RET_FAILURE;
 473         col = simple_strtoul(argv[1], NULL, 10);
 474         row = simple_strtoul(argv[2], NULL, 10);
 475         vidconsole_position_cursor(dev, col, row);
 476
 477         return 0;
 478 }
 479
 480 static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
 481                          char *const argv[])
 482 {
 483         struct udevice *dev;
 484         const char *s;
 485
 486         if (argc != 2)
 487                 return CMD_RET_USAGE;
 488
 489         if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
 490                 return CMD_RET_FAILURE;
 491         for (s = argv[1]; *s; s++)
 492                 vidconsole_put_char(dev, *s);
 493
 494         video_sync(dev->parent);
 495
 496         return 0;
 497 }
 498
 499 U_BOOT_CMD(
 500         setcurs, 3,     1,      do_video_setcursor,
 501         "set cursor position within screen",
 502         "    <col> <row> in character"
 503 );
 504
 505 U_BOOT_CMD(
 506         lcdputs, 2,     1,      do_video_puts,
 507         "print string on video framebuffer",
 508         "    <string>"
 509 );