arch/parisc/kernel/setup.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *    Initial setup-routines for HP 9000 based hardware.
   4  *
   5  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
   6  *    Modifications for PA-RISC (C) 1999 Helge Deller <deller@gmx.de>
   7  *    Modifications copyright 1999 SuSE GmbH (Philipp Rumpf)
   8  *    Modifications copyright 2000 Martin K. Petersen <mkp@mkp.net>
   9  *    Modifications copyright 2000 Philipp Rumpf <prumpf@tux.org>
  10  *    Modifications copyright 2001 Ryan Bradetich <rbradetich@uswest.net>
  11  *
  12  *    Initial PA-RISC Version: 04-23-1999 by Helge Deller
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/initrd.h>
  17 #include <linux/init.h>
  18 #include <linux/console.h>
  19 #include <linux/seq_file.h>
  20 #define PCI_DEBUG
  21 #include <linux/pci.h>
  22 #undef PCI_DEBUG
  23 #include <linux/proc_fs.h>
  24 #include <linux/export.h>
  25 #include <linux/sched.h>
  26 #include <linux/sched/clock.h>
  27 #include <linux/start_kernel.h>
  28
  29 #include <asm/cacheflush.h>
  30 #include <asm/processor.h>
  31 #include <asm/sections.h>
  32 #include <asm/pdc.h>
  33 #include <asm/led.h>
  34 #include <asm/machdep.h>        /* for pa7300lc_init() proto */
  35 #include <asm/pdc_chassis.h>
  36 #include <asm/io.h>
  37 #include <asm/setup.h>
  38 #include <asm/unwind.h>
  39 #include <asm/smp.h>
  40
  41 static char __initdata command_line[COMMAND_LINE_SIZE];
  42
  43 /* Intended for ccio/sba/cpu statistics under /proc/bus/{runway|gsc} */
  44 struct proc_dir_entry * proc_runway_root __read_mostly = NULL;
  45 struct proc_dir_entry * proc_gsc_root __read_mostly = NULL;
  46 struct proc_dir_entry * proc_mckinley_root __read_mostly = NULL;
  47
  48 void __init setup_cmdline(char **cmdline_p)
  49 {
  50         extern unsigned int boot_args[];
  51         char *p;
  52
  53         /* Collect stuff passed in from the boot loader */
  54
  55         /* boot_args[0] is free-mem start, boot_args[1] is ptr to command line */
  56         if (boot_args[0] < 64) {
  57                 /* called from hpux boot loader */
  58                 boot_command_line[0] = '\0';
  59         } else {
  60                 strscpy(boot_command_line, (char *)__va(boot_args[1]),
  61                         COMMAND_LINE_SIZE);
  62
  63         /* autodetect console type (if not done by palo yet) */
  64         p = boot_command_line;
  65         if (!str_has_prefix(p, "console=") && !strstr(p, " console=")) {
  66                 strlcat(p, " console=", COMMAND_LINE_SIZE);
  67                 if (PAGE0->mem_cons.cl_class == CL_DUPLEX)
  68                         strlcat(p, "ttyS0", COMMAND_LINE_SIZE);
  69                 else
  70                         strlcat(p, "tty0", COMMAND_LINE_SIZE);
  71         }
  72
  73 #ifdef CONFIG_BLK_DEV_INITRD
  74                 if (boot_args[2] != 0) /* did palo pass us a ramdisk? */
  75                 {
  76                     initrd_start = (unsigned long)__va(boot_args[2]);
  77                     initrd_end = (unsigned long)__va(boot_args[3]);
  78                 }
  79 #endif
  80         }
  81
  82         strscpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
  83         *cmdline_p = command_line;
  84 }
  85
  86 #ifdef CONFIG_PA11
  87 void __init dma_ops_init(void)
  88 {
  89         switch (boot_cpu_data.cpu_type) {
  90         case pcx:
  91                 /*
  92                  * We've got way too many dependencies on 1.1 semantics
  93                  * to support 1.0 boxes at this point.
  94                  */
  95                 panic(  "PA-RISC Linux currently only supports machines that conform to\n"
  96                         "the PA-RISC 1.1 or 2.0 architecture specification.\n");
  97
  98         case pcxl2:
  99                 pa7300lc_init();
 100                 break;
 101         default:
 102                 break;
 103         }
 104 }
 105 #endif
 106
 107 extern void collect_boot_cpu_data(void);
 108
 109 void __init setup_arch(char **cmdline_p)
 110 {
 111 #ifdef CONFIG_64BIT
 112         extern int parisc_narrow_firmware;
 113 #endif
 114         unwind_init();
 115
 116         init_per_cpu(smp_processor_id());       /* Set Modes & Enable FP */
 117
 118 #ifdef CONFIG_64BIT
 119         printk(KERN_INFO "The 64-bit Kernel has started...\n");
 120 #else
 121         printk(KERN_INFO "The 32-bit Kernel has started...\n");
 122 #endif
 123
 124         printk(KERN_INFO "Kernel default page size is %d KB. Huge pages ",
 125                 (int)(PAGE_SIZE / 1024));
 126 #ifdef CONFIG_HUGETLB_PAGE
 127         printk(KERN_CONT "enabled with %d MB physical and %d MB virtual size",
 128                  1 << (REAL_HPAGE_SHIFT - 20), 1 << (HPAGE_SHIFT - 20));
 129 #else
 130         printk(KERN_CONT "disabled");
 131 #endif
 132         printk(KERN_CONT ".\n");
 133
 134         /*
 135          * Check if initial kernel page mappings are sufficient.
 136          * panic early if not, else we may access kernel functions
 137          * and variables which can't be reached.
 138          */
 139         if (__pa((unsigned long) &_end) >= KERNEL_INITIAL_SIZE)
 140                 panic("KERNEL_INITIAL_ORDER too small!");
 141
 142         pdc_console_init();
 143
 144 #ifdef CONFIG_64BIT
 145         if(parisc_narrow_firmware) {
 146                 printk(KERN_INFO "Kernel is using PDC in 32-bit mode.\n");
 147         }
 148 #endif
 149         setup_pdc();
 150         setup_cmdline(cmdline_p);
 151         collect_boot_cpu_data();
 152         do_memory_inventory();  /* probe for physical memory */
 153         parisc_cache_init();
 154         paging_init();
 155
 156 #ifdef CONFIG_CHASSIS_LCD_LED
 157         /* initialize the LCD/LED after boot_cpu_data is available ! */
 158         led_init();             /* LCD/LED initialization */
 159 #endif
 160
 161 #ifdef CONFIG_PA11
 162         dma_ops_init();
 163 #endif
 164
 165         clear_sched_clock_stable();
 166 }
 167
 168 /*
 169  * Display CPU info for all CPUs.
 170  * for parisc this is in processor.c
 171  */
 172 extern int show_cpuinfo (struct seq_file *m, void *v);
 173
 174 static void *
 175 c_start (struct seq_file *m, loff_t *pos)
 176 {
 177         /* Looks like the caller will call repeatedly until we return
 178          * 0, signaling EOF perhaps.  This could be used to sequence
 179          * through CPUs for example.  Since we print all cpu info in our
 180          * show_cpuinfo() disregarding 'pos' (which I assume is 'v' above)
 181          * we only allow for one "position".  */
 182         return ((long)*pos < 1) ? (void *)1 : NULL;
 183 }
 184
 185 static void *
 186 c_next (struct seq_file *m, void *v, loff_t *pos)
 187 {
 188         ++*pos;
 189         return c_start(m, pos);
 190 }
 191
 192 static void
 193 c_stop (struct seq_file *m, void *v)
 194 {
 195 }
 196
 197 const struct seq_operations cpuinfo_op = {
 198         .start  = c_start,
 199         .next   = c_next,
 200         .stop   = c_stop,
 201         .show   = show_cpuinfo
 202 };
 203
 204 static void __init parisc_proc_mkdir(void)
 205 {
 206         /*
 207         ** Can't call proc_mkdir() until after proc_root_init() has been
 208         ** called by start_kernel(). In other words, this code can't
 209         ** live in arch/.../setup.c because start_parisc() calls
 210         ** start_kernel().
 211         */
 212         switch (boot_cpu_data.cpu_type) {
 213         case pcxl:
 214         case pcxl2:
 215                 if (NULL == proc_gsc_root)
 216                 {
 217                         proc_gsc_root = proc_mkdir("bus/gsc", NULL);
 218                 }
 219                 break;
 220         case pcxt_:
 221         case pcxu:
 222         case pcxu_:
 223         case pcxw:
 224         case pcxw_:
 225         case pcxw2:
 226                 if (NULL == proc_runway_root)
 227                 {
 228                         proc_runway_root = proc_mkdir("bus/runway", NULL);
 229                 }
 230                 break;
 231         case mako:
 232         case mako2:
 233                 if (NULL == proc_mckinley_root)
 234                 {
 235                         proc_mckinley_root = proc_mkdir("bus/mckinley", NULL);
 236                 }
 237                 break;
 238         default:
 239                 /* FIXME: this was added to prevent the compiler
 240                  * complaining about missing pcx, pcxs and pcxt
 241                  * I'm assuming they have neither gsc nor runway */
 242                 break;
 243         }
 244 }
 245
 246 static struct resource central_bus = {
 247         .name   = "Central Bus",
 248         .start  = F_EXTEND(0xfff80000),
 249         .end    = F_EXTEND(0xfffaffff),
 250         .flags  = IORESOURCE_MEM,
 251 };
 252
 253 static struct resource local_broadcast = {
 254         .name   = "Local Broadcast",
 255         .start  = F_EXTEND(0xfffb0000),
 256         .end    = F_EXTEND(0xfffdffff),
 257         .flags  = IORESOURCE_MEM,
 258 };
 259
 260 static struct resource global_broadcast = {
 261         .name   = "Global Broadcast",
 262         .start  = F_EXTEND(0xfffe0000),
 263         .end    = F_EXTEND(0xffffffff),
 264         .flags  = IORESOURCE_MEM,
 265 };
 266
 267 static int __init parisc_init_resources(void)
 268 {
 269         int result;
 270
 271         result = request_resource(&iomem_resource, &central_bus);
 272         if (result < 0) {
 273                 printk(KERN_ERR
 274                        "%s: failed to claim %s address space!\n",
 275                        __FILE__, central_bus.name);
 276                 return result;
 277         }
 278
 279         result = request_resource(&iomem_resource, &local_broadcast);
 280         if (result < 0) {
 281                 printk(KERN_ERR
 282                        "%s: failed to claim %s address space!\n",
 283                        __FILE__, local_broadcast.name);
 284                 return result;
 285         }
 286
 287         result = request_resource(&iomem_resource, &global_broadcast);
 288         if (result < 0) {
 289                 printk(KERN_ERR
 290                        "%s: failed to claim %s address space!\n",
 291                        __FILE__, global_broadcast.name);
 292                 return result;
 293         }
 294
 295         return 0;
 296 }
 297
 298 extern void gsc_init(void);
 299 extern void processor_init(void);
 300 extern void ccio_init(void);
 301 extern void hppb_init(void);
 302 extern void dino_init(void);
 303 extern void iosapic_init(void);
 304 extern void lba_init(void);
 305 extern void sba_init(void);
 306 extern void eisa_init(void);
 307
 308 static int __init parisc_init(void)
 309 {
 310         u32 osid = (OS_ID_LINUX << 16);
 311
 312         parisc_proc_mkdir();
 313         parisc_init_resources();
 314         do_device_inventory();                  /* probe for hardware */
 315
 316         parisc_pdc_chassis_init();
 317
 318         /* set up a new led state on systems shipped LED State panel */
 319         pdc_chassis_send_status(PDC_CHASSIS_DIRECT_BSTART);
 320
 321         /* tell PDC we're Linux. Nevermind failure. */
 322         pdc_stable_write(0x40, &osid, sizeof(osid));
 323
 324         /* start with known state */
 325         flush_cache_all_local();
 326         flush_tlb_all_local(NULL);
 327
 328         processor_init();
 329 #ifdef CONFIG_SMP
 330         pr_info("CPU(s): %d out of %d %s at %d.%06d MHz online\n",
 331                 num_online_cpus(), num_present_cpus(),
 332 #else
 333         pr_info("CPU(s): 1 x %s at %d.%06d MHz\n",
 334 #endif
 335                         boot_cpu_data.cpu_name,
 336                         boot_cpu_data.cpu_hz / 1000000,
 337                         boot_cpu_data.cpu_hz % 1000000  );
 338
 339 #if defined(CONFIG_64BIT) && defined(CONFIG_SMP)
 340         /* Don't serialize TLB flushes if we run on one CPU only. */
 341         if (num_online_cpus() == 1)
 342                 pa_serialize_tlb_flushes = 0;
 343 #endif
 344
 345         apply_alternatives_all();
 346         parisc_setup_cache_timing();
 347
 348         /* These are in a non-obvious order, will fix when we have an iotree */
 349 #if defined(CONFIG_IOSAPIC)
 350         iosapic_init();
 351 #endif
 352 #if defined(CONFIG_IOMMU_SBA)
 353         sba_init();
 354 #endif
 355 #if defined(CONFIG_PCI_LBA)
 356         lba_init();
 357 #endif
 358
 359         /* CCIO before any potential subdevices */
 360 #if defined(CONFIG_IOMMU_CCIO)
 361         ccio_init();
 362 #endif
 363
 364         /*
 365          * Need to register Asp & Wax before the EISA adapters for the IRQ
 366          * regions.  EISA must come before PCI to be sure it gets IRQ region
 367          * 0.
 368          */
 369 #if defined(CONFIG_GSC_LASI) || defined(CONFIG_GSC_WAX)
 370         gsc_init();
 371 #endif
 372 #ifdef CONFIG_EISA
 373         eisa_init();
 374 #endif
 375
 376 #if defined(CONFIG_HPPB)
 377         hppb_init();
 378 #endif
 379
 380 #if defined(CONFIG_GSC_DINO)
 381         dino_init();
 382 #endif
 383
 384 #ifdef CONFIG_CHASSIS_LCD_LED
 385         register_led_regions(); /* register LED port info in procfs */
 386 #endif
 387
 388         return 0;
 389 }
 390 arch_initcall(parisc_init);
 391
 392 void __init start_parisc(void)
 393 {
 394         extern void early_trap_init(void);
 395
 396         int ret, cpunum;
 397         struct pdc_coproc_cfg coproc_cfg;
 398
 399         /* check QEMU/SeaBIOS marker in PAGE0 */
 400         running_on_qemu = (memcmp(&PAGE0->pad0, "SeaBIOS", 8) == 0);
 401
 402         cpunum = smp_processor_id();
 403
 404         init_cpu_topology();
 405
 406         set_firmware_width_unlocked();
 407
 408         ret = pdc_coproc_cfg_unlocked(&coproc_cfg);
 409         if (ret >= 0 && coproc_cfg.ccr_functional) {
 410                 mtctl(coproc_cfg.ccr_functional, 10);
 411
 412                 per_cpu(cpu_data, cpunum).fp_rev = coproc_cfg.revision;
 413                 per_cpu(cpu_data, cpunum).fp_model = coproc_cfg.model;
 414
 415                 asm volatile ("fstd     %fr0,8(%sp)");
 416         } else {
 417                 panic("must have an fpu to boot linux");
 418         }
 419
 420         early_trap_init(); /* initialize checksum of fault_vector */
 421
 422         start_kernel();
 423         // not reached
 424 }