[ARM] iop13xx: msi support
[linux-2.6.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/delay.h>
22
23 #include <asm/irq.h>
24 #include <asm/hardware.h>
25 #include <asm/sizes.h>
26 #include <asm/mach/pci.h>
27 #include <asm/arch/pci.h>
28
29 #define IOP13XX_PCI_DEBUG 0
30 #define PRINTK(x...) ((void)(IOP13XX_PCI_DEBUG && printk(x)))
31
32 u32 iop13xx_atux_pmmr_offset; /* This offset can change based on strapping */
33 u32 iop13xx_atue_pmmr_offset; /* This offset can change based on strapping */
34 static struct pci_bus *pci_bus_atux = 0;
35 static struct pci_bus *pci_bus_atue = 0;
36 u32 iop13xx_atue_mem_base;
37 u32 iop13xx_atux_mem_base;
38 size_t iop13xx_atue_mem_size;
39 size_t iop13xx_atux_mem_size;
40 unsigned long iop13xx_pcibios_min_io = 0;
41 unsigned long iop13xx_pcibios_min_mem = 0;
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", __FUNCTION__);
97                                                 BUG();
98                                         }
99                                 } else
100                                         iop13xx_atux_mem_size = 0;
101                                 PRINTK("%s: atu: %d bus_size: %d mem_base: %x\n",
102                                 __FUNCTION__, 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", __FUNCTION__);
123                                                 BUG();
124                                         }
125                                 } else
126                                         iop13xx_atue_mem_size = 0;
127                                 PRINTK("%s: atu: %d bus_size: %d mem_base: %x\n",
128                                 __FUNCTION__, 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 inline 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 occure 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 inline 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 occure 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 inline int __init
391 iop13xx_pcie_map_irq(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 inline 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         iop13xx_pcibios_min_mem = IOP13XX_PCIX_LOWER_MEM_BA;
973
974         /* if Linux is given control of an ATU
975          * clear out its prior configuration,
976          * otherwise do not touch the registers
977          */
978         if (init_atu & IOP13XX_INIT_ATU_ATUE) {
979                 iop13xx_atue_disable();
980                 iop13xx_atue_setup();
981         }
982
983         if (init_atu & IOP13XX_INIT_ATU_ATUX) {
984                 iop13xx_atux_disable();
985                 iop13xx_atux_setup();
986         }
987
988         hook_fault_code(16+6, iop13xx_pci_abort, SIGBUS,
989                         "imprecise external abort");
990 }
991
992 /* intialize the pci memory space.  handle any combination of
993  * atue and atux enabled/disabled
994  */
995 int iop13xx_pci_setup(int nr, struct pci_sys_data *sys)
996 {
997         struct resource *res;
998         int which_atu;
999         u32 pcixsr, pcsr;
1000
1001         if (nr > 1)
1002                 return 0;
1003
1004         res = kmalloc(sizeof(struct resource) * 2, GFP_KERNEL);
1005         if (!res)
1006                 panic("PCI: unable to alloc resources");
1007
1008         memset(res, 0, sizeof(struct resource) * 2);
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                 return 0;
1031
1032         switch(which_atu) {
1033         case IOP13XX_INIT_ATU_ATUX:
1034                 pcixsr = __raw_readl(IOP13XX_ATUX_PCIXSR);
1035                 pcixsr &= ~0xffff;
1036                 pcixsr |= sys->busnr << IOP13XX_ATUX_PCIXSR_BUS_NUM |
1037                           0 << IOP13XX_ATUX_PCIXSR_DEV_NUM |
1038                           iop13xx_atu_function(IOP13XX_INIT_ATU_ATUX)
1039                                   << IOP13XX_ATUX_PCIXSR_FUNC_NUM;
1040                 __raw_writel(pcixsr, IOP13XX_ATUX_PCIXSR);
1041
1042                 res[0].start = IOP13XX_PCIX_LOWER_IO_PA + IOP13XX_PCIX_IO_BUS_OFFSET;
1043                 res[0].end   = IOP13XX_PCIX_UPPER_IO_PA;
1044                 res[0].name  = "IQ81340 ATUX PCI I/O Space";
1045                 res[0].flags = IORESOURCE_IO;
1046
1047                 res[1].start = IOP13XX_PCIX_LOWER_MEM_RA;
1048                 res[1].end   = IOP13XX_PCIX_UPPER_MEM_RA;
1049                 res[1].name  = "IQ81340 ATUX PCI Memory Space";
1050                 res[1].flags = IORESOURCE_MEM;
1051                 sys->mem_offset = IOP13XX_PCIX_MEM_OFFSET;
1052                 sys->io_offset = IOP13XX_PCIX_LOWER_IO_PA;
1053                 break;
1054         case IOP13XX_INIT_ATU_ATUE:
1055                 /* Note: the function number field in the PCSR is ro */
1056                 pcsr = __raw_readl(IOP13XX_ATUE_PCSR);
1057                 pcsr &= ~(0xfff8 << 16);
1058                 pcsr |= sys->busnr << IOP13XX_ATUE_PCSR_BUS_NUM |
1059                                 0 << IOP13XX_ATUE_PCSR_DEV_NUM;
1060
1061                 __raw_writel(pcsr, IOP13XX_ATUE_PCSR);
1062
1063                 res[0].start = IOP13XX_PCIE_LOWER_IO_PA + IOP13XX_PCIE_IO_BUS_OFFSET;
1064                 res[0].end   = IOP13XX_PCIE_UPPER_IO_PA;
1065                 res[0].name  = "IQ81340 ATUE PCI I/O Space";
1066                 res[0].flags = IORESOURCE_IO;
1067
1068                 res[1].start = IOP13XX_PCIE_LOWER_MEM_RA;
1069                 res[1].end   = IOP13XX_PCIE_UPPER_MEM_RA;
1070                 res[1].name  = "IQ81340 ATUE PCI Memory Space";
1071                 res[1].flags = IORESOURCE_MEM;
1072                 sys->mem_offset = IOP13XX_PCIE_MEM_OFFSET;
1073                 sys->io_offset = IOP13XX_PCIE_LOWER_IO_PA;
1074                 sys->map_irq = iop13xx_pcie_map_irq;
1075                 break;
1076         default:
1077                 return 0;
1078         }
1079
1080         request_resource(&ioport_resource, &res[0]);
1081         request_resource(&iomem_resource, &res[1]);
1082
1083         sys->resource[0] = &res[0];
1084         sys->resource[1] = &res[1];
1085         sys->resource[2] = NULL;
1086
1087         return 1;
1088 }
1089
1090 u16 iop13xx_dev_id(void)
1091 {
1092         if (__raw_readl(IOP13XX_ESSR0) & IOP13XX_INTERFACE_SEL_PCIX)
1093                 return __raw_readw(IOP13XX_ATUE_DID);
1094         else
1095                 return __raw_readw(IOP13XX_ATUX_DID);
1096 }
1097
1098 static int __init iop13xx_init_atu_setup(char *str)
1099 {
1100         init_atu = IOP13XX_INIT_ATU_NONE;
1101         if (str) {
1102                 while (*str != '\0') {
1103                         switch (*str) {
1104                         case 'x':
1105                         case 'X':
1106                                 init_atu |= IOP13XX_INIT_ATU_ATUX;
1107                                 init_atu &= ~IOP13XX_INIT_ATU_NONE;
1108                                 break;
1109                         case 'e':
1110                         case 'E':
1111                                 init_atu |= IOP13XX_INIT_ATU_ATUE;
1112                                 init_atu &= ~IOP13XX_INIT_ATU_NONE;
1113                                 break;
1114                         case ',':
1115                         case '=':
1116                                 break;
1117                         default:
1118                                 PRINTK("\"iop13xx_init_atu\" malformed at "
1119                                             "character: \'%c\'", *str);
1120                                 *(str + 1) = '\0';
1121                                 init_atu = IOP13XX_INIT_ATU_DEFAULT;
1122                         }
1123                         str++;
1124                 }
1125         }
1126         return 1;
1127 }
1128
1129 __setup("iop13xx_init_atu", iop13xx_init_atu_setup);