projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'linux-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / arm / mach-iop13xx / pci.c
1 /*
2 * iop13xx PCI support
3 * Copyright (c) 2005-2006, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16 * Place - Suite 330, Boston, MA 02111-1307 USA.
17 *
18 */
19
20 #include <linux/pci.h>
21 #include <linux/slab.h>
22 #include <linux/delay.h>
23 #include <linux/jiffies.h>
24 #include <asm/irq.h>
25 #include <mach/hardware.h>
26 #include <asm/sizes.h>
27 #include <asm/signal.h>
28 #include <asm/mach/pci.h>
29 #include <mach/pci.h>
30
31 #define IOP13XX_PCI_DEBUG 0
32 #define PRINTK(x...) ((void)(IOP13XX_PCI_DEBUG && printk(x)))
33
34 u32 iop13xx_atux_pmmr_offset; /* This offset can change based on strapping */
35 u32 iop13xx_atue_pmmr_offset; /* This offset can change based on strapping */
36 static struct pci_bus *pci_bus_atux = 0;
37 static struct pci_bus *pci_bus_atue = 0;
38 u32 iop13xx_atue_mem_base;
39 u32 iop13xx_atux_mem_base;
40 size_t iop13xx_atue_mem_size;
41 size_t iop13xx_atux_mem_size;
42
43 EXPORT_SYMBOL(iop13xx_atue_mem_base);
44 EXPORT_SYMBOL(iop13xx_atux_mem_base);
45 EXPORT_SYMBOL(iop13xx_atue_mem_size);
46 EXPORT_SYMBOL(iop13xx_atux_mem_size);
47
48 int init_atu = 0; /* Flag to select which ATU(s) to initialize / disable */
49 static unsigned long atux_trhfa_timeout = 0; /* Trhfa = RST# high to first
50 access */
51
52 /* Scan the initialized busses and ioremap the requested memory range
53 */
54 void iop13xx_map_pci_memory(void)
55 {
56 int atu;
57 struct pci_bus *bus;
58 struct pci_dev *dev;
59 resource_size_t end = 0;
60
61 for (atu = 0; atu < 2; atu++) {
62 bus = atu ? pci_bus_atue : pci_bus_atux;
63 if (bus) {
64 list_for_each_entry(dev, &bus->devices, bus_list) {
65 int i;
66 int max = 7;
67
68 if (dev->subordinate)
69 max = DEVICE_COUNT_RESOURCE;
70
71 for (i = 0; i < max; i++) {
72 struct resource *res = &dev->resource[i];
73 if (res->flags & IORESOURCE_MEM)
74 end = max(res->end, end);
75 }
76 }
77
78 switch(atu) {
79 case 0:
80 iop13xx_atux_mem_size =
81 (end - IOP13XX_PCIX_LOWER_MEM_RA) + 1;
82
83 /* 16MB align the request */
84 if (iop13xx_atux_mem_size & (SZ_16M - 1)) {
85 iop13xx_atux_mem_size &= ~(SZ_16M - 1);
86 iop13xx_atux_mem_size += SZ_16M;
87 }
88
89 if (end) {
90 iop13xx_atux_mem_base =
91 (u32) __arm_ioremap_pfn(
92 __phys_to_pfn(IOP13XX_PCIX_LOWER_MEM_PA)
93 , 0, iop13xx_atux_mem_size, MT_DEVICE);
94 if (!iop13xx_atux_mem_base) {
95 printk("%s: atux allocation "
96 "failed\n", __func__);
97 BUG();
98 }
99 } else
100 iop13xx_atux_mem_size = 0;
101 PRINTK("%s: atu: %d bus_size: %d mem_base: %x\n",
102 __func__, atu, iop13xx_atux_mem_size,
103 iop13xx_atux_mem_base);
104 break;
105 case 1:
106 iop13xx_atue_mem_size =
107 (end - IOP13XX_PCIE_LOWER_MEM_RA) + 1;
108
109 /* 16MB align the request */
110 if (iop13xx_atue_mem_size & (SZ_16M - 1)) {
111 iop13xx_atue_mem_size &= ~(SZ_16M - 1);
112 iop13xx_atue_mem_size += SZ_16M;
113 }
114
115 if (end) {
116 iop13xx_atue_mem_base =
117 (u32) __arm_ioremap_pfn(
118 __phys_to_pfn(IOP13XX_PCIE_LOWER_MEM_PA)
119 , 0, iop13xx_atue_mem_size, MT_DEVICE);
120 if (!iop13xx_atue_mem_base) {
121 printk("%s: atue allocation "
122 "failed\n", __func__);
123 BUG();
124 }
125 } else
126 iop13xx_atue_mem_size = 0;
127 PRINTK("%s: atu: %d bus_size: %d mem_base: %x\n",
128 __func__, atu, iop13xx_atue_mem_size,
129 iop13xx_atue_mem_base);
130 break;
131 }
132
133 printk("%s: Initialized (%uM @ resource/virtual: %08lx/%08x)\n",
134 atu ? "ATUE" : "ATUX",
135 (atu ? iop13xx_atue_mem_size : iop13xx_atux_mem_size) /
136 SZ_1M,
137 atu ? IOP13XX_PCIE_LOWER_MEM_RA :
138 IOP13XX_PCIX_LOWER_MEM_RA,
139 atu ? iop13xx_atue_mem_base :
140 iop13xx_atux_mem_base);
141 end = 0;
142 }
143
144 }
145 }
146
147 static int iop13xx_atu_function(int atu)
148 {
149 int func = 0;
150 /* the function number depends on the value of the
151 * IOP13XX_INTERFACE_SEL_PCIX reset strap
152 * see C-Spec section 3.17
153 */
154 switch(atu) {
155 case IOP13XX_INIT_ATU_ATUX:
156 if (__raw_readl(IOP13XX_ESSR0) & IOP13XX_INTERFACE_SEL_PCIX)
157 func = 5;
158 else
159 func = 0;
160 break;
161 case IOP13XX_INIT_ATU_ATUE:
162 if (__raw_readl(IOP13XX_ESSR0) & IOP13XX_INTERFACE_SEL_PCIX)
163 func = 0;
164 else
165 func = 5;
166 break;
167 default:
168 BUG();
169 }
170
171 return func;
172 }
173
174 /* iop13xx_atux_cfg_address - format a configuration address for atux
175 * @bus: Target bus to access
176 * @devfn: Combined device number and function number
177 * @where: Desired register's address offset
178 *
179 * Convert the parameters to a configuration address formatted
180 * according the PCI-X 2.0 specification
181 */
182 static u32 iop13xx_atux_cfg_address(struct pci_bus *bus, int devfn, int where)
183 {
184 struct pci_sys_data *sys = bus->sysdata;
185 u32 addr;
186
187 if (sys->busnr == bus->number)
188 addr = 1 << (PCI_SLOT(devfn) + 16) | (PCI_SLOT(devfn) << 11);
189 else
190 addr = bus->number << 16 | PCI_SLOT(devfn) << 11 | 1;
191
192 addr |= PCI_FUNC(devfn) << 8 | ((where & 0xff) & ~3);
193 addr |= ((where & 0xf00) >> 8) << 24; /* upper register number */
194
195 return addr;
196 }
197
198 /* iop13xx_atue_cfg_address - format a configuration address for atue
199 * @bus: Target bus to access
200 * @devfn: Combined device number and function number
201 * @where: Desired register's address offset
202 *
203 * Convert the parameters to an address usable by the ATUE_OCCAR
204 */
205 static u32 iop13xx_atue_cfg_address(struct pci_bus *bus, int devfn, int where)
206 {
207 struct pci_sys_data *sys = bus->sysdata;
208 u32 addr;
209
210 PRINTK("iop13xx_atue_cfg_address: bus: %d dev: %d func: %d",
211 bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn));
212 addr = ((u32) bus->number) << IOP13XX_ATUE_OCCAR_BUS_NUM |
213 ((u32) PCI_SLOT(devfn)) << IOP13XX_ATUE_OCCAR_DEV_NUM |
214 ((u32) PCI_FUNC(devfn)) << IOP13XX_ATUE_OCCAR_FUNC_NUM |
215 (where & ~0x3);
216
217 if (sys->busnr != bus->number)
218 addr |= 1; /* type 1 access */
219
220 return addr;
221 }
222
223 /* This routine checks the status of the last configuration cycle. If an error
224 * was detected it returns >0, else it returns a 0. The errors being checked
225 * are parity, master abort, target abort (master and target). These types of
226 * errors occur during a config cycle where there is no device, like during
227 * the discovery stage.
228 */
229 static int iop13xx_atux_pci_status(int clear)
230 {
231 unsigned int status;
232 int err = 0;
233
234 /*
235 * Check the status registers.
236 */
237 status = __raw_readw(IOP13XX_ATUX_ATUSR);
238 if (status & IOP_PCI_STATUS_ERROR)
239 {
240 PRINTK("\t\t\tPCI error: ATUSR %#08x", status);
241 if(clear)
242 __raw_writew(status & IOP_PCI_STATUS_ERROR,
243 IOP13XX_ATUX_ATUSR);
244 err = 1;
245 }
246 status = __raw_readl(IOP13XX_ATUX_ATUISR);
247 if (status & IOP13XX_ATUX_ATUISR_ERROR)
248 {
249 PRINTK("\t\t\tPCI error interrupt: ATUISR %#08x", status);
250 if(clear)
251 __raw_writel(status & IOP13XX_ATUX_ATUISR_ERROR,
252 IOP13XX_ATUX_ATUISR);
253 err = 1;
254 }
255 return err;
256 }
257
258 /* Simply write the address register and read the configuration
259 * data. Note that the data dependency on %0 encourages an abort
260 * to be detected before we return.
261 */
262 static u32 iop13xx_atux_read(unsigned long addr)
263 {
264 u32 val;
265
266 __asm__ __volatile__(
267 "str %1, [%2]\n\t"
268 "ldr %0, [%3]\n\t"
269 "mov %0, %0\n\t"
270 : "=r" (val)
271 : "r" (addr), "r" (IOP13XX_ATUX_OCCAR), "r" (IOP13XX_ATUX_OCCDR));
272
273 return val;
274 }
275
276 /* The read routines must check the error status of the last configuration
277 * cycle. If there was an error, the routine returns all hex f's.
278 */
279 static int
280 iop13xx_atux_read_config(struct pci_bus *bus, unsigned int devfn, int where,
281 int size, u32 *value)
282 {
283 unsigned long addr = iop13xx_atux_cfg_address(bus, devfn, where);
284 u32 val = iop13xx_atux_read(addr) >> ((where & 3) * 8);
285
286 if (iop13xx_atux_pci_status(1) || is_atux_occdr_error()) {
287 __raw_writel(__raw_readl(IOP13XX_XBG_BECSR) & 3,
288 IOP13XX_XBG_BECSR);
289 val = 0xffffffff;
290 }
291
292 *value = val;
293
294 return PCIBIOS_SUCCESSFUL;
295 }
296
297 static int
298 iop13xx_atux_write_config(struct pci_bus *bus, unsigned int devfn, int where,
299 int size, u32 value)
300 {
301 unsigned long addr = iop13xx_atux_cfg_address(bus, devfn, where);
302 u32 val;
303
304 if (size != 4) {
305 val = iop13xx_atux_read(addr);
306 if (!iop13xx_atux_pci_status(1) == 0)
307 return PCIBIOS_SUCCESSFUL;
308
309 where = (where & 3) * 8;
310
311 if (size == 1)
312 val &= ~(0xff << where);
313 else
314 val &= ~(0xffff << where);
315
316 __raw_writel(val | value << where, IOP13XX_ATUX_OCCDR);
317 } else {
318 __raw_writel(addr, IOP13XX_ATUX_OCCAR);
319 __raw_writel(value, IOP13XX_ATUX_OCCDR);
320 }
321
322 return PCIBIOS_SUCCESSFUL;
323 }
324
325 static struct pci_ops iop13xx_atux_ops = {
326 .read = iop13xx_atux_read_config,
327 .write = iop13xx_atux_write_config,
328 };
329
330 /* This routine checks the status of the last configuration cycle. If an error
331 * was detected it returns >0, else it returns a 0. The errors being checked
332 * are parity, master abort, target abort (master and target). These types of
333 * errors occur during a config cycle where there is no device, like during
334 * the discovery stage.
335 */
336 static int iop13xx_atue_pci_status(int clear)
337 {
338 unsigned int status;
339 int err = 0;
340
341 /*
342 * Check the status registers.
343 */
344
345 /* standard pci status register */
346 status = __raw_readw(IOP13XX_ATUE_ATUSR);
347 if (status & IOP_PCI_STATUS_ERROR) {
348 PRINTK("\t\t\tPCI error: ATUSR %#08x", status);
349 if(clear)
350 __raw_writew(status & IOP_PCI_STATUS_ERROR,
351 IOP13XX_ATUE_ATUSR);
352 err++;
353 }
354
355 /* check the normal status bits in the ATUISR */
356 status = __raw_readl(IOP13XX_ATUE_ATUISR);
357 if (status & IOP13XX_ATUE_ATUISR_ERROR) {
358 PRINTK("\t\t\tPCI error: ATUISR %#08x", status);
359 if (clear)
360 __raw_writew(status & IOP13XX_ATUE_ATUISR_ERROR,
361 IOP13XX_ATUE_ATUISR);
362 err++;
363
364 /* check the PCI-E status if the ATUISR reports an interface error */
365 if (status & IOP13XX_ATUE_STAT_PCI_IFACE_ERR) {
366 /* get the unmasked errors */
367 status = __raw_readl(IOP13XX_ATUE_PIE_STS) &
368 ~(__raw_readl(IOP13XX_ATUE_PIE_MSK));
369
370 if (status) {
371 PRINTK("\t\t\tPCI-E error: ATUE_PIE_STS %#08x",
372 __raw_readl(IOP13XX_ATUE_PIE_STS));
373 err++;
374 } else {
375 PRINTK("\t\t\tPCI-E error: ATUE_PIE_STS %#08x",
376 __raw_readl(IOP13XX_ATUE_PIE_STS));
377 PRINTK("\t\t\tPCI-E error: ATUE_PIE_MSK %#08x",
378 __raw_readl(IOP13XX_ATUE_PIE_MSK));
379 BUG();
380 }
381
382 if(clear)
383 __raw_writel(status, IOP13XX_ATUE_PIE_STS);
384 }
385 }
386
387 return err;
388 }
389
390 static int
391 iop13xx_pcie_map_irq(const struct pci_dev *dev, u8 idsel, u8 pin)
392 {
393 WARN_ON(idsel != 0);
394
395 switch (pin) {
396 case 1: return ATUE_INTA;
397 case 2: return ATUE_INTB;
398 case 3: return ATUE_INTC;
399 case 4: return ATUE_INTD;
400 default: return -1;
401 }
402 }
403
404 static u32 iop13xx_atue_read(unsigned long addr)
405 {
406 u32 val;
407
408 __raw_writel(addr, IOP13XX_ATUE_OCCAR);
409 val = __raw_readl(IOP13XX_ATUE_OCCDR);
410
411 rmb();
412
413 return val;
414 }
415
416 /* The read routines must check the error status of the last configuration
417 * cycle. If there was an error, the routine returns all hex f's.
418 */
419 static int
420 iop13xx_atue_read_config(struct pci_bus *bus, unsigned int devfn, int where,
421 int size, u32 *value)
422 {
423 u32 val;
424 unsigned long addr = iop13xx_atue_cfg_address(bus, devfn, where);
425
426 /* Hide device numbers > 0 on the local PCI-E bus (Type 0 access) */
427 if (!PCI_SLOT(devfn) || (addr & 1)) {
428 val = iop13xx_atue_read(addr) >> ((where & 3) * 8);
429 if( iop13xx_atue_pci_status(1) || is_atue_occdr_error() ) {
430 __raw_writel(__raw_readl(IOP13XX_XBG_BECSR) & 3,
431 IOP13XX_XBG_BECSR);
432 val = 0xffffffff;
433 }
434
435 PRINTK("addr=%#0lx, val=%#010x", addr, val);
436 } else
437 val = 0xffffffff;
438
439 *value = val;
440
441 return PCIBIOS_SUCCESSFUL;
442 }
443
444 static int
445 iop13xx_atue_write_config(struct pci_bus *bus, unsigned int devfn, int where,
446 int size, u32 value)
447 {
448 unsigned long addr = iop13xx_atue_cfg_address(bus, devfn, where);
449 u32 val;
450
451 if (size != 4) {
452 val = iop13xx_atue_read(addr);
453 if (!iop13xx_atue_pci_status(1) == 0)
454 return PCIBIOS_SUCCESSFUL;
455
456 where = (where & 3) * 8;
457
458 if (size == 1)
459 val &= ~(0xff << where);
460 else
461 val &= ~(0xffff << where);
462
463 __raw_writel(val | value << where, IOP13XX_ATUE_OCCDR);
464 } else {
465 __raw_writel(addr, IOP13XX_ATUE_OCCAR);
466 __raw_writel(value, IOP13XX_ATUE_OCCDR);
467 }
468
469 return PCIBIOS_SUCCESSFUL;
470 }
471
472 static struct pci_ops iop13xx_atue_ops = {
473 .read = iop13xx_atue_read_config,
474 .write = iop13xx_atue_write_config,
475 };
476
477 /* When a PCI device does not exist during config cycles, the XScale gets a
478 * bus error instead of returning 0xffffffff. We can't rely on the ATU status
479 * bits to tell us that it was indeed a configuration cycle that caused this
480 * error especially in the case when the ATUE link is down. Instead we rely
481 * on data from the south XSI bridge to validate the abort
482 */
483 int
484 iop13xx_pci_abort(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
485 {
486 PRINTK("Data abort: address = 0x%08lx "
487 "fsr = 0x%03x PC = 0x%08lx LR = 0x%08lx",
488 addr, fsr, regs->ARM_pc, regs->ARM_lr);
489
490 PRINTK("IOP13XX_XBG_BECSR: %#10x", __raw_readl(IOP13XX_XBG_BECSR));
491 PRINTK("IOP13XX_XBG_BERAR: %#10x", __raw_readl(IOP13XX_XBG_BERAR));
492 PRINTK("IOP13XX_XBG_BERUAR: %#10x", __raw_readl(IOP13XX_XBG_BERUAR));
493
494 /* If it was an imprecise abort, then we need to correct the
495 * return address to be _after_ the instruction.
496 */
497 if (fsr & (1 << 10))
498 regs->ARM_pc += 4;
499
500 if (is_atue_occdr_error() || is_atux_occdr_error())
501 return 0;
502 else
503 return 1;
504 }
505
506 /* Scan an IOP13XX PCI bus. nr selects which ATU we use.
507 */
508 struct pci_bus *iop13xx_scan_bus(int nr, struct pci_sys_data *sys)
509 {
510 int which_atu;
511 struct pci_bus *bus = NULL;
512
513 switch (init_atu) {
514 case IOP13XX_INIT_ATU_ATUX:
515 which_atu = nr ? 0 : IOP13XX_INIT_ATU_ATUX;
516 break;
517 case IOP13XX_INIT_ATU_ATUE:
518 which_atu = nr ? 0 : IOP13XX_INIT_ATU_ATUE;
519 break;
520 case (IOP13XX_INIT_ATU_ATUX | IOP13XX_INIT_ATU_ATUE):
521 which_atu = nr ? IOP13XX_INIT_ATU_ATUE : IOP13XX_INIT_ATU_ATUX;
522 break;
523 default:
524 which_atu = 0;
525 }
526
527 if (!which_atu) {
528 BUG();
529 return NULL;
530 }
531
532 switch (which_atu) {
533 case IOP13XX_INIT_ATU_ATUX:
534 if (time_after_eq(jiffies + msecs_to_jiffies(1000),
535 atux_trhfa_timeout)) /* ensure not wrap */
536 while(time_before(jiffies, atux_trhfa_timeout))
537 udelay(100);
538
539 bus = pci_bus_atux = pci_scan_bus(sys->busnr,
540 &iop13xx_atux_ops,
541 sys);
542 break;
543 case IOP13XX_INIT_ATU_ATUE:
544 bus = pci_bus_atue = pci_scan_bus(sys->busnr,
545 &iop13xx_atue_ops,
546 sys);
547 break;
548 }
549
550 return bus;
551 }
552
553 /* This function is called from iop13xx_pci_init() after assigning valid
554 * values to iop13xx_atue_pmmr_offset. This is the location for common
555 * setup of ATUE for all IOP13XX implementations.
556 */
557 void __init iop13xx_atue_setup(void)
558 {
559 int func = iop13xx_atu_function(IOP13XX_INIT_ATU_ATUE);
560 u32 reg_val;
561
562 #ifdef CONFIG_PCI_MSI
563 /* BAR 0 (inbound msi window) */
564 __raw_writel(IOP13XX_MU_BASE_PHYS, IOP13XX_MU_MUBAR);
565 __raw_writel(~(IOP13XX_MU_WINDOW_SIZE - 1), IOP13XX_ATUE_IALR0);
566 __raw_writel(IOP13XX_MU_BASE_PHYS, IOP13XX_ATUE_IATVR0);
567 __raw_writel(IOP13XX_MU_BASE_PCI, IOP13XX_ATUE_IABAR0);
568 #endif
569
570 /* BAR 1 (1:1 mapping with Physical RAM) */
571 /* Set limit and enable */
572 __raw_writel(~(IOP13XX_MAX_RAM_SIZE - PHYS_OFFSET - 1) & ~0x1,
573 IOP13XX_ATUE_IALR1);
574 __raw_writel(0x0, IOP13XX_ATUE_IAUBAR1);
575
576 /* Set base at the top of the reserved address space */
577 __raw_writel(PHYS_OFFSET | PCI_BASE_ADDRESS_MEM_TYPE_64 |
578 PCI_BASE_ADDRESS_MEM_PREFETCH, IOP13XX_ATUE_IABAR1);
579
580 /* 1:1 mapping with physical ram
581 * (leave big endian byte swap disabled)
582 */
583 __raw_writel(0x0, IOP13XX_ATUE_IAUTVR1);
584 __raw_writel(PHYS_OFFSET, IOP13XX_ATUE_IATVR1);
585
586 /* Outbound window 1 (PCIX/PCIE memory window) */
587 /* 32 bit Address Space */
588 __raw_writel(0x0, IOP13XX_ATUE_OUMWTVR1);
589 /* PA[35:32] */
590 __raw_writel(IOP13XX_ATUE_OUMBAR_ENABLE |
591 (IOP13XX_PCIE_MEM_PHYS_OFFSET >> 32),
592 IOP13XX_ATUE_OUMBAR1);
593
594 /* Setup the I/O Bar
595 * A[35-16] in 31-12
596 */
597 __raw_writel(((IOP13XX_PCIE_LOWER_IO_PA >> 0x4) & 0xfffff000),
598 IOP13XX_ATUE_OIOBAR);
599 __raw_writel(IOP13XX_PCIE_LOWER_IO_BA, IOP13XX_ATUE_OIOWTVR);
600
601 /* clear startup errors */
602 iop13xx_atue_pci_status(1);
603
604 /* OIOBAR function number
605 */
606 reg_val = __raw_readl(IOP13XX_ATUE_OIOBAR);
607 reg_val &= ~0x7;
608 reg_val |= func;
609 __raw_writel(reg_val, IOP13XX_ATUE_OIOBAR);
610
611 /* OUMBAR function numbers
612 */
613 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR0);
614 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
615 IOP13XX_ATU_OUMBAR_FUNC_NUM);
616 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
617 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR0);
618
619 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR1);
620 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
621 IOP13XX_ATU_OUMBAR_FUNC_NUM);
622 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
623 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR1);
624
625 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR2);
626 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
627 IOP13XX_ATU_OUMBAR_FUNC_NUM);
628 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
629 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR2);
630
631 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR3);
632 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
633 IOP13XX_ATU_OUMBAR_FUNC_NUM);
634 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
635 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR3);
636
637 /* Enable inbound and outbound cycles
638 */
639 reg_val = __raw_readw(IOP13XX_ATUE_ATUCMD);
640 reg_val |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
641 PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
642 __raw_writew(reg_val, IOP13XX_ATUE_ATUCMD);
643
644 reg_val = __raw_readl(IOP13XX_ATUE_ATUCR);
645 reg_val |= IOP13XX_ATUE_ATUCR_OUT_EN |
646 IOP13XX_ATUE_ATUCR_IVM;
647 __raw_writel(reg_val, IOP13XX_ATUE_ATUCR);
648 }
649
650 void __init iop13xx_atue_disable(void)
651 {
652 u32 reg_val;
653
654 __raw_writew(0x0, IOP13XX_ATUE_ATUCMD);
655 __raw_writel(IOP13XX_ATUE_ATUCR_IVM, IOP13XX_ATUE_ATUCR);
656
657 /* wait for cycles to quiesce */
658 while (__raw_readl(IOP13XX_ATUE_PCSR) & (IOP13XX_ATUE_PCSR_OUT_Q_BUSY |
659 IOP13XX_ATUE_PCSR_IN_Q_BUSY |
660 IOP13XX_ATUE_PCSR_LLRB_BUSY))
661 cpu_relax();
662
663 /* BAR 0 ( Disabled ) */
664 __raw_writel(0x0, IOP13XX_ATUE_IAUBAR0);
665 __raw_writel(0x0, IOP13XX_ATUE_IABAR0);
666 __raw_writel(0x0, IOP13XX_ATUE_IAUTVR0);
667 __raw_writel(0x0, IOP13XX_ATUE_IATVR0);
668 __raw_writel(0x0, IOP13XX_ATUE_IALR0);
669 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR0);
670 reg_val &= ~IOP13XX_ATUE_OUMBAR_ENABLE;
671 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR0);
672
673 /* BAR 1 ( Disabled ) */
674 __raw_writel(0x0, IOP13XX_ATUE_IAUBAR1);
675 __raw_writel(0x0, IOP13XX_ATUE_IABAR1);
676 __raw_writel(0x0, IOP13XX_ATUE_IAUTVR1);
677 __raw_writel(0x0, IOP13XX_ATUE_IATVR1);
678 __raw_writel(0x0, IOP13XX_ATUE_IALR1);
679 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR1);
680 reg_val &= ~IOP13XX_ATUE_OUMBAR_ENABLE;
681 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR1);
682
683 /* BAR 2 ( Disabled ) */
684 __raw_writel(0x0, IOP13XX_ATUE_IAUBAR2);
685 __raw_writel(0x0, IOP13XX_ATUE_IABAR2);
686 __raw_writel(0x0, IOP13XX_ATUE_IAUTVR2);
687 __raw_writel(0x0, IOP13XX_ATUE_IATVR2);
688 __raw_writel(0x0, IOP13XX_ATUE_IALR2);
689 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR2);
690 reg_val &= ~IOP13XX_ATUE_OUMBAR_ENABLE;
691 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR2);
692
693 /* BAR 3 ( Disabled ) */
694 reg_val = __raw_readl(IOP13XX_ATUE_OUMBAR3);
695 reg_val &= ~IOP13XX_ATUE_OUMBAR_ENABLE;
696 __raw_writel(reg_val, IOP13XX_ATUE_OUMBAR3);
697
698 /* Setup the I/O Bar
699 * A[35-16] in 31-12
700 */
701 __raw_writel((IOP13XX_PCIE_LOWER_IO_PA >> 0x4) & 0xfffff000,
702 IOP13XX_ATUE_OIOBAR);
703 __raw_writel(IOP13XX_PCIE_LOWER_IO_BA, IOP13XX_ATUE_OIOWTVR);
704 }
705
706 /* This function is called from iop13xx_pci_init() after assigning valid
707 * values to iop13xx_atux_pmmr_offset. This is the location for common
708 * setup of ATUX for all IOP13XX implementations.
709 */
710 void __init iop13xx_atux_setup(void)
711 {
712 u32 reg_val;
713 int func = iop13xx_atu_function(IOP13XX_INIT_ATU_ATUX);
714
715 /* Take PCI-X bus out of reset if bootloader hasn't already.
716 * According to spec, we should wait for 2^25 PCI clocks to meet
717 * the PCI timing parameter Trhfa (RST# high to first access).
718 * This is rarely necessary and often ignored.
719 */
720 reg_val = __raw_readl(IOP13XX_ATUX_PCSR);
721 if (reg_val & IOP13XX_ATUX_PCSR_P_RSTOUT) {
722 int msec = (reg_val >> IOP13XX_ATUX_PCSR_FREQ_OFFSET) & 0x7;
723 msec = 1000 / (8-msec); /* bits 100=133MHz, 111=>33MHz */
724 __raw_writel(reg_val & ~IOP13XX_ATUX_PCSR_P_RSTOUT,
725 IOP13XX_ATUX_PCSR);
726 atux_trhfa_timeout = jiffies + msecs_to_jiffies(msec);
727 }
728 else
729 atux_trhfa_timeout = jiffies;
730
731 #ifdef CONFIG_PCI_MSI
732 /* BAR 0 (inbound msi window) */
733 __raw_writel(IOP13XX_MU_BASE_PHYS, IOP13XX_MU_MUBAR);
734 __raw_writel(~(IOP13XX_MU_WINDOW_SIZE - 1), IOP13XX_ATUX_IALR0);
735 __raw_writel(IOP13XX_MU_BASE_PHYS, IOP13XX_ATUX_IATVR0);
736 __raw_writel(IOP13XX_MU_BASE_PCI, IOP13XX_ATUX_IABAR0);
737 #endif
738
739 /* BAR 1 (1:1 mapping with Physical RAM) */
740 /* Set limit and enable */
741 __raw_writel(~(IOP13XX_MAX_RAM_SIZE - PHYS_OFFSET - 1) & ~0x1,
742 IOP13XX_ATUX_IALR1);
743 __raw_writel(0x0, IOP13XX_ATUX_IAUBAR1);
744
745 /* Set base at the top of the reserved address space */
746 __raw_writel(PHYS_OFFSET | PCI_BASE_ADDRESS_MEM_TYPE_64 |
747 PCI_BASE_ADDRESS_MEM_PREFETCH, IOP13XX_ATUX_IABAR1);
748
749 /* 1:1 mapping with physical ram
750 * (leave big endian byte swap disabled)
751 */
752 __raw_writel(0x0, IOP13XX_ATUX_IAUTVR1);
753 __raw_writel(PHYS_OFFSET, IOP13XX_ATUX_IATVR1);
754
755 /* Outbound window 1 (PCIX/PCIE memory window) */
756 /* 32 bit Address Space */
757 __raw_writel(0x0, IOP13XX_ATUX_OUMWTVR1);
758 /* PA[35:32] */
759 __raw_writel(IOP13XX_ATUX_OUMBAR_ENABLE |
760 IOP13XX_PCIX_MEM_PHYS_OFFSET >> 32,
761 IOP13XX_ATUX_OUMBAR1);
762
763 /* Setup the I/O Bar
764 * A[35-16] in 31-12
765 */
766 __raw_writel((IOP13XX_PCIX_LOWER_IO_PA >> 0x4) & 0xfffff000,
767 IOP13XX_ATUX_OIOBAR);
768 __raw_writel(IOP13XX_PCIX_LOWER_IO_BA, IOP13XX_ATUX_OIOWTVR);
769
770 /* clear startup errors */
771 iop13xx_atux_pci_status(1);
772
773 /* OIOBAR function number
774 */
775 reg_val = __raw_readl(IOP13XX_ATUX_OIOBAR);
776 reg_val &= ~0x7;
777 reg_val |= func;
778 __raw_writel(reg_val, IOP13XX_ATUX_OIOBAR);
779
780 /* OUMBAR function numbers
781 */
782 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR0);
783 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
784 IOP13XX_ATU_OUMBAR_FUNC_NUM);
785 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
786 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR0);
787
788 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR1);
789 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
790 IOP13XX_ATU_OUMBAR_FUNC_NUM);
791 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
792 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR1);
793
794 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR2);
795 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
796 IOP13XX_ATU_OUMBAR_FUNC_NUM);
797 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
798 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR2);
799
800 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR3);
801 reg_val &= ~(IOP13XX_ATU_OUMBAR_FUNC_NUM_MASK <<
802 IOP13XX_ATU_OUMBAR_FUNC_NUM);
803 reg_val |= func << IOP13XX_ATU_OUMBAR_FUNC_NUM;
804 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR3);
805
806 /* Enable inbound and outbound cycles
807 */
808 reg_val = __raw_readw(IOP13XX_ATUX_ATUCMD);
809 reg_val |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
810 PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
811 __raw_writew(reg_val, IOP13XX_ATUX_ATUCMD);
812
813 reg_val = __raw_readl(IOP13XX_ATUX_ATUCR);
814 reg_val |= IOP13XX_ATUX_ATUCR_OUT_EN;
815 __raw_writel(reg_val, IOP13XX_ATUX_ATUCR);
816 }
817
818 void __init iop13xx_atux_disable(void)
819 {
820 u32 reg_val;
821
822 __raw_writew(0x0, IOP13XX_ATUX_ATUCMD);
823 __raw_writel(0x0, IOP13XX_ATUX_ATUCR);
824
825 /* wait for cycles to quiesce */
826 while (__raw_readl(IOP13XX_ATUX_PCSR) & (IOP13XX_ATUX_PCSR_OUT_Q_BUSY |
827 IOP13XX_ATUX_PCSR_IN_Q_BUSY))
828 cpu_relax();
829
830 /* BAR 0 ( Disabled ) */
831 __raw_writel(0x0, IOP13XX_ATUX_IAUBAR0);
832 __raw_writel(0x0, IOP13XX_ATUX_IABAR0);
833 __raw_writel(0x0, IOP13XX_ATUX_IAUTVR0);
834 __raw_writel(0x0, IOP13XX_ATUX_IATVR0);
835 __raw_writel(0x0, IOP13XX_ATUX_IALR0);
836 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR0);
837 reg_val &= ~IOP13XX_ATUX_OUMBAR_ENABLE;
838 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR0);
839
840 /* BAR 1 ( Disabled ) */
841 __raw_writel(0x0, IOP13XX_ATUX_IAUBAR1);
842 __raw_writel(0x0, IOP13XX_ATUX_IABAR1);
843 __raw_writel(0x0, IOP13XX_ATUX_IAUTVR1);
844 __raw_writel(0x0, IOP13XX_ATUX_IATVR1);
845 __raw_writel(0x0, IOP13XX_ATUX_IALR1);
846 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR1);
847 reg_val &= ~IOP13XX_ATUX_OUMBAR_ENABLE;
848 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR1);
849
850 /* BAR 2 ( Disabled ) */
851 __raw_writel(0x0, IOP13XX_ATUX_IAUBAR2);
852 __raw_writel(0x0, IOP13XX_ATUX_IABAR2);
853 __raw_writel(0x0, IOP13XX_ATUX_IAUTVR2);
854 __raw_writel(0x0, IOP13XX_ATUX_IATVR2);
855 __raw_writel(0x0, IOP13XX_ATUX_IALR2);
856 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR2);
857 reg_val &= ~IOP13XX_ATUX_OUMBAR_ENABLE;
858 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR2);
859
860 /* BAR 3 ( Disabled ) */
861 __raw_writel(0x0, IOP13XX_ATUX_IAUBAR3);
862 __raw_writel(0x0, IOP13XX_ATUX_IABAR3);
863 __raw_writel(0x0, IOP13XX_ATUX_IAUTVR3);
864 __raw_writel(0x0, IOP13XX_ATUX_IATVR3);
865 __raw_writel(0x0, IOP13XX_ATUX_IALR3);
866 reg_val = __raw_readl(IOP13XX_ATUX_OUMBAR3);
867 reg_val &= ~IOP13XX_ATUX_OUMBAR_ENABLE;
868 __raw_writel(reg_val, IOP13XX_ATUX_OUMBAR3);
869
870 /* Setup the I/O Bar
871 * A[35-16] in 31-12
872 */
873 __raw_writel((IOP13XX_PCIX_LOWER_IO_PA >> 0x4) & 0xfffff000,
874 IOP13XX_ATUX_OIOBAR);
875 __raw_writel(IOP13XX_PCIX_LOWER_IO_BA, IOP13XX_ATUX_OIOWTVR);
876 }
877
878 void __init iop13xx_set_atu_mmr_bases(void)
879 {
880 /* Based on ESSR0, determine the ATU X/E offsets */
881 switch(__raw_readl(IOP13XX_ESSR0) &
882 (IOP13XX_CONTROLLER_ONLY | IOP13XX_INTERFACE_SEL_PCIX)) {
883 /* both asserted */
884 case 0:
885 iop13xx_atux_pmmr_offset = IOP13XX_ATU1_PMMR_OFFSET;
886 iop13xx_atue_pmmr_offset = IOP13XX_ATU2_PMMR_OFFSET;
887 break;
888 /* IOP13XX_CONTROLLER_ONLY = deasserted
889 * IOP13XX_INTERFACE_SEL_PCIX = asserted
890 */
891 case IOP13XX_CONTROLLER_ONLY:
892 iop13xx_atux_pmmr_offset = IOP13XX_ATU0_PMMR_OFFSET;
893 iop13xx_atue_pmmr_offset = IOP13XX_ATU2_PMMR_OFFSET;
894 break;
895 /* IOP13XX_CONTROLLER_ONLY = asserted
896 * IOP13XX_INTERFACE_SEL_PCIX = deasserted
897 */
898 case IOP13XX_INTERFACE_SEL_PCIX:
899 iop13xx_atux_pmmr_offset = IOP13XX_ATU1_PMMR_OFFSET;
900 iop13xx_atue_pmmr_offset = IOP13XX_ATU2_PMMR_OFFSET;
901 break;
902 /* both deasserted */
903 case IOP13XX_CONTROLLER_ONLY | IOP13XX_INTERFACE_SEL_PCIX:
904 iop13xx_atux_pmmr_offset = IOP13XX_ATU2_PMMR_OFFSET;
905 iop13xx_atue_pmmr_offset = IOP13XX_ATU0_PMMR_OFFSET;
906 break;
907 default:
908 BUG();
909 }
910 }
911
912 void __init iop13xx_atu_select(struct hw_pci *plat_pci)
913 {
914 int i;
915
916 /* set system defaults
917 * note: if "iop13xx_init_atu=" is specified this autodetect
918 * sequence will be bypassed
919 */
920 if (init_atu == IOP13XX_INIT_ATU_DEFAULT) {
921 /* check for single/dual interface */
922 if (__raw_readl(IOP13XX_ESSR0) & IOP13XX_INTERFACE_SEL_PCIX) {
923 /* ATUE must be present check the device id
924 * to see if ATUX is present.
925 */
926 init_atu |= IOP13XX_INIT_ATU_ATUE;
927 switch (__raw_readw(IOP13XX_ATUE_DID) & 0xf0) {
928 case 0x70:
929 case 0x80:
930 case 0xc0:
931 init_atu |= IOP13XX_INIT_ATU_ATUX;
932 break;
933 }
934 } else {
935 /* ATUX must be present check the device id
936 * to see if ATUE is present.
937 */
938 init_atu |= IOP13XX_INIT_ATU_ATUX;
939 switch (__raw_readw(IOP13XX_ATUX_DID) & 0xf0) {
940 case 0x70:
941 case 0x80:
942 case 0xc0:
943 init_atu |= IOP13XX_INIT_ATU_ATUE;
944 break;
945 }
946 }
947
948 /* check central resource and root complex capability */
949 if (init_atu & IOP13XX_INIT_ATU_ATUX)
950 if (!(__raw_readl(IOP13XX_ATUX_PCSR) &
951 IOP13XX_ATUX_PCSR_CENTRAL_RES))
952 init_atu &= ~IOP13XX_INIT_ATU_ATUX;
953
954 if (init_atu & IOP13XX_INIT_ATU_ATUE)
955 if (__raw_readl(IOP13XX_ATUE_PCSR) &
956 IOP13XX_ATUE_PCSR_END_POINT)
957 init_atu &= ~IOP13XX_INIT_ATU_ATUE;
958 }
959
960 for (i = 0; i < 2; i++) {
961 if((init_atu & (1 << i)) == (1 << i))
962 plat_pci->nr_controllers++;
963 }
964 }
965
966 void __init iop13xx_pci_init(void)
967 {
968 /* clear pre-existing south bridge errors */
969 __raw_writel(__raw_readl(IOP13XX_XBG_BECSR) & 3, IOP13XX_XBG_BECSR);
970
971 /* Setup the Min Address for PCI memory... */
972 pcibios_min_io = 0;
973 pcibios_min_mem = IOP13XX_PCIX_LOWER_MEM_BA;
974
975 /* if Linux is given control of an ATU
976 * clear out its prior configuration,
977 * otherwise do not touch the registers
978 */
979 if (init_atu & IOP13XX_INIT_ATU_ATUE) {
980 iop13xx_atue_disable();
981 iop13xx_atue_setup();
982 }
983
984 if (init_atu & IOP13XX_INIT_ATU_ATUX) {
985 iop13xx_atux_disable();
986 iop13xx_atux_setup();
987 }
988
989 hook_fault_code(16+6, iop13xx_pci_abort, SIGBUS, 0,
990 "imprecise external abort");
991 }
992
993 /* initialize the pci memory space. handle any combination of
994 * atue and atux enabled/disabled
995 */
996 int iop13xx_pci_setup(int nr, struct pci_sys_data *sys)
997 {
998 struct resource *res;
999 int which_atu;
1000 u32 pcixsr, pcsr;
1001
1002 if (nr > 1)
1003 return 0;
1004
1005 res = kcalloc(2, sizeof(struct resource), GFP_KERNEL);
1006 if (!res)
1007 panic("PCI: unable to alloc resources");
1008
1009
1010 /* 'nr' assumptions:
1011 * ATUX is always 0
1012 * ATUE is 1 when ATUX is also enabled
1013 * ATUE is 0 when ATUX is disabled
1014 */
1015 switch(init_atu) {
1016 case IOP13XX_INIT_ATU_ATUX:
1017 which_atu = nr ? 0 : IOP13XX_INIT_ATU_ATUX;
1018 break;
1019 case IOP13XX_INIT_ATU_ATUE:
1020 which_atu = nr ? 0 : IOP13XX_INIT_ATU_ATUE;
1021 break;
1022 case (IOP13XX_INIT_ATU_ATUX | IOP13XX_INIT_ATU_ATUE):
1023 which_atu = nr ? IOP13XX_INIT_ATU_ATUE : IOP13XX_INIT_ATU_ATUX;
1024 break;
1025 default:
1026 which_atu = 0;
1027 }
1028
1029 if (!which_atu) {
1030 kfree(res);
1031 return 0;
1032 }
1033
1034 switch(which_atu) {
1035 case IOP13XX_INIT_ATU_ATUX:
1036 pcixsr = __raw_readl(IOP13XX_ATUX_PCIXSR);
1037 pcixsr &= ~0xffff;
1038 pcixsr |= sys->busnr << IOP13XX_ATUX_PCIXSR_BUS_NUM |
1039 0 << IOP13XX_ATUX_PCIXSR_DEV_NUM |
1040 iop13xx_atu_function(IOP13XX_INIT_ATU_ATUX)
1041 << IOP13XX_ATUX_PCIXSR_FUNC_NUM;
1042 __raw_writel(pcixsr, IOP13XX_ATUX_PCIXSR);
1043
1044 res[0].start = IOP13XX_PCIX_LOWER_IO_PA + IOP13XX_PCIX_IO_BUS_OFFSET;
1045 res[0].end = IOP13XX_PCIX_UPPER_IO_PA;
1046 res[0].name = "IQ81340 ATUX PCI I/O Space";
1047 res[0].flags = IORESOURCE_IO;
1048
1049 res[1].start = IOP13XX_PCIX_LOWER_MEM_RA;
1050 res[1].end = IOP13XX_PCIX_UPPER_MEM_RA;
1051 res[1].name = "IQ81340 ATUX PCI Memory Space";
1052 res[1].flags = IORESOURCE_MEM;
1053 sys->mem_offset = IOP13XX_PCIX_MEM_OFFSET;
1054 sys->io_offset = IOP13XX_PCIX_LOWER_IO_PA;
1055 break;
1056 case IOP13XX_INIT_ATU_ATUE:
1057 /* Note: the function number field in the PCSR is ro */
1058 pcsr = __raw_readl(IOP13XX_ATUE_PCSR);
1059 pcsr &= ~(0xfff8 << 16);
1060 pcsr |= sys->busnr << IOP13XX_ATUE_PCSR_BUS_NUM |
1061 0 << IOP13XX_ATUE_PCSR_DEV_NUM;
1062
1063 __raw_writel(pcsr, IOP13XX_ATUE_PCSR);
1064
1065 res[0].start = IOP13XX_PCIE_LOWER_IO_PA + IOP13XX_PCIE_IO_BUS_OFFSET;
1066 res[0].end = IOP13XX_PCIE_UPPER_IO_PA;
1067 res[0].name = "IQ81340 ATUE PCI I/O Space";
1068 res[0].flags = IORESOURCE_IO;
1069
1070 res[1].start = IOP13XX_PCIE_LOWER_MEM_RA;
1071 res[1].end = IOP13XX_PCIE_UPPER_MEM_RA;
1072 res[1].name = "IQ81340 ATUE PCI Memory Space";
1073 res[1].flags = IORESOURCE_MEM;
1074 sys->mem_offset = IOP13XX_PCIE_MEM_OFFSET;
1075 sys->io_offset = IOP13XX_PCIE_LOWER_IO_PA;
1076 sys->map_irq = iop13xx_pcie_map_irq;
1077 break;
1078 default:
1079 kfree(res);
1080 return 0;
1081 }
1082
1083 request_resource(&ioport_resource, &res[0]);
1084 request_resource(&iomem_resource, &res[1]);
1085
1086 sys->resource[0] = &res[0];
1087 sys->resource[1] = &res[1];
1088 sys->resource[2] = NULL;
1089
1090 return 1;
1091 }
1092
1093 u16 iop13xx_dev_id(void)
1094 {
1095 if (__raw_readl(IOP13XX_ESSR0) & IOP13XX_INTERFACE_SEL_PCIX)
1096 return __raw_readw(IOP13XX_ATUE_DID);
1097 else
1098 return __raw_readw(IOP13XX_ATUX_DID);
1099 }
1100
1101 static int __init iop13xx_init_atu_setup(char *str)
1102 {
1103 init_atu = IOP13XX_INIT_ATU_NONE;
1104 if (str) {
1105 while (*str != '\0') {
1106 switch (*str) {
1107 case 'x':
1108 case 'X':
1109 init_atu |= IOP13XX_INIT_ATU_ATUX;
1110 init_atu &= ~IOP13XX_INIT_ATU_NONE;
1111 break;
1112 case 'e':
1113 case 'E':
1114 init_atu |= IOP13XX_INIT_ATU_ATUE;
1115 init_atu &= ~IOP13XX_INIT_ATU_NONE;
1116 break;
1117 case ',':
1118 case '=':
1119 break;
1120 default:
1121 PRINTK("\"iop13xx_init_atu\" malformed at "
1122 "character: \'%c\'", *str);
1123 *(str + 1) = '\0';
1124 init_atu = IOP13XX_INIT_ATU_DEFAULT;
1125 }
1126 str++;
1127 }
1128 }
1129 return 1;
1130 }
1131
1132 __setup("iop13xx_init_atu", iop13xx_init_atu_setup);
kernel source for telekom puls (alcatel/mediatek)