drivers/video/vidconsole-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2015 Google, Inc
   4  * (C) Copyright 2001-2015
   5  * DENX Software Engineering -- wd@denx.de
   6  * Compulab Ltd - http://compulab.co.il/
   7  * Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
   8  */
   9
  10 #define LOG_CATEGORY UCLASS_VIDEO_CONSOLE
  11
  12 #include <common.h>
  13 #include <command.h>
  14 #include <console.h>
  15 #include <log.h>
  16 #include <dm.h>
  17 #include <video.h>
  18 #include <video_console.h>
  19 #include <video_font.h>         /* Bitmap font for code page 437 */
  20 #include <linux/ctype.h>
  21
  22 int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch)
  23 {
  24         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  25
  26         if (!ops->putc_xy)
  27                 return -ENOSYS;
  28         return ops->putc_xy(dev, x, y, ch);
  29 }
  30
  31 int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
  32                          uint count)
  33 {
  34         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  35
  36         if (!ops->move_rows)
  37                 return -ENOSYS;
  38         return ops->move_rows(dev, rowdst, rowsrc, count);
  39 }
  40
  41 int vidconsole_set_row(struct udevice *dev, uint row, int clr)
  42 {
  43         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  44
  45         if (!ops->set_row)
  46                 return -ENOSYS;
  47         return ops->set_row(dev, row, clr);
  48 }
  49
  50 static int vidconsole_entry_start(struct udevice *dev)
  51 {
  52         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  53
  54         if (!ops->entry_start)
  55                 return -ENOSYS;
  56         return ops->entry_start(dev);
  57 }
  58
  59 /* Move backwards one space */
  60 static int vidconsole_back(struct udevice *dev)
  61 {
  62         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
  63         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
  64         int ret;
  65
  66         if (ops->backspace) {
  67                 ret = ops->backspace(dev);
  68                 if (ret != -ENOSYS)
  69                         return ret;
  70         }
  71
  72         priv->xcur_frac -= VID_TO_POS(priv->x_charsize);
  73         if (priv->xcur_frac < priv->xstart_frac) {
  74                 priv->xcur_frac = (priv->cols - 1) *
  75                         VID_TO_POS(priv->x_charsize);
  76                 priv->ycur -= priv->y_charsize;
  77                 if (priv->ycur < 0)
  78                         priv->ycur = 0;
  79         }
  80         return video_sync(dev->parent, false);
  81 }
  82
  83 /* Move to a newline, scrolling the display if necessary */
  84 static void vidconsole_newline(struct udevice *dev)
  85 {
  86         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
  87         struct udevice *vid_dev = dev->parent;
  88         struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
  89         const int rows = CONFIG_VAL(CONSOLE_SCROLL_LINES);
  90         int i, ret;
  91
  92         priv->xcur_frac = priv->xstart_frac;
  93         priv->ycur += priv->y_charsize;
  94
  95         /* Check if we need to scroll the terminal */
  96         if ((priv->ycur + priv->y_charsize) / priv->y_charsize > priv->rows) {
  97                 vidconsole_move_rows(dev, 0, rows, priv->rows - rows);
  98                 for (i = 0; i < rows; i++)
  99                         vidconsole_set_row(dev, priv->rows - i - 1,
 100                                            vid_priv->colour_bg);
 101                 priv->ycur -= rows * priv->y_charsize;
 102         }
 103         priv->last_ch = 0;
 104
 105         ret = video_sync(dev->parent, false);
 106         if (ret) {
 107 #ifdef DEBUG
 108                 console_puts_select_stderr(true, "[vc err: video_sync]");
 109 #endif
 110         }
 111 }
 112
 113 static char *parsenum(char *s, int *num)
 114 {
 115         char *end;
 116         *num = simple_strtol(s, &end, 10);
 117         return end;
 118 }
 119
 120 void vidconsole_set_cursor_pos(struct udevice *dev, int x, int y)
 121 {
 122         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 123
 124         priv->xcur_frac = VID_TO_POS(x);
 125         priv->xstart_frac = priv->xcur_frac;
 126         priv->ycur = y;
 127 }
 128
 129 /**
 130  * set_cursor_position() - set cursor position
 131  *
 132  * @priv:       private data of the video console
 133  * @row:        new row
 134  * @col:        new column
 135  */
 136 static void set_cursor_position(struct vidconsole_priv *priv, int row, int col)
 137 {
 138         /*
 139          * Ensure we stay in the bounds of the screen.
 140          */
 141         if (row >= priv->rows)
 142                 row = priv->rows - 1;
 143         if (col >= priv->cols)
 144                 col = priv->cols - 1;
 145
 146         priv->ycur = row * priv->y_charsize;
 147         priv->xcur_frac = priv->xstart_frac +
 148                           VID_TO_POS(col * priv->x_charsize);
 149 }
 150
 151 /**
 152  * get_cursor_position() - get cursor position
 153  *
 154  * @priv:       private data of the video console
 155  * @row:        row
 156  * @col:        column
 157  */
 158 static void get_cursor_position(struct vidconsole_priv *priv,
 159                                 int *row, int *col)
 160 {
 161         *row = priv->ycur / priv->y_charsize;
 162         *col = VID_TO_PIXEL(priv->xcur_frac - priv->xstart_frac) /
 163                priv->x_charsize;
 164 }
 165
 166 /*
 167  * Process a character while accumulating an escape string.  Chars are
 168  * accumulated into escape_buf until the end of escape sequence is
 169  * found, at which point the sequence is parsed and processed.
 170  */
 171 static void vidconsole_escape_char(struct udevice *dev, char ch)
 172 {
 173         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 174
 175         if (!IS_ENABLED(CONFIG_VIDEO_ANSI))
 176                 goto error;
 177
 178         /* Sanity checking for bogus ESC sequences: */
 179         if (priv->escape_len >= sizeof(priv->escape_buf))
 180                 goto error;
 181         if (priv->escape_len == 0) {
 182                 switch (ch) {
 183                 case '7':
 184                         /* Save cursor position */
 185                         get_cursor_position(priv, &priv->row_saved,
 186                                             &priv->col_saved);
 187                         priv->escape = 0;
 188
 189                         return;
 190                 case '8': {
 191                         /* Restore cursor position */
 192                         int row = priv->row_saved;
 193                         int col = priv->col_saved;
 194
 195                         set_cursor_position(priv, row, col);
 196                         priv->escape = 0;
 197                         return;
 198                 }
 199                 case '[':
 200                         break;
 201                 default:
 202                         goto error;
 203                 }
 204         }
 205
 206         priv->escape_buf[priv->escape_len++] = ch;
 207
 208         /*
 209          * Escape sequences are terminated by a letter, so keep
 210          * accumulating until we get one:
 211          */
 212         if (!isalpha(ch))
 213                 return;
 214
 215         /*
 216          * clear escape mode first, otherwise things will get highly
 217          * surprising if you hit any debug prints that come back to
 218          * this console.
 219          */
 220         priv->escape = 0;
 221
 222         switch (ch) {
 223         case 'A':
 224         case 'B':
 225         case 'C':
 226         case 'D':
 227         case 'E':
 228         case 'F': {
 229                 int row, col, num;
 230                 char *s = priv->escape_buf;
 231
 232                 /*
 233                  * Cursor up/down: [%dA, [%dB, [%dE, [%dF
 234                  * Cursor left/right: [%dD, [%dC
 235                  */
 236                 s++;    /* [ */
 237                 s = parsenum(s, &num);
 238                 if (num == 0)                   /* No digit in sequence ... */
 239                         num = 1;                /* ... means "move by 1". */
 240
 241                 get_cursor_position(priv, &row, &col);
 242                 if (ch == 'A' || ch == 'F')
 243                         row -= num;
 244                 if (ch == 'C')
 245                         col += num;
 246                 if (ch == 'D')
 247                         col -= num;
 248                 if (ch == 'B' || ch == 'E')
 249                         row += num;
 250                 if (ch == 'E' || ch == 'F')
 251                         col = 0;
 252                 if (col < 0)
 253                         col = 0;
 254                 if (row < 0)
 255                         row = 0;
 256                 /* Right and bottom overflows are handled in the callee. */
 257                 set_cursor_position(priv, row, col);
 258                 break;
 259         }
 260         case 'H':
 261         case 'f': {
 262                 int row, col;
 263                 char *s = priv->escape_buf;
 264
 265                 /*
 266                  * Set cursor position: [%d;%df or [%d;%dH
 267                  */
 268                 s++;    /* [ */
 269                 s = parsenum(s, &row);
 270                 s++;    /* ; */
 271                 s = parsenum(s, &col);
 272
 273                 /*
 274                  * Video origin is [0, 0], terminal origin is [1, 1].
 275                  */
 276                 if (row)
 277                         --row;
 278                 if (col)
 279                         --col;
 280
 281                 set_cursor_position(priv, row, col);
 282
 283                 break;
 284         }
 285         case 'J': {
 286                 int mode;
 287
 288                 /*
 289                  * Clear part/all screen:
 290                  *   [J or [0J - clear screen from cursor down
 291                  *   [1J       - clear screen from cursor up
 292                  *   [2J       - clear entire screen
 293                  *
 294                  * TODO we really only handle entire-screen case, others
 295                  * probably require some additions to video-uclass (and
 296                  * are not really needed yet by efi_console)
 297                  */
 298                 parsenum(priv->escape_buf + 1, &mode);
 299
 300                 if (mode == 2) {
 301                         int ret;
 302
 303                         video_clear(dev->parent);
 304                         ret = video_sync(dev->parent, false);
 305                         if (ret) {
 306 #ifdef DEBUG
 307                                 console_puts_select_stderr(true, "[vc err: video_sync]");
 308 #endif
 309                         }
 310                         priv->ycur = 0;
 311                         priv->xcur_frac = priv->xstart_frac;
 312                 } else {
 313                         debug("unsupported clear mode: %d\n", mode);
 314                 }
 315                 break;
 316         }
 317         case 'K': {
 318                 struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
 319                 int mode;
 320
 321                 /*
 322                  * Clear (parts of) current line
 323                  *   [0K       - clear line to end
 324                  *   [2K       - clear entire line
 325                  */
 326                 parsenum(priv->escape_buf + 1, &mode);
 327
 328                 if (mode == 2) {
 329                         int row, col;
 330
 331                         get_cursor_position(priv, &row, &col);
 332                         vidconsole_set_row(dev, row, vid_priv->colour_bg);
 333                 }
 334                 break;
 335         }
 336         case 'm': {
 337                 struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
 338                 char *s = priv->escape_buf;
 339                 char *end = &priv->escape_buf[priv->escape_len];
 340
 341                 /*
 342                  * Set graphics mode: [%d;...;%dm
 343                  *
 344                  * Currently only supports the color attributes:
 345                  *
 346                  * Foreground Colors:
 347                  *
 348                  *   30 Black
 349                  *   31 Red
 350                  *   32 Green
 351                  *   33 Yellow
 352                  *   34 Blue
 353                  *   35 Magenta
 354                  *   36 Cyan
 355                  *   37 White
 356                  *
 357                  * Background Colors:
 358                  *
 359                  *   40 Black
 360                  *   41 Red
 361                  *   42 Green
 362                  *   43 Yellow
 363                  *   44 Blue
 364                  *   45 Magenta
 365                  *   46 Cyan
 366                  *   47 White
 367                  */
 368
 369                 s++;    /* [ */
 370                 while (s < end) {
 371                         int val;
 372
 373                         s = parsenum(s, &val);
 374                         s++;
 375
 376                         switch (val) {
 377                         case 0:
 378                                 /* all attributes off */
 379                                 video_set_default_colors(dev->parent, false);
 380                                 break;
 381                         case 1:
 382                                 /* bold */
 383                                 vid_priv->fg_col_idx |= 8;
 384                                 vid_priv->colour_fg = video_index_to_colour(
 385                                                 vid_priv, vid_priv->fg_col_idx);
 386                                 break;
 387                         case 7:
 388                                 /* reverse video */
 389                                 vid_priv->colour_fg = video_index_to_colour(
 390                                                 vid_priv, vid_priv->bg_col_idx);
 391                                 vid_priv->colour_bg = video_index_to_colour(
 392                                                 vid_priv, vid_priv->fg_col_idx);
 393                                 break;
 394                         case 30 ... 37:
 395                                 /* foreground color */
 396                                 vid_priv->fg_col_idx &= ~7;
 397                                 vid_priv->fg_col_idx |= val - 30;
 398                                 vid_priv->colour_fg = video_index_to_colour(
 399                                                 vid_priv, vid_priv->fg_col_idx);
 400                                 break;
 401                         case 40 ... 47:
 402                                 /* background color, also mask the bold bit */
 403                                 vid_priv->bg_col_idx &= ~0xf;
 404                                 vid_priv->bg_col_idx |= val - 40;
 405                                 vid_priv->colour_bg = video_index_to_colour(
 406                                                 vid_priv, vid_priv->bg_col_idx);
 407                                 break;
 408                         default:
 409                                 /* ignore unsupported SGR parameter */
 410                                 break;
 411                         }
 412                 }
 413
 414                 break;
 415         }
 416         default:
 417                 debug("unrecognized escape sequence: %*s\n",
 418                       priv->escape_len, priv->escape_buf);
 419         }
 420
 421         return;
 422
 423 error:
 424         /* something went wrong, just revert to normal mode: */
 425         priv->escape = 0;
 426 }
 427
 428 /* Put that actual character on the screen (using the CP437 code page). */
 429 static int vidconsole_output_glyph(struct udevice *dev, char ch)
 430 {
 431         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 432         int ret;
 433
 434         /*
 435          * Failure of this function normally indicates an unsupported
 436          * colour depth. Check this and return an error to help with
 437          * diagnosis.
 438          */
 439         ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
 440         if (ret == -EAGAIN) {
 441                 vidconsole_newline(dev);
 442                 ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
 443         }
 444         if (ret < 0)
 445                 return ret;
 446         priv->xcur_frac += ret;
 447         priv->last_ch = ch;
 448         if (priv->xcur_frac >= priv->xsize_frac)
 449                 vidconsole_newline(dev);
 450
 451         return 0;
 452 }
 453
 454 int vidconsole_put_char(struct udevice *dev, char ch)
 455 {
 456         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 457         int ret;
 458
 459         if (priv->escape) {
 460                 vidconsole_escape_char(dev, ch);
 461                 return 0;
 462         }
 463
 464         switch (ch) {
 465         case '\x1b':
 466                 priv->escape_len = 0;
 467                 priv->escape = 1;
 468                 break;
 469         case '\a':
 470                 /* beep */
 471                 break;
 472         case '\r':
 473                 priv->xcur_frac = priv->xstart_frac;
 474                 break;
 475         case '\n':
 476                 vidconsole_newline(dev);
 477                 vidconsole_entry_start(dev);
 478                 break;
 479         case '\t':      /* Tab (8 chars alignment) */
 480                 priv->xcur_frac = ((priv->xcur_frac / priv->tab_width_frac)
 481                                 + 1) * priv->tab_width_frac;
 482
 483                 if (priv->xcur_frac >= priv->xsize_frac)
 484                         vidconsole_newline(dev);
 485                 break;
 486         case '\b':
 487                 vidconsole_back(dev);
 488                 priv->last_ch = 0;
 489                 break;
 490         default:
 491                 ret = vidconsole_output_glyph(dev, ch);
 492                 if (ret < 0)
 493                         return ret;
 494                 break;
 495         }
 496
 497         return 0;
 498 }
 499
 500 int vidconsole_put_string(struct udevice *dev, const char *str)
 501 {
 502         const char *s;
 503         int ret;
 504
 505         for (s = str; *s; s++) {
 506                 ret = vidconsole_put_char(dev, *s);
 507                 if (ret)
 508                         return ret;
 509         }
 510
 511         return 0;
 512 }
 513
 514 static void vidconsole_putc(struct stdio_dev *sdev, const char ch)
 515 {
 516         struct udevice *dev = sdev->priv;
 517         int ret;
 518
 519         ret = vidconsole_put_char(dev, ch);
 520         if (ret) {
 521 #ifdef DEBUG
 522                 console_puts_select_stderr(true, "[vc err: putc]");
 523 #endif
 524         }
 525         ret = video_sync(dev->parent, false);
 526         if (ret) {
 527 #ifdef DEBUG
 528                 console_puts_select_stderr(true, "[vc err: video_sync]");
 529 #endif
 530         }
 531 }
 532
 533 static void vidconsole_puts(struct stdio_dev *sdev, const char *s)
 534 {
 535         struct udevice *dev = sdev->priv;
 536         int ret;
 537
 538         ret = vidconsole_put_string(dev, s);
 539         if (ret) {
 540 #ifdef DEBUG
 541                 char str[30];
 542
 543                 snprintf(str, sizeof(str), "[vc err: puts %d]", ret);
 544                 console_puts_select_stderr(true, str);
 545 #endif
 546         }
 547         ret = video_sync(dev->parent, false);
 548         if (ret) {
 549 #ifdef DEBUG
 550                 console_puts_select_stderr(true, "[vc err: video_sync]");
 551 #endif
 552         }
 553 }
 554
 555 void vidconsole_list_fonts(struct udevice *dev)
 556 {
 557         struct vidfont_info info;
 558         int ret, i;
 559
 560         for (i = 0, ret = 0; !ret; i++) {
 561                 ret = vidconsole_get_font(dev, i, &info);
 562                 if (!ret)
 563                         printf("%s\n", info.name);
 564         }
 565 }
 566
 567 int vidconsole_get_font(struct udevice *dev, int seq,
 568                         struct vidfont_info *info)
 569 {
 570         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 571
 572         if (!ops->get_font)
 573                 return -ENOSYS;
 574
 575         return ops->get_font(dev, seq, info);
 576 }
 577
 578 int vidconsole_get_font_size(struct udevice *dev, const char **name, uint *sizep)
 579 {
 580         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 581
 582         if (!ops->get_font_size)
 583                 return -ENOSYS;
 584
 585         *name = ops->get_font_size(dev, sizep);
 586         return 0;
 587 }
 588
 589 int vidconsole_select_font(struct udevice *dev, const char *name, uint size)
 590 {
 591         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 592
 593         if (!ops->select_font)
 594                 return -ENOSYS;
 595
 596         return ops->select_font(dev, name, size);
 597 }
 598
 599 int vidconsole_measure(struct udevice *dev, const char *name, uint size,
 600                        const char *text, struct vidconsole_bbox *bbox)
 601 {
 602         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 603         struct vidconsole_ops *ops = vidconsole_get_ops(dev);
 604         int ret;
 605
 606         if (ops->measure) {
 607                 ret = ops->measure(dev, name, size, text, bbox);
 608                 if (ret != -ENOSYS)
 609                         return ret;
 610         }
 611
 612         bbox->valid = true;
 613         bbox->x0 = 0;
 614         bbox->y0 = 0;
 615         bbox->x1 = priv->x_charsize * strlen(text);
 616         bbox->y1 = priv->y_charsize;
 617
 618         return 0;
 619 }
 620
 621 void vidconsole_push_colour(struct udevice *dev, enum colour_idx fg,
 622                             enum colour_idx bg, struct vidconsole_colour *old)
 623 {
 624         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
 625
 626         old->colour_fg = vid_priv->colour_fg;
 627         old->colour_bg = vid_priv->colour_bg;
 628
 629         vid_priv->colour_fg = video_index_to_colour(vid_priv, fg);
 630         vid_priv->colour_bg = video_index_to_colour(vid_priv, bg);
 631 }
 632
 633 void vidconsole_pop_colour(struct udevice *dev, struct vidconsole_colour *old)
 634 {
 635         struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
 636
 637         vid_priv->colour_fg = old->colour_fg;
 638         vid_priv->colour_bg = old->colour_bg;
 639 }
 640
 641 /* Set up the number of rows and colours (rotated drivers override this) */
 642 static int vidconsole_pre_probe(struct udevice *dev)
 643 {
 644         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 645         struct udevice *vid = dev->parent;
 646         struct video_priv *vid_priv = dev_get_uclass_priv(vid);
 647
 648         priv->xsize_frac = VID_TO_POS(vid_priv->xsize);
 649
 650         return 0;
 651 }
 652
 653 /* Register the device with stdio */
 654 static int vidconsole_post_probe(struct udevice *dev)
 655 {
 656         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 657         struct stdio_dev *sdev = &priv->sdev;
 658
 659         if (!priv->tab_width_frac)
 660                 priv->tab_width_frac = VID_TO_POS(priv->x_charsize) * 8;
 661
 662         if (dev_seq(dev)) {
 663                 snprintf(sdev->name, sizeof(sdev->name), "vidconsole%d",
 664                          dev_seq(dev));
 665         } else {
 666                 strcpy(sdev->name, "vidconsole");
 667         }
 668
 669         sdev->flags = DEV_FLAGS_OUTPUT;
 670         sdev->putc = vidconsole_putc;
 671         sdev->puts = vidconsole_puts;
 672         sdev->priv = dev;
 673
 674         return stdio_register(sdev);
 675 }
 676
 677 UCLASS_DRIVER(vidconsole) = {
 678         .id             = UCLASS_VIDEO_CONSOLE,
 679         .name           = "vidconsole0",
 680         .pre_probe      = vidconsole_pre_probe,
 681         .post_probe     = vidconsole_post_probe,
 682         .per_device_auto        = sizeof(struct vidconsole_priv),
 683 };
 684
 685 #ifdef CONFIG_VIDEO_COPY
 686 int vidconsole_sync_copy(struct udevice *dev, void *from, void *to)
 687 {
 688         struct udevice *vid = dev_get_parent(dev);
 689
 690         return video_sync_copy(vid, from, to);
 691 }
 692
 693 int vidconsole_memmove(struct udevice *dev, void *dst, const void *src,
 694                        int size)
 695 {
 696         memmove(dst, src, size);
 697         return vidconsole_sync_copy(dev, dst, dst + size);
 698 }
 699 #endif
 700
 701 int vidconsole_clear_and_reset(struct udevice *dev)
 702 {
 703         int ret;
 704
 705         ret = video_clear(dev_get_parent(dev));
 706         if (ret)
 707                 return ret;
 708         vidconsole_position_cursor(dev, 0, 0);
 709
 710         return 0;
 711 }
 712
 713 void vidconsole_position_cursor(struct udevice *dev, unsigned col, unsigned row)
 714 {
 715         struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
 716         struct udevice *vid_dev = dev->parent;
 717         struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
 718         short x, y;
 719
 720         x = min_t(short, col * priv->x_charsize, vid_priv->xsize - 1);
 721         y = min_t(short, row * priv->y_charsize, vid_priv->ysize - 1);
 722         vidconsole_set_cursor_pos(dev, x, y);
 723 }