Annotation of sys/arch/zaurus/zaurus/zaurus_machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: zaurus_machdep.c,v 1.27 2007/05/19 15:49:06 miod Exp $ */
2: /* $NetBSD: lubbock_machdep.c,v 1.2 2003/07/15 00:25:06 lukem Exp $ */
3:
4: /*
5: * Copyright (c) 2002, 2003 Genetec Corporation. All rights reserved.
6: * Written by Hiroyuki Bessho for Genetec Corporation.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. The name of Genetec Corporation may not be used to endorse or
17: * promote products derived from this software without specific prior
18: * written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY GENETEC CORPORATION ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENETEC CORPORATION
24: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30: * POSSIBILITY OF SUCH DAMAGE.
31: *
32: * Machine dependant functions for kernel setup for
33: * Intel DBPXA250 evaluation board (a.k.a. Lubbock).
34: * Based on iq80310_machhdep.c
35: */
36: /*
37: * Copyright (c) 2001 Wasabi Systems, Inc.
38: * All rights reserved.
39: *
40: * Written by Jason R. Thorpe for Wasabi Systems, Inc.
41: *
42: * Redistribution and use in source and binary forms, with or without
43: * modification, are permitted provided that the following conditions
44: * are met:
45: * 1. Redistributions of source code must retain the above copyright
46: * notice, this list of conditions and the following disclaimer.
47: * 2. Redistributions in binary form must reproduce the above copyright
48: * notice, this list of conditions and the following disclaimer in the
49: * documentation and/or other materials provided with the distribution.
50: * 3. All advertising materials mentioning features or use of this software
51: * must display the following acknowledgement:
52: * This product includes software developed for the NetBSD Project by
53: * Wasabi Systems, Inc.
54: * 4. The name of Wasabi Systems, Inc. may not be used to endorse
55: * or promote products derived from this software without specific prior
56: * written permission.
57: *
58: * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
59: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
60: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
61: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
62: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
63: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
64: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
65: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
66: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
67: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
68: * POSSIBILITY OF SUCH DAMAGE.
69: */
70:
71: /*
72: * Copyright (c) 1997,1998 Mark Brinicombe.
73: * Copyright (c) 1997,1998 Causality Limited.
74: * All rights reserved.
75: *
76: * Redistribution and use in source and binary forms, with or without
77: * modification, are permitted provided that the following conditions
78: * are met:
79: * 1. Redistributions of source code must retain the above copyright
80: * notice, this list of conditions and the following disclaimer.
81: * 2. Redistributions in binary form must reproduce the above copyright
82: * notice, this list of conditions and the following disclaimer in the
83: * documentation and/or other materials provided with the distribution.
84: * 3. All advertising materials mentioning features or use of this software
85: * must display the following acknowledgement:
86: * This product includes software developed by Mark Brinicombe
87: * for the NetBSD Project.
88: * 4. The name of the company nor the name of the author may be used to
89: * endorse or promote products derived from this software without specific
90: * prior written permission.
91: *
92: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
93: * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
94: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
95: * IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
96: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
97: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
98: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
99: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
100: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
101: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
102: * SUCH DAMAGE.
103: *
104: * Machine dependant functions for kernel setup for Intel IQ80310 evaluation
105: * boards using RedBoot firmware.
106: */
107:
108: /*
109: * DIP switches:
110: *
111: * S19: no-dot: set RB_KDB. enter kgdb session.
112: * S20: no-dot: set RB_SINGLE. don't go multi user mode.
113: */
114:
115: #include <sys/param.h>
116: #include <sys/device.h>
117: #include <sys/systm.h>
118: #include <sys/kernel.h>
119: #include <sys/exec.h>
120: #include <sys/proc.h>
121: #include <sys/msgbuf.h>
122: #include <sys/reboot.h>
123: #include <sys/termios.h>
124: #include <sys/kcore.h>
125:
126: #include <uvm/uvm_extern.h>
127:
128: #include <sys/conf.h>
129: #include <sys/queue.h>
130: #include <sys/device.h>
131: #include <dev/cons.h>
132: #include <dev/ic/smc91cxxreg.h>
133:
134: #include <machine/db_machdep.h>
135: #include <ddb/db_sym.h>
136: #include <ddb/db_extern.h>
137: #ifdef KGDB
138: #include <sys/kgdb.h>
139: #endif
140:
141: #include <machine/bootconfig.h>
142: #include <machine/bus.h>
143: #include <machine/cpu.h>
144: #include <machine/frame.h>
145: #include <arm/kcore.h>
146: #include <arm/undefined.h>
147: #include <arm/machdep.h>
148:
149: #include <arm/xscale/pxa2x0reg.h>
150: #include <arm/xscale/pxa2x0var.h>
151: #include <arm/xscale/pxa2x0_gpio.h>
152: #include <arm/sa11x0/sa1111_reg.h>
153: #include <machine/zaurus_reg.h>
154: #include <machine/zaurus_var.h>
155:
156: #include <zaurus/dev/zaurus_scoopreg.h>
157:
158: #include "apm.h"
159: #if NAPM > 0
160: #include <zaurus/dev/zaurus_apm.h>
161: #endif
162:
163: #include "wsdisplay.h"
164:
165: /* Kernel text starts 2MB in from the bottom of the kernel address space. */
166: #define KERNEL_TEXT_BASE (KERNEL_BASE + 0x00200000)
167: #define KERNEL_VM_BASE (KERNEL_BASE + 0x04000000)
168:
169: /*
170: * The range 0xc1000000 - 0xccffffff is available for kernel VM space
171: * Core-logic registers and I/O mappings occupy 0xfd000000 - 0xffffffff
172: */
173: /*
174: #define KERNEL_VM_SIZE 0x0C000000
175: */
176: #define KERNEL_VM_SIZE 0x10000000
177:
178:
179: /*
180: * Address to call from cpu_reset() to reset the machine.
181: * This is machine architecture dependant as it varies depending
182: * on where the ROM appears when you turn the MMU off.
183: */
184:
185: u_int cpu_reset_address = 0;
186:
187: /* Define various stack sizes in pages */
188: #define IRQ_STACK_SIZE 1
189: #define ABT_STACK_SIZE 1
190: #ifdef IPKDB
191: #define UND_STACK_SIZE 2
192: #else
193: #define UND_STACK_SIZE 1
194: #endif
195:
196: int zaurusmod;
197:
198: BootConfig bootconfig; /* Boot config storage */
199: char *boot_args = NULL;
200: char *boot_file = NULL;
201:
202: paddr_t physical_start;
203: paddr_t physical_freestart;
204: paddr_t physical_freeend;
205: paddr_t physical_end;
206: u_int free_pages;
207: int physmem = 0;
208:
209: /*int debug_flags;*/
210: #ifndef PMAP_STATIC_L1S
211: int max_processes = 64; /* Default number */
212: #endif /* !PMAP_STATIC_L1S */
213:
214: /* Physical and virtual addresses for some global pages */
215: pv_addr_t systempage;
216: pv_addr_t irqstack;
217: pv_addr_t undstack;
218: pv_addr_t abtstack;
219: extern pv_addr_t kernelstack;
220: pv_addr_t minidataclean;
221:
222: paddr_t msgbufphys;
223:
224: extern u_int data_abort_handler_address;
225: extern u_int prefetch_abort_handler_address;
226: extern u_int undefined_handler_address;
227:
228: #ifdef PMAP_DEBUG
229: extern int pmap_debug_level;
230: #endif
231:
232: #define KERNEL_PT_SYS 0 /* Page table for mapping proc0 zero page */
233: #define KERNEL_PT_KERNEL 1 /* Page table for mapping kernel */
234: #define KERNEL_PT_KERNEL_NUM 32
235: #define KERNEL_PT_VMDATA (KERNEL_PT_KERNEL+KERNEL_PT_KERNEL_NUM)
236: /* Page tables for mapping kernel VM */
237: #define KERNEL_PT_VMDATA_NUM 8 /* start with 32MB of KVM */
238: #define NUM_KERNEL_PTS (KERNEL_PT_VMDATA + KERNEL_PT_VMDATA_NUM)
239:
240: pv_addr_t kernel_pt_table[NUM_KERNEL_PTS];
241:
242: extern struct user *proc0paddr;
243:
244: /* Prototypes */
245:
246: #define BOOT_STRING_MAGIC 0x4f425344
247:
248: char bootargs[MAX_BOOT_STRING];
249: void process_kernel_args(char *);
250:
251: void consinit(void);
252: void early_clkman(u_int, int);
253: void kgdb_port_init(void);
254: void change_clock(uint32_t v);
255:
256: bs_protos(bs_notimpl);
257:
258: #include "com.h"
259: #if NCOM > 0
260: #include <dev/ic/comvar.h>
261: #include <dev/ic/comreg.h>
262: #endif
263:
264: #ifndef CONSPEED
265: #define CONSPEED B9600 /* What RedBoot uses */
266: #endif
267: #ifndef CONMODE
268: #define CONMODE ((TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8) /* 8N1 */
269: #endif
270:
271: int comcnspeed = CONSPEED;
272: int comcnmode = CONMODE;
273:
274:
275: /*
276: * void boot(int howto, char *bootstr)
277: *
278: * Reboots the system
279: *
280: * Deal with any syncing, unmounting, dumping and shutdown hooks,
281: * then reset the CPU.
282: */
283: void
284: boot(int howto)
285: {
286: /*
287: * If we are still cold then hit the air brakes
288: * and crash to earth fast
289: */
290: if (cold) {
291: doshutdownhooks();
292: if ((howto & (RB_HALT | RB_USERREQ)) != RB_USERREQ) {
293: printf("The operating system has halted.\n");
294: printf("Please press any key to reboot.\n\n");
295: cngetc();
296: }
297: printf("rebooting...\n");
298: delay(6000000);
299: #if NAPM > 0
300: zapm_restart();
301: #endif
302: printf("reboot failed; spinning\n");
303: while(1);
304: /*NOTREACHED*/
305: }
306:
307: /* Disable console buffering */
308: /* cnpollc(1);*/
309:
310: /*
311: * If RB_NOSYNC was not specified sync the discs.
312: * Note: Unless cold is set to 1 here, syslogd will die during the
313: * unmount. It looks like syslogd is getting woken up only to find
314: * that it cannot page part of the binary in as the filesystem has
315: * been unmounted.
316: */
317: if (!(howto & RB_NOSYNC))
318: bootsync(howto);
319:
320: /* Say NO to interrupts */
321: splhigh();
322:
323: /* Do a dump if requested. */
324: if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
325: dumpsys();
326:
327: /* Run any shutdown hooks */
328: doshutdownhooks();
329:
330: /* Make sure IRQ's are disabled */
331: IRQdisable;
332:
333: if (howto & RB_HALT) {
334: #if NAPM > 0
335: if (howto & RB_POWERDOWN) {
336:
337: printf("\nAttempting to power down...\n");
338: delay(6000000);
339: zapm_poweroff();
340: }
341: #endif
342:
343: printf("The operating system has halted.\n");
344: printf("Please press any key to reboot.\n\n");
345: cngetc();
346: }
347:
348: printf("rebooting...\n");
349: delay(6000000);
350: #if NAPM > 0
351: zapm_restart();
352: #endif
353: printf("reboot failed; spinning\n");
354: while(1);
355: /*NOTREACHED*/
356: }
357:
358: static __inline
359: pd_entry_t *
360: read_ttb(void)
361: {
362: long ttb;
363:
364: __asm __volatile("mrc p15, 0, %0, c2, c0, 0" : "=r" (ttb));
365:
366:
367: return (pd_entry_t *)(ttb & ~((1<<14)-1));
368: }
369:
370: /*
371: * Mapping table for core kernel memory. These areas are mapped in
372: * init time at fixed virtual address with section mappings.
373: */
374: struct l1_sec_map {
375: vaddr_t va;
376: vaddr_t pa;
377: vsize_t size;
378: int flags;
379: } l1_sec_table[] = {
380: {
381: ZAURUS_GPIO_VBASE,
382: PXA2X0_GPIO_BASE,
383: PXA2X0_GPIO_SIZE,
384: PTE_NOCACHE,
385: },
386: {
387: ZAURUS_CLKMAN_VBASE,
388: PXA2X0_CLKMAN_BASE,
389: PXA2X0_CLKMAN_SIZE,
390: PTE_NOCACHE,
391: },
392: {
393: ZAURUS_INTCTL_VBASE,
394: PXA2X0_INTCTL_BASE,
395: PXA2X0_INTCTL_SIZE,
396: PTE_NOCACHE,
397: },
398: {
399: ZAURUS_SCOOP0_VBASE,
400: C3000_SCOOP0_BASE,
401: SCOOP_SIZE,
402: PTE_NOCACHE,
403: },
404: {
405: ZAURUS_SCOOP1_VBASE,
406: trunc_page(C3000_SCOOP1_BASE),
407: round_page(SCOOP_SIZE),
408: PTE_NOCACHE,
409: },
410: {0, 0, 0, 0,}
411: };
412:
413: static void
414: map_io_area(paddr_t pagedir)
415: {
416: int loop;
417:
418: /*
419: * Map devices we can map w/ section mappings.
420: */
421: loop = 0;
422: while (l1_sec_table[loop].size) {
423: vsize_t sz;
424:
425: #define VERBOSE_INIT_ARM
426: #ifdef VERBOSE_INIT_ARM
427: printf("%08lx -> %08lx @ %08lx\n", l1_sec_table[loop].pa,
428: l1_sec_table[loop].pa + l1_sec_table[loop].size - 1,
429: l1_sec_table[loop].va);
430: #endif
431: for (sz = 0; sz < l1_sec_table[loop].size; sz += L1_S_SIZE)
432: pmap_map_section(pagedir, l1_sec_table[loop].va + sz,
433: l1_sec_table[loop].pa + sz,
434: VM_PROT_READ|VM_PROT_WRITE,
435: l1_sec_table[loop].flags);
436: ++loop;
437: }
438: }
439:
440: /*
441: * simple memory mapping function used in early bootstrap stage
442: * before pmap is initialized.
443: * size and cacheability are ignored and map one section with nocache.
444: */
445: static vaddr_t section_free = ZAURUS_VBASE_FREE;
446:
447: static int
448: bootstrap_bs_map(void *t, bus_addr_t bpa, bus_size_t size,
449: int cacheable, bus_space_handle_t *bshp)
450: {
451: u_long startpa;
452: vaddr_t va;
453: pd_entry_t *pagedir = read_ttb();
454: /* This assumes PA==VA for page directory */
455:
456: va = section_free;
457: section_free += L1_S_SIZE;
458:
459: startpa = trunc_page(bpa);
460: pmap_map_section((vaddr_t)pagedir, va, startpa,
461: VM_PROT_READ | VM_PROT_WRITE, PTE_NOCACHE);
462: cpu_tlb_flushD();
463:
464: *bshp = (bus_space_handle_t)(va + (bpa - startpa));
465:
466: return(0);
467: }
468:
469: static void
470: copy_io_area_map(pd_entry_t *new_pd)
471: {
472: pd_entry_t *cur_pd = read_ttb();
473: vaddr_t va;
474:
475: for (va = ZAURUS_IO_AREA_VBASE;
476: (cur_pd[va>>L1_S_SHIFT] & L1_TYPE_MASK) == L1_TYPE_S;
477: va += L1_S_SIZE) {
478:
479: new_pd[va>>L1_S_SHIFT] = cur_pd[va>>L1_S_SHIFT];
480: if (va == (0 - L1_S_SIZE))
481: break; /* STUPID */
482:
483: }
484: }
485:
486: /* XXX tidy up! */
487: void green_on(int virt);
488: void
489: green_on(int virt)
490: {
491: /* clobber green led p */
492: volatile u_int16_t *p;
493: if (virt)
494: p = (u_int16_t *)(ZAURUS_SCOOP0_VBASE+SCOOP_GPWR);
495: else
496: p = (u_int16_t *)(C3000_SCOOP0_BASE+SCOOP_GPWR);
497:
498: *p = *p | (1<<SCOOP0_LED_GREEN);
499: }
500: void irda_on(int virt);
501: void
502: irda_on(int virt)
503: {
504: /* clobber IrDA led p */
505: volatile u_int16_t *p;
506: /* XXX scoop1 registers are not page-aligned! */
507: int ofs = C3000_SCOOP1_BASE - trunc_page(C3000_SCOOP1_BASE);
508:
509: if (virt)
510: p = (u_int16_t *)(ZAURUS_SCOOP1_VBASE+ofs+SCOOP_GPWR);
511: else
512: p = (u_int16_t *)(C3000_SCOOP1_BASE+SCOOP_GPWR);
513:
514: *p = *p & ~(1<<SCOOP1_IR_ON);
515: }
516:
517: #if 0
518: void sysprobe(void);
519: void
520: sysprobe(void)
521: {
522: u_int32_t *p;
523:
524: p = (void *)0x48000014; /* MECR */
525: printf("MECR %x\n", *p);
526:
527: p = (void *)0x48000028; /* MCMEM0 */
528: printf("MCMEM0 %x\n", *p);
529: p = (void *)0x4800002C; /* MCMEM1 */
530: printf("MCMEM1 %x\n", *p);
531:
532: p = (void *)0x48000030; /* MCATTx */
533: printf("MCATT0 %x\n", *p);
534: p = (void *)0x48000034; /* MCATTx */
535: printf("MCATT1 %x\n", *p);
536:
537: p = (void *)0x48000038; /* MCIOx */
538: printf("MCIO0 %x\n", *p);
539: p = (void *)0x4800003C; /* MCIOx */
540: printf("MCIO1 %x\n", *p);
541: }
542: #endif
543:
544: /*
545: * u_int initarm(...)
546: *
547: * Initial entry point on startup. This gets called before main() is
548: * entered.
549: * It should be responsible for setting up everything that must be
550: * in place when main is called.
551: * This includes
552: * Taking a copy of the boot configuration structure.
553: * Initialising the physical console so characters can be printed.
554: * Setting up page tables for the kernel
555: * Relocating the kernel to the bottom of physical memory
556: */
557: u_int
558: initarm(void *arg)
559: {
560: extern vaddr_t xscale_cache_clean_addr;
561: extern cpu_kcore_hdr_t cpu_kcore_hdr;
562: int loop;
563: int loop1;
564: u_int l1pagetable;
565: pv_addr_t kernel_l1pt;
566: paddr_t memstart;
567: psize_t memsize;
568: extern u_int32_t esym; /* &_end if no symbols are loaded */
569:
570: #if 0
571: int led_data = 0;
572: #endif
573: #ifdef DIAGNOSTIC
574: extern vsize_t xscale_minidata_clean_size; /* used in KASSERT */
575: #endif
576: /* early bus_space_map support */
577: struct bus_space tmp_bs_tag;
578: int (*map_func_save)(void *, bus_addr_t, bus_size_t, int,
579: bus_space_handle_t *);
580:
581:
582: #if 0
583: /* XXX */
584: /* start 32.768KHz OSC */
585: ioreg_write(PXA2X0_CLKMAN_BASE + 0x08, 2);
586: #endif
587:
588: /*
589: * Heads up ... Setup the CPU / MMU / TLB functions
590: */
591: if (set_cpufuncs())
592: panic("cpu not recognized!");
593:
594: /* Get ready for splfoo() */
595: pxa2x0_intr_bootstrap(PXA2X0_INTCTL_BASE);
596:
597: #if 0
598: /* Calibrate the delay loop. */
599: #endif
600:
601: /*
602: * Okay, RedBoot has provided us with the following memory map:
603: *
604: * Physical Address Range Description
605: * ----------------------- ----------------------------------
606: * 0x00000000 - 0x01ffffff flash Memory (32MB)
607: * 0x04000000 - 0x05ffffff Application flash Memory (32MB)
608: * 0x08000000 - 0x080000ff I/O baseboard registers
609: * 0x0a000000 - 0x0a0fffff SRAM (1MB)
610: * 0x0c000000 - 0x0c0fffff Ethernet Controller
611: * 0x0e000000 - 0x0e0fffff Ethernet Controller (Attribute)
612: * 0x10000000 - 0x103fffff SA-1111 Companion Chip
613: * 0x14000000 - 0x17ffffff Expansion Card (64MB)
614: * 0x40000000 - 0x480fffff Processor Registers
615: * 0xa0000000 - 0xa3ffffff SDRAM Bank 0 (64MB)
616: *
617: *
618: * Virtual Address Range X C B Description
619: * ----------------------- - - - ----------------------------------
620: * 0x00000000 - 0x00003fff N Y Y SDRAM
621: * 0x00004000 - 0x000fffff N Y N Boot ROM
622: * 0x00100000 - 0x01ffffff N N N Application Flash
623: * 0x04000000 - 0x05ffffff N N N Exp Application Flash
624: * 0x08000000 - 0x080fffff N N N I/O baseboard registers
625: * 0x0a000000 - 0x0a0fffff N N N SRAM
626: * 0x40000000 - 0x480fffff N N N Processor Registers
627: * 0xa0000000 - 0xa000ffff N Y N RedBoot SDRAM
628: * 0xa0017000 - 0xa3ffffff Y Y Y SDRAM
629: * 0xc0000000 - 0xcfffffff Y Y Y Cache Flush Region
630: * (done by this routine)
631: * 0xfd000000 - 0xfd0000ff N N N I/O baseboard registers
632: * 0xfd100000 - 0xfd2fffff N N N Processor Registers.
633: * 0xfd200000 - 0xfd2fffff N N N 0x10800000 registers
634: *
635: * The first level page table is at 0xa0004000. There are also
636: * 2 second-level tables at 0xa0008000 and 0xa0008400.
637: *
638: */
639:
640: {
641: /*
642: * Tweak RedBoot's pagetable so that we can access to
643: * some registers at same VA before and after installing
644: * our page table.
645: */
646: paddr_t ttb = (paddr_t)read_ttb();
647:
648: map_io_area(ttb);
649: cpu_tlb_flushD();
650: }
651:
652: /*
653: * Examine the boot args string for options we need to know about
654: * now.
655: */
656: /* XXX should really be done after setting up the console, but we
657: * XXX need to parse the console selection flags right now. */
658: process_kernel_args((char *)0xa0200000 - MAX_BOOT_STRING - 1);
659: #ifdef RAMDISK_HOOKS
660: boothowto |= RB_DFLTROOT;
661: #endif /* RAMDISK_HOOKS */
662:
663: /*
664: * This test will work for now but has to be revised when support
665: * for other models is added.
666: */
667: if ((cputype & ~CPU_ID_XSCALE_COREREV_MASK) == CPU_ID_PXA27X)
668: zaurusmod = ZAURUS_C3000;
669: else
670: zaurusmod = ZAURUS_C860;
671:
672: /* setup GPIO for BTUART, in case bootloader doesn't take care of it */
673: pxa2x0_gpio_bootstrap(ZAURUS_GPIO_VBASE);
674: #if 0
675: pxa2x0_gpio_set_function(42, GPIO_ALT_FN_1_IN);
676: pxa2x0_gpio_set_function(43, GPIO_ALT_FN_2_OUT);
677: pxa2x0_gpio_set_function(44, GPIO_ALT_FN_1_IN);
678: pxa2x0_gpio_set_function(45, GPIO_ALT_FN_2_OUT);
679:
680: /* FFUART */
681: pxa2x0_gpio_set_function(34, GPIO_ALT_FN_1_IN);
682: pxa2x0_gpio_set_function(39, GPIO_ALT_FN_2_OUT);
683: pxa2x0_gpio_set_function(35, GPIO_ALT_FN_1_IN);
684: pxa2x0_gpio_set_function(40, GPIO_ALT_FN_2_OUT);
685: pxa2x0_gpio_set_function(41, GPIO_ALT_FN_2_OUT);
686:
687: /* STUART */
688: pxa2x0_gpio_set_function(46, GPIO_ALT_FN_2_IN);
689: pxa2x0_gpio_set_function(47, GPIO_ALT_FN_1_OUT);
690: #endif
691:
692: /* tell com to drive STUART in slow infrared mode */
693: comsiraddr = (bus_addr_t)PXA2X0_STUART_BASE;
694:
695: #if 1
696: /* turn on clock to UART block.
697: XXX this should not be necessary, consinit() will do it */
698: early_clkman(CKEN_FFUART | CKEN_BTUART | CKEN_STUART, 1);
699: #endif
700:
701: green_on(0);
702:
703: /*
704: * Temporarily replace bus_space_map() functions so that
705: * console devices can get mapped.
706: *
707: * Note that this relies upon the fact that both regular
708: * and a4x bus_space tags use the same map function.
709: */
710: tmp_bs_tag = pxa2x0_bs_tag;
711: tmp_bs_tag.bs_map = bootstrap_bs_map;
712: map_func_save = pxa2x0_bs_tag.bs_map;
713: pxa2x0_a4x_bs_tag.bs_map = pxa2x0_bs_tag.bs_map = bootstrap_bs_map;
714:
715: /* setup a serial console for very early boot */
716: consinit();
717: #ifdef KGDB
718: kgdb_port_init();
719: #endif
720:
721:
722: /* Talk to the user */
723: printf("\nOpenBSD/zaurus booting ...\n");
724:
725: {
726: /* XXX - all Zaurus have this for now, fix memory sizing */
727: memstart = 0xa0000000;
728: memsize = 0x04000000; /* 64MB */
729: }
730:
731: #if 0
732: {
733: volatile int *p;
734: char *membase;
735: char *memmax;
736: int chunksize = 0x02000000;
737: printf("probing memory");
738:
739: membase = (char *)0xa0000000;
740: memmax = (char *)0xc0000000;
741: for (p = (int *)membase;
742: p < (int *)memmax;
743: p = (int *) (((char *)p) + chunksize)) {
744: printf ("cbase %p\n", p);
745: p[0] = 0x12345678;
746: p[1] = 0x12345678;
747: if ((p[0] != 0x12345678) || (p[1] != 0x12345678))
748: break;
749: }
750: memsize = ((char *)p) - membase;
751:
752: printf("probing memory done found memsize %d\n", memsize);
753: }
754: #else
755: #endif
756:
757: #define DEBUG
758: #ifdef DEBUG
759: printf("initarm: Configuring system ...\n");
760: #endif
761:
762: /* Fake bootconfig structure for the benefit of pmap.c */
763: /* XXX must make the memory description h/w independant */
764: bootconfig.dramblocks = 1;
765: bootconfig.dram[0].address = memstart;
766: bootconfig.dram[0].pages = memsize / PAGE_SIZE;
767:
768: /*
769: * Set up the variables that define the availablilty of
770: * physical memory. For now, we're going to set
771: * physical_freestart to 0xa0200000 (where the kernel
772: * was loaded), and allocate the memory we need downwards.
773: * If we get too close to the page tables that RedBoot
774: * set up, we will panic. We will update physical_freestart
775: * and physical_freeend later to reflect what pmap_bootstrap()
776: * wants to see.
777: *
778: * XXX pmap_bootstrap() needs an enema.
779: */
780: physical_start = bootconfig.dram[0].address;
781: physical_end = physical_start + (bootconfig.dram[0].pages * PAGE_SIZE);
782:
783: physical_freestart = 0xa0009000UL;
784: physical_freeend = 0xa0200000UL;
785:
786: physmem = (physical_end - physical_start) / PAGE_SIZE;
787:
788: #ifdef DEBUG
789: /* Tell the user about the memory */
790: printf("physmemory: %d pages at 0x%08lx -> 0x%08lx\n", physmem,
791: physical_start, physical_end - 1);
792: #endif
793:
794: /*
795: * Okay, the kernel starts 2MB in from the bottom of physical
796: * memory. We are going to allocate our bootstrap pages downwards
797: * from there.
798: *
799: * We need to allocate some fixed page tables to get the kernel
800: * going. We allocate one page directory and a number of page
801: * tables and store the physical addresses in the kernel_pt_table
802: * array.
803: *
804: * The kernel page directory must be on a 16K boundary. The page
805: * tables must be on 4K bounaries. What we do is allocate the
806: * page directory on the first 16K boundary that we encounter, and
807: * the page tables on 4K boundaries otherwise. Since we allocate
808: * at least 3 L2 page tables, we are guaranteed to encounter at
809: * least one 16K aligned region.
810: */
811:
812: #ifdef VERBOSE_INIT_ARM
813: printf("Allocating page tables\n");
814: #endif
815:
816: free_pages = (physical_freeend - physical_freestart) / PAGE_SIZE;
817:
818: #ifdef VERBOSE_INIT_ARM
819: printf("freestart = 0x%08lx, free_pages = %d (0x%08x)\n",
820: physical_freestart, free_pages, free_pages);
821: #endif
822:
823: /* Define a macro to simplify memory allocation */
824: #define valloc_pages(var, np) \
825: alloc_pages((var).pv_pa, (np)); \
826: (var).pv_va = KERNEL_BASE + (var).pv_pa - physical_start;
827:
828: #define alloc_pages(var, np) \
829: physical_freeend -= ((np) * PAGE_SIZE); \
830: if (physical_freeend < physical_freestart) \
831: panic("initarm: out of memory"); \
832: (var) = physical_freeend; \
833: free_pages -= (np); \
834: memset((char *)(var), 0, ((np) * PAGE_SIZE));
835:
836: loop1 = 0;
837: kernel_l1pt.pv_pa = 0;
838: for (loop = 0; loop <= NUM_KERNEL_PTS; ++loop) {
839: /* Are we 16KB aligned for an L1 ? */
840: if (((physical_freeend - L1_TABLE_SIZE) & (L1_TABLE_SIZE - 1)) == 0
841: && kernel_l1pt.pv_pa == 0) {
842: valloc_pages(kernel_l1pt, L1_TABLE_SIZE / PAGE_SIZE);
843: } else {
844: valloc_pages(kernel_pt_table[loop1],
845: L2_TABLE_SIZE / PAGE_SIZE);
846: ++loop1;
847: }
848: }
849:
850: /* This should never be able to happen but better confirm that. */
851: if (!kernel_l1pt.pv_pa || (kernel_l1pt.pv_pa & (L1_TABLE_SIZE-1)) != 0)
852: panic("initarm: Failed to align the kernel page directory");
853:
854: /*
855: * Allocate a page for the system page mapped to V0x00000000
856: * This page will just contain the system vectors and can be
857: * shared by all processes.
858: */
859: alloc_pages(systempage.pv_pa, 1);
860:
861: /* Allocate stacks for all modes */
862: valloc_pages(irqstack, IRQ_STACK_SIZE);
863: valloc_pages(abtstack, ABT_STACK_SIZE);
864: valloc_pages(undstack, UND_STACK_SIZE);
865: valloc_pages(kernelstack, UPAGES);
866:
867: /* Allocate enough pages for cleaning the Mini-Data cache. */
868: KASSERT(xscale_minidata_clean_size <= PAGE_SIZE);
869: valloc_pages(minidataclean, 1);
870:
871: #ifdef VERBOSE_INIT_ARM
872: printf("IRQ stack: p0x%08lx v0x%08lx\n", irqstack.pv_pa,
873: irqstack.pv_va);
874: printf("ABT stack: p0x%08lx v0x%08lx\n", abtstack.pv_pa,
875: abtstack.pv_va);
876: printf("UND stack: p0x%08lx v0x%08lx\n", undstack.pv_pa,
877: undstack.pv_va);
878: printf("SVC stack: p0x%08lx v0x%08lx\n", kernelstack.pv_pa,
879: kernelstack.pv_va);
880: #endif
881:
882: /*
883: * XXX Defer this to later so that we can reclaim the memory
884: * XXX used by the RedBoot page tables.
885: */
886: alloc_pages(msgbufphys, round_page(MSGBUFSIZE) / PAGE_SIZE);
887:
888: /*
889: * Ok we have allocated physical pages for the primary kernel
890: * page tables
891: */
892:
893: #ifdef VERBOSE_INIT_ARM
894: printf("Creating L1 page table at 0x%08lx\n", kernel_l1pt.pv_pa);
895: #endif
896:
897: /*
898: * Now we start construction of the L1 page table
899: * We start by mapping the L2 page tables into the L1.
900: * This means that we can replace L1 mappings later on if necessary
901: */
902: l1pagetable = kernel_l1pt.pv_pa;
903:
904: /* Map the L2 pages tables in the L1 page table */
905: pmap_link_l2pt(l1pagetable, 0x00000000,
906: &kernel_pt_table[KERNEL_PT_SYS]);
907:
908: for (loop = 0; loop < KERNEL_PT_KERNEL_NUM; loop++)
909: pmap_link_l2pt(l1pagetable, KERNEL_BASE + loop * 0x00400000,
910: &kernel_pt_table[KERNEL_PT_KERNEL + loop]);
911:
912: for (loop = 0; loop < KERNEL_PT_VMDATA_NUM; loop++)
913: pmap_link_l2pt(l1pagetable, KERNEL_VM_BASE + loop * 0x00400000,
914: &kernel_pt_table[KERNEL_PT_VMDATA + loop]);
915:
916: /* update the top of the kernel VM */
917: pmap_curmaxkvaddr =
918: KERNEL_VM_BASE + (KERNEL_PT_VMDATA_NUM * 0x00400000);
919:
920: #ifdef VERBOSE_INIT_ARM
921: printf("Mapping kernel\n");
922: #endif
923:
924: /* Now we fill in the L2 pagetable for the kernel static code/data
925: * and the symbol table. */
926: {
927: extern char etext[];
928: size_t textsize = (u_int32_t) etext - KERNEL_TEXT_BASE;
929: size_t totalsize = esym - KERNEL_TEXT_BASE;
930: u_int logical;
931:
932: textsize = (textsize + PGOFSET) & ~PGOFSET;
933: totalsize = (totalsize + PGOFSET) & ~PGOFSET;
934:
935: logical = 0x00200000; /* offset of kernel in RAM */
936:
937: /* Update dump information */
938: cpu_kcore_hdr.kernelbase = KERNEL_BASE;
939: cpu_kcore_hdr.kerneloffs = logical;
940: cpu_kcore_hdr.staticsize = totalsize;
941:
942: logical += pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
943: physical_start + logical, textsize,
944: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
945: pmap_map_chunk(l1pagetable, KERNEL_BASE + logical,
946: physical_start + logical, totalsize - textsize,
947: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
948: }
949:
950: #ifdef VERBOSE_INIT_ARM
951: printf("Constructing L2 page tables\n");
952: #endif
953:
954: /* Map the stack pages */
955: pmap_map_chunk(l1pagetable, irqstack.pv_va, irqstack.pv_pa,
956: IRQ_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
957: pmap_map_chunk(l1pagetable, abtstack.pv_va, abtstack.pv_pa,
958: ABT_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
959: pmap_map_chunk(l1pagetable, undstack.pv_va, undstack.pv_pa,
960: UND_STACK_SIZE * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
961: pmap_map_chunk(l1pagetable, kernelstack.pv_va, kernelstack.pv_pa,
962: UPAGES * PAGE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_CACHE);
963:
964: pmap_map_chunk(l1pagetable, kernel_l1pt.pv_va, kernel_l1pt.pv_pa,
965: L1_TABLE_SIZE, VM_PROT_READ | VM_PROT_WRITE, PTE_PAGETABLE);
966:
967: for (loop = 0; loop < NUM_KERNEL_PTS; ++loop) {
968: pmap_map_chunk(l1pagetable, kernel_pt_table[loop].pv_va,
969: kernel_pt_table[loop].pv_pa, L2_TABLE_SIZE,
970: VM_PROT_READ|VM_PROT_WRITE, PTE_PAGETABLE);
971: }
972:
973: /* Map the Mini-Data cache clean area. */
974: xscale_setup_minidata(l1pagetable, minidataclean.pv_va,
975: minidataclean.pv_pa);
976:
977: /* Map the vector page. */
978: #if 1
979: /* MULTI-ICE requires that page 0 is NC/NB so that it can download the
980: * cache-clean code there. */
981: pmap_map_entry(l1pagetable, vector_page, systempage.pv_pa,
982: VM_PROT_READ|VM_PROT_WRITE, PTE_NOCACHE);
983: #else
984: pmap_map_entry(l1pagetable, vector_page, systempage.pv_pa,
985: VM_PROT_READ|VM_PROT_WRITE, PTE_CACHE);
986: #endif
987:
988: /*
989: * map integrated peripherals at same address in l1pagetable
990: * so that we can continue to use console.
991: */
992: copy_io_area_map((pd_entry_t *)l1pagetable);
993:
994: /*
995: * Give the XScale global cache clean code an appropriately
996: * sized chunk of unmapped VA space starting at 0xff000000
997: * (our device mappings end before this address).
998: */
999: xscale_cache_clean_addr = 0xff000000U;
1000:
1001: /*
1002: * Now we have the real page tables in place so we can switch to them.
1003: * Once this is done we will be running with the REAL kernel page
1004: * tables.
1005: */
1006:
1007: /*
1008: * Update the physical_freestart/physical_freeend/free_pages
1009: * variables.
1010: */
1011: {
1012: physical_freestart = physical_start +
1013: (((esym + PGOFSET) & ~PGOFSET) - KERNEL_BASE);
1014: physical_freeend = physical_end;
1015: free_pages =
1016: (physical_freeend - physical_freestart) / PAGE_SIZE;
1017: }
1018:
1019: /* be a client to all domains */
1020: cpu_domains(0x55555555);
1021: /* Switch tables */
1022: #ifdef VERBOSE_INIT_ARM
1023: printf("freestart = 0x%08lx, free_pages = %d (0x%x)\n",
1024: physical_freestart, free_pages, free_pages);
1025: printf("switching to new L1 page table @%#lx...", kernel_l1pt.pv_pa);
1026: #endif
1027:
1028: /* set new intc register address so that splfoo() doesn't
1029: touch illegal address. */
1030: pxa2x0_intr_bootstrap(ZAURUS_INTCTL_VBASE);
1031:
1032: cpu_domains((DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2)) | DOMAIN_CLIENT);
1033: setttb(kernel_l1pt.pv_pa);
1034: cpu_tlb_flushID();
1035: cpu_domains(DOMAIN_CLIENT << (PMAP_DOMAIN_KERNEL*2));
1036:
1037: /*
1038: * Moved from cpu_startup() as data_abort_handler() references
1039: * this during uvm init
1040: */
1041: proc0paddr = (struct user *)kernelstack.pv_va;
1042: proc0.p_addr = proc0paddr;
1043:
1044: #ifdef VERBOSE_INIT_ARM
1045: printf("bootstrap done.\n");
1046: #endif
1047:
1048: arm32_vector_init(ARM_VECTORS_LOW, ARM_VEC_ALL);
1049:
1050: /*
1051: * Pages were allocated during the secondary bootstrap for the
1052: * stacks for different CPU modes.
1053: * We must now set the r13 registers in the different CPU modes to
1054: * point to these stacks.
1055: * Since the ARM stacks use STMFD etc. we must set r13 to the top end
1056: * of the stack memory.
1057: */
1058: #ifdef VERBOSE_INIT_ARM
1059: printf("init subsystems: stacks ");
1060: #endif
1061:
1062: set_stackptr(PSR_IRQ32_MODE,
1063: irqstack.pv_va + IRQ_STACK_SIZE * PAGE_SIZE);
1064: set_stackptr(PSR_ABT32_MODE,
1065: abtstack.pv_va + ABT_STACK_SIZE * PAGE_SIZE);
1066: set_stackptr(PSR_UND32_MODE,
1067: undstack.pv_va + UND_STACK_SIZE * PAGE_SIZE);
1068:
1069: /*
1070: * Well we should set a data abort handler.
1071: * Once things get going this will change as we will need a proper
1072: * handler.
1073: * Until then we will use a handler that just panics but tells us
1074: * why.
1075: * Initialisation of the vectors will just panic on a data abort.
1076: * This just fills in a slightly better one.
1077: */
1078: #ifdef VERBOSE_INIT_ARM
1079: printf("vectors ");
1080: #endif
1081: data_abort_handler_address = (u_int)data_abort_handler;
1082: prefetch_abort_handler_address = (u_int)prefetch_abort_handler;
1083: undefined_handler_address = (u_int)undefinedinstruction_bounce;
1084:
1085: /* Initialise the undefined instruction handlers */
1086: #ifdef VERBOSE_INIT_ARM
1087: printf("undefined ");
1088: #endif
1089: undefined_init();
1090:
1091: /* Load memory into UVM. */
1092: #ifdef VERBOSE_INIT_ARM
1093: printf("page ");
1094: #endif
1095: uvm_setpagesize(); /* initialize PAGE_SIZE-dependent variables */
1096: uvm_page_physload(atop(physical_freestart), atop(physical_freeend),
1097: atop(physical_freestart), atop(physical_freeend),
1098: VM_FREELIST_DEFAULT);
1099:
1100: /* Boot strap pmap telling it where the kernel page table is */
1101: #ifdef VERBOSE_INIT_ARM
1102: printf("pmap ");
1103: #endif
1104: pmap_bootstrap((pd_entry_t *)kernel_l1pt.pv_va, KERNEL_VM_BASE,
1105: KERNEL_VM_BASE + KERNEL_VM_SIZE);
1106:
1107: /* Update dump information */
1108: cpu_kcore_hdr.pmap_kernel_l1 = (u_int32_t)pmap_kernel()->pm_l1;
1109: cpu_kcore_hdr.pmap_kernel_l2 = (u_int32_t)&(pmap_kernel()->pm_l2);
1110:
1111: #ifdef __HAVE_MEMORY_DISK__
1112: md_root_setconf(memory_disk, sizeof memory_disk);
1113: #endif
1114:
1115: #ifdef IPKDB
1116: /* Initialise ipkdb */
1117: ipkdb_init();
1118: if (boothowto & RB_KDB)
1119: ipkdb_connect(0);
1120: #endif
1121:
1122: #ifdef KGDB
1123: if (boothowto & RB_KDB) {
1124: kgdb_debug_init = 1;
1125: kgdb_connect(1);
1126: }
1127: #endif
1128:
1129: /*
1130: * Restore proper bus_space operation, now that pmap is initialized.
1131: */
1132: pxa2x0_a4x_bs_tag.bs_map = pxa2x0_bs_tag.bs_map = map_func_save;
1133:
1134: #ifdef DDB
1135: db_machine_init();
1136:
1137: /* Firmware doesn't load symbols. */
1138: ddb_init();
1139:
1140: if (boothowto & RB_KDB)
1141: Debugger();
1142: #endif
1143:
1144: /* We return the new stack pointer address */
1145: return(kernelstack.pv_va + USPACE_SVC_STACK_TOP);
1146: }
1147:
1148: const char *console = "glass";
1149:
1150: void
1151: process_kernel_args(char *args)
1152: {
1153: char *cp = args;
1154:
1155: if (cp == NULL || *(int *)cp != BOOT_STRING_MAGIC) {
1156: boothowto = RB_AUTOBOOT;
1157: return;
1158: }
1159:
1160: /* Eat the cookie */
1161: *(int *)cp = 0;
1162: cp += sizeof(int);
1163:
1164: boothowto = 0;
1165:
1166: /* Make a local copy of the bootargs */
1167: strncpy(bootargs, cp, MAX_BOOT_STRING - sizeof(int));
1168:
1169: cp = bootargs;
1170: boot_file = bootargs;
1171:
1172: /* Skip the kernel image filename */
1173: while (*cp != ' ' && *cp != 0)
1174: ++cp;
1175:
1176: if (*cp != 0)
1177: *cp++ = 0;
1178:
1179: while (*cp == ' ')
1180: ++cp;
1181:
1182: boot_args = cp;
1183:
1184: printf("bootfile: %s\n", boot_file);
1185: printf("bootargs: %s\n", boot_args);
1186:
1187: /* Setup pointer to boot flags */
1188: while (*cp != '-')
1189: if (*cp++ == '\0')
1190: return;
1191:
1192: for (;*++cp;) {
1193: int fl;
1194:
1195: fl = 0;
1196: switch(*cp) {
1197: case 'a':
1198: fl |= RB_ASKNAME;
1199: break;
1200: case 'c':
1201: fl |= RB_CONFIG;
1202: break;
1203: case 'd':
1204: fl |= RB_KDB;
1205: break;
1206: case 's':
1207: fl |= RB_SINGLE;
1208: break;
1209: /* XXX undocumented console switching flags */
1210: case '0':
1211: console = "ffuart";
1212: break;
1213: case '1':
1214: console = "btuart";
1215: break;
1216: case '2':
1217: console = "stuart";
1218: break;
1219: default:
1220: printf("unknown option `%c'\n", *cp);
1221: break;
1222: }
1223: boothowto |= fl;
1224: }
1225: }
1226:
1227: #ifdef KGDB
1228: #ifndef KGDB_DEVNAME
1229: #define KGDB_DEVNAME "ffuart"
1230: #endif
1231: const char kgdb_devname[] = KGDB_DEVNAME;
1232:
1233: #if (NCOM > 0)
1234: #ifndef KGDB_DEVMODE
1235: #define KGDB_DEVMODE ((TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8) /* 8N1 */
1236: #endif
1237: int comkgdbmode = KGDB_DEVMODE;
1238: #endif /* NCOM */
1239:
1240: #endif /* KGDB */
1241:
1242: void
1243: consinit(void)
1244: {
1245: #if NCOM > 0
1246: static int consinit_called = 0;
1247: paddr_t paddr;
1248: u_int cken = 0;
1249:
1250: if (consinit_called != 0)
1251: return;
1252:
1253: consinit_called = 1;
1254:
1255: #ifdef KGDB
1256: if (strcmp(kgdb_devname, console) == 0) {
1257: /* port is reserved for kgdb */
1258: } else
1259: #endif
1260: if (strcmp(console, "ffuart") == 0) {
1261: paddr = PXA2X0_FFUART_BASE;
1262: cken = CKEN_FFUART;
1263: } else if (strcmp(console, "btuart") == 0) {
1264: paddr = PXA2X0_BTUART_BASE;
1265: cken = CKEN_BTUART;
1266: } else if (strcmp(console, "stuart") == 0) {
1267: paddr = PXA2X0_STUART_BASE;
1268: cken = CKEN_STUART;
1269: irda_on(0);
1270: }
1271: if (cken != 0 && comcnattach(&pxa2x0_a4x_bs_tag, paddr, comcnspeed,
1272: PXA2X0_COM_FREQ, comcnmode) == 0) {
1273: early_clkman(cken, 1);
1274: }
1275: #endif /* NCOM */
1276: }
1277:
1278: #ifdef KGDB
1279: void
1280: kgdb_port_init(void)
1281: {
1282: #if (NCOM > 0) && defined(COM_PXA2X0)
1283: paddr_t paddr;
1284: u_int cken;
1285:
1286: if (strcmp(kgdb_devname, "ffuart") == 0) {
1287: paddr = PXA2X0_FFUART_BASE;
1288: cken = CKEN_FFUART;
1289: } else if (strcmp(kgdb_devname, "btuart") == 0) {
1290: paddr = PXA2X0_BTUART_BASE;
1291: cken = CKEN_BTUART;
1292: } else if (strcmp(kgdb_devname, "stuart") == 0) {
1293: paddr = PXA2X0_STUART_BASE;
1294: cken = CKEN_STUART;
1295: irda_on(0);
1296: } else
1297: return;
1298:
1299: if (com_kgdb_attach_pxa2x0(&pxa2x0_a4x_bs_tag, paddr,
1300: kgdb_rate, PXA2X0_COM_FREQ, COM_TYPE_PXA2x0, comkgdbmode) == 0) {
1301: early_clkman(cken, 1);
1302: }
1303: #endif
1304: }
1305: #endif
1306:
1307: /* same as pxa2x0_clkman, but before autoconf */
1308: void
1309: early_clkman(u_int clk, int enable)
1310: {
1311: u_int32_t rv;
1312:
1313: rv = ioreg_read(ZAURUS_CLKMAN_VBASE + CLKMAN_CKEN);
1314: if (enable)
1315: rv |= clk;
1316: else
1317: rv &= ~clk;
1318: ioreg_write(ZAURUS_CLKMAN_VBASE + CLKMAN_CKEN, rv);
1319: }
1320:
1321: int glass_console = 0;
1322:
1323: void
1324: board_startup(void)
1325: {
1326: extern int lcd_cnattach(void (*)(u_int, int));
1327: extern bus_addr_t comconsaddr;
1328:
1329: #if NWSDISPLAY > 0
1330: /*
1331: * Try to attach the display console now that VM services
1332: * are available.
1333: */
1334:
1335: if ((cputype & ~CPU_ID_XSCALE_COREREV_MASK) == CPU_ID_PXA27X) {
1336: if (strcmp(console, "glass") == 0) {
1337: printf("attempting to switch console to lcd screen\n");
1338: glass_console = 1;
1339: }
1340: if (glass_console == 1 && lcd_cnattach(early_clkman) == 0) {
1341: /*
1342: * Kill the existing serial console.
1343: * XXX need to bus_space_unmap resources and disable
1344: * clocks...
1345: */
1346: comconsaddr = 0;
1347:
1348: /*
1349: * Display the copyright notice again on the new console
1350: */
1351: extern const char copyright[];
1352: printf("%s\n", copyright);
1353: }
1354: }
1355: #endif
1356:
1357: if (boothowto & RB_CONFIG) {
1358: #ifdef BOOT_CONFIG
1359: user_config();
1360: #else
1361: printf("kernel does not support -c; continuing..\n");
1362: #endif
1363: }
1364: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to zaurus_machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / zaurus / zaurus