开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
start.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：11k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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