git.oblomov.eu Git - linux-2.6/blob - arch/powerpc/xmon/start_32.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/bitops.h>
  15 #include <asm/xmon.h>
  16 #include <asm/prom.h>
  17 #include <asm/bootx.h>
  18 #include <asm/machdep.h>
  19 #include <asm/errno.h>
  20 #include <asm/pmac_feature.h>
  21 #include <asm/processor.h>
  22 #include <asm/delay.h>
  23 #include <asm/btext.h>
  24 #include <asm/time.h>
  25 #include "nonstdio.h"
  26
  27 static volatile unsigned char __iomem *sccc, *sccd;
  28 unsigned int TXRDY, RXRDY, DLAB;
  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 void buf_access(void)
  37 {
  38         if (DLAB)
  39                 sccd[3] &= ~DLAB;       /* reset DLAB */
  40 }
  41
  42 extern int adb_init(void);
  43
  44 #ifdef CONFIG_PPC_CHRP
  45 /*
  46  * This looks in the "ranges" property for the primary PCI host bridge
  47  * to find the physical address of the start of PCI/ISA I/O space.
  48  * It is basically a cut-down version of pci_process_bridge_OF_ranges.
  49  */
  50 static unsigned long chrp_find_phys_io_base(void)
  51 {
  52         struct device_node *node;
  53         unsigned int *ranges;
  54         unsigned long base = CHRP_ISA_IO_BASE;
  55         int rlen = 0;
  56         int np;
  57
  58         node = find_devices("isa");
  59         if (node != NULL) {
  60                 node = node->parent;
  61                 if (node == NULL || node->type == NULL
  62                     || strcmp(node->type, "pci") != 0)
  63                         node = NULL;
  64         }
  65         if (node == NULL)
  66                 node = find_devices("pci");
  67         if (node == NULL)
  68                 return base;
  69
  70         ranges = (unsigned int *) get_property(node, "ranges", &rlen);
  71         np = prom_n_addr_cells(node) + 5;
  72         while ((rlen -= np * sizeof(unsigned int)) >= 0) {
  73                 if ((ranges[0] >> 24) == 1 && ranges[2] == 0) {
  74                         /* I/O space starting at 0, grab the phys base */
  75                         base = ranges[np - 3];
  76                         break;
  77                 }
  78                 ranges += np;
  79         }
  80         return base;
  81 }
  82 #endif /* CONFIG_PPC_CHRP */
  83
  84 void xmon_map_scc(void)
  85 {
  86 #ifdef CONFIG_PPC_MULTIPLATFORM
  87         volatile unsigned char __iomem *base;
  88
  89         if (_machine == _MACH_Pmac) {
  90                 struct device_node *np;
  91                 unsigned long addr;
  92 #ifdef CONFIG_BOOTX_TEXT
  93                 if (!use_screen && !use_serial
  94                     && !machine_is_compatible("iMac")) {
  95                         /* see if there is a keyboard in the device tree
  96                            with a parent of type "adb" */
  97                         for (np = find_devices("keyboard"); np; np = np->next)
  98                                 if (np->parent && np->parent->type
  99                                     && strcmp(np->parent->type, "adb") == 0)
 100                                         break;
 101
 102                         /* needs to be hacked if xmon_printk is to be used
 103                            from within find_via_pmu() */
 104 #ifdef CONFIG_ADB_PMU
 105                         if (np != NULL && boot_text_mapped && find_via_pmu())
 106                                 use_screen = 1;
 107 #endif
 108 #ifdef CONFIG_ADB_CUDA
 109                         if (np != NULL && boot_text_mapped && find_via_cuda())
 110                                 use_screen = 1;
 111 #endif
 112                 }
 113                 if (!use_screen && (np = find_devices("escc")) != NULL) {
 114                         /*
 115                          * look for the device node for the serial port
 116                          * we're using and see if it says it has a modem
 117                          */
 118                         char *name = xmon_use_sccb? "ch-b": "ch-a";
 119                         char *slots;
 120                         int l;
 121
 122                         np = np->child;
 123                         while (np != NULL && strcmp(np->name, name) != 0)
 124                                 np = np->sibling;
 125                         if (np != NULL) {
 126                                 /* XXX should parse this properly */
 127                                 channel_node = np;
 128                                 slots = get_property(np, "slot-names", &l);
 129                                 if (slots != NULL && l >= 10
 130                                     && strcmp(slots+4, "Modem") == 0)
 131                                         via_modem = 1;
 132                         }
 133                 }
 134                 btext_drawstring("xmon uses ");
 135                 if (use_screen)
 136                         btext_drawstring("screen and keyboard\n");
 137                 else {
 138                         if (via_modem)
 139                                 btext_drawstring("modem on ");
 140                         btext_drawstring(xmon_use_sccb? "printer": "modem");
 141                         btext_drawstring(" port\n");
 142                 }
 143
 144 #endif /* CONFIG_BOOTX_TEXT */
 145
 146 #ifdef CHRP_ESCC
 147                 addr = 0xc1013020;
 148 #else
 149                 addr = 0xf3013020;
 150 #endif
 151                 TXRDY = 4;
 152                 RXRDY = 1;
 153
 154                 np = find_devices("mac-io");
 155                 if (np && np->n_addrs)
 156                         addr = np->addrs[0].address + 0x13020;
 157                 base = (volatile unsigned char *) ioremap(addr & PAGE_MASK, PAGE_SIZE);
 158                 sccc = base + (addr & ~PAGE_MASK);
 159                 sccd = sccc + 0x10;
 160
 161         } else {
 162                 base = (volatile unsigned char *) isa_io_base;
 163
 164 #ifdef CONFIG_PPC_CHRP
 165                 if (_machine == _MACH_chrp)
 166                         base = (volatile unsigned char __iomem *)
 167                                 ioremap(chrp_find_phys_io_base(), 0x1000);
 168 #endif
 169
 170                 sccc = base + 0x3fd;
 171                 sccd = base + 0x3f8;
 172                 if (xmon_use_sccb) {
 173                         sccc -= 0x100;
 174                         sccd -= 0x100;
 175                 }
 176                 TXRDY = 0x20;
 177                 RXRDY = 1;
 178                 DLAB = 0x80;
 179         }
 180 #elif defined(CONFIG_GEMINI)
 181         /* should already be mapped by the kernel boot */
 182         sccc = (volatile unsigned char __iomem *) 0xffeffb0d;
 183         sccd = (volatile unsigned char __iomem *) 0xffeffb08;
 184         TXRDY = 0x20;
 185         RXRDY = 1;
 186         DLAB = 0x80;
 187 #elif defined(CONFIG_405GP)
 188         sccc = (volatile unsigned char __iomem *)0xef600305;
 189         sccd = (volatile unsigned char __iomem *)0xef600300;
 190         TXRDY = 0x20;
 191         RXRDY = 1;
 192         DLAB = 0x80;
 193 #endif /* platform */
 194 }
 195
 196 static int scc_initialized = 0;
 197
 198 void xmon_init_scc(void);
 199 extern void cuda_poll(void);
 200
 201 static inline void do_poll_adb(void)
 202 {
 203 #ifdef CONFIG_ADB_PMU
 204         if (sys_ctrler == SYS_CTRLER_PMU)
 205                 pmu_poll_adb();
 206 #endif /* CONFIG_ADB_PMU */
 207 #ifdef CONFIG_ADB_CUDA
 208         if (sys_ctrler == SYS_CTRLER_CUDA)
 209                 cuda_poll();
 210 #endif /* CONFIG_ADB_CUDA */
 211 }
 212
 213 int xmon_write(void *ptr, int nb)
 214 {
 215         char *p = ptr;
 216         int i, c, ct;
 217
 218 #ifdef CONFIG_SMP
 219         static unsigned long xmon_write_lock;
 220         int lock_wait = 1000000;
 221         int locked;
 222
 223         while ((locked = test_and_set_bit(0, &xmon_write_lock)) != 0)
 224                 if (--lock_wait == 0)
 225                         break;
 226 #endif
 227
 228 #ifdef CONFIG_BOOTX_TEXT
 229         if (use_screen) {
 230                 /* write it on the screen */
 231                 for (i = 0; i < nb; ++i)
 232                         btext_drawchar(*p++);
 233                 goto out;
 234         }
 235 #endif
 236         if (!scc_initialized)
 237                 xmon_init_scc();
 238         ct = 0;
 239         for (i = 0; i < nb; ++i) {
 240                 while ((*sccc & TXRDY) == 0)
 241                         do_poll_adb();
 242                 c = p[i];
 243                 if (c == '\n' && !ct) {
 244                         c = '\r';
 245                         ct = 1;
 246                         --i;
 247                 } else {
 248                         ct = 0;
 249                 }
 250                 buf_access();
 251                 *sccd = c;
 252                 eieio();
 253         }
 254
 255  out:
 256 #ifdef CONFIG_SMP
 257         if (!locked)
 258                 clear_bit(0, &xmon_write_lock);
 259 #endif
 260         return nb;
 261 }
 262
 263 int xmon_wants_key;
 264 int xmon_adb_keycode;
 265
 266 #ifdef CONFIG_BOOTX_TEXT
 267 static int xmon_adb_shiftstate;
 268
 269 static unsigned char xmon_keytab[128] =
 270         "asdfhgzxcv\000bqwer"                           /* 0x00 - 0x0f */
 271         "yt123465=97-80]o"                              /* 0x10 - 0x1f */
 272         "u[ip\rlj'k;\\,/nm."                            /* 0x20 - 0x2f */
 273         "\t `\177\0\033\0\0\0\0\0\0\0\0\0\0"            /* 0x30 - 0x3f */
 274         "\0.\0*\0+\0\0\0\0\0/\r\0-\0"                   /* 0x40 - 0x4f */
 275         "\0\0000123456789\0\0\0";                       /* 0x50 - 0x5f */
 276
 277 static unsigned char xmon_shift_keytab[128] =
 278         "ASDFHGZXCV\000BQWER"                           /* 0x00 - 0x0f */
 279         "YT!@#$^%+(&_*)}O"                              /* 0x10 - 0x1f */
 280         "U{IP\rLJ\"K:|<?NM>"                            /* 0x20 - 0x2f */
 281         "\t ~\177\0\033\0\0\0\0\0\0\0\0\0\0"            /* 0x30 - 0x3f */
 282         "\0.\0*\0+\0\0\0\0\0/\r\0-\0"                   /* 0x40 - 0x4f */
 283         "\0\0000123456789\0\0\0";                       /* 0x50 - 0x5f */
 284
 285 static int xmon_get_adb_key(void)
 286 {
 287         int k, t, on;
 288
 289         xmon_wants_key = 1;
 290         for (;;) {
 291                 xmon_adb_keycode = -1;
 292                 t = 0;
 293                 on = 0;
 294                 do {
 295                         if (--t < 0) {
 296                                 on = 1 - on;
 297                                 btext_drawchar(on? 0xdb: 0x20);
 298                                 btext_drawchar('\b');
 299                                 t = 200000;
 300                         }
 301                         do_poll_adb();
 302                 } while (xmon_adb_keycode == -1);
 303                 k = xmon_adb_keycode;
 304                 if (on)
 305                         btext_drawstring(" \b");
 306
 307                 /* test for shift keys */
 308                 if ((k & 0x7f) == 0x38 || (k & 0x7f) == 0x7b) {
 309                         xmon_adb_shiftstate = (k & 0x80) == 0;
 310                         continue;
 311                 }
 312                 if (k >= 0x80)
 313                         continue;       /* ignore up transitions */
 314                 k = (xmon_adb_shiftstate? xmon_shift_keytab: xmon_keytab)[k];
 315                 if (k != 0)
 316                         break;
 317         }
 318         xmon_wants_key = 0;
 319         return k;
 320 }
 321 #endif /* CONFIG_BOOTX_TEXT */
 322
 323 int xmon_readchar(void)
 324 {
 325 #ifdef CONFIG_BOOTX_TEXT
 326         if (use_screen)
 327                 return xmon_get_adb_key();
 328 #endif
 329         if (!scc_initialized)
 330                 xmon_init_scc();
 331         while ((*sccc & RXRDY) == 0)
 332                 do_poll_adb();
 333         buf_access();
 334         return *sccd;
 335 }
 336
 337 int xmon_read_poll(void)
 338 {
 339         if ((*sccc & RXRDY) == 0) {
 340                 do_poll_adb();
 341                 return -1;
 342         }
 343         buf_access();
 344         return *sccd;
 345 }
 346
 347 static unsigned char scc_inittab[] = {
 348     13, 0,              /* set baud rate divisor */
 349     12, 1,
 350     14, 1,              /* baud rate gen enable, src=rtxc */
 351     11, 0x50,           /* clocks = br gen */
 352     5,  0xea,           /* tx 8 bits, assert DTR & RTS */
 353     4,  0x46,           /* x16 clock, 1 stop */
 354     3,  0xc1,           /* rx enable, 8 bits */
 355 };
 356
 357 void xmon_init_scc(void)
 358 {
 359         if ( _machine == _MACH_chrp )
 360         {
 361                 sccd[3] = 0x83; eieio();        /* LCR = 8N1 + DLAB */
 362                 sccd[0] = 12; eieio();          /* DLL = 9600 baud */
 363                 sccd[1] = 0; eieio();
 364                 sccd[2] = 0; eieio();           /* FCR = 0 */
 365                 sccd[3] = 3; eieio();           /* LCR = 8N1 */
 366                 sccd[1] = 0; eieio();           /* IER = 0 */
 367         }
 368         else if ( _machine == _MACH_Pmac )
 369         {
 370                 int i, x;
 371                 unsigned long timeout;
 372
 373                 if (channel_node != 0)
 374                         pmac_call_feature(
 375                                 PMAC_FTR_SCC_ENABLE,
 376                                 channel_node,
 377                                 PMAC_SCC_ASYNC | PMAC_SCC_FLAG_XMON, 1);
 378                         printk(KERN_INFO "Serial port locked ON by debugger !\n");
 379                 if (via_modem && channel_node != 0) {
 380                         unsigned int t0;
 381
 382                         pmac_call_feature(
 383                                 PMAC_FTR_MODEM_ENABLE,
 384                                 channel_node, 0, 1);
 385                         printk(KERN_INFO "Modem powered up by debugger !\n");
 386                         t0 = get_tbl();
 387                         timeout = 3 * tb_ticks_per_sec;
 388                         if (timeout == 0)
 389                                 /* assume 25MHz if tb_ticks_per_sec not set */
 390                                 timeout = 75000000;
 391                         while (get_tbl() - t0 < timeout)
 392                                 eieio();
 393                 }
 394                 /* use the B channel if requested */
 395                 if (xmon_use_sccb) {
 396                         sccc = (volatile unsigned char *)
 397                                 ((unsigned long)sccc & ~0x20);
 398                         sccd = sccc + 0x10;
 399                 }
 400                 for (i = 20000; i != 0; --i) {
 401                         x = *sccc; eieio();
 402                 }
 403                 *sccc = 9; eieio();             /* reset A or B side */
 404                 *sccc = ((unsigned long)sccc & 0x20)? 0x80: 0x40; eieio();
 405                 for (i = 0; i < sizeof(scc_inittab); ++i) {
 406                         *sccc = scc_inittab[i];
 407                         eieio();
 408                 }
 409         }
 410         scc_initialized = 1;
 411         if (via_modem) {
 412                 for (;;) {
 413                         xmon_write("ATE1V1\r", 7);
 414                         if (xmon_expect("OK", 5)) {
 415                                 xmon_write("ATA\r", 4);
 416                                 if (xmon_expect("CONNECT", 40))
 417                                         break;
 418                         }
 419                         xmon_write("+++", 3);
 420                         xmon_expect("OK", 3);
 421                 }
 422         }
 423 }
 424
 425 void xmon_enter(void)
 426 {
 427 #ifdef CONFIG_ADB_PMU
 428         if (_machine == _MACH_Pmac) {
 429                 pmu_suspend();
 430         }
 431 #endif
 432 }
 433
 434 void xmon_leave(void)
 435 {
 436 #ifdef CONFIG_ADB_PMU
 437         if (_machine == _MACH_Pmac) {
 438                 pmu_resume();
 439         }
 440 #endif
 441 }