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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
chrp_setup.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

chrp_setup.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.chrp_setup.c 1.40 12/19/01 09:45:54 trini
  3.  */
  4. /*
  5.  *  linux/arch/ppc/kernel/setup.c
  6.  *
  7.  *  Copyright (C) 1995  Linus Torvalds
  8.  *  Adapted from 'alpha' version by Gary Thomas
  9.  *  Modified by Cort Dougan (cort@cs.nmt.edu)
  10.  */
  12. /*
  13.  * bootup setup stuff..
  14.  */
  16. #include <linux/config.h>
  17. #include <linux/errno.h>
  18. #include <linux/sched.h>
  19. #include <linux/kernel.h>
  20. #include <linux/mm.h>
  21. #include <linux/stddef.h>
  22. #include <linux/unistd.h>
  23. #include <linux/ptrace.h>
  24. #include <linux/slab.h>
  25. #include <linux/user.h>
  26. #include <linux/a.out.h>
  27. #include <linux/tty.h>
  28. #include <linux/major.h>
  29. #include <linux/interrupt.h>
  30. #include <linux/reboot.h>
  31. #include <linux/init.h>
  32. #include <linux/blk.h>
  33. #include <linux/ioport.h>
  34. #include <linux/console.h>
  35. #include <linux/pci.h>
  36. #include <linux/version.h>
  37. #include <linux/adb.h>
  38. #include <linux/module.h>
  39. #include <linux/delay.h>
  40. #include <linux/ide.h>
  41. #include <linux/seq_file.h>
  43. #include <asm/mmu.h>
  44. #include <asm/processor.h>
  45. #include <asm/io.h>
  46. #include <asm/pgtable.h>
  47. #include <asm/prom.h>
  48. #include <asm/gg2.h>
  49. #include <asm/pci-bridge.h>
  50. #include <asm/dma.h>
  51. #include <asm/machdep.h>
  52. #include <asm/irq.h>
  53. #include <asm/hydra.h>
  54. #include <asm/keyboard.h>
  55. #include <asm/sections.h>
  56. #include <asm/time.h>
  57. #include <asm/btext.h>
  59. #include "local_irq.h"
  60. #include "i8259.h"
  61. #include "open_pic.h"
  62. #include "xics.h"
  64. unsigned long chrp_get_rtc_time(void);
  65. int chrp_set_rtc_time(unsigned long nowtime);
  66. void chrp_calibrate_decr(void);
  67. long chrp_time_init(void);
  69. void chrp_find_bridges(void);
  70. void chrp_event_scan(void);
  71. void rtas_display_progress(char *, unsigned short);
  72. void rtas_indicator_progress(char *, unsigned short);
  73. void btext_progress(char *, unsigned short);
  75. extern unsigned long pmac_find_end_of_memory(void);
  76. extern int pckbd_setkeycode(unsigned int scancode, unsigned int keycode);
  77. extern int pckbd_getkeycode(unsigned int scancode);
  78. extern int pckbd_translate(unsigned char scancode, unsigned char *keycode,
  79.    char raw_mode);
  80. extern char pckbd_unexpected_up(unsigned char keycode);
  81. extern void pckbd_leds(unsigned char leds);
  82. extern void pckbd_init_hw(void);
  83. extern unsigned char pckbd_sysrq_xlate[128];
  84. extern void select_adb_keyboard(void);
  85. extern int of_show_percpuinfo(struct seq_file *, int);
  87. extern kdev_t boot_dev;
  89. extern PTE *Hash, *Hash_end;
  90. extern unsigned long Hash_size, Hash_mask;
  91. extern int probingmem;
  92. extern unsigned long loops_per_jiffy;
  93. static int max_width;
  95. #ifdef CONFIG_SMP
  96. extern struct smp_ops_t chrp_smp_ops;
  97. extern struct smp_ops_t xics_smp_ops;
  98. #endif
  100. static const char *gg2_memtypes[4] = {
  101. "FPM", "SDRAM", "EDO", "BEDO"
  102. };
  103. static const char *gg2_cachesizes[4] = {
  104. "256 KB", "512 KB", "1 MB", "Reserved"
  105. };
  106. static const char *gg2_cachetypes[4] = {
  107. "Asynchronous", "Reserved", "Flow-Through Synchronous",
  108. "Pipelined Synchronous"
  109. };
  110. static const char *gg2_cachemodes[4] = {
  111. "Disabled", "Write-Through", "Copy-Back", "Transparent Mode"
  112. };
  114. int __chrp
  115. chrp_show_cpuinfo(struct seq_file *m)
  116. {
  117. int i, sdramen;
  118. unsigned int t;
  119. struct device_node *root;
  120. const char *model = "";
  122. root = find_path_device("/");
  123. if (root)
  124. model = get_property(root, "model", NULL);
  125. seq_printf(m, "machinett: CHRP %sn", model);
  127. /* longtrail (goldengate) stuff */
  128. if (!strncmp(model, "IBM,LongTrail", 13)) {
  129. /* VLSI VAS96011/12 `Golden Gate 2' */
  130. /* Memory banks */
  131. sdramen = (in_le32((unsigned *)(GG2_PCI_CONFIG_BASE+
  132. GG2_PCI_DRAM_CTRL))
  133.    >>31) & 1;
  134. for (i = 0; i < (sdramen ? 4 : 6); i++) {
  135. t = in_le32((unsigned *)(GG2_PCI_CONFIG_BASE+
  136.  GG2_PCI_DRAM_BANK0+
  137.  i*4));
  138. if (!(t & 1))
  139. continue;
  140. switch ((t>>8) & 0x1f) {
  141. case 0x1f:
  142. model = "4 MB";
  143. break;
  144. case 0x1e:
  145. model = "8 MB";
  146. break;
  147. case 0x1c:
  148. model = "16 MB";
  149. break;
  150. case 0x18:
  151. model = "32 MB";
  152. break;
  153. case 0x10:
  154. model = "64 MB";
  155. break;
  156. case 0x00:
  157. model = "128 MB";
  158. break;
  159. default:
  160. model = "Reserved";
  161. break;
  162. }
  163. seq_printf(m, "memory bank %dt: %s %sn", i, model,
  164.    gg2_memtypes[sdramen ? 1 : ((t>>1) & 3)]);
  165. }
  166. /* L2 cache */
  167. t = in_le32((unsigned *)(GG2_PCI_CONFIG_BASE+GG2_PCI_CC_CTRL));
  168. seq_printf(m, "board l2t: %s %s (%s)n",
  169.    gg2_cachesizes[(t>>7) & 3],
  170.    gg2_cachetypes[(t>>2) & 3],
  171.    gg2_cachemodes[t & 3]);
  172. }
  173. return 0;
  174. }
  176. /*
  177.  *  Fixes for the National Semiconductor PC78308VUL SuperI/O
  178.  *
  179.  *  Some versions of Open Firmware incorrectly initialize the IRQ settings
  180.  *  for keyboard and mouse
  181.  */
  182. static inline void __init sio_write(u8 val, u8 index)
  183. {
  184. outb(index, 0x15c);
  185. outb(val, 0x15d);
  186. }
  188. static inline u8 __init sio_read(u8 index)
  189. {
  190. outb(index, 0x15c);
  191. return inb(0x15d);
  192. }
  194. static void __init sio_fixup_irq(const char *name, u8 device, u8 level,
  195.      u8 type)
  196. {
  197. u8 level0, type0, active;
  199. /* select logical device */
  200. sio_write(device, 0x07);
  201. active = sio_read(0x30);
  202. level0 = sio_read(0x70);
  203. type0 = sio_read(0x71);
  204. if (level0 != level || type0 != type || !active) {
  205. printk(KERN_WARNING "sio: %s irq level %d, type %d, %sactive: "
  206.        "remapping to level %d, type %d, activen",
  207.        name, level0, type0, !active ? "in" : "", level, type);
  208. sio_write(0x01, 0x30);
  209. sio_write(level, 0x70);
  210. sio_write(type, 0x71);
  211. }
  212. }
  214. static void __init sio_init(void)
  215. {
  216. struct device_node *root;
  218. if ((root = find_path_device("/")) &&
  219.     !strncmp(get_property(root, "model", NULL), "IBM,LongTrail", 13)) {
  220. /* logical device 0 (KBC/Keyboard) */
  221. sio_fixup_irq("keyboard", 0, 1, 2);
  222. /* select logical device 1 (KBC/Mouse) */
  223. sio_fixup_irq("mouse", 1, 12, 2);
  224. }
  225. }
  228. void __init
  229. chrp_setup_arch(void)
  230. {
  231. struct device_node *device;
  233. /* init to some ~sane value until calibrate_delay() runs */
  234. loops_per_jiffy = 50000000/HZ;
  236. #ifdef CONFIG_BLK_DEV_INITRD
  237. /* this is fine for chrp */
  238. initrd_below_start_ok = 1;
  240. if (initrd_start)
  241. ROOT_DEV = MKDEV(RAMDISK_MAJOR, 0);
  242. else
  243. #endif
  244. ROOT_DEV = to_kdev_t(0x0802); /* sda2 (sda1 is for the kernel) */
  246. /* Lookup PCI host bridges */
  247. chrp_find_bridges();
  249. #ifndef CONFIG_PPC64BRIDGE
  250. /*
  251.  *  Temporary fixes for PCI devices.
  252.  *  -- Geert
  253.  */
  254. hydra_init(); /* Mac I/O */
  256. #endif /* CONFIG_PPC64BRIDGE */
  258. /* Some IBM machines don't have the hydra -- Cort */
  259. if (!OpenPIC_Addr) {
  260. struct device_node *root;
  261. unsigned long *opprop;
  262. int n;
  264. root = find_path_device("/");
  265. opprop = (unsigned long *) get_property
  266. (root, "platform-open-pic", NULL);
  267. n = prom_n_addr_cells(root);
  268. if (opprop != 0) {
  269. printk("OpenPIC addrs: %lx %lx %lxn",
  270.        opprop[n-1], opprop[2*n-1], opprop[3*n-1]);
  271. OpenPIC_Addr = ioremap(opprop[n-1], 0x40000);
  272. }
  273. }
  275. /*
  276.  *  Fix the Super I/O configuration
  277.  */
  278. sio_init();
  280. /*
  281.  *  Setup the console operations
  282.  */
  283. #ifdef CONFIG_DUMMY_CONSOLE
  284. conswitchp = &dummy_con;
  285. #endif
  287. /* Get the event scan rate for the rtas so we know how
  288.  * often it expects a heartbeat. -- Cort
  289.  */
  290. if ( rtas_data ) {
  291. struct property *p;
  292. device = find_devices("rtas");
  293. for ( p = device->properties;
  294.       p && strncmp(p->name, "rtas-event-scan-rate", 20);
  295.       p = p->next )
  296. /* nothing */ ;
  297. if ( p && *(unsigned long *)p->value ) {
  298. ppc_md.heartbeat = chrp_event_scan;
  299. ppc_md.heartbeat_reset = (HZ/(*(unsigned long *)p->value)*30)-1;
  300. ppc_md.heartbeat_count = 1;
  301. printk("RTAS Event Scan Rate: %lu (%lu jiffies)n",
  302.        *(unsigned long *)p->value, ppc_md.heartbeat_reset );
  303. }
  304. }
  305. }
  307. void __chrp
  308. chrp_event_scan(void)
  309. {
  310. unsigned char log[1024];
  311. unsigned long ret = 0;
  312. /* XXX: we should loop until the hardware says no more error logs -- Cort */
  313. call_rtas( "event-scan", 4, 1, &ret, 0xffffffff, 0,
  314.    __pa(log), 1024 );
  315. ppc_md.heartbeat_count = ppc_md.heartbeat_reset;
  316. }
  318. void __chrp
  319. chrp_restart(char *cmd)
  320. {
  321. printk("RTAS system-reboot returned %dn",
  322.        call_rtas("system-reboot", 0, 1, NULL));
  323. for (;;);
  324. }
  326. void __chrp
  327. chrp_power_off(void)
  328. {
  329. /* allow power on only with power button press */
  330. printk("RTAS power-off returned %dn",
  331.        call_rtas("power-off", 2, 1, NULL,0xffffffff,0xffffffff));
  332. for (;;);
  333. }
  335. void __chrp
  336. chrp_halt(void)
  337. {
  338. chrp_power_off();
  339. }
  341. u_int __chrp
  342. chrp_irq_cannonicalize(u_int irq)
  343. {
  344. if (irq == 2)
  345. return 9;
  346. return irq;
  347. }
  349. void __init chrp_init_IRQ(void)
  350. {
  351. struct device_node *np;
  352. int i;
  353. unsigned int *addrp;
  354. unsigned char* chrp_int_ack_special = 0;
  355. unsigned char init_senses[NR_IRQS - NUM_8259_INTERRUPTS];
  356. int nmi_irq = -1;
  357. #if defined(CONFIG_VT) && defined(CONFIG_ADB_KEYBOARD) && defined(XMON)
  358. struct device_node *kbd;
  359. #endif
  361. if (!(np = find_devices("pci"))
  362.     || !(addrp = (unsigned int *)
  363.  get_property(np, "8259-interrupt-acknowledge", NULL)))
  364. printk("Cannot find pci to get ack addressn");
  365. else
  366. chrp_int_ack_special = (unsigned char *)
  367. ioremap(addrp[prom_n_addr_cells(np)-1], 1);
  368. /* hydra still sets OpenPIC_InitSenses to a static set of values */
  369. if (OpenPIC_InitSenses == NULL) {
  370. prom_get_irq_senses(init_senses, NUM_8259_INTERRUPTS, NR_IRQS);
  371. OpenPIC_InitSenses = init_senses;
  372. OpenPIC_NumInitSenses = NR_IRQS - NUM_8259_INTERRUPTS;
  373. }
  374. openpic_init(1, NUM_8259_INTERRUPTS, chrp_int_ack_special, nmi_irq);
  375. for ( i = 0 ; i < NUM_8259_INTERRUPTS  ; i++ )
  376. irq_desc[i].handler = &i8259_pic;
  377. i8259_init(NULL);
  378. #if defined(CONFIG_VT) && defined(CONFIG_ADB_KEYBOARD) && defined(XMON)
  379. /* see if there is a keyboard in the device tree
  380.    with a parent of type "adb" */
  381. for (kbd = find_devices("keyboard"); kbd; kbd = kbd->next)
  382. if (kbd->parent && kbd->parent->type
  383.     && strcmp(kbd->parent->type, "adb") == 0)
  384. break;
  385. if (kbd)
  386. request_irq( HYDRA_INT_ADB_NMI, xmon_irq, 0, "XMON break", 0);
  387. #endif
  388. }
  390. void __init
  391. chrp_init2(void)
  392. {
  393. #ifdef CONFIG_NVRAM  
  394. pmac_nvram_init();
  395. #endif
  397. request_region(0x20,0x20,"pic1");
  398. request_region(0xa0,0x20,"pic2");
  399. request_region(0x00,0x20,"dma1");
  400. request_region(0x40,0x20,"timer");
  401. request_region(0x80,0x10,"dma page reg");
  402. request_region(0xc0,0x20,"dma2");
  404. if (ppc_md.progress)
  405. ppc_md.progress("  Have fun!    ", 0x7777);
  407. #if defined(CONFIG_VT) && (defined(CONFIG_ADB_KEYBOARD) || defined(CONFIG_INPUT))
  408. /* see if there is a keyboard in the device tree
  409.    with a parent of type "adb" */
  410. {
  411. struct device_node *kbd;
  413. for (kbd = find_devices("keyboard"); kbd; kbd = kbd->next) {
  414. if (kbd->parent && kbd->parent->type
  415.     && strcmp(kbd->parent->type, "adb") == 0) {
  416. select_adb_keyboard();
  417. break;
  418. }
  419. }
  420. }
  421. #endif /* CONFIG_VT && (CONFIG_ADB_KEYBOARD || CONFIG_INPUT) */
  422. }
  424. #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
  425. /*
  426.  * IDE stuff.
  427.  */
  429. static int __chrp
  430. chrp_ide_check_region(ide_ioreg_t from, unsigned int extent)
  431. {
  432.         return check_region(from, extent);
  433. }
  435. static void __chrp
  436. chrp_ide_request_region(ide_ioreg_t from,
  437. unsigned int extent,
  438. const char *name)
  439. {
  440.         request_region(from, extent, name);
  441. }
  443. static void __chrp
  444. chrp_ide_release_region(ide_ioreg_t from,
  445. unsigned int extent)
  446. {
  447.         release_region(from, extent);
  448. }
  450. static void __chrp
  451. chrp_ide_init_hwif_ports(hw_regs_t *hw, ide_ioreg_t data_port, ide_ioreg_t ctrl_port, int *irq)
  452. {
  453. ide_ioreg_t reg = data_port;
  454. int i;
  456. for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
  457. hw->io_ports[i] = reg;
  458. reg += 1;
  459. }
  460. hw->io_ports[IDE_CONTROL_OFFSET] = ctrl_port;
  461. }
  462. #endif
  464. /*
  465.  * One of the main thing these mappings are needed for is so that
  466.  * xmon can get to the serial port early on.  We probably should
  467.  * handle the machines with the mpc106 as well as the python (F50)
  468.  * and the GG2 (longtrail).  Actually we should look in the device
  469.  * tree and do the right thing.
  470.  */
  471. static void __init
  472. chrp_map_io(void)
  473. {
  474. char *name;
  476. /*
  477.  * The code below tends to get removed, please don't take it out.
  478.  * The F50 needs this mapping and it you take it out I'll track you
  479.  * down and slap your hands.  If it causes problems please email me.
  480.  *  -- Cort <cort@fsmlabs.com>
  481.  */
  482. name = get_property(find_path_device("/"), "name", NULL);
  483. if (name && strncmp(name, "IBM-70", 6) == 0
  484.     && strstr(name, "-F50")) {
  485. io_block_mapping(0x80000000, 0x80000000, 0x10000000, _PAGE_IO);
  486. io_block_mapping(0x90000000, 0x90000000, 0x10000000, _PAGE_IO);
  487. return;
  488. } else {
  489. io_block_mapping(0xf8000000, 0xf8000000, 0x04000000, _PAGE_IO);
  490. }
  491. }
  493. void __init
  494. chrp_init(unsigned long r3, unsigned long r4, unsigned long r5,
  495.   unsigned long r6, unsigned long r7)
  496. {
  497. #ifdef CONFIG_BLK_DEV_INITRD
  498. /* take care of initrd if we have one */
  499. if ( r6 )
  500. {
  501. initrd_start = r6 + KERNELBASE;
  502. initrd_end = r6 + r7 + KERNELBASE;
  503. }
  504. #endif /* CONFIG_BLK_DEV_INITRD */
  506. ISA_DMA_THRESHOLD = ~0L;
  507. DMA_MODE_READ = 0x44;
  508. DMA_MODE_WRITE = 0x48;
  509. isa_io_base = CHRP_ISA_IO_BASE; /* default value */
  511. ppc_md.setup_arch     = chrp_setup_arch;
  512. ppc_md.show_percpuinfo = of_show_percpuinfo;
  513. ppc_md.show_cpuinfo   = chrp_show_cpuinfo;
  514. ppc_md.irq_cannonicalize = chrp_irq_cannonicalize;
  515. #ifndef CONFIG_POWER4
  516. ppc_md.init_IRQ       = chrp_init_IRQ;
  517. ppc_md.get_irq        = openpic_get_irq;
  518. #else
  519. ppc_md.init_IRQ       = xics_init_IRQ;
  520. ppc_md.get_irq       = xics_get_irq;
  521. #endif /* CONFIG_POWER4 */
  523. ppc_md.init           = chrp_init2;
  525. ppc_md.restart        = chrp_restart;
  526. ppc_md.power_off      = chrp_power_off;
  527. ppc_md.halt           = chrp_halt;
  529. ppc_md.time_init      = chrp_time_init;
  530. ppc_md.set_rtc_time   = chrp_set_rtc_time;
  531. ppc_md.get_rtc_time   = chrp_get_rtc_time;
  532. ppc_md.calibrate_decr = chrp_calibrate_decr;
  534. ppc_md.find_end_of_memory = pmac_find_end_of_memory;
  535. ppc_md.setup_io_mappings = chrp_map_io;
  537. #ifdef CONFIG_VT
  538. /* these are adjusted in chrp_init2 if we have an ADB keyboard */
  539. ppc_md.kbd_setkeycode    = pckbd_setkeycode;
  540. ppc_md.kbd_getkeycode    = pckbd_getkeycode;
  541. ppc_md.kbd_translate     = pckbd_translate;
  542. ppc_md.kbd_unexpected_up = pckbd_unexpected_up;
  543. ppc_md.kbd_leds          = pckbd_leds;
  544. ppc_md.kbd_init_hw       = pckbd_init_hw;
  545. #ifdef CONFIG_MAGIC_SYSRQ
  546. ppc_md.ppc_kbd_sysrq_xlate  = pckbd_sysrq_xlate;
  547. SYSRQ_KEY = 0x54;
  548. #endif /* CONFIG_MAGIC_SYSRQ */
  549. #endif /* CONFIG_VT */
  551. if (rtas_data) {
  552. struct device_node *rtas;
  553. unsigned int *p;
  555. rtas = find_devices("rtas");
  556. if (rtas != NULL) {
  557. if (get_property(rtas, "display-character", NULL)) {
  558. ppc_md.progress = rtas_display_progress;
  559. p = (unsigned int *) get_property
  560.        (rtas, "ibm,display-line-length", NULL);
  561. if (p)
  562. max_width = *p;
  563. } else if (get_property(rtas, "set-indicator", NULL))
  564. ppc_md.progress = rtas_indicator_progress;
  565. }
  566. }
  567. #ifdef CONFIG_BOOTX_TEXT
  568. if (ppc_md.progress == NULL && boot_text_mapped)
  569. ppc_md.progress = btext_progress;
  570. #endif
  572. #ifdef CONFIG_SMP
  573. #ifndef CONFIG_POWER4
  574. ppc_md.smp_ops = &chrp_smp_ops;
  575. #else
  576. ppc_md.smp_ops = &xics_smp_ops;
  577. #endif /* CONFIG_POWER4 */
  578. #endif /* CONFIG_SMP */
  580. #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
  581.         ppc_ide_md.ide_check_region = chrp_ide_check_region;
  582.         ppc_ide_md.ide_request_region = chrp_ide_request_region;
  583.         ppc_ide_md.ide_release_region = chrp_ide_release_region;
  584.         ppc_ide_md.ide_init_hwif = chrp_ide_init_hwif_ports;
  585. #endif
  587. /*
  588.  * Print the banner, then scroll down so boot progress
  589.  * can be printed.  -- Cort 
  590.  */
  591. if ( ppc_md.progress ) ppc_md.progress("Linux/PPC "UTS_RELEASE"n", 0x0);
  592. }
  594. void __chrp
  595. rtas_display_progress(char *s, unsigned short hex)
  596. {
  597. int width;
  598. char *os = s;
  600. if ( call_rtas( "display-character", 1, 1, NULL, 'r' ) )
  601. return;
  603. width = max_width;
  604. while ( *os )
  605. {
  606. if ( (*os == 'n') || (*os == 'r') )
  607. width = max_width;
  608. else
  609. width--;
  610. call_rtas( "display-character", 1, 1, NULL, *os++ );
  611. /* if we overwrite the screen length */
  612. if ( width == 0 )
  613. while ( (*os != 0) && (*os != 'n') && (*os != 'r') )
  614. os++;
  615. }
  617. /*while ( width-- > 0 )*/
  618. call_rtas( "display-character", 1, 1, NULL, ' ' );
  619. }
  621. void __chrp
  622. rtas_indicator_progress(char *s, unsigned short hex)
  623. {
  624. call_rtas("set-indicator", 3, 1, NULL, 6, 0, hex);
  625. }
  627. #ifdef CONFIG_BOOTX_TEXT
  628. void
  629. btext_progress(char *s, unsigned short hex)
  630. {
  631. prom_print(s);
  632. prom_print("n");
  633. }
  634. #endif /* CONFIG_BOOTX_TEXT */