arch/ppc/boot/common/misc-common.c

   1 /*
   2  * Misc. bootloader code (almost) all platforms can use
   3  *
   4  * Author: Johnnie Peters <jpeters@mvista.com>
   5  * Editor: Tom Rini <trini@mvista.com>
   6  *
   7  * Derived from arch/ppc/boot/prep/misc.c
   8  *
   9  * 2000-2001 (c) MontaVista, Software, Inc.  This file is licensed under
  10  * the terms of the GNU General Public License version 2.  This program
  11  * is licensed "as is" without any warranty of any kind, whether express
  12  * or implied.
  13  */
  14
  15 #include <stdarg.h>     /* for va_ bits */
  16 #include <linux/string.h>
  17 #include <linux/zlib.h>
  18 #include "nonstdio.h"
  19
  20 /* If we're on a PReP, assume we have a keyboard controller
  21  * Also note, if we're not PReP, we assume you are a serial
  22  * console - Tom */
  23 #if defined(CONFIG_PPC_PREP) && defined(CONFIG_VGA_CONSOLE)
  24 extern void cursor(int x, int y);
  25 extern void scroll(void);
  26 extern char *vidmem;
  27 extern int lines, cols;
  28 extern int orig_x, orig_y;
  29 extern int keyb_present;
  30 extern int CRT_tstc(void);
  31 extern int CRT_getc(void);
  32 #else
  33 int cursor(int x, int y) {return 0;}
  34 void scroll(void) {}
  35 char vidmem[1];
  36 #define lines 0
  37 #define cols 0
  38 int orig_x = 0;
  39 int orig_y = 0;
  40 #define keyb_present 0
  41 int CRT_tstc(void) {return 0;}
  42 int CRT_getc(void) {return 0;}
  43 #endif
  44
  45 extern char *avail_ram;
  46 extern char *end_avail;
  47 extern char _end[];
  48
  49 void puts(const char *);
  50 void putc(const char c);
  51 void puthex(unsigned long val);
  52 void gunzip(void *, int, unsigned char *, int *);
  53 static int _cvt(unsigned long val, char *buf, long radix, char *digits);
  54
  55 void _vprintk(void(*putc)(const char), const char *fmt0, va_list ap);
  56 unsigned char *ISA_io = NULL;
  57
  58 #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \
  59         || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \
  60         || defined(CONFIG_SERIAL_MPSC_CONSOLE) \
  61         || defined(CONFIG_SERIAL_UARTLITE_CONSOLE)
  62 extern unsigned long com_port;
  63
  64 extern int serial_tstc(unsigned long com_port);
  65 extern unsigned char serial_getc(unsigned long com_port);
  66 extern void serial_putc(unsigned long com_port, unsigned char c);
  67 #endif
  68
  69 void pause(void)
  70 {
  71         puts("pause\n");
  72 }
  73
  74 void exit(void)
  75 {
  76         puts("exit\n");
  77         while(1);
  78 }
  79
  80 int tstc(void)
  81 {
  82 #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \
  83         || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \
  84         || defined(CONFIG_SERIAL_MPSC_CONSOLE) \
  85         || defined(CONFIG_SERIAL_UARTLITE_CONSOLE)
  86         if(keyb_present)
  87                 return (CRT_tstc() || serial_tstc(com_port));
  88         else
  89                 return (serial_tstc(com_port));
  90 #else
  91         return CRT_tstc();
  92 #endif
  93 }
  94
  95 int getc(void)
  96 {
  97         while (1) {
  98 #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \
  99         || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \
 100         || defined(CONFIG_SERIAL_MPSC_CONSOLE) \
 101         || defined(CONFIG_SERIAL_UARTLITE_CONSOLE)
 102                 if (serial_tstc(com_port))
 103                         return (serial_getc(com_port));
 104 #endif /* serial console */
 105                 if (keyb_present)
 106                         if(CRT_tstc())
 107                                 return (CRT_getc());
 108         }
 109 }
 110
 111 void
 112 putc(const char c)
 113 {
 114         int x,y;
 115
 116 #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \
 117         || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \
 118         || defined(CONFIG_SERIAL_MPSC_CONSOLE) \
 119         || defined(CONFIG_SERIAL_UARTLITE_CONSOLE)
 120         serial_putc(com_port, c);
 121         if ( c == '\n' )
 122                 serial_putc(com_port, '\r');
 123 #endif /* serial console */
 124
 125         x = orig_x;
 126         y = orig_y;
 127
 128         if ( c == '\n' ) {
 129                 x = 0;
 130                 if ( ++y >= lines ) {
 131                         scroll();
 132                         y--;
 133                 }
 134         } else if (c == '\r') {
 135                 x = 0;
 136         } else if (c == '\b') {
 137                 if (x > 0) {
 138                         x--;
 139                 }
 140         } else {
 141                 vidmem [ ( x + cols * y ) * 2 ] = c;
 142                 if ( ++x >= cols ) {
 143                         x = 0;
 144                         if ( ++y >= lines ) {
 145                                 scroll();
 146                                 y--;
 147                         }
 148                 }
 149         }
 150
 151         cursor(x, y);
 152
 153         orig_x = x;
 154         orig_y = y;
 155 }
 156
 157 void puts(const char *s)
 158 {
 159         int x,y;
 160         char c;
 161
 162         x = orig_x;
 163         y = orig_y;
 164
 165         while ( ( c = *s++ ) != '\0' ) {
 166 #if defined(CONFIG_SERIAL_CPM_CONSOLE) || defined(CONFIG_SERIAL_8250_CONSOLE) \
 167         || defined(CONFIG_SERIAL_MPC52xx_CONSOLE) \
 168         || defined(CONFIG_SERIAL_MPSC_CONSOLE) \
 169         || defined(CONFIG_SERIAL_UARTLITE_CONSOLE)
 170                 serial_putc(com_port, c);
 171                 if ( c == '\n' ) serial_putc(com_port, '\r');
 172 #endif /* serial console */
 173
 174                 if ( c == '\n' ) {
 175                         x = 0;
 176                         if ( ++y >= lines ) {
 177                                 scroll();
 178                                 y--;
 179                         }
 180                 } else if (c == '\b') {
 181                   if (x > 0) {
 182                     x--;
 183                   }
 184                 } else {
 185                         vidmem [ ( x + cols * y ) * 2 ] = c;
 186                         if ( ++x >= cols ) {
 187                                 x = 0;
 188                                 if ( ++y >= lines ) {
 189                                         scroll();
 190                                         y--;
 191                                 }
 192                         }
 193                 }
 194         }
 195
 196         cursor(x, y);
 197
 198         orig_x = x;
 199         orig_y = y;
 200 }
 201
 202 void error(char *x)
 203 {
 204         puts("\n\n");
 205         puts(x);
 206         puts("\n\n -- System halted");
 207
 208         while(1);       /* Halt */
 209 }
 210
 211 static void *zalloc(unsigned size)
 212 {
 213         void *p = avail_ram;
 214
 215         size = (size + 7) & -8;
 216         avail_ram += size;
 217         if (avail_ram > end_avail) {
 218                 puts("oops... out of memory\n");
 219                 pause();
 220         }
 221         return p;
 222 }
 223
 224 #define HEAD_CRC        2
 225 #define EXTRA_FIELD     4
 226 #define ORIG_NAME       8
 227 #define COMMENT         0x10
 228 #define RESERVED        0xe0
 229
 230 void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp)
 231 {
 232         z_stream s;
 233         int r, i, flags;
 234
 235         /* skip header */
 236         i = 10;
 237         flags = src[3];
 238         if (src[2] != Z_DEFLATED || (flags & RESERVED) != 0) {
 239                 puts("bad gzipped data\n");
 240                 exit();
 241         }
 242         if ((flags & EXTRA_FIELD) != 0)
 243                 i = 12 + src[10] + (src[11] << 8);
 244         if ((flags & ORIG_NAME) != 0)
 245                 while (src[i++] != 0)
 246                         ;
 247         if ((flags & COMMENT) != 0)
 248                 while (src[i++] != 0)
 249                         ;
 250         if ((flags & HEAD_CRC) != 0)
 251                 i += 2;
 252         if (i >= *lenp) {
 253                 puts("gunzip: ran out of data in header\n");
 254                 exit();
 255         }
 256
 257         /* Initialize ourself. */
 258         s.workspace = zalloc(zlib_inflate_workspacesize());
 259         r = zlib_inflateInit2(&s, -MAX_WBITS);
 260         if (r != Z_OK) {
 261                 puts("zlib_inflateInit2 returned "); puthex(r); puts("\n");
 262                 exit();
 263         }
 264         s.next_in = src + i;
 265         s.avail_in = *lenp - i;
 266         s.next_out = dst;
 267         s.avail_out = dstlen;
 268         r = zlib_inflate(&s, Z_FINISH);
 269         if (r != Z_OK && r != Z_STREAM_END) {
 270                 puts("inflate returned "); puthex(r); puts("\n");
 271                 exit();
 272         }
 273         *lenp = s.next_out - (unsigned char *) dst;
 274         zlib_inflateEnd(&s);
 275 }
 276
 277 void
 278 puthex(unsigned long val)
 279 {
 280
 281         unsigned char buf[10];
 282         int i;
 283         for (i = 7;  i >= 0;  i--)
 284         {
 285                 buf[i] = "0123456789ABCDEF"[val & 0x0F];
 286                 val >>= 4;
 287         }
 288         buf[8] = '\0';
 289         puts(buf);
 290 }
 291
 292 #define FALSE 0
 293 #define TRUE  1
 294
 295 void
 296 _printk(char const *fmt, ...)
 297 {
 298         va_list ap;
 299
 300         va_start(ap, fmt);
 301         _vprintk(putc, fmt, ap);
 302         va_end(ap);
 303         return;
 304 }
 305
 306 #define is_digit(c) ((c >= '0') && (c <= '9'))
 307
 308 void
 309 _vprintk(void(*putc)(const char), const char *fmt0, va_list ap)
 310 {
 311         char c, sign, *cp = 0;
 312         int left_prec, right_prec, zero_fill, length = 0, pad, pad_on_right;
 313         char buf[32];
 314         long val;
 315         while ((c = *fmt0++))
 316         {
 317                 if (c == '%')
 318                 {
 319                         c = *fmt0++;
 320                         left_prec = right_prec = pad_on_right = 0;
 321                         if (c == '-')
 322                         {
 323                                 c = *fmt0++;
 324                                 pad_on_right++;
 325                         }
 326                         if (c == '0')
 327                         {
 328                                 zero_fill = TRUE;
 329                                 c = *fmt0++;
 330                         } else
 331                         {
 332                                 zero_fill = FALSE;
 333                         }
 334                         while (is_digit(c))
 335                         {
 336                                 left_prec = (left_prec * 10) + (c - '0');
 337                                 c = *fmt0++;
 338                         }
 339                         if (c == '.')
 340                         {
 341                                 c = *fmt0++;
 342                                 zero_fill++;
 343                                 while (is_digit(c))
 344                                 {
 345                                         right_prec = (right_prec * 10) + (c - '0');
 346                                         c = *fmt0++;
 347                                 }
 348                         } else
 349                         {
 350                                 right_prec = left_prec;
 351                         }
 352                         sign = '\0';
 353                         switch (c)
 354                         {
 355                         case 'd':
 356                         case 'x':
 357                         case 'X':
 358                                 val = va_arg(ap, long);
 359                                 switch (c)
 360                                 {
 361                                 case 'd':
 362                                         if (val < 0)
 363                                         {
 364                                                 sign = '-';
 365                                                 val = -val;
 366                                         }
 367                                         length = _cvt(val, buf, 10, "0123456789");
 368                                         break;
 369                                 case 'x':
 370                                         length = _cvt(val, buf, 16, "0123456789abcdef");
 371                                         break;
 372                                 case 'X':
 373                                         length = _cvt(val, buf, 16, "0123456789ABCDEF");
 374                                         break;
 375                                 }
 376                                 cp = buf;
 377                                 break;
 378                         case 's':
 379                                 cp = va_arg(ap, char *);
 380                                 length = strlen(cp);
 381                                 break;
 382                         case 'c':
 383                                 c = va_arg(ap, long /*char*/);
 384                                 (*putc)(c);
 385                                 continue;
 386                         default:
 387                                 (*putc)('?');
 388                         }
 389                         pad = left_prec - length;
 390                         if (sign != '\0')
 391                         {
 392                                 pad--;
 393                         }
 394                         if (zero_fill)
 395                         {
 396                                 c = '0';
 397                                 if (sign != '\0')
 398                                 {
 399                                         (*putc)(sign);
 400                                         sign = '\0';
 401                                 }
 402                         } else
 403                         {
 404                                 c = ' ';
 405                         }
 406                         if (!pad_on_right)
 407                         {
 408                                 while (pad-- > 0)
 409                                 {
 410                                         (*putc)(c);
 411                                 }
 412                         }
 413                         if (sign != '\0')
 414                         {
 415                                 (*putc)(sign);
 416                         }
 417                         while (length-- > 0)
 418                         {
 419                                 (*putc)(c = *cp++);
 420                                 if (c == '\n')
 421                                 {
 422                                         (*putc)('\r');
 423                                 }
 424                         }
 425                         if (pad_on_right)
 426                         {
 427                                 while (pad-- > 0)
 428                                 {
 429                                         (*putc)(c);
 430                                 }
 431                         }
 432                 } else
 433                 {
 434                         (*putc)(c);
 435                         if (c == '\n')
 436                         {
 437                                 (*putc)('\r');
 438                         }
 439                 }
 440         }
 441 }
 442
 443 int
 444 _cvt(unsigned long val, char *buf, long radix, char *digits)
 445 {
 446         char temp[80];
 447         char *cp = temp;
 448         int length = 0;
 449         if (val == 0)
 450         { /* Special case */
 451                 *cp++ = '0';
 452         } else
 453                 while (val)
 454                 {
 455                         *cp++ = digits[val % radix];
 456                         val /= radix;
 457                 }
 458         while (cp != temp)
 459         {
 460                 *buf++ = *--cp;
 461                 length++;
 462         }
 463         *buf = '\0';
 464         return (length);
 465 }
 466
 467 void
 468 _dump_buf_with_offset(unsigned char *p, int s, unsigned char *base)
 469 {
 470         int i, c;
 471         if ((unsigned int)s > (unsigned int)p)
 472         {
 473                 s = (unsigned int)s - (unsigned int)p;
 474         }
 475         while (s > 0)
 476         {
 477                 if (base)
 478                 {
 479                         _printk("%06X: ", (int)p - (int)base);
 480                 } else
 481                 {
 482                         _printk("%06X: ", p);
 483                 }
 484                 for (i = 0;  i < 16;  i++)
 485                 {
 486                         if (i < s)
 487                         {
 488                                 _printk("%02X", p[i] & 0xFF);
 489                         } else
 490                         {
 491                                 _printk("  ");
 492                         }
 493                         if ((i % 2) == 1) _printk(" ");
 494                         if ((i % 8) == 7) _printk(" ");
 495                 }
 496                 _printk(" |");
 497                 for (i = 0;  i < 16;  i++)
 498                 {
 499                         if (i < s)
 500                         {
 501                                 c = p[i] & 0xFF;
 502                                 if ((c < 0x20) || (c >= 0x7F)) c = '.';
 503                         } else
 504                         {
 505                                 c = ' ';
 506                         }
 507                         _printk("%c", c);
 508                 }
 509                 _printk("|\n");
 510                 s -= 16;
 511                 p += 16;
 512         }
 513 }
 514
 515 void
 516 _dump_buf(unsigned char *p, int s)
 517 {
 518         _printk("\n");
 519         _dump_buf_with_offset(p, s, 0);
 520 }
 521
 522 /* Very simple inb/outb routines.  We declare ISA_io to be 0 above, and
 523  * then modify it on platforms which need to.  We do it like this
 524  * because on some platforms we give inb/outb an exact location, and
 525  * on others it's an offset from a given location. -- Tom
 526  */
 527
 528 void ISA_init(unsigned long base)
 529 {
 530         ISA_io = (unsigned char *)base;
 531 }
 532
 533 void
 534 outb(int port, unsigned char val)
 535 {
 536         /* Ensure I/O operations complete */
 537         __asm__ volatile("eieio");
 538         ISA_io[port] = val;
 539 }
 540
 541 unsigned char
 542 inb(int port)
 543 {
 544         /* Ensure I/O operations complete */
 545         __asm__ volatile("eieio");
 546         return (ISA_io[port]);
 547 }
 548
 549 /*
 550  * Local variables:
 551  *  c-indent-level: 8
 552  *  c-basic-offset: 8
 553  *  tab-width: 8
 554  * End:
 555  */