projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ar71xx: rewrite prom code (based on a patch by Jeff Hansen)
[openwrt.git] / target / linux / coldfire / patches / 078-m547x_8x_pci_initial.patch
1 From 7f92b68c12c1891435c75f7f83a6390b4c73eaa6 Mon Sep 17 00:00:00 2001
2 From: Kurt Mahan <kmahan@freescale.com>
3 Date: Thu, 10 Jul 2008 19:17:11 -0600
4 Subject: [PATCH] Add PCI to m547x/m548x.
5
6 LTIBName: m547x-8x-pci-initial
7 Signed-off-by: Kurt Mahan <kmahan@freescale.com>
8 Signed-off-by: Shrek Wu <b16972@freescale.com>
9 ---
10 arch/m68k/Kconfig | 4 +-
11 arch/m68k/coldfire/Makefile | 7 +-
12 arch/m68k/coldfire/ints.c | 8 +-
13 arch/m68k/coldfire/mcf548x-pci.c | 934 +++++++++++++++++++++++++++++++++++++
14 arch/m68k/kernel/Makefile | 3 +
15 arch/m68k/kernel/bios32_mcf548x.c | 631 +++++++++++++++++++++++++
16 arch/m68k/kernel/dma.c | 32 +-
17 arch/m68k/mm/kmap.c | 11 +-
18 drivers/pci/access.c | 16 +-
19 drivers/usb/host/Makefile | 2 +-
20 include/asm-m68k/5445x_pci.h | 94 ++++
21 include/asm-m68k/548x_pci.h | 99 ++++
22 include/asm-m68k/io.h | 65 +++-
23 include/asm-m68k/m5485pci.h | 330 +++++++++++++
24 include/asm-m68k/pci.h | 96 +----
25 include/asm-m68k/raw_io.h | 26 +
26 include/asm-m68k/virtconvert.h | 5 +
27 include/linux/pci.h | 2 +
28 18 files changed, 2250 insertions(+), 115 deletions(-)
29 create mode 100644 arch/m68k/coldfire/mcf548x-pci.c
30 create mode 100644 arch/m68k/kernel/bios32_mcf548x.c
31 create mode 100644 include/asm-m68k/5445x_pci.h
32 create mode 100644 include/asm-m68k/548x_pci.h
33 create mode 100644 include/asm-m68k/m5485pci.h
34
35 --- a/arch/m68k/Kconfig
36 +++ b/arch/m68k/Kconfig
37 @@ -175,8 +175,8 @@ config HADES
38 to use this kernel on a Hades, say Y here; otherwise say N.
39
40 config PCI
41 - bool
42 - depends on HADES || M54455
43 + bool "PCI bus support"
44 + depends on HADES || M54455 || M547X_8X
45 default n
46 help
47 Find out whether you have a PCI motherboard. PCI is the name of a
48 --- a/arch/m68k/coldfire/Makefile
49 +++ b/arch/m68k/coldfire/Makefile
50 @@ -3,12 +3,17 @@
51 #
52
53 obj-y:= entry.o config.o cache.o signal.o muldi3.o traps.o ints.o
54 -
55 +ifdef CONFIG_M5445X
56 ifneq ($(strip $(CONFIG_USB) $(CONFIG_USB_GADGET_MCF5445X)),)
57 obj-y += usb.o usb/
58 endif
59 +endif
60
61 +ifdef CONFIG_M547X_8X
62 +obj-$(CONFIG_PCI) += mcf548x-pci.o
63 +else
64 obj-$(CONFIG_PCI) += pci.o mcf5445x-pci.o iomap.o
65 +endif
66 obj-$(CONFIG_M5445X) += mcf5445x-devices.o
67 obj-$(CONFIG_M547X_8X) += m547x_8x-devices.o
68 obj-$(CONFIG_M547X_8X) += mcf548x-devices.o
69 --- a/arch/m68k/coldfire/ints.c
70 +++ b/arch/m68k/coldfire/ints.c
71 @@ -192,6 +192,8 @@ int setup_irq(unsigned int irq, struct i
72 /* Can't share interrupts unless both agree to */
73 if (!((*prev)->flags & node->flags & IRQF_SHARED)) {
74 spin_unlock_irqrestore(&contr->lock, flags);
75 + printk(KERN_INFO "%s: -BUSY-Incorrect IRQ %d \n",
76 + __FUNCTION__, irq);
77 return -EBUSY;
78 }
79 while (*prev)
80 @@ -219,9 +221,11 @@ int request_irq(unsigned int irq,
81 struct irq_node *node = get_irq_node();
82 int res;
83
84 - if (!node)
85 + if (!node) {
86 + printk(KERN_INFO "%s:get_irq_node error %x\n",
87 + __FUNCTION__,(unsigned int) node);
88 return -ENOMEM;
89 -
90 + }
91 node->handler = handler;
92 node->flags = flags;
93 node->dev_id = dev_id;
94 --- /dev/null
95 +++ b/arch/m68k/coldfire/mcf548x-pci.c
96 @@ -0,0 +1,934 @@
97 +/*
98 + * ColdFire 547x/548x PCI Host Controller functions
99 + */
100 +#include <linux/kernel.h>
101 +#include <linux/types.h>
102 +#include <linux/init.h>
103 +#include <linux/mm.h>
104 +#include <linux/string.h>
105 +#include <linux/pci.h>
106 +#include <linux/ioport.h>
107 +#include <linux/slab.h>
108 +#include <linux/version.h>
109 +#include <linux/interrupt.h>
110 +
111 +#include <linux/dma-mapping.h>
112 +#include <asm/coldfire.h>
113 +#include <asm/io.h>
114 +#include <asm/m5485sim.h>
115 +#include <asm/m5485pci.h>
116 +#include <asm/irq.h>
117 +#include <asm/pci.h>
118 +#include <asm/virtconvert.h>
119 +
120 +
121 +#undef DEBUG
122 +//#define DEBUG
123 +
124 +#ifdef DEBUG
125 +//#define DBG(x...) printk(KERN_DEBUG x)
126 +#define DBG(x...) printk(x)
127 +#else
128 +#define DBG(x...)
129 +#endif
130 +
131 +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,75))
132 +# define irqreturn_t void
133 +# define IRQ_HANDLED
134 +# define IRQ_NONE
135 +#endif
136 +
137 +/*
138 + * Bridge configration dafaults
139 + */
140 +#define PCI_RETRIES 0
141 +#define PCI_CACHE_LINE 8
142 +#define PCI_MINGNT 1
143 +#define PCI_MAXLAT 42
144 +
145 +
146 +/*
147 + * Initiator windows setting
148 + */
149 +#define HOST_MEM_BASE 0xD0000000 /* ColdFire Memory window base */
150 +#define PCI_MEM_BASE 0xD0000000 /* PCI Memory window base */
151 +#define PCI_MEM_SIZE 0x08000000 /* Memory window size (128M) */
152 +#define HOST_IO_BASE 0xD8000000 /* ColdFire I/O window base */
153 +#define PCI_IO_BASE_ADDR 0x00000000 /* PCI I/O window base */
154 +#define PCI_IO_SIZE 0x00010000 /* I/O window size (64K) */
155 +#define HOST_CFG_BASE 0xD8000000 /* ColdFire config window base */
156 +#define HOST_DMA_BASE CONFIG_SDRAM_BASE /* ColdFire PCI-DMA window base */
157 +#define PCI_HDR_BASE (MCF_MBAR+0xB00)/* ColdFire config registers */
158 +
159 +#define PCI_MEM_MASK (PCI_MEM_SIZE-1)
160 +#define PCI_IO_MASK (PCI_IO_SIZE-1)
161 +
162 +/* Macro to set initiator window */
163 +#define WxBAR(host_address, pci_address, size) \
164 + (((host_address) & 0xff000000) | \
165 + ((((size)-1) & 0xff000000) >> 8) | \
166 + ((pci_address) & 0xff000000) >> 16)
167 +
168 +/*
169 + * BIOS internal data
170 + */
171 +static u8 revision; /* controller revision */
172 +
173 +/*
174 + * Board specific setting
175 + */
176 +const unsigned int irq_lines[] = { 5, 7 };
177 +
178 +#define N_SLOTS (sizeof(board_info) / sizeof(board_info[0]))
179 +#define N_IRQS (sizeof(irq_lines) / sizeof(irq_lines[0]))
180 +#define BRIDGE_SLOT 0
181 +
182 +const struct slotinfo {
183 + unsigned char idsel; /* device number */
184 + unsigned char irq; /* external IRQ */
185 + unsigned char req; /* REQ line number */
186 + unsigned char gnt; /* GNT line number */
187 +} board_info[] = {
188 + {0, 0, 0, 0}, /* Bridge */
189 + {17, 5, 1, 1}, /* Slot #1 */
190 + {18, 5, 2, 2}, /* Slot #2 */
191 + {20, 7, 3, 3}, /* Slot #3 */
192 + {21, 7, 4, 4}, /* Slot #4 */
193 +};
194 +
195 +/************************************************************************/
196 +
197 +/*
198 + * static int mk_conf_addr()
199 + *
200 + * Return type0 or type1 configuration address
201 + * by the means of device address and PCI dword location
202 + * 0 - for not existing slots
203 + */
204 +static int mk_conf_addr(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where)
205 +{
206 + int slot, func, address, idsel, dev_fn;
207 +
208 + if (bus->number) {
209 + address = MCF_PCICAR_E | (bus->number << 16) |
210 + (devfn << 8) | (where & 0xfc);
211 + } else {
212 + slot = PCI_SLOT(devfn);
213 + if (slot > N_SLOTS || slot == BRIDGE_SLOT)
214 + return 0;
215 + else {
216 + func = PCI_FUNC(devfn);
217 + idsel = board_info[slot].idsel;
218 +
219 + dev_fn = PCI_DEVFN(idsel, func);
220 + address = MCF_PCICAR_E | (bus->number << 16) |
221 + (dev_fn << 8) | (where & 0xfc);
222 + }
223 + }
224 +
225 + return (address);
226 +}
227 +
228 +/*
229 + * static int read_config_byte()
230 + *
231 + * Read a byte from configuration space of specified device
232 + */
233 +static int read_config_byte(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where, u8 *value)
234 +{
235 + int slot;
236 + int address;
237 + int result;
238 +
239 + *value = 0xff;
240 + result = PCIBIOS_SUCCESSFUL;
241 +
242 + slot = PCI_SLOT(devfn);
243 + if (slot == BRIDGE_SLOT) {
244 + if (where <= 0x40)
245 + *value = *(volatile u8 *) (PCI_HDR_BASE + (where ^ 3));
246 + else
247 + *value = 0;
248 + } else {
249 + address = mk_conf_addr(bus, devfn, where);
250 + if (!address)
251 + result = PCIBIOS_DEVICE_NOT_FOUND;
252 + else {
253 + MCF_PCICAR = address;
254 + *value = *(volatile u8 *) (HOST_CFG_BASE + (where & 3));
255 + }
256 + }
257 + __asm__ __volatile__("nop");
258 + __asm__ __volatile__("nop");
259 + MCF_PCICAR &= ~MCF_PCICAR_E;
260 +
261 + DBG("PCI: read_config_byte bus=%d, devfn=%d, addr=0x%02X, val=0x%02X, ret=%02X\n",
262 + bus->number, devfn, where, *value, result);
263 +
264 + return (result);
265 +}
266 +
267 +/*
268 + * static int read_config_word()
269 + *
270 + * Read a word from configuration space of specified device
271 + */
272 +static int read_config_word(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where, u16 *value)
273 +{
274 + int slot;
275 + int address;
276 + int result;
277 +
278 + *value = 0xffff;
279 + result = PCIBIOS_SUCCESSFUL;
280 +
281 + if (where & 0x1)
282 + result = PCIBIOS_BAD_REGISTER_NUMBER;
283 + else {
284 + slot = PCI_SLOT(devfn);
285 + if (slot == BRIDGE_SLOT) {
286 + if (where <= 0x3f)
287 + *value =
288 + *(volatile u16 *) (PCI_HDR_BASE +
289 + (where ^ 2));
290 + else
291 + *value = 0;
292 + } else {
293 + address = mk_conf_addr(bus, devfn, where);
294 + if (!address)
295 + result = PCIBIOS_DEVICE_NOT_FOUND;
296 + else {
297 + MCF_PCICAR = address;
298 + *value = le16_to_cpu(*(volatile u16 *)
299 + (HOST_CFG_BASE +
300 + (where & 2)));
301 + }
302 + }
303 + }
304 + __asm__ __volatile__("nop");
305 + __asm__ __volatile__("nop");
306 + MCF_PCICAR &= ~MCF_PCICAR_E;
307 +
308 + DBG("PCI: read_config_word bus=%d, devfn=%d, addr=0x%02X, val=0x%04X ret=%02X\n",
309 + bus->number, devfn, where, *value, result);
310 +
311 + return (result);
312 +}
313 +
314 +/*
315 + * static int read_config_dword()
316 + *
317 + * Read a long word from configuration space of specified device
318 + */
319 +static int read_config_dword(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where, u32 *value)
320 +{
321 + int slot;
322 + int address;
323 + int result;
324 +
325 + *value = 0xffffffff;
326 + result = PCIBIOS_SUCCESSFUL;
327 +
328 + if (where & 0x3)
329 + result = PCIBIOS_BAD_REGISTER_NUMBER;
330 + else {
331 + slot = PCI_SLOT(devfn);
332 + if (slot == BRIDGE_SLOT) {
333 + if (where <= 0x3d)
334 + *value =
335 + *(volatile u32 *) (PCI_HDR_BASE + where);
336 + else
337 + *value = 0;
338 + __asm__ __volatile__("nop");
339 + __asm__ __volatile__("nop");
340 + } else {
341 + address = mk_conf_addr(bus, devfn, where);
342 + if (!address)
343 + result = PCIBIOS_DEVICE_NOT_FOUND;
344 + else {
345 + MCF_PCICAR = address;
346 + *value = le32_to_cpu(*(volatile u32 *)
347 + (HOST_CFG_BASE));
348 + __asm__ __volatile__("nop");
349 + __asm__ __volatile__("nop");
350 + if (bus->number != 0 && revision < 1) {
351 + volatile u32 temp;
352 +
353 + MCF_PCICAR |= 0xff0000;
354 + temp = *(volatile u32 *) (HOST_CFG_BASE);
355 + }
356 + }
357 + }
358 + }
359 +
360 + MCF_PCICAR &= ~MCF_PCICAR_E;
361 +
362 + DBG("PCI: read_config_dword bus=%d, devfn=%d, addr=0x%02X, value=0x%08X ret=%02X\n",
363 + bus->number, devfn, where, *value, result);
364 +
365 + return (result);
366 +}
367 +
368 +/*
369 + * static int write_config_byte()
370 + *
371 + * Write a byte to configuration space of specified device
372 + */
373 +static int write_config_byte(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where, u8 value)
374 +{
375 + int slot;
376 + int address;
377 + int result;
378 +
379 + result = PCIBIOS_SUCCESSFUL;
380 +
381 + slot = PCI_SLOT(devfn);
382 + if (slot == BRIDGE_SLOT) {
383 + if (where <= 0x40)
384 + *(volatile u8 *) (PCI_HDR_BASE + (where ^ 3)) = value;
385 + } else {
386 + address = mk_conf_addr(bus, devfn, where);
387 + if (!address)
388 + result = PCIBIOS_DEVICE_NOT_FOUND;
389 + else {
390 + MCF_PCICAR = address;
391 + *(volatile u8 *) (HOST_CFG_BASE + (where & 3)) = value;
392 + }
393 + }
394 + __asm__ __volatile__("nop");
395 + __asm__ __volatile__("nop");
396 + MCF_PCICAR &= ~MCF_PCICAR_E;
397 +
398 + DBG("PCI: write_config_byte bus=%d, devfn=%d, addr=0x%02X, value=0x%02X ret=%02X\n",
399 + bus->number, devfn, where, value, result);
400 +
401 + return (result);
402 +}
403 +
404 +/*
405 + * static int write_config_word()
406 + *
407 + * Write a word to configuration space of specified device
408 + */
409 +static int write_config_word(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where, u16 value)
410 +{
411 + int slot;
412 + int address;
413 + int result;
414 +
415 + result = PCIBIOS_SUCCESSFUL;
416 +
417 + if (where & 0x1)
418 + result = PCIBIOS_BAD_REGISTER_NUMBER;
419 + else {
420 + slot = PCI_SLOT(devfn);
421 + if (slot == BRIDGE_SLOT) {
422 + if (where <= 0x3f)
423 + *(volatile u16 *) (PCI_HDR_BASE + (where ^ 2)) =
424 + value;
425 + } else {
426 + address = mk_conf_addr(bus, devfn, where);
427 + if (!address)
428 + result = PCIBIOS_DEVICE_NOT_FOUND;
429 + else {
430 + MCF_PCICAR = address;
431 + *(volatile u16 *) (HOST_CFG_BASE + (where & 2)) =
432 + cpu_to_le16(value);
433 + }
434 + }
435 + }
436 + __asm__ __volatile__("nop");
437 + __asm__ __volatile__("nop");
438 + MCF_PCICAR &= ~MCF_PCICAR_E;
439 +
440 + DBG("PCI: write_config_word bus=%d, devfn=%d, addr=0x%02X, value=0x%04X ret=%02X\n",
441 + bus->number, devfn, where, value, result);
442 +
443 + return (result);
444 +}
445 +
446 +/*
447 + * static int write_config_dword()
448 + *
449 + * Write a long word to configuration space of specified device
450 + */
451 +static int write_config_dword(/*struct pci_dev *dev*/struct pci_bus *bus, unsigned int devfn, int where, u32 value)
452 +{
453 + int slot;
454 + int address;
455 + int result;
456 +
457 + result = PCIBIOS_SUCCESSFUL;
458 +
459 + if (where & 0x3)
460 + result = PCIBIOS_BAD_REGISTER_NUMBER;
461 + else {
462 + slot = PCI_SLOT(devfn);
463 + if (slot == BRIDGE_SLOT) {
464 + if (where <= 0x3d)
465 + *(volatile u32 *) (PCI_HDR_BASE + where) =
466 + value;
467 + } else {
468 + address = mk_conf_addr(bus, devfn, where);
469 + if (!address)
470 + result = PCIBIOS_DEVICE_NOT_FOUND;
471 + else {
472 + MCF_PCICAR = address;
473 + *(volatile u32 *) (HOST_CFG_BASE) =
474 + cpu_to_le32(value);
475 + }
476 + }
477 + }
478 + __asm__ __volatile__("nop");
479 + __asm__ __volatile__("nop");
480 + MCF_PCICAR &= ~MCF_PCICAR_E;
481 +
482 + DBG("PCI: write_config_dword dev=%d, fn=%d, addr=0x%02X, value=0x%08X ret=%02X\n",
483 + PCI_SLOT(devfn), PCI_FUNC(devfn), where, value, result);
484 +
485 + return (result);
486 +}
487 +
488 +static int config_read(struct pci_bus *bus, unsigned int devfn,
489 + int where, int size, u32 * val)
490 +{
491 + switch (size) {
492 + case 1:
493 + return read_config_byte(bus, devfn, where, (u8 *) val);
494 + case 2:
495 + return read_config_word(bus, devfn, where, (u16 *) val);
496 + default:
497 + return read_config_dword(bus, devfn, where, val);
498 + }
499 +}
500 +
501 +static int config_write(struct pci_bus *bus, unsigned int devfn,
502 + int where, int size, u32 val)
503 +{
504 + switch (size) {
505 + case 1:
506 + return write_config_byte(bus, devfn, where, (u8) val);
507 + case 2:
508 + return write_config_word(bus, devfn, where, (u16) val);
509 + default:
510 + return write_config_dword(bus, devfn, where, val);
511 + }
512 +}
513 +
514 +/*
515 + * configuration routines entry points
516 + */
517 +static struct pci_ops bus_ops = {
518 + read: config_read,
519 + write: config_write
520 +};
521 +
522 +/************************************************************************/
523 +
524 +/*
525 + * u8 pci_inb()
526 + *
527 + * Read a byte at specified address from I/O space
528 + */
529 +unsigned char pci_inb(long addr)
530 +{
531 + char value;
532 +
533 + value = *(volatile unsigned char *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
534 + DBG("PCI: inb addr=0x%08X, value=0x%02X\n", addr, value);
535 +
536 + return (unsigned char) value;
537 +}
538 +
539 +
540 +/*
541 + * u16 pci_inw()
542 + *
543 + * Read a word at specified address from I/O space
544 + */
545 +unsigned short pci_inw(long addr)
546 +{
547 + short value;
548 + volatile unsigned short *ptr;
549 +
550 + ptr = (volatile unsigned short *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
551 + value = le16_to_cpu(*ptr);
552 +
553 + DBG("PCI: inw addr=0x%08X, value=0x%04X\n", addr, value);
554 + return (unsigned short) value;
555 +}
556 +
557 +/*
558 + * u16 pci_raw_inw()
559 + *
560 + * Read a raw word at specified address from I/O space
561 + */
562 +unsigned short pci_raw_inw(long addr)
563 +{
564 + short value;
565 + volatile unsigned short *ptr;
566 +
567 + ptr = (volatile unsigned short *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
568 + value = *ptr;
569 +
570 + DBG("PCI: raw_inw addr=0x%08X, value=0x%04X\n", addr, value);
571 + return (unsigned short) value;
572 +}
573 +
574 +/*
575 + * u32 pci_inl()
576 + *
577 + * Read a dword at specified address from I/O space
578 + */
579 +unsigned long pci_inl(long addr)
580 +{
581 + long value;
582 + volatile unsigned long *ptr;
583 +
584 + ptr = (volatile unsigned long *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
585 + value = le32_to_cpu(*ptr);
586 +
587 + DBG("PCI: inl addr=0x%08X, value=0x%08X\n", addr, value);
588 + return (unsigned long) value;
589 +}
590 +
591 +/*
592 + * u32 pci_raw_inl()
593 + *
594 + * Read a raw dword at specified address from I/O space
595 + */
596 +unsigned long pci_raw_inl(long addr)
597 +{
598 + long value;
599 + volatile unsigned long *ptr;
600 +
601 + ptr = (volatile unsigned long *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
602 + value = *ptr;
603 +
604 + DBG("PCI: raw_inl addr=0x%08X, value=0x%08X\n", addr, value);
605 + return (unsigned long) value;
606 +}
607 +
608 +/*
609 + * void pci_outb()
610 + *
611 + * Write a byte value at specified address to I/O space
612 + */
613 +void pci_outb( unsigned char value, long addr)
614 +{
615 +
616 + *(volatile unsigned char *) (HOST_IO_BASE | (addr & PCI_IO_MASK)) = value;
617 + DBG("PCI: outb addr=0x%08X, value=0x%02X\n", addr, value);
618 +}
619 +
620 +
621 +/*
622 + * void pci_outw()
623 + *
624 + * Write a word value at specified address to I/O space
625 + */
626 +void pci_outw(volatile unsigned short value, volatile long addr)
627 +{
628 + volatile unsigned short *ptr;
629 +
630 + ptr = (volatile unsigned short *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
631 + *ptr = cpu_to_le16(value);
632 + DBG("PCI: outw addr=0x%08X, value=0x%04X\n", addr, value);
633 +}
634 +
635 +/*
636 + * void pci_raw_outw()
637 + *
638 + * Write a raw word value at specified address to I/O space
639 + */
640 +void pci_raw_outw(volatile unsigned short value, volatile long addr)
641 +{
642 + volatile unsigned short *ptr;
643 +
644 + ptr = (volatile unsigned short *) (HOST_IO_BASE | (addr & PCI_IO_MASK));
645 + *ptr = value;
646 + DBG("PCI: raw_outw addr=0x%08X, value=0x%04X\n", addr, value);
647 +}
648 +
649 +/*
650 + * void pci_outl()
651 + *
652 + * Write a long word value at specified address to I/O space
653 + */
654 +void pci_outl(volatile unsigned long value, volatile long addr)
655 +{
656 + volatile unsigned long *ptr;
657 +
658 + ptr = (volatile unsigned long *)(HOST_IO_BASE | (addr & PCI_IO_MASK));
659 + *ptr = cpu_to_le32(value);
660 + DBG("PCI: outl addr=0x%08X, value=0x%08X\n", addr, value);
661 +}
662 +
663 +/*
664 + * void pci_raw_outl()
665 + *
666 + * Write a raw long word value at specified address to I/O space
667 + */
668 +void pci_raw_outl(volatile unsigned long value, volatile long addr)
669 +{
670 + volatile unsigned long *ptr;
671 +
672 + ptr = (volatile unsigned long *)(HOST_IO_BASE | (addr & PCI_IO_MASK));
673 + *ptr = value;
674 + DBG("PCI: raw_outl addr=0x%08X, value=0x%08X\n", addr, value);
675 +}
676 +
677 +/*
678 + * void pci_insb()
679 + *
680 + * Read several byte values from specified I/O port
681 + */
682 +void pci_insb(volatile unsigned char *addr, unsigned char *buf, int len)
683 +{
684 + for (; len--; buf++)
685 + *buf = pci_inb((unsigned long)addr);
686 + DBG("PCI: pci_insb addr=0x%08X, buf=%p, len=%d\n", addr, buf, len);
687 +}
688 +
689 +
690 +/*
691 + * void pci_insw()
692 + *
693 + * Read several word values from specified I/O port
694 + */
695 +void pci_insw(volatile unsigned short *addr, unsigned short *buf, int len)
696 +{
697 + for (; len--; buf++)
698 + *buf = pci_inw((unsigned long)addr);
699 + DBG("PCI: pci_insw addr=0x%08X, buf=%p, len=%d\n", addr, buf, len);
700 +}
701 +
702 +/*
703 + * void pci_insl()
704 + *
705 + * Read several dword values from specified I/O port
706 + */
707 +void pci_insl(volatile unsigned long *addr, unsigned long *buf, int len)
708 +{
709 + for (; len--; buf++)
710 + *buf = pci_inl((unsigned long)addr);
711 + DBG("PCI: pci_insl addr=0x%08X, buf=%p, len=%d\n", addr, buf, len);
712 +}
713 +
714 +/*
715 + * void pci_outsb()
716 + *
717 + * Write several byte values to specified I/O port
718 + */
719 +void pci_outsb(volatile unsigned char *addr, const unsigned char *buf, int len)
720 +{
721 + for (; len--; buf++)
722 + pci_outb((unsigned long)addr, *buf);
723 + DBG("PCI: pci_outsb addr=0x%08X, buf=%p, len=%d\n", addr, buf, len);
724 +}
725 +
726 +/*
727 + * void pci_outsw()
728 + *
729 + * Write several word values to specified I/O port
730 + */
731 +void pci_outsw(volatile unsigned short *addr, const unsigned short *buf, int len)
732 +{
733 + for (; len--; buf++)
734 + pci_outw((unsigned long)addr, *buf);
735 + DBG("PCI: pci_outsw addr=0x%08X, buf=%p, len=%d\n", addr, buf, len);
736 +}
737 +
738 +/*
739 + * void pci_outsl()
740 + *
741 + * Write several dword values to specified I/O port
742 + */
743 +void pci_outsl(volatile unsigned long *addr, const unsigned long *buf, int len)
744 +{
745 + for (; len--; buf++)
746 + pci_outl((unsigned long)addr, *buf);
747 + DBG("PCI: pci_outsl addr=0x%08X, buf=%p, len=%d\n", addr, buf, len);
748 +}
749 +
750 +/*
751 + * void pci_xlb_handler()
752 + *
753 + * PCI XLB interrupt handler
754 + */
755 +irqreturn_t xlb_interrupt(int irq, void *dev)
756 +{
757 + volatile int xlb_error = MCF_PCIISR;
758 +
759 + /* Acknowlege interrupt */
760 + MCF_PCIISR = xlb_error;
761 +
762 + /* Dump interrupt reason */
763 + if (xlb_error & MCF_PCIISR_RE)
764 + DBG("PCI: Retry Error Received\n");
765 +
766 + if (xlb_error & MCF_PCIISR_IA)
767 + DBG("PCI: Initiator Abort Received\n");
768 +
769 + if (xlb_error & MCF_PCIISR_TA)
770 + DBG("PCI: Target Abort Received\n");
771 +
772 + return IRQ_HANDLED;
773 +}
774 +
775 +
776 +/*
777 + * void pci_arbiter_handler()
778 + *
779 + * PCI arbiter interrupt handler
780 + */
781 +irqreturn_t arb_interrupt(int irq, void *dev)
782 +{
783 + volatile unsigned long arb_error = MCF_PCIARB_PASR;
784 +
785 + /* Acknowlege interrupt */
786 + printk("%s\n",__FUNCTION__);
787 + MCF_PCIARB_PASR = arb_error;
788 +
789 + if (arb_error & MCF_PCIARB_PASR_ITLMBK) {
790 + DBG("PCI: coldfire master time-out\n");
791 +
792 + /* Set infinite number of retries */
793 + MCF_PCIICR &= ~0xFF;
794 + }
795 +
796 + if (arb_error & MCF_PCIARB_PASR_EXTMBK(0x1F)) {
797 + arb_error >>= 17;
798 + DBG("PCI: external master time-out (mask = 0x%X)\n", arb_error);
799 +
800 + /* raise arbitration priority level */
801 + MCF_PCIARB_PACR = MCF_PCIARB_PACR_EXTMPRI(arb_error);
802 + }
803 +
804 + return IRQ_HANDLED;
805 +}
806 +
807 +
808 +/*
809 + * void pci_eint_handler()
810 + *
811 + * Eport interrupt handler
812 + */
813 +irqreturn_t eint_handler(int irq, void *dev)
814 +{
815 + /* Just acknowlege interrupt and exit */
816 + MCF_EPFR = 0x1 << (irq - 64);
817 + return IRQ_HANDLED;
818 +}
819 +
820 +
821 +/*
822 + * void __init coldfire_fixup(int pci_modify)
823 + *
824 + * Assign IRQ numbers as used by Linux to the interrupt pins
825 + * of the PCI cards.
826 + */
827 +static void __init coldfire_fixup(int pci_modify)
828 +{
829 + struct pci_dev *dev;
830 + unsigned char slot, pin;
831 +
832 + DBG("%s\n",__FUNCTION__);
833 +#ifdef NL_ORIGINAL
834 + pci_for_each_dev(dev) {
835 +#else
836 + dev = NULL;
837 + while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
838 +#endif
839 + if (dev->class >> 16 != PCI_BASE_CLASS_BRIDGE) {
840 + slot = PCI_SLOT(dev->devfn);
841 + dev->irq = 64 + board_info[slot].irq;
842 +
843 + /* Check if device needs interrupt */
844 +#ifdef NL_ORIGINAL
845 + pcibios_read_config_byte(
846 + dev->bus->number, dev->devfn,
847 + PCI_INTERRUPT_PIN, &pin);
848 +
849 + if ( pin ) {
850 + pcibios_write_config_byte(
851 + dev->bus->number, dev->devfn,
852 + PCI_INTERRUPT_LINE, dev->irq);
853 + }
854 +#else
855 + pci_read_config_byte(dev,
856 + PCI_INTERRUPT_PIN, &pin);
857 +
858 + if ( pin ) {
859 + pci_write_config_byte(dev,
860 + PCI_INTERRUPT_LINE, dev->irq);
861 + }
862 +#endif
863 + }
864 + }
865 +}
866 +
867 +static void __init configure_device(struct pci_dev *dev)
868 +{
869 + /* TODO: This should depend from disable_pci_burst setting */
870 + DBG("%s\n",__FUNCTION__);
871 +#ifdef NL_ORIGINAL
872 + pcibios_write_config_byte(bus, devfn, PCI_CACHE_LINE_SIZE, PCI_CACHE_LINE);
873 +#else
874 + pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, PCI_CACHE_LINE);
875 +#endif
876 +}
877 +
878 +struct pci_bus_info *__init init_coldfire_pci(void)
879 +{
880 + static struct pci_bus_info bus;
881 + int i;
882 + int pci_mem_va;
883 + static char irq_name[N_IRQS][15];
884 +
885 + /* Get controller revision */
886 + revision = MCF_PCICCRIR;
887 + printk("ColdFire PCI Host Bridge (Rev. %d) detected:"
888 + "MEMBase %x,MEMLen %x,IOBase %x,IOLen %x\n",
889 + revision, HOST_MEM_BASE, PCI_MEM_SIZE - 1, 0, PCI_IO_SIZE - 1);
890 +
891 + /* Setup bus info structure. */
892 + memset(&bus, 0, sizeof (struct pci_bus_info));
893 +
894 + /* Request intiator memory resource */
895 + bus.mem_space.start = PCI_MEM_BASE;//HOST_MEM_BASE;
896 + bus.mem_space.end = bus.mem_space.start + PCI_MEM_SIZE - 1;
897 + bus.mem_space.name = "PCI Bus #0";
898 + if (request_resource(&iomem_resource, &bus.mem_space) != 0)
899 + {
900 + printk("Failed to request bridge iomem resource\n");
901 + return NULL;
902 + }
903 +
904 + /* Request intiator memory resource */
905 + bus.io_space.start = 0;
906 + bus.io_space.end = bus.io_space.start + PCI_IO_SIZE - 1;
907 + bus.io_space.name = "PCI Bus #0";
908 + if (request_resource(&ioport_resource, &bus.io_space) != 0)
909 + {
910 + printk("Failed to request bridge ioport resource\n");
911 + return NULL;
912 + }
913 +
914 + /* Set up the arbiter */
915 + MCF_PCIARB_PACR = 0 /*MCF_PCIARB_PACR_PKMD*/
916 + | MCF_PCIARB_PACR_INTMPRI
917 + | MCF_PCIARB_PACR_INTMINTEN
918 + | MCF_PCIARB_PACR_EXTMPRI(0x1F)
919 + | MCF_PCIARB_PACR_EXTMINTEN(0x1F);
920 +
921 + /* GNT and REQ */
922 + MCF_PAR_PCIBG = 0x3FF;
923 + MCF_PAR_PCIBR = 0x3FF;
924 +
925 + /* Enable bus mastering, memory access and MWI */
926 + MCF_PCISCR = MCF_PCISCR_B | MCF_PCISCR_M | MCF_PCISCR_MW;
927 +
928 + /* Setup burst parameters */
929 + MCF_PCICR1 = MCF_PCICR1_LATTIMER(32) |
930 + MCF_PCICR1_CACHELINESIZE(PCI_CACHE_LINE);
931 +
932 + MCF_PCICR2 = 0;
933 + /*MCF_PCICR2_MINGNT(PCI_MINGNT) |
934 + MCF_PCICR2_MAXLAT(PCI_MAXLAT);
935 + */
936 + /* Turn on error signaling */
937 + MCF_PCIICR = MCF_PCIICR_TAE | MCF_PCIICR_IAE | PCI_RETRIES;
938 + MCF_PCIGSCR |= MCF_PCIGSCR_SEE;
939 + /*
940 + * Configure Initiator Windows
941 + * Window 0: 128M PCI Memory @ HOST_MEM_BASE, 1:1 mapping
942 + * Window 1: 64K I/O Memory @ HOST_IO_BASE, 1:0 mapping
943 + */
944 + MCF_PCIIW0BTAR = WxBAR(HOST_MEM_BASE, PCI_MEM_BASE, PCI_MEM_SIZE);
945 + MCF_PCIIW1BTAR = WxBAR(HOST_IO_BASE, PCI_IO_BASE_ADDR, PCI_IO_SIZE);
946 +
947 + MCF_PCIIWCR = MCF_PCIIWCR_WINCTRL1_IO |
948 + MCF_PCIIWCR_WINCTRL0_MEMRDLINE;
949 +
950 + /* Target PCI DMA Windows */
951 + MCF_PCIBAR1 = PCI_DMA_BASE;
952 + MCF_PCITBATR1 = HOST_DMA_BASE | MCF_PCITBATR1_EN;
953 + MCF_PCIBAR0 = MCF_RAMBAR0;;
954 + MCF_PCITBATR0 = MCF_RAMBAR0 | MCF_PCITBATR0_EN;
955 + DBG("PCI TCR %x,MCF_PCIBAR1 %x,MCF_PCITBATR1 %x."
956 + "MCF_PCIBAR0 %x,MCF_PCITBATR9 %x\n", MCF_PCITCR, MCF_PCIBAR1,
957 + MCF_PCITBATR1, MCF_PCIBAR0, MCF_PCITBATR0);
958 + /* Enable internal PCI controller interrupts */
959 + MCF_ICR(ISC_PCI_XLB) = ILP_PCI_XLB;
960 + /*request_irq(64+ISC_PCI_XLB, xlb_interrupt,
961 + SA_INTERRUPT, "PCI XL Bus", (void*)-1);
962 + enable_irq (64+ISC_PCI_XLB);
963 + */
964 + if(request_irq(64+ISC_PCI_XLB, xlb_interrupt,
965 + IRQF_DISABLED, "PCI XL Bus", (void*)-1)){
966 + printk("Cannot allocate ISC_PCI_XLB IRQ\n");
967 + return (struct pci_bus_info *)-EBUSY;
968 + }
969 +
970 + MCF_ICR(ISC_PCI_ARB) = ILP_PCI_ARB;
971 + /*request_irq(64+ISC_PCI_ARB, arb_interrupt,
972 + SA_INTERRUPT, "PCI Arbiter", (void*)-1);
973 + enable_irq (64+ISC_PCI_ARB);
974 + */
975 + if(request_irq(64+ISC_PCI_ARB, arb_interrupt,
976 + IRQF_DISABLED, "PCI Arbiter", (void*)-1)){
977 + printk("Cannot allocate ISC_PCI_ARB IRQ\n");
978 + return (struct pci_bus_info *)-EBUSY;
979 + }
980 +
981 + /* Set slots interrupt setting */
982 + for (i = 0; i < N_IRQS; i++)
983 + {
984 + /* Set trailing edge for PCI interrupts */
985 + MCF_EPPAR &= ~MCF_EPPAR_EPPA(irq_lines[i], 0x3);
986 + if (irq_lines[i] == 5)
987 + MCF_EPPAR |= MCF_EPPAR_EPPA(irq_lines[i], MCF_EPPAR_EPPAx_FALLING);
988 + else
989 + MCF_EPPAR |= MCF_EPPAR_EPPA(irq_lines[i], 0/*MCF_EPPAR_EPPAx_FALLING*/);
990 + /* Turn on irq line in eport */
991 + MCF_EPIER |= MCF_EPIER_EPIE(irq_lines[i]);
992 +
993 + /* Enable irq in gpio */
994 + if (irq_lines[i] == 5)
995 + MCF_PAR_FECI2CIRQ |= 1;
996 +
997 + if (irq_lines[i] == 6)
998 + MCF_PAR_FECI2CIRQ |= 2;
999 +
1000 + /* Register external interrupt handlers */
1001 + sprintf(irq_name[i], "PCI IRQ%d", irq_lines[i]);
1002 + /*request_irq(64 + irq_lines[i], eint_handler,
1003 + SA_SHIRQ, irq_name[i], (void*)-1);
1004 + enable_irq(64 + irq_lines[i]);*/
1005 + if(request_irq(64 + irq_lines[i], eint_handler,
1006 + IRQF_SHARED, irq_name[i], (void*)-1)){
1007 + printk("Cannot allocate irq_lines[%d] IRQ\n", irq_lines[i]);
1008 + return (struct pci_bus_info *)-EBUSY;
1009 + }
1010 + }
1011 +
1012 + /* Clear PCI Reset and wait for devices to reset */
1013 + MCF_PCIGSCR &= ~MCF_PCIGSCR_PR;
1014 + schedule_timeout((5 * HZ) / 10);
1015 + /* Remap initiator windows (should be 1:1 to the physical memory) */
1016 + pci_mem_va = (int) ioremap_nocache(HOST_MEM_BASE, PCI_MEM_SIZE + PCI_IO_SIZE);
1017 +#if 1
1018 + printk("%s: MEMBase_phy %x, Virt %x, len %x\n",__FUNCTION__,
1019 + HOST_MEM_BASE,pci_mem_va,PCI_MEM_SIZE + PCI_IO_SIZE);
1020 +#endif
1021 + BUG_ON(pci_mem_va != HOST_MEM_BASE);
1022 +
1023 + /* Setup bios32 and pci bus driver callbacks */
1024 + bus.m68k_pci_ops = &bus_ops;
1025 + bus.fixup = coldfire_fixup;
1026 + bus.conf_device = configure_device;
1027 +
1028 + return &bus;
1029 +}
1030 +
1031 --- a/arch/m68k/kernel/Makefile
1032 +++ b/arch/m68k/kernel/Makefile
1033 @@ -12,6 +12,9 @@ ifndef CONFIG_COLDFIRE
1034 obj-$(CONFIG_PCI) += bios32.o
1035 else # CONFIG_COLDFIRE
1036 extra-y := ../coldfire/head.o vmlinux.lds
1037 +ifdef CONFIG_M547X_8X
1038 + obj-$(CONFIG_PCI) += bios32_mcf548x.o
1039 +endif
1040 endif
1041 endif
1042
1043 --- /dev/null
1044 +++ b/arch/m68k/kernel/bios32_mcf548x.c
1045 @@ -0,0 +1,631 @@
1046 +/*
1047 + * bios32.c - PCI BIOS functions for m68k systems.
1048 + *
1049 + * Written by Wout Klaren.
1050 + *
1051 + * Based on the DEC Alpha bios32.c by Dave Rusling and David Mosberger.
1052 + */
1053 +#include <linux/init.h>
1054 +#include <linux/kernel.h>
1055 +
1056 +#if 0
1057 +# define DBG_DEVS(args) printk args
1058 +#else
1059 +# define DBG_DEVS(args)
1060 +#endif
1061 +
1062 +#ifdef CONFIG_PCI
1063 +
1064 +/*
1065 + * PCI support for Linux/m68k. Currently only the Hades is supported.
1066 + *
1067 + * The support for PCI bridges in the DEC Alpha version has
1068 + * been removed in this version.
1069 + */
1070 +
1071 +#include <linux/pci.h>
1072 +#include <linux/slab.h>
1073 +#include <linux/mm.h>
1074 +
1075 +#include <asm/io.h>
1076 +#include <asm/pci.h>
1077 +#include <asm/uaccess.h>
1078 +
1079 +#define KB 1024
1080 +#define MB (1024*KB)
1081 +#define GB (1024*MB)
1082 +
1083 +#define MAJOR_REV 0
1084 +#define MINOR_REV 5
1085 +
1086 +/*
1087 + * Align VAL to ALIGN, which must be a power of two.
1088 + */
1089 +
1090 +#define MAX(val1, val2) (((val1) > (val2)) ? val1 : val2)
1091 +
1092 +/*
1093 + * Offsets relative to the I/O and memory base addresses from where resources
1094 + * are allocated.
1095 + */
1096 +
1097 +#ifdef CONFIG_COLDFIRE
1098 +#define IO_ALLOC_OFFSET 0x00000100
1099 +#define MEM_ALLOC_OFFSET 0x00000000
1100 +#else /* CONFIG_COLDFIRE */
1101 +#define IO_ALLOC_OFFSET 0x00004000
1102 +#define MEM_ALLOC_OFFSET 0x04000000
1103 +#endif /* CONFIG_COLDFIRE */
1104 +
1105 +/*
1106 + * Declarations of hardware specific initialisation functions.
1107 + */
1108 +
1109 +extern struct pci_bus_info *init_hades_pci(void);
1110 +
1111 +/*
1112 + * Bus info structure of the PCI bus. A pointer to this structure is
1113 + * put in the sysdata member of the pci_bus structure.
1114 + */
1115 +
1116 +static struct pci_bus_info *bus_info;
1117 +
1118 +static int pci_modify = 1; /* If set, layout the PCI bus ourself. */
1119 +static int skip_vga; /* If set do not modify base addresses
1120 + of vga cards.*/
1121 +static int disable_pci_burst; /* If set do not allow PCI bursts. */
1122 +
1123 +static unsigned int io_base;
1124 +static unsigned int mem_base;
1125 +
1126 +/*
1127 + * static void disable_dev(struct pci_dev *dev)
1128 + *
1129 + * Disable PCI device DEV so that it does not respond to I/O or memory
1130 + * accesses.
1131 + *
1132 + * Parameters:
1133 + *
1134 + * dev - device to disable.
1135 + */
1136 +
1137 +static void __init disable_dev(struct pci_dev *dev)
1138 +{
1139 + unsigned short cmd;
1140 +
1141 + if (((dev->class >> 8 == PCI_CLASS_NOT_DEFINED_VGA) ||
1142 + (dev->class >> 8 == PCI_CLASS_DISPLAY_VGA) ||
1143 + (dev->class >> 8 == PCI_CLASS_DISPLAY_XGA)) && skip_vga)
1144 + return;
1145 +
1146 + pci_read_config_word(dev, PCI_COMMAND, &cmd);
1147 +
1148 + cmd &= (~PCI_COMMAND_IO & ~PCI_COMMAND_MEMORY & ~PCI_COMMAND_MASTER);
1149 + pci_write_config_word(dev, PCI_COMMAND, cmd);
1150 +}
1151 +
1152 +/* Stolen from pcibios_enable_resources/i386 */
1153 +int pcibios_enable_device(struct pci_dev *dev, int mask)
1154 +{
1155 + u16 cmd, old_cmd;
1156 + int idx;
1157 + struct resource *r;
1158 +
1159 + pci_read_config_word(dev, PCI_COMMAND, &cmd);
1160 + old_cmd = cmd;
1161 + for(idx=0; idx<6; idx++) {
1162 + /* Only set up the requested stuff */
1163 + if (!(mask & (1<<idx)))
1164 + continue;
1165 +
1166 + r = &dev->resource[idx];
1167 + if (!r->start && r->end) {
1168 + printk("PCI: Device %s not available because"
1169 + " of resource collisions\n", dev->dev.bus_id);
1170 + return -EINVAL;
1171 + }
1172 + if (r->flags & IORESOURCE_IO)
1173 + cmd |= PCI_COMMAND_IO;
1174 + if (r->flags & IORESOURCE_MEM)
1175 + cmd |= PCI_COMMAND_MEMORY;
1176 + }
1177 + if (dev->resource[PCI_ROM_RESOURCE].start)
1178 + cmd |= PCI_COMMAND_MEMORY;
1179 + if (cmd != old_cmd) {
1180 + printk("PCI: Enabling device %s (%04x -> %04x)\n", dev->dev.bus_id, old_cmd, cmd);
1181 + pci_write_config_word(dev, PCI_COMMAND, cmd);
1182 + }
1183 + return 0;
1184 +}
1185 +
1186 +/*
1187 + * static void layout_dev(struct pci_dev *dev)
1188 + *
1189 + * Layout memory and I/O for a device.
1190 + *
1191 + * Parameters:
1192 + *
1193 + * device - device to layout memory and I/O for.
1194 + */
1195 +
1196 +static void __init layout_dev(struct pci_dev *dev)
1197 +{
1198 + unsigned short cmd;
1199 + unsigned int base, mask, size, reg;
1200 + unsigned int alignto;
1201 + int i;
1202 +
1203 + /*
1204 + * Skip video cards if requested.
1205 + */
1206 + if (((dev->class >> 8 == PCI_CLASS_NOT_DEFINED_VGA) ||
1207 + (dev->class >> 8 == PCI_CLASS_DISPLAY_VGA) ||
1208 + (dev->class >> 8 == PCI_CLASS_DISPLAY_XGA)) && skip_vga){
1209 + printk("%s: VGA\n",__FUNCTION__);
1210 + return;
1211 + }
1212 + pci_read_config_word(dev, PCI_COMMAND, &cmd);
1213 +
1214 + for (reg = PCI_BASE_ADDRESS_0, i = 0; reg <= PCI_BASE_ADDRESS_5; reg += 4, i++)
1215 + {
1216 + /*
1217 + * Figure out how much space and of what type this
1218 + * device wants.
1219 + */
1220 +
1221 + pci_write_config_dword(dev, reg, 0xffffffff);
1222 + pci_read_config_dword(dev, reg, &base);
1223 + if (!base)
1224 + {
1225 + /* this base-address register is unused */
1226 + dev->resource[i].start = 0;
1227 + dev->resource[i].end = 0;
1228 + dev->resource[i].flags = 0;
1229 + continue;
1230 + }
1231 +
1232 + /*
1233 + * We've read the base address register back after
1234 + * writing all ones and so now we must decode it.
1235 + */
1236 +
1237 + if (base & PCI_BASE_ADDRESS_SPACE_IO)
1238 + {
1239 + /*
1240 + * I/O space base address register.
1241 + */
1242 +
1243 + cmd |= PCI_COMMAND_IO;
1244 +
1245 + base &= PCI_BASE_ADDRESS_IO_MASK;
1246 + mask = (~base << 1) | 0x1;
1247 + size = (mask & base) & 0xffffffff;
1248 +
1249 + /*
1250 + * Align to multiple of size of minimum base.
1251 + */
1252 +
1253 +#ifdef CONFIG_COLDFIRE
1254 + alignto = MAX(PAGE_SIZE, size) ;
1255 +#else /* CONFIG_COLDFIRE */
1256 + alignto = MAX(0x040, size) ;
1257 +#endif /* CONFIG_COLDFIRE */
1258 + base = ALIGN(io_base, alignto);
1259 + io_base = base + size;
1260 + pci_write_config_dword(dev, reg, base | PCI_BASE_ADDRESS_SPACE_IO);
1261 +
1262 + dev->resource[i].start = base;
1263 + dev->resource[i].end = dev->resource[i].start + size - 1;
1264 + dev->resource[i].flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
1265 +
1266 + DBG_DEVS(("layout_dev: IO address: %x\n", base));
1267 + }
1268 + else
1269 + {
1270 + unsigned int type;
1271 +
1272 + /*
1273 + * Memory space base address register.
1274 + */
1275 +
1276 + cmd |= PCI_COMMAND_MEMORY;
1277 + type = base & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
1278 + base &= PCI_BASE_ADDRESS_MEM_MASK;
1279 + mask = (~base << 1) | 0x1;
1280 + size = (mask & base) & 0xffffffff;
1281 + switch (type)
1282 + {
1283 + case PCI_BASE_ADDRESS_MEM_TYPE_32:
1284 + case PCI_BASE_ADDRESS_MEM_TYPE_64:
1285 + break;
1286 +
1287 + case PCI_BASE_ADDRESS_MEM_TYPE_1M:
1288 + printk("bios32 WARNING: slot %d, function %d "
1289 + "requests memory below 1MB---don't "
1290 + "know how to do that.\n",
1291 + PCI_SLOT(dev->devfn),
1292 + PCI_FUNC(dev->devfn));
1293 + continue;
1294 + }
1295 + DBG_DEVS(("%s MEM: base %x,type %x,mask %x,size %x\n",
1296 + __FUNCTION__, base, type, mask, size));
1297 + /*
1298 + * Align to multiple of size of minimum base.
1299 + */
1300 +
1301 + alignto = max_t(unsigned int, 0x1000, size);
1302 + base = ALIGN(mem_base, alignto);
1303 + mem_base = base + size;
1304 + pci_write_config_dword(dev, reg, base);
1305 +
1306 + dev->resource[i].start = base;
1307 + dev->resource[i].end = dev->resource[i].start + size - 1;
1308 + dev->resource[i].flags = IORESOURCE_MEM;
1309 + DBG_DEVS(("%s MEM :base %x,size %x\n",
1310 + __FUNCTION__, base, size));
1311 + if (type == PCI_BASE_ADDRESS_MEM_TYPE_64)
1312 + {
1313 + /*
1314 + * 64-bit address, set the highest 32 bits
1315 + * to zero.
1316 + */
1317 +
1318 + reg += 4;
1319 + pci_write_config_dword(dev, reg, 0);
1320 +
1321 + i++;
1322 + dev->resource[i].start = 0;
1323 + dev->resource[i].end = 0;
1324 + dev->resource[i].flags = 0;
1325 + printk("%s:type == 64\n",__FUNCTION__);
1326 + }
1327 + }
1328 + }
1329 +
1330 + /*
1331 + * Enable device:
1332 + */
1333 +
1334 + if (dev->class >> 8 == PCI_CLASS_NOT_DEFINED ||
1335 + dev->class >> 8 == PCI_CLASS_NOT_DEFINED_VGA ||
1336 + dev->class >> 8 == PCI_CLASS_DISPLAY_VGA ||
1337 + dev->class >> 8 == PCI_CLASS_DISPLAY_XGA)
1338 + {
1339 + /*
1340 + * All of these (may) have I/O scattered all around
1341 + * and may not use i/o-base address registers at all.
1342 + * So we just have to always enable I/O to these
1343 + * devices.
1344 + */
1345 + cmd |= PCI_COMMAND_IO;
1346 + }
1347 +
1348 + pci_write_config_word(dev, PCI_COMMAND, cmd | PCI_COMMAND_MASTER);
1349 +
1350 + pci_write_config_byte(dev, PCI_LATENCY_TIMER, (disable_pci_burst) ? 0 : 32);
1351 +
1352 + if (bus_info != NULL)
1353 + bus_info->conf_device(dev); /* Machine dependent configuration. */
1354 +
1355 + printk(KERN_INFO "layout_dev: bus %d slot 0x%x VID 0x%x DID 0x%x class 0x%x\n",
1356 + dev->bus->number, PCI_SLOT(dev->devfn),
1357 + dev->vendor, dev->device, dev->class);
1358 +}
1359 +
1360 +/*
1361 + * static void layout_bus(struct pci_bus *bus)
1362 + *
1363 + * Layout memory and I/O for all devices on the given bus.
1364 + *
1365 + * Parameters:
1366 + *
1367 + * bus - bus.
1368 + */
1369 +
1370 +static void __init layout_bus(struct pci_bus *bus)
1371 +{
1372 + unsigned int bio, bmem;
1373 + struct pci_dev *dev;
1374 +
1375 + DBG_DEVS(("layout_bus: starting bus %d\n", bus->number));
1376 +
1377 + if (list_empty(&bus->devices) && list_empty(&bus->children))
1378 + return;
1379 +
1380 + /*
1381 + * Align the current bases on appropriate boundaries (4K for
1382 + * IO and 1MB for memory).
1383 + */
1384 +
1385 + bio = io_base = ALIGN(io_base, 4*KB);
1386 + bmem = mem_base = ALIGN(mem_base, 1*MB);
1387 +
1388 + /*
1389 + * PCI devices might have been setup by a PCI BIOS emulation
1390 + * running under TOS. In these cases there is a
1391 + * window during which two devices may have an overlapping
1392 + * address range. To avoid this causing trouble, we first
1393 + * turn off the I/O and memory address decoders for all PCI
1394 + * devices. They'll be re-enabled only once all address
1395 + * decoders are programmed consistently.
1396 + */
1397 +
1398 + DBG_DEVS(("layout_bus: disable_dev for bus %d\n", bus->number));
1399 +
1400 +#ifdef NL_ORIGINAL
1401 + for (dev = bus->devices; dev; dev = dev->sibling)
1402 +#else
1403 + dev = NULL;
1404 + while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL)
1405 +#endif
1406 + {
1407 + if ((dev->class >> 16 != PCI_BASE_CLASS_BRIDGE) ||
1408 + (dev->class >> 8 == PCI_CLASS_BRIDGE_PCMCIA))
1409 + disable_dev(dev);
1410 + }
1411 +
1412 + /*
1413 + * Allocate space to each device:
1414 + */
1415 +
1416 + DBG_DEVS(("layout_bus: starting bus %d devices\n", bus->number));
1417 +
1418 +#ifdef NL_ORIGINAL
1419 + for (dev = bus->devices; dev; dev = dev->sibling)
1420 +#else
1421 + dev = NULL;
1422 + while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL)
1423 +#endif
1424 + {
1425 + if ((dev->class >> 16 != PCI_BASE_CLASS_BRIDGE) ||
1426 + (dev->class >> 8 == PCI_CLASS_BRIDGE_PCMCIA))
1427 + layout_dev(dev);
1428 + }
1429 +
1430 + DBG_DEVS(("layout_bus: bus %d finished\n", bus->number));
1431 +}
1432 +
1433 +/*
1434 + * static void pcibios_fixup(void)
1435 + *
1436 + * Layout memory and I/O of all devices on the PCI bus if 'pci_modify' is
1437 + * true. This might be necessary because not every m68k machine with a PCI
1438 + * bus has a PCI BIOS. This function should be called right after
1439 + * pci_scan_bus() in pcibios_init().
1440 + */
1441 +
1442 +static void __init pcibios_fixup(void)
1443 +{
1444 + DBG_DEVS(("%s\n", __FUNCTION__));
1445 + if (pci_modify)
1446 + {
1447 + /*
1448 + * Set base addresses for allocation of I/O and memory space.
1449 + */
1450 +
1451 + io_base = bus_info->io_space.start + IO_ALLOC_OFFSET;
1452 + mem_base = bus_info->mem_space.start + MEM_ALLOC_OFFSET;
1453 +
1454 + /*
1455 + * Scan the tree, allocating PCI memory and I/O space.
1456 + */
1457 +
1458 +#ifdef NL_ORIGINAL
1459 + layout_bus(pci_bus_b(pci_root.next));
1460 +#else
1461 + layout_bus(pci_bus_b(pci_root_buses.next));
1462 +#endif
1463 + }
1464 +
1465 + /*
1466 + * Fix interrupt assignments, etc.
1467 + */
1468 +
1469 + bus_info->fixup(pci_modify);
1470 +}
1471 +
1472 +/*
1473 + * static void pcibios_claim_resources(struct pci_bus *bus)
1474 + *
1475 + * Claim all resources that are assigned to devices on the given bus.
1476 + *
1477 + * Parameters:
1478 + *
1479 + * bus - bus.
1480 + */
1481 +
1482 +static void __init pcibios_claim_resources(struct pci_bus *bus)
1483 +{
1484 + struct pci_dev *dev;
1485 + int i;
1486 + DBG_DEVS(("%s\n", __FUNCTION__));
1487 +#ifdef NL_ORIGINAL
1488 + while (bus)
1489 +#else
1490 + while ((bus = pci_find_next_bus(bus)) != NULL)
1491 +#endif
1492 + {
1493 +
1494 +#ifdef NL_ORIGINAL
1495 + for (dev = bus->devices; (dev != NULL); dev = dev->sibling)
1496 +#else
1497 + dev = NULL;
1498 + while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL)
1499 +#endif
1500 + {
1501 + for (i = 0; i < PCI_NUM_RESOURCES; i++)
1502 + {
1503 + struct resource *r = &dev->resource[i];
1504 + struct resource *pr;
1505 + struct pci_bus_info *bus_info =
1506 + (struct pci_bus_info *) dev->sysdata;
1507 +
1508 + if ((r->start == 0) || (r->parent != NULL))
1509 + continue;
1510 +
1511 +#ifdef CONFIG_COLDFIRE
1512 + if (dev->class >> 16 == PCI_BASE_CLASS_BRIDGE)
1513 + continue;
1514 +#endif /* CONFIG_COLDFIRE */
1515 +#if 1
1516 + if (r->flags & IORESOURCE_IO)
1517 + pr = &bus_info->io_space;
1518 + else
1519 + pr = &bus_info->mem_space;
1520 +#else
1521 + if (r->flags & IORESOURCE_IO)
1522 + pr = &ioport_resource;
1523 + else
1524 + pr = &iomem_resource;
1525 +#endif
1526 + if (request_resource(pr, r) < 0)
1527 + {
1528 +#ifdef NL_ORIGINAL
1529 + DBG_DEVS(("PCI: Address space collision on "
1530 + "region %d of device %s\n", i, dev->name));
1531 +#else
1532 + printk("PCI: Address space collision on region %d of device %s\n", i, dev->dev.bus_id);
1533 +#endif
1534 + }
1535 + }
1536 + }
1537 +
1538 +#ifdef NL_ORIGINAL
1539 + if (bus->children)
1540 + pcibios_claim_resources(bus->children);
1541 +#else
1542 + if (!list_empty(&bus->children))
1543 + pcibios_claim_resources(pci_bus_b(bus->children.next));
1544 +#endif
1545 +
1546 +#ifdef NL_ORIGINAL
1547 + bus = bus->next;
1548 +#endif
1549 + }
1550 +}
1551 +
1552 +/*
1553 + * int pcibios_assign_resource(struct pci_dev *dev, int i)
1554 + *
1555 + * Assign a new address to a PCI resource.
1556 + *
1557 + * Parameters:
1558 + *
1559 + * dev - device.
1560 + * i - resource.
1561 + *
1562 + * Result: 0 if successful.
1563 + */
1564 +
1565 +int __init pcibios_assign_resource(struct pci_dev *dev, int i)
1566 +{
1567 + struct resource *r = &dev->resource[i];
1568 + struct resource *pr = pci_find_parent_resource(dev, r);
1569 + unsigned long size = r->end + 1;
1570 + DBG_DEVS(("%s:IO_ALLOC_OFFSET %x\n", __FUNCTION__, IO_ALLOC_OFFSET));
1571 + if (!pr)
1572 + return -EINVAL;
1573 +
1574 + if (r->flags & IORESOURCE_IO)
1575 + {
1576 + DBG_DEVS(("%s:IORESOURCE_IO:start %x, size %lx\n",
1577 + __FUNCTION__, bus_info->io_space.start, size));
1578 + if (size > 0x100)
1579 + return -EFBIG;
1580 +
1581 +#ifdef NL_ORIGINAL
1582 + if (allocate_resource(pr, r, size, bus_info->io_space.start +
1583 + IO_ALLOC_OFFSET, bus_info->io_space.end, 1024))
1584 +#else
1585 + if (allocate_resource(pr, r, size, bus_info->io_space.start +
1586 + IO_ALLOC_OFFSET, bus_info->io_space.end, 1024, NULL, NULL))
1587 +#endif
1588 + return -EBUSY;
1589 + }
1590 + else
1591 + {
1592 + DBG_DEVS(("%s:IORESOURCE_MEM:start %x, size %lx\n",
1593 + __FUNCTION__, bus_info->mem_space.start, size));
1594 +#ifdef NL_ORIGINAL
1595 + if (allocate_resource(pr, r, size, bus_info->mem_space.start +
1596 + MEM_ALLOC_OFFSET, bus_info->mem_space.end, size))
1597 +#else
1598 + if (allocate_resource(pr, r, size, bus_info->io_space.start +
1599 + IO_ALLOC_OFFSET, bus_info->io_space.end, 1024, NULL, NULL))
1600 +#endif
1601 + return -EBUSY;
1602 + }
1603 +
1604 + if (i < 6)
1605 + pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, r->start);
1606 +
1607 + return 0;
1608 +}
1609 +
1610 +void pcibios_fixup_bus(struct pci_bus *bus)
1611 +{
1612 + struct pci_dev *dev;
1613 + void *sysdata;
1614 +
1615 + sysdata = (bus->parent) ? bus->parent->sysdata : bus->sysdata;
1616 +
1617 +#ifdef NL_ORIGINAL
1618 + for (dev = bus->devices; (dev != NULL); dev = dev->sibling)
1619 +#else
1620 + dev = NULL;
1621 + while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL)
1622 +#endif
1623 + dev->sysdata = sysdata;
1624 +}
1625 +
1626 +int __init pcibios_init(void)
1627 +{
1628 + printk("Linux/m68k PCI BIOS32 revision %x.%02x\n", MAJOR_REV, MINOR_REV);
1629 +
1630 + bus_info = NULL;
1631 +#ifdef CONFIG_COLDFIRE
1632 + bus_info = init_coldfire_pci();
1633 +#endif /* CONFIG_COLDFIRE */
1634 +#ifdef CONFIG_HADES
1635 + if (MACH_IS_HADES)
1636 + bus_info = init_hades_pci();
1637 +#endif
1638 + if (bus_info != NULL)
1639 + {
1640 + printk("PCI: Probing PCI hardware\n");
1641 + pci_scan_bus(0, bus_info->m68k_pci_ops, bus_info);
1642 + pcibios_fixup();
1643 +#ifdef NL_ORIGINAL
1644 + pcibios_claim_resources(pci_root);
1645 +#else
1646 + pcibios_claim_resources(pci_bus_b(pci_root_buses.next));
1647 +#endif
1648 + }
1649 + else
1650 + printk("PCI: No PCI bus detected\n");
1651 + return 0;
1652 +}
1653 +
1654 +subsys_initcall(pcibios_init);
1655 +
1656 +char * pcibios_setup(char *str)
1657 +{
1658 + if (!strcmp(str, "nomodify"))
1659 + {
1660 + pci_modify = 0;
1661 + return NULL;
1662 + }
1663 + else if (!strcmp(str, "skipvga"))
1664 + {
1665 + skip_vga = 1;
1666 + return NULL;
1667 + }
1668 + else if (!strcmp(str, "noburst"))
1669 + {
1670 + disable_pci_burst = 1;
1671 + return NULL;
1672 + }
1673 +
1674 + return str;
1675 +}
1676 +#endif /* CONFIG_PCI */
1677 --- a/arch/m68k/kernel/dma.c
1678 +++ b/arch/m68k/kernel/dma.c
1679 @@ -11,13 +11,24 @@
1680 #include <linux/kernel.h>
1681 #include <linux/scatterlist.h>
1682 #include <linux/vmalloc.h>
1683 -
1684 +#include <linux/pci.h>
1685 #include <asm/pgalloc.h>
1686
1687 void *dma_alloc_coherent(struct device *dev, size_t size,
1688 dma_addr_t *handle, gfp_t flag)
1689 {
1690 -#ifndef CONFIG_M5445X
1691 +#if defined(CONFIG_M547X_8X) | defined(CONFIG_M54455)
1692 + /*
1693 + * On the M5445x platform the memory allocated with GFP_DMA
1694 + * is guaranteed to be DMA'able.
1695 + */
1696 + void *addr;
1697 +
1698 + size = PAGE_ALIGN(size);
1699 + addr = kmalloc(size, GFP_DMA);
1700 + *handle = virt_to_phys(addr);
1701 + return addr;
1702 +#else
1703 struct page *page, **map;
1704 pgprot_t pgprot;
1705 void *addr;
1706 @@ -56,17 +67,6 @@ void *dma_alloc_coherent(struct device *
1707 kfree(map);
1708
1709 return addr;
1710 -#else
1711 - /*
1712 - * On the M5445x platform the memory allocated with GFP_DMA
1713 - * is guaranteed to be DMA'able.
1714 - */
1715 - void *addr;
1716 -
1717 - size = PAGE_ALIGN(size);
1718 - addr = kmalloc(size, GFP_DMA);
1719 - *handle = virt_to_phys(addr);
1720 - return addr;
1721 #endif
1722 }
1723 EXPORT_SYMBOL(dma_alloc_coherent);
1724 @@ -75,10 +75,10 @@ void dma_free_coherent(struct device *de
1725 void *addr, dma_addr_t handle)
1726 {
1727 pr_debug("dma_free_coherent: %p, %x\n", addr, handle);
1728 -#ifndef CONFIG_M5445X
1729 - vfree(addr);
1730 -#else
1731 +#if defined(CONFIG_M547X_8X) | defined(CONFIG_M54455)
1732 kfree(addr);
1733 +#else
1734 + vfree(addr);
1735 #endif
1736 }
1737 EXPORT_SYMBOL(dma_free_coherent);
1738 --- a/arch/m68k/mm/kmap.c
1739 +++ b/arch/m68k/mm/kmap.c
1740 @@ -153,6 +153,10 @@ void __iomem *__ioremap(unsigned long ph
1741 */
1742 return (void __iomem *)physaddr;
1743 }
1744 + if ((physaddr >= 0xd0000000) && (physaddr + size < 0xd800ffff)) {
1745 + printk("ioremap:PCI 0x%lx,0x%lx(%d) - PCI area hit\n", physaddr, size, cacheflag);
1746 + return (void *)physaddr;
1747 + }
1748 #endif
1749
1750 #ifdef DEBUG
1751 @@ -284,7 +288,12 @@ void __iounmap(void *addr, unsigned long
1752 pgd_t *pgd_dir;
1753 pmd_t *pmd_dir;
1754 pte_t *pte_dir;
1755 -
1756 +#ifdef CONFIG_M547X_8X
1757 + if ((addr >= (void*)0xd0000000) && (addr + size < (void*)0xd800ffff)) {
1758 + printk("%s: PCI address\n",__FUNCTION__);
1759 + return;
1760 + }
1761 +#endif
1762 while ((long)size > 0) {
1763 pgd_dir = pgd_offset_k(virtaddr);
1764 if (pgd_bad(*pgd_dir)) {
1765 --- a/drivers/pci/access.c
1766 +++ b/drivers/pci/access.c
1767 @@ -23,6 +23,7 @@ static DEFINE_SPINLOCK(pci_lock);
1768 #define PCI_word_BAD (pos & 1)
1769 #define PCI_dword_BAD (pos & 3)
1770
1771 +#ifdef NL_ORIGINAL
1772 #define PCI_OP_READ(size,type,len) \
1773 int pci_bus_read_config_##size \
1774 (struct pci_bus *bus, unsigned int devfn, int pos, type *value) \
1775 @@ -37,7 +38,20 @@ int pci_bus_read_config_##size \
1776 spin_unlock_irqrestore(&pci_lock, flags); \
1777 return res; \
1778 }
1779 -
1780 +#else /* NL_ORIGINAL */
1781 +#define PCI_OP_READ(size,type,len) \
1782 +int pci_bus_read_config_##size \
1783 + (struct pci_bus *bus, unsigned int devfn, int pos, type *value) \
1784 +{ \
1785 + int res; \
1786 + unsigned long flags; \
1787 + if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \
1788 + spin_lock_irqsave(&pci_lock, flags); \
1789 + res = bus->ops->read(bus, devfn, pos, len, (u32 *)value); \
1790 + spin_unlock_irqrestore(&pci_lock, flags); \
1791 + return res; \
1792 +}
1793 +#endif /* NL_ORIGINAL */
1794 #define PCI_OP_WRITE(size,type,len) \
1795 int pci_bus_write_config_##size \
1796 (struct pci_bus *bus, unsigned int devfn, int pos, type value) \
1797 --- a/drivers/usb/host/Makefile
1798 +++ b/drivers/usb/host/Makefile
1799 @@ -6,7 +6,7 @@ ifeq ($(CONFIG_USB_DEBUG),y)
1800 EXTRA_CFLAGS += -DDEBUG
1801 endif
1802
1803 -obj-$(CONFIG_PCI) += pci-quirks.o
1804 +#obj-$(CONFIG_PCI) += pci-quirks.o
1805
1806 obj-$(CONFIG_USB_EHCI_HCD) += ehci-hcd.o
1807 obj-$(CONFIG_USB_ISP116X_HCD) += isp116x-hcd.o
1808 --- /dev/null
1809 +++ b/include/asm-m68k/5445x_pci.h
1810 @@ -0,0 +1,94 @@
1811 +/*
1812 + * asm-m68k/pci.h - m68k specific PCI declarations.
1813 + *
1814 + * Coldfire Implementation Copyright (c) 2007 Freescale Semiconductor, Inc.
1815 + * Kurt Mahan <kmahan@freescale.com>
1816 + */
1817 +#ifndef _ASM_M68K_5445X_PCI_H
1818 +#define _ASM_M68K_5445x_PCI_H
1819 +
1820 +#ifndef CONFIG_PCI
1821 +/*
1822 + * The PCI address space does equal the physical memory
1823 + * address space. The networking and block device layers use
1824 + * this boolean for bounce buffer decisions.
1825 + */
1826 +#define PCI_DMA_BUS_IS_PHYS (1)
1827 +#else
1828 +#include <asm-generic/pci-dma-compat.h>
1829 +
1830 +/*
1831 + * The PCI address space does equal the physical memory
1832 + * address space. The networking and block device layers use
1833 + * this boolean for bounce buffer decisions.
1834 + */
1835 +#define PCI_DMA_BUS_IS_PHYS (1)
1836 +
1837 +#define PCIBIOS_MIN_IO 0x00004000
1838 +#define PCIBIOS_MIN_MEM 0x02000000
1839 +
1840 +#define pcibios_assign_all_busses() 0
1841 +#define pcibios_scan_all_fns(a, b) 0
1842 +
1843 +static inline void
1844 +pcibios_set_master(struct pci_dev *dev)
1845 +{
1846 + /* no special bus mastering setup handling */
1847 +}
1848 +
1849 +static inline void
1850 +pcibios_penalize_isa_irq(int irq, int active)
1851 +{
1852 + /* no dynamic PCI IRQ allocation */
1853 +}
1854 +
1855 +#if 0
1856 +static inline void
1857 +pcibios_add_platform_entries(struct pci_dev *dev)
1858 +{
1859 + /* no special handling */
1860 +}
1861 +#endif
1862 +
1863 +static inline void
1864 +pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
1865 + struct resource *res)
1866 +{
1867 +#ifdef CONFIG_M54455
1868 + if ((res->start == 0xa0000000) || (res->start == 0xa8000000)) {
1869 + /* HACK! FIX! kludge to fix bridge mapping */
1870 + region->start = res->start & 0x0fffffff;
1871 + region->end = res->end & 0x0fffffff;
1872 + } else {
1873 + region->start = res->start;
1874 + region->end = res->end;
1875 + }
1876 +#else
1877 + region->start = res->start;
1878 + region->end = res->end;
1879 +#endif
1880 +}
1881 +
1882 +static inline void
1883 +pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
1884 + struct pci_bus_region *region)
1885 +{
1886 + res->start = region->start;
1887 + res->end = region->end;
1888 +}
1889 +
1890 +static inline struct resource *
1891 +pcibios_select_root(struct pci_dev *pdev, struct resource *res)
1892 +{
1893 + struct resource *root = NULL;
1894 +
1895 + if (res->flags & IORESOURCE_IO)
1896 + root = &ioport_resource;
1897 + if (res->flags & IORESOURCE_MEM)
1898 + root = &iomem_resource;
1899 +
1900 + return root;
1901 +}
1902 +
1903 +#endif /* CONFIG_PCI */
1904 +#endif /* _ASM_M68K_5445X_PCI_H */
1905 --- /dev/null
1906 +++ b/include/asm-m68k/548x_pci.h
1907 @@ -0,0 +1,99 @@
1908 +#ifndef _ASM_M68K_548X_PCI_H
1909 +#define _ASM_M68K_548X_PCI_H
1910 +
1911 +/*
1912 + * asm-m68k/pci_m68k.h - m68k specific PCI declarations.
1913 + *
1914 + * Written by Wout Klaren.
1915 + */
1916 +#include <linux/mm.h>
1917 +#include <asm/scatterlist.h>
1918 +
1919 +#include <asm-generic/pci.h>
1920 +
1921 +struct pci_ops;
1922 +
1923 +/*
1924 + * Structure with hardware dependent information and functions of the
1925 + * PCI bus.
1926 + */
1927 +
1928 +struct pci_bus_info
1929 +{
1930 + /*
1931 + * Resources of the PCI bus.
1932 + */
1933 +
1934 + struct resource mem_space;
1935 + struct resource io_space;
1936 +
1937 + /*
1938 + * System dependent functions.
1939 + */
1940 +
1941 + struct pci_ops *m68k_pci_ops;
1942 +
1943 + void (*fixup)(int pci_modify);
1944 + void (*conf_device)(struct pci_dev *dev);
1945 +};
1946 +
1947 +#define pcibios_assign_all_busses() 0
1948 +#define pcibios_scan_all_fns(a, b) 0
1949 +
1950 +static inline void pcibios_set_master(struct pci_dev *dev)
1951 +{
1952 + /* No special bus mastering setup handling */
1953 +}
1954 +
1955 +static inline void pcibios_penalize_isa_irq(int irq)
1956 +{
1957 + /* We don't do dynamic PCI IRQ allocation */
1958 +}
1959 +
1960 +#ifndef CONFIG_COLDFIRE
1961 +/* The PCI address space does equal the physical memory
1962 + * address space. The networking and block device layers use
1963 + * this boolean for bounce buffer decisions.
1964 + */
1965 +#define PCI_DMA_BUS_IS_PHYS (1)
1966 +
1967 +#define PCIBIOS_MIN_IO 0x00004000
1968 +#define PCIBIOS_MIN_MEM 0x04000000
1969 +
1970 +#else /* !CONFIG_COLDFIRE */
1971 +#include <asm-generic/pci-dma-compat.h>
1972 +#define PCI_DMA_BASE /*0x40000000*/0 /* PCI-DMA window base */
1973 +
1974 +extern struct pci_bus_info *__init init_coldfire_pci(void);
1975 +extern void * pci_alloc_son(struct pci_dev *, size_t,
1976 + dma_addr_t *, int);
1977 +/*
1978 + * The PCI address space equal the virtual memory
1979 + * address space on m547X/m548X.
1980 + */
1981 +#define PCI_DMA_BUS_IS_PHYS (1)
1982 +
1983 +#define PCIBIOS_MIN_IO 0x00000100
1984 +#define PCIBIOS_MIN_MEM 0x02000000
1985 +
1986 +struct scatterlist;
1987 +
1988 +
1989 +/* This is always fine. */
1990 +#define pci_dac_dma_supported(pci_dev, mask) (1)
1991 +
1992 +
1993 +/* These macros should be used after a pci_map_sg call has been done
1994 + * to get bus addresses of each of the SG entries and their lengths.
1995 + * You should only work with the number of sg entries pci_map_sg
1996 + * returns.
1997 + */
1998 +#define sg_dma_address(sg) ((sg)->dma_address)
1999 +#define sg_dma_len(sg) ((sg)->length)
2000 +
2001 +static inline void pcibios_align_resource(void *data, struct resource *res, unsigned long size, unsigned long align)
2002 +{
2003 +}
2004 +
2005 +#endif /* !CONFIG_COLDFIRE*/
2006 +#endif /* _ASM_M68K_548X_PCI_H */
2007 --- a/include/asm-m68k/io.h
2008 +++ b/include/asm-m68k/io.h
2009 @@ -204,6 +204,12 @@ static inline u16 __iomem *isa_mtw(unsig
2010 #define isa_outw(val,port) (ISA_SEX ? out_be16(isa_itw(port),(val)) : out_le16(isa_itw(port),(val)))
2011 #define isa_outl(val,port) (ISA_SEX ? out_be32(isa_itl(port),(val)) : out_le32(isa_itl(port),(val)))
2012
2013 +#ifndef CONFIG_COLDFIRE
2014 +#define isa_readb(p) in_8(isa_mtb(p))
2015 +#define isa_readw(p) (ISA_SEX ? in_be16(isa_mtw(p)) : in_le16(isa_mtw(p)))
2016 +#define isa_writeb(val,p) out_8(isa_mtb(p),(val))
2017 +#define isa_writew(val,p) (ISA_SEX ? out_be16(isa_mtw(p),(val)) : out_le16(isa_mtw(p),(val)))
2018 +#else
2019 #define isa_readb(p) in_8(isa_mtb((unsigned long)(p)))
2020 #define isa_readw(p) \
2021 (ISA_SEX ? in_be16(isa_mtw((unsigned long)(p))) \
2022 @@ -212,7 +218,7 @@ static inline u16 __iomem *isa_mtw(unsig
2023 #define isa_writew(val,p) \
2024 (ISA_SEX ? out_be16(isa_mtw((unsigned long)(p)),(val)) \
2025 : out_le16(isa_mtw((unsigned long)(p)),(val)))
2026 -
2027 +#endif
2028 static inline void isa_delay(void)
2029 {
2030 switch(ISA_TYPE)
2031 @@ -285,6 +291,29 @@ static inline void isa_delay(void)
2032 #endif /* CONFIG_ISA */
2033
2034 #if defined(CONFIG_PCI)
2035 +#ifdef CONFIG_COLDFIRE
2036 +#define inb_p inb
2037 +#define inw_p inw
2038 +#define inl_p inl
2039 +#define outb_p outb
2040 +#define outw_p outw
2041 +#define outl_p outl
2042 +
2043 +unsigned char pci_inb(long addr);
2044 +unsigned short pci_inw(long addr);
2045 +unsigned long pci_inl(long addr);
2046 +void pci_outb(unsigned char val, long addr);
2047 +void pci_outw(unsigned short val, long addr);
2048 +void pci_outl(unsigned long val, long addr);
2049 +
2050 +void pci_insb(volatile unsigned char* addr, unsigned char* buf, int len);
2051 +void pci_insw(volatile unsigned short* addr, unsigned short* buf, int len);
2052 +void pci_insl(volatile unsigned long* addr, unsigned long* buf, int len);
2053 +
2054 +void pci_outsb(volatile unsigned char* addr, const unsigned char* buf, int len);
2055 +void pci_outsw(volatile unsigned short* addr, const unsigned short* buf, int len);
2056 +void pci_outsl(volatile unsigned long* addr, const unsigned long* buf, int len);
2057 +#endif
2058
2059 #define readl(addr) in_le32(addr)
2060 #define writel(val,addr) out_le32((addr),(val))
2061 @@ -300,6 +329,7 @@ static inline void isa_delay(void)
2062 #define readl_relaxed(addr) readl(addr)
2063
2064 #ifndef CONFIG_ISA
2065 +#ifndef CONFIG_COLDFIRE
2066 #define inb(port) in_8(port)
2067 #define outb(val,port) out_8((port),(val))
2068 #define inw(port) in_le16(port)
2069 @@ -319,6 +349,30 @@ static inline void isa_delay(void)
2070 #define outsl(port, buf, nr) \
2071 raw_outsw_swapw((u16 *)(port), (u16 *)(buf), (nr)<<1)
2072 #else
2073 +#define inb(port) pci_inb(port)
2074 +#define outb(val,port) pci_outb((val),(port))
2075 +#define inw(port) pci_inw(port)
2076 +#define outw(val,port) pci_outw((val),(port))
2077 +#define insb(a,b,c) pci_insb((volatile unsigned char*)a,(unsigned char*)b,c)
2078 +#define insw(a,b,c) pci_insw((volatile unsigned short*)a,(const unsigned short*)b,c)
2079 +#define insl(a,b,c) pci_insl((volatile unsigned long*)a,(const unsigned long*)b,c)
2080 +#define outsb(a,b,c) pci_outsb((volatile unsigned char*)a,(const unsigned char*)b,c)
2081 +#define outsw(a,b,c) pci_outsw((volatile unsigned short*)a,(const unsigned short*)b,c)
2082 +#define outsl(a,b,c) pci_outsl((volatile unsigned long*)a,(const unsigned long*)b,c)
2083 +#define inl(port) pci_inl(port)
2084 +#define outl(val,port) pci_outl((val),(port))
2085 +#endif
2086 +
2087 +#ifndef CONFIG_COLDFIRE
2088 +#define __raw_readb readb
2089 +#define __raw_readw readw
2090 +#define __raw_readl readl
2091 +#define __raw_writeb writeb
2092 +#define __raw_writew writew
2093 +#define __raw_writel writel
2094 +#endif
2095 +
2096 +#else
2097 /*
2098 * kernel with both ISA and PCI compiled in, those have
2099 * conflicting defs for in/out. Simply consider port < 1024
2100 @@ -432,6 +486,15 @@ static inline void memcpy_toio(volatile
2101 #define xlate_dev_kmem_ptr(p) p
2102
2103 #ifdef CONFIG_COLDFIRE
2104 +#define __raw_readb(addr) \
2105 + ({ unsigned char __v = (*(volatile unsigned char *) (addr)); __v; })
2106 +#define __raw_readw(addr) \
2107 + ({ unsigned short __v = (*(volatile unsigned short *) (addr)); __v; })
2108 +#define __raw_readl(addr) \
2109 + ({ unsigned long __v = (*(volatile unsigned long *) (addr)); __v; })
2110 +#define __raw_writeb(b,addr) (void)((*(volatile unsigned char *) (addr)) = (b))
2111 +#define __raw_writew(b,addr) (void)((*(volatile unsigned short *) (addr)) = (b))
2112 +#define __raw_writel(b,addr) (void)((*(volatile unsigned int *) (addr)) = (b))
2113
2114 #define memset_io(a, b, c) memset((void *)(a), (b), (c))
2115 #define memcpy_fromio(a, b, c) memcpy((a), (void *)(b), (c))
2116 --- /dev/null
2117 +++ b/include/asm-m68k/m5485pci.h
2118 @@ -0,0 +1,330 @@
2119 +/*
2120 + * m5485pci.h -- ColdFire 547x/548x PCI controller support.
2121 + */
2122 +#ifndef __MCF548X_PCI_H__
2123 +#define __MCF548X_PCI_H__
2124 +
2125 +
2126 +/* PCI Type 0 Configuration Registers */
2127 +#define MCF_PCIIDR MCF_REG32(0x000B00) /* PCI Device ID/Vendor ID */
2128 +#define MCF_PCISCR MCF_REG32(0x000B04) /* PCI Status/Command */
2129 +#define MCF_PCICCRIR MCF_REG32(0x000B08) /* PCI Class Code / Revision ID */
2130 +#define MCF_PCICR1 MCF_REG32(0x000B0C) /* PCI Configuration 1 Register */
2131 +#define MCF_PCIBAR0 MCF_REG32(0x000B10) /* PCI Base Address Register 0 */
2132 +#define MCF_PCIBAR1 MCF_REG32(0x000B14) /* PCI Base Address Register 1 */
2133 +#define MCF_PCICCPR MCF_REG32(0x000B28) /* PCI Cardbus CIS Pointer */
2134 +#define MCF_PCISID MCF_REG32(0x000B2C) /* Subsystem ID/Subsystem Vendor ID*/
2135 +#define MCF_PCIERBAR MCF_REG32(0x000B30) /* PCI Expansion ROM */
2136 +#define MCF_PCICPR MCF_REG32(0x000B30) /* PCI Capabilities Pointer */
2137 +#define MCF_PCICR2 MCF_REG32(0x000B3C) /* PCI Configuration Register 2 */
2138 +
2139 +/* General Control/Status Registers */
2140 +#define MCF_PCIGSCR MCF_REG32(0x000B60) /* Global Status/Control Register */
2141 +#define MCF_PCITBATR0 MCF_REG32(0x000B64) /* Target Base Address Translation 0*/
2142 +#define MCF_PCITBATR1 MCF_REG32(0x000B68) /* Target Base Address Translation 1*/
2143 +#define MCF_PCITCR MCF_REG32(0x000B6C) /* Target Control Register */
2144 +#define MCF_PCIIW0BTAR MCF_REG32(0x000B70) /* Initiator Window 0 Base Address */
2145 +#define MCF_PCIIW1BTAR MCF_REG32(0x000B74) /* Initiator Window 1 Base Address */
2146 +#define MCF_PCIIW2BTAR MCF_REG32(0x000B78) /* Initiator Window 2 Base Address */
2147 +#define MCF_PCIIWCR MCF_REG32(0x000B80) /* Initiator Window Configuration */
2148 +#define MCF_PCIICR MCF_REG32(0x000B84) /* Initiator Control Register */
2149 +#define MCF_PCIISR MCF_REG32(0x000B88) /* Initiator Status Register */
2150 +#define MCF_PCICAR MCF_REG32(0x000BF8) /* Configuration Address Register */
2151 +
2152 +/* CommBus FIFO Transmit Interface Registers */
2153 +#define MCF_PCITPSR MCF_REG32(0x008400) /* Tx Packet Size Register */
2154 +#define MCF_PCITSAR MCF_REG32(0x008404) /* Tx Start Address Register */
2155 +#define MCF_PCITTCR MCF_REG32(0x008408) /* Tx Transaction Control Register */
2156 +#define MCF_PCITER MCF_REG32(0x00840C) /* Tx Enables Register */
2157 +#define MCF_PCITNAR MCF_REG32(0x008410) /* Tx Next Address Register */
2158 +#define MCF_PCITLWR MCF_REG32(0x008414) /* Tx Last Word Register */
2159 +#define MCF_PCITDCR MCF_REG32(0x008418) /* Tx Done Counts Register */
2160 +#define MCF_PCITSR MCF_REG32(0x00841C) /* Tx Status Register */
2161 +#define MCF_PCITFDR MCF_REG32(0x008440) /* Tx FIFO Data Register */
2162 +#define MCF_PCITFSR MCF_REG32(0x008444) /* Tx FIFO Status Register */
2163 +#define MCF_PCITFCR MCF_REG32(0x008448) /* Tx FIFO Control Register */
2164 +#define MCF_PCITFAR MCF_REG32(0x00844C) /* Tx FIFO Alarm Register */
2165 +#define MCF_PCITFRPR MCF_REG32(0x008450) /* Tx FIFO Read Pointer Register */
2166 +#define MCF_PCITFWPR MCF_REG32(0x008454) /* Tx FIFO Write Pointer Register */
2167 +
2168 +/* CommBus FIFO Receive Interface Registers */
2169 +#define MCF_PCIRPSR MCF_REG32(0x008480) /* Tx Packet Size Register */
2170 +#define MCF_PCIRSAR MCF_REG32(0x008484) /* Tx Start Address Register */
2171 +#define MCF_PCIRTCR MCF_REG32(0x008488) /* Tx Transaction Control Register */
2172 +#define MCF_PCIRER MCF_REG32(0x00848C) /* Tx Enables Register */
2173 +#define MCF_PCIRNAR MCF_REG32(0x008490) /* Tx Next Address Register */
2174 +#define MCF_PCIRDCR MCF_REG32(0x008498) /* Tx Done Counts Register */
2175 +#define MCF_PCIRSR MCF_REG32(0x00849C) /* Tx Status Register */
2176 +#define MCF_PCIRFDR MCF_REG32(0x0084C0) /* Tx FIFO Data Register */
2177 +#define MCF_PCIRFSR MCF_REG32(0x0084C4) /* Tx FIFO Status Register */
2178 +#define MCF_PCIRFCR MCF_REG32(0x0084C8) /* Tx FIFO Control Register */
2179 +#define MCF_PCIRFAR MCF_REG32(0x0084CC) /* Tx FIFO Alarm Register */
2180 +#define MCF_PCIRFRPR MCF_REG32(0x0084D0) /* Tx FIFO Read Pointer Register */
2181 +#define MCF_PCIRFWPR MCF_REG32(0x0084D4) /* Tx FIFO Write Pointer Register */
2182 +
2183 +/* PCI Arbiter Registers */
2184 +#define MCF_PCIARB_PACR MCF_REG32(0x000C00)
2185 +#define MCF_PCIARB_PASR MCF_REG32(0x000C04)
2186 +
2187 +
2188 +/* Bit definitions and macros for MCF_PCIIDR */
2189 +#define MCF_PCIIDR_VENDORID(x) (((x)&0x0000FFFF)<<0)
2190 +#define MCF_PCIIDR_DEVICEID(x) (((x)&0x0000FFFF)<<16)
2191 +
2192 +/* Bit definitions and macros for MCF_PCISCR */
2193 +#define MCF_PCISCR_M (0x00000002)
2194 +#define MCF_PCISCR_B (0x00000004)
2195 +#define MCF_PCISCR_SP (0x00000008)
2196 +#define MCF_PCISCR_MW (0x00000010)
2197 +#define MCF_PCISCR_PER (0x00000040)
2198 +#define MCF_PCISCR_S (0x00000100)
2199 +#define MCF_PCISCR_F (0x00000200)
2200 +#define MCF_PCISCR_C (0x00100000)
2201 +#define MCF_PCISCR_66M (0x00200000)
2202 +#define MCF_PCISCR_R (0x00400000)
2203 +#define MCF_PCISCR_FC (0x00800000)
2204 +#define MCF_PCISCR_DP (0x01000000)
2205 +#define MCF_PCISCR_DT(x) (((x)&0x00000003)<<25)
2206 +#define MCF_PCISCR_TS (0x08000000)
2207 +#define MCF_PCISCR_TR (0x10000000)
2208 +#define MCF_PCISCR_MA (0x20000000)
2209 +#define MCF_PCISCR_SE (0x40000000)
2210 +#define MCF_PCISCR_PE (0x80000000)
2211 +
2212 +/* Bit definitions and macros for MCF_PCICCRIR */
2213 +#define MCF_PCICCRIR_REVID(x) (((x)&0x000000FF)<<0)
2214 +#define MCF_PCICCRIR_CLASSCODE(x) (((x)&0x00FFFFFF)<<8)
2215 +
2216 +/* Bit definitions and macros for MCF_PCICR1 */
2217 +#define MCF_PCICR1_CACHELINESIZE(x) (((x)&0x0000000F)<<0)
2218 +#define MCF_PCICR1_LATTIMER(x) (((x)&0x000000FF)<<8)
2219 +#define MCF_PCICR1_HEADERTYPE(x) (((x)&0x000000FF)<<16)
2220 +#define MCF_PCICR1_BIST(x) (((x)&0x000000FF)<<24)
2221 +
2222 +/* Bit definitions and macros for MCF_PCIBAR# */
2223 +#define MCF_PCIBAR0_ADDR(x) (((x)&0x00003FFF)<<18)
2224 +#define MCF_PCIBAR1_ADDR(x) (((x)&0x00000003)<<30)
2225 +
2226 +/* Bit definitions and macros for MCF_PCICR2 */
2227 +#define MCF_PCICR2_INTLINE(x) (((x)&0x000000FF)<<0)
2228 +#define MCF_PCICR2_INTPIN(x) (((x)&0x000000FF)<<8)
2229 +#define MCF_PCICR2_MINGNT(x) (((x)&0x000000FF)<<16)
2230 +#define MCF_PCICR2_MAXLAT(x) (((x)&0x000000FF)<<24)
2231 +
2232 +/* Bit definitions and macros for MCF_PCIGSCR */
2233 +#define MCF_PCIGSCR_PR (0x00000001)
2234 +#define MCF_PCIGSCR_SEE (0x00001000)
2235 +#define MCF_PCIGSCR_PEE (0x00002000)
2236 +#define MCF_PCIGSCR_SE (0x10000000)
2237 +#define MCF_PCIGSCR_PE (0x20000000)
2238 +
2239 +/* Bit definitions and macros for MCF_PCITBATR0 */
2240 +#define MCF_PCITBATR0_EN (0x00000001)
2241 +#define MCF_PCITBATR0_BAT0(x) (((x)&0x00003FFF)<<18)
2242 +
2243 +/* Bit definitions and macros for MCF_PCITBATR1 */
2244 +#define MCF_PCITBATR1_EN (0x00000001)
2245 +#define MCF_PCITBATR1_BAT1(x) (((x)&0x00000003)<<30)
2246 +
2247 +/* Bit definitions and macros for MCF_PCITCR */
2248 +#define MCF_PCITCR_P (0x00010000)
2249 +#define MCF_PCITCR_LD (0x01000000)
2250 +
2251 +/* Bit definitions and macros for MCF_PCIIW0BTAR */
2252 +#define MCF_PCIIW0BTAR_WTA0(x) (((x)&0x000000FF)<<8)
2253 +#define MCF_PCIIW0BTAR_WAM0(x) (((x)&0x000000FF)<<16)
2254 +#define MCF_PCIIW0BTAR_WBA0(x) (((x)&0x000000FF)<<24)
2255 +
2256 +/* Bit definitions and macros for MCF_PCIIW1BTAR */
2257 +#define MCF_PCIIW1BTAR_WTA1(x) (((x)&0x000000FF)<<8)
2258 +#define MCF_PCIIW1BTAR_WAM1(x) (((x)&0x000000FF)<<16)
2259 +#define MCF_PCIIW1BTAR_WBA1(x) (((x)&0x000000FF)<<24)
2260 +
2261 +/* Bit definitions and macros for MCF_PCIIW2BTAR */
2262 +#define MCF_PCIIW2BTAR_WTA2(x) (((x)&0x000000FF)<<8)
2263 +#define MCF_PCIIW2BTAR_WAM2(x) (((x)&0x000000FF)<<16)
2264 +#define MCF_PCIIW2BTAR_WBA2(x) (((x)&0x000000FF)<<24)
2265 +
2266 +/* Bit definitions and macros for MCF_PCIIWCR */
2267 +#define MCF_PCIIWCR_WINCTRL2(x) (((x)&0x0000000F)<<8)
2268 +#define MCF_PCIIWCR_WINCTRL1(x) (((x)&0x0000000F)<<16)
2269 +#define MCF_PCIIWCR_WINCTRL0(x) (((x)&0x0000000F)<<24)
2270 +#define MCF_PCIIWCR_WINCTRL0_MEMREAD (0x01000000)
2271 +#define MCF_PCIIWCR_WINCTRL0_MEMRDLINE (0x03000000)
2272 +#define MCF_PCIIWCR_WINCTRL0_MEMRDMUL (0x05000000)
2273 +#define MCF_PCIIWCR_WINCTRL0_IO (0x09000000)
2274 +#define MCF_PCIIWCR_WINCTRL0_E (0x01000000)
2275 +#define MCF_PCIIWCR_WINCTRL1_MEMREAD (0x00010000)
2276 +#define MCF_PCIIWCR_WINCTRL1_MEMRDLINE (0x00030000)
2277 +#define MCF_PCIIWCR_WINCTRL1_MEMRDMUL (0x00050000)
2278 +#define MCF_PCIIWCR_WINCTRL1_IO (0x00090000)
2279 +#define MCF_PCIIWCR_WINCTRL1_E (0x00010000)
2280 +#define MCF_PCIIWCR_WINCTRL2_MEMREAD (0x00000100)
2281 +#define MCF_PCIIWCR_WINCTRL2_MEMRDLINE (0x00000300)
2282 +#define MCF_PCIIWCR_WINCTRL2_MEMRDMUL (0x00000500)
2283 +#define MCF_PCIIWCR_WINCTRL2_IO (0x00000900)
2284 +#define MCF_PCIIWCR_WINCTRL2_E (0x00000100)
2285 +
2286 +
2287 +/* Bit definitions and macros for MCF_PCIICR */
2288 +#define MCF_PCIICR_MAXRETRY(x) (((x)&0x000000FF)<<0)
2289 +#define MCF_PCIICR_TAE (0x01000000)
2290 +#define MCF_PCIICR_IAE (0x02000000)
2291 +#define MCF_PCIICR_REE (0x04000000)
2292 +
2293 +/* Bit definitions and macros for MCF_PCIISR */
2294 +#define MCF_PCIISR_TA (0x01000000)
2295 +#define MCF_PCIISR_IA (0x02000000)
2296 +#define MCF_PCIISR_RE (0x04000000)
2297 +
2298 +/* Bit definitions and macros for MCF_PCICAR */
2299 +#define MCF_PCICAR_DWORD(x) (((x)&0x0000003F)<<2)
2300 +#define MCF_PCICAR_FUNCNUM(x) (((x)&0x00000007)<<8)
2301 +#define MCF_PCICAR_DEVNUM(x) (((x)&0x0000001F)<<11)
2302 +#define MCF_PCICAR_BUSNUM(x) (((x)&0x000000FF)<<16)
2303 +#define MCF_PCICAR_E (0x80000000)
2304 +
2305 +/* Bit definitions and macros for MCF_PCITPSR */
2306 +#define MCF_PCITPSR_PKTSIZE(x) (((x)&0x0000FFFF)<<16)
2307 +
2308 +/* Bit definitions and macros for MCF_PCITTCR */
2309 +#define MCF_PCITTCR_DI (0x00000001)
2310 +#define MCF_PCITTCR_W (0x00000010)
2311 +#define MCF_PCITTCR_MAXBEATS(x) (((x)&0x00000007)<<8)
2312 +#define MCF_PCITTCR_MAXRETRY(x) (((x)&0x000000FF)<<16)
2313 +#define MCF_PCITTCR_PCICMD(x) (((x)&0x0000000F)<<24)
2314 +
2315 +/* Bit definitions and macros for MCF_PCITER */
2316 +#define MCF_PCITER_NE (0x00010000)
2317 +#define MCF_PCITER_IAE (0x00020000)
2318 +#define MCF_PCITER_TAE (0x00040000)
2319 +#define MCF_PCITER_RE (0x00080000)
2320 +#define MCF_PCITER_SE (0x00100000)
2321 +#define MCF_PCITER_FEE (0x00200000)
2322 +#define MCF_PCITER_ME (0x01000000)
2323 +#define MCF_PCITER_BE (0x08000000)
2324 +#define MCF_PCITER_CM (0x10000000)
2325 +#define MCF_PCITER_RF (0x40000000)
2326 +#define MCF_PCITER_RC (0x80000000)
2327 +
2328 +/* Bit definitions and macros for MCF_PCITDCR */
2329 +#define MCF_PCITDCR_PKTSDONE(x) (((x)&0x0000FFFF)<<0)
2330 +#define MCF_PCITDCR_BYTESDONE(x) (((x)&0x0000FFFF)<<16)
2331 +
2332 +/* Bit definitions and macros for MCF_PCITSR */
2333 +#define MCF_PCITSR_IA (0x00010000)
2334 +#define MCF_PCITSR_TA (0x00020000)
2335 +#define MCF_PCITSR_RE (0x00040000)
2336 +#define MCF_PCITSR_SE (0x00080000)
2337 +#define MCF_PCITSR_FE (0x00100000)
2338 +#define MCF_PCITSR_BE1 (0x00200000)
2339 +#define MCF_PCITSR_BE2 (0x00400000)
2340 +#define MCF_PCITSR_BE3 (0x00800000)
2341 +#define MCF_PCITSR_NT (0x01000000)
2342 +
2343 +/* Bit definitions and macros for MCF_PCITFSR */
2344 +#define MCF_PCITFSR_EMT (0x00010000)
2345 +#define MCF_PCITFSR_ALARM (0x00020000)
2346 +#define MCF_PCITFSR_FU (0x00040000)
2347 +#define MCF_PCITFSR_FR (0x00080000)
2348 +#define MCF_PCITFSR_OF (0x00100000)
2349 +#define MCF_PCITFSR_UF (0x00200000)
2350 +#define MCF_PCITFSR_RXW (0x00400000)
2351 +
2352 +/* Bit definitions and macros for MCF_PCITFCR */
2353 +#define MCF_PCITFCR_OF_MSK (0x00080000)
2354 +#define MCF_PCITFCR_UF_MSK (0x00100000)
2355 +#define MCF_PCITFCR_RXW_MSK (0x00200000)
2356 +#define MCF_PCITFCR_FAE_MSK (0x00400000)
2357 +#define MCF_PCITFCR_IP_MSK (0x00800000)
2358 +#define MCF_PCITFCR_GR(x) (((x)&0x00000007)<<24)
2359 +
2360 +/* Bit definitions and macros for MCF_PCITFAR */
2361 +#define MCF_PCITFAR_ALARM(x) (((x)&0x0000007F)<<0)
2362 +
2363 +/* Bit definitions and macros for MCF_PCITFRPR */
2364 +#define MCF_PCITFRPR_READ(x) (((x)&0x00000FFF)<<0)
2365 +
2366 +/* Bit definitions and macros for MCF_PCITFWPR */
2367 +#define MCF_PCITFWPR_WRITE(x) (((x)&0x00000FFF)<<0)
2368 +
2369 +/* Bit definitions and macros for MCF_PCIRPSR */
2370 +#define MCF_PCIRPSR_PKTSIZE(x) (((x)&0x0000FFFF)<<16)
2371 +
2372 +/* Bit definitions and macros for MCF_PCIRTCR */
2373 +#define MCF_PCIRTCR_DI (0x00000001)
2374 +#define MCF_PCIRTCR_W (0x00000010)
2375 +#define MCF_PCIRTCR_MAXBEATS(x) (((x)&0x00000007)<<8)
2376 +#define MCF_PCIRTCR_FB (0x00001000)
2377 +#define MCF_PCIRTCR_MAXRETRY(x) (((x)&0x000000FF)<<16)
2378 +#define MCF_PCIRTCR_PCICMD(x) (((x)&0x0000000F)<<24)
2379 +
2380 +/* Bit definitions and macros for MCF_PCIRER */
2381 +#define MCF_PCIRER_NE (0x00010000)
2382 +#define MCF_PCIRER_IAE (0x00020000)
2383 +#define MCF_PCIRER_TAE (0x00040000)
2384 +#define MCF_PCIRER_RE (0x00080000)
2385 +#define MCF_PCIRER_SE (0x00100000)
2386 +#define MCF_PCIRER_FEE (0x00200000)
2387 +#define MCF_PCIRER_ME (0x01000000)
2388 +#define MCF_PCIRER_BE (0x08000000)
2389 +#define MCF_PCIRER_CM (0x10000000)
2390 +#define MCF_PCIRER_FE (0x20000000)
2391 +#define MCF_PCIRER_RF (0x40000000)
2392 +#define MCF_PCIRER_RC (0x80000000)
2393 +
2394 +/* Bit definitions and macros for MCF_PCIRDCR */
2395 +#define MCF_PCIRDCR_PKTSDONE(x) (((x)&0x0000FFFF)<<0)
2396 +#define MCF_PCIRDCR_BYTESDONE(x) (((x)&0x0000FFFF)<<16)
2397 +
2398 +/* Bit definitions and macros for MCF_PCIRSR */
2399 +#define MCF_PCIRSR_IA (0x00010000)
2400 +#define MCF_PCIRSR_TA (0x00020000)
2401 +#define MCF_PCIRSR_RE (0x00040000)
2402 +#define MCF_PCIRSR_SE (0x00080000)
2403 +#define MCF_PCIRSR_FE (0x00100000)
2404 +#define MCF_PCIRSR_BE1 (0x00200000)
2405 +#define MCF_PCIRSR_BE2 (0x00400000)
2406 +#define MCF_PCIRSR_BE3 (0x00800000)
2407 +#define MCF_PCIRSR_NT (0x01000000)
2408 +
2409 +/* Bit definitions and macros for MCF_PCIRFSR */
2410 +#define MCF_PCIRFSR_EMT (0x00010000)
2411 +#define MCF_PCIRFSR_ALARM (0x00020000)
2412 +#define MCF_PCIRFSR_FU (0x00040000)
2413 +#define MCF_PCIRFSR_FR (0x00080000)
2414 +#define MCF_PCIRFSR_OF (0x00100000)
2415 +#define MCF_PCIRFSR_UF (0x00200000)
2416 +#define MCF_PCIRFSR_RXW (0x00400000)
2417 +
2418 +/* Bit definitions and macros for MCF_PCIRFCR */
2419 +#define MCF_PCIRFCR_OF_MSK (0x00080000)
2420 +#define MCF_PCIRFCR_UF_MSK (0x00100000)
2421 +#define MCF_PCIRFCR_RXW_MSK (0x00200000)
2422 +#define MCF_PCIRFCR_FAE_MSK (0x00400000)
2423 +#define MCF_PCIRFCR_IP_MSK (0x00800000)
2424 +#define MCF_PCIRFCR_GR(x) (((x)&0x00000007)<<24)
2425 +
2426 +/* Bit definitions and macros for MCF_PCIRFAR */
2427 +#define MCF_PCIRFAR_ALARM(x) (((x)&0x0000007F)<<0)
2428 +
2429 +/* Bit definitions and macros for MCF_PCIRFRPR */
2430 +#define MCF_PCIRFRPR_READ(x) (((x)&0x00000FFF)<<0)
2431 +
2432 +/* Bit definitions and macros for MCF_PCIRFWPR */
2433 +#define MCF_PCIRFWPR_WRITE(x) (((x)&0x00000FFF)<<0)
2434 +
2435 +
2436 +/* Bit definitions and macros for MCF_PCIARB_PACR */
2437 +#define MCF_PCIARB_PACR_INTMPRI (0x00000001)
2438 +#define MCF_PCIARB_PACR_EXTMPRI(x) (((x)&0x0000001F)<<1)
2439 +#define MCF_PCIARB_PACR_INTMINTEN (0x00010000)
2440 +#define MCF_PCIARB_PACR_EXTMINTEN(x) (((x)&0x0000001F)<<17)
2441 +#define MCF_PCIARB_PACR_PKMD (0x40000000)
2442 +#define MCF_PCIARB_PACR_DS (0x80000000)
2443 +
2444 +/* Bit definitions and macros for MCF_PCIARB_PASR */
2445 +#define MCF_PCIARB_PASR_ITLMBK (0x00010000)
2446 +#define MCF_PCIARB_PASR_EXTMBK(x) (((x)&0x0000001F)<<17)
2447 +
2448 +#endif /* __MCF548X_PCI_H__ */
2449 --- a/include/asm-m68k/pci.h
2450 +++ b/include/asm-m68k/pci.h
2451 @@ -1,94 +1,10 @@
2452 -/*
2453 - * asm-m68k/pci.h - m68k specific PCI declarations.
2454 - *
2455 - * Coldfire Implementation Copyright (c) 2007 Freescale Semiconductor, Inc.
2456 - * Kurt Mahan <kmahan@freescale.com>
2457 - */
2458 -#ifndef _ASM_M68K_PCI_H
2459 -#define _ASM_M68K_PCI_H
2460 +#ifndef M68K_PCI_H
2461 +#define M68K_PCI_H
2462
2463 -#ifndef CONFIG_PCI
2464 -/*
2465 - * The PCI address space does equal the physical memory
2466 - * address space. The networking and block device layers use
2467 - * this boolean for bounce buffer decisions.
2468 - */
2469 -#define PCI_DMA_BUS_IS_PHYS (1)
2470 +#ifdef CONFIG_M5445X
2471 +#include "5445x_pci.h"
2472 #else
2473 -#include <asm-generic/pci-dma-compat.h>
2474 -
2475 -/*
2476 - * The PCI address space does equal the physical memory
2477 - * address space. The networking and block device layers use
2478 - * this boolean for bounce buffer decisions.
2479 - */
2480 -#define PCI_DMA_BUS_IS_PHYS (1)
2481 -
2482 -#define PCIBIOS_MIN_IO 0x00004000
2483 -#define PCIBIOS_MIN_MEM 0x02000000
2484 -
2485 -#define pcibios_assign_all_busses() 0
2486 -#define pcibios_scan_all_fns(a, b) 0
2487 -
2488 -static inline void
2489 -pcibios_set_master(struct pci_dev *dev)
2490 -{
2491 - /* no special bus mastering setup handling */
2492 -}
2493 -
2494 -static inline void
2495 -pcibios_penalize_isa_irq(int irq, int active)
2496 -{
2497 - /* no dynamic PCI IRQ allocation */
2498 -}
2499 -
2500 -#if 0
2501 -static inline void
2502 -pcibios_add_platform_entries(struct pci_dev *dev)
2503 -{
2504 - /* no special handling */
2505 -}
2506 +#include "548x_pci.h"
2507 #endif
2508
2509 -static inline void
2510 -pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
2511 - struct resource *res)
2512 -{
2513 -#ifdef CONFIG_M54455
2514 - if ((res->start == 0xa0000000) || (res->start == 0xa8000000)) {
2515 - /* HACK! FIX! kludge to fix bridge mapping */
2516 - region->start = res->start & 0x0fffffff;
2517 - region->end = res->end & 0x0fffffff;
2518 - } else {
2519 - region->start = res->start;
2520 - region->end = res->end;
2521 - }
2522 -#else
2523 - region->start = res->start;
2524 - region->end = res->end;
2525 -#endif
2526 -}
2527 -
2528 -static inline void
2529 -pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
2530 - struct pci_bus_region *region)
2531 -{
2532 - res->start = region->start;
2533 - res->end = region->end;
2534 -}
2535 -
2536 -static inline struct resource *
2537 -pcibios_select_root(struct pci_dev *pdev, struct resource *res)
2538 -{
2539 - struct resource *root = NULL;
2540 -
2541 - if (res->flags & IORESOURCE_IO)
2542 - root = &ioport_resource;
2543 - if (res->flags & IORESOURCE_MEM)
2544 - root = &iomem_resource;
2545 -
2546 - return root;
2547 -}
2548 -
2549 -#endif /* CONFIG_PCI */
2550 -#endif /* _ASM_M68K_PCI_H */
2551 +#endif /* M68K_PCI_H */
2552 --- a/include/asm-m68k/raw_io.h
2553 +++ b/include/asm-m68k/raw_io.h
2554 @@ -46,6 +46,29 @@ extern void __iounmap(void *addr, unsign
2555 #define out_le16(addr,w) (void)((*(__force volatile __le16 *) (addr)) = cpu_to_le16(w))
2556 #define out_le32(addr,l) (void)((*(__force volatile __le32 *) (addr)) = cpu_to_le32(l))
2557
2558 +#if (defined CONFIG_COLDFIRE) && (defined CONFIG_PCI)
2559 +unsigned char pci_inb(long addr);
2560 +unsigned short pci_inw(long addr);
2561 +unsigned long pci_inl(long addr);
2562 +void pci_outb(unsigned char val, long addr);
2563 +void pci_outw(unsigned short val, long addr);
2564 +void pci_outl(unsigned long val, long addr);
2565 +unsigned short pci_raw_inw(long addr);
2566 +unsigned long pci_raw_inl(long addr);
2567 +void pci_raw_outw(unsigned short val, long addr);
2568 +void pci_raw_outl(unsigned long val, long addr);
2569 +#define raw_inb(port) pci_inb((long)((volatile unsigned char *)(port)))
2570 +#define raw_inw(port) pci_raw_inw((long)((volatile unsigned short *)(port)))
2571 +#define raw_inl(port) pci_raw_inl((long)((volatile unsigned long *)(port)))
2572 +
2573 +#define raw_outb(val,port) pci_outb((val),(long)((volatile unsigned char *)(port)))
2574 +#define raw_outw(val,port) pci_raw_outw((val),(long)((volatile unsigned short *)(port)))
2575 +#define raw_outl(val,port) pci_raw_outl((val),(long)((volatile unsigned long *)(port)))
2576 +
2577 +#define swap_inw(port) pci_inw((long)((volatile unsigned short *)(port)))
2578 +#define swap_outw(val,port) pci_outw((val),(long)((volatile unsigned short *)(port)))
2579 +
2580 +#else
2581 #define raw_inb in_8
2582 #define raw_inw in_be16
2583 #define raw_inl in_be32
2584 @@ -60,6 +83,9 @@ extern void __iounmap(void *addr, unsign
2585 #define __raw_writew(val,addr) out_be16((addr),(val))
2586 #define __raw_writel(val,addr) out_be32((addr),(val))
2587
2588 +#define swap_inw(port) in_le16((port))
2589 +#define swap_outw(val,port) out_le16((port),(val))
2590 +#endif
2591 static inline void raw_insb(volatile u8 __iomem *port, u8 *buf, unsigned int len)
2592 {
2593 unsigned int i;
2594 --- a/include/asm-m68k/virtconvert.h
2595 +++ b/include/asm-m68k/virtconvert.h
2596 @@ -46,9 +46,14 @@ static inline void *phys_to_virt(unsigne
2597 #define virt_to_bus(a) (virt_to_phys(a) + (MACH_IS_HADES ? 0x80000000 : 0))
2598 #define bus_to_virt(a) (phys_to_virt((a) - (MACH_IS_HADES ? 0x80000000 : 0)))
2599 #else
2600 +#ifdef CONFIG_COLDFIRE
2601 +#define virt_to_bus(a) (a - PAGE_OFFSET + PCI_DMA_BASE)
2602 +#define bus_to_virt(a) (a - PCI_DMA_BASE + PAGE_OFFSET)
2603 +#else /* CONFIG_COLDFIRE */
2604 #define virt_to_bus virt_to_phys
2605 #define bus_to_virt phys_to_virt
2606 #endif
2607 +#endif
2608
2609 #endif
2610 #endif
2611 --- a/include/linux/pci.h
2612 +++ b/include/linux/pci.h
2613 @@ -458,8 +458,10 @@ int __must_check pcibios_enable_device(s
2614 char *pcibios_setup(char *str);
2615
2616 /* Used only when drivers/pci/setup.c is used */
2617 +#ifndef CONFIG_COLDFIRE
2618 void pcibios_align_resource(void *, struct resource *, resource_size_t,
2619 resource_size_t);
2620 +#endif
2621 void pcibios_update_irq(struct pci_dev *, int irq);
2622
2623 /* Generic PCI functions used internally */
Personal OpenWRT clone
This page took 0.175195 seconds and 5 git commands to generate.