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

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

嵌入式Linux

开发平台：

Unix_Linux

pmac_setup.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.pmac_setup.c 1.45 12/01/01 20:09:06 benh
  3.  */
  4. /*
  5.  *  linux/arch/ppc/kernel/setup.c
  6.  *
  7.  *  PowerPC version 
  8.  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
  9.  *
  10.  *  Adapted for Power Macintosh by Paul Mackerras
  11.  *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
  12.  *
  13.  *  Derived from "arch/alpha/kernel/setup.c"
  14.  *    Copyright (C) 1995 Linus Torvalds
  15.  *
  16.  *  This program is free software; you can redistribute it and/or
  17.  *  modify it under the terms of the GNU General Public License
  18.  *  as published by the Free Software Foundation; either version
  19.  *  2 of the License, or (at your option) any later version.
  20.  *
  21.  */
  23. /*
  24.  * bootup setup stuff..
  25.  */
  27. #include <linux/config.h>
  28. #include <linux/init.h>
  29. #include <linux/errno.h>
  30. #include <linux/sched.h>
  31. #include <linux/kernel.h>
  32. #include <linux/mm.h>
  33. #include <linux/stddef.h>
  34. #include <linux/unistd.h>
  35. #include <linux/ptrace.h>
  36. #include <linux/slab.h>
  37. #include <linux/user.h>
  38. #include <linux/a.out.h>
  39. #include <linux/tty.h>
  40. #include <linux/string.h>
  41. #include <linux/delay.h>
  42. #include <linux/ioport.h>
  43. #include <linux/major.h>
  44. #include <linux/blk.h>
  45. #include <linux/vt_kern.h>
  46. #include <linux/console.h>
  47. #include <linux/ide.h>
  48. #include <linux/pci.h>
  49. #include <linux/adb.h>
  50. #include <linux/cuda.h>
  51. #include <linux/pmu.h>
  52. #include <linux/seq_file.h>
  54. #include <asm/processor.h>
  55. #include <asm/sections.h>
  56. #include <asm/prom.h>
  57. #include <asm/system.h>
  58. #include <asm/pgtable.h>
  59. #include <asm/bitops.h>
  60. #include <asm/io.h>
  61. #include <asm/pci-bridge.h>
  62. #include <asm/ohare.h>
  63. #include <asm/mediabay.h>
  64. #include <asm/machdep.h>
  65. #include <asm/keyboard.h>
  66. #include <asm/dma.h>
  67. #include <asm/bootx.h>
  68. #include <asm/cputable.h>
  69. #include <asm/btext.h>
  71. #include <asm/pmac_feature.h>
  72. #include <asm/time.h>
  73. #include "local_irq.h"
  74. #include "pmac_pic.h"
  75. #include "../mm/mem_pieces.h"
  77. #undef SHOW_GATWICK_IRQS
  79. extern long pmac_time_init(void);
  80. extern unsigned long pmac_get_rtc_time(void);
  81. extern int pmac_set_rtc_time(unsigned long nowtime);
  82. extern void pmac_read_rtc_time(void);
  83. extern void pmac_calibrate_decr(void);
  84. extern void pmac_pcibios_fixup(void);
  85. extern void pmac_find_bridges(void);
  86. extern int pmac_ide_check_base(ide_ioreg_t base);
  87. extern ide_ioreg_t pmac_ide_get_base(int index);
  88. extern void pmac_ide_init_hwif_ports(hw_regs_t *hw,
  89. ide_ioreg_t data_port, ide_ioreg_t ctrl_port, int *irq);
  91. extern int mackbd_setkeycode(unsigned int scancode, unsigned int keycode);
  92. extern int mackbd_getkeycode(unsigned int scancode);
  93. extern int mackbd_translate(unsigned char keycode, unsigned char *keycodep,
  94.      char raw_mode);
  95. extern char mackbd_unexpected_up(unsigned char keycode);
  96. extern void mackbd_leds(unsigned char leds);
  97. extern void __init mackbd_init_hw(void);
  98. extern int mac_hid_kbd_translate(unsigned char scancode, unsigned char *keycode,
  99.  char raw_mode);
  100. extern char mac_hid_kbd_unexpected_up(unsigned char keycode);
  101. extern void mac_hid_init_hw(void);
  102. extern unsigned char mac_hid_kbd_sysrq_xlate[];
  103. extern unsigned char pckbd_sysrq_xlate[];
  104. extern unsigned char mackbd_sysrq_xlate[];
  105. extern int pckbd_setkeycode(unsigned int scancode, unsigned int keycode);
  106. extern int pckbd_getkeycode(unsigned int scancode);
  107. extern int pckbd_translate(unsigned char scancode, unsigned char *keycode,
  108.    char raw_mode);
  109. extern char pckbd_unexpected_up(unsigned char keycode);
  110. extern int keyboard_sends_linux_keycodes;
  111. extern void pmac_nvram_update(void);
  113. extern int pmac_pci_enable_device_hook(struct pci_dev *dev, int initial);
  114. extern void pmac_pcibios_after_init(void);
  116. struct device_node *memory_node;
  118. unsigned char drive_info;
  120. int ppc_override_l2cr = 0;
  121. int ppc_override_l2cr_value;
  122. int has_l2cache = 0;
  124. static int current_root_goodness = -1;
  126. extern char saved_command_line[];
  128. extern int pmac_newworld;
  130. #define DEFAULT_ROOT_DEVICE 0x0801 /* sda1 - slightly silly choice */
  132. extern void zs_kgdb_hook(int tty_num);
  133. static void ohare_init(void);
  134. #ifdef CONFIG_BOOTX_TEXT
  135. void pmac_progress(char *s, unsigned short hex);
  136. #endif
  138. sys_ctrler_t sys_ctrler = SYS_CTRLER_UNKNOWN;
  140. #ifdef CONFIG_SMP
  141. extern struct smp_ops_t psurge_smp_ops;
  142. extern struct smp_ops_t core99_smp_ops;
  144. volatile static long int core99_l2_cache;
  145. void __init
  146. core99_init_l2(void)
  147. {
  148. int cpu = smp_processor_id();
  150. if (!(cur_cpu_spec[0]->cpu_features & CPU_FTR_L2CR))
  151. return;
  153. if (cpu == 0){
  154. core99_l2_cache = _get_L2CR();
  155. printk("CPU0: L2CR is %lxn", core99_l2_cache);
  156. } else {
  157. printk("CPU%d: L2CR was %lxn", cpu, _get_L2CR());
  158. _set_L2CR(0);
  159. _set_L2CR(core99_l2_cache);
  160. printk("CPU%d: L2CR set to %lxn", cpu, core99_l2_cache);
  161. }
  162. }
  163. #endif /* CONFIG_SMP */
  165. /*
  166.  * Assume here that all clock rates are the same in a
  167.  * smp system.  -- Cort
  168.  */
  169. int __openfirmware
  170. of_show_percpuinfo(struct seq_file *m, int i)
  171. {
  172. struct device_node *cpu_node;
  173. int *fp, s;
  175. cpu_node = find_type_devices("cpu");
  176. if (!cpu_node)
  177. return 0;
  178. for (s = 0; s < i && cpu_node->next; s++)
  179. cpu_node = cpu_node->next;
  180. fp = (int *) get_property(cpu_node, "clock-frequency", NULL);
  181. if (fp)
  182. seq_printf(m, "clocktt: %dMHzn", *fp / 1000000);
  183. return 0;
  184. }
  186. int __pmac
  187. pmac_show_cpuinfo(struct seq_file *m)
  188. {
  189. struct device_node *np;
  190. char *pp;
  191. int plen;
  193. /* find motherboard type */
  194. seq_printf(m, "machinett: ");
  195. np = find_devices("device-tree");
  196. if (np != NULL) {
  197. pp = (char *) get_property(np, "model", NULL);
  198. if (pp != NULL)
  199. seq_printf(m, "%sn", pp);
  200. else
  201. seq_printf(m, "PowerMacn");
  202. pp = (char *) get_property(np, "compatible", &plen);
  203. if (pp != NULL) {
  204. seq_printf(m, "motherboardt:");
  205. while (plen > 0) {
  206. int l = strlen(pp) + 1;
  207. seq_printf(m, " %s", pp);
  208. plen -= l;
  209. pp += l;
  210. }
  211. seq_printf(m, "n");
  212. }
  213. } else
  214. seq_printf(m, "PowerMacn");
  216. /* find l2 cache info */
  217. np = find_devices("l2-cache");
  218. if (np == 0)
  219. np = find_type_devices("cache");
  220. if (np != 0) {
  221. unsigned int *ic = (unsigned int *)
  222. get_property(np, "i-cache-size", NULL);
  223. unsigned int *dc = (unsigned int *)
  224. get_property(np, "d-cache-size", NULL);
  225. seq_printf(m, "L2 cachet:");
  226. has_l2cache = 1;
  227. if (get_property(np, "cache-unified", NULL) != 0 && dc) {
  228. seq_printf(m, " %dK unified", *dc / 1024);
  229. } else {
  230. if (ic)
  231. seq_printf(m, " %dK instruction", *ic / 1024);
  232. if (dc)
  233. seq_printf(m, "%s %dK data",
  234.    (ic? " +": ""), *dc / 1024);
  235. }
  236. pp = get_property(np, "ram-type", NULL);
  237. if (pp)
  238. seq_printf(m, " %s", pp);
  239. seq_printf(m, "n");
  240. }
  242. /* find ram info */
  243. np = find_devices("memory");
  244. if (np != 0) {
  245. int n;
  246. struct reg_property *reg = (struct reg_property *)
  247. get_property(np, "reg", &n);
  249. if (reg != 0) {
  250. unsigned long total = 0;
  252. for (n /= sizeof(struct reg_property); n > 0; --n)
  253. total += (reg++)->size;
  254. seq_printf(m, "memorytt: %luMBn", total >> 20);
  255. }
  256. }
  258. /* Checks "l2cr-value" property in the registry */
  259. np = find_devices("cpus");
  260. if (np == 0)
  261. np = find_type_devices("cpu");
  262. if (np != 0) {
  263. unsigned int *l2cr = (unsigned int *)
  264. get_property(np, "l2cr-value", NULL);
  265. if (l2cr != 0) {
  266. seq_printf(m, "l2cr overridet: 0x%xn", *l2cr);
  267. }
  268. }
  270. /* Indicate newworld/oldworld */
  271. seq_printf(m, "pmac-generationt: %sn",
  272.    pmac_newworld ? "NewWorld" : "OldWorld");
  275. return 0;
  276. }
  278. #ifdef CONFIG_SCSI
  279. /* Find the device number for the disk (if any) at target tgt
  280.    on host adaptor host.  We just need to get the prototype from
  281.    sd.h */
  282. #include <linux/blkdev.h>
  283. #include "../../../drivers/scsi/scsi.h"
  284. #include "../../../drivers/scsi/sd.h"
  286. #endif
  288. #ifdef CONFIG_VT
  289. /*
  290.  * Dummy mksound function that does nothing.
  291.  * The real one is in the dmasound driver.
  292.  */
  293. static void __pmac
  294. pmac_mksound(unsigned int hz, unsigned int ticks)
  295. {
  296. }
  297. #endif /* CONFIG_VT */
  299. static volatile u32 *sysctrl_regs;
  301. void __init
  302. pmac_setup_arch(void)
  303. {
  304. struct device_node *cpu;
  305. int *fp;
  306. unsigned long pvr;
  308. pvr = PVR_VER(mfspr(PVR));
  310. /* Set loops_per_jiffy to a half-way reasonable value,
  311.    for use until calibrate_delay gets called. */
  312. cpu = find_type_devices("cpu");
  313. if (cpu != 0) {
  314. fp = (int *) get_property(cpu, "clock-frequency", NULL);
  315. if (fp != 0) {
  316. if (pvr == 4 || pvr >= 8)
  317. /* 604, G3, G4 etc. */
  318. loops_per_jiffy = *fp / HZ;
  319. else
  320. /* 601, 603, etc. */
  321. loops_per_jiffy = *fp / (2*HZ);
  322. } else
  323. loops_per_jiffy = 50000000 / HZ;
  324. }
  326. /* this area has the CPU identification register
  327.    and some registers used by smp boards */
  328. sysctrl_regs = (volatile u32 *) ioremap(0xf8000000, 0x1000);
  329. ohare_init();
  331. /* Lookup PCI hosts */
  332. pmac_find_bridges();
  334. /* Checks "l2cr-value" property in the registry */
  335. if (cur_cpu_spec[0]->cpu_features & CPU_FTR_L2CR) {
  336. struct device_node *np = find_devices("cpus");
  337. if (np == 0)
  338. np = find_type_devices("cpu");
  339. if (np != 0) {
  340. unsigned int *l2cr = (unsigned int *)
  341. get_property(np, "l2cr-value", NULL);
  342. if (l2cr != 0) {
  343. ppc_override_l2cr = 1;
  344. ppc_override_l2cr_value = *l2cr;
  345. _set_L2CR(0);
  346. _set_L2CR(ppc_override_l2cr_value);
  347. }
  348. }
  349. }
  351. if (ppc_override_l2cr)
  352. printk(KERN_INFO "L2CR overriden (0x%x), backside cache is %sn",
  353. ppc_override_l2cr_value, (ppc_override_l2cr_value & 0x80000000)
  354. ? "enabled" : "disabled");
  356. #ifdef CONFIG_SMP
  357. /* somewhat of a hack */
  358. core99_init_l2();
  359. #endif
  361. #ifdef CONFIG_KGDB
  362. zs_kgdb_hook(0);
  363. #endif
  365. #ifdef CONFIG_ADB_CUDA
  366. find_via_cuda();
  367. #else
  368. if (find_devices("via-cuda")) {
  369. printk("WARNING ! Your machine is Cuda based but your kerneln");
  370. printk("          wasn't compiled with CONFIG_ADB_CUDA option !n");
  371. }
  372. #endif
  373. #ifdef CONFIG_ADB_PMU
  374. find_via_pmu();
  375. #else
  376. if (find_devices("via-pmu")) {
  377. printk("WARNING ! Your machine is PMU based but your kerneln");
  378. printk("          wasn't compiled with CONFIG_ADB_PMU option !n");
  379. }
  380. #endif
  381. #ifdef CONFIG_NVRAM
  382. pmac_nvram_init();
  383. #endif
  384. #ifdef CONFIG_DUMMY_CONSOLE
  385. conswitchp = &dummy_con;
  386. #endif
  387. #ifdef CONFIG_VT
  388. kd_mksound = pmac_mksound;
  389. #endif
  390. #ifdef CONFIG_BLK_DEV_INITRD
  391. if (initrd_start)
  392. ROOT_DEV = MKDEV(RAMDISK_MAJOR, 0);
  393. else
  394. #endif
  395. ROOT_DEV = to_kdev_t(DEFAULT_ROOT_DEVICE);
  397. #ifdef CONFIG_SMP
  398. /* Check for Core99 */
  399. if (find_devices("uni-n"))
  400. ppc_md.smp_ops = &core99_smp_ops;
  401. else
  402. ppc_md.smp_ops = &psurge_smp_ops;
  403. #endif /* CONFIG_SMP */
  404. }
  406. static void __init ohare_init(void)
  407. {
  408. /*
  409.  * Turn on the L2 cache.
  410.  * We assume that we have a PSX memory controller iff
  411.  * we have an ohare I/O controller.
  412.  */
  413. if (find_devices("ohare") != NULL) {
  414. if (((sysctrl_regs[2] >> 24) & 0xf) >= 3) {
  415. if (sysctrl_regs[4] & 0x10)
  416. sysctrl_regs[4] |= 0x04000020;
  417. else
  418. sysctrl_regs[4] |= 0x04000000;
  419. if(has_l2cache)
  420. printk(KERN_INFO "Level 2 cache enabledn");
  421. }
  422. }
  423. }
  425. extern char *bootpath;
  426. extern char *bootdevice;
  427. void *boot_host;
  428. int boot_target;
  429. int boot_part;
  430. extern kdev_t boot_dev;
  432. void __init
  433. pmac_init2(void)
  434. {
  435. #ifdef CONFIG_ADB_PMU
  436. via_pmu_start();
  437. #endif
  438. #ifdef CONFIG_ADB_CUDA
  439. via_cuda_start();
  440. #endif
  441. #ifdef CONFIG_PMAC_PBOOK
  442. media_bay_init();
  443. #endif
  444. pmac_feature_late_init();
  445. }
  447. #ifdef CONFIG_SCSI
  448. void __init
  449. note_scsi_host(struct device_node *node, void *host)
  450. {
  451. int l;
  452. char *p;
  454. l = strlen(node->full_name);
  455. if (bootpath != NULL && bootdevice != NULL
  456.     && strncmp(node->full_name, bootdevice, l) == 0
  457.     && (bootdevice[l] == '/' || bootdevice[l] == 0)) {
  458. boot_host = host;
  459. /*
  460.  * There's a bug in OF 1.0.5.  (Why am I not surprised.)
  461.  * If you pass a path like scsi/sd@1:0 to canon, it returns
  462.  * something like /bandit@F2000000/gc@10/53c94@10000/sd@0,0
  463.  * That is, the scsi target number doesn't get preserved.
  464.  * So we pick the target number out of bootpath and use that.
  465.  */
  466. p = strstr(bootpath, "/sd@");
  467. if (p != NULL) {
  468. p += 4;
  469. boot_target = simple_strtoul(p, NULL, 10);
  470. p = strchr(p, ':');
  471. if (p != NULL)
  472. boot_part = simple_strtoul(p + 1, NULL, 10);
  473. }
  474. }
  475. }
  476. #endif
  478. #if defined(CONFIG_BLK_DEV_IDE) && defined(CONFIG_BLK_DEV_IDE_PMAC)
  479. kdev_t __init
  480. find_ide_boot(void)
  481. {
  482. char *p;
  483. int n;
  484. kdev_t __init pmac_find_ide_boot(char *bootdevice, int n);
  486. if (bootdevice == NULL)
  487. return 0;
  488. p = strrchr(bootdevice, '/');
  489. if (p == NULL)
  490. return 0;
  491. n = p - bootdevice;
  493. return pmac_find_ide_boot(bootdevice, n);
  494. }
  495. #endif /* CONFIG_BLK_DEV_IDE && CONFIG_BLK_DEV_IDE_PMAC */
  497. void __init
  498. find_boot_device(void)
  499. {
  500. #if defined(CONFIG_SCSI) && defined(CONFIG_BLK_DEV_SD)
  501. if (boot_host != NULL) {
  502. boot_dev = sd_find_target(boot_host, boot_target);
  503. if (boot_dev != 0)
  504. return;
  505. }
  506. #endif
  507. #if defined(CONFIG_BLK_DEV_IDE) && defined(CONFIG_BLK_DEV_IDE_PMAC)
  508. boot_dev = find_ide_boot();
  509. #endif
  510. }
  512. /* can't be __init - can be called whenever a disk is first accessed */
  513. void __pmac
  514. note_bootable_part(kdev_t dev, int part, int goodness)
  515. {
  516. static int found_boot = 0;
  517. char *p;
  519. /* Do nothing if the root has been mounted already. */
  520. if (init_task.fs->rootmnt != NULL)
  521. return;
  522. if ((goodness <= current_root_goodness) &&
  523.     (ROOT_DEV != to_kdev_t(DEFAULT_ROOT_DEVICE)))
  524. return;
  525. p = strstr(saved_command_line, "root=");
  526. if (p != NULL && (p == saved_command_line || p[-1] == ' '))
  527. return;
  529. if (!found_boot) {
  530. find_boot_device();
  531. found_boot = 1;
  532. }
  533. if (boot_dev == 0 || dev == boot_dev) {
  534. ROOT_DEV = MKDEV(MAJOR(dev), MINOR(dev) + part);
  535. boot_dev = NODEV;
  536. current_root_goodness = goodness;
  537. }
  538. }
  540. void __pmac
  541. pmac_restart(char *cmd)
  542. {
  543. #ifdef CONFIG_ADB_CUDA
  544. struct adb_request req;
  545. #endif /* CONFIG_ADB_CUDA */
  547. #ifdef CONFIG_NVRAM
  548. pmac_nvram_update();
  549. #endif
  551. switch (sys_ctrler) {
  552. #ifdef CONFIG_ADB_CUDA
  553. case SYS_CTRLER_CUDA:
  554. cuda_request(&req, NULL, 2, CUDA_PACKET,
  555.      CUDA_RESET_SYSTEM);
  556. for (;;)
  557. cuda_poll();
  558. break;
  559. #endif /* CONFIG_ADB_CUDA */
  560. #ifdef CONFIG_ADB_PMU
  561. case SYS_CTRLER_PMU:
  562. pmu_restart();
  563. break;
  564. #endif /* CONFIG_ADB_PMU */
  565. default: ;
  566. }
  567. }
  569. void __pmac
  570. pmac_power_off(void)
  571. {
  572. #ifdef CONFIG_ADB_CUDA
  573. struct adb_request req;
  574. #endif /* CONFIG_ADB_CUDA */
  576. #ifdef CONFIG_NVRAM
  577. pmac_nvram_update();
  578. #endif
  580. switch (sys_ctrler) {
  581. #ifdef CONFIG_ADB_CUDA
  582. case SYS_CTRLER_CUDA:
  583. cuda_request(&req, NULL, 2, CUDA_PACKET,
  584.      CUDA_POWERDOWN);
  585. for (;;)
  586. cuda_poll();
  587. break;
  588. #endif /* CONFIG_ADB_CUDA */
  589. #ifdef CONFIG_ADB_PMU
  590. case SYS_CTRLER_PMU:
  591. pmu_shutdown();
  592. break;
  593. #endif /* CONFIG_ADB_PMU */
  594. default: ;
  595. }
  596. }
  598. void __pmac
  599. pmac_halt(void)
  600. {
  601.    pmac_power_off();
  602. }
  605. #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
  606. /*
  607.  * IDE stuff.
  608.  */
  609. static int __pmac
  610. pmac_ide_check_region(ide_ioreg_t from, unsigned int extent)
  611. {
  612. #ifdef CONFIG_BLK_DEV_IDE_PMAC
  613. if (pmac_ide_check_base(from) >= 0)
  614. return 0;
  615. #endif
  616. return check_region(from, extent);
  617. }
  619. static void __pmac
  620. pmac_ide_request_region(ide_ioreg_t from,
  621. unsigned int extent,
  622. const char *name)
  623. {
  624. #ifdef CONFIG_BLK_DEV_IDE_PMAC
  625. if (pmac_ide_check_base(from) >= 0)
  626. return;
  627. #endif
  628. request_region(from, extent, name);
  629. }
  631. static void __pmac
  632. pmac_ide_release_region(ide_ioreg_t from,
  633. unsigned int extent)
  634. {
  635. #ifdef CONFIG_BLK_DEV_IDE_PMAC
  636. if (pmac_ide_check_base(from) >= 0)
  637. return;
  638. #endif
  639. release_region(from, extent);
  640. }
  642. #ifndef CONFIG_BLK_DEV_IDE_PMAC
  643. /*
  644.  * This is only used if we have a PCI IDE controller, not
  645.  * for the IDE controller in the ohare/paddington/heathrow/keylargo.
  646.  */
  647. static void __pmac
  648. pmac_ide_pci_init_hwif_ports(hw_regs_t *hw, ide_ioreg_t data_port,
  649. ide_ioreg_t ctrl_port, int *irq)
  650. {
  651. ide_ioreg_t reg = data_port;
  652. int i;
  654. for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
  655. hw->io_ports[i] = reg;
  656. reg += 1;
  657. }
  658. hw->io_ports[IDE_CONTROL_OFFSET] = ctrl_port;
  659. }
  660. #endif /* CONFIG_BLK_DEV_IDE_PMAC */
  661. #endif /* defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE) */
  663. /*
  664.  * Read in a property describing some pieces of memory.
  665.  */
  667. static void __init
  668. get_mem_prop(char *name, struct mem_pieces *mp)
  669. {
  670. struct reg_property *rp;
  671. int i, s;
  672. unsigned int *ip;
  673. int nac = prom_n_addr_cells(memory_node);
  674. int nsc = prom_n_size_cells(memory_node);
  676. ip = (unsigned int *) get_property(memory_node, name, &s);
  677. if (ip == NULL) {
  678. printk(KERN_ERR "error: couldn't get %s property on /memoryn",
  679.        name);
  680. abort();
  681. }
  682. s /= (nsc + nac) * 4;
  683. rp = mp->regions;
  684. for (i = 0; i < s; ++i, ip += nac+nsc) {
  685. if (nac >= 2 && ip[nac-2] != 0)
  686. continue;
  687. rp->address = ip[nac-1];
  688. if (nsc >= 2 && ip[nac+nsc-2] != 0)
  689. rp->size = ~0U;
  690. else
  691. rp->size = ip[nac+nsc-1];
  692. ++rp;
  693. }
  694. mp->n_regions = rp - mp->regions;
  696. /* Make sure the pieces are sorted. */
  697. mem_pieces_sort(mp);
  698. mem_pieces_coalesce(mp);
  699. }
  701. /*
  702.  * On systems with Open Firmware, collect information about
  703.  * physical RAM and which pieces are already in use.
  704.  * At this point, we have (at least) the first 8MB mapped with a BAT.
  705.  * Our text, data, bss use something over 1MB, starting at 0.
  706.  * Open Firmware may be using 1MB at the 4MB point.
  707.  */
  708. unsigned long __init
  709. pmac_find_end_of_memory(void)
  710. {
  711. unsigned long a, total;
  712. struct mem_pieces phys_mem;
  714. memory_node = find_devices("memory");
  715. if (memory_node == NULL) {
  716. printk(KERN_ERR "can't find memory noden");
  717. abort();
  718. }
  720. /*
  721.  * Find out where physical memory is, and check that it
  722.  * starts at 0 and is contiguous.  It seems that RAM is
  723.  * always physically contiguous on Power Macintoshes.
  724.  *
  725.  * Supporting discontiguous physical memory isn't hard,
  726.  * it just makes the virtual <-> physical mapping functions
  727.  * more complicated (or else you end up wasting space
  728.  * in mem_map).
  729.  */
  730. get_mem_prop("reg", &phys_mem);
  731. if (phys_mem.n_regions == 0)
  732. panic("No RAM??");
  733. a = phys_mem.regions[0].address;
  734. if (a != 0)
  735. panic("RAM doesn't start at physical address 0");
  736. total = phys_mem.regions[0].size;
  738. if (phys_mem.n_regions > 1) {
  739. printk("RAM starting at 0x%x is not contiguousn",
  740.        phys_mem.regions[1].address);
  741. printk("Using RAM from 0 to 0x%lxn", total-1);
  742. }
  744. return total;
  745. }
  747. void __init
  748. select_adb_keyboard(void)
  749. {
  750. #ifdef CONFIG_VT
  751. #ifdef CONFIG_INPUT
  752. ppc_md.kbd_init_hw       = mac_hid_init_hw;
  753. ppc_md.kbd_translate     = mac_hid_kbd_translate;
  754. ppc_md.kbd_unexpected_up = mac_hid_kbd_unexpected_up;
  755. ppc_md.kbd_setkeycode    = 0;
  756. ppc_md.kbd_getkeycode    = 0;
  757. ppc_md.kbd_leds  = 0;
  758. #ifdef CONFIG_MAGIC_SYSRQ
  759. #ifdef CONFIG_MAC_ADBKEYCODES
  760. if (!keyboard_sends_linux_keycodes) {
  761. ppc_md.ppc_kbd_sysrq_xlate = mac_hid_kbd_sysrq_xlate;
  762. SYSRQ_KEY = 0x69;
  763. } else
  764. #endif /* CONFIG_MAC_ADBKEYCODES */
  765. {
  766. ppc_md.ppc_kbd_sysrq_xlate = pckbd_sysrq_xlate;
  767. SYSRQ_KEY = 0x54;
  768. }
  769. #endif /* CONFIG_MAGIC_SYSRQ */
  770. #elif defined(CONFIG_ADB_KEYBOARD)
  771. ppc_md.kbd_setkeycode       = mackbd_setkeycode;
  772. ppc_md.kbd_getkeycode       = mackbd_getkeycode;
  773. ppc_md.kbd_translate        = mackbd_translate;
  774. ppc_md.kbd_unexpected_up    = mackbd_unexpected_up;
  775. ppc_md.kbd_leds             = mackbd_leds;
  776. ppc_md.kbd_init_hw          = mackbd_init_hw;
  777. #ifdef CONFIG_MAGIC_SYSRQ
  778. ppc_md.ppc_kbd_sysrq_xlate  = mackbd_sysrq_xlate;
  779. SYSRQ_KEY = 0x69;
  780. #endif /* CONFIG_MAGIC_SYSRQ */
  781. #endif /* CONFIG_INPUT_ADBHID/CONFIG_ADB_KEYBOARD */
  782. #endif /* CONFIG_VT */
  783. }
  785. void __init
  786. pmac_init(unsigned long r3, unsigned long r4, unsigned long r5,
  787.   unsigned long r6, unsigned long r7)
  788. {
  789. /* isa_io_base gets set in pmac_find_bridges */
  790. isa_mem_base = PMAC_ISA_MEM_BASE;
  791. pci_dram_offset = PMAC_PCI_DRAM_OFFSET;
  792. ISA_DMA_THRESHOLD = ~0L;
  793. DMA_MODE_READ = 1;
  794. DMA_MODE_WRITE = 2;
  796. ppc_md.setup_arch     = pmac_setup_arch;
  797. ppc_md.show_cpuinfo   = pmac_show_cpuinfo;
  798. ppc_md.show_percpuinfo = of_show_percpuinfo;
  799. ppc_md.irq_cannonicalize = NULL;
  800. ppc_md.init_IRQ       = pmac_pic_init;
  801. ppc_md.get_irq        = pmac_get_irq; /* Changed later on ... */
  802. ppc_md.init           = pmac_init2;
  804. ppc_md.pcibios_fixup  = pmac_pcibios_fixup;
  805. ppc_md.pcibios_enable_device_hook = pmac_pci_enable_device_hook;
  806. ppc_md.pcibios_after_init = pmac_pcibios_after_init;
  808. ppc_md.restart        = pmac_restart;
  809. ppc_md.power_off      = pmac_power_off;
  810. ppc_md.halt           = pmac_halt;
  812. ppc_md.time_init      = pmac_time_init;
  813. ppc_md.set_rtc_time   = pmac_set_rtc_time;
  814. ppc_md.get_rtc_time   = pmac_get_rtc_time;
  815. ppc_md.calibrate_decr = pmac_calibrate_decr;
  817. ppc_md.find_end_of_memory = pmac_find_end_of_memory;
  819. ppc_md.feature_call   = pmac_do_feature_call;
  821. select_adb_keyboard();
  823. #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
  824.         ppc_ide_md.ide_check_region = pmac_ide_check_region;
  825.         ppc_ide_md.ide_request_region = pmac_ide_request_region;
  826.         ppc_ide_md.ide_release_region = pmac_ide_release_region;
  827. #ifdef CONFIG_BLK_DEV_IDE_PMAC
  828.         ppc_ide_md.ide_init_hwif = pmac_ide_init_hwif_ports;
  829.         ppc_ide_md.default_io_base = pmac_ide_get_base;
  830. #else /* CONFIG_BLK_DEV_IDE_PMAC */
  831.         ppc_ide_md.ide_init_hwif = pmac_ide_pci_init_hwif_ports;
  832. #endif /* CONFIG_BLK_DEV_IDE_PMAC */
  833. #endif /* defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE) */
  835. #ifdef CONFIG_BOOTX_TEXT
  836. ppc_md.progress = pmac_progress;
  837. #endif /* CONFIG_BOOTX_TEXT */
  839. if (ppc_md.progress) ppc_md.progress("pmac_init(): exit", 0);
  841. }
  843. #ifdef CONFIG_BOOTX_TEXT
  844. extern void drawchar(char c);
  845. extern void drawstring(const char *c);
  846. extern boot_infos_t *disp_bi;
  847. void __init
  848. pmac_progress(char *s, unsigned short hex)
  849. {
  850. if (disp_bi == 0)
  851. return;
  852. btext_drawstring(s);
  853. btext_drawchar('n');
  854. }
  855. #endif /* CONFIG_BOOTX_TEXT */