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

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

Linux/Unix编程

开发平台：

Unix_Linux

setup.c：源码内容
  1. /*
  2.  *  linux/arch/alpha/kernel/setup.c
  3.  *
  4.  *  Copyright (C) 1995  Linus Torvalds
  5.  */
  7. /* 2.3.x bootmem, 1999 Andrea Arcangeli <andrea@suse.de> */
  9. /*
  10.  * Bootup setup stuff.
  11.  */
  13. #include <linux/sched.h>
  14. #include <linux/kernel.h>
  15. #include <linux/mm.h>
  16. #include <linux/stddef.h>
  17. #include <linux/unistd.h>
  18. #include <linux/ptrace.h>
  19. #include <linux/slab.h>
  20. #include <linux/user.h>
  21. #include <linux/a.out.h>
  22. #include <linux/tty.h>
  23. #include <linux/delay.h>
  24. #include <linux/config.h> /* CONFIG_ALPHA_LCA etc */
  25. #include <linux/mc146818rtc.h>
  26. #include <linux/console.h>
  27. #include <linux/errno.h>
  28. #include <linux/init.h>
  29. #include <linux/string.h>
  30. #include <linux/ioport.h>
  31. #include <linux/bootmem.h>
  32. #include <linux/pci.h>
  33. #include <linux/seq_file.h>
  35. #ifdef CONFIG_BLK_DEV_INITRD
  36. #include <linux/blk.h>
  37. #endif
  39. #include <linux/notifier.h>
  40. extern struct notifier_block *panic_notifier_list;
  41. static int alpha_panic_event(struct notifier_block *, unsigned long, void *);
  42. static struct notifier_block alpha_panic_block = {
  43. alpha_panic_event,
  44.         NULL,
  45.         INT_MAX /* try to do it first */
  46. };
  48. #include <asm/uaccess.h>
  49. #include <asm/pgtable.h>
  50. #include <asm/system.h>
  51. #include <asm/hwrpb.h>
  52. #include <asm/dma.h>
  53. #include <asm/io.h>
  54. #include <asm/mmu_context.h>
  55. #include <asm/console.h>
  57. #include "proto.h"
  58. #include "pci_impl.h"
  61. struct hwrpb_struct *hwrpb;
  62. unsigned long srm_hae;
  64. /* Which processor we booted from.  */
  65. int boot_cpuid;
  67. /*
  68.  * Using SRM callbacks for initial console output. This works from
  69.  * setup_arch() time through the end of time_init(), as those places
  70.  * are under our (Alpha) control.
  72.  * "srmcons" specified in the boot command arguments allows us to
  73.  * see kernel messages during the period of time before the true
  74.  * console device is "registered" during console_init(). As of this
  75.  * version (2.4.10), time_init() is the last Alpha-specific code
  76.  * called before console_init(), so we put "unregister" code
  77.  * there to prevent schizophrenic console behavior later... ;-}
  78.  *
  79.  * By default, OFF; set it with a bootcommand arg of "srmcons".
  80.  */
  81. int srmcons_output = 0;
  83. /* Enforce a memory size limit; useful for testing. By default, none. */
  84. unsigned long mem_size_limit = 0;
  86. #ifdef CONFIG_ALPHA_GENERIC
  87. struct alpha_machine_vector alpha_mv;
  88. int alpha_using_srm;
  89. #endif
  91. unsigned char aux_device_present = 0xaa;
  93. #define N(a) (sizeof(a)/sizeof(a[0]))
  95. static struct alpha_machine_vector *get_sysvec(long, long, long);
  96. static struct alpha_machine_vector *get_sysvec_byname(const char *);
  97. static void get_sysnames(long, long, long, char **, char **);
  99. static char command_line[COMMAND_LINE_SIZE];
  100. char saved_command_line[COMMAND_LINE_SIZE];
  102. /*
  103.  * The format of "screen_info" is strange, and due to early
  104.  * i386-setup code. This is just enough to make the console
  105.  * code think we're on a VGA color display.
  106.  */
  108. struct screen_info screen_info = {
  109. orig_x: 0,
  110. orig_y: 25,
  111. orig_video_cols: 80,
  112. orig_video_lines: 25,
  113. orig_video_isVGA: 1,
  114. orig_video_points: 16
  115. };
  117. /*
  118.  * The direct map I/O window, if any.  This should be the same
  119.  * for all busses, since it's used by virt_to_bus.
  120.  */
  122. unsigned long __direct_map_base;
  123. unsigned long __direct_map_size;
  125. /*
  126.  * Declare all of the machine vectors.
  127.  */
  129. /* GCC 2.7.2 (on alpha at least) is lame.  It does not support either 
  130.    __attribute__((weak)) or #pragma weak.  Bypass it and talk directly
  131.    to the assembler.  */
  133. #define WEAK(X) 
  134. extern struct alpha_machine_vector X; 
  135. asm(".weak "#X)
  137. WEAK(alcor_mv);
  138. WEAK(alphabook1_mv);
  139. WEAK(avanti_mv);
  140. WEAK(cabriolet_mv);
  141. WEAK(clipper_mv);
  142. WEAK(dp264_mv);
  143. WEAK(eb164_mv);
  144. WEAK(eb64p_mv);
  145. WEAK(eb66_mv);
  146. WEAK(eb66p_mv);
  147. WEAK(eiger_mv);
  148. WEAK(jensen_mv);
  149. WEAK(lx164_mv);
  150. WEAK(miata_mv);
  151. WEAK(mikasa_mv);
  152. WEAK(mikasa_primo_mv);
  153. WEAK(monet_mv);
  154. WEAK(nautilus_mv);
  155. WEAK(noname_mv);
  156. WEAK(noritake_mv);
  157. WEAK(noritake_primo_mv);
  158. WEAK(p2k_mv);
  159. WEAK(pc164_mv);
  160. WEAK(privateer_mv);
  161. WEAK(rawhide_mv);
  162. WEAK(ruffian_mv);
  163. WEAK(rx164_mv);
  164. WEAK(sable_mv);
  165. WEAK(sable_gamma_mv);
  166. WEAK(shark_mv);
  167. WEAK(sx164_mv);
  168. WEAK(takara_mv);
  169. WEAK(webbrick_mv);
  170. WEAK(wildfire_mv);
  171. WEAK(xl_mv);
  172. WEAK(xlt_mv);
  174. #undef WEAK
  176. /*
  177.  * I/O resources inherited from PeeCees.  Except for perhaps the
  178.  * turbochannel alphas, everyone has these on some sort of SuperIO chip.
  179.  *
  180.  * ??? If this becomes less standard, move the struct out into the
  181.  * machine vector.
  182.  */
  184. static void __init
  185. reserve_std_resources(void)
  186. {
  187. static struct resource standard_io_resources[] = {
  188. { "rtc", -1, -1 },
  189.          { "dma1", 0x00, 0x1f },
  190.          { "pic1", 0x20, 0x3f },
  191.          { "timer", 0x40, 0x5f },
  192.          { "keyboard", 0x60, 0x6f },
  193.          { "dma page reg", 0x80, 0x8f },
  194.          { "pic2", 0xa0, 0xbf },
  195.          { "dma2", 0xc0, 0xdf },
  196. };
  198. struct resource *io = &ioport_resource;
  199. long i;
  201. if (hose_head) {
  202. struct pci_controller *hose;
  203. for (hose = hose_head; hose; hose = hose->next)
  204. if (hose->index == 0) {
  205. io = hose->io_space;
  206. break;
  207. }
  208. }
  210. /* Fix up for the Jensen's queer RTC placement.  */
  211. standard_io_resources[0].start = RTC_PORT(0);
  212. standard_io_resources[0].end = RTC_PORT(0) + 0x10;
  214. for (i = 0; i < N(standard_io_resources); ++i)
  215. request_resource(io, standard_io_resources+i);
  216. }
  218. #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
  219. #define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
  220. #define PFN_PHYS(x) ((x) << PAGE_SHIFT)
  221. #define PFN_MAX PFN_DOWN(0x80000000)
  222. #define for_each_mem_cluster(memdesc, cluster, i)
  223. for ((cluster) = (memdesc)->cluster, (i) = 0;
  224.      (i) < (memdesc)->numclusters; (i)++, (cluster)++)
  226. static unsigned long __init
  227. get_mem_size_limit(char *s)
  228. {
  229.         unsigned long end = 0;
  230.         char *from = s;
  232.         end = simple_strtoul(from, &from, 0);
  233.         if ( *from == 'K' || *from == 'k' ) {
  234.                 end = end << 10;
  235.                 from++;
  236.         } else if ( *from == 'M' || *from == 'm' ) {
  237.                 end = end << 20;
  238.                 from++;
  239.         } else if ( *from == 'G' || *from == 'g' ) {
  240.                 end = end << 30;
  241.                 from++;
  242.         }
  243.         return end >> PAGE_SHIFT; /* Return the PFN of the limit. */
  244. }
  246. #ifndef CONFIG_DISCONTIGMEM
  247. static void __init
  248. setup_memory(void *kernel_end)
  249. {
  250. struct memclust_struct * cluster;
  251. struct memdesc_struct * memdesc;
  252. unsigned long start_kernel_pfn, end_kernel_pfn;
  253. unsigned long bootmap_size, bootmap_pages, bootmap_start;
  254. unsigned long start, end;
  255. int i;
  257. /* Find free clusters, and init and free the bootmem accordingly.  */
  258. memdesc = (struct memdesc_struct *)
  259.   (hwrpb->mddt_offset + (unsigned long) hwrpb);
  261. for_each_mem_cluster(memdesc, cluster, i) {
  262. printk("memcluster %d, usage %01lx, start %8lu, end %8lun",
  263.        i, cluster->usage, cluster->start_pfn,
  264.        cluster->start_pfn + cluster->numpages);
  266. /* Bit 0 is console/PALcode reserved.  Bit 1 is
  267.    non-volatile memory -- we might want to mark
  268.    this for later.  */
  269. if (cluster->usage & 3)
  270. continue;
  272. end = cluster->start_pfn + cluster->numpages;
  273. if (end > max_low_pfn)
  274. max_low_pfn = end;
  275. }
  277. if (mem_size_limit && max_low_pfn >= mem_size_limit)
  278. {
  279. printk("setup: forcing memory size to %ldK (from %ldK).n",
  280.        mem_size_limit << (PAGE_SHIFT - 10),
  281.        max_low_pfn    << (PAGE_SHIFT - 10));
  282. max_low_pfn = mem_size_limit;
  283. }
  285. /* Find the bounds of kernel memory.  */
  286. start_kernel_pfn = PFN_DOWN(KERNEL_START_PHYS);
  287. end_kernel_pfn = PFN_UP(virt_to_phys(kernel_end));
  288. bootmap_start = -1;
  290.  try_again:
  291. if (max_low_pfn <= end_kernel_pfn)
  292. panic("not enough memory to boot");
  294. /* We need to know how many physically contiguous pages
  295.    we'll need for the bootmap.  */
  296. bootmap_pages = bootmem_bootmap_pages(max_low_pfn);
  298. /* Now find a good region where to allocate the bootmap.  */
  299. for_each_mem_cluster(memdesc, cluster, i) {
  300. if (cluster->usage & 3)
  301. continue;
  303. start = cluster->start_pfn;
  304. end = start + cluster->numpages;
  305. if (start >= max_low_pfn)
  306. continue;
  307. if (end > max_low_pfn)
  308. end = max_low_pfn;
  309. if (start < start_kernel_pfn) {
  310. if (end > end_kernel_pfn
  311.     && end - end_kernel_pfn >= bootmap_pages) {
  312. bootmap_start = end_kernel_pfn;
  313. break;
  314. } else if (end > start_kernel_pfn)
  315. end = start_kernel_pfn;
  316. } else if (start < end_kernel_pfn)
  317. start = end_kernel_pfn;
  318. if (end - start >= bootmap_pages) {
  319. bootmap_start = start;
  320. break;
  321. }
  322. }
  324. if (bootmap_start == -1) {
  325. max_low_pfn >>= 1;
  326. goto try_again;
  327. }
  329. /* Allocate the bootmap and mark the whole MM as reserved.  */
  330. bootmap_size = init_bootmem(bootmap_start, max_low_pfn);
  332. /* Mark the free regions.  */
  333. for_each_mem_cluster(memdesc, cluster, i) {
  334. if (cluster->usage & 3)
  335. continue;
  337. start = cluster->start_pfn;
  338. end = cluster->start_pfn + cluster->numpages;
  339. if (start >= max_low_pfn)
  340. continue;
  341. if (end > max_low_pfn)
  342. end = max_low_pfn;
  343. if (start < start_kernel_pfn) {
  344. if (end > end_kernel_pfn) {
  345. free_bootmem(PFN_PHYS(start),
  346.      (PFN_PHYS(start_kernel_pfn)
  347.       - PFN_PHYS(start)));
  348. printk("freeing pages %ld:%ldn",
  349.        start, start_kernel_pfn);
  350. start = end_kernel_pfn;
  351. } else if (end > start_kernel_pfn)
  352. end = start_kernel_pfn;
  353. } else if (start < end_kernel_pfn)
  354. start = end_kernel_pfn;
  355. if (start >= end)
  356. continue;
  358. free_bootmem(PFN_PHYS(start), PFN_PHYS(end) - PFN_PHYS(start));
  359. printk("freeing pages %ld:%ldn", start, end);
  360. }
  362. /* Reserve the bootmap memory.  */
  363. reserve_bootmem(PFN_PHYS(bootmap_start), bootmap_size);
  364. printk("reserving pages %ld:%ldn", bootmap_start, bootmap_start+PFN_UP(bootmap_size));
  366. #ifdef CONFIG_BLK_DEV_INITRD
  367. initrd_start = INITRD_START;
  368. if (initrd_start) {
  369. initrd_end = initrd_start+INITRD_SIZE;
  370. printk("Initial ramdisk at: 0x%p (%lu bytes)n",
  371.        (void *) initrd_start, INITRD_SIZE);
  373. if ((void *)initrd_end > phys_to_virt(PFN_PHYS(max_low_pfn))) {
  374. printk("initrd extends beyond end of memory "
  375.        "(0x%08lx > 0x%p)ndisabling initrdn",
  376.        initrd_end,
  377.        phys_to_virt(PFN_PHYS(max_low_pfn)));
  378. initrd_start = initrd_end = 0;
  379. } else {
  380. reserve_bootmem(virt_to_phys((void *)initrd_start),
  381. INITRD_SIZE);
  382. }
  383. }
  384. #endif /* CONFIG_BLK_DEV_INITRD */
  385. }
  386. #else
  387. extern void setup_memory(void *);
  388. #endif /* !CONFIG_DISCONTIGMEM */
  390. int __init
  391. page_is_ram(unsigned long pfn)
  392. {
  393. struct memclust_struct * cluster;
  394. struct memdesc_struct * memdesc;
  395. int i;
  397. memdesc = (struct memdesc_struct *)
  398. (hwrpb->mddt_offset + (unsigned long) hwrpb);
  399. for_each_mem_cluster(memdesc, cluster, i)
  400. {
  401. if (pfn >= cluster->start_pfn  &&
  402.     pfn < cluster->start_pfn + cluster->numpages) {
  403. return (cluster->usage & 3) ? 0 : 1;
  404. }
  405. }
  407. return 0;
  408. }
  410. #undef PFN_UP
  411. #undef PFN_DOWN
  412. #undef PFN_PHYS
  413. #undef PFN_MAX
  415. #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM)
  416. /*
  417.  *      Manage the SRM callbacks as a "console".
  418.  */
  419. static struct console srmcons;
  421. void __init register_srm_console(void)
  422. {
  423.         register_console(&srmcons);
  424. }
  426. void __init unregister_srm_console(void)
  427. {
  428.         unregister_console(&srmcons);
  429. }
  431. static void srm_console_write(struct console *co, const char *s,
  432.                                 unsigned count)
  433. {
  434. srm_printk(s);
  435. }
  437. static kdev_t srm_console_device(struct console *c)
  438. {
  439.   /* Huh? */
  440.         return MKDEV(TTY_MAJOR, 64 + c->index);
  441. }
  443. static int __init srm_console_setup(struct console *co, char *options)
  444. {
  445. return 1;
  446. }
  448. static struct console srmcons = {
  449. name: "srm0",
  450. write: srm_console_write,
  451. device: srm_console_device,
  452. setup: srm_console_setup,
  453. flags: CON_PRINTBUFFER | CON_ENABLED, /* fake it out */
  454. index: -1,
  455. };
  457. #else
  458. void __init register_srm_console(void)
  459. {
  460. }
  461. void __init unregister_srm_console(void)
  462. {
  463. }
  464. #endif
  466. void __init
  467. setup_arch(char **cmdline_p)
  468. {
  469. extern char _end[];
  471. struct alpha_machine_vector *vec = NULL;
  472. struct percpu_struct *cpu;
  473. char *type_name, *var_name, *p;
  474. void *kernel_end = _end; /* end of kernel */
  476. hwrpb = (struct hwrpb_struct*) __va(INIT_HWRPB->phys_addr);
  477. boot_cpuid = hard_smp_processor_id();
  479. /* Register a call for panic conditions. */
  480. notifier_chain_register(&panic_notifier_list, &alpha_panic_block);
  482. #ifdef CONFIG_ALPHA_GENERIC
  483. /* Assume that we've booted from SRM if we havn't booted from MILO.
  484.    Detect the later by looking for "MILO" in the system serial nr.  */
  485. alpha_using_srm = strncmp((const char *)hwrpb->ssn, "MILO", 4) != 0;
  486. #endif
  488. /* If we are using SRM, we want to allow callbacks
  489.    as early as possible, so do this NOW, and then
  490.    they should work immediately thereafter.
  491. */
  492. kernel_end = callback_init(kernel_end);
  494. /* 
  495.  * Locate the command line.
  496.  */
  497. /* Hack for Jensen... since we're restricted to 8 or 16 chars for
  498.    boot flags depending on the boot mode, we need some shorthand.
  499.    This should do for installation.  */
  500. if (strcmp(COMMAND_LINE, "INSTALL") == 0) {
  501. strcpy(command_line, "root=/dev/fd0 load_ramdisk=1");
  502. } else {
  503. strncpy(command_line, COMMAND_LINE, sizeof command_line);
  504. command_line[sizeof(command_line)-1] = 0;
  505. }
  506. strcpy(saved_command_line, command_line);
  507. *cmdline_p = command_line;
  509. /* 
  510.  * Process command-line arguments.
  511.  */
  512. for (p = strtok(command_line, " t"); p ; p = strtok(NULL, " t")) {
  513. if (strncmp(p, "alpha_mv=", 9) == 0) {
  514. vec = get_sysvec_byname(p+9);
  515. continue;
  516. }
  517. if (strncmp(p, "cycle=", 6) == 0) {
  518. est_cycle_freq = simple_strtol(p+6, NULL, 0);
  519. continue;
  520. }
  521. if (strncmp(p, "mem=", 4) == 0) {
  522. mem_size_limit = get_mem_size_limit(p+4);
  523. continue;
  524. }
  525. if (strncmp(p, "srmcons", 7) == 0) {
  526. srmcons_output = 1;
  527. continue;
  528. }
  529. }
  531. /* Replace the command line, now that we've killed it with strtok.  */
  532. strcpy(command_line, saved_command_line);
  534. /* If we want SRM console printk echoing early, do it now. */
  535. if (alpha_using_srm && srmcons_output) {
  536. register_srm_console();
  537. }
  539. /*
  540.  * Indentify and reconfigure for the current system.
  541.  */
  542. cpu = (struct percpu_struct*)((char*)hwrpb + hwrpb->processor_offset);
  544. get_sysnames(hwrpb->sys_type, hwrpb->sys_variation,
  545.      cpu->type, &type_name, &var_name);
  546. if (*var_name == '0')
  547. var_name = "";
  549. if (!vec) {
  550. vec = get_sysvec(hwrpb->sys_type, hwrpb->sys_variation,
  551.  cpu->type);
  552. }
  554. if (!vec) {
  555. panic("Unsupported system type: %s%s%s (%ld %ld)n",
  556.       type_name, (*var_name ? " variation " : ""), var_name,
  557.       hwrpb->sys_type, hwrpb->sys_variation);
  558. }
  559. if (vec != &alpha_mv) {
  560. alpha_mv = *vec;
  561. }
  563. printk("Booting "
  564. #ifdef CONFIG_ALPHA_GENERIC
  565.        "GENERIC "
  566. #endif
  567.        "on %s%s%s using machine vector %s from %sn",
  568.        type_name, (*var_name ? " variation " : ""),
  569.        var_name, alpha_mv.vector_name,
  570.        (alpha_using_srm ? "SRM" : "MILO"));
  572. printk("Command line: %sn", command_line);
  574. /* 
  575.  * Sync up the HAE.
  576.  * Save the SRM's current value for restoration.
  577.  */
  578. srm_hae = *alpha_mv.hae_register;
  579. __set_hae(alpha_mv.hae_cache);
  581. /* Reset enable correctable error reports.  */
  582. wrmces(0x7);
  584. /* Find our memory.  */
  585. setup_memory(kernel_end);
  587. /* Initialize the machine.  Usually has to do with setting up
  588.    DMA windows and the like.  */
  589. if (alpha_mv.init_arch)
  590. alpha_mv.init_arch();
  592. /* Reserve standard resources.  */
  593. reserve_std_resources();
  595. /* 
  596.  * Give us a default console.  TGA users will see nothing until
  597.  * chr_dev_init is called, rather late in the boot sequence.
  598.  */
  600. #ifdef CONFIG_VT
  601. #if defined(CONFIG_VGA_CONSOLE)
  602. conswitchp = &vga_con;
  603. #elif defined(CONFIG_DUMMY_CONSOLE)
  604. conswitchp = &dummy_con;
  605. #endif
  606. #endif
  608. /* Default root filesystem to sda2.  */
  609. ROOT_DEV = to_kdev_t(0x0802);
  611.   /*
  612.  * Check ASN in HWRPB for validity, report if bad.
  613.  * FIXME: how was this failing?  Should we trust it instead,
  614.  * and copy the value into alpha_mv.max_asn?
  615.    */
  617.   if (hwrpb->max_asn != MAX_ASN) {
  618. printk("Max ASN from HWRPB is bad (0x%lx)n", hwrpb->max_asn);
  619.   }
  621. /*
  622.  * Identify the flock of penguins.
  623.  */
  625. #ifdef CONFIG_SMP
  626. setup_smp();
  627. #endif
  628. paging_init();
  629. }
  631. static char sys_unknown[] = "Unknown";
  632. static char systype_names[][16] = {
  633. "0",
  634. "ADU", "Cobra", "Ruby", "Flamingo", "Mannequin", "Jensen",
  635. "Pelican", "Morgan", "Sable", "Medulla", "Noname",
  636. "Turbolaser", "Avanti", "Mustang", "Alcor", "Tradewind",
  637. "Mikasa", "EB64", "EB66", "EB64+", "AlphaBook1",
  638. "Rawhide", "K2", "Lynx", "XL", "EB164", "Noritake",
  639. "Cortex", "29", "Miata", "XXM", "Takara", "Yukon",
  640. "Tsunami", "Wildfire", "CUSCO", "Eiger", "Titan"
  641. };
  643. static char unofficial_names[][8] = {"100", "Ruffian"};
  645. static char api_names[][16] = {"200", "Nautilus"};
  647. static char eb164_names[][8] = {"EB164", "PC164", "LX164", "SX164", "RX164"};
  648. static int eb164_indices[] = {0,0,0,1,1,1,1,1,2,2,2,2,3,3,3,3,4};
  650. static char alcor_names[][16] = {"Alcor", "Maverick", "Bret"};
  651. static int alcor_indices[] = {0,0,0,1,1,1,0,0,0,0,0,0,2,2,2,2,2,2};
  653. static char eb64p_names[][16] = {"EB64+", "Cabriolet", "AlphaPCI64"};
  654. static int eb64p_indices[] = {0,0,1,2};
  656. static char eb66_names[][8] = {"EB66", "EB66+"};
  657. static int eb66_indices[] = {0,0,1};
  659. static char rawhide_names[][16] = {
  660. "Dodge", "Wrangler", "Durango", "Tincup", "DaVinci"
  661. };
  662. static int rawhide_indices[] = {0,0,0,1,1,2,2,3,3,4,4};
  664. static char titan_names[][16] = {
  665. "0", "Privateer"
  666. };
  667. static int titan_indices[] = {0,1};
  669. static char tsunami_names[][16] = {
  670. "0", "DP264", "Warhol", "Windjammer", "Monet", "Clipper",
  671. "Goldrush", "Webbrick", "Catamaran", "Brisbane", "Melbourne",
  672. "Flying Clipper", "Shark"
  673. };
  674. static int tsunami_indices[] = {0,1,2,3,4,5,6,7,8,9,10,11,12};
  676. static struct alpha_machine_vector * __init
  677. get_sysvec(long type, long variation, long cpu)
  678. {
  679. static struct alpha_machine_vector *systype_vecs[] __initdata =
  680. {
  681. NULL, /* 0 */
  682. NULL, /* ADU */
  683. NULL, /* Cobra */
  684. NULL, /* Ruby */
  685. NULL, /* Flamingo */
  686. NULL, /* Mannequin */
  687. &jensen_mv,
  688. NULL,  /* Pelican */
  689. NULL, /* Morgan */
  690. NULL, /* Sable -- see below.  */
  691. NULL, /* Medulla */
  692. &noname_mv,
  693. NULL, /* Turbolaser */
  694. &avanti_mv,
  695. NULL, /* Mustang */
  696. &alcor_mv, /* Alcor, Bret, Maverick.  */
  697. NULL, /* Tradewind */
  698. NULL, /* Mikasa -- see below.  */
  699. NULL, /* EB64 */
  700. NULL, /* EB66 -- see variation.  */
  701. NULL, /* EB64+ -- see variation.  */
  702. &alphabook1_mv,
  703. &rawhide_mv,
  704. NULL, /* K2 */
  705. NULL, /* Lynx */
  706. &xl_mv,
  707. NULL, /* EB164 -- see variation.  */
  708. NULL, /* Noritake -- see below.  */
  709. NULL, /* Cortex */
  710. NULL, /* 29 */
  711. &miata_mv,
  712. NULL, /* XXM */
  713. &takara_mv,
  714. NULL, /* Yukon */
  715. NULL, /* Tsunami -- see variation.  */
  716. &wildfire_mv, /* Wildfire */
  717. NULL, /* CUSCO */
  718. &eiger_mv, /* Eiger */
  719. NULL, /* Titan */
  720. };
  722. static struct alpha_machine_vector *unofficial_vecs[] __initdata =
  723. {
  724. NULL, /* 100 */
  725. &ruffian_mv,
  726. };
  728. static struct alpha_machine_vector *api_vecs[] __initdata =
  729. {
  730. NULL, /* 200 */
  731. &nautilus_mv,
  732. };
  734. static struct alpha_machine_vector *alcor_vecs[] __initdata = 
  735. {
  736. &alcor_mv, &xlt_mv, &xlt_mv
  737. };
  739. static struct alpha_machine_vector *eb164_vecs[] __initdata =
  740. {
  741. &eb164_mv, &pc164_mv, &lx164_mv, &sx164_mv, &rx164_mv
  742. };
  744. static struct alpha_machine_vector *eb64p_vecs[] __initdata =
  745. {
  746. &eb64p_mv,
  747. &cabriolet_mv,
  748. &cabriolet_mv /* AlphaPCI64 */
  749. };
  751. static struct alpha_machine_vector *eb66_vecs[] __initdata =
  752. {
  753. &eb66_mv,
  754. &eb66p_mv
  755. };
  757. static struct alpha_machine_vector *titan_vecs[] __initdata =
  758. {
  759. NULL,
  760. &privateer_mv, /* privateer */
  761. };
  763. static struct alpha_machine_vector *tsunami_vecs[]  __initdata =
  764. {
  765. NULL,
  766. &dp264_mv, /* dp264 */
  767. &dp264_mv, /* warhol */
  768. &dp264_mv, /* windjammer */
  769. &monet_mv, /* monet */
  770. &clipper_mv, /* clipper */
  771. &dp264_mv, /* goldrush */
  772. &webbrick_mv, /* webbrick */
  773. &dp264_mv, /* catamaran */
  774. NULL, /* brisbane? */
  775. NULL, /* melbourne? */
  776. NULL, /* flying clipper? */
  777. &shark_mv, /* shark */
  778. };
  780. /* ??? Do we need to distinguish between Rawhides?  */
  782. struct alpha_machine_vector *vec;
  784. /* Restore real CABRIO and EB66+ family names, ie EB64+ and EB66 */
  785. if (type < 0)
  786. type = -type;
  788. /* Search the system tables first... */
  789. vec = NULL;
  790. if (type < N(systype_vecs)) {
  791. vec = systype_vecs[type];
  792. } else if ((type > ST_API_BIAS) &&
  793.    (type - ST_API_BIAS) < N(api_vecs)) {
  794. vec = api_vecs[type - ST_API_BIAS];
  795. } else if ((type > ST_UNOFFICIAL_BIAS) &&
  796.    (type - ST_UNOFFICIAL_BIAS) < N(unofficial_vecs)) {
  797. vec = unofficial_vecs[type - ST_UNOFFICIAL_BIAS];
  798. }
  800. /* If we've not found one, try for a variation.  */
  802. if (!vec) {
  803. /* Member ID is a bit-field. */
  804. long member = (variation >> 10) & 0x3f;
  806. cpu &= 0xffffffff; /* make it usable */
  808. switch (type) {
  809. case ST_DEC_ALCOR:
  810. if (member < N(alcor_indices))
  811. vec = alcor_vecs[alcor_indices[member]];
  812. break;
  813. case ST_DEC_EB164:
  814. if (member < N(eb164_indices))
  815. vec = eb164_vecs[eb164_indices[member]];
  816. /* PC164 may show as EB164 variation with EV56 CPU,
  817.    but, since no true EB164 had anything but EV5... */
  818. if (vec == &eb164_mv && cpu == EV56_CPU)
  819. vec = &pc164_mv;
  820. break;
  821. case ST_DEC_EB64P:
  822. if (member < N(eb64p_indices))
  823. vec = eb64p_vecs[eb64p_indices[member]];
  824. break;
  825. case ST_DEC_EB66:
  826. if (member < N(eb66_indices))
  827. vec = eb66_vecs[eb66_indices[member]];
  828. break;
  829. case ST_DEC_TITAN:
  830. if (member < N(titan_indices))
  831. vec = titan_vecs[titan_indices[member]];
  832. break;
  833. case ST_DEC_TSUNAMI:
  834. if (member < N(tsunami_indices))
  835. vec = tsunami_vecs[tsunami_indices[member]];
  836. break;
  837. case ST_DEC_1000:
  838. if (cpu == EV5_CPU || cpu == EV56_CPU)
  839. vec = &mikasa_primo_mv;
  840. else
  841. vec = &mikasa_mv;
  842. break;
  843. case ST_DEC_NORITAKE:
  844. if (cpu == EV5_CPU || cpu == EV56_CPU)
  845. vec = &noritake_primo_mv;
  846. else
  847. vec = &noritake_mv;
  848. break;
  849. case ST_DEC_2100_A500:
  850. if (cpu == EV5_CPU || cpu == EV56_CPU)
  851. vec = &sable_gamma_mv;
  852. else
  853. vec = &sable_mv;
  854. break;
  855. }
  856. }
  857. return vec;
  858. }
  860. static struct alpha_machine_vector * __init
  861. get_sysvec_byname(const char *name)
  862. {
  863. static struct alpha_machine_vector *all_vecs[] __initdata =
  864. {
  865. &alcor_mv,
  866. &alphabook1_mv,
  867. &avanti_mv,
  868. &cabriolet_mv,
  869. &clipper_mv,
  870. &dp264_mv,
  871. &eb164_mv,
  872. &eb64p_mv,
  873. &eb66_mv,
  874. &eb66p_mv,
  875. &eiger_mv,
  876. &jensen_mv,
  877. &lx164_mv,
  878. &miata_mv,
  879. &mikasa_mv,
  880. &mikasa_primo_mv,
  881. &monet_mv,
  882. &nautilus_mv,
  883. &noname_mv,
  884. &noritake_mv,
  885. &noritake_primo_mv,
  886. &p2k_mv,
  887. &pc164_mv,
  888. &privateer_mv,
  889. &rawhide_mv,
  890. &ruffian_mv,
  891. &rx164_mv,
  892. &sable_mv,
  893. &sable_gamma_mv,
  894. &shark_mv,
  895. &sx164_mv,
  896. &takara_mv,
  897. &webbrick_mv,
  898. &wildfire_mv,
  899. &xl_mv,
  900. &xlt_mv
  901. };
  903. int i, n = sizeof(all_vecs)/sizeof(*all_vecs);
  904. for (i = 0; i < n; ++i) {
  905. struct alpha_machine_vector *mv = all_vecs[i];
  906. if (strcasecmp(mv->vector_name, name) == 0)
  907. return mv;
  908. }
  909. return NULL;
  910. }
  912. static void
  913. get_sysnames(long type, long variation, long cpu,
  914.      char **type_name, char **variation_name)
  915. {
  916. long member;
  918. /* Restore real CABRIO and EB66+ family names, ie EB64+ and EB66 */
  919. if (type < 0)
  920. type = -type;
  922. /* If not in the tables, make it UNKNOWN,
  923.    else set type name to family */
  924. if (type < N(systype_names)) {
  925. *type_name = systype_names[type];
  926. } else if ((type > ST_API_BIAS) &&
  927.    (type - ST_API_BIAS) < N(api_names)) {
  928. *type_name = api_names[type - ST_API_BIAS];
  929. } else if ((type > ST_UNOFFICIAL_BIAS) &&
  930.    (type - ST_UNOFFICIAL_BIAS) < N(unofficial_names)) {
  931. *type_name = unofficial_names[type - ST_UNOFFICIAL_BIAS];
  932. } else {
  933. *type_name = sys_unknown;
  934. *variation_name = sys_unknown;
  935. return;
  936. }
  938. /* Set variation to "0"; if variation is zero, done */
  939. *variation_name = systype_names[0];
  940. if (variation == 0) {
  941. return;
  942. }
  944. member = (variation >> 10) & 0x3f; /* member ID is a bit-field */
  946. cpu &= 0xffffffff; /* make it usable */
  948. switch (type) { /* select by family */
  949. default: /* default to variation "0" for now */
  950. break;
  951. case ST_DEC_EB164:
  952. if (member < N(eb164_indices))
  953. *variation_name = eb164_names[eb164_indices[member]];
  954. /* PC164 may show as EB164 variation, but with EV56 CPU,
  955.    so, since no true EB164 had anything but EV5... */
  956. if (eb164_indices[member] == 0 && cpu == EV56_CPU)
  957. *variation_name = eb164_names[1]; /* make it PC164 */
  958. break;
  959. case ST_DEC_ALCOR:
  960. if (member < N(alcor_indices))
  961. *variation_name = alcor_names[alcor_indices[member]];
  962. break;
  963. case ST_DEC_EB64P:
  964. if (member < N(eb64p_indices))
  965. *variation_name = eb64p_names[eb64p_indices[member]];
  966. break;
  967. case ST_DEC_EB66:
  968. if (member < N(eb66_indices))
  969. *variation_name = eb66_names[eb66_indices[member]];
  970. break;
  971. case ST_DEC_RAWHIDE:
  972. if (member < N(rawhide_indices))
  973. *variation_name = rawhide_names[rawhide_indices[member]];
  974. break;
  975. case ST_DEC_TITAN:
  976. if (member < N(titan_indices))
  977. *variation_name = titan_names[titan_indices[member]];
  978. break;
  979. case ST_DEC_TSUNAMI:
  980. if (member < N(tsunami_indices))
  981. *variation_name = tsunami_names[tsunami_indices[member]];
  982. break;
  983. }
  984. }
  986. /*
  987.  * A change was made to the HWRPB via an ECO and the following code
  988.  * tracks a part of the ECO.  In HWRPB versions less than 5, the ECO
  989.  * was not implemented in the console firmware.  If it's revision 5 or
  990.  * greater we can get the name of the platform as an ASCII string from
  991.  * the HWRPB.  That's what this function does.  It checks the revision
  992.  * level and if the string is in the HWRPB it returns the address of
  993.  * the string--a pointer to the name of the platform.
  994.  *
  995.  * Returns:
  996.  *      - Pointer to a ASCII string if it's in the HWRPB
  997.  *      - Pointer to a blank string if the data is not in the HWRPB.
  998.  */
  1000. static char *
  1001. platform_string(void)
  1002. {
  1003. struct dsr_struct *dsr;
  1004. static char unk_system_string[] = "N/A";
  1006. /* Go to the console for the string pointer.
  1007.  * If the rpb_vers is not 5 or greater the rpb
  1008.  * is old and does not have this data in it.
  1009.  */
  1010. if (hwrpb->revision < 5)
  1011. return (unk_system_string);
  1012. else {
  1013. /* The Dynamic System Recognition struct
  1014.  * has the system platform name starting
  1015.  * after the character count of the string.
  1016.  */
  1017. dsr =  ((struct dsr_struct *)
  1018. ((char *)hwrpb + hwrpb->dsr_offset));
  1019. return ((char *)dsr + (dsr->sysname_off +
  1020.        sizeof(long)));
  1021. }
  1022. }
  1024. static int
  1025. get_nr_processors(struct percpu_struct *cpubase, unsigned long num)
  1026. {
  1027. struct percpu_struct *cpu;
  1028. int i, count = 0;
  1030. for (i = 0; i < num; i++) {
  1031. cpu = (struct percpu_struct *)
  1032. ((char *)cpubase + i*hwrpb->processor_size);
  1033. if ((cpu->flags & 0x1cc) == 0x1cc)
  1034. count++;
  1035. }
  1036. return count;
  1037. }
  1040. static int
  1041. show_cpuinfo(struct seq_file *f, void *slot)
  1042. {
  1043. extern struct unaligned_stat {
  1044. unsigned long count, va, pc;
  1045. } unaligned[2];
  1047. static char cpu_names[][8] = {
  1048. "EV3", "EV4", "Simulate", "LCA4", "EV5", "EV45", "EV56",
  1049. "EV6", "PCA56", "PCA57", "EV67", "EV68CB", "EV68AL",
  1050. "EV68CX", "EV7", "EV79", "EV69"
  1051. };
  1053. struct percpu_struct *cpu = slot;
  1054. unsigned int cpu_index;
  1055. char *cpu_name;
  1056. char *systype_name;
  1057. char *sysvariation_name;
  1058. int nr_processors;
  1060. cpu_index = (unsigned) (cpu->type - 1);
  1061. cpu_name = "Unknown";
  1062. if (cpu_index < N(cpu_names))
  1063. cpu_name = cpu_names[cpu_index];
  1065. get_sysnames(hwrpb->sys_type, hwrpb->sys_variation,
  1066.      cpu->type, &systype_name, &sysvariation_name);
  1068. nr_processors = get_nr_processors(cpu, hwrpb->nr_processors);
  1070. seq_printf(f, "cputtt: Alphan"
  1071.       "cpu modeltt: %sn"
  1072.       "cpu variationtt: %ldn"
  1073.       "cpu revisiontt: %ldn"
  1074.       "cpu serial numbert: %sn"
  1075.       "system typett: %sn"
  1076.       "system variationt: %sn"
  1077.       "system revisiontt: %ldn"
  1078.       "system serial numbert: %sn"
  1079.       "cycle frequency [Hz]t: %lu %sn"
  1080.       "timer frequency [Hz]t: %lu.%02lun"
  1081.       "page size [bytes]t: %ldn"
  1082.       "phys. address bitst: %ldn"
  1083.       "max. addr. space #t: %ldn"
  1084.       "BogoMIPStt: %lu.%02lun"
  1085.       "kernel unaligned acct: %ld (pc=%lx,va=%lx)n"
  1086.       "user unaligned acct: %ld (pc=%lx,va=%lx)n"
  1087.       "platform stringtt: %sn"
  1088.       "cpus detectedtt: %dn",
  1089.        cpu_name, cpu->variation, cpu->revision,
  1090.        (char*)cpu->serial_no,
  1091.        systype_name, sysvariation_name, hwrpb->sys_revision,
  1092.        (char*)hwrpb->ssn,
  1093.        est_cycle_freq ? : hwrpb->cycle_freq,
  1094.        est_cycle_freq ? "est." : "",
  1095.        hwrpb->intr_freq / 4096,
  1096.        (100 * hwrpb->intr_freq / 4096) % 100,
  1097.        hwrpb->pagesize,
  1098.        hwrpb->pa_bits,
  1099.        hwrpb->max_asn,
  1100.        loops_per_jiffy / (500000/HZ),
  1101.        (loops_per_jiffy / (5000/HZ)) % 100,
  1102.        unaligned[0].count, unaligned[0].pc, unaligned[0].va,
  1103.        unaligned[1].count, unaligned[1].pc, unaligned[1].va,
  1104.        platform_string(), nr_processors);
  1106. #ifdef CONFIG_SMP
  1107. seq_printf(f, "cpus activett: %dn"
  1108.       "cpu active masktt: %016lxn",
  1109.        smp_num_cpus, cpu_present_mask);
  1110. #endif
  1112. return 0;
  1113. }
  1115. /*
  1116.  * We show only CPU #0 info.
  1117.  */
  1118. static void *
  1119. c_start(struct seq_file *f, loff_t *pos)
  1120. {
  1121. return *pos ? NULL : (char *)hwrpb + hwrpb->processor_offset;
  1122. }
  1124. static void *
  1125. c_next(struct seq_file *f, void *v, loff_t *pos)
  1126. {
  1127. return NULL;
  1128. }
  1130. static void
  1131. c_stop(struct seq_file *f, void *v)
  1132. {
  1133. }
  1135. struct seq_operations cpuinfo_op = {
  1136. start: c_start,
  1137. next: c_next,
  1138. stop: c_stop,
  1139. show: show_cpuinfo,
  1140. };
  1143. static int alpha_panic_event(struct notifier_block *this,
  1144.      unsigned long event,
  1145.      void *ptr)
  1146. {
  1147. #if 1
  1148. /* FIXME FIXME FIXME */
  1149. /* If we are using SRM and serial console, just hard halt here. */
  1150. if (alpha_using_srm && srmcons_output)
  1151. __halt();
  1152. #endif
  1153.         return NOTIFY_DONE;
  1154. }