projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[mac80211] Do not build the mac80211 module in the kernel.
[openwrt.git] / target / linux / coldfire / patches / 008-mcfv4e_coldfire_code.patch
1 From 70b2bd01829b38a1a79caeda05d436b2e5fecf82 Mon Sep 17 00:00:00 2001
2 From: Kurt Mahan <kmahan@freescale.com>
3 Date: Wed, 31 Oct 2007 17:00:18 -0600
4 Subject: [PATCH] Core Coldfire/MCF5445x specific code.
5
6 LTIBName: mcfv4e-coldfire-code
7 Signed-off-by: Kurt Mahan <kmahan@freescale.com>
8 ---
9 arch/m68k/coldfire/Makefile | 11 +
10 arch/m68k/coldfire/cache.c | 215 +++++++++
11 arch/m68k/coldfire/config.c | 420 ++++++++++++++++++
12 arch/m68k/coldfire/entry.S | 701 ++++++++++++++++++++++++++++++
13 arch/m68k/coldfire/head.S | 474 ++++++++++++++++++++
14 arch/m68k/coldfire/ints.c | 384 ++++++++++++++++
15 arch/m68k/coldfire/iomap.c | 54 +++
16 arch/m68k/coldfire/mcf5445x-pci.c | 427 ++++++++++++++++++
17 arch/m68k/coldfire/muldi3.S | 64 +++
18 arch/m68k/coldfire/pci.c | 245 +++++++++++
19 arch/m68k/coldfire/signal.c | 868 +++++++++++++++++++++++++++++++++++++
20 arch/m68k/coldfire/traps.c | 454 +++++++++++++++++++
21 arch/m68k/coldfire/vmlinux-cf.lds | 92 ++++
22 13 files changed, 4409 insertions(+), 0 deletions(-)
23 create mode 100644 arch/m68k/coldfire/Makefile
24 create mode 100644 arch/m68k/coldfire/cache.c
25 create mode 100644 arch/m68k/coldfire/config.c
26 create mode 100644 arch/m68k/coldfire/entry.S
27 create mode 100644 arch/m68k/coldfire/head.S
28 create mode 100644 arch/m68k/coldfire/ints.c
29 create mode 100644 arch/m68k/coldfire/iomap.c
30 create mode 100644 arch/m68k/coldfire/mcf5445x-pci.c
31 create mode 100644 arch/m68k/coldfire/muldi3.S
32 create mode 100644 arch/m68k/coldfire/pci.c
33 create mode 100644 arch/m68k/coldfire/signal.c
34 create mode 100644 arch/m68k/coldfire/traps.c
35 create mode 100644 arch/m68k/coldfire/vmlinux-cf.lds
36
37 --- /dev/null
38 +++ b/arch/m68k/coldfire/Makefile
39 @@ -0,0 +1,11 @@
40 +#
41 +# Makefile for Linux arch/m68k/coldfire source directory
42 +#
43 +
44 +obj-y:= entry.o config.o cache.o signal.o muldi3.o traps.o ints.o
45 +
46 +ifneq ($(strip $(CONFIG_USB) $(CONFIG_USB_GADGET_MCF5445X)),)
47 + obj-y += usb.o usb/
48 +endif
49 +
50 +obj-$(CONFIG_PCI) += pci.o mcf5445x-pci.o iomap.o
51 --- /dev/null
52 +++ b/arch/m68k/coldfire/cache.c
53 @@ -0,0 +1,215 @@
54 +/*
55 + * linux/arch/m68k/coldifre/cache.c
56 + *
57 + * Matt Waddel Matt.Waddel@freescale.com
58 + * Copyright Freescale Semiconductor, Inc. 2007
59 + *
60 + * This program is free software; you can redistribute it and/or modify
61 + * it under the terms of the GNU General Public License as published by
62 + * the Free Software Foundation; either version 2 of the License, or
63 + * (at your option) any later version.
64 + */
65 +
66 +#include <linux/interrupt.h>
67 +#include <asm/cfcache.h>
68 +#include <asm/coldfire.h>
69 +#include <asm/system.h>
70 +
71 +#define _DCACHE_SIZE (2*16384)
72 +#define _ICACHE_SIZE (2*16384)
73 +
74 +#define _SET_SHIFT 4
75 +
76 +/*
77 + * Masks for cache sizes. Programming note: because the set size is a
78 + * power of two, the mask is also the last address in the set.
79 + */
80 +
81 +#define _DCACHE_SET_MASK ((_DCACHE_SIZE/64-1)<<_SET_SHIFT)
82 +#define _ICACHE_SET_MASK ((_ICACHE_SIZE/64-1)<<_SET_SHIFT)
83 +#define LAST_DCACHE_ADDR _DCACHE_SET_MASK
84 +#define LAST_ICACHE_ADDR _ICACHE_SET_MASK
85 +
86 +/************************************************************
87 + * Routine to cleanly flush the cache, pushing all lines and
88 + * invalidating them.
89 + *
90 + * The is the flash-resident version, used after copying the .text
91 + * segment from flash to ram.
92 + *************************************************************/
93 +void FLASHDcacheFlushInvalidate(void)
94 + __attribute__ ((section (".text_loader")));
95 +
96 +void FLASHDcacheFlushInvalidate()
97 +{
98 + unsigned long set;
99 + unsigned long start_set;
100 + unsigned long end_set;
101 +
102 + start_set = 0;
103 + end_set = (unsigned long)LAST_DCACHE_ADDR;
104 +
105 + for (set = start_set; set < end_set; set += (0x10 - 3))
106 + asm volatile("cpushl %%dc,(%0)\n"
107 + "\taddq%.l #1,%0\n"
108 + "\tcpushl %%dc,(%0)\n"
109 + "\taddq%.l #1,%0\n"
110 + "\tcpushl %%dc,(%0)\n"
111 + "\taddq%.l #1,%0\n"
112 + "\tcpushl %%dc,(%0)" : : "a" (set));
113 +}
114 +
115 +/************************************************************
116 + * Routine to cleanly flush the cache, pushing all lines and
117 + * invalidating them.
118 + *
119 + *************************************************************/
120 +void DcacheFlushInvalidate()
121 +{
122 + unsigned long set;
123 + unsigned long start_set;
124 + unsigned long end_set;
125 +
126 + start_set = 0;
127 + end_set = (unsigned long)LAST_DCACHE_ADDR;
128 +
129 + for (set = start_set; set < end_set; set += (0x10 - 3))
130 + asm volatile("cpushl %%dc,(%0)\n"
131 + "\taddq%.l #1,%0\n"
132 + "\tcpushl %%dc,(%0)\n"
133 + "\taddq%.l #1,%0\n"
134 + "\tcpushl %%dc,(%0)\n"
135 + "\taddq%.l #1,%0\n"
136 + "\tcpushl %%dc,(%0)" : : "a" (set));
137 +}
138 +
139 +
140 +
141 +/******************************************************************************
142 + * Routine to cleanly flush the a block of cache, pushing all relevant lines
143 + * and invalidating them.
144 + *
145 + ******************************************************************************/
146 +void DcacheFlushInvalidateCacheBlock(void *start, unsigned long size)
147 +{
148 + unsigned long set;
149 + unsigned long start_set;
150 + unsigned long end_set;
151 +
152 + /* if size is bigger than the cache can store
153 + * set the size to the maximum amount
154 + */
155 +
156 + if (size > LAST_DCACHE_ADDR)
157 + size = LAST_DCACHE_ADDR;
158 +
159 + start_set = ((unsigned long)start) & _DCACHE_SET_MASK;
160 + end_set = ((unsigned long)(start+size-1)) & _DCACHE_SET_MASK;
161 +
162 + if (start_set > end_set) {
163 + /* from the begining to the lowest address */
164 + for (set = 0; set <= end_set; set += (0x10 - 3))
165 + asm volatile("cpushl %%dc,(%0)\n"
166 + "\taddq%.l #1,%0\n"
167 + "\tcpushl %%dc,(%0)\n"
168 + "\taddq%.l #1,%0\n"
169 + "\tcpushl %%dc,(%0)\n"
170 + "\taddq%.l #1,%0\n"
171 + "\tcpushl %%dc,(%0)" : : "a" (set));
172 +
173 + /* next loop will finish the cache ie pass the hole */
174 + end_set = LAST_DCACHE_ADDR;
175 + }
176 + for (set = start_set; set <= end_set; set += (0x10 - 3))
177 + asm volatile("cpushl %%dc,(%0)\n"
178 + "\taddq%.l #1,%0\n"
179 + "\tcpushl %%dc,(%0)\n"
180 + "\taddq%.l #1,%0\n"
181 + "\tcpushl %%dc,(%0)\n"
182 + "\taddq%.l #1,%0\n"
183 + "\tcpushl %%dc,(%0)" : : "a" (set));
184 +}
185 +
186 +
187 +void IcacheInvalidateCacheBlock(void *start, unsigned long size)
188 +{
189 + unsigned long set;
190 + unsigned long start_set;
191 + unsigned long end_set;
192 +
193 + /* if size is bigger than the cache can store
194 + * set the size to the maximum ammount
195 + */
196 +
197 + if (size > LAST_ICACHE_ADDR)
198 + size = LAST_ICACHE_ADDR;
199 +
200 + start_set = ((unsigned long)start) & _ICACHE_SET_MASK;
201 + end_set = ((unsigned long)(start+size-1)) & _ICACHE_SET_MASK;
202 +
203 + if (start_set > end_set) {
204 + /* from the begining to the lowest address */
205 + for (set = 0; set <= end_set; set += (0x10 - 3))
206 + asm volatile("cpushl %%ic,(%0)\n"
207 + "\taddq%.l #1,%0\n"
208 + "\tcpushl %%ic,(%0)\n"
209 + "\taddq%.l #1,%0\n"
210 + "\tcpushl %%ic,(%0)\n"
211 + "\taddq%.l #1,%0\n"
212 + "\tcpushl %%ic,(%0)" : : "a" (set));
213 +
214 + /* next loop will finish the cache ie pass the hole */
215 + end_set = LAST_ICACHE_ADDR;
216 + }
217 + for (set = start_set; set <= end_set; set += (0x10 - 3))
218 + asm volatile("cpushl %%ic,(%0)\n"
219 + "\taddq%.l #1,%0\n"
220 + "\tcpushl %%ic,(%0)\n"
221 + "\taddq%.l #1,%0\n"
222 + "\tcpushl %%ic,(%0)\n"
223 + "\taddq%.l #1,%0\n"
224 + "\tcpushl %%ic,(%0)" : : "a" (set));
225 +}
226 +
227 +
228 +/********************************************************************
229 + * Disable the data cache completely
230 + ********************************************************************/
231 +void DcacheDisable(void)
232 +{
233 + int newValue;
234 + unsigned long flags;
235 +
236 + local_save_flags(flags);
237 + local_irq_disable();
238 +
239 + DcacheFlushInvalidate(); /* begin by flushing the cache */
240 + newValue = CACHE_DISABLE_MODE; /* disable it */
241 + cacr_set(newValue);
242 + local_irq_restore(flags);
243 +}
244 +
245 +/********************************************************************
246 + * Unconditionally enable the data cache
247 + ********************************************************************/
248 +void DcacheEnable(void)
249 +{
250 + cacr_set(CACHE_INITIAL_MODE);
251 +}
252 +
253 +
254 +unsigned long shadow_cacr;
255 +
256 +void cacr_set(unsigned long x)
257 +{
258 + shadow_cacr = x;
259 +
260 + __asm__ __volatile__ ("movec %0, %%cacr"
261 + : /* no outputs */
262 + : "r" (shadow_cacr));
263 +}
264 +
265 +unsigned long cacr_get(void)
266 +{
267 + return shadow_cacr;
268 +}
269 --- /dev/null
270 +++ b/arch/m68k/coldfire/config.c
271 @@ -0,0 +1,420 @@
272 +/*
273 + * linux/arch/m68k/coldifre/config.c
274 + *
275 + * Matt Waddel Matt.Waddel@freescale.com
276 + * Copyright Freescale Semiconductor, Inc. 2007
277 + *
278 + * This program is free software; you can redistribute it and/or modify
279 + * it under the terms of the GNU General Public License as published by
280 + * the Free Software Foundation; either version 2 of the License, or
281 + * (at your option) any later version.
282 + */
283 +
284 +#include <linux/module.h>
285 +#include <linux/init.h>
286 +#include <linux/string.h>
287 +#include <linux/kernel.h>
288 +#include <linux/console.h>
289 +#include <linux/bootmem.h>
290 +#include <linux/mm.h>
291 +#include <asm/bootinfo.h>
292 +#include <asm/machdep.h>
293 +#include <asm/coldfire.h>
294 +#include <asm/cfcache.h>
295 +#include <asm/bootinfo.h>
296 +#include <asm/io.h>
297 +#include <asm/cfmmu.h>
298 +#include <asm/setup.h>
299 +#include <asm/irq.h>
300 +#include <asm/traps.h>
301 +#include <asm/movs.h>
302 +#include <asm/movs.h>
303 +#include <asm/page.h>
304 +#include <asm/pgalloc.h>
305 +#include <asm/mcf5445x_intc.h>
306 +#include <asm/mcf5445x_sdramc.h>
307 +#include <asm/mcf5445x_fbcs.h>
308 +#include <asm/mcf5445x_dtim.h>
309 +
310 +/* JKM -- testing */
311 +#include <linux/pfn.h>
312 +/* JKM */
313 +
314 +extern int get_irq_list(struct seq_file *p, void *v);
315 +extern char _text, _end;
316 +extern char _etext, _edata, __init_begin, __init_end;
317 +extern struct console mcfrs_console;
318 +extern char m68k_command_line[CL_SIZE];
319 +extern unsigned long availmem;
320 +
321 +static int irq_enable[NR_IRQS];
322 +unsigned long num_pages;
323 +
324 +void coldfire_sort_memrec(void)
325 +{
326 + int i, j;
327 +
328 + /* Sort the m68k_memory records by address */
329 + for (i = 0; i < m68k_num_memory; ++i) {
330 + for (j = i + 1; j < m68k_num_memory; ++j) {
331 + if (m68k_memory[i].addr > m68k_memory[j].addr) {
332 + struct mem_info tmp;
333 + tmp = m68k_memory[i];
334 + m68k_memory[i] = m68k_memory[j];
335 + m68k_memory[j] = tmp;
336 + }
337 + }
338 + }
339 + /* Trim off discontiguous bits */
340 + for (i = 1; i < m68k_num_memory; ++i) {
341 + if ((m68k_memory[i-1].addr + m68k_memory[i-1].size) !=
342 + m68k_memory[i].addr) {
343 + printk(KERN_DEBUG "m68k_parse_bootinfo: addr gap between \
344 + 0x%lx & 0x%lx\n",
345 + m68k_memory[i-1].addr+m68k_memory[i-1].size,
346 + m68k_memory[i].addr);
347 + m68k_num_memory = i;
348 + break;
349 + }
350 + }
351 +}
352 +
353 +int __init uboot_commandline(char *bootargs)
354 +{
355 + int len = 0, cmd_line_len;
356 + static struct uboot_record uboot_info;
357 +
358 + extern unsigned long uboot_info_stk;
359 +
360 + /* Add 0x80000000 to get post-remapped kernel memory location */
361 + uboot_info.bd_info = (*(u32 *)(uboot_info_stk)) + 0x80000000;
362 + uboot_info.initrd_start = (*(u32 *)(uboot_info_stk+4)) + 0x80000000;
363 + uboot_info.initrd_end = (*(u32 *)(uboot_info_stk+8)) + 0x80000000;
364 + uboot_info.cmd_line_start = (*(u32 *)(uboot_info_stk+12)) + 0x80000000;
365 + uboot_info.cmd_line_stop = (*(u32 *)(uboot_info_stk+16)) + 0x80000000;
366 +
367 + cmd_line_len = uboot_info.cmd_line_stop - uboot_info.cmd_line_start;
368 + if ((cmd_line_len > 0) && (cmd_line_len < CL_SIZE-1))
369 + len = (int)strncpy(bootargs, (char *)uboot_info.cmd_line_start,\
370 + cmd_line_len);
371 +
372 + return len;
373 +}
374 +
375 +/*
376 + * This routine does things not done in the bootloader.
377 + */
378 +#define DEFAULT_COMMAND_LINE "root=/dev/mtdblock1 rw rootfstype=jffs2 ip=none mtdparts=physmap-flash.0:5M(kernel)ro,-(jffs2)"
379 +asmlinkage void __init cf_early_init(void)
380 +{
381 + struct bi_record *record = (struct bi_record *) &_end;
382 +
383 + extern char _end;
384 +
385 + SET_VBR((void *)MCF_RAMBAR1);
386 +
387 + /* Mask all interrupts */
388 + MCF_INTC0_IMRL = 0xFFFFFFFF;
389 + MCF_INTC0_IMRH = 0xFFFFFFFF;
390 + MCF_INTC1_IMRL = 0xFFFFFFFF;
391 + MCF_INTC1_IMRH = 0xFFFFFFFF;
392 +
393 +#if defined(CONFIG_NOR_FLASH_BASE)
394 + MCF_FBCS_CSAR(1) = CONFIG_NOR_FLASH_BASE;
395 +#else
396 + MCF_FBCS_CSAR(1) = 0x00000000;
397 +#endif
398 +
399 +#if CONFIG_SDRAM_SIZE > (256*1024*1024)
400 + /* Init optional SDRAM chip select */
401 + MCF_SDRAMC_SDCS(1) = (256*1024*1024) | 0x1B;
402 +#endif
403 +
404 + m68k_machtype = MACH_CFMMU;
405 + m68k_fputype = FPU_CFV4E;
406 + m68k_mmutype = MMU_CFV4E;
407 + m68k_cputype = CPU_CFV4E;
408 +
409 + m68k_num_memory = 0;
410 + m68k_memory[m68k_num_memory].addr = CONFIG_SDRAM_BASE;
411 + m68k_memory[m68k_num_memory++].size = CONFIG_SDRAM_SIZE;
412 +
413 + if (!uboot_commandline(m68k_command_line)) {
414 +#if defined(CONFIG_BOOTPARAM)
415 + strncpy(m68k_command_line, CONFIG_BOOTPARAM_STRING, CL_SIZE-1);
416 +#else
417 + strcpy(m68k_command_line, DEFAULT_COMMAND_LINE);
418 +#endif
419 + }
420 +
421 +
422 +#if defined(CONFIG_BLK_DEV_INITRD)
423 + /* add initrd image */
424 + record = (struct bi_record *) ((void *)record + record->size);
425 + record->tag = BI_RAMDISK;
426 + record->size = sizeof(record->tag) + sizeof(record->size)
427 + + sizeof(record->data[0]) + sizeof(record->data[1]);
428 +#endif
429 +
430 + /* Mark end of tags. */
431 + record = (struct bi_record *) ((void *) record + record->size);
432 + record->tag = 0;
433 + record->data[0] = 0;
434 + record->data[1] = 0;
435 + record->size = sizeof(record->tag) + sizeof(record->size)
436 + + sizeof(record->data[0]) + sizeof(record->data[1]);
437 +
438 + /* Invalidate caches via CACR */
439 + cacr_set(CACHE_DISABLE_MODE);
440 +
441 + /* Turn on caches via CACR, enable EUSP */
442 + cacr_set(CACHE_INITIAL_MODE);
443 +}
444 +
445 +void settimericr(unsigned int timer, unsigned int level)
446 +{
447 + volatile unsigned char *icrp;
448 + unsigned int icr;
449 + unsigned char irq;
450 +
451 + if (timer <= 2) {
452 + switch (timer) {
453 + case 2: irq = 33; icr = MCFSIM_ICR_TIMER2; break;
454 + default: irq = 32; icr = MCFSIM_ICR_TIMER1; break;
455 + }
456 +
457 + icrp = (volatile unsigned char *) (icr);
458 + *icrp = level;
459 + coldfire_enable_irq0(irq);
460 + }
461 +}
462 +
463 +/* Assembler routines */
464 +asmlinkage void buserr(void);
465 +asmlinkage void trap(void);
466 +asmlinkage void system_call(void);
467 +asmlinkage void inthandler(void);
468 +
469 +void __init coldfire_trap_init(void)
470 +{
471 + int i = 0;
472 + e_vector *vectors;
473 +
474 + vectors = (e_vector *)MCF_RAMBAR1;
475 + /*
476 + * There is a common trap handler and common interrupt
477 + * handler that handle almost every vector. We treat
478 + * the system call and bus error special, they get their
479 + * own first level handlers.
480 + */
481 + for (i = 3; (i <= 23); i++)
482 + vectors[i] = trap;
483 + for (i = 33; (i <= 63); i++)
484 + vectors[i] = trap;
485 + for (i = 24; (i <= 31); i++)
486 + vectors[i] = inthandler;
487 + for (i = 64; (i < 255); i++)
488 + vectors[i] = inthandler;
489 +
490 + vectors[255] = 0;
491 + vectors[2] = buserr;
492 + vectors[32] = system_call;
493 +}
494 +
495 +void coldfire_tick(void)
496 +{
497 + /* Reset the ColdFire timer */
498 + __raw_writeb(MCF_DTIM_DTER_CAP | MCF_DTIM_DTER_REF, MCF_DTIM0_DTER);
499 +}
500 +
501 +void __init coldfire_sched_init(irq_handler_t handler)
502 +{
503 + unsigned int mcf_timerlevel = 5;
504 + unsigned int mcf_timervector = 64+32;
505 +
506 + __raw_writew(MCF_DTIM_DTMR_RST_RST, MCF_DTIM0_DTMR);
507 + __raw_writel(((MCF_BUSCLK / 16) / HZ), MCF_DTIM0_DTRR);
508 + __raw_writew(MCF_DTIM_DTMR_ORRI | MCF_DTIM_DTMR_CLK_DIV16 |
509 + MCF_DTIM_DTMR_FRR | MCF_DTIM_DTMR_RST_EN, \
510 + MCF_DTIM0_DTMR);
511 +
512 + request_irq(mcf_timervector, handler, SA_INTERRUPT, \
513 + "timer", (void *)MCF_DTIM0_DTMR);
514 +
515 + settimericr(1, mcf_timerlevel);
516 +}
517 +
518 +int timerirqpending(int timer)
519 +{
520 + unsigned int imr = 0;
521 +
522 + switch (timer) {
523 + case 1: imr = 0x1; break;
524 + case 2: imr = 0x2; break;
525 + default: break;
526 + }
527 +
528 + return (getiprh() & imr);
529 +}
530 +
531 +unsigned long coldfire_gettimeoffset(void)
532 +{
533 + volatile unsigned long trr, tcn, offset;
534 +
535 + tcn = __raw_readw(MCF_DTIM0_DTCN);
536 + trr = __raw_readl(MCF_DTIM0_DTRR);
537 + offset = (tcn * (1000000 / HZ)) / trr;
538 +
539 + /* Check if we just wrapped the counters and maybe missed a tick */
540 + if ((offset < (1000000 / HZ / 2)) && timerirqpending(1))
541 + offset += 1000000 / HZ;
542 + return offset;
543 +}
544 +
545 +void coldfire_reboot(void)
546 +{
547 + /* disable interrupts and do a software reset */
548 + asm("movew #0x2700, %%sr\n\t"
549 + "moveb #0x80, %%d0\n\t"
550 + "moveb %%d0, 0xfc0a0000\n\t"
551 + : : : "%d0");
552 +}
553 +
554 +/* int coldfire_hwclk(int i, struct rtc_time *t)
555 +{
556 + printk ("Real time clock needs porting.\n");
557 + return 0;
558 +}*/
559 +
560 +static void coldfire_get_model(char *model)
561 +{
562 + sprintf(model, "Version 4 ColdFire");
563 +}
564 +
565 +void coldfire_enable_irq(unsigned int vec)
566 +{
567 + unsigned long flags;
568 +
569 + vec -= 64;
570 +
571 + if (((int)vec < 0) || (vec > 63)) {
572 + printk(KERN_WARNING "enable_irq %d failed\n", vec);
573 + return;
574 + }
575 +
576 + local_irq_save(flags);
577 + irq_enable[vec]++;
578 + if (vec < 32)
579 + MCF_INTC0_IMRL &= ~(1 << vec);
580 + else
581 + MCF_INTC0_IMRH &= ~(1 << (vec - 32));
582 + local_irq_restore(flags);
583 +}
584 +
585 +void coldfire_disable_irq(unsigned int vec)
586 +{
587 + unsigned long flags;
588 +
589 + vec -= 64;
590 +
591 + if (((int)vec < 0) || (vec > 63)) {
592 + printk(KERN_WARNING "disable_irq %d failed\n", vec);
593 + return;
594 + }
595 +
596 + local_irq_save(flags);
597 + if (--irq_enable[vec] == 0) {
598 + if (vec < 32)
599 + MCF_INTC0_IMRL |= (1 << vec);
600 + else
601 + MCF_INTC0_IMRH |= (1 << (vec - 32));
602 +
603 + }
604 + local_irq_restore(flags);
605 +}
606 +
607 +static void __init
608 +coldfire_bootmem_alloc(unsigned long memory_start, unsigned long memory_end)
609 +{
610 + unsigned long base_pfn;
611 +
612 + /* compute total pages in system */
613 + num_pages = PAGE_ALIGN(memory_end - PAGE_OFFSET) >> PAGE_SHIFT;
614 +
615 + /* align start/end to page boundries */
616 + memory_start = PAGE_ALIGN(memory_start);
617 + memory_end = memory_end & PAGE_MASK;
618 +
619 + /* page numbers */
620 + base_pfn = __pa(PAGE_OFFSET) >> PAGE_SHIFT;
621 + min_low_pfn = __pa(memory_start) >> PAGE_SHIFT;
622 + max_low_pfn = __pa(memory_end) >> PAGE_SHIFT;
623 +
624 + high_memory = (void *)memory_end;
625 + availmem = memory_start;
626 +
627 + /* setup bootmem data */
628 + m68k_setup_node(0);
629 + availmem += init_bootmem_node(NODE_DATA(0), min_low_pfn,
630 + base_pfn, max_low_pfn);
631 + availmem = PAGE_ALIGN(availmem);
632 + free_bootmem(__pa(availmem), memory_end - (availmem));
633 +}
634 +
635 +void __init config_coldfire(void)
636 +{
637 + unsigned long endmem, startmem;
638 + int i;
639 +
640 + /*
641 + * Calculate endmem from m68k_memory, assume all are contiguous
642 + */
643 + startmem = ((((int) &_end) + (PAGE_SIZE - 1)) & PAGE_MASK);
644 + endmem = PAGE_OFFSET;
645 + for (i = 0; i < m68k_num_memory; ++i)
646 + endmem += m68k_memory[i].size;
647 +
648 + printk(KERN_INFO "starting up linux startmem 0x%lx, endmem 0x%lx, \
649 + size %luMB\n", startmem, endmem, (endmem - startmem) >> 20);
650 +
651 + memset(irq_enable, 0, sizeof(irq_enable));
652 +
653 + /*
654 + * Setup coldfire mach-specific handlers
655 + */
656 + mach_max_dma_address = 0xffffffff;
657 + mach_sched_init = coldfire_sched_init;
658 + mach_tick = coldfire_tick;
659 + mach_gettimeoffset = coldfire_gettimeoffset;
660 + mach_reset = coldfire_reboot;
661 +/* mach_hwclk = coldfire_hwclk; to be done */
662 + mach_get_model = coldfire_get_model;
663 +
664 + coldfire_bootmem_alloc(startmem, endmem);
665 +
666 + /*
667 + * initrd setup
668 + */
669 +/* #ifdef CONFIG_BLK_DEV_INITRD
670 + if (m68k_ramdisk.size) {
671 + reserve_bootmem (__pa(m68k_ramdisk.addr), m68k_ramdisk.size);
672 + initrd_start = (unsigned long) m68k_ramdisk.addr;
673 + initrd_end = initrd_start + m68k_ramdisk.size;
674 + printk (KERN_DEBUG "initrd: %08lx - %08lx\n", initrd_start,
675 + initrd_end);
676 + }
677 +#endif */
678 +
679 +#if defined(CONFIG_DUMMY_CONSOLE) || defined(CONFIG_FRAMEBUFFER_CONSOLE)
680 + conswitchp = &dummy_con;
681 +#endif
682 +
683 +#if defined(CONFIG_SERIAL_COLDFIRE)
684 + /*
685 + * This causes trouble when it is re-registered later.
686 + * Currently this is fixed by conditionally commenting
687 + * out the register_console in mcf_serial.c
688 + */
689 + register_console(&mcfrs_console);
690 +#endif
691 +}
692 --- /dev/null
693 +++ b/arch/m68k/coldfire/entry.S
694 @@ -0,0 +1,701 @@
695 +/*
696 + * arch/m68k/coldfire/entry.S
697 + *
698 + * Copyright (C) 1999-2002, Greg Ungerer (gerg@snapgear.com)
699 + * Copyright (C) 1998 D. Jeff Dionne <jeff@lineo.ca>,
700 + * Kenneth Albanowski <kjahds@kjahds.com>,
701 + * Copyright (C) 2000 Lineo Inc. (www.lineo.com)
702 + * Copyright (C) 2004-2006 Macq Electronique SA. (www.macqel.com)
703 + * Matt Waddel Matt.Waddel@freescale.com
704 + * Kurt Mahan kmahan@freescale.com
705 + * Copyright Freescale Semiconductor, Inc. 2007
706 + *
707 + * Based on:
708 + *
709 + * arch/m68knommu/platform/5307/entry.S &
710 + * arch/m68k/kernel/entry.S
711 + *
712 + * Copyright (C) 1991, 1992 Linus Torvalds
713 + *
714 + * This file is subject to the terms and conditions of the GNU General Public
715 + * License. See the file README.legal in the main directory of this archive
716 + * for more details.
717 + *
718 + * Linux/m68k support by Hamish Macdonald
719 + *
720 + * ColdFire support by Greg Ungerer (gerg@snapgear.com)
721 + * 5307 fixes by David W. Miller
722 + * linux 2.4 support David McCullough <davidm@snapgear.com>
723 + * Bug, speed and maintainability fixes by Philippe De Muyter <phdm@macqel.be>
724 + * Ported to mmu Coldfire by Matt Waddel
725 + */
726 +
727 +#include <linux/sys.h>
728 +#include <linux/linkage.h>
729 +#include <asm/cf_entry.h>
730 +#include <asm/errno.h>
731 +#include <asm/setup.h>
732 +#include <asm/segment.h>
733 +#include <asm/traps.h>
734 +#include <asm/unistd.h>
735 +
736 +/*
737 + * TASK_INFO:
738 + *
739 + * - TINFO_PREEMPT (struct thread_info / preempt_count)
740 + * Used to keep track of preemptability
741 + * - TINFO_FLAGS (struct thread_info / flags - include/asm-m68k/thread_info.h)
742 + * Various bit flags that are checked for scheduling/tracing
743 + * Bits 0-7 are checked every exception exit
744 + * 8-15 are checked every syscall exit
745 + *
746 + * TIF_SIGPENDING 6
747 + * TIF_NEED_RESCHED 7
748 + * TIF_DELAYED_TRACE 14
749 + * TIF_SYSCALL_TRACE 15
750 + * TIF_MEMDIE 16 (never checked here)
751 + */
752 +
753 +.bss
754 +
755 +sw_ksp:
756 +.long 0
757 +
758 +sw_usp:
759 +.long 0
760 +
761 +.text
762 +
763 +.globl system_call
764 +.globl buserr
765 +.globl trap
766 +.globl resume
767 +.globl ret_from_exception
768 +.globl ret_from_signal
769 +.globl sys_call_table
770 +.globl ret_from_interrupt
771 +.globl inthandler
772 +
773 +ENTRY(buserr)
774 + SAVE_ALL_INT
775 + GET_CURRENT(%d0)
776 + movel %sp,%sp@- /* stack frame pointer argument */
777 + jsr buserr_c
778 + addql #4,%sp
779 + jra .Lret_from_exception
780 +
781 +ENTRY(trap)
782 + SAVE_ALL_INT
783 + GET_CURRENT(%d0)
784 + movel %sp,%sp@- /* stack frame pointer argument */
785 + jsr trap_c
786 + addql #4,%sp
787 + jra .Lret_from_exception
788 +
789 + /* After a fork we jump here directly from resume,
790 + %d1 contains the previous task schedule_tail */
791 +ENTRY(ret_from_fork)
792 + movel %d1,%sp@-
793 + jsr schedule_tail
794 + addql #4,%sp
795 + jra .Lret_from_exception
796 +
797 +do_trace_entry:
798 + movel #-ENOSYS,%d1 /* needed for strace */
799 + movel %d1,%sp@(PT_D0)
800 + subql #4,%sp
801 + SAVE_SWITCH_STACK
802 + jbsr syscall_trace
803 + RESTORE_SWITCH_STACK
804 + addql #4,%sp
805 + movel %sp@(PT_ORIG_D0),%d0
806 + cmpl #NR_syscalls,%d0
807 + jcs syscall
808 +badsys:
809 + movel #-ENOSYS,%d1
810 + movel %d1,%sp@(PT_D0)
811 + jra ret_from_exception
812 +
813 +do_trace_exit:
814 + subql #4,%sp
815 + SAVE_SWITCH_STACK
816 + jbsr syscall_trace
817 + RESTORE_SWITCH_STACK
818 + addql #4,%sp
819 + jra .Lret_from_exception
820 +
821 +ENTRY(ret_from_signal)
822 + RESTORE_SWITCH_STACK
823 + addql #4,%sp
824 + jra .Lret_from_exception
825 +
826 +ENTRY(system_call)
827 + SAVE_ALL_SYS
828 +
829 + GET_CURRENT(%d1)
830 + /* save top of frame */
831 + movel %sp,%curptr@(TASK_THREAD+THREAD_ESP0)
832 +
833 + /* syscall trace */
834 + tstb %curptr@(TASK_INFO+TINFO_FLAGS+2)
835 + jmi do_trace_entry /* SYSCALL_TRACE is set */
836 + cmpl #NR_syscalls,%d0
837 + jcc badsys
838 +syscall:
839 + movel #sys_call_table,%a0
840 + asll #2,%d0
841 + addl %d0,%a0
842 + movel %a0@,%a0
843 + jsr %a0@
844 + movel %d0,%sp@(PT_D0) /* save the return value */
845 +ret_from_syscall:
846 + movew %curptr@(TASK_INFO+TINFO_FLAGS+2),%d0
847 + jne syscall_exit_work /* flags set so process */
848 +1: RESTORE_ALL
849 +
850 +syscall_exit_work:
851 + btst #5,%sp@(PT_SR) /* check if returning to kernel */
852 + bnes 1b /* if so, skip resched, signals */
853 +
854 + btstl #15,%d0 /* check if SYSCALL_TRACE */
855 + jne do_trace_exit
856 + btstl #14,%d0 /* check if DELAYED_TRACE */
857 + jne do_delayed_trace
858 + btstl #6,%d0 /* check if SIGPENDING */
859 + jne do_signal_return
860 + pea resume_userspace
861 + jra schedule
862 +
863 +ENTRY(ret_from_exception)
864 +.Lret_from_exception:
865 + btst #5,%sp@(PT_SR) /* check if returning to kernel */
866 + bnes 1f /* if so, skip resched, signals */
867 + movel %d0,%sp@- /* Only allow interrupts when we are */
868 + move %sr,%d0 /* last one on the kernel stack, */
869 + andl #ALLOWINT,%d0 /* otherwise stack overflow can occur */
870 + move %d0,%sr /* during heavy interrupt load. */
871 + movel %sp@+,%d0
872 +
873 +resume_userspace:
874 + moveb %curptr@(TASK_INFO+TINFO_FLAGS+3),%d0
875 + jne exit_work /* SIGPENDING and/or NEED_RESCHED set */
876 +1: RESTORE_ALL
877 +
878 +exit_work:
879 + /* save top of frame */
880 + movel %sp,%curptr@(TASK_THREAD+THREAD_ESP0)
881 + btstl #6,%d0 /* check for SIGPENDING in flags */
882 + jne do_signal_return
883 + pea resume_userspace
884 + jra schedule
885 +
886 +do_signal_return:
887 + subql #4,%sp /* dummy return address */
888 + SAVE_SWITCH_STACK
889 + pea %sp@(SWITCH_STACK_SIZE)
890 + clrl %sp@-
891 + bsrl do_signal
892 + addql #8,%sp
893 + RESTORE_SWITCH_STACK
894 + addql #4,%sp
895 + jbra resume_userspace
896 +
897 +do_delayed_trace:
898 + bclr #7,%sp@(PT_SR) /* clear trace bit in SR */
899 + pea 1 /* send SIGTRAP */
900 + movel %curptr,%sp@-
901 + pea LSIGTRAP
902 + jbsr send_sig
903 + addql #8,%sp
904 + addql #4,%sp
905 + jbra resume_userspace
906 +
907 +/*
908 + * This is the interrupt handler (for all hardware interrupt
909 + * sources). It figures out the vector number and calls the appropriate
910 + * interrupt service routine directly.
911 + */
912 +ENTRY(inthandler)
913 + SAVE_ALL_INT
914 + GET_CURRENT(%d0)
915 + addql #1,%curptr@(TASK_INFO+TINFO_PREEMPT)
916 + /* put exception # in d0 */
917 + movel %sp@(PT_VECTOR),%d0
918 + swap %d0 /* extract bits 25:18 */
919 + lsrl #2,%d0
920 + andl #0x0ff,%d0
921 +
922 + movel %sp,%sp@-
923 + movel %d0,%sp@- /* put vector # on stack */
924 +auto_irqhandler_fixup = . + 2
925 + jbsr process_int /* process the IRQ */
926 + addql #8,%sp /* pop parameters off stack */
927 +
928 +ENTRY(ret_from_interrupt)
929 +ret_from_interrupt:
930 +
931 + subql #1,%curptr@(TASK_INFO+TINFO_PREEMPT)
932 + jeq ret_from_last_interrupt
933 +2: RESTORE_ALL
934 +
935 + ALIGN
936 +ret_from_last_interrupt:
937 + moveb %sp@(PT_SR),%d0
938 + andl #(~ALLOWINT>>8)&0xff,%d0
939 + jne 2b
940 +
941 + /* check if we need to do software interrupts */
942 + tstl irq_stat+CPUSTAT_SOFTIRQ_PENDING
943 + jeq .Lret_from_exception
944 + pea ret_from_exception
945 + jra do_softirq
946 +
947 +ENTRY(user_inthandler)
948 + SAVE_ALL_INT
949 + GET_CURRENT(%d0)
950 + addql #1,%curptr@(TASK_INFO+TINFO_PREEMPT)
951 + /* put exception # in d0 */
952 + movel %sp@(PT_VECTOR),%d0
953 +user_irqvec_fixup = . + 2
954 + swap %d0 /* extract bits 25:18 */
955 + lsrl #2,%d0
956 + andl #0x0ff,%d0
957 +
958 + movel %sp,%sp@-
959 + movel %d0,%sp@- /* put vector # on stack */
960 +user_irqhandler_fixup = . + 2
961 + jbsr process_int /* process the IRQ */
962 + addql #8,%sp /* pop parameters off stack */
963 +
964 + subql #1,%curptr@(TASK_INFO+TINFO_PREEMPT)
965 + jeq ret_from_last_interrupt
966 + RESTORE_ALL
967 +
968 +/* Handler for uninitialized and spurious interrupts */
969 +
970 +ENTRY(bad_inthandler)
971 + SAVE_ALL_INT
972 + GET_CURRENT(%d0)
973 + addql #1,%curptr@(TASK_INFO+TINFO_PREEMPT)
974 +
975 + movel %sp,%sp@-
976 + jsr handle_badint
977 + addql #4,%sp
978 +
979 + subql #1,%curptr@(TASK_INFO+TINFO_PREEMPT)
980 + jeq ret_from_last_interrupt
981 + RESTORE_ALL
982 +
983 +ENTRY(sys_fork)
984 + SAVE_SWITCH_STACK
985 + pea %sp@(SWITCH_STACK_SIZE)
986 + jbsr m68k_fork
987 + addql #4,%sp
988 + RESTORE_SWITCH_STACK
989 + rts
990 +
991 +ENTRY(sys_clone)
992 + SAVE_SWITCH_STACK
993 + pea %sp@(SWITCH_STACK_SIZE)
994 + jbsr m68k_clone
995 + addql #4,%sp
996 + RESTORE_SWITCH_STACK
997 + rts
998 +
999 +ENTRY(sys_vfork)
1000 + SAVE_SWITCH_STACK
1001 + pea %sp@(SWITCH_STACK_SIZE)
1002 + jbsr m68k_vfork
1003 + addql #4,%sp
1004 + RESTORE_SWITCH_STACK
1005 + rts
1006 +
1007 +ENTRY(sys_sigsuspend)
1008 + SAVE_SWITCH_STACK
1009 + pea %sp@(SWITCH_STACK_SIZE)
1010 + jbsr do_sigsuspend
1011 + addql #4,%sp
1012 + RESTORE_SWITCH_STACK
1013 + rts
1014 +
1015 +ENTRY(sys_rt_sigsuspend)
1016 + SAVE_SWITCH_STACK
1017 + pea %sp@(SWITCH_STACK_SIZE)
1018 + jbsr do_rt_sigsuspend
1019 + addql #4,%sp
1020 + RESTORE_SWITCH_STACK
1021 + rts
1022 +
1023 +ENTRY(sys_sigreturn)
1024 + SAVE_SWITCH_STACK
1025 + jbsr do_sigreturn
1026 + RESTORE_SWITCH_STACK
1027 + rts
1028 +
1029 +ENTRY(sys_rt_sigreturn)
1030 + SAVE_SWITCH_STACK
1031 + jbsr do_rt_sigreturn
1032 + RESTORE_SWITCH_STACK
1033 + rts
1034 +
1035 +resume:
1036 + /*
1037 + * Beware - when entering resume, prev (the current task) is
1038 + * in a0, next (the new task) is in a1,so don't change these
1039 + * registers until their contents are no longer needed.
1040 + */
1041 +
1042 + /* save sr */
1043 + movew %sr,%d0
1044 + movew %d0,%a0@(TASK_THREAD+THREAD_SR)
1045 +
1046 + /* save usp */
1047 + /* Save USP via %a1 (which is saved/restored from %d0) */
1048 + movel %a1,%d0
1049 + movel %usp,%a1
1050 + movel %a1,%a0@(TASK_THREAD+THREAD_USP)
1051 + movel %d0,%a1
1052 +
1053 + /* save non-scratch registers on stack */
1054 + SAVE_SWITCH_STACK
1055 +
1056 + /* save current kernel stack pointer */
1057 + movel %sp,%a0@(TASK_THREAD+THREAD_KSP)
1058 +
1059 + /* Return previous task in %d1 */
1060 + movel %curptr,%d1
1061 +
1062 + /* switch to new task (a1 contains new task) */
1063 + movel %a1,%curptr
1064 +
1065 + /* restore the kernel stack pointer */
1066 + movel %a1@(TASK_THREAD+THREAD_KSP),%sp
1067 +
1068 + /* restore non-scratch registers */
1069 + RESTORE_SWITCH_STACK
1070 +
1071 + /* restore user stack pointer */
1072 + movel %a1@(TASK_THREAD+THREAD_USP),%a0
1073 + movel %a0,%usp
1074 +
1075 + /* restore status register */
1076 + movew %a1@(TASK_THREAD+THREAD_SR),%d0
1077 + movew %d0,%sr
1078 +
1079 + rts
1080 +
1081 +.data
1082 +ALIGN
1083 +sys_call_table:
1084 + .long sys_ni_syscall /* 0 - old "setup()" system call*/
1085 + .long sys_exit
1086 + .long sys_fork
1087 + .long sys_read
1088 + .long sys_write
1089 + .long sys_open /* 5 */
1090 + .long sys_close
1091 + .long sys_waitpid
1092 + .long sys_creat
1093 + .long sys_link
1094 + .long sys_unlink /* 10 */
1095 + .long sys_execve
1096 + .long sys_chdir
1097 + .long sys_time
1098 + .long sys_mknod
1099 + .long sys_chmod /* 15 */
1100 + .long sys_chown16
1101 + .long sys_ni_syscall /* old break syscall holder */
1102 + .long sys_stat
1103 + .long sys_lseek
1104 + .long sys_getpid /* 20 */
1105 + .long sys_mount
1106 + .long sys_oldumount
1107 + .long sys_setuid16
1108 + .long sys_getuid16
1109 + .long sys_stime /* 25 */
1110 + .long sys_ptrace
1111 + .long sys_alarm
1112 + .long sys_fstat
1113 + .long sys_pause
1114 + .long sys_utime /* 30 */
1115 + .long sys_ni_syscall /* old stty syscall holder */
1116 + .long sys_ni_syscall /* old gtty syscall holder */
1117 + .long sys_access
1118 + .long sys_nice
1119 + .long sys_ni_syscall /* 35 */ /* old ftime syscall holder */
1120 + .long sys_sync
1121 + .long sys_kill
1122 + .long sys_rename
1123 + .long sys_mkdir
1124 + .long sys_rmdir /* 40 */
1125 + .long sys_dup
1126 + .long sys_pipe
1127 + .long sys_times
1128 + .long sys_ni_syscall /* old prof syscall holder */
1129 + .long sys_brk /* 45 */
1130 + .long sys_setgid16
1131 + .long sys_getgid16
1132 + .long sys_signal
1133 + .long sys_geteuid16
1134 + .long sys_getegid16 /* 50 */
1135 + .long sys_acct
1136 + .long sys_umount /* recycled never used phys() */
1137 + .long sys_ni_syscall /* old lock syscall holder */
1138 + .long sys_ioctl
1139 + .long sys_fcntl /* 55 */
1140 + .long sys_ni_syscall /* old mpx syscall holder */
1141 + .long sys_setpgid
1142 + .long sys_ni_syscall /* old ulimit syscall holder */
1143 + .long sys_ni_syscall
1144 + .long sys_umask /* 60 */
1145 + .long sys_chroot
1146 + .long sys_ustat
1147 + .long sys_dup2
1148 + .long sys_getppid
1149 + .long sys_getpgrp /* 65 */
1150 + .long sys_setsid
1151 + .long sys_sigaction
1152 + .long sys_sgetmask
1153 + .long sys_ssetmask
1154 + .long sys_setreuid16 /* 70 */
1155 + .long sys_setregid16
1156 + .long sys_sigsuspend
1157 + .long sys_sigpending
1158 + .long sys_sethostname
1159 + .long sys_setrlimit /* 75 */
1160 + .long sys_old_getrlimit
1161 + .long sys_getrusage
1162 + .long sys_gettimeofday
1163 + .long sys_settimeofday
1164 + .long sys_getgroups16 /* 80 */
1165 + .long sys_setgroups16
1166 + .long old_select
1167 + .long sys_symlink
1168 + .long sys_lstat
1169 + .long sys_readlink /* 85 */
1170 + .long sys_uselib
1171 + .long sys_swapon
1172 + .long sys_reboot
1173 + .long old_readdir
1174 + .long old_mmap /* 90 */
1175 + .long sys_munmap
1176 + .long sys_truncate
1177 + .long sys_ftruncate
1178 + .long sys_fchmod
1179 + .long sys_fchown16 /* 95 */
1180 + .long sys_getpriority
1181 + .long sys_setpriority
1182 + .long sys_ni_syscall /* old profil syscall holder */
1183 + .long sys_statfs
1184 + .long sys_fstatfs /* 100 */
1185 + .long sys_ni_syscall /* ioperm for i386 */
1186 + .long sys_socketcall
1187 + .long sys_syslog
1188 + .long sys_setitimer
1189 + .long sys_getitimer /* 105 */
1190 + .long sys_newstat
1191 + .long sys_newlstat
1192 + .long sys_newfstat
1193 + .long sys_ni_syscall
1194 + .long sys_ni_syscall /* 110 */ /* iopl for i386 */
1195 + .long sys_vhangup
1196 + .long sys_ni_syscall /* obsolete idle() syscall */
1197 + .long sys_ni_syscall /* vm86old for i386 */
1198 + .long sys_wait4
1199 + .long sys_swapoff /* 115 */
1200 + .long sys_sysinfo
1201 + .long sys_ipc
1202 + .long sys_fsync
1203 + .long sys_sigreturn
1204 + .long sys_clone /* 120 */
1205 + .long sys_setdomainname
1206 + .long sys_newuname
1207 + .long sys_cacheflush /* modify_ldt for i386 */
1208 + .long sys_adjtimex
1209 + .long sys_mprotect /* 125 */
1210 + .long sys_sigprocmask
1211 + .long sys_ni_syscall /* old "create_module" */
1212 + .long sys_init_module
1213 + .long sys_delete_module
1214 + .long sys_ni_syscall /* 130 - old "get_kernel_syms" */
1215 + .long sys_quotactl
1216 + .long sys_getpgid
1217 + .long sys_fchdir
1218 + .long sys_bdflush
1219 + .long sys_sysfs /* 135 */
1220 + .long sys_personality
1221 + .long sys_ni_syscall /* for afs_syscall */
1222 + .long sys_setfsuid16
1223 + .long sys_setfsgid16
1224 + .long sys_llseek /* 140 */
1225 + .long sys_getdents
1226 + .long sys_select
1227 + .long sys_flock
1228 + .long sys_msync
1229 + .long sys_readv /* 145 */
1230 + .long sys_writev
1231 + .long sys_getsid
1232 + .long sys_fdatasync
1233 + .long sys_sysctl
1234 + .long sys_mlock /* 150 */
1235 + .long sys_munlock
1236 + .long sys_mlockall
1237 + .long sys_munlockall
1238 + .long sys_sched_setparam
1239 + .long sys_sched_getparam /* 155 */
1240 + .long sys_sched_setscheduler
1241 + .long sys_sched_getscheduler
1242 + .long sys_sched_yield
1243 + .long sys_sched_get_priority_max
1244 + .long sys_sched_get_priority_min /* 160 */
1245 + .long sys_sched_rr_get_interval
1246 + .long sys_nanosleep
1247 + .long sys_mremap
1248 + .long sys_setresuid16
1249 + .long sys_getresuid16 /* 165 */
1250 + .long sys_getpagesize
1251 + .long sys_ni_syscall /* old sys_query_module */
1252 + .long sys_poll
1253 + .long sys_nfsservctl
1254 + .long sys_setresgid16 /* 170 */
1255 + .long sys_getresgid16
1256 + .long sys_prctl
1257 + .long sys_rt_sigreturn
1258 + .long sys_rt_sigaction
1259 + .long sys_rt_sigprocmask /* 175 */
1260 + .long sys_rt_sigpending
1261 + .long sys_rt_sigtimedwait
1262 + .long sys_rt_sigqueueinfo
1263 + .long sys_rt_sigsuspend
1264 + .long sys_pread64 /* 180 */
1265 + .long sys_pwrite64
1266 + .long sys_lchown16;
1267 + .long sys_getcwd
1268 + .long sys_capget
1269 + .long sys_capset /* 185 */
1270 + .long sys_sigaltstack
1271 + .long sys_sendfile
1272 + .long sys_ni_syscall /* streams1 */
1273 + .long sys_ni_syscall /* streams2 */
1274 + .long sys_vfork /* 190 */
1275 + .long sys_getrlimit
1276 + .long sys_mmap2
1277 + .long sys_truncate64
1278 + .long sys_ftruncate64
1279 + .long sys_stat64 /* 195 */
1280 + .long sys_lstat64
1281 + .long sys_fstat64
1282 + .long sys_chown
1283 + .long sys_getuid
1284 + .long sys_getgid /* 200 */
1285 + .long sys_geteuid
1286 + .long sys_getegid
1287 + .long sys_setreuid
1288 + .long sys_setregid
1289 + .long sys_getgroups /* 205 */
1290 + .long sys_setgroups
1291 + .long sys_fchown
1292 + .long sys_setresuid
1293 + .long sys_getresuid
1294 + .long sys_setresgid /* 210 */
1295 + .long sys_getresgid
1296 + .long sys_lchown
1297 + .long sys_setuid
1298 + .long sys_setgid
1299 + .long sys_setfsuid /* 215 */
1300 + .long sys_setfsgid
1301 + .long sys_pivot_root
1302 + .long sys_ni_syscall
1303 + .long sys_ni_syscall
1304 + .long sys_getdents64 /* 220 */
1305 + .long sys_gettid
1306 + .long sys_tkill
1307 + .long sys_setxattr
1308 + .long sys_lsetxattr
1309 + .long sys_fsetxattr /* 225 */
1310 + .long sys_getxattr
1311 + .long sys_lgetxattr
1312 + .long sys_fgetxattr
1313 + .long sys_listxattr
1314 + .long sys_llistxattr /* 230 */
1315 + .long sys_flistxattr
1316 + .long sys_removexattr
1317 + .long sys_lremovexattr
1318 + .long sys_fremovexattr
1319 + .long sys_futex /* 235 */
1320 + .long sys_sendfile64
1321 + .long sys_mincore
1322 + .long sys_madvise
1323 + .long sys_fcntl64
1324 + .long sys_readahead /* 240 */
1325 + .long sys_io_setup
1326 + .long sys_io_destroy
1327 + .long sys_io_getevents
1328 + .long sys_io_submit
1329 + .long sys_io_cancel /* 245 */
1330 + .long sys_fadvise64
1331 + .long sys_exit_group
1332 + .long sys_lookup_dcookie
1333 + .long sys_epoll_create
1334 + .long sys_epoll_ctl /* 250 */
1335 + .long sys_epoll_wait
1336 + .long sys_remap_file_pages
1337 + .long sys_set_tid_address
1338 + .long sys_timer_create
1339 + .long sys_timer_settime /* 255 */
1340 + .long sys_timer_gettime
1341 + .long sys_timer_getoverrun
1342 + .long sys_timer_delete
1343 + .long sys_clock_settime
1344 + .long sys_clock_gettime /* 260 */
1345 + .long sys_clock_getres
1346 + .long sys_clock_nanosleep
1347 + .long sys_statfs64
1348 + .long sys_fstatfs64
1349 + .long sys_tgkill /* 265 */
1350 + .long sys_utimes
1351 + .long sys_fadvise64_64
1352 + .long sys_mbind
1353 + .long sys_get_mempolicy
1354 + .long sys_set_mempolicy /* 270 */
1355 + .long sys_mq_open
1356 + .long sys_mq_unlink
1357 + .long sys_mq_timedsend
1358 + .long sys_mq_timedreceive
1359 + .long sys_mq_notify /* 275 */
1360 + .long sys_mq_getsetattr
1361 + .long sys_waitid
1362 + .long sys_ni_syscall /* for sys_vserver */
1363 + .long sys_add_key
1364 + .long sys_request_key /* 280 */
1365 + .long sys_keyctl
1366 + .long sys_ioprio_set
1367 + .long sys_ioprio_get
1368 + .long sys_inotify_init
1369 + .long sys_inotify_add_watch /* 285 */
1370 + .long sys_inotify_rm_watch
1371 + .long sys_migrate_pages
1372 + .long sys_openat
1373 + .long sys_mkdirat
1374 + .long sys_mknodat /* 290 */
1375 + .long sys_fchownat
1376 + .long sys_futimesat
1377 + .long sys_fstatat64
1378 + .long sys_unlinkat
1379 + .long sys_renameat /* 295 */
1380 + .long sys_linkat
1381 + .long sys_symlinkat
1382 + .long sys_readlinkat
1383 + .long sys_fchmodat
1384 + .long sys_faccessat /* 300 */
1385 + .long sys_ni_syscall /* Reserved for pselect6 */
1386 + .long sys_ni_syscall /* Reserved for ppoll */
1387 + .long sys_unshare
1388 + .long sys_set_robust_list
1389 + .long sys_get_robust_list /* 305 */
1390 + .long sys_splice
1391 + .long sys_sync_file_range
1392 + .long sys_tee
1393 + .long sys_vmsplice
1394 + .long sys_move_pages /* 310 */
1395 +
1396 --- /dev/null
1397 +++ b/arch/m68k/coldfire/head.S
1398 @@ -0,0 +1,474 @@
1399 +/*
1400 + * head.S is the MMU enabled ColdFire specific initial boot code
1401 + *
1402 + * Ported to ColdFire by
1403 + * Matt Waddel Matt.Waddel@freescale.com
1404 + * Kurt Mahan kmahan@freescale.com
1405 + * Copyright Freescale Semiconductor, Inc. 2007
1406 + *
1407 + * This program is free software; you can redistribute it and/or modify
1408 + * it under the terms of the GNU General Public License as published by
1409 + * the Free Software Foundation; either version 2 of the License, or
1410 + * (at your option) any later version.
1411 + *
1412 + * Parts of this code came from arch/m68k/kernel/head.S
1413 + */
1414 +#include <linux/linkage.h>
1415 +#include <linux/init.h>
1416 +#include <asm/bootinfo.h>
1417 +#include <asm/setup.h>
1418 +#include <asm/entry.h>
1419 +#include <asm/pgtable.h>
1420 +#include <asm/page.h>
1421 +#include <asm/coldfire.h>
1422 +#include <asm/mcfuart.h>
1423 +#include <asm/cfcache.h>
1424 +
1425 +#define DEBUG
1426 +
1427 +.globl kernel_pg_dir
1428 +.globl availmem
1429 +.globl set_context
1430 +.globl set_fpga
1431 +
1432 +#ifdef DEBUG
1433 +/* When debugging use readable names for labels */
1434 +#ifdef __STDC__
1435 +#define L(name) .head.S.##name
1436 +#else
1437 +#define L(name) .head.S./**/name
1438 +#endif
1439 +#else
1440 +#ifdef __STDC__
1441 +#define L(name) .L##name
1442 +#else
1443 +#define L(name) .L/**/name
1444 +#endif
1445 +#endif
1446 +
1447 +/* The __INITDATA stuff is a no-op when ftrace or kgdb are turned on */
1448 +#ifndef __INITDATA
1449 +#define __INITDATA .data
1450 +#define __FINIT .previous
1451 +#endif
1452 +
1453 +/*
1454 + * Setup ACR mappings to provide the following memory map:
1455 + * Data
1456 + * 0xA0000000 -> 0xAFFFFFFF [0] NO CACHE / PRECISE / SUPER ONLY
1457 + * 0xFC000000 -> 0xFCFFFFFF [1] NO CACHE / PRECISE / SUPER ONLY
1458 + * Code
1459 + * None currently (mapped via TLBs)
1460 + */
1461 +
1462 +#define ACR0_DEFAULT #0xA00FA048 /* ACR0 default value */
1463 +#define ACR1_DEFAULT #0xFC00A040 /* ACR1 default value */
1464 +#define ACR2_DEFAULT #0x00000000 /* ACR2 default value */
1465 +#define ACR3_DEFAULT #0x00000000 /* ACR3 default value */
1466 +
1467 +/* ACR mapping for FPGA (maps 0) */
1468 +#define ACR0_FPGA #0x000FA048 /* ACR0 enable FPGA */
1469 +
1470 +/* Several macros to make the writing of subroutines easier:
1471 + * - func_start marks the beginning of the routine which setups the frame
1472 + * register and saves the registers, it also defines another macro
1473 + * to automatically restore the registers again.
1474 + * - func_return marks the end of the routine and simply calls the prepared
1475 + * macro to restore registers and jump back to the caller.
1476 + * - func_define generates another macro to automatically put arguments
1477 + * onto the stack call the subroutine and cleanup the stack again.
1478 + */
1479 +
1480 +.macro load_symbol_address symbol,register
1481 + movel #\symbol,\register
1482 +.endm
1483 +
1484 +.macro func_start name,saveregs,savesize,stack=0
1485 +L(\name):
1486 + linkw %a6,#-\stack
1487 + subal #(\savesize),%sp
1488 + moveml \saveregs,%sp@
1489 +.set stackstart,-\stack
1490 +
1491 +.macro func_return_\name
1492 + moveml %sp@,\saveregs
1493 + addal #(\savesize),%sp
1494 + unlk %a6
1495 + rts
1496 +.endm
1497 +.endm
1498 +
1499 +.macro func_return name
1500 + func_return_\name
1501 +.endm
1502 +
1503 +.macro func_call name
1504 + jbsr L(\name)
1505 +.endm
1506 +
1507 +.macro move_stack nr,arg1,arg2,arg3,arg4
1508 +.if \nr
1509 + move_stack "(\nr-1)",\arg2,\arg3,\arg4
1510 + movel \arg1,%sp@-
1511 +.endif
1512 +.endm
1513 +
1514 +.macro func_define name,nr=0
1515 +.macro \name arg1,arg2,arg3,arg4
1516 + move_stack \nr,\arg1,\arg2,\arg3,\arg4
1517 + func_call \name
1518 +.if \nr
1519 + lea %sp@(\nr*4),%sp
1520 +.endif
1521 +.endm
1522 +.endm
1523 +
1524 +func_define serial_putc,1
1525 +
1526 +.macro putc ch
1527 + pea \ch
1528 + func_call serial_putc
1529 + addql #4,%sp
1530 +.endm
1531 +
1532 +.macro dputc ch
1533 +#ifdef DEBUG
1534 + putc \ch
1535 +#endif
1536 +.endm
1537 +
1538 +func_define putn,1
1539 +
1540 +.macro dputn nr
1541 +#ifdef DEBUG
1542 + putn \nr
1543 +#endif
1544 +.endm
1545 +
1546 +/*
1547 + mmu_map - creates a new TLB entry
1548 +
1549 + virt_addr Must be on proper boundary
1550 + phys_addr Must be on proper boundary
1551 + itlb MMUOR_ITLB if instruction TLB or 0
1552 + asid address space ID
1553 + shared_global MMUTR_SG if shared between different ASIDs or 0
1554 + size_code MMUDR_SZ1M 1 MB
1555 + MMUDR_SZ4K 4 KB
1556 + MMUDR_SZ8K 8 KB
1557 + MMUDR_SZ16M 16 MB
1558 + cache_mode MMUDR_INC instruction non-cacheable
1559 + MMUDR_IC instruction cacheable
1560 + MMUDR_DWT data writethrough
1561 + MMUDR_DCB data copyback
1562 + MMUDR_DNCP data non-cacheable, precise
1563 + MMUDR_DNCIP data non-cacheable, imprecise
1564 + super_prot MMUDR_SP if user mode generates exception or 0
1565 + readable MMUDR_R if permits read access (data TLB) or 0
1566 + writable MMUDR_W if permits write access (data TLB) or 0
1567 + executable MMUDR_X if permits execute access (instruction TLB) or 0
1568 + locked MMUDR_LK prevents TLB entry from being replaced or 0
1569 + temp_data_reg a data register to use for temporary values
1570 +*/
1571 +.macro mmu_map virt_addr,phys_addr,itlb,asid,shared_global,size_code,cache_mode,super_prot,readable,writable,executable,locked,temp_data_reg
1572 + /* Set up search of TLB. */
1573 + movel #(\virt_addr+1), \temp_data_reg
1574 + movel \temp_data_reg, MMUAR
1575 + /* Search. */
1576 + movel #(MMUOR_STLB + MMUOR_ADR +\itlb), \temp_data_reg
1577 + movew \temp_data_reg, (MMUOR)
1578 + /* Set up tag value. */
1579 + movel #(\virt_addr + \asid + \shared_global + MMUTR_V), \temp_data_reg
1580 + movel \temp_data_reg, MMUTR
1581 + /* Set up data value. */
1582 + movel #(\phys_addr + \size_code + \cache_mode + \super_prot + \readable + \writable + \executable + \locked), \temp_data_reg
1583 + movel \temp_data_reg, MMUDR
1584 + /* Save it. */
1585 + movel #(MMUOR_ACC + MMUOR_UAA + \itlb), \temp_data_reg
1586 + movew \temp_data_reg, (MMUOR)
1587 +.endm /* mmu_map */
1588 +
1589 +.macro mmu_unmap virt_addr,itlb,temp_data_reg
1590 + /* Set up search of TLB. */
1591 + movel #(\virt_addr+1), \temp_data_reg
1592 + movel \temp_data_reg, MMUAR
1593 + /* Search. */
1594 + movel #(MMUOR_STLB + MMUOR_ADR +\itlb), \temp_data_reg
1595 + movew \temp_data_reg, (MMUOR)
1596 + /* Test for hit. */
1597 + movel MMUSR,\temp_data_reg
1598 + btst #MMUSR_HITN,\temp_data_reg
1599 + beq 1f
1600 + /* Read the TLB. */
1601 + movel #(MMUOR_RW + MMUOR_ACC +\itlb), \temp_data_reg
1602 + movew \temp_data_reg, (MMUOR)
1603 + movel MMUSR,\temp_data_reg
1604 + /* Set up tag value. */
1605 + movel #0, \temp_data_reg
1606 + movel \temp_data_reg, MMUTR
1607 + /* Set up data value. */
1608 + movel #0, \temp_data_reg
1609 + movel \temp_data_reg, MMUDR
1610 + /* Save it. */
1611 + movel #(MMUOR_ACC + MMUOR_UAA + \itlb), \temp_data_reg
1612 + movew \temp_data_reg, (MMUOR)
1613 +1:
1614 +.endm /* mmu_unmap */
1615 +
1616 +/* .text */
1617 +.section ".text.head","ax"
1618 +ENTRY(_stext)
1619 +/* Version numbers of the bootinfo interface -- if we later pass info
1620 + * from boot ROM we might want to put something real here.
1621 + *
1622 + * The area from _stext to _start will later be used as kernel pointer table
1623 + */
1624 + bras 1f /* Jump over bootinfo version numbers */
1625 +
1626 + .long BOOTINFOV_MAGIC
1627 + .long 0
1628 +1: jmp __start-0x80000000
1629 +
1630 +.equ kernel_pg_dir,_stext
1631 +.equ .,_stext+0x1000
1632 +
1633 +ENTRY(_start)
1634 + jra __start
1635 +__INIT
1636 +ENTRY(__start)
1637 +
1638 +/* Save the location of u-boot info - cmd line, bd_info, etc. */
1639 + movel %a7,%a4 /* Don't use %a4 before cf_early_init */
1640 + addl #0x80000004,%a4 /* 0x80000004= 1 stack push + high mem offset */
1641 +
1642 +/* Setup initial stack pointer */
1643 + movel #0x40001000,%sp
1644 +
1645 +/* Clear usp */
1646 + subl %a0,%a0
1647 + movel %a0,%usp
1648 +
1649 + movel #(MCF_RAMBAR1 + 0x221), %d0
1650 + movec %d0, %rambar1
1651 + movew #0x2700,%sr
1652 +
1653 + movel #(MMU_BASE+1),%d0
1654 + movecl %d0,%mmubar
1655 + movel #MMUOR_CA,%a0 /* Clear tlb entries */
1656 + movew %a0,(MMUOR)
1657 + movel #(MMUOR_CA + MMUOR_ITLB),%a0 /* Use ITLB for searches */
1658 + movew %a0,(MMUOR)
1659 + movel #0,%a0 /* Clear Addr Space User ID */
1660 + movecl %a0,%asid
1661 +
1662 +/* setup ACRs */
1663 + movel ACR0_DEFAULT, %d0 /* ACR0 (DATA) setup */
1664 + movec %d0, %acr0
1665 + movel ACR1_DEFAULT, %d0 /* ACR1 (DATA) setup */
1666 + movec %d0, %acr1
1667 + movel ACR2_DEFAULT, %d0 /* ACR2 (CODE) setup */
1668 + movec %d0, %acr2
1669 + movel ACR3_DEFAULT, %d0 /* ACR3 (CODE) setup */
1670 + movec %d0, %acr3
1671 +
1672 + /* If you change the memory size to another value make a matching
1673 + change in paging_init(cf-mmu.c) to zones_size[]. */
1674 +
1675 + /* Map 256MB as code */
1676 + mmu_map (PAGE_OFFSET+0*0x1000000), (PHYS_OFFSET+0*0x1000000), \
1677 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1678 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1679 + mmu_map (PAGE_OFFSET+1*0x1000000), (PHYS_OFFSET+1*0x1000000), \
1680 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1681 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1682 + mmu_map (PAGE_OFFSET+2*0x1000000), (PHYS_OFFSET+2*0x1000000), \
1683 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1684 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1685 + mmu_map (PAGE_OFFSET+3*0x1000000), (PHYS_OFFSET+3*0x1000000), \
1686 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1687 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1688 + mmu_map (PAGE_OFFSET+4*0x1000000), (PHYS_OFFSET+4*0x1000000), \
1689 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1690 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1691 + mmu_map (PAGE_OFFSET+5*0x1000000), (PHYS_OFFSET+5*0x1000000), \
1692 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1693 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1694 + mmu_map (PAGE_OFFSET+6*0x1000000), (PHYS_OFFSET+6*0x1000000), \
1695 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1696 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1697 + mmu_map (PAGE_OFFSET+7*0x1000000), (PHYS_OFFSET+7*0x1000000), \
1698 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1699 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1700 + mmu_map (PAGE_OFFSET+8*0x1000000), (PHYS_OFFSET+8*0x1000000), \
1701 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1702 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1703 + mmu_map (PAGE_OFFSET+9*0x1000000), (PHYS_OFFSET+9*0x1000000), \
1704 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1705 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1706 + mmu_map (PAGE_OFFSET+10*0x1000000), (PHYS_OFFSET+10*0x1000000), \
1707 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1708 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1709 + mmu_map (PAGE_OFFSET+11*0x1000000), (PHYS_OFFSET+11*0x1000000), \
1710 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1711 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1712 + mmu_map (PAGE_OFFSET+12*0x1000000), (PHYS_OFFSET+12*0x1000000), \
1713 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1714 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1715 + mmu_map (PAGE_OFFSET+13*0x1000000), (PHYS_OFFSET+13*0x1000000), \
1716 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1717 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1718 + mmu_map (PAGE_OFFSET+14*0x1000000), (PHYS_OFFSET+14*0x1000000), \
1719 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1720 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1721 + mmu_map (PAGE_OFFSET+15*0x1000000), (PHYS_OFFSET+15*0x1000000), \
1722 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_IC, MMUDR_SP, \
1723 + 0, 0, MMUDR_X, MMUDR_LK, %d0
1724 +
1725 + /* Map 256MB as data also */
1726 + mmu_map (PAGE_OFFSET+0*0x1000000), (PHYS_OFFSET+0*0x1000000), 0, 0, \
1727 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1728 + 0, MMUDR_LK, %d0
1729 + mmu_map (PAGE_OFFSET+1*0x1000000), (PHYS_OFFSET+1*0x1000000), 0, 0, \
1730 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1731 + 0, MMUDR_LK, %d0
1732 + mmu_map (PAGE_OFFSET+2*0x1000000), (PHYS_OFFSET+2*0x1000000), 0, 0, \
1733 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1734 + 0, MMUDR_LK, %d0
1735 + mmu_map (PAGE_OFFSET+3*0x1000000), (PHYS_OFFSET+3*0x1000000), 0, 0, \
1736 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1737 + 0, MMUDR_LK, %d0
1738 + mmu_map (PAGE_OFFSET+4*0x1000000), (PHYS_OFFSET+4*0x1000000), 0, 0, \
1739 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1740 + 0, MMUDR_LK, %d0
1741 + mmu_map (PAGE_OFFSET+5*0x1000000), (PHYS_OFFSET+5*0x1000000), 0, 0, \
1742 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1743 + 0, MMUDR_LK, %d0
1744 + mmu_map (PAGE_OFFSET+6*0x1000000), (PHYS_OFFSET+6*0x1000000), 0, 0, \
1745 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1746 + 0, MMUDR_LK, %d0
1747 + mmu_map (PAGE_OFFSET+7*0x1000000), (PHYS_OFFSET+7*0x1000000), 0, 0, \
1748 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1749 + 0, MMUDR_LK, %d0
1750 + mmu_map (PAGE_OFFSET+8*0x1000000), (PHYS_OFFSET+8*0x1000000), 0, 0, \
1751 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1752 + 0, MMUDR_LK, %d0
1753 + mmu_map (PAGE_OFFSET+9*0x1000000), (PHYS_OFFSET+9*0x1000000), 0, 0, \
1754 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1755 + 0, MMUDR_LK, %d0
1756 + mmu_map (PAGE_OFFSET+10*0x1000000), (PHYS_OFFSET+10*0x1000000), 0, 0, \
1757 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1758 + 0, MMUDR_LK, %d0
1759 + mmu_map (PAGE_OFFSET+11*0x1000000), (PHYS_OFFSET+11*0x1000000), 0, 0, \
1760 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1761 + 0, MMUDR_LK, %d0
1762 + mmu_map (PAGE_OFFSET+12*0x1000000), (PHYS_OFFSET+12*0x1000000), 0, 0, \
1763 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1764 + 0, MMUDR_LK, %d0
1765 + mmu_map (PAGE_OFFSET+13*0x1000000), (PHYS_OFFSET+13*0x1000000), 0, 0, \
1766 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1767 + 0, MMUDR_LK, %d0
1768 + mmu_map (PAGE_OFFSET+14*0x1000000), (PHYS_OFFSET+14*0x1000000), 0, 0, \
1769 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1770 + 0, MMUDR_LK, %d0
1771 + mmu_map (PAGE_OFFSET+15*0x1000000), (PHYS_OFFSET+15*0x1000000), 0, 0, \
1772 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1773 + 0, MMUDR_LK, %d0
1774 +
1775 + /* Do unity mapping to enable the MMU. Map first 16 MB in place as
1776 + code (delete TLBs after MMU is enabled and we are executing in high
1777 + memory). */
1778 + mmu_map (PHYS_OFFSET+0*0x1000000), (PHYS_OFFSET+0*0x1000000), \
1779 + MMUOR_ITLB, 0, MMUTR_SG, MMUDR_SZ16M, MMUDR_INC, MMUDR_SP, 0, \
1780 + 0, MMUDR_X, 0, %d0
1781 + /* Map first 16 MB as data too. */
1782 + mmu_map (PHYS_OFFSET+0*0x1000000), (PHYS_OFFSET+0*0x1000000), 0, 0, \
1783 + MMUTR_SG, MMUDR_SZ16M, MMUDR_DNCP, MMUDR_SP, MMUDR_R, MMUDR_W, \
1784 + 0, 0, %d0
1785 +
1786 + /* Turn on MMU */
1787 + movel #(MMUCR_EN),%a0
1788 + movel %a0,MMUCR
1789 + nop /* This synchs the pipeline after a write to MMUCR */
1790 +
1791 + movel #__running_high,%a0 /* Get around PC-relative addressing. */
1792 + jmp %a0@
1793 +
1794 +ENTRY(__running_high)
1795 + load_symbol_address _stext,%sp
1796 + movel L(memory_start),%a0
1797 + movel %a0,availmem
1798 + load_symbol_address L(phys_kernel_start),%a0
1799 + load_symbol_address _stext,%a1
1800 + subl #_stext,%a1
1801 + addl #PAGE_OFFSET,%a1
1802 + movel %a1,%a0@
1803 +
1804 + /* Unmap first 16 MB, code and data. */
1805 + mmu_unmap (PHYS_OFFSET+0*0x1000000), MMUOR_ITLB, %d0
1806 + mmu_unmap (PHYS_OFFSET+0*0x1000000), 0, %d0
1807 +
1808 +/* Setup initial stack pointer */
1809 + lea init_task,%a2
1810 + lea init_thread_union+THREAD_SIZE,%sp
1811 + subl %a6,%a6 /* clear a6 for gdb */
1812 +
1813 +#ifdef CONFIG_MCF_USER_HALT
1814 +/* Setup debug control reg to allow halts from user space */
1815 + lea wdbg_uhe,%a0
1816 + wdebug (%a0)
1817 +#endif
1818 +
1819 + movel %a4,uboot_info_stk /* save uboot info to variable */
1820 + jsr cf_early_init
1821 + jmp start_kernel
1822 +
1823 +.section ".text.head","ax"
1824 +set_context:
1825 +func_start set_context,%d0,(1*4)
1826 + movel 12(%sp),%d0
1827 + movec %d0,%asid
1828 +func_return set_context
1829 +
1830 +/*
1831 + * set_fpga(addr,val)
1832 + *
1833 + * Map in 0x00000000 -> 0x0fffffff and then do the write.
1834 + */
1835 +set_fpga:
1836 + movew %sr,%d1
1837 + movew #0x2700,%sr
1838 + movel ACR0_FPGA, %d0
1839 + movec %d0, %acr0
1840 + nop
1841 + moveal 4(%sp),%a0
1842 + movel 8(%sp),%a0@
1843 + movel ACR0_DEFAULT, %d0
1844 + movec %d0, %acr0
1845 + nop
1846 + movew %d1,%sr
1847 + rts
1848 +
1849 + .data
1850 + .align 4
1851 +
1852 +availmem:
1853 + .long 0
1854 +L(phys_kernel_start):
1855 + .long PAGE_OFFSET
1856 +L(kernel_end):
1857 + .long 0
1858 +L(memory_start):
1859 + .long PAGE_OFFSET_RAW
1860 +
1861 +#ifdef CONFIG_MCF_USER_HALT
1862 +/*
1863 + * Enable User Halt Enable in the debug control register.
1864 + */
1865 +wdbg_uhe:
1866 + .word 0x2c80 /* DR0 */
1867 + .word 0x00b0 /* 31:16 */
1868 + .word 0x0400 /* 15:0 -- enable UHE */
1869 + .word 0x0000 /* unused */
1870 +#endif
1871 +
1872 +
1873 --- /dev/null
1874 +++ b/arch/m68k/coldfire/ints.c
1875 @@ -0,0 +1,384 @@
1876 +/*
1877 + * linux/arch/m68k/coldfire/ints.c -- General interrupt handling code
1878 + *
1879 + * Copyright (C) 1999-2002 Greg Ungerer (gerg@snapgear.com)
1880 + * Copyright (C) 1998 D. Jeff Dionne <jeff@lineo.ca>,
1881 + * Kenneth Albanowski <kjahds@kjahds.com>,
1882 + * Copyright (C) 2000 Lineo Inc. (www.lineo.com)
1883 + * Matt Waddel Matt.Waddel@freescale.com
1884 + * Copyright Freescale Semiconductor, Inc. 2007
1885 + * Kurt Mahan kmahan@freescale.com
1886 + *
1887 + * Based on:
1888 + * linux/arch/m68k/kernel/ints.c &
1889 + * linux/arch/m68knommu/5307/ints.c
1890 + *
1891 + * This file is subject to the terms and conditions of the GNU General Public
1892 + * License. See the file COPYING in the main directory of this archive
1893 + * for more details.
1894 + */
1895 +
1896 +#include <linux/module.h>
1897 +#include <linux/types.h>
1898 +#include <linux/init.h>
1899 +#include <linux/sched.h>
1900 +#include <linux/kernel_stat.h>
1901 +#include <linux/errno.h>
1902 +#include <linux/seq_file.h>
1903 +#include <linux/interrupt.h>
1904 +
1905 +#include <asm/system.h>
1906 +#include <asm/irq.h>
1907 +#include <asm/traps.h>
1908 +#include <asm/page.h>
1909 +#include <asm/machdep.h>
1910 +#include <asm/irq_regs.h>
1911 +
1912 +#include <asm/mcfsim.h>
1913 +
1914 +/*
1915 + * IRQ Handler lists.
1916 + */
1917 +static struct irq_node *irq_list[SYS_IRQS];
1918 +static struct irq_controller *irq_controller[SYS_IRQS];
1919 +static int irq_depth[SYS_IRQS];
1920 +
1921 +/*
1922 + * IRQ Controller
1923 + */
1924 +#ifdef CONFIG_M54455
1925 +void m5445x_irq_enable(unsigned int irq);
1926 +void m5445x_irq_disable(unsigned int irq);
1927 +static struct irq_controller m5445x_irq_controller = {
1928 + .name = "M5445X",
1929 + .lock = SPIN_LOCK_UNLOCKED,
1930 + .enable = m5445x_irq_enable,
1931 + .disable = m5445x_irq_disable,
1932 +};
1933 +#endif
1934 +
1935 +#define POOL_SIZE SYS_IRQS
1936 +static struct irq_node pool[POOL_SIZE];
1937 +static struct irq_node *get_irq_node(void);
1938 +
1939 +/* The number of spurious interrupts */
1940 +unsigned int num_spurious;
1941 +asmlinkage void handle_badint(struct pt_regs *regs);
1942 +
1943 +/*
1944 + * void init_IRQ(void)
1945 + *
1946 + * This function should be called during kernel startup to initialize
1947 + * the IRQ handling routines.
1948 + */
1949 +void __init init_IRQ(void)
1950 +{
1951 + int i;
1952 +
1953 +#ifdef CONFIG_M54455
1954 + for (i = 0; i < SYS_IRQS; i++)
1955 + irq_controller[i] = &m5445x_irq_controller;
1956 +#endif
1957 +}
1958 +
1959 +/*
1960 + * process_int(unsigned long vec, struct pt_regs *fp)
1961 + *
1962 + * Process an interrupt. Called from entry.S.
1963 + */
1964 +asmlinkage void process_int(unsigned long vec, struct pt_regs *fp)
1965 +{
1966 + struct pt_regs *old_regs;
1967 + struct irq_node *node;
1968 + old_regs = set_irq_regs(fp);
1969 + kstat_cpu(0).irqs[vec]++;
1970 +
1971 + node = irq_list[vec];
1972 + if (!node)
1973 + handle_badint(fp);
1974 + else {
1975 + do {
1976 + node->handler(vec, node->dev_id);
1977 + node = node->next;
1978 + } while (node);
1979 + }
1980 +
1981 + set_irq_regs(old_regs);
1982 +}
1983 +
1984 +/*
1985 + * show_interrupts( struct seq_file *p, void *v)
1986 + *
1987 + * Called to show all the current interrupt information.
1988 + */
1989 +int show_interrupts(struct seq_file *p, void *v)
1990 +{
1991 + struct irq_controller *contr;
1992 + struct irq_node *node;
1993 + int i = *(loff_t *) v;
1994 +
1995 + if ((i < NR_IRQS) && (irq_list[i])) {
1996 + contr = irq_controller[i];
1997 + node = irq_list[i];
1998 + seq_printf(p, "%-8s %3u: %10u %s", contr->name, i,
1999 + kstat_cpu(0).irqs[i], node->devname);
2000 + while ((node = node->next))
2001 + seq_printf(p, ", %s", node->devname);
2002 +
2003 + seq_printf(p, "\n");
2004 + }
2005 +
2006 + return 0;
2007 +}
2008 +
2009 +/*
2010 + * get_irq_node(void)
2011 + *
2012 + * Get an irq node from the pool.
2013 + */
2014 +struct irq_node *get_irq_node(void)
2015 +{
2016 + struct irq_node *p = pool;
2017 + int i;
2018 +
2019 + for (i = 0; i < POOL_SIZE; i++, p++) {
2020 + if (!p->handler) {
2021 + memset(p, 0, sizeof(struct irq_node));
2022 + return p;
2023 + }
2024 + }
2025 + printk(KERN_INFO "%s(%s:%d): No more irq nodes, I suggest you \
2026 + increase POOL_SIZE", __FUNCTION__, __FILE__, __LINE__);
2027 + return NULL;
2028 +}
2029 +
2030 +void init_irq_proc(void)
2031 +{
2032 + /* Insert /proc/irq driver here */
2033 +}
2034 +
2035 +int setup_irq(unsigned int irq, struct irq_node *node)
2036 +{
2037 + struct irq_controller *contr;
2038 + struct irq_node **prev;
2039 + unsigned long flags;
2040 +
2041 + if (irq >= NR_IRQS || !irq_controller[irq]) {
2042 + printk("%s: Incorrect IRQ %d from %s\n",
2043 + __FUNCTION__, irq, node->devname);
2044 + return -ENXIO;
2045 + }
2046 +
2047 + contr = irq_controller[irq];
2048 + spin_lock_irqsave(&contr->lock, flags);
2049 +
2050 + prev = irq_list + irq;
2051 + if (*prev) {
2052 + /* Can't share interrupts unless both agree to */
2053 + if (!((*prev)->flags & node->flags & IRQF_SHARED)) {
2054 + spin_unlock_irqrestore(&contr->lock, flags);
2055 + return -EBUSY;
2056 + }
2057 + while (*prev)
2058 + prev = &(*prev)->next;
2059 + }
2060 +
2061 + if (!irq_list[irq]) {
2062 + if (contr->startup)
2063 + contr->startup(irq);
2064 + else
2065 + contr->enable(irq);
2066 + }
2067 + node->next = NULL;
2068 + *prev = node;
2069 +
2070 + spin_unlock_irqrestore(&contr->lock, flags);
2071 +
2072 + return 0;
2073 +}
2074 +
2075 +int request_irq(unsigned int irq,
2076 + irq_handler_t handler,
2077 + unsigned long flags, const char *devname, void *dev_id)
2078 +{
2079 + struct irq_node *node = get_irq_node();
2080 + int res;
2081 +
2082 + if (!node)
2083 + return -ENOMEM;
2084 +
2085 + node->handler = handler;
2086 + node->flags = flags;
2087 + node->dev_id = dev_id;
2088 + node->devname = devname;
2089 +
2090 + res = setup_irq(irq, node);
2091 + if (res)
2092 + node->handler = NULL;
2093 +
2094 + return res;
2095 +}
2096 +EXPORT_SYMBOL(request_irq);
2097 +
2098 +void free_irq(unsigned int irq, void *dev_id)
2099 +{
2100 + struct irq_controller *contr;
2101 + struct irq_node **p, *node;
2102 + unsigned long flags;
2103 +
2104 + if (irq >= NR_IRQS || !irq_controller[irq]) {
2105 + printk(KERN_DEBUG "%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
2106 + return;
2107 + }
2108 +
2109 + contr = irq_controller[irq];
2110 + spin_lock_irqsave(&contr->lock, flags);
2111 +
2112 + p = irq_list + irq;
2113 + while ((node = *p)) {
2114 + if (node->dev_id == dev_id)
2115 + break;
2116 + p = &node->next;
2117 + }
2118 +
2119 + if (node) {
2120 + *p = node->next;
2121 + node->handler = NULL;
2122 + } else
2123 + printk(KERN_DEBUG "%s: Removing probably wrong IRQ %d\n",
2124 + __FUNCTION__, irq);
2125 +
2126 + if (!irq_list[irq]) {
2127 + if (contr->shutdown)
2128 + contr->shutdown(irq);
2129 + else
2130 + contr->disable(irq);
2131 + }
2132 +
2133 + spin_unlock_irqrestore(&contr->lock, flags);
2134 +}
2135 +EXPORT_SYMBOL(free_irq);
2136 +
2137 +void enable_irq(unsigned int irq)
2138 +{
2139 + struct irq_controller *contr;
2140 + unsigned long flags;
2141 +
2142 + if (irq >= NR_IRQS || !irq_controller[irq]) {
2143 + printk(KERN_DEBUG "%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
2144 + return;
2145 + }
2146 +
2147 + contr = irq_controller[irq];
2148 + spin_lock_irqsave(&contr->lock, flags);
2149 + if (irq_depth[irq]) {
2150 + if (!--irq_depth[irq]) {
2151 + if (contr->enable)
2152 + contr->enable(irq);
2153 + }
2154 + } else
2155 + WARN_ON(1);
2156 + spin_unlock_irqrestore(&contr->lock, flags);
2157 +}
2158 +EXPORT_SYMBOL(enable_irq);
2159 +
2160 +void disable_irq(unsigned int irq)
2161 +{
2162 + struct irq_controller *contr;
2163 + unsigned long flags;
2164 +
2165 + if (irq >= NR_IRQS || !irq_controller[irq]) {
2166 + printk(KERN_DEBUG "%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
2167 + return;
2168 + }
2169 +
2170 + contr = irq_controller[irq];
2171 + spin_lock_irqsave(&contr->lock, flags);
2172 + if (!irq_depth[irq]++) {
2173 + if (contr->disable)
2174 + contr->disable(irq);
2175 + }
2176 + spin_unlock_irqrestore(&contr->lock, flags);
2177 +}
2178 +EXPORT_SYMBOL(disable_irq);
2179 +
2180 +unsigned long probe_irq_on(void)
2181 +{
2182 + return 0;
2183 +}
2184 +EXPORT_SYMBOL(probe_irq_on);
2185 +
2186 +int probe_irq_off(unsigned long irqs)
2187 +{
2188 + return 0;
2189 +}
2190 +EXPORT_SYMBOL(probe_irq_off);
2191 +
2192 +asmlinkage void handle_badint(struct pt_regs *regs)
2193 +{
2194 + kstat_cpu(0).irqs[0]++;
2195 + num_spurious++;
2196 + printk(KERN_DEBUG "unexpected interrupt from %u\n", regs->vector);
2197 +}
2198 +EXPORT_SYMBOL(handle_badint);
2199 +
2200 +#ifdef CONFIG_M54455
2201 +/*
2202 + * M5445X Implementation
2203 + */
2204 +void m5445x_irq_enable(unsigned int irq)
2205 +{
2206 + /* enable the interrupt hardware */
2207 + if (irq < 64)
2208 + return;
2209 +
2210 + /* adjust past non-hardware ints */
2211 + irq -= 64;
2212 +
2213 + /* check for eport */
2214 + if ((irq > 0) && (irq < 8)) {
2215 + /* enable eport */
2216 + MCF_EPORT_EPPAR &= ~(3 << (irq*2)); /* level */
2217 + MCF_EPORT_EPDDR &= ~(1 << irq); /* input */
2218 + MCF_EPORT_EPIER |= 1 << irq; /* irq enabled */
2219 + }
2220 +
2221 + if (irq < 64) {
2222 + /* controller 0 */
2223 + MCF_INTC0_ICR(irq) = 0x02;
2224 + MCF_INTC0_CIMR = irq;
2225 + } else {
2226 + /* controller 1 */
2227 + irq -= 64;
2228 + MCF_INTC1_ICR(irq) = 0x02;
2229 + MCF_INTC1_CIMR = irq;
2230 + }
2231 +}
2232 +
2233 +void m5445x_irq_disable(unsigned int irq)
2234 +{
2235 + /* disable the interrupt hardware */
2236 + if (irq < 64)
2237 + return;
2238 +
2239 + /* adjust past non-hardware ints */
2240 + irq -= 64;
2241 +
2242 + /* check for eport */
2243 + if ((irq > 0) && (irq < 8)) {
2244 + /* disable eport */
2245 + MCF_EPORT_EPIER &= ~(1 << irq);
2246 + }
2247 +
2248 + if (irq < 64) {
2249 + /* controller 0 */
2250 + MCF_INTC0_ICR(irq) = 0x00;
2251 + MCF_INTC0_SIMR = irq;
2252 + } else {
2253 + /* controller 1 */
2254 + irq -= 64;
2255 + MCF_INTC1_ICR(irq) = 0x00;
2256 + MCF_INTC1_SIMR = irq;
2257 + }
2258 +}
2259 +#endif
2260 --- /dev/null
2261 +++ b/arch/m68k/coldfire/iomap.c
2262 @@ -0,0 +1,54 @@
2263 +/*
2264 + * arch/m68k/coldfire/iomap.c
2265 + *
2266 + * Generic coldfire iomap interface
2267 + *
2268 + * Based on the sh64 iomap.c by Paul Mundt.
2269 + *
2270 + * This file is subject to the terms and conditions of the GNU General Public
2271 + * License. See the file "COPYING" in the main directory of this archive
2272 + * for more details.
2273 + */
2274 +#include <linux/pci.h>
2275 +#include <asm/io.h>
2276 +
2277 +void __iomem *__attribute__ ((weak))
2278 +ioport_map(unsigned long port, unsigned int len)
2279 +{
2280 + return (void __iomem *)port;
2281 +}
2282 +EXPORT_SYMBOL(pci_iomap);
2283 +
2284 +void ioport_unmap(void __iomem *addr)
2285 +{
2286 + /* Nothing .. */
2287 +}
2288 +EXPORT_SYMBOL(pci_iounmap);
2289 +
2290 +void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max)
2291 +{
2292 + unsigned long start = pci_resource_start(dev, bar);
2293 + unsigned long len = pci_resource_len(dev, bar);
2294 + unsigned long flags = pci_resource_flags(dev, bar);
2295 +printk(KERN_INFO "PCI_IOMAP: BAR=%d START=0x%lx LEN=0x%lx FLAGS=0x%lx\n",
2296 + bar, start, len, flags);
2297 +
2298 + if (!len)
2299 + return NULL;
2300 + if (max && len > max)
2301 + len = max;
2302 + if (flags & IORESOURCE_IO)
2303 + return ioport_map(start, len);
2304 + if (flags & IORESOURCE_MEM)
2305 + return (void __iomem *)start;
2306 +
2307 + /* What? */
2308 + return NULL;
2309 +}
2310 +EXPORT_SYMBOL(ioport_map);
2311 +
2312 +void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
2313 +{
2314 + /* Nothing .. */
2315 +}
2316 +EXPORT_SYMBOL(ioport_unmap);
2317 --- /dev/null
2318 +++ b/arch/m68k/coldfire/mcf5445x-pci.c
2319 @@ -0,0 +1,427 @@
2320 +/*
2321 + * arch/m68k/coldfire/mcf5445x-pci.c
2322 + *
2323 + * Coldfire M5445x specific PCI implementation.
2324 + *
2325 + * Copyright (c) 2007 Freescale Semiconductor, Inc.
2326 + * Kurt Mahan <kmahan@freescale.com>
2327 + */
2328 +
2329 +#include <linux/delay.h>
2330 +#include <linux/pci.h>
2331 +
2332 +#include <asm/mcfsim.h>
2333 +#include <asm/pci.h>
2334 +#include <asm/irq.h>
2335 +
2336 +/*
2337 + * Layout MCF5445x to PCI memory mappings:
2338 + *
2339 + * WIN MCF5445x PCI TYPE
2340 + * --- -------- --- ----
2341 + * [0] 0xA0000000 -> 0xA7FFFFFF 0xA0000000 -> 0xA7FFFFFF MEM
2342 + * [1] 0xA8000000 -> 0xABFFFFFF 0xA8000000 -> 0xABFFFFFF MEM
2343 + * [2] 0xAC000000 -> 0xAFFFFFFF 0xAC000000 -> 0xAFFFFFFF IO
2344 + */
2345 +
2346 +#define MCF5445X_PCI_MEM_BASE 0xA0000000
2347 +#define MCF5445X_PCI_MEM_SIZE 0x0C000000
2348 +
2349 +#define MCF5445X_PCI_CONFIG_BASE 0xAC000000
2350 +#define MCF5445X_PCI_CONFIG_SIZE 0x04000000
2351 +
2352 +#define MCF5445X_PCI_IO_BASE 0xAC000000
2353 +#define MCF5445X_PCI_IO_SIZE 0x04000000
2354 +
2355 +/* PCI Bus memory resource block */
2356 +struct resource pci_iomem_resource = {
2357 + .name = "PCI memory space",
2358 + .start = MCF5445X_PCI_MEM_BASE,
2359 + .flags = IORESOURCE_MEM,
2360 + .end = MCF5445X_PCI_MEM_BASE + MCF5445X_PCI_MEM_SIZE - 1
2361 +};
2362 +
2363 +/* PCI Bus ioport resource block */
2364 +struct resource pci_ioport_resource = {
2365 + .name = "PCI I/O space",
2366 + .start = MCF5445X_PCI_IO_BASE,
2367 + .flags = IORESOURCE_IO,
2368 + .end = MCF5445X_PCI_IO_BASE + MCF5445X_PCI_IO_SIZE - 1
2369 +};
2370 +
2371 +/*
2372 + * The M54455EVB multiplexes all the PCI interrupts via
2373 + * the FPGA and routes them to a single interrupt. The
2374 + * PCI spec requires all PCI interrupt routines be smart
2375 + * enough to sort out their own interrupts.
2376 + * The interrupt source from the FPGA is configured
2377 + * to EPORT 3.
2378 + */
2379 +#define MCF5445X_PCI_IRQ 0x43
2380 +
2381 +#define PCI_SLOTS 4
2382 +
2383 +/*
2384 + * FPGA Info
2385 + */
2386 +#define FPGA_PCI_IRQ_ENABLE (u32 *)0x09000000
2387 +#define FPGA_PCI_IRQ_STATUS (u32 *)0x09000004
2388 +#define FPGA_PCI_IRQ_ROUTE (u32 *)0x0900000c
2389 +#define FPGA_SEVEN_LED (u32 *)0x09000014
2390 +
2391 +extern void set_fpga(u32 *addr, u32 val);
2392 +
2393 +#ifdef DEBUG
2394 +void mcf5445x_pci_dumpregs(void);
2395 +#endif
2396 +
2397 +/*
2398 + * static void mcf5445x_conf_device(struct pci_dev *dev)
2399 + *
2400 + * Machine dependent Configure the given device.
2401 + *
2402 + * Parameters:
2403 + *
2404 + * dev - the pci device.
2405 + */
2406 +void __init
2407 +mcf5445x_conf_device(struct pci_dev *dev)
2408 +{
2409 + set_fpga(FPGA_PCI_IRQ_ENABLE, 0x0f);
2410 +}
2411 +
2412 +/*
2413 + * int mcf5445x_pci_config_read(unsigned int seg, unsigned int bus,
2414 + * unsigned int devfn, int reg,
2415 + * u32 *value)
2416 + *
2417 + * Read from PCI configuration space.
2418 + *
2419 + */
2420 +int mcf5445x_pci_config_read(unsigned int seg, unsigned int bus,
2421 + unsigned int devfn, int reg, int len, u32 *value)
2422 +{
2423 + u32 addr = MCF_PCI_PCICAR_BUSNUM(bus) |
2424 + MCF_PCI_PCICAR_DEVNUM(PCI_SLOT(devfn)) |
2425 + MCF_PCI_PCICAR_FUNCNUM(PCI_FUNC(devfn)) |
2426 + MCF_PCI_PCICAR_DWORD(reg) |
2427 + MCF_PCI_PCICAR_E;
2428 +
2429 + if ((bus > 255) || (devfn > 255) || (reg > 255)) {
2430 + *value = -1;
2431 + return -EINVAL;
2432 + }
2433 +
2434 + /* setup for config mode */
2435 + MCF_PCI_PCICAR = addr;
2436 + __asm__ __volatile__("nop");
2437 +
2438 + switch (len) {
2439 + case 1:
2440 + *value = *(volatile u8 *)(MCF5445X_PCI_CONFIG_BASE+(reg&3));
2441 + break;
2442 + case 2:
2443 + *value = le16_to_cpu(*(volatile u16 *)
2444 + (MCF5445X_PCI_CONFIG_BASE + (reg&2)));
2445 + break;
2446 + case 4:
2447 + *value = le32_to_cpu(*(volatile u32 *)
2448 + (MCF5445X_PCI_CONFIG_BASE));
2449 + break;
2450 + }
2451 +
2452 + /* clear config mode */
2453 + MCF_PCI_PCICAR = ~MCF_PCI_PCICAR_E;
2454 + __asm__ __volatile__("nop");
2455 +
2456 + return 0;
2457 +}
2458 +
2459 +/*
2460 + * int mcf5445x_pci_config_write(unsigned int seg, unsigned int bus,
2461 + * unsigned int devfn, int reg,
2462 + * u32 *value)
2463 + *
2464 + * Write to PCI configuration space
2465 + */
2466 +int mcf5445x_pci_config_write(unsigned int seg, unsigned int bus,
2467 + unsigned int devfn, int reg, int len, u32 value)
2468 +{
2469 + u32 addr = MCF_PCI_PCICAR_BUSNUM(bus) |
2470 + MCF_PCI_PCICAR_DEVNUM(PCI_SLOT(devfn)) |
2471 + MCF_PCI_PCICAR_FUNCNUM(PCI_FUNC(devfn)) |
2472 + MCF_PCI_PCICAR_DWORD(reg) |
2473 + MCF_PCI_PCICAR_E;
2474 +
2475 + if ((bus > 255) || (devfn > 255) || (reg > 255))
2476 + return -EINVAL;
2477 +
2478 + /* setup for config mode */
2479 + MCF_PCI_PCICAR = addr;
2480 + __asm__ __volatile__("nop");
2481 +
2482 + switch (len) {
2483 + case 1:
2484 + *(volatile u8 *)(MCF5445X_PCI_CONFIG_BASE+(reg&3)) = (u8)value;
2485 + break;
2486 + case 2:
2487 + *(volatile u16 *)(MCF5445X_PCI_CONFIG_BASE+(reg&2)) =
2488 + cpu_to_le16((u16)value);
2489 + break;
2490 + case 4:
2491 + *(volatile u32 *)(MCF5445X_PCI_CONFIG_BASE) =
2492 + cpu_to_le32(value);
2493 + break;
2494 + }
2495 +
2496 + /* clear config mode */
2497 + MCF_PCI_PCICAR = ~MCF_PCI_PCICAR_E;
2498 + __asm__ __volatile__("nop");
2499 +
2500 + return 0;
2501 +}
2502 +
2503 +/* hardware operations */
2504 +static struct pci_raw_ops mcf5445x_pci_ops = {
2505 + .read = mcf5445x_pci_config_read,
2506 + .write = mcf5445x_pci_config_write,
2507 +};
2508 +
2509 +/*
2510 + * irqreturn_t mcf5445x_pci_interrupt( int irq, void *dev)
2511 + *
2512 + * PCI controller interrupt handler.
2513 + */
2514 +static irqreturn_t
2515 +mcf5445x_pci_interrupt(int irq, void *dev)
2516 +{
2517 + u32 status = MCF_PCI_PCIGSCR;
2518 +#ifdef DEBUG
2519 + printk(KERN_INFO "PCI: Controller irq status=0x%08x\n", status);
2520 +#endif
2521 + /* clear */
2522 + MCF_PCI_PCIGSCR = status;
2523 +
2524 + return IRQ_HANDLED;
2525 +}
2526 +
2527 +/*
2528 + * irqreturn_t mcf5445x_pci_arb_interrupt( int irq, void *dev)
2529 + *
2530 + * PCI Arbiter interrupt handler.
2531 + */
2532 +static irqreturn_t
2533 +mcf5445x_pci_arb_interrupt(int irq, void *dev)
2534 +{
2535 + u32 status = MCF_PCIARB_PASR;
2536 +#ifdef DEBUG
2537 + printk(KERN_INFO "PCI: Arbiter irq status=0x%08x\n", status);
2538 +#endif
2539 + /* clear */
2540 + MCF_PCIARB_PASR = status;
2541 + return IRQ_HANDLED;
2542 +}
2543 +
2544 +/*
2545 + * struct pci_bus_info *init_mcf5445x_pci(void)
2546 + *
2547 + * Machine specific initialisation:
2548 + *
2549 + * - Allocate and initialise a 'pci_bus_info' structure
2550 + * - Initialize hardware
2551 + *
2552 + * Result: pointer to 'pci_bus_info' structure.
2553 + */
2554 +int __init
2555 +init_mcf5445x_pci(void)
2556 +{
2557 + /*
2558 + * Initialize the PCI core
2559 + */
2560 +
2561 + /* arbitration controller */
2562 + MCF_PCIARB_PACR = MCF_PCIARB_PACR_INTMPRI |
2563 + MCF_PCIARB_PACR_EXTMPRI(0x0f) |
2564 + MCF_PCIARB_PACR_INTMINTEN |
2565 + MCF_PCIARB_PACR_EXTMINTEN(0x0f);
2566 +
2567 + /* pci pin assignment regs */
2568 + MCF_GPIO_PAR_PCI = MCF_GPIO_PAR_PCI_GNT0 |
2569 + MCF_GPIO_PAR_PCI_GNT1 |
2570 + MCF_GPIO_PAR_PCI_GNT2 |
2571 + MCF_GPIO_PAR_PCI_GNT3_GNT3 |
2572 + MCF_GPIO_PAR_PCI_REQ0 |
2573 + MCF_GPIO_PAR_PCI_REQ1 |
2574 + MCF_GPIO_PAR_PCI_REQ2 |
2575 + MCF_GPIO_PAR_PCI_REQ3_REQ3;
2576 +
2577 + /* target control reg */
2578 + MCF_PCI_PCITCR = MCF_PCI_PCITCR_P |
2579 + MCF_PCI_PCITCR_WCT(8);
2580 +
2581 + /* PCI MEM address */
2582 + MCF_PCI_PCIIW0BTAR = 0xA007A000;
2583 +
2584 + /* PCI MEM address */
2585 + MCF_PCI_PCIIW1BTAR = 0xA803A800;
2586 +
2587 + /* PCI IO address */
2588 + MCF_PCI_PCIIW2BTAR = 0xAC03AC00;
2589 +
2590 + /* window control */
2591 + MCF_PCI_PCIIWCR = MCF_PCI_PCIIWCR_WINCTRL0_ENABLE |
2592 + MCF_PCI_PCIIWCR_WINCTRL0_MEMREAD |
2593 + MCF_PCI_PCIIWCR_WINCTRL1_ENABLE |
2594 + MCF_PCI_PCIIWCR_WINCTRL1_MEMREAD |
2595 + MCF_PCI_PCIIWCR_WINCTRL2_ENABLE |
2596 + MCF_PCI_PCIIWCR_WINCTRL2_IO;
2597 +
2598 + /* initiator control reg */
2599 + MCF_PCI_PCIICR = 0x00ff;
2600 +
2601 + /* type 0 - command */
2602 + MCF_PCI_PCISCR = MCF_PCI_PCISCR_MW | /* mem write/inval */
2603 + MCF_PCI_PCISCR_B | /* bus master enable */
2604 + MCF_PCI_PCISCR_M; /* mem access enable */
2605 +
2606 + /* type 0 - config reg */
2607 + MCF_PCI_PCICR1 = MCF_PCI_PCICR1_CACHELINESIZE(8) |
2608 + MCF_PCI_PCICR1_LATTIMER(0xff);
2609 +
2610 + /* type 0 - config 2 reg */
2611 + MCF_PCI_PCICR2 = 0;
2612 +
2613 + /* target control reg */
2614 + MCF_PCI_PCITCR2 = MCF_PCI_PCITCR2_B0E |
2615 + MCF_PCI_PCITCR2_B4E;
2616 +
2617 + /* translate addresses from PCI[0] to CF[SDRAM] */
2618 + MCF_PCI_PCITBATR0 = MCF_RAMBAR1 | MCF_PCI_PCITBATR0_EN;
2619 + MCF_PCI_PCITBATR4 = MCF_RAMBAR1 | MCF_PCI_PCITBATR4_EN;
2620 +
2621 + /* setup controller interrupt handlers */
2622 + if (request_irq(55+128, mcf5445x_pci_interrupt, IRQF_SHARED,
2623 + "PCI Controller", NULL))
2624 + printk(KERN_ERR "PCI: Unable to register controller irq\n");
2625 +
2626 + if (request_irq (56+128, mcf5445x_pci_arb_interrupt, IRQF_SHARED, "PCI Arbiter", NULL))
2627 + printk(KERN_ERR "PCI: Unable to register arbiter irq\n");
2628 +
2629 + /* global control - clear reset bit */
2630 + MCF_PCI_PCIGSCR = MCF_PCI_PCIGSCR_SEE |
2631 + MCF_PCI_PCIGSCR_PEE;
2632 +
2633 + /* let everything settle */
2634 + udelay(1000);
2635 +
2636 + /* allocate bus ioport resource */
2637 + if (request_resource(&ioport_resource, &pci_ioport_resource) < 0)
2638 + printk(KERN_ERR "PCI: Unable to alloc ioport resource\n");
2639 +
2640 + /* allocate bus iomem resource */
2641 + if (request_resource(&iomem_resource, &pci_iomem_resource) < 0)
2642 + printk(KERN_ERR "PCI: Unable to alloc iomem resource\n");
2643 +
2644 + /* setup FPGA to route PCI to IRQ3(67), SW7 to IRQ7, SW6 to IRQ4 */
2645 + set_fpga(FPGA_PCI_IRQ_ENABLE, 0x00000000);
2646 + set_fpga(FPGA_PCI_IRQ_ROUTE, 0x00000039);
2647 + set_fpga(FPGA_SEVEN_LED, 0x000000FF);
2648 +
2649 + raw_pci_ops = &mcf5445x_pci_ops;
2650 +
2651 + return 0;
2652 +}
2653 +
2654 +/*
2655 + * DEBUGGING
2656 + */
2657 +
2658 +#ifdef DEBUG
2659 +struct regdump {
2660 + u32 addr;
2661 + char regname[16];
2662 +};
2663 +
2664 +struct regdump type0regs[] = {
2665 + { 0xfc0a8000, "PCIIDR" },
2666 + { 0xfc0a8004, "PCISCR" },
2667 + { 0xfc0a8008, "PCICCRIR" },
2668 + { 0xfc0a800c, "PCICR1" },
2669 + { 0xfc0a8010, "PCIBAR0" },
2670 + { 0xfc0a8014, "PCIBAR1" },
2671 + { 0xfc0a8018, "PCIBAR2" },
2672 + { 0xfc0a801c, "PCIBAR3" },
2673 + { 0xfc0a8020, "PCIBAR4" },
2674 + { 0xfc0a8024, "PCIBAR5" },
2675 + { 0xfc0a8028, "PCICCPR" },
2676 + { 0xfc0a802c, "PCISID" },
2677 + { 0xfc0a8030, "PCIERBAR" },
2678 + { 0xfc0a8034, "PCICPR" },
2679 + { 0xfc0a803c, "PCICR2" },
2680 + { 0, "" }
2681 +};
2682 +
2683 +struct regdump genregs[] = {
2684 + { 0xfc0a8060, "PCIGSCR" },
2685 + { 0xfc0a8064, "PCITBATR0" },
2686 + { 0xfc0a8068, "PCITBATR1" },
2687 + { 0xfc0a806c, "PCITCR1" },
2688 + { 0xfc0a8070, "PCIIW0BTAR" },
2689 + { 0xfc0a8074, "PCIIW1BTAR" },
2690 + { 0xfc0a8078, "PCIIW2BTAR" },
2691 + { 0xfc0a8080, "PCIIWCR" },
2692 + { 0xfc0a8084, "PCIICR" },
2693 + { 0xfc0a8088, "PCIISR" },
2694 + { 0xfc0a808c, "PCITCR2" },
2695 + { 0xfc0a8090, "PCITBATR0" },
2696 + { 0xfc0a8094, "PCITBATR1" },
2697 + { 0xfc0a8098, "PCITBATR2" },
2698 + { 0xfc0a809c, "PCITBATR3" },
2699 + { 0xfc0a80a0, "PCITBATR4" },
2700 + { 0xfc0a80a4, "PCITBATR5" },
2701 + { 0xfc0a80a8, "PCIINTR" },
2702 + { 0xfc0a80f8, "PCICAR" },
2703 + { 0, "" }
2704 +};
2705 +
2706 +struct regdump arbregs[] = {
2707 + { 0xfc0ac000, "PACR" },
2708 + { 0xfc0ac004, "PASR" }, /* documentation error */
2709 + { 0, "" }
2710 +};
2711 +
2712 +/*
2713 + * void mcf5445x_pci_dumpregs()
2714 + *
2715 + * Dump out all the PCI registers
2716 + */
2717 +void
2718 +mcf5445x_pci_dumpregs(void)
2719 +{
2720 + struct regdump *reg;
2721 +
2722 + printk(KERN_INFO "*** MCF5445x PCI TARGET 0 REGISTERS ***\n");
2723 +
2724 + reg = type0regs;
2725 + while (reg->addr) {
2726 + printk(KERN_INFO "0x%08x 0x%08x %s\n", reg->addr,
2727 + *((u32 *)reg->addr), reg->regname);
2728 + reg++;
2729 + }
2730 +
2731 + printk(KERN_INFO "\n*** MCF5445x PCI GENERAL REGISTERS ***\n");
2732 + reg = genregs;
2733 + while (reg->addr) {
2734 + printk(KERN_INFO "0x%08x 0x%08x %s\n", reg->addr,
2735 + *((u32 *)reg->addr), reg->regname);
2736 + reg++;
2737 + }
2738 + printk(KERN_INFO "\n*** MCF5445x PCI ARBITER REGISTERS ***\n");
2739 + reg = arbregs;
2740 + while (reg->addr) {
2741 + printk(KERN_INFO "0x%08x 0x%08x %s\n", reg->addr,
2742 + *((u32 *)reg->addr), reg->regname);
2743 + reg++;
2744 + }
2745 +}
2746 +#endif /* DEBUG */
2747 --- /dev/null
2748 +++ b/arch/m68k/coldfire/muldi3.S
2749 @@ -0,0 +1,64 @@
2750 +/*
2751 + * Coldfire muldi3 assembly verion
2752 + */
2753 +
2754 +#include <linux/linkage.h>
2755 +.globl __muldi3
2756 +
2757 +ENTRY(__muldi3)
2758 + linkw %fp,#0
2759 + lea %sp@(-32),%sp
2760 + moveml %d2-%d7/%a2-%a3,%sp@
2761 + moveal %fp@(8), %a2
2762 + moveal %fp@(12), %a3
2763 + moveal %fp@(16), %a0
2764 + moveal %fp@(20),%a1
2765 + movel %a3,%d2
2766 + andil #65535,%d2
2767 + movel %a3,%d3
2768 + clrw %d3
2769 + swap %d3
2770 + movel %a1,%d0
2771 + andil #65535,%d0
2772 + movel %a1,%d1
2773 + clrw %d1
2774 + swap %d1
2775 + movel %d2,%d7
2776 + mulsl %d0,%d7
2777 + movel %d2,%d4
2778 + mulsl %d1,%d4
2779 + movel %d3,%d2
2780 + mulsl %d0,%d2
2781 + mulsl %d1,%d3
2782 + movel %d7,%d0
2783 + clrw %d0
2784 + swap %d0
2785 + addl %d0,%d4
2786 + addl %d2,%d4
2787 + cmpl %d4,%d2
2788 + blss 1f
2789 + addil #65536,%d3
2790 +1:
2791 + movel %d4,%d0
2792 + clrw %d0
2793 + swap %d0
2794 + movel %d3,%d5
2795 + addl %d0,%d5
2796 + movew %d4,%d6
2797 + swap %d6
2798 + movew %d7,%d6
2799 + movel %d5,%d0
2800 + movel %d6,%d1
2801 + movel %a3,%d2
2802 + movel %a0,%d3
2803 + mulsl %d3,%d2
2804 + movel %a2,%d3
2805 + movel %a1,%d4
2806 + mulsl %d4,%d3
2807 + addl %d3,%d2
2808 + movel %d2,%d0
2809 + addl %d5,%d0
2810 + moveml %sp@, %d2-%d7/%a2-%a3
2811 + lea %sp@(32),%sp
2812 + unlk %fp
2813 + rts
2814 --- /dev/null
2815 +++ b/arch/m68k/coldfire/pci.c
2816 @@ -0,0 +1,245 @@
2817 +/*
2818 + * linux/arch/m68k/coldfire/pci.c
2819 + *
2820 + * PCI initialization for Coldfire architectures.
2821 + *
2822 + * Currently Supported:
2823 + * M5445x
2824 + *
2825 + * Copyright (c) 2007 Freescale Semiconductor, Inc.
2826 + * Kurt Mahan <kmahan@freescale.com>
2827 + */
2828 +
2829 +#include <linux/kernel.h>
2830 +#include <linux/init.h>
2831 +#include <linux/pci.h>
2832 +
2833 +#include <asm/mcfsim.h>
2834 +#include <asm/pci.h>
2835 +
2836 +/* pci ops for reading/writing config */
2837 +struct pci_raw_ops *raw_pci_ops;
2838 +
2839 +/* pci debug flag */
2840 +static int debug_pci;
2841 +
2842 +#ifdef CONFIG_M54455
2843 +extern int init_mcf5445x_pci(void);
2844 +extern void mcf5445x_conf_device(struct pci_dev *dev);
2845 +extern void mcf5445x_pci_dumpregs(void);
2846 +
2847 +extern struct resource pci_ioport_resource;
2848 +extern struct resource pci_iomem_resource;
2849 +#endif
2850 +
2851 +static int
2852 +pci_read(struct pci_bus *bus, unsigned int devfn, int where,
2853 + int size, u32 *value)
2854 +{
2855 + return raw_pci_ops->read(0, bus->number, devfn, where, size, value);
2856 +}
2857 +
2858 +static int
2859 +pci_write(struct pci_bus *bus, unsigned int devfn, int where,
2860 + int size, u32 value)
2861 +{
2862 + return raw_pci_ops->write(0, bus->number, devfn, where, size, value);
2863 +}
2864 +
2865 +struct pci_ops pci_root_ops = {
2866 + .read = pci_read,
2867 + .write = pci_write,
2868 +};
2869 +
2870 +/*
2871 + * pcibios_setup(char *)
2872 + *
2873 + * Initialize the pcibios based on cmd line params.
2874 + */
2875 +char * __init
2876 +pcibios_setup(char *str)
2877 +{
2878 + if (!strcmp(str, "debug")) {
2879 + debug_pci = 1;
2880 + return NULL;
2881 + }
2882 + return str;
2883 +}
2884 +
2885 +/*
2886 + * We need to avoid collisions with `mirrored' VGA ports
2887 + * and other strange ISA hardware, so we always want the
2888 + * addresses to be allocated in the 0x000-0x0ff region
2889 + * modulo 0x400.
2890 + *
2891 + * Why? Because some silly external IO cards only decode
2892 + * the low 10 bits of the IO address. The 0x00-0xff region
2893 + * is reserved for motherboard devices that decode all 16
2894 + * bits, so it's ok to allocate at, say, 0x2800-0x28ff,
2895 + * but we want to try to avoid allocating at 0x2900-0x2bff
2896 + * which might have be mirrored at 0x0100-0x03ff..
2897 + */
2898 +void
2899 +pcibios_align_resource(void *data, struct resource *res, resource_size_t size,
2900 + resource_size_t align)
2901 +{
2902 + struct pci_dev *dev = data;
2903 +
2904 + if (res->flags & IORESOURCE_IO) {
2905 + resource_size_t start = res->start;
2906 +
2907 + if (size > 0x100)
2908 + printk(KERN_ERR "PCI: I/O Region %s/%d too large"
2909 + " (%ld bytes)\n", pci_name(dev),
2910 + dev->resource - res, (long int)size);
2911 +
2912 + if (start & 0x300) {
2913 + start = (start + 0x3ff) & ~0x3ff;
2914 + res->start = start;
2915 + }
2916 + }
2917 +}
2918 +
2919 +/*
2920 + * Swizzle the device pin each time we cross a bridge
2921 + * and return the slot number.
2922 + */
2923 +static u8 __devinit
2924 +pcibios_swizzle(struct pci_dev *dev, u8 *pin)
2925 +{
2926 + return 0;
2927 +}
2928 +
2929 +/*
2930 + * Map a slot/pin to an IRQ.
2931 + */
2932 +static int
2933 +pcibios_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
2934 +{
2935 + return 0x43;
2936 +}
2937 +
2938 +/*
2939 + * pcibios_update_irq(struct pci_dev *dev, int irq)
2940 + *
2941 + * Update a PCI interrupt.
2942 + */
2943 +void __init
2944 +pcibios_update_irq(struct pci_dev *dev, int irq)
2945 +{
2946 + pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
2947 +}
2948 +
2949 +/*
2950 + * pcibios_enable_device(struct pci_dev *dev, int mask)
2951 + *
2952 + * Enable a device on the PCI bus.
2953 + */
2954 +int
2955 +pcibios_enable_device(struct pci_dev *dev, int mask)
2956 +{
2957 + u16 cmd, old_cmd;
2958 + int idx;
2959 + struct resource *r;
2960 +
2961 + pci_read_config_word(dev, PCI_COMMAND, &cmd);
2962 + old_cmd = cmd;
2963 + for (idx = 0; idx < 6; idx++) {
2964 + r = &dev->resource[idx];
2965 + if (!r->start && r->end) {
2966 + printk(KERN_ERR "PCI: Device %s not available because "
2967 + "of resource collisions\n", pci_name(dev));
2968 + return -EINVAL;
2969 + }
2970 + if (r->flags & IORESOURCE_IO)
2971 + cmd |= PCI_COMMAND_IO;
2972 + if (r->flags & IORESOURCE_MEM)
2973 + cmd |= PCI_COMMAND_MEMORY;
2974 + }
2975 + if (cmd != old_cmd) {
2976 + printk("PCI: Enabling device %s (%04x -> %04x)\n",
2977 + pci_name(dev), old_cmd, cmd);
2978 + pci_write_config_word(dev, PCI_COMMAND, cmd);
2979 +#ifdef CONFIG_M54455
2980 + mcf5445x_conf_device(dev);
2981 +#endif
2982 + }
2983 +
2984 + return 0;
2985 +}
2986 +
2987 +/*
2988 + * pcibios_fixup_bus(struct pci_bus *bus)
2989 + */
2990 +void __init
2991 +pcibios_fixup_bus(struct pci_bus *bus)
2992 +{
2993 + struct pci_dev *dev = bus->self;
2994 +
2995 + if (!dev) {
2996 + /* Root bus. */
2997 +#ifdef CONFIG_M54455
2998 + bus->resource[0] = &pci_ioport_resource;
2999 + bus->resource[1] = &pci_iomem_resource;
3000 +#endif
3001 + }
3002 +}
3003 +
3004 +/*
3005 + * pcibios_init(void)
3006 + *
3007 + * Allocate/initialize low level pci bus/devices.
3008 + */
3009 +static int __init
3010 +pcibios_init(void)
3011 +{
3012 + struct pci_bus *bus;
3013 +
3014 + if (!raw_pci_ops) {
3015 + printk(KERN_WARNING "PCIBIOS: FATAL: NO PCI Hardware found\n");
3016 + return 0;
3017 + }
3018 +
3019 + /* allocate and scan the (only) bus */
3020 + bus = pci_scan_bus_parented(NULL, 0, &pci_root_ops, NULL);
3021 +
3022 + /* setup everything */
3023 + if (bus) {
3024 + /* compute the bridge window sizes */
3025 + pci_bus_size_bridges(bus);
3026 +
3027 + /* (re)assign device resources */
3028 + pci_bus_assign_resources(bus);
3029 +
3030 + /* add the bus to the system */
3031 + pci_bus_add_devices(bus);
3032 +
3033 + /* fixup irqs */
3034 + pci_fixup_irqs(pcibios_swizzle, pcibios_map_irq);
3035 + }
3036 +
3037 + return 0;
3038 +}
3039 +
3040 +/*
3041 + * pci_init(void)
3042 + *
3043 + * Initialize the PCI Hardware.
3044 + */
3045 +static int __init
3046 +pci_init(void)
3047 +{
3048 +#if defined(CONFIG_M54455)
3049 + init_mcf5445x_pci();
3050 +#endif
3051 + if (!raw_pci_ops)
3052 + printk(KERN_ERR "PCI: FATAL: NO PCI Detected\n");
3053 +
3054 + return 0;
3055 +}
3056 +
3057 +/* low level hardware (first) */
3058 +arch_initcall(pci_init);
3059 +
3060 +/* basic bios init (second) */
3061 +subsys_initcall(pcibios_init);
3062 --- /dev/null
3063 +++ b/arch/m68k/coldfire/signal.c
3064 @@ -0,0 +1,868 @@
3065 +/*
3066 + * linux/arch/m68k/kernel/signal.c
3067 + *
3068 + * Copyright (C) 1991, 1992 Linus Torvalds
3069 + *
3070 + * This file is subject to the terms and conditions of the GNU General Public
3071 + * License. See the file COPYING in the main directory of this archive
3072 + * for more details.
3073 + */
3074 +
3075 +/*
3076 + * Derived from m68k/kernel/signal.c and the original authors are credited
3077 + * there.
3078 + *
3079 + * Coldfire support by:
3080 + * Matt Waddel Matt.Waddel@freescale.com
3081 + * Copyright Freescale Semiconductor, Inc 2007
3082 + */
3083 +
3084 +#include <linux/sched.h>
3085 +#include <linux/mm.h>
3086 +#include <linux/kernel.h>
3087 +#include <linux/signal.h>
3088 +#include <linux/syscalls.h>
3089 +#include <linux/errno.h>
3090 +#include <linux/wait.h>
3091 +#include <linux/ptrace.h>
3092 +#include <linux/unistd.h>
3093 +#include <linux/stddef.h>
3094 +#include <linux/highuid.h>
3095 +#include <linux/personality.h>
3096 +#include <linux/tty.h>
3097 +#include <linux/binfmts.h>
3098 +
3099 +#include <asm/setup.h>
3100 +#include <asm/cf_uaccess.h>
3101 +#include <asm/cf_pgtable.h>
3102 +#include <asm/traps.h>
3103 +#include <asm/ucontext.h>
3104 +
3105 +#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
3106 +
3107 +asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
3108 +
3109 +const int frame_extra_sizes[16] = {
3110 + [1] = -1,
3111 + [2] = sizeof(((struct frame *)0)->un.fmt2),
3112 + [3] = sizeof(((struct frame *)0)->un.fmt3),
3113 + [4] = 0,
3114 + [5] = -1,
3115 + [6] = -1,
3116 + [7] = sizeof(((struct frame *)0)->un.fmt7),
3117 + [8] = -1,
3118 + [9] = sizeof(((struct frame *)0)->un.fmt9),
3119 + [10] = sizeof(((struct frame *)0)->un.fmta),
3120 + [11] = sizeof(((struct frame *)0)->un.fmtb),
3121 + [12] = -1,
3122 + [13] = -1,
3123 + [14] = -1,
3124 + [15] = -1,
3125 +};
3126 +
3127 +/*
3128 + * Atomically swap in the new signal mask, and wait for a signal.
3129 + */
3130 +asmlinkage int do_sigsuspend(struct pt_regs *regs)
3131 +{
3132 + old_sigset_t mask = regs->d3;
3133 + sigset_t saveset;
3134 +
3135 + mask &= _BLOCKABLE;
3136 + spin_lock_irq(&current->sighand->siglock);
3137 + saveset = current->blocked;
3138 + siginitset(&current->blocked, mask);
3139 + recalc_sigpending();
3140 + spin_unlock_irq(&current->sighand->siglock);
3141 +
3142 + regs->d0 = -EINTR;
3143 + while (1) {
3144 + current->state = TASK_INTERRUPTIBLE;
3145 + schedule();
3146 + if (do_signal(&saveset, regs))
3147 + return -EINTR;
3148 + }
3149 +}
3150 +
3151 +asmlinkage int
3152 +do_rt_sigsuspend(struct pt_regs *regs)
3153 +{
3154 + sigset_t __user *unewset = (sigset_t __user *)regs->d1;
3155 + size_t sigsetsize = (size_t)regs->d2;
3156 + sigset_t saveset, newset;
3157 +
3158 + /* XXX: Don't preclude handling different sized sigset_t's. */
3159 + if (sigsetsize != sizeof(sigset_t))
3160 + return -EINVAL;
3161 +
3162 + if (copy_from_user(&newset, unewset, sizeof(newset)))
3163 + return -EFAULT;
3164 + sigdelsetmask(&newset, ~_BLOCKABLE);
3165 +
3166 + spin_lock_irq(&current->sighand->siglock);
3167 + saveset = current->blocked;
3168 + current->blocked = newset;
3169 + recalc_sigpending();
3170 + spin_unlock_irq(&current->sighand->siglock);
3171 +
3172 + regs->d0 = -EINTR;
3173 + while (1) {
3174 + current->state = TASK_INTERRUPTIBLE;
3175 + schedule();
3176 + if (do_signal(&saveset, regs))
3177 + return -EINTR;
3178 + }
3179 +}
3180 +
3181 +asmlinkage int
3182 +sys_sigaction(int sig, const struct old_sigaction __user *act,
3183 + struct old_sigaction __user *oact)
3184 +{
3185 + struct k_sigaction new_ka, old_ka;
3186 + int ret;
3187 +
3188 + if (act) {
3189 + old_sigset_t mask;
3190 + if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3191 + __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3192 + __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
3193 + return -EFAULT;
3194 + __get_user(new_ka.sa.sa_flags, &act->sa_flags);
3195 + __get_user(mask, &act->sa_mask);
3196 + siginitset(&new_ka.sa.sa_mask, mask);
3197 + }
3198 +
3199 + ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3200 +
3201 + if (!ret && oact) {
3202 + if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3203 + __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3204 + __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
3205 + return -EFAULT;
3206 + __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3207 + __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
3208 + }
3209 +
3210 + return ret;
3211 +}
3212 +
3213 +asmlinkage int
3214 +sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
3215 +{
3216 + return do_sigaltstack(uss, uoss, rdusp());
3217 +}
3218 +
3219 +
3220 +/*
3221 + * Do a signal return; undo the signal stack.
3222 + *
3223 + * Keep the return code on the stack quadword aligned!
3224 + * That makes the cache flush below easier.
3225 + */
3226 +
3227 +struct sigframe
3228 +{
3229 + char __user *pretcode;
3230 + int sig;
3231 + int code;
3232 + struct sigcontext __user *psc;
3233 + char retcode[16];
3234 + unsigned long extramask[_NSIG_WORDS-1];
3235 + struct sigcontext sc;
3236 +};
3237 +
3238 +struct rt_sigframe
3239 +{
3240 + char __user *pretcode;
3241 + int sig;
3242 + struct siginfo __user *pinfo;
3243 + void __user *puc;
3244 + char retcode[16];
3245 + struct siginfo info;
3246 + struct ucontext uc;
3247 +};
3248 +
3249 +#define FPCONTEXT_SIZE 216
3250 +#define uc_fpstate uc_filler[0]
3251 +#define uc_formatvec uc_filler[FPCONTEXT_SIZE/4]
3252 +#define uc_extra uc_filler[FPCONTEXT_SIZE/4+1]
3253 +
3254 +#ifdef CONFIG_FPU
3255 +static unsigned char fpu_version; /* version num of fpu, set by setup_frame */
3256 +
3257 +static inline int restore_fpu_state(struct sigcontext *sc)
3258 +{
3259 + int err = 1;
3260 +
3261 + if (FPU_IS_EMU) {
3262 + /* restore registers */
3263 + memcpy(current->thread.fpcntl, sc->sc_fpcntl, 12);
3264 + memcpy(current->thread.fp, sc->sc_fpregs, 24);
3265 + return 0;
3266 + }
3267 +
3268 + if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
3269 + /* Verify the frame format. */
3270 + if (!CPU_IS_060 && (sc->sc_fpstate[0] != fpu_version))
3271 + goto out;
3272 + if (CPU_IS_020_OR_030) {
3273 + if (m68k_fputype & FPU_68881 &&
3274 + !(sc->sc_fpstate[1] == 0x18 || sc->sc_fpstate[1] == 0xb4))
3275 + goto out;
3276 + if (m68k_fputype & FPU_68882 &&
3277 + !(sc->sc_fpstate[1] == 0x38 || sc->sc_fpstate[1] == 0xd4))
3278 + goto out;
3279 + } else if (CPU_IS_040) {
3280 + if (!(sc->sc_fpstate[1] == 0x00 ||
3281 + sc->sc_fpstate[1] == 0x28 ||
3282 + sc->sc_fpstate[1] == 0x60))
3283 + goto out;
3284 + } else if (CPU_IS_060) {
3285 + if (!(sc->sc_fpstate[3] == 0x00 ||
3286 + sc->sc_fpstate[3] == 0x60 ||
3287 + sc->sc_fpstate[3] == 0xe0))
3288 + goto out;
3289 + } else
3290 + goto out;
3291 +
3292 + }
3293 + err = 0;
3294 +
3295 +out:
3296 + return err;
3297 +}
3298 +
3299 +static inline int rt_restore_fpu_state(struct ucontext __user *uc)
3300 +{
3301 + unsigned char fpstate[FPCONTEXT_SIZE];
3302 + int context_size = CPU_IS_060 ? 8 : 0;
3303 + fpregset_t fpregs;
3304 + int err = 1;
3305 +
3306 + if (FPU_IS_EMU) {
3307 + /* restore fpu control register */
3308 + if (__copy_from_user(current->thread.fpcntl,
3309 + uc->uc_mcontext.fpregs.f_fpcntl, 12))
3310 + goto out;
3311 + /* restore all other fpu register */
3312 + if (__copy_from_user(current->thread.fp,
3313 + uc->uc_mcontext.fpregs.f_fpregs, 96))
3314 + goto out;
3315 + return 0;
3316 + }
3317 +
3318 + if (__get_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate))
3319 + goto out;
3320 + if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
3321 + if (!CPU_IS_060)
3322 + context_size = fpstate[1];
3323 + /* Verify the frame format. */
3324 + if (!CPU_IS_060 && (fpstate[0] != fpu_version))
3325 + goto out;
3326 + if (CPU_IS_020_OR_030) {
3327 + if (m68k_fputype & FPU_68881 &&
3328 + !(context_size == 0x18 || context_size == 0xb4))
3329 + goto out;
3330 + if (m68k_fputype & FPU_68882 &&
3331 + !(context_size == 0x38 || context_size == 0xd4))
3332 + goto out;
3333 + } else if (CPU_IS_040) {
3334 + if (!(context_size == 0x00 ||
3335 + context_size == 0x28 ||
3336 + context_size == 0x60))
3337 + goto out;
3338 + } else if (CPU_IS_060) {
3339 + if (!(fpstate[3] == 0x00 ||
3340 + fpstate[3] == 0x60 ||
3341 + fpstate[3] == 0xe0))
3342 + goto out;
3343 + } else
3344 + goto out;
3345 + if (__copy_from_user(&fpregs, &uc->uc_mcontext.fpregs,
3346 + sizeof(fpregs)))
3347 + goto out;
3348 + }
3349 + if (context_size &&
3350 + __copy_from_user(fpstate + 4, (long __user *)&uc->uc_fpstate + 1,
3351 + context_size))
3352 + goto out;
3353 + err = 0;
3354 +
3355 +out:
3356 + return err;
3357 +}
3358 +#endif
3359 +
3360 +static inline int
3361 +restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *usc,
3362 + void __user *fp, int *pd0)
3363 +{
3364 + int fsize, formatvec;
3365 + struct sigcontext context;
3366 + int err = 0;
3367 +
3368 + /* get previous context */
3369 + if (copy_from_user(&context, usc, sizeof(context)))
3370 + goto badframe;
3371 +
3372 + /* restore passed registers */
3373 + regs->d1 = context.sc_d1;
3374 + regs->a0 = context.sc_a0;
3375 + regs->a1 = context.sc_a1;
3376 + regs->sr = (regs->sr & 0xff00) | (context.sc_sr & 0xff);
3377 + regs->pc = context.sc_pc;
3378 + regs->orig_d0 = -1; /* disable syscall checks */
3379 + wrusp(context.sc_usp);
3380 + formatvec = context.sc_formatvec;
3381 + regs->format = formatvec >> 12;
3382 + regs->vector = formatvec & 0xfff;
3383 +
3384 +#ifdef CONFIG_FPU
3385 + err = restore_fpu_state(&context);
3386 +#endif
3387 +
3388 + fsize = frame_extra_sizes[regs->format];
3389 + if (fsize < 0) {
3390 + /*
3391 + * user process trying to return with weird frame format
3392 + */
3393 +#ifdef DEBUG
3394 + printk(KERN_DEBUG "user process returning with weird \
3395 + frame format\n");
3396 +#endif
3397 + goto badframe;
3398 + }
3399 +
3400 + /* OK. Make room on the supervisor stack for the extra junk,
3401 + * if necessary.
3402 + */
3403 +
3404 + {
3405 + struct switch_stack *sw = (struct switch_stack *)regs - 1;
3406 + regs->d0 = context.sc_d0;
3407 +#define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
3408 + __asm__ __volatile__
3409 + (" movel %0,%/sp\n\t"
3410 + " bra ret_from_signal\n"
3411 + "4:\n"
3412 + ".section __ex_table,\"a\"\n"
3413 + " .align 4\n"
3414 + " .long 2b,4b\n"
3415 + ".previous"
3416 + : /* no outputs, it doesn't ever return */
3417 + : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
3418 + "n" (frame_offset), "a" (fp)
3419 + : "a0");
3420 +#undef frame_offset
3421 + /*
3422 + * If we ever get here an exception occurred while
3423 + * building the above stack-frame.
3424 + */
3425 + goto badframe;
3426 + }
3427 +
3428 + *pd0 = context.sc_d0;
3429 + return err;
3430 +
3431 +badframe:
3432 + return 1;
3433 +}
3434 +
3435 +static inline int
3436 +rt_restore_ucontext(struct pt_regs *regs, struct switch_stack *sw,
3437 + struct ucontext __user *uc, int *pd0)
3438 +{
3439 + int fsize, temp;
3440 + greg_t __user *gregs = uc->uc_mcontext.gregs;
3441 + unsigned long usp;
3442 + int err;
3443 +
3444 + err = __get_user(temp, &uc->uc_mcontext.version);
3445 + if (temp != MCONTEXT_VERSION)
3446 + goto badframe;
3447 + /* restore passed registers */
3448 + err |= __get_user(regs->d0, &gregs[0]);
3449 + err |= __get_user(regs->d1, &gregs[1]);
3450 + err |= __get_user(regs->d2, &gregs[2]);
3451 + err |= __get_user(regs->d3, &gregs[3]);
3452 + err |= __get_user(regs->d4, &gregs[4]);
3453 + err |= __get_user(regs->d5, &gregs[5]);
3454 + err |= __get_user(sw->d6, &gregs[6]);
3455 + err |= __get_user(sw->d7, &gregs[7]);
3456 + err |= __get_user(regs->a0, &gregs[8]);
3457 + err |= __get_user(regs->a1, &gregs[9]);
3458 + err |= __get_user(regs->a2, &gregs[10]);
3459 + err |= __get_user(sw->a3, &gregs[11]);
3460 + err |= __get_user(sw->a4, &gregs[12]);
3461 + err |= __get_user(sw->a5, &gregs[13]);
3462 + err |= __get_user(sw->a6, &gregs[14]);
3463 + err |= __get_user(usp, &gregs[15]);
3464 + wrusp(usp);
3465 + err |= __get_user(regs->pc, &gregs[16]);
3466 + err |= __get_user(temp, &gregs[17]);
3467 + regs->sr = (regs->sr & 0xff00) | (temp & 0xff);
3468 + regs->orig_d0 = -1; /* disable syscall checks */
3469 + err |= __get_user(temp, &uc->uc_formatvec);
3470 + regs->format = temp >> 12;
3471 + regs->vector = temp & 0xfff;
3472 +
3473 +#ifdef CONFIG_FPU
3474 + err |= rt_restore_fpu_state(uc);
3475 +#endif
3476 +
3477 + if (do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
3478 + goto badframe;
3479 +
3480 + fsize = frame_extra_sizes[regs->format];
3481 + if (fsize < 0) {
3482 + /*
3483 + * user process trying to return with weird frame format
3484 + */
3485 +#ifdef DEBUG
3486 + printk(KERN_DEBUG "user process returning with weird \
3487 + frame format\n");
3488 +#endif
3489 + goto badframe;
3490 + }
3491 +
3492 + /* OK. Make room on the supervisor stack for the extra junk,
3493 + * if necessary.
3494 + */
3495 +
3496 + {
3497 +#define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
3498 + __asm__ __volatile__
3499 + (" movel %0,%/sp\n\t"
3500 + " bra ret_from_signal\n"
3501 + "4:\n"
3502 + ".section __ex_table,\"a\"\n"
3503 + " .align 4\n"
3504 + " .long 2b,4b\n"
3505 + ".previous"
3506 + : /* no outputs, it doesn't ever return */
3507 + : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
3508 + "n" (frame_offset), "a" (&uc->uc_extra)
3509 + : "a0");
3510 +#undef frame_offset
3511 + /*
3512 + * If we ever get here an exception occurred while
3513 + * building the above stack-frame.
3514 + */
3515 + goto badframe;
3516 + }
3517 +
3518 + *pd0 = regs->d0;
3519 + return err;
3520 +
3521 +badframe:
3522 + return 1;
3523 +}
3524 +
3525 +asmlinkage int do_sigreturn(unsigned long __unused)
3526 +{
3527 + struct switch_stack *sw = (struct switch_stack *) &__unused;
3528 + struct pt_regs *regs = (struct pt_regs *) (sw + 1);
3529 + unsigned long usp = rdusp();
3530 + struct sigframe __user *frame = (struct sigframe __user *)(usp - 4);
3531 + sigset_t set;
3532 + int d0;
3533 +
3534 + if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
3535 + goto badframe;
3536 + if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
3537 + (_NSIG_WORDS > 1 &&
3538 + __copy_from_user(&set.sig[1], &frame->extramask,
3539 + sizeof(frame->extramask))))
3540 + goto badframe;
3541 +
3542 + sigdelsetmask(&set, ~_BLOCKABLE);
3543 + spin_lock_irq(&current->sighand->siglock);
3544 + current->blocked = set;
3545 + recalc_sigpending();
3546 + spin_unlock_irq(&current->sighand->siglock);
3547 +
3548 + if (restore_sigcontext(regs, &frame->sc, frame + 1, &d0))
3549 + goto badframe;
3550 + return d0;
3551 +
3552 +badframe:
3553 + force_sig(SIGSEGV, current);
3554 + return 0;
3555 +}
3556 +
3557 +asmlinkage int do_rt_sigreturn(unsigned long __unused)
3558 +{
3559 + struct switch_stack *sw = (struct switch_stack *) &__unused;
3560 + struct pt_regs *regs = (struct pt_regs *) (sw + 1);
3561 + unsigned long usp = rdusp();
3562 + struct rt_sigframe __user *frame =
3563 + (struct rt_sigframe __user *)(usp - 4);
3564 + sigset_t set;
3565 + int d0;
3566 +
3567 + if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
3568 + goto badframe;
3569 + if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
3570 + goto badframe;
3571 +
3572 + sigdelsetmask(&set, ~_BLOCKABLE);
3573 + spin_lock_irq(&current->sighand->siglock);
3574 + current->blocked = set;
3575 + recalc_sigpending();
3576 + spin_unlock_irq(&current->sighand->siglock);
3577 +
3578 + if (rt_restore_ucontext(regs, sw, &frame->uc, &d0))
3579 + goto badframe;
3580 + return d0;
3581 +
3582 +badframe:
3583 + force_sig(SIGSEGV, current);
3584 + return 0;
3585 +}
3586 +
3587 +#ifdef CONFIG_FPU
3588 +/*
3589 + * Set up a signal frame.
3590 + */
3591 +
3592 +static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
3593 +{
3594 + if (FPU_IS_EMU) {
3595 + /* save registers */
3596 + memcpy(sc->sc_fpcntl, current->thread.fpcntl, 12);
3597 + memcpy(sc->sc_fpregs, current->thread.fp, 24);
3598 + return;
3599 + }
3600 +}
3601 +
3602 +static inline int rt_save_fpu_state(struct ucontext __user *uc,
3603 + struct pt_regs *regs)
3604 +{
3605 + int err = 0;
3606 +
3607 + if (FPU_IS_EMU) {
3608 + /* save fpu control register */
3609 + err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpcntl,
3610 + current->thread.fpcntl, 12);
3611 + /* save all other fpu register */
3612 + err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpregs,
3613 + current->thread.fp, 96);
3614 + return err;
3615 + }
3616 +
3617 + return err;
3618 +}
3619 +#endif
3620 +
3621 +static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
3622 + unsigned long mask)
3623 +{
3624 + sc->sc_mask = mask;
3625 + sc->sc_usp = rdusp();
3626 + sc->sc_d0 = regs->d0;
3627 + sc->sc_d1 = regs->d1;
3628 + sc->sc_a0 = regs->a0;
3629 + sc->sc_a1 = regs->a1;
3630 + sc->sc_sr = regs->sr;
3631 + sc->sc_pc = regs->pc;
3632 + sc->sc_formatvec = regs->format << 12 | regs->vector;
3633 +#ifdef CONFIG_FPU
3634 + save_fpu_state(sc, regs);
3635 +#endif
3636 +}
3637 +
3638 +static inline int rt_setup_ucontext(struct ucontext __user *uc,
3639 + struct pt_regs *regs)
3640 +{
3641 + struct switch_stack *sw = (struct switch_stack *)regs - 1;
3642 + greg_t __user *gregs = uc->uc_mcontext.gregs;
3643 + int err = 0;
3644 +
3645 + err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
3646 + err |= __put_user(regs->d0, &gregs[0]);
3647 + err |= __put_user(regs->d1, &gregs[1]);
3648 + err |= __put_user(regs->d2, &gregs[2]);
3649 + err |= __put_user(regs->d3, &gregs[3]);
3650 + err |= __put_user(regs->d4, &gregs[4]);
3651 + err |= __put_user(regs->d5, &gregs[5]);
3652 + err |= __put_user(sw->d6, &gregs[6]);
3653 + err |= __put_user(sw->d7, &gregs[7]);
3654 + err |= __put_user(regs->a0, &gregs[8]);
3655 + err |= __put_user(regs->a1, &gregs[9]);
3656 + err |= __put_user(regs->a2, &gregs[10]);
3657 + err |= __put_user(sw->a3, &gregs[11]);
3658 + err |= __put_user(sw->a4, &gregs[12]);
3659 + err |= __put_user(sw->a5, &gregs[13]);
3660 + err |= __put_user(sw->a6, &gregs[14]);
3661 + err |= __put_user(rdusp(), &gregs[15]);
3662 + err |= __put_user(regs->pc, &gregs[16]);
3663 + err |= __put_user(regs->sr, &gregs[17]);
3664 + err |= __put_user((regs->format << 12) | regs->vector,
3665 + &uc->uc_formatvec);
3666 +#ifdef CONFIG_FPU
3667 + err |= rt_save_fpu_state(uc, regs);
3668 +#endif
3669 + return err;
3670 +}
3671 +
3672 +extern void IcacheInvalidateCacheBlock(void *, unsigned long);
3673 +static inline void push_cache(unsigned long vaddr)
3674 +{
3675 + IcacheInvalidateCacheBlock((void *)vaddr, 8);
3676 +}
3677 +
3678 +static inline void __user *
3679 +get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
3680 +{
3681 + unsigned long usp;
3682 +
3683 + /* Default to using normal stack. */
3684 + usp = rdusp();
3685 +
3686 + /* This is the X/Open sanctioned signal stack switching. */
3687 + if (ka->sa.sa_flags & SA_ONSTACK) {
3688 + if (!sas_ss_flags(usp))
3689 + usp = current->sas_ss_sp + current->sas_ss_size;
3690 + }
3691 + return (void __user *)((usp - frame_size) & -8UL);
3692 +}
3693 +
3694 +static void setup_frame(int sig, struct k_sigaction *ka,
3695 + sigset_t *set, struct pt_regs *regs)
3696 +{
3697 + struct sigframe __user *frame;
3698 + int fsize = frame_extra_sizes[regs->format];
3699 + struct sigcontext context;
3700 + int err = 0;
3701 +
3702 + if (fsize < 0) {
3703 +#ifdef DEBUG
3704 + printk(KERN_DEBUG "setup_frame: Unknown frame format %#x\n",
3705 + regs->format);
3706 +#endif
3707 + goto give_sigsegv;
3708 + }
3709 +
3710 + frame = get_sigframe(ka, regs, sizeof(*frame));
3711 +
3712 + err |= __put_user((current_thread_info()->exec_domain
3713 + && current_thread_info()->exec_domain->signal_invmap
3714 + && sig < 32
3715 + ? current_thread_info()->exec_domain->signal_invmap[sig]
3716 + : sig),
3717 + &frame->sig);
3718 +
3719 + err |= __put_user(regs->vector, &frame->code);
3720 + err |= __put_user(&frame->sc, &frame->psc);
3721 +
3722 + if (_NSIG_WORDS > 1)
3723 + err |= copy_to_user(frame->extramask, &set->sig[1],
3724 + sizeof(frame->extramask));
3725 +
3726 + setup_sigcontext(&context, regs, set->sig[0]);
3727 + err |= copy_to_user(&frame->sc, &context, sizeof(context));
3728 +
3729 + /* Set up to return from userspace. */
3730 + err |= __put_user(frame->retcode, &frame->pretcode);
3731 + /* moveq #,d0; trap #0 */
3732 + err |= __put_user(0x70004e40 + (__NR_sigreturn << 16),
3733 + (long __user *)(frame->retcode));
3734 +
3735 + if (err)
3736 + goto give_sigsegv;
3737 +
3738 + push_cache((unsigned long) &frame->retcode);
3739 +
3740 + /* Set up registers for signal handler */
3741 + wrusp((unsigned long) frame);
3742 + regs->pc = (unsigned long) ka->sa.sa_handler;
3743 +
3744 +adjust_stack:
3745 + /* Prepare to skip over the extra stuff in the exception frame. */
3746 + if (regs->stkadj) {
3747 + struct pt_regs *tregs =
3748 + (struct pt_regs *)((ulong)regs + regs->stkadj);
3749 +#ifdef DEBUG
3750 + printk(KERN_DEBUG "Performing stackadjust=%04x\n",
3751 + regs->stkadj);
3752 +#endif
3753 + /* This must be copied with decreasing addresses to
3754 + handle overlaps. */
3755 + tregs->vector = 0;
3756 + tregs->format = 0;
3757 + tregs->pc = regs->pc;
3758 + tregs->sr = regs->sr;
3759 + }
3760 + return;
3761 +
3762 +give_sigsegv:
3763 + force_sigsegv(sig, current);
3764 + goto adjust_stack;
3765 +}
3766 +
3767 +static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
3768 + sigset_t *set, struct pt_regs *regs)
3769 +{
3770 + struct rt_sigframe __user *frame;
3771 + int fsize = frame_extra_sizes[regs->format];
3772 + int err = 0;
3773 +
3774 + if (fsize < 0) {
3775 +#ifdef DEBUG
3776 + printk(KERN_DEBUG "setup_frame: Unknown frame format %#x\n",
3777 + regs->format);
3778 +#endif
3779 + goto give_sigsegv;
3780 + }
3781 +
3782 + frame = get_sigframe(ka, regs, sizeof(*frame));
3783 +
3784 + if (fsize) {
3785 + err |= copy_to_user(&frame->uc.uc_extra, regs + 1, fsize);
3786 + regs->stkadj = fsize;
3787 + }
3788 +
3789 + err |= __put_user((current_thread_info()->exec_domain
3790 + && current_thread_info()->exec_domain->signal_invmap
3791 + && sig < 32
3792 + ? current_thread_info()->exec_domain->signal_invmap[sig]
3793 + : sig),
3794 + &frame->sig);
3795 + err |= __put_user(&frame->info, &frame->pinfo);
3796 + err |= __put_user(&frame->uc, &frame->puc);
3797 + err |= copy_siginfo_to_user(&frame->info, info);
3798 +
3799 + /* Create the ucontext. */
3800 + err |= __put_user(0, &frame->uc.uc_flags);
3801 + err |= __put_user(NULL, &frame->uc.uc_link);
3802 + err |= __put_user((void __user *)current->sas_ss_sp,
3803 + &frame->uc.uc_stack.ss_sp);
3804 + err |= __put_user(sas_ss_flags(rdusp()),
3805 + &frame->uc.uc_stack.ss_flags);
3806 + err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
3807 + err |= rt_setup_ucontext(&frame->uc, regs);
3808 + err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
3809 +
3810 + /* Set up to return from userspace. */
3811 + err |= __put_user(frame->retcode, &frame->pretcode);
3812 +
3813 + /* moveq #,d0; andi.l #,D0; trap #0 */
3814 + err |= __put_user(0x70AD0280, (long *)(frame->retcode + 0));
3815 + err |= __put_user(0x000000ff, (long *)(frame->retcode + 4));
3816 + err |= __put_user(0x4e400000, (long *)(frame->retcode + 8));
3817 +
3818 + if (err)
3819 + goto give_sigsegv;
3820 +
3821 + push_cache((unsigned long) &frame->retcode);
3822 +
3823 + /* Set up registers for signal handler */
3824 + wrusp((unsigned long) frame);
3825 + regs->pc = (unsigned long) ka->sa.sa_handler;
3826 +
3827 +adjust_stack:
3828 + /* Prepare to skip over the extra stuff in the exception frame. */
3829 + if (regs->stkadj) {
3830 + struct pt_regs *tregs =
3831 + (struct pt_regs *)((ulong)regs + regs->stkadj);
3832 +#ifdef DEBUG
3833 + printk(KERN_DEBUG "Performing stackadjust=%04x\n",
3834 + regs->stkadj);
3835 +#endif
3836 + /* This must be copied with decreasing addresses to
3837 + handle overlaps. */
3838 + tregs->vector = 0;
3839 + tregs->format = 0;
3840 + tregs->pc = regs->pc;
3841 + tregs->sr = regs->sr;
3842 + }
3843 + return;
3844 +
3845 +give_sigsegv:
3846 + force_sigsegv(sig, current);
3847 + goto adjust_stack;
3848 +}
3849 +
3850 +static inline void
3851 +handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
3852 +{
3853 + switch (regs->d0) {
3854 + case -ERESTARTNOHAND:
3855 + if (!has_handler)
3856 + goto do_restart;
3857 + regs->d0 = -EINTR;
3858 + break;
3859 +
3860 + case -ERESTARTSYS:
3861 + if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
3862 + regs->d0 = -EINTR;
3863 + break;
3864 + }
3865 + /* fallthrough */
3866 + case -ERESTARTNOINTR:
3867 +do_restart:
3868 + regs->d0 = regs->orig_d0;
3869 + regs->pc -= 2;
3870 + break;
3871 + }
3872 +}
3873 +
3874 +/*
3875 + * OK, we're invoking a handler
3876 + */
3877 +static void
3878 +handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
3879 + sigset_t *oldset, struct pt_regs *regs)
3880 +{
3881 + /* are we from a system call? */
3882 + if (regs->orig_d0 >= 0)
3883 + /* If so, check system call restarting.. */
3884 + handle_restart(regs, ka, 1);
3885 +
3886 + /* set up the stack frame */
3887 + if (ka->sa.sa_flags & SA_SIGINFO)
3888 + setup_rt_frame(sig, ka, info, oldset, regs);
3889 + else
3890 + setup_frame(sig, ka, oldset, regs);
3891 +
3892 + if (ka->sa.sa_flags & SA_ONESHOT)
3893 + ka->sa.sa_handler = SIG_DFL;
3894 +
3895 + spin_lock_irq(&current->sighand->siglock);
3896 + sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
3897 + if (!(ka->sa.sa_flags & SA_NODEFER))
3898 + sigaddset(&current->blocked, sig);
3899 + recalc_sigpending();
3900 + spin_unlock_irq(&current->sighand->siglock);
3901 +}
3902 +
3903 +/*
3904 + * Note that 'init' is a special process: it doesn't get signals it doesn't
3905 + * want to handle. Thus you cannot kill init even with a SIGKILL even by
3906 + * mistake.
3907 + */
3908 +asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
3909 +{
3910 + siginfo_t info;
3911 + struct k_sigaction ka;
3912 + int signr;
3913 +
3914 + current->thread.esp0 = (unsigned long) regs;
3915 +
3916 + if (!oldset)
3917 + oldset = &current->blocked;
3918 +
3919 + signr = get_signal_to_deliver(&info, &ka, regs, NULL);
3920 + if (signr > 0) {
3921 + /* Whee! Actually deliver the signal. */
3922 + handle_signal(signr, &ka, &info, oldset, regs);
3923 + return 1;
3924 + }
3925 +
3926 + /* Did we come from a system call? */
3927 + if (regs->orig_d0 >= 0)
3928 + /* Restart the system call - no handlers present */
3929 + handle_restart(regs, NULL, 0);
3930 +
3931 + return 0;
3932 +}
3933 --- /dev/null
3934 +++ b/arch/m68k/coldfire/traps.c
3935 @@ -0,0 +1,454 @@
3936 +/*
3937 + * linux/arch/m68knommu/kernel/traps.c
3938 + *
3939 + * Copyright (C) 1993, 1994 by Hamish Macdonald
3940 + *
3941 + * 68040 fixes by Michael Rausch
3942 + * 68040 fixes by Martin Apel
3943 + * 68060 fixes by Roman Hodek
3944 + * 68060 fixes by Jesper Skov
3945 + *
3946 + * This file is subject to the terms and conditions of the GNU General Public
3947 + * License. See the file COPYING in the main directory of this archive
3948 + * for more details.
3949 + */
3950 +
3951 +/*
3952 + * Sets up all exception vectors
3953 + */
3954 +#include <linux/sched.h>
3955 +#include <linux/signal.h>
3956 +#include <linux/kernel.h>
3957 +#include <linux/mm.h>
3958 +#include <linux/module.h>
3959 +#include <linux/types.h>
3960 +#include <linux/a.out.h>
3961 +#include <linux/user.h>
3962 +#include <linux/string.h>
3963 +#include <linux/linkage.h>
3964 +#include <linux/init.h>
3965 +#include <linux/ptrace.h>
3966 +#include <linux/kallsyms.h>
3967 +
3968 +#include <asm/setup.h>
3969 +#include <asm/fpu.h>
3970 +#include <asm/system.h>
3971 +#include <asm/uaccess.h>
3972 +#include <asm/traps.h>
3973 +#include <asm/pgtable.h>
3974 +#include <asm/machdep.h>
3975 +#include <asm/siginfo.h>
3976 +
3977 +static char const * const vec_names[] = {
3978 + "RESET SP", "RESET PC", "BUS ERROR", "ADDRESS ERROR",
3979 + "ILLEGAL INSTRUCTION", "ZERO DIVIDE", "CHK", "TRAPcc",
3980 + "PRIVILEGE VIOLATION", "TRACE", "LINE 1010", "LINE 1111",
3981 + "UNASSIGNED RESERVED 12", "COPROCESSOR PROTOCOL VIOLATION",
3982 + "FORMAT ERROR", "UNINITIALIZED INTERRUPT",
3983 + "UNASSIGNED RESERVED 16", "UNASSIGNED RESERVED 17",
3984 + "UNASSIGNED RESERVED 18", "UNASSIGNED RESERVED 19",
3985 + "UNASSIGNED RESERVED 20", "UNASSIGNED RESERVED 21",
3986 + "UNASSIGNED RESERVED 22", "UNASSIGNED RESERVED 23",
3987 + "SPURIOUS INTERRUPT", "LEVEL 1 INT", "LEVEL 2 INT", "LEVEL 3 INT",
3988 + "LEVEL 4 INT", "LEVEL 5 INT", "LEVEL 6 INT", "LEVEL 7 INT",
3989 + "SYSCALL", "TRAP #1", "TRAP #2", "TRAP #3",
3990 + "TRAP #4", "TRAP #5", "TRAP #6", "TRAP #7",
3991 + "TRAP #8", "TRAP #9", "TRAP #10", "TRAP #11",
3992 + "TRAP #12", "TRAP #13", "TRAP #14", "TRAP #15",
3993 + "FPCP BSUN", "FPCP INEXACT", "FPCP DIV BY 0", "FPCP UNDERFLOW",
3994 + "FPCP OPERAND ERROR", "FPCP OVERFLOW", "FPCP SNAN",
3995 + "FPCP UNSUPPORTED OPERATION",
3996 + "MMU CONFIGURATION ERROR"
3997 +};
3998 +
3999 +asmlinkage int do_page_fault(struct pt_regs *regs, unsigned long address,
4000 + unsigned long error_code);
4001 +asmlinkage void trap_c(struct frame *fp);
4002 +extern void __init coldfire_trap_init(void);
4003 +
4004 +void __init trap_init(void)
4005 +{
4006 + coldfire_trap_init();
4007 +}
4008 +
4009 +/* The following table converts the FS encoding of a ColdFire
4010 + exception stack frame into the error_code value needed by
4011 + do_fault. */
4012 +
4013 +static const unsigned char fs_err_code[] = {
4014 + 0, /* 0000 */
4015 + 0, /* 0001 */
4016 + 0, /* 0010 */
4017 + 0, /* 0011 */
4018 + 1, /* 0100 */
4019 + 0, /* 0101 */
4020 + 0, /* 0110 */
4021 + 0, /* 0111 */
4022 + 2, /* 1000 */
4023 + 3, /* 1001 */
4024 + 2, /* 1010 */
4025 + 0, /* 1011 */
4026 + 1, /* 1100 */
4027 + 1, /* 1101 */
4028 + 0, /* 1110 */
4029 + 0 /* 1111 */
4030 +};
4031 +
4032 +#ifdef DEBUG
4033 +static const char *fs_err_msg[16] = {
4034 + "Normal",
4035 + "Reserved",
4036 + "Interrupt during debug service routine",
4037 + "Reserved",
4038 + "X Protection",
4039 + "TLB X miss (opword)",
4040 + "TLB X miss (ext. word)",
4041 + "IFP in emulator mode",
4042 + "W Protection",
4043 + "Write error",
4044 + "TLB W miss",
4045 + "Reserved",
4046 + "R Protection",
4047 + "R/RMW Protection",
4048 + "TLB R miss",
4049 + "OEP in emulator mode",
4050 +};
4051 +#endif
4052 +
4053 +static inline void access_errorCF(struct frame *fp)
4054 +{
4055 + unsigned long int mmusr, complainingAddress;
4056 + unsigned int err_code, fs;
4057 + int need_page_fault;
4058 +
4059 + mmusr = fp->ptregs.mmusr;
4060 + complainingAddress = fp->ptregs.mmuar;
4061 +#ifdef DEBUG
4062 + printk(KERN_DEBUG "pc %#lx, mmusr %#lx, complainingAddress %#lx\n", \
4063 + fp->ptregs.pc, mmusr, complainingAddress);
4064 +#endif
4065 +
4066 + /*
4067 + * error_code:
4068 + * bit 0 == 0 means no page found, 1 means protection fault
4069 + * bit 1 == 0 means read, 1 means write
4070 + */
4071 +
4072 + fs = (fp->ptregs.fs2 << 2) | fp->ptregs.fs1;
4073 + switch (fs) {
4074 + case 5: /* 0101 TLB opword X miss */
4075 + need_page_fault = cf_tlb_miss(&fp->ptregs, 0, 0, 0);
4076 + complainingAddress = fp->ptregs.pc;
4077 + break;
4078 + case 6: /* 0110 TLB extension word X miss */
4079 + need_page_fault = cf_tlb_miss(&fp->ptregs, 0, 0, 1);
4080 + complainingAddress = fp->ptregs.pc + sizeof(long);
4081 + break;
4082 + case 10: /* 1010 TLB W miss */
4083 + need_page_fault = cf_tlb_miss(&fp->ptregs, 1, 1, 0);
4084 + break;
4085 + case 14: /* 1110 TLB R miss */
4086 + need_page_fault = cf_tlb_miss(&fp->ptregs, 0, 1, 0);
4087 + break;
4088 + default:
4089 + /* 0000 Normal */
4090 + /* 0001 Reserved */
4091 + /* 0010 Interrupt during debug service routine */
4092 + /* 0011 Reserved */
4093 + /* 0100 X Protection */
4094 + /* 0111 IFP in emulator mode */
4095 + /* 1000 W Protection*/
4096 + /* 1001 Write error*/
4097 + /* 1011 Reserved*/
4098 + /* 1100 R Protection*/
4099 + /* 1101 R Protection*/
4100 + /* 1111 OEP in emulator mode*/
4101 + need_page_fault = 1;
4102 + break;
4103 + }
4104 +
4105 + if (need_page_fault) {
4106 + err_code = fs_err_code[fs];
4107 + if ((fs == 13) && (mmusr & MMUSR_WF)) /* rd-mod-wr access */
4108 + err_code |= 2; /* bit1 - write, bit0 - protection */
4109 + do_page_fault(&fp->ptregs, complainingAddress, err_code);
4110 + }
4111 +}
4112 +
4113 +void die_if_kernel(char *str, struct pt_regs *fp, int nr)
4114 +{
4115 + if (!(fp->sr & PS_S))
4116 + return;
4117 +
4118 + console_verbose();
4119 + printk(KERN_EMERG "%s: %08x\n", str, nr);
4120 + printk(KERN_EMERG "PC: [<%08lx>]", fp->pc);
4121 + print_symbol(" %s", fp->pc);
4122 + printk(KERN_EMERG "\nSR: %04x SP: %p a2: %08lx\n",
4123 + fp->sr, fp, fp->a2);
4124 + printk(KERN_EMERG "d0: %08lx d1: %08lx d2: %08lx d3: %08lx\n",
4125 + fp->d0, fp->d1, fp->d2, fp->d3);
4126 + printk(KERN_EMERG "d4: %08lx d5: %08lx a0: %08lx a1: %08lx\n",
4127 + fp->d4, fp->d5, fp->a0, fp->a1);
4128 +
4129 + printk(KERN_EMERG "Process %s (pid: %d, stackpage=%08lx)\n",
4130 + current->comm, current->pid, PAGE_SIZE+(unsigned long)current);
4131 + show_stack(NULL, (unsigned long *)fp);
4132 + do_exit(SIGSEGV);
4133 +}
4134 +
4135 +asmlinkage void buserr_c(struct frame *fp)
4136 +{
4137 + unsigned int fs;
4138 +
4139 + /* Only set esp0 if coming from user mode */
4140 + if (user_mode(&fp->ptregs))
4141 + current->thread.esp0 = (unsigned long) fp;
4142 +
4143 + fs = (fp->ptregs.fs2 << 2) | fp->ptregs.fs1;
4144 +#if defined(DEBUG)
4145 + printk(KERN_DEBUG "*** Bus Error *** (%x)%s\n", fs,
4146 + fs_err_msg[fs & 0xf]);
4147 +#endif
4148 + switch (fs) {
4149 + case 0x5:
4150 + case 0x6:
4151 + case 0x7:
4152 + case 0x9:
4153 + case 0xa:
4154 + case 0xd:
4155 + case 0xe:
4156 + case 0xf:
4157 + access_errorCF(fp);
4158 + break;
4159 + default:
4160 + die_if_kernel("bad frame format", &fp->ptregs, 0);
4161 +#if defined(DEBUG)
4162 + printk(KERN_DEBUG "Unknown SIGSEGV - 4\n");
4163 +#endif
4164 + force_sig(SIGSEGV, current);
4165 + }
4166 +}
4167 +
4168 +
4169 +int kstack_depth_to_print = 48;
4170 +
4171 +void show_stack(struct task_struct *task, unsigned long *stack)
4172 +{
4173 + unsigned long *endstack, addr, symaddr;
4174 + extern char _start, _etext;
4175 + int i;
4176 +
4177 + if (!stack) {
4178 + if (task)
4179 + stack = (unsigned long *)task->thread.ksp;
4180 + else
4181 + stack = (unsigned long *)&stack;
4182 + }
4183 +
4184 + addr = (unsigned long) stack;
4185 + endstack = (unsigned long *) PAGE_ALIGN(addr);
4186 +
4187 + printk(KERN_EMERG "Stack from %08lx:", (unsigned long)stack);
4188 + for (i = 0; i < kstack_depth_to_print; i++) {
4189 + if (stack + 1 > endstack)
4190 + break;
4191 + if (i % 8 == 0)
4192 + printk("\n" KERN_EMERG " ");
4193 + symaddr = *stack;
4194 + printk(KERN_EMERG " %08lx", *stack++);
4195 + if ((symaddr >= 0xc0000000) && (symaddr < 0xc1000000))
4196 + print_symbol("(%s)", symaddr);
4197 + }
4198 + printk("\n");
4199 +
4200 + printk(KERN_EMERG "Call Trace:");
4201 + i = 0;
4202 + while (stack + 1 <= endstack) {
4203 + addr = *stack++;
4204 + /*
4205 + * If the address is either in the text segment of the
4206 + * kernel, or in the region which contains vmalloc'ed
4207 + * memory, it *may* be the address of a calling
4208 + * routine; if so, print it so that someone tracing
4209 + * down the cause of the crash will be able to figure
4210 + * out the call path that was taken.
4211 + */
4212 + if (((addr >= (unsigned long) &_start) &&
4213 + (addr <= (unsigned long) &_etext))) {
4214 + if (i % 4 == 0)
4215 + printk("\n" KERN_EMERG " ");
4216 + printk(KERN_EMERG " [<%08lx>]", addr);
4217 + i++;
4218 + }
4219 + }
4220 + printk("\n");
4221 +}
4222 +
4223 +void bad_super_trap(struct frame *fp)
4224 +{
4225 + console_verbose();
4226 + if (fp->ptregs.vector < 4*sizeof(vec_names)/sizeof(vec_names[0]))
4227 + printk(KERN_WARNING "*** %s *** FORMAT=%X\n",
4228 + vec_names[(fp->ptregs.vector) >> 2],
4229 + fp->ptregs.format);
4230 + else
4231 + printk(KERN_WARNING "*** Exception %d *** FORMAT=%X\n",
4232 + (fp->ptregs.vector) >> 2,
4233 + fp->ptregs.format);
4234 + printk(KERN_WARNING "Current process id is %d\n", current->pid);
4235 + die_if_kernel("BAD KERNEL TRAP", &fp->ptregs, 0);
4236 +}
4237 +
4238 +asmlinkage void trap_c(struct frame *fp)
4239 +{
4240 + int sig;
4241 + siginfo_t info;
4242 +
4243 + if (fp->ptregs.sr & PS_S) {
4244 + if ((fp->ptregs.vector >> 2) == VEC_TRACE) {
4245 + /* traced a trapping instruction */
4246 + current->ptrace |= PT_DTRACE;
4247 + } else
4248 + bad_super_trap(fp);
4249 + return;
4250 + }
4251 +
4252 + /* send the appropriate signal to the user program */
4253 + switch ((fp->ptregs.vector) >> 2) {
4254 + case VEC_ADDRERR:
4255 + info.si_code = BUS_ADRALN;
4256 + sig = SIGBUS;
4257 + break;
4258 + case VEC_ILLEGAL:
4259 + case VEC_LINE10:
4260 + case VEC_LINE11:
4261 + info.si_code = ILL_ILLOPC;
4262 + sig = SIGILL;
4263 + break;
4264 + case VEC_PRIV:
4265 + info.si_code = ILL_PRVOPC;
4266 + sig = SIGILL;
4267 + break;
4268 + case VEC_COPROC:
4269 + info.si_code = ILL_COPROC;
4270 + sig = SIGILL;
4271 + break;
4272 + case VEC_TRAP1: /* gdbserver breakpoint */
4273 + fp->ptregs.pc -= 2;
4274 + info.si_code = TRAP_TRACE;
4275 + sig = SIGTRAP;
4276 + break;
4277 + case VEC_TRAP2:
4278 + case VEC_TRAP3:
4279 + case VEC_TRAP4:
4280 + case VEC_TRAP5:
4281 + case VEC_TRAP6:
4282 + case VEC_TRAP7:
4283 + case VEC_TRAP8:
4284 + case VEC_TRAP9:
4285 + case VEC_TRAP10:
4286 + case VEC_TRAP11:
4287 + case VEC_TRAP12:
4288 + case VEC_TRAP13:
4289 + case VEC_TRAP14:
4290 + info.si_code = ILL_ILLTRP;
4291 + sig = SIGILL;
4292 + break;
4293 + case VEC_FPBRUC:
4294 + case VEC_FPOE:
4295 + case VEC_FPNAN:
4296 + info.si_code = FPE_FLTINV;
4297 + sig = SIGFPE;
4298 + break;
4299 + case VEC_FPIR:
4300 + info.si_code = FPE_FLTRES;
4301 + sig = SIGFPE;
4302 + break;
4303 + case VEC_FPDIVZ:
4304 + info.si_code = FPE_FLTDIV;
4305 + sig = SIGFPE;
4306 + break;
4307 + case VEC_FPUNDER:
4308 + info.si_code = FPE_FLTUND;
4309 + sig = SIGFPE;
4310 + break;
4311 + case VEC_FPOVER:
4312 + info.si_code = FPE_FLTOVF;
4313 + sig = SIGFPE;
4314 + break;
4315 + case VEC_ZERODIV:
4316 + info.si_code = FPE_INTDIV;
4317 + sig = SIGFPE;
4318 + break;
4319 + case VEC_CHK:
4320 + case VEC_TRAP:
4321 + info.si_code = FPE_INTOVF;
4322 + sig = SIGFPE;
4323 + break;
4324 + case VEC_TRACE: /* ptrace single step */
4325 + info.si_code = TRAP_TRACE;
4326 + sig = SIGTRAP;
4327 + break;
4328 + case VEC_TRAP15: /* breakpoint */
4329 + info.si_code = TRAP_BRKPT;
4330 + sig = SIGTRAP;
4331 + break;
4332 + default:
4333 + info.si_code = ILL_ILLOPC;
4334 + sig = SIGILL;
4335 + break;
4336 + }
4337 + info.si_signo = sig;
4338 + info.si_errno = 0;
4339 + switch (fp->ptregs.format) {
4340 + default:
4341 + info.si_addr = (void *) fp->ptregs.pc;
4342 + break;
4343 + case 2:
4344 + info.si_addr = (void *) fp->un.fmt2.iaddr;
4345 + break;
4346 + case 7:
4347 + info.si_addr = (void *) fp->un.fmt7.effaddr;
4348 + break;
4349 + case 9:
4350 + info.si_addr = (void *) fp->un.fmt9.iaddr;
4351 + break;
4352 + case 10:
4353 + info.si_addr = (void *) fp->un.fmta.daddr;
4354 + break;
4355 + case 11:
4356 + info.si_addr = (void *) fp->un.fmtb.daddr;
4357 + break;
4358 + }
4359 + force_sig_info(sig, &info, current);
4360 +}
4361 +
4362 +asmlinkage void set_esp0(unsigned long ssp)
4363 +{
4364 + current->thread.esp0 = ssp;
4365 +}
4366 +
4367 +/*
4368 + * The architecture-independent backtrace generator
4369 + */
4370 +void dump_stack(void)
4371 +{
4372 + unsigned long stack;
4373 +
4374 + show_stack(current, &stack);
4375 +}
4376 +EXPORT_SYMBOL(dump_stack);
4377 +
4378 +#ifdef CONFIG_M68KFPU_EMU
4379 +asmlinkage void fpemu_signal(int signal, int code, void *addr)
4380 +{
4381 + siginfo_t info;
4382 +
4383 + info.si_signo = signal;
4384 + info.si_errno = 0;
4385 + info.si_code = code;
4386 + info.si_addr = addr;
4387 + force_sig_info(signal, &info, current);
4388 +}
4389 +#endif
4390 --- /dev/null
4391 +++ b/arch/m68k/coldfire/vmlinux-cf.lds
4392 @@ -0,0 +1,92 @@
4393 +/* ld script to make m68k Coldfire Linux kernel */
4394 +
4395 +#include <asm-generic/vmlinux.lds.h>
4396 +
4397 +OUTPUT_FORMAT("elf32-m68k", "elf32-m68k", "elf32-m68k")
4398 +OUTPUT_ARCH(m68k)
4399 +ENTRY(_start)
4400 +jiffies = jiffies_64 + 4;
4401 +SECTIONS
4402 +{
4403 + . = 0xC0020000;
4404 + _text = .; /* Text and read-only data */
4405 + .text : {
4406 + *(.text.head)
4407 + TEXT_TEXT
4408 + SCHED_TEXT
4409 + LOCK_TEXT
4410 + *(.fixup)
4411 + *(.gnu.warning)
4412 + } :text = 0x4e75
4413 +
4414 + _etext = .; /* End of text section */
4415 +
4416 + . = ALIGN(16);
4417 + __start___ex_table = .;
4418 + __ex_table : { *(__ex_table) }
4419 + __stop___ex_table = .;
4420 +
4421 + RODATA
4422 +
4423 + .data : { /* Data */
4424 + DATA_DATA
4425 + CONSTRUCTORS
4426 + }
4427 +
4428 + .bss : { *(.bss) } /* BSS */
4429 +
4430 + . = ALIGN(16);
4431 + .data.cacheline_aligned : { *(.data.cacheline_aligned) } :data
4432 +
4433 + _edata = .; /* End of data section */
4434 +
4435 + . = ALIGN(8192); /* Initrd */
4436 + __init_begin = .;
4437 + .init.text : {
4438 + _sinittext = .;
4439 + *(.init.text)
4440 + _einittext = .;
4441 + }
4442 + .init.data : { *(.init.data) }
4443 + . = ALIGN(16);
4444 + __setup_start = .;
4445 + .init.setup : { *(.init.setup) }
4446 + __setup_end = .;
4447 + __initcall_start = .;
4448 + .initcall.init : {
4449 + INITCALLS
4450 + }
4451 + __initcall_end = .;
4452 + __con_initcall_start = .;
4453 + .con_initcall.init : { *(.con_initcall.init) }
4454 + __con_initcall_end = .;
4455 + SECURITY_INIT
4456 +#ifdef CONFIG_BLK_DEV_INITRD
4457 + . = ALIGN(8192);
4458 + __initramfs_start = .;
4459 + .init.ramfs : { *(.init.ramfs) }
4460 + __initramfs_end = .;
4461 +#endif
4462 + . = ALIGN(8192);
4463 + __init_end = .;
4464 +
4465 + .data.init_task : { *(.data.init_task) } /* The initial task and kernel stack */
4466 +
4467 + _end = . ;
4468 +
4469 + /* Sections to be discarded */
4470 + /DISCARD/ : {
4471 + *(.exit.text)
4472 + *(.exit.data)
4473 + *(.exitcall.exit)
4474 + }
4475 +
4476 + /* Stabs debugging sections. */
4477 + .stab 0 : { *(.stab) }
4478 + .stabstr 0 : { *(.stabstr) }
4479 + .stab.excl 0 : { *(.stab.excl) }
4480 + .stab.exclstr 0 : { *(.stab.exclstr) }
4481 + .stab.index 0 : { *(.stab.index) }
4482 + .stab.indexstr 0 : { *(.stab.indexstr) }
4483 + .comment 0 : { *(.comment) }
4484 +}
Personal OpenWRT clone
This page took 0.211304 seconds and 5 git commands to generate.