arch/ppc/xmon/start.c

   1 /*
   2  * Copyright (C) 1996 Paul Mackerras.
   3  */
   4 #include <linux/config.h>
   5 #include <linux/string.h>
   6 #include <asm/machdep.h>
   7 #include <asm/io.h>
   8 #include <asm/page.h>
   9 #include <linux/adb.h>
  10 #include <linux/pmu.h>
  11 #include <linux/cuda.h>
  12 #include <linux/kernel.h>
  13 #include <linux/errno.h>
  14 #include <linux/sysrq.h>
  15 #include <linux/bitops.h>
  16 #include <asm/xmon.h>
  17 #include <asm/prom.h>
  18 #include <asm/bootx.h>
  19 #include <asm/machdep.h>
  20 #include <asm/errno.h>
  21 #include <asm/pmac_feature.h>
  22 #include <asm/processor.h>
  23 #include <asm/delay.h>
  24 #include <asm/btext.h>
  25
  26 static volatile unsigned char *sccc, *sccd;
  27 unsigned int TXRDY, RXRDY, DLAB;
  28 static int xmon_expect(const char *str, unsigned int timeout);
  29
  30 static int use_serial;
  31 static int use_screen;
  32 static int via_modem;
  33 static int xmon_use_sccb;
  34 static struct device_node *channel_node;
  35
  36 #define TB_SPEED        25000000
  37
  38 static inline unsigned int readtb(void)
  39 {
  40         unsigned int ret;
  41
  42         asm volatile("mftb %0" : "=r" (ret) :);
  43         return ret;
  44 }
  45
  46 void buf_access(void)
  47 {
  48         if (DLAB)
  49                 sccd[3] &= ~DLAB;       /* reset DLAB */
  50 }
  51
  52 extern int adb_init(void);
  53
  54 #ifdef CONFIG_PPC_CHRP
  55 /*
  56  * This looks in the "ranges" property for the primary PCI host bridge
  57  * to find the physical address of the start of PCI/ISA I/O space.
  58  * It is basically a cut-down version of pci_process_bridge_OF_ranges.
  59  */
  60 static unsigned long chrp_find_phys_io_base(void)
  61 {
  62         struct device_node *node;
  63         unsigned int *ranges;
  64         unsigned long base = CHRP_ISA_IO_BASE;
  65         int rlen = 0;
  66         int np;
  67
  68         node = find_devices("isa");
  69         if (node != NULL) {
  70                 node = node->parent;
  71                 if (node == NULL || node->type == NULL
  72                     || strcmp(node->type, "pci") != 0)
  73                         node = NULL;
  74         }
  75         if (node == NULL)
  76                 node = find_devices("pci");
  77         if (node == NULL)
  78                 return base;
  79
  80         ranges = (unsigned int *) get_property(node, "ranges", &rlen);
  81         np = prom_n_addr_cells(node) + 5;
  82         while ((rlen -= np * sizeof(unsigned int)) >= 0) {
  83                 if ((ranges[0] >> 24) == 1 && ranges[2] == 0) {
  84                         /* I/O space starting at 0, grab the phys base */
  85                         base = ranges[np - 3];
  86                         break;
  87                 }
  88                 ranges += np;
  89         }
  90         return base;
  91 }
  92 #endif /* CONFIG_PPC_CHRP */
  93
  94 #ifdef CONFIG_MAGIC_SYSRQ
  95 static void sysrq_handle_xmon(int key, struct pt_regs *regs,
  96                               struct tty_struct *tty)
  97 {
  98         xmon(regs);
  99 }
 100
 101 static struct sysrq_key_op sysrq_xmon_op =
 102 {
 103         .handler =      sysrq_handle_xmon,
 104         .help_msg =     "Xmon",
 105         .action_msg =   "Entering xmon",
 106 };
 107 #endif
 108
 109 void
 110 xmon_map_scc(void)
 111 {
 112 #ifdef CONFIG_PPC_MULTIPLATFORM
 113         volatile unsigned char *base;
 114
 115         if (_machine == _MACH_Pmac) {
 116                 struct device_node *np;
 117                 unsigned long addr;
 118 #ifdef CONFIG_BOOTX_TEXT
 119                 if (!use_screen && !use_serial
 120                     && !machine_is_compatible("iMac")) {
 121                         /* see if there is a keyboard in the device tree
 122                            with a parent of type "adb" */
 123                         for (np = find_devices("keyboard"); np; np = np->next)
 124                                 if (np->parent && np->parent->type
 125                                     && strcmp(np->parent->type, "adb") == 0)
 126                                         break;
 127
 128                         /* needs to be hacked if xmon_printk is to be used
 129                            from within find_via_pmu() */
 130 #ifdef CONFIG_ADB_PMU
 131                         if (np != NULL && boot_text_mapped && find_via_pmu())
 132                                 use_screen = 1;
 133 #endif
 134 #ifdef CONFIG_ADB_CUDA
 135                         if (np != NULL && boot_text_mapped && find_via_cuda())
 136                                 use_screen = 1;
 137 #endif
 138                 }
 139                 if (!use_screen && (np = find_devices("escc")) != NULL) {
 140                         /*
 141                          * look for the device node for the serial port
 142                          * we're using and see if it says it has a modem
 143                          */
 144                         char *name = xmon_use_sccb? "ch-b": "ch-a";
 145                         char *slots;
 146                         int l;
 147
 148                         np = np->child;
 149                         while (np != NULL && strcmp(np->name, name) != 0)
 150                                 np = np->sibling;
 151                         if (np != NULL) {
 152                                 /* XXX should parse this properly */
 153                                 channel_node = np;
 154                                 slots = get_property(np, "slot-names", &l);
 155                                 if (slots != NULL && l >= 10
 156                                     && strcmp(slots+4, "Modem") == 0)
 157                                         via_modem = 1;
 158                         }
 159                 }
 160                 btext_drawstring("xmon uses ");
 161                 if (use_screen)
 162                         btext_drawstring("screen and keyboard\n");
 163                 else {
 164                         if (via_modem)
 165                                 btext_drawstring("modem on ");
 166                         btext_drawstring(xmon_use_sccb? "printer": "modem");
 167                         btext_drawstring(" port\n");
 168                 }
 169
 170 #endif /* CONFIG_BOOTX_TEXT */
 171
 172 #ifdef CHRP_ESCC
 173                 addr = 0xc1013020;
 174 #else
 175                 addr = 0xf3013020;
 176 #endif
 177                 TXRDY = 4;
 178                 RXRDY = 1;
 179
 180                 np = find_devices("mac-io");
 181                 if (np && np->n_addrs)
 182                         addr = np->addrs[0].address + 0x13020;
 183                 base = (volatile unsigned char *) ioremap(addr & PAGE_MASK, PAGE_SIZE);
 184                 sccc = base + (addr & ~PAGE_MASK);
 185                 sccd = sccc + 0x10;
 186
 187         }
 188 #ifdef CONFIG_PPC_CHRP
 189         else {
 190                 base = (volatile unsigned char *) isa_io_base;
 191                 if (_machine == _MACH_chrp)
 192                         base = (volatile unsigned char *)
 193                                 ioremap(chrp_find_phys_io_base(), 0x1000);
 194
 195                 sccc = base + 0x3fd;
 196                 sccd = base + 0x3f8;
 197                 if (xmon_use_sccb) {
 198                         sccc -= 0x100;
 199                         sccd -= 0x100;
 200                 }
 201                 TXRDY = 0x20;
 202                 RXRDY = 1;
 203                 DLAB = 0x80;
 204         }
 205 #endif /* CONFIG_PPC_CHRP */
 206 #elif defined(CONFIG_GEMINI)
 207         /* should already be mapped by the kernel boot */
 208         sccc = (volatile unsigned char *) 0xffeffb0d;
 209         sccd = (volatile unsigned char *) 0xffeffb08;
 210         TXRDY = 0x20;
 211         RXRDY = 1;
 212         DLAB = 0x80;
 213 #elif defined(CONFIG_405GP)
 214         sccc = (volatile unsigned char *)0xef600305;
 215         sccd = (volatile unsigned char *)0xef600300;
 216         TXRDY = 0x20;
 217         RXRDY = 1;
 218         DLAB = 0x80;
 219 #endif /* platform */
 220
 221         register_sysrq_key('x', &sysrq_xmon_op);
 222 }
 223
 224 static int scc_initialized = 0;
 225
 226 void xmon_init_scc(void);
 227 extern void cuda_poll(void);
 228
 229 static inline void do_poll_adb(void)
 230 {
 231 #ifdef CONFIG_ADB_PMU
 232         if (sys_ctrler == SYS_CTRLER_PMU)
 233                 pmu_poll_adb();
 234 #endif /* CONFIG_ADB_PMU */
 235 #ifdef CONFIG_ADB_CUDA
 236         if (sys_ctrler == SYS_CTRLER_CUDA)
 237                 cuda_poll();
 238 #endif /* CONFIG_ADB_CUDA */
 239 }
 240
 241 int
 242 xmon_write(void *handle, void *ptr, int nb)
 243 {
 244         char *p = ptr;
 245         int i, c, ct;
 246
 247 #ifdef CONFIG_SMP
 248         static unsigned long xmon_write_lock;
 249         int lock_wait = 1000000;
 250         int locked;
 251
 252         while ((locked = test_and_set_bit(0, &xmon_write_lock)) != 0)
 253                 if (--lock_wait == 0)
 254                         break;
 255 #endif
 256
 257 #ifdef CONFIG_BOOTX_TEXT
 258         if (use_screen) {
 259                 /* write it on the screen */
 260                 for (i = 0; i < nb; ++i)
 261                         btext_drawchar(*p++);
 262                 goto out;
 263         }
 264 #endif
 265         if (!scc_initialized)
 266                 xmon_init_scc();
 267         ct = 0;
 268         for (i = 0; i < nb; ++i) {
 269                 while ((*sccc & TXRDY) == 0)
 270                         do_poll_adb();
 271                 c = p[i];
 272                 if (c == '\n' && !ct) {
 273                         c = '\r';
 274                         ct = 1;
 275                         --i;
 276                 } else {
 277                         ct = 0;
 278                 }
 279                 buf_access();
 280                 *sccd = c;
 281                 eieio();
 282         }
 283
 284  out:
 285 #ifdef CONFIG_SMP
 286         if (!locked)
 287                 clear_bit(0, &xmon_write_lock);
 288 #endif
 289         return nb;
 290 }
 291
 292 int xmon_wants_key;
 293 int xmon_adb_keycode;
 294
 295 #ifdef CONFIG_BOOTX_TEXT
 296 static int xmon_adb_shiftstate;
 297
 298 static unsigned char xmon_keytab[128] =
 299         "asdfhgzxcv\000bqwer"                           /* 0x00 - 0x0f */
 300         "yt123465=97-80]o"                              /* 0x10 - 0x1f */
 301         "u[ip\rlj'k;\\,/nm."                            /* 0x20 - 0x2f */
 302         "\t `\177\0\033\0\0\0\0\0\0\0\0\0\0"            /* 0x30 - 0x3f */
 303         "\0.\0*\0+\0\0\0\0\0/\r\0-\0"                   /* 0x40 - 0x4f */
 304         "\0\0000123456789\0\0\0";                       /* 0x50 - 0x5f */
 305
 306 static unsigned char xmon_shift_keytab[128] =
 307         "ASDFHGZXCV\000BQWER"                           /* 0x00 - 0x0f */
 308         "YT!@#$^%+(&_*)}O"                              /* 0x10 - 0x1f */
 309         "U{IP\rLJ\"K:|<?NM>"                            /* 0x20 - 0x2f */
 310         "\t ~\177\0\033\0\0\0\0\0\0\0\0\0\0"            /* 0x30 - 0x3f */
 311         "\0.\0*\0+\0\0\0\0\0/\r\0-\0"                   /* 0x40 - 0x4f */
 312         "\0\0000123456789\0\0\0";                       /* 0x50 - 0x5f */
 313
 314 static int
 315 xmon_get_adb_key(void)
 316 {
 317         int k, t, on;
 318
 319         xmon_wants_key = 1;
 320         for (;;) {
 321                 xmon_adb_keycode = -1;
 322                 t = 0;
 323                 on = 0;
 324                 do {
 325                         if (--t < 0) {
 326                                 on = 1 - on;
 327                                 btext_drawchar(on? 0xdb: 0x20);
 328                                 btext_drawchar('\b');
 329                                 t = 200000;
 330                         }
 331                         do_poll_adb();
 332                 } while (xmon_adb_keycode == -1);
 333                 k = xmon_adb_keycode;
 334                 if (on)
 335                         btext_drawstring(" \b");
 336
 337                 /* test for shift keys */
 338                 if ((k & 0x7f) == 0x38 || (k & 0x7f) == 0x7b) {
 339                         xmon_adb_shiftstate = (k & 0x80) == 0;
 340                         continue;
 341                 }
 342                 if (k >= 0x80)
 343                         continue;       /* ignore up transitions */
 344                 k = (xmon_adb_shiftstate? xmon_shift_keytab: xmon_keytab)[k];
 345                 if (k != 0)
 346                         break;
 347         }
 348         xmon_wants_key = 0;
 349         return k;
 350 }
 351 #endif /* CONFIG_BOOTX_TEXT */
 352
 353 int
 354 xmon_read(void *handle, void *ptr, int nb)
 355 {
 356     char *p = ptr;
 357     int i;
 358
 359 #ifdef CONFIG_BOOTX_TEXT
 360     if (use_screen) {
 361         for (i = 0; i < nb; ++i)
 362             *p++ = xmon_get_adb_key();
 363         return i;
 364     }
 365 #endif
 366     if (!scc_initialized)
 367         xmon_init_scc();
 368     for (i = 0; i < nb; ++i) {
 369         while ((*sccc & RXRDY) == 0)
 370             do_poll_adb();
 371         buf_access();
 372         *p++ = *sccd;
 373     }
 374     return i;
 375 }
 376
 377 int
 378 xmon_read_poll(void)
 379 {
 380         if ((*sccc & RXRDY) == 0) {
 381                 do_poll_adb();
 382                 return -1;
 383         }
 384         buf_access();
 385         return *sccd;
 386 }
 387
 388 static unsigned char scc_inittab[] = {
 389     13, 0,              /* set baud rate divisor */
 390     12, 1,
 391     14, 1,              /* baud rate gen enable, src=rtxc */
 392     11, 0x50,           /* clocks = br gen */
 393     5,  0xea,           /* tx 8 bits, assert DTR & RTS */
 394     4,  0x46,           /* x16 clock, 1 stop */
 395     3,  0xc1,           /* rx enable, 8 bits */
 396 };
 397
 398 void
 399 xmon_init_scc(void)
 400 {
 401         if ( _machine == _MACH_chrp )
 402         {
 403                 sccd[3] = 0x83; eieio();        /* LCR = 8N1 + DLAB */
 404                 sccd[0] = 12; eieio();          /* DLL = 9600 baud */
 405                 sccd[1] = 0; eieio();
 406                 sccd[2] = 0; eieio();           /* FCR = 0 */
 407                 sccd[3] = 3; eieio();           /* LCR = 8N1 */
 408                 sccd[1] = 0; eieio();           /* IER = 0 */
 409         }
 410         else if ( _machine == _MACH_Pmac )
 411         {
 412                 int i, x;
 413
 414                 if (channel_node != 0)
 415                         pmac_call_feature(
 416                                 PMAC_FTR_SCC_ENABLE,
 417                                 channel_node,
 418                                 PMAC_SCC_ASYNC | PMAC_SCC_FLAG_XMON, 1);
 419                         printk(KERN_INFO "Serial port locked ON by debugger !\n");
 420                 if (via_modem && channel_node != 0) {
 421                         unsigned int t0;
 422
 423                         pmac_call_feature(
 424                                 PMAC_FTR_MODEM_ENABLE,
 425                                 channel_node, 0, 1);
 426                         printk(KERN_INFO "Modem powered up by debugger !\n");
 427                         t0 = readtb();
 428                         while (readtb() - t0 < 3*TB_SPEED)
 429                                 eieio();
 430                 }
 431                 /* use the B channel if requested */
 432                 if (xmon_use_sccb) {
 433                         sccc = (volatile unsigned char *)
 434                                 ((unsigned long)sccc & ~0x20);
 435                         sccd = sccc + 0x10;
 436                 }
 437                 for (i = 20000; i != 0; --i) {
 438                         x = *sccc; eieio();
 439                 }
 440                 *sccc = 9; eieio();             /* reset A or B side */
 441                 *sccc = ((unsigned long)sccc & 0x20)? 0x80: 0x40; eieio();
 442                 for (i = 0; i < sizeof(scc_inittab); ++i) {
 443                         *sccc = scc_inittab[i];
 444                         eieio();
 445                 }
 446         }
 447         scc_initialized = 1;
 448         if (via_modem) {
 449                 for (;;) {
 450                         xmon_write(NULL, "ATE1V1\r", 7);
 451                         if (xmon_expect("OK", 5)) {
 452                                 xmon_write(NULL, "ATA\r", 4);
 453                                 if (xmon_expect("CONNECT", 40))
 454                                         break;
 455                         }
 456                         xmon_write(NULL, "+++", 3);
 457                         xmon_expect("OK", 3);
 458                 }
 459         }
 460 }
 461
 462 #if 0
 463 extern int (*prom_entry)(void *);
 464
 465 int
 466 xmon_exit(void)
 467 {
 468     struct prom_args {
 469         char *service;
 470     } args;
 471
 472     for (;;) {
 473         args.service = "exit";
 474         (*prom_entry)(&args);
 475     }
 476 }
 477 #endif
 478
 479 void *xmon_stdin;
 480 void *xmon_stdout;
 481 void *xmon_stderr;
 482
 483 void
 484 xmon_init(int arg)
 485 {
 486         xmon_map_scc();
 487 }
 488
 489 int
 490 xmon_putc(int c, void *f)
 491 {
 492     char ch = c;
 493
 494     if (c == '\n')
 495         xmon_putc('\r', f);
 496     return xmon_write(f, &ch, 1) == 1? c: -1;
 497 }
 498
 499 int
 500 xmon_putchar(int c)
 501 {
 502     return xmon_putc(c, xmon_stdout);
 503 }
 504
 505 int
 506 xmon_fputs(char *str, void *f)
 507 {
 508     int n = strlen(str);
 509
 510     return xmon_write(f, str, n) == n? 0: -1;
 511 }
 512
 513 int
 514 xmon_readchar(void)
 515 {
 516     char ch;
 517
 518     for (;;) {
 519         switch (xmon_read(xmon_stdin, &ch, 1)) {
 520         case 1:
 521             return ch;
 522         case -1:
 523             xmon_printf("read(stdin) returned -1\r\n", 0, 0);
 524             return -1;
 525         }
 526     }
 527 }
 528
 529 static char line[256];
 530 static char *lineptr;
 531 static int lineleft;
 532
 533 int xmon_expect(const char *str, unsigned int timeout)
 534 {
 535         int c;
 536         unsigned int t0;
 537
 538         timeout *= TB_SPEED;
 539         t0 = readtb();
 540         do {
 541                 lineptr = line;
 542                 for (;;) {
 543                         c = xmon_read_poll();
 544                         if (c == -1) {
 545                                 if (readtb() - t0 > timeout)
 546                                         return 0;
 547                                 continue;
 548                         }
 549                         if (c == '\n')
 550                                 break;
 551                         if (c != '\r' && lineptr < &line[sizeof(line) - 1])
 552                                 *lineptr++ = c;
 553                 }
 554                 *lineptr = 0;
 555         } while (strstr(line, str) == NULL);
 556         return 1;
 557 }
 558
 559 int
 560 xmon_getchar(void)
 561 {
 562     int c;
 563
 564     if (lineleft == 0) {
 565         lineptr = line;
 566         for (;;) {
 567             c = xmon_readchar();
 568             if (c == -1 || c == 4)
 569                 break;
 570             if (c == '\r' || c == '\n') {
 571                 *lineptr++ = '\n';
 572                 xmon_putchar('\n');
 573                 break;
 574             }
 575             switch (c) {
 576             case 0177:
 577             case '\b':
 578                 if (lineptr > line) {
 579                     xmon_putchar('\b');
 580                     xmon_putchar(' ');
 581                     xmon_putchar('\b');
 582                     --lineptr;
 583                 }
 584                 break;
 585             case 'U' & 0x1F:
 586                 while (lineptr > line) {
 587                     xmon_putchar('\b');
 588                     xmon_putchar(' ');
 589                     xmon_putchar('\b');
 590                     --lineptr;
 591                 }
 592                 break;
 593             default:
 594                 if (lineptr >= &line[sizeof(line) - 1])
 595                     xmon_putchar('\a');
 596                 else {
 597                     xmon_putchar(c);
 598                     *lineptr++ = c;
 599                 }
 600             }
 601         }
 602         lineleft = lineptr - line;
 603         lineptr = line;
 604     }
 605     if (lineleft == 0)
 606         return -1;
 607     --lineleft;
 608     return *lineptr++;
 609 }
 610
 611 char *
 612 xmon_fgets(char *str, int nb, void *f)
 613 {
 614     char *p;
 615     int c;
 616
 617     for (p = str; p < str + nb - 1; ) {
 618         c = xmon_getchar();
 619         if (c == -1) {
 620             if (p == str)
 621                 return NULL;
 622             break;
 623         }
 624         *p++ = c;
 625         if (c == '\n')
 626             break;
 627     }
 628     *p = 0;
 629     return str;
 630 }
 631
 632 void
 633 xmon_enter(void)
 634 {
 635 #ifdef CONFIG_ADB_PMU
 636         if (_machine == _MACH_Pmac) {
 637                 pmu_suspend();
 638         }
 639 #endif
 640 }
 641
 642 void
 643 xmon_leave(void)
 644 {
 645 #ifdef CONFIG_ADB_PMU
 646         if (_machine == _MACH_Pmac) {
 647                 pmu_resume();
 648         }
 649 #endif
 650 }