arch/mips/kernel/setup.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1995 Linus Torvalds
   7  * Copyright (C) 1995 Waldorf Electronics
   8  * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03  Ralf Baechle
   9  * Copyright (C) 1996 Stoned Elipot
  10  * Copyright (C) 1999 Silicon Graphics, Inc.
  11  * Copyright (C) 2000 2001, 2002  Maciej W. Rozycki
  12  */
  13 #include <linux/config.h>
  14 #include <linux/errno.h>
  15 #include <linux/init.h>
  16 #include <linux/ioport.h>
  17 #include <linux/sched.h>
  18 #include <linux/kernel.h>
  19 #include <linux/mm.h>
  20 #include <linux/module.h>
  21 #include <linux/stddef.h>
  22 #include <linux/string.h>
  23 #include <linux/unistd.h>
  24 #include <linux/slab.h>
  25 #include <linux/user.h>
  26 #include <linux/utsname.h>
  27 #include <linux/a.out.h>
  28 #include <linux/tty.h>
  29 #include <linux/bootmem.h>
  30 #include <linux/initrd.h>
  31 #include <linux/major.h>
  32 #include <linux/kdev_t.h>
  33 #include <linux/root_dev.h>
  34
  35 #include <asm/addrspace.h>
  36 #include <asm/bootinfo.h>
  37 #include <asm/cpu.h>
  38 #include <asm/sections.h>
  39 #include <asm/system.h>
  40
  41 struct cpuinfo_mips cpu_data[NR_CPUS];
  42
  43 #ifdef CONFIG_VT
  44 struct screen_info screen_info;
  45 #endif
  46
  47 /*
  48  * Set if box has EISA slots.
  49  */
  50 #ifdef CONFIG_EISA
  51 int EISA_bus;
  52
  53 EXPORT_SYMBOL(EISA_bus);
  54 #endif
  55
  56 #if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE)
  57 extern struct fd_ops no_fd_ops;
  58 struct fd_ops *fd_ops;
  59 #endif
  60
  61 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
  62 extern struct ide_ops no_ide_ops;
  63 struct ide_ops *ide_ops;
  64 #endif
  65
  66 extern void * __rd_start, * __rd_end;
  67
  68 extern struct rtc_ops no_rtc_ops;
  69 struct rtc_ops *rtc_ops;
  70
  71 /*
  72  * Setup information
  73  *
  74  * These are initialized so they are in the .data section
  75  */
  76 unsigned long mips_machtype = MACH_UNKNOWN;
  77 unsigned long mips_machgroup = MACH_GROUP_UNKNOWN;
  78
  79 struct boot_mem_map boot_mem_map;
  80
  81 static char command_line[CL_SIZE];
  82        char saved_command_line[CL_SIZE];
  83 extern char arcs_cmdline[CL_SIZE];
  84
  85 /*
  86  * mips_io_port_base is the begin of the address space to which x86 style
  87  * I/O ports are mapped.
  88  */
  89 const unsigned long mips_io_port_base = -1;
  90 EXPORT_SYMBOL(mips_io_port_base);
  91
  92 /*
  93  * isa_slot_offset is the address where E(ISA) busaddress 0 is mapped
  94  * for the processor.
  95  */
  96 unsigned long isa_slot_offset;
  97 EXPORT_SYMBOL(isa_slot_offset);
  98
  99 extern void SetUpBootInfo(void);
 100 extern void load_mmu(void);
 101 extern ATTRIB_NORET asmlinkage void start_kernel(void);
 102 extern void prom_init(int, char **, char **, int *);
 103
 104 static struct resource code_resource = { "Kernel code" };
 105 static struct resource data_resource = { "Kernel data" };
 106
 107 asmlinkage void __init init_arch(int argc, char **argv, char **envp,
 108         int *prom_vec)
 109 {
 110         /* Determine which MIPS variant we are running on. */
 111         cpu_probe();
 112
 113         prom_init(argc, argv, envp, prom_vec);
 114
 115         cpu_report();
 116
 117         /*
 118          * Determine the mmu/cache attached to this machine, then flush the
 119          * tlb and caches.  On the r4xx0 variants this also sets CP0_WIRED to
 120          * zero.
 121          */
 122         load_mmu();
 123
 124 #ifdef CONFIG_MIPS32
 125         /* Disable coprocessors and set FPU for 16/32 FPR register model */
 126         clear_c0_status(ST0_CU1|ST0_CU2|ST0_CU3|ST0_KX|ST0_SX|ST0_FR);
 127         set_c0_status(ST0_CU0);
 128 #endif
 129 #ifdef CONFIG_MIPS64
 130         /*
 131          * On IP27, I am seeing the TS bit set when the kernel is loaded.
 132          * Maybe because the kernel is in ckseg0 and not xkphys? Clear it
 133          * anyway ...
 134          */
 135         clear_c0_status(ST0_BEV|ST0_TS|ST0_CU1|ST0_CU2|ST0_CU3);
 136         set_c0_status(ST0_CU0|ST0_KX|ST0_SX|ST0_FR);
 137 #endif
 138
 139         start_kernel();
 140 }
 141
 142 void __init add_memory_region(phys_t start, phys_t size,
 143                               long type)
 144 {
 145         int x = boot_mem_map.nr_map;
 146
 147         if (x == BOOT_MEM_MAP_MAX) {
 148                 printk("Ooops! Too many entries in the memory map!\n");
 149                 return;
 150         }
 151
 152         boot_mem_map.map[x].addr = start;
 153         boot_mem_map.map[x].size = size;
 154         boot_mem_map.map[x].type = type;
 155         boot_mem_map.nr_map++;
 156 }
 157
 158 static void __init print_memory_map(void)
 159 {
 160         int i;
 161
 162         for (i = 0; i < boot_mem_map.nr_map; i++) {
 163                 printk(" memory: %0*Lx @ %0*Lx ",
 164                        sizeof(long) * 2, (u64) boot_mem_map.map[i].size,
 165                        sizeof(long) * 2, (u64) boot_mem_map.map[i].addr);
 166
 167                 switch (boot_mem_map.map[i].type) {
 168                 case BOOT_MEM_RAM:
 169                         printk("(usable)\n");
 170                         break;
 171                 case BOOT_MEM_ROM_DATA:
 172                         printk("(ROM data)\n");
 173                         break;
 174                 case BOOT_MEM_RESERVED:
 175                         printk("(reserved)\n");
 176                         break;
 177                 default:
 178                         printk("type %lu\n", boot_mem_map.map[i].type);
 179                         break;
 180                 }
 181         }
 182 }
 183
 184 static inline void parse_cmdline_early(void)
 185 {
 186         char c = ' ', *to = command_line, *from = saved_command_line;
 187         unsigned long start_at, mem_size;
 188         int len = 0;
 189         int usermem = 0;
 190
 191         printk("Determined physical RAM map:\n");
 192         print_memory_map();
 193
 194         for (;;) {
 195                 /*
 196                  * "mem=XXX[kKmM]" defines a memory region from
 197                  * 0 to <XXX>, overriding the determined size.
 198                  * "mem=XXX[KkmM]@YYY[KkmM]" defines a memory region from
 199                  * <YYY> to <YYY>+<XXX>, overriding the determined size.
 200                  */
 201                 if (c == ' ' && !memcmp(from, "mem=", 4)) {
 202                         if (to != command_line)
 203                                 to--;
 204                         /*
 205                          * If a user specifies memory size, we
 206                          * blow away any automatically generated
 207                          * size.
 208                          */
 209                         if (usermem == 0) {
 210                                 boot_mem_map.nr_map = 0;
 211                                 usermem = 1;
 212                         }
 213                         mem_size = memparse(from + 4, &from);
 214                         if (*from == '@')
 215                                 start_at = memparse(from + 1, &from);
 216                         else
 217                                 start_at = 0;
 218                         add_memory_region(start_at, mem_size, BOOT_MEM_RAM);
 219                 }
 220                 c = *(from++);
 221                 if (!c)
 222                         break;
 223                 if (CL_SIZE <= ++len)
 224                         break;
 225                 *(to++) = c;
 226         }
 227         *to = '\0';
 228
 229         if (usermem) {
 230                 printk("User-defined physical RAM map:\n");
 231                 print_memory_map();
 232         }
 233 }
 234
 235
 236 #define PFN_UP(x)       (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
 237 #define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
 238 #define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 239
 240 #define MAXMEM          HIGHMEM_START
 241 #define MAXMEM_PFN      PFN_DOWN(MAXMEM)
 242
 243 static inline void bootmem_init(void)
 244 {
 245 #ifdef CONFIG_BLK_DEV_INITRD
 246         unsigned long tmp;
 247         unsigned long *initrd_header;
 248 #endif
 249         unsigned long bootmap_size;
 250         unsigned long start_pfn, max_low_pfn, first_usable_pfn;
 251         int i;
 252
 253 #ifdef CONFIG_BLK_DEV_INITRD
 254         tmp = (((unsigned long)&_end + PAGE_SIZE-1) & PAGE_MASK) - 8;
 255         if (tmp < (unsigned long)&_end)
 256                 tmp += PAGE_SIZE;
 257         initrd_header = (unsigned long *)tmp;
 258         if (initrd_header[0] == 0x494E5244) {
 259                 initrd_start = (unsigned long)&initrd_header[2];
 260                 initrd_end = initrd_start + initrd_header[1];
 261         }
 262         start_pfn = PFN_UP(CPHYSADDR((&_end)+(initrd_end - initrd_start) + PAGE_SIZE));
 263 #else
 264         /*
 265          * Partially used pages are not usable - thus
 266          * we are rounding upwards.
 267          */
 268         start_pfn = PFN_UP(CPHYSADDR(&_end));
 269 #endif  /* CONFIG_BLK_DEV_INITRD */
 270
 271 #ifndef CONFIG_SGI_IP27
 272         /* Find the highest page frame number we have available.  */
 273         max_pfn = 0;
 274         first_usable_pfn = -1UL;
 275         for (i = 0; i < boot_mem_map.nr_map; i++) {
 276                 unsigned long start, end;
 277
 278                 if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
 279                         continue;
 280
 281                 start = PFN_UP(boot_mem_map.map[i].addr);
 282                 end = PFN_DOWN(boot_mem_map.map[i].addr
 283                       + boot_mem_map.map[i].size);
 284
 285                 if (start >= end)
 286                         continue;
 287                 if (end > max_pfn)
 288                         max_pfn = end;
 289                 if (start < first_usable_pfn) {
 290                         if (start > start_pfn) {
 291                                 first_usable_pfn = start;
 292                         } else if (end > start_pfn) {
 293                                 first_usable_pfn = start_pfn;
 294                         }
 295                 }
 296         }
 297
 298         /*
 299          * Determine low and high memory ranges
 300          */
 301         max_low_pfn = max_pfn;
 302         if (max_low_pfn > MAXMEM_PFN) {
 303                 max_low_pfn = MAXMEM_PFN;
 304 #ifndef CONFIG_HIGHMEM
 305                 /* Maximum memory usable is what is directly addressable */
 306                 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
 307                        MAXMEM >> 20);
 308                 printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 309 #endif
 310         }
 311
 312 #ifdef CONFIG_HIGHMEM
 313         /*
 314          * Crude, we really should make a better attempt at detecting
 315          * highstart_pfn
 316          */
 317         highstart_pfn = highend_pfn = max_pfn;
 318         if (max_pfn > MAXMEM_PFN) {
 319                 highstart_pfn = MAXMEM_PFN;
 320                 printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
 321                        (highend_pfn - highstart_pfn) >> (20 - PAGE_SHIFT));
 322         }
 323 #endif
 324
 325         /* Initialize the boot-time allocator with low memory only.  */
 326         bootmap_size = init_bootmem(first_usable_pfn, max_low_pfn);
 327
 328         /*
 329          * Register fully available low RAM pages with the bootmem allocator.
 330          */
 331         for (i = 0; i < boot_mem_map.nr_map; i++) {
 332                 unsigned long curr_pfn, last_pfn, size;
 333
 334                 /*
 335                  * Reserve usable memory.
 336                  */
 337                 if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
 338                         continue;
 339
 340                 /*
 341                  * We are rounding up the start address of usable memory:
 342                  */
 343                 curr_pfn = PFN_UP(boot_mem_map.map[i].addr);
 344                 if (curr_pfn >= max_low_pfn)
 345                         continue;
 346                 if (curr_pfn < start_pfn)
 347                         curr_pfn = start_pfn;
 348
 349                 /*
 350                  * ... and at the end of the usable range downwards:
 351                  */
 352                 last_pfn = PFN_DOWN(boot_mem_map.map[i].addr
 353                                     + boot_mem_map.map[i].size);
 354
 355                 if (last_pfn > max_low_pfn)
 356                         last_pfn = max_low_pfn;
 357
 358                 /*
 359                  * Only register lowmem part of lowmem segment with bootmem.
 360                  */
 361                 size = last_pfn - curr_pfn;
 362                 if (curr_pfn > PFN_DOWN(HIGHMEM_START))
 363                         continue;
 364                 if (curr_pfn + size - 1 > PFN_DOWN(HIGHMEM_START))
 365                         size = PFN_DOWN(HIGHMEM_START) - curr_pfn;
 366                 if (!size)
 367                         continue;
 368
 369                 /*
 370                  * ... finally, did all the rounding and playing
 371                  * around just make the area go away?
 372                  */
 373                 if (last_pfn <= curr_pfn)
 374                         continue;
 375
 376                 /* Register lowmem ranges */
 377                 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
 378         }
 379
 380         /* Reserve the bootmap memory.  */
 381         reserve_bootmem(PFN_PHYS(first_usable_pfn), bootmap_size);
 382 #endif
 383
 384 #ifdef CONFIG_BLK_DEV_INITRD
 385         /* Board specific code should have set up initrd_start and initrd_end */
 386         ROOT_DEV = Root_RAM0;
 387         if (&__rd_start != &__rd_end) {
 388                 initrd_start = (unsigned long)&__rd_start;
 389                 initrd_end = (unsigned long)&__rd_end;
 390         }
 391         initrd_below_start_ok = 1;
 392         if (initrd_start) {
 393                 unsigned long initrd_size = ((unsigned char *)initrd_end) - ((unsigned char *)initrd_start);
 394                 printk("Initial ramdisk at: 0x%p (%lu bytes)\n",
 395                        (void *)initrd_start,
 396                        initrd_size);
 397 /* FIXME: is this right? */
 398 #ifndef CONFIG_SGI_IP27
 399                 if (CPHYSADDR(initrd_end) > PFN_PHYS(max_low_pfn)) {
 400                         printk("initrd extends beyond end of memory "
 401                                "(0x%0*Lx > 0x%0*Lx)\ndisabling initrd\n",
 402                                sizeof(long) * 2, CPHYSADDR(initrd_end),
 403                                sizeof(long) * 2, PFN_PHYS(max_low_pfn));
 404                         initrd_start = initrd_end = 0;
 405                 }
 406 #endif /* !CONFIG_SGI_IP27 */
 407         }
 408 #endif /* CONFIG_BLK_DEV_INITRD  */
 409 }
 410
 411 static inline void resource_init(void)
 412 {
 413         int i;
 414
 415         code_resource.start = virt_to_phys(&_text);
 416         code_resource.end = virt_to_phys(&_etext) - 1;
 417         data_resource.start = virt_to_phys(&_etext);
 418         data_resource.end = virt_to_phys(&_edata) - 1;
 419
 420         /*
 421          * Request address space for all standard RAM.
 422          */
 423         for (i = 0; i < boot_mem_map.nr_map; i++) {
 424                 struct resource *res;
 425                 unsigned long start, end;
 426
 427                 start = boot_mem_map.map[i].addr;
 428                 end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1;
 429                 if (start >= MAXMEM)
 430                         continue;
 431                 if (end >= MAXMEM)
 432                         end = MAXMEM - 1;
 433
 434                 res = alloc_bootmem(sizeof(struct resource));
 435                 switch (boot_mem_map.map[i].type) {
 436                 case BOOT_MEM_RAM:
 437                 case BOOT_MEM_ROM_DATA:
 438                         res->name = "System RAM";
 439                         break;
 440                 case BOOT_MEM_RESERVED:
 441                 default:
 442                         res->name = "reserved";
 443                 }
 444
 445                 res->start = start;
 446                 res->end = end;
 447
 448                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 449                 request_resource(&iomem_resource, res);
 450
 451                 /*
 452                  *  We don't know which RAM region contains kernel data,
 453                  *  so we try it repeatedly and let the resource manager
 454                  *  test it.
 455                  */
 456                 request_resource(res, &code_resource);
 457                 request_resource(res, &data_resource);
 458         }
 459 }
 460
 461 #undef PFN_UP
 462 #undef PFN_DOWN
 463 #undef PFN_PHYS
 464
 465 #undef MAXMEM
 466 #undef MAXMEM_PFN
 467
 468 void __init setup_arch(char **cmdline_p)
 469 {
 470         extern void atlas_setup(void);
 471         extern void baget_setup(void);
 472         extern void cobalt_setup(void);
 473         extern void lasat_setup(void);
 474         extern void ddb_setup(void);
 475         extern void decstation_setup(void);
 476         extern void deskstation_setup(void);
 477         extern void jazz_setup(void);
 478         extern void sni_rm200_pci_setup(void);
 479         extern void ip22_setup(void);
 480         extern void ip27_setup(void);
 481         extern void ip32_setup(void);
 482         extern void ev96100_setup(void);
 483         extern void malta_setup(void);
 484         extern void sead_setup(void);
 485         extern void ikos_setup(void);
 486         extern void momenco_ocelot_setup(void);
 487         extern void momenco_ocelot_g_setup(void);
 488         extern void momenco_ocelot_c_setup(void);
 489         extern void nec_osprey_setup(void);
 490         extern void nec_eagle_setup(void);
 491         extern void zao_capcella_setup(void);
 492         extern void victor_mpc30x_setup(void);
 493         extern void ibm_workpad_setup(void);
 494         extern void casio_e55_setup(void);
 495         extern void jmr3927_setup(void);
 496         extern void it8172_setup(void);
 497         extern void swarm_setup(void);
 498         extern void hp_setup(void);
 499         extern void au1x00_setup(void);
 500         extern void frame_info_init(void);
 501
 502         frame_info_init();
 503
 504 #ifdef CONFIG_BLK_DEV_FD
 505         fd_ops = &no_fd_ops;
 506 #endif
 507
 508 #ifdef CONFIG_BLK_DEV_IDE
 509         ide_ops = &no_ide_ops;
 510 #endif
 511
 512         rtc_ops = &no_rtc_ops;
 513
 514         switch (mips_machgroup) {
 515 #ifdef CONFIG_BAGET_MIPS
 516         case MACH_GROUP_BAGET:
 517                 baget_setup();
 518                 break;
 519 #endif
 520 #ifdef CONFIG_MIPS_COBALT
 521         case MACH_GROUP_COBALT:
 522                 cobalt_setup();
 523                 break;
 524 #endif
 525 #ifdef CONFIG_DECSTATION
 526         case MACH_GROUP_DEC:
 527                 decstation_setup();
 528                 break;
 529 #endif
 530 #ifdef CONFIG_MIPS_ATLAS
 531         case MACH_GROUP_UNKNOWN:
 532                 atlas_setup();
 533                 break;
 534 #endif
 535 #ifdef CONFIG_MIPS_JAZZ
 536         case MACH_GROUP_JAZZ:
 537                 jazz_setup();
 538                 break;
 539 #endif
 540 #ifdef CONFIG_MIPS_MALTA
 541         case MACH_GROUP_UNKNOWN:
 542                 malta_setup();
 543                 break;
 544 #endif
 545 #ifdef CONFIG_MOMENCO_OCELOT
 546         case MACH_GROUP_MOMENCO:
 547                 momenco_ocelot_setup();
 548                 break;
 549 #endif
 550 #ifdef CONFIG_MOMENCO_OCELOT_G
 551         case MACH_GROUP_MOMENCO:
 552                 momenco_ocelot_g_setup();
 553                 break;
 554 #endif
 555 #ifdef CONFIG_MOMENCO_OCELOT_C
 556         case MACH_GROUP_MOMENCO:
 557                 momenco_ocelot_c_setup();
 558                 break;
 559 #endif
 560 #ifdef CONFIG_MIPS_SEAD
 561         case MACH_GROUP_UNKNOWN:
 562                 sead_setup();
 563                 break;
 564 #endif
 565 #ifdef CONFIG_SGI_IP22
 566         /* As of now this is only IP22.  */
 567         case MACH_GROUP_SGI:
 568                 ip22_setup();
 569                 break;
 570 #endif
 571 #ifdef CONFIG_SGI_IP27
 572         case MACH_GROUP_SGI:
 573                 ip27_setup();
 574                 break;
 575 #endif
 576 #ifdef CONFIG_SGI_IP32
 577         case MACH_GROUP_SGI:
 578                 ip32_setup();
 579                 break;
 580 #endif
 581 #ifdef CONFIG_SNI_RM200_PCI
 582         case MACH_GROUP_SNI_RM:
 583                 sni_rm200_pci_setup();
 584                 break;
 585 #endif
 586 #ifdef CONFIG_DDB5074
 587         case MACH_GROUP_NEC_DDB:
 588                 ddb_setup();
 589                 break;
 590 #endif
 591 #ifdef CONFIG_DDB5476
 592        case MACH_GROUP_NEC_DDB:
 593                ddb_setup();
 594                break;
 595 #endif
 596 #ifdef CONFIG_DDB5477
 597        case MACH_GROUP_NEC_DDB:
 598                ddb_setup();
 599                break;
 600 #endif
 601 #ifdef CONFIG_CPU_VR41XX
 602         case MACH_GROUP_NEC_VR41XX:
 603                 switch (mips_machtype) {
 604 #ifdef CONFIG_NEC_OSPREY
 605                 case MACH_NEC_OSPREY:
 606                         nec_osprey_setup();
 607                         break;
 608 #endif
 609 #ifdef CONFIG_NEC_EAGLE
 610                 case MACH_NEC_EAGLE:
 611                         nec_eagle_setup();
 612                         break;
 613 #endif
 614 #ifdef CONFIG_ZAO_CAPCELLA
 615                 case MACH_ZAO_CAPCELLA:
 616                         zao_capcella_setup();
 617                         break;
 618 #endif
 619 #ifdef CONFIG_VICTOR_MPC30X
 620                 case MACH_VICTOR_MPC30X:
 621                         victor_mpc30x_setup();
 622                         break;
 623 #endif
 624 #ifdef CONFIG_IBM_WORKPAD
 625                 case MACH_IBM_WORKPAD:
 626                         ibm_workpad_setup();
 627                         break;
 628 #endif
 629 #ifdef CONFIG_CASIO_E55
 630                 case MACH_CASIO_E55:
 631                         casio_e55_setup();
 632                         break;
 633 #endif
 634 #ifdef CONFIG_TANBAC_TB0229
 635                 case MACH_TANBAC_TB0229:
 636                         tanbac_tb0229_setup();
 637                         break;
 638 #endif
 639                 }
 640                 break;
 641 #endif
 642 #ifdef CONFIG_MIPS_EV96100
 643         case MACH_GROUP_GALILEO:
 644                 ev96100_setup();
 645                 break;
 646 #endif
 647 #ifdef CONFIG_MIPS_EV64120
 648         case MACH_GROUP_GALILEO:
 649                 ev64120_setup();
 650                 break;
 651 #endif
 652 #if defined(CONFIG_MIPS_IVR) || defined(CONFIG_MIPS_ITE8172)
 653         case  MACH_GROUP_ITE:
 654         case  MACH_GROUP_GLOBESPAN:
 655                 it8172_setup();
 656                 break;
 657 #endif
 658 #ifdef CONFIG_LASAT
 659         case MACH_GROUP_LASAT:
 660                 lasat_setup();
 661                 break;
 662 #endif
 663 #ifdef CONFIG_SOC_AU1X00
 664         case MACH_GROUP_ALCHEMY:
 665                 au1x00_setup();
 666                 break;
 667 #endif
 668 #ifdef CONFIG_TOSHIBA_JMR3927
 669         case MACH_GROUP_TOSHIBA:
 670                 jmr3927_setup();
 671                 break;
 672 #endif
 673 #ifdef CONFIG_TOSHIBA_RBTX4927
 674         case MACH_GROUP_TOSHIBA:
 675                 tx4927_setup();
 676                 break;
 677 #endif
 678 #ifdef CONFIG_SIBYTE_BOARD
 679         case MACH_GROUP_SIBYTE:
 680                 swarm_setup();
 681                 break;
 682 #endif
 683 #ifdef CONFIG_HP_LASERJET
 684         case MACH_GROUP_HP_LJ:
 685                 hp_setup();
 686                 break;
 687 #endif
 688         default:
 689                 panic("Unsupported architecture");
 690         }
 691
 692         strlcpy(command_line, arcs_cmdline, sizeof(command_line));
 693         strlcpy(saved_command_line, command_line, sizeof(saved_command_line));
 694
 695         *cmdline_p = command_line;
 696
 697         parse_cmdline_early();
 698
 699         bootmem_init();
 700
 701         paging_init();
 702
 703         resource_init();
 704 }
 705
 706 int __init fpu_disable(char *s)
 707 {
 708         cpu_data[0].options &= ~MIPS_CPU_FPU;
 709
 710         return 1;
 711 }
 712
 713 __setup("nofpu", fpu_disable);