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

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