v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / arch / arm / mach-integrator / pci_v3.c
1 /*
2  *  linux/arch/arm/mach-integrator/pci_v3.c
3  *
4  *  PCI functions for V3 host PCI bridge
5  *
6  *  Copyright (C) 1999 ARM Limited
7  *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23 #include <linux/sched.h>
24 #include <linux/kernel.h>
25 #include <linux/pci.h>
26 #include <linux/ptrace.h>
27 #include <linux/malloc.h>
28 #include <linux/ioport.h>
29 #include <linux/interrupt.h>
30 #include <linux/spinlock.h>
31 #include <linux/init.h>
32
33 #include <asm/hardware.h>
34 #include <asm/irq.h>
35 #include <asm/system.h>
36 #include <asm/mach/pci.h>
37
38 #include <asm/hardware/pci_v3.h>
39
40 /*
41  * The V3 PCI interface chip in Integrator provides several windows from
42  * local bus memory into the PCI memory areas.   Unfortunately, there
43  * are not really enough windows for our usage, therefore we reuse 
44  * one of the windows for access to PCI configuration space.  The
45  * memory map is as follows:
46  * 
47  * Local Bus Memory         Usage
48  * 
49  * 40000000 - 4FFFFFFF      PCI memory.  256M non-prefetchable
50  * 50000000 - 5FFFFFFF      PCI memory.  256M prefetchable
51  * 60000000 - 60FFFFFF      PCI IO.  16M
52  * 68000000 - 68FFFFFF      PCI Configuration. 16M
53  * 
54  * There are three V3 windows, each described by a pair of V3 registers.
55  * These are LB_BASE0/LB_MAP0, LB_BASE1/LB_MAP1 and LB_BASE2/LB_MAP2.
56  * Base0 and Base1 can be used for any type of PCI memory access.   Base2
57  * can be used either for PCI I/O or for I20 accesses.  By default, uHAL
58  * uses this only for PCI IO space.
59  * 
60  * PCI Memory is mapped so that assigned addresses in PCI Memory match
61  * local bus memory addresses.  In other words, if a PCI device is assigned
62  * address 80200000 then that address is a valid local bus address as well
63  * as a valid PCI Memory address.  PCI IO addresses are mapped to start
64  * at zero.  This means that local bus address 60000000 maps to PCI IO address
65  * 00000000 and so on.   Device driver writers need to be aware of this 
66  * distinction.
67  * 
68  * Normally these spaces are mapped using the following base registers:
69  * 
70  * Usage Local Bus Memory         Base/Map registers used
71  * 
72  * Mem   40000000 - 4FFFFFFF      LB_BASE0/LB_MAP0
73  * Mem   50000000 - 5FFFFFFF      LB_BASE1/LB_MAP1
74  * IO    60000000 - 60FFFFFF      LB_BASE2/LB_MAP2
75  * Cfg   68000000 - 68FFFFFF      
76  * 
77  * This means that I20 and PCI configuration space accesses will fail.
78  * When PCI configuration accesses are needed (via the uHAL PCI 
79  * configuration space primitives) we must remap the spaces as follows:
80  * 
81  * Usage Local Bus Memory         Base/Map registers used
82  * 
83  * Mem   40000000 - 4FFFFFFF      LB_BASE0/LB_MAP0
84  * Mem   50000000 - 5FFFFFFF      LB_BASE0/LB_MAP0
85  * IO    60000000 - 60FFFFFF      LB_BASE2/LB_MAP2
86  * Cfg   68000000 - 68FFFFFF      LB_BASE1/LB_MAP1
87  * 
88  * To make this work, the code depends on overlapping windows working.
89  * The V3 chip translates an address by checking its range within 
90  * each of the BASE/MAP pairs in turn (in ascending register number
91  * order).  It will use the first matching pair.   So, for example,
92  * if the same address is mapped by both LB_BASE0/LB_MAP0 and
93  * LB_BASE1/LB_MAP1, the V3 will use the translation from 
94  * LB_BASE0/LB_MAP0.
95  * 
96  * To allow PCI Configuration space access, the code enlarges the
97  * window mapped by LB_BASE0/LB_MAP0 from 256M to 512M.  This occludes
98  * the windows currently mapped by LB_BASE1/LB_MAP1 so that it can
99  * be remapped for use by configuration cycles.
100  * 
101  * At the end of the PCI Configuration space accesses, 
102  * LB_BASE1/LB_MAP1 is reset to map PCI Memory.  Finally the window
103  * mapped by LB_BASE0/LB_MAP0 is reduced in size from 512M to 256M to
104  * reveal the now restored LB_BASE1/LB_MAP1 window.
105  * 
106  * NOTE: We do not set up I2O mapping.  I suspect that this is only
107  * for an intelligent (target) device.  Using I2O disables most of
108  * the mappings into PCI memory.
109  */
110
111 // V3 access routines
112 #define v3_writeb(o,v) __raw_writeb(v, PCI_V3_VADDR + (unsigned int)(o))
113 #define v3_readb(o)    (__raw_readb(PCI_V3_VADDR + (unsigned int)(o)))
114
115 #define v3_writew(o,v) __raw_writew(v, PCI_V3_VADDR + (unsigned int)(o))
116 #define v3_readw(o)    (__raw_readw(PCI_V3_VADDR + (unsigned int)(o)))
117
118 #define v3_writel(o,v) __raw_writel(v, PCI_V3_VADDR + (unsigned int)(o))
119 #define v3_readl(o)    (__raw_readl(PCI_V3_VADDR + (unsigned int)(o)))
120
121 /*============================================================================
122  *
123  * routine:     uHALir_PCIMakeConfigAddress()
124  *
125  * parameters:  bus = which bus
126  *              device = which device
127  *              function = which function
128  *              offset = configuration space register we are interested in
129  *
130  * description: this routine will generate a platform dependant config
131  *              address.
132  *
133  * calls:       none
134  *
135  * returns:     configuration address to play on the PCI bus
136  *
137  * To generate the appropriate PCI configuration cycles in the PCI 
138  * configuration address space, you present the V3 with the following pattern 
139  * (which is very nearly a type 1 (except that the lower two bits are 00 and
140  * not 01).   In order for this mapping to work you need to set up one of
141  * the local to PCI aperatures to 16Mbytes in length translating to
142  * PCI configuration space starting at 0x0000.0000.
143  *
144  * PCI configuration cycles look like this:
145  *
146  * Type 0:
147  *
148  *  3 3|3 3 2 2|2 2 2 2|2 2 2 2|1 1 1 1|1 1 1 1|1 1 
149  *  3 2|1 0 9 8|7 6 5 4|3 2 1 0|9 8 7 6|5 4 3 2|1 0 9 8|7 6 5 4|3 2 1 0
150  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
151  * | | |D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|F|F|F|R|R|R|R|R|R|0|0|
152  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
153  *
154  *      31:11   Device select bit.
155  *      10:8    Function number
156  *       7:2    Register number
157  *
158  * Type 1:
159  *
160  *  3 3|3 3 2 2|2 2 2 2|2 2 2 2|1 1 1 1|1 1 1 1|1 1 
161  *  3 2|1 0 9 8|7 6 5 4|3 2 1 0|9 8 7 6|5 4 3 2|1 0 9 8|7 6 5 4|3 2 1 0
162  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
163  * | | | | | | | | | | |B|B|B|B|B|B|B|B|D|D|D|D|D|F|F|F|R|R|R|R|R|R|0|1|
164  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
165  *
166  *      31:24   reserved
167  *      23:16   bus number (8 bits = 128 possible buses)
168  *      15:11   Device number (5 bits)
169  *      10:8    function number
170  *       7:2    register number
171  *  
172  */
173 static spinlock_t v3_lock = SPIN_LOCK_UNLOCKED;
174
175 #define PCI_BUS_NONMEM_START    0x00000000
176 #define PCI_BUS_NONMEM_SIZE     0x10000000
177
178 #define PCI_BUS_PREMEM_START    0x10000000
179 #define PCI_BUS_PREMEM_SIZE     0x10000000
180
181 #if PCI_BUS_NONMEM_START & 0x000fffff
182 #error PCI_BUS_NONMEM_START must be megabyte aligned
183 #endif
184 #if PCI_BUS_PREMEM_START & 0x000fffff
185 #error PCI_BUS_PREMEM_START must be megabyte aligned
186 #endif
187
188 #undef V3_LB_BASE_PREFETCH
189 #define V3_LB_BASE_PREFETCH 0
190
191 static unsigned long v3_open_config_window(struct pci_dev *dev, int offset)
192 {
193         unsigned int address, mapaddress, busnr;
194
195         busnr = dev->bus->number;
196
197         /*
198          * Trap out illegal values
199          */
200         if (offset > 255)
201                 BUG();
202         if (busnr > 255)
203                 BUG();
204         if (dev->devfn > 255)
205                 BUG();
206
207         if (busnr == 0) {
208                 int slot = PCI_SLOT(dev->devfn);
209
210                 /*
211                  * local bus segment so need a type 0 config cycle
212                  *
213                  * build the PCI configuration "address" with one-hot in
214                  * A31-A11
215                  *
216                  * mapaddress:
217                  *  3:1 = config cycle (101)
218                  *  0   = PCI A1 & A0 are 0 (0)
219                  */
220                 address = PCI_FUNC(dev->devfn) << 8;
221                 mapaddress = V3_LB_MAP_TYPE_CONFIG;
222
223                 if (slot > 12)
224                         /*
225                          * high order bits are handled by the MAP register
226                          */
227                         mapaddress |= 1 << (slot - 5);
228                 else
229                         /*
230                          * low order bits handled directly in the address
231                          */
232                         address |= 1 << (slot + 11);
233         } else {
234                 /*
235                  * not the local bus segment so need a type 1 config cycle
236                  *
237                  * address:
238                  *  23:16 = bus number
239                  *  15:11 = slot number (7:3 of devfn)
240                  *  10:8  = func number (2:0 of devfn)
241                  *
242                  * mapaddress:
243                  *  3:1 = config cycle (101)
244                  *  0   = PCI A1 & A0 from host bus (1)
245                  */
246                 mapaddress = V3_LB_MAP_TYPE_CONFIG | V3_LB_MAP_AD_LOW_EN;
247                 address = (busnr << 16) | (dev->devfn << 8);
248         }
249
250         /*
251          * Set up base0 to see all 512Mbytes of memory space (not
252          * prefetchable), this frees up base1 for re-use by
253          * configuration memory
254          */
255         v3_writel(V3_LB_BASE0, v3_addr_to_lb_base(PHYS_PCI_MEM_BASE) |
256                         V3_LB_BASE_ADR_SIZE_512MB | V3_LB_BASE_ENABLE);
257
258         /*
259          * Set up base1/map1 to point into configuration space.
260          */
261         v3_writel(V3_LB_BASE1, v3_addr_to_lb_base(PHYS_PCI_CONFIG_BASE) |
262                         V3_LB_BASE_ADR_SIZE_16MB | V3_LB_BASE_ENABLE);
263         v3_writew(V3_LB_MAP1, mapaddress);
264
265         return PCI_CONFIG_VADDR + address + offset;
266 }
267
268 static void v3_close_config_window(void)
269 {
270         /*
271          * Reassign base1 for use by prefetchable PCI memory
272          */
273         v3_writel(V3_LB_BASE1, v3_addr_to_lb_base(PHYS_PCI_MEM_BASE + SZ_256M) |
274                         V3_LB_BASE_ADR_SIZE_256MB | V3_LB_BASE_PREFETCH |
275                         V3_LB_BASE_ENABLE);
276         v3_writew(V3_LB_MAP1, v3_addr_to_lb_map(PCI_BUS_PREMEM_START) |
277                         V3_LB_MAP_TYPE_MEM_MULTIPLE);
278
279         /*
280          * And shrink base0 back to a 256M window (NOTE: MAP0 already correct)
281          */
282         v3_writel(V3_LB_BASE0, v3_addr_to_lb_base(PHYS_PCI_MEM_BASE) |
283                         V3_LB_BASE_ADR_SIZE_256MB | V3_LB_BASE_ENABLE);
284 }
285
286 static int v3_read_config_byte(struct pci_dev *dev, int where, u8 *val)
287 {
288         unsigned long addr;
289         unsigned long flags;
290         u8 v;
291
292         spin_lock_irqsave(&v3_lock, flags);
293         addr = v3_open_config_window(dev, where);
294
295         v = __raw_readb(addr);
296
297         v3_close_config_window();
298         spin_unlock_irqrestore(&v3_lock, flags);
299
300         *val = v;
301         return PCIBIOS_SUCCESSFUL;
302 }
303
304 static int v3_read_config_word(struct pci_dev *dev, int where, u16 *val)
305 {
306         unsigned long addr;
307         unsigned long flags;
308         u16 v;
309
310         spin_lock_irqsave(&v3_lock, flags);
311         addr = v3_open_config_window(dev, where);
312
313         v = __raw_readw(addr);
314
315         v3_close_config_window();
316         spin_unlock_irqrestore(&v3_lock, flags);
317
318         *val = v;
319         return PCIBIOS_SUCCESSFUL;
320 }
321
322 static int v3_read_config_dword(struct pci_dev *dev, int where, u32 *val)
323 {
324         unsigned long addr;
325         unsigned long flags;
326         u32 v;
327
328         spin_lock_irqsave(&v3_lock, flags);
329         addr = v3_open_config_window(dev, where);
330
331         v = __raw_readl(addr);
332
333         v3_close_config_window();
334         spin_unlock_irqrestore(&v3_lock, flags);
335
336         *val = v;
337         return PCIBIOS_SUCCESSFUL;
338 }
339
340 static int v3_write_config_byte(struct pci_dev *dev, int where, u8 val)
341 {
342         unsigned long addr;
343         unsigned long flags;
344
345         spin_lock_irqsave(&v3_lock, flags);
346         addr = v3_open_config_window(dev, where);
347
348         __raw_writeb(val, addr);
349         __raw_readb(addr);
350         
351         v3_close_config_window();
352         spin_unlock_irqrestore(&v3_lock, flags);
353
354         return PCIBIOS_SUCCESSFUL;
355 }
356
357 static int v3_write_config_word(struct pci_dev *dev, int where, u16 val)
358 {
359         unsigned long addr;
360         unsigned long flags;
361
362         spin_lock_irqsave(&v3_lock, flags);
363         addr = v3_open_config_window(dev, where);
364
365         __raw_writew(val, addr);
366         __raw_readw(addr);
367
368         v3_close_config_window();
369         spin_unlock_irqrestore(&v3_lock, flags);
370
371         return PCIBIOS_SUCCESSFUL;
372 }
373
374 static int v3_write_config_dword(struct pci_dev *dev, int where, u32 val)
375 {
376         unsigned long addr;
377         unsigned long flags;
378
379         spin_lock_irqsave(&v3_lock, flags);
380         addr = v3_open_config_window(dev, where);
381
382         __raw_writel(val, addr);
383         __raw_readl(addr);
384
385         v3_close_config_window();
386         spin_unlock_irqrestore(&v3_lock, flags);
387
388         return PCIBIOS_SUCCESSFUL;
389 }
390
391 static struct pci_ops pci_v3_ops = {
392         read_byte:      v3_read_config_byte,
393         read_word:      v3_read_config_word,
394         read_dword:     v3_read_config_dword,
395         write_byte:     v3_write_config_byte,
396         write_word:     v3_write_config_word,
397         write_dword:    v3_write_config_dword,
398 };
399
400 static struct resource non_mem = {
401         name:   "PCI non-prefetchable",
402         start:  0x40000000 + PCI_BUS_NONMEM_START,
403         end:    0x40000000 + PCI_BUS_NONMEM_START + PCI_BUS_NONMEM_SIZE - 1,
404         flags:  IORESOURCE_MEM,
405 };
406
407 static struct resource pre_mem = {
408         name:   "PCI prefetchable",
409         start:  0x40000000 + PCI_BUS_PREMEM_START,
410         end:    0x40000000 + PCI_BUS_PREMEM_START + PCI_BUS_PREMEM_SIZE - 1,
411         flags:  IORESOURCE_MEM | IORESOURCE_PREFETCH,
412 };
413
414 void __init pci_v3_setup_resources(struct resource **resource)
415 {
416         if (request_resource(&iomem_resource, &non_mem))
417                 printk("PCI: unable to allocate non-prefetchable memory region\n");
418         if (request_resource(&iomem_resource, &pre_mem))
419                 printk("PCI: unable to allocate prefetchable memory region\n");
420
421         /*
422          * bus->resource[0] is the IO resource for this bus
423          * bus->resource[1] is the mem resource for this bus
424          * bus->resource[2] is the prefetch mem resource for this bus
425          */
426         resource[0] = &ioport_resource;
427         resource[1] = &non_mem;
428         resource[2] = &pre_mem;
429 }
430
431 /*
432  * These don't seem to be implemented on the Integrator I have, which
433  * means I can't get additional information on the reason for the pm2fb
434  * problems.  I suppose I'll just have to mind-meld with the machine. ;)
435  */
436 #define SC_PCI     (IO_ADDRESS(INTEGRATOR_SC_PCIENABLE))
437 #define SC_LBFADDR (IO_ADDRESS(INTEGRATOR_SC_BASE+0x20))
438 #define SC_LBFCODE (IO_ADDRESS(INTEGRATOR_SC_BASE+0x24))
439
440 static int v3_fault(unsigned long addr, struct pt_regs *regs)
441 {
442         unsigned long pc = instruction_pointer(regs);
443         unsigned long instr = *(unsigned long *)pc;
444
445         printk("V3 fault: address=0x%08lx, pc=0x%08lx [%08lx] LBFADDR=%08x LBFCODE=%02x ISTAT=%02x\n",
446                 addr, pc, instr, __raw_readl(SC_LBFADDR), __raw_readl(SC_LBFCODE) & 255,
447                 v3_readb(V3_LB_ISTAT));
448
449         v3_writeb(V3_LB_ISTAT, 0);
450         __raw_writel(3, SC_PCI);
451
452         /*
453          * If the instruction being executed was a read,
454          * make it look like it read all-ones.
455          */
456         if ((instr & 0x0c100000) == 0x04100000) {
457                 int reg = (instr >> 12) & 15;
458                 unsigned long val;
459
460                 if (instr & 0x00400000)
461                         val = 255;
462                 else
463                         val = -1;
464
465                 regs->uregs[reg] = val;
466                 regs->ARM_pc += 4;
467                 return 0;
468         }
469
470         return 1;
471 }
472
473 static void v3_irq(int irq, void *devid, struct pt_regs *regs)
474 {
475         unsigned long pc = instruction_pointer(regs);
476         unsigned long instr = *(unsigned long *)pc;
477         char buf[128];
478
479         sprintf(buf, "V3 int %d: pc=0x%08lx [%08lx] LBFADDR=%08x LBFCODE=%02x ISTAT=%02x\n", irq,
480                 pc, instr, __raw_readl(SC_LBFADDR), __raw_readl(SC_LBFCODE) & 255,
481                 v3_readb(V3_LB_ISTAT));
482         printascii(buf);
483
484         v3_writeb(V3_LB_ISTAT, 0);
485         __raw_writel(3, SC_PCI);
486
487         /*
488          * If the instruction being executed was a read,
489          * make it look like it read all-ones.
490          */
491         if ((instr & 0x0c100000) == 0x04100000) {
492                 int reg = (instr >> 16) & 15;
493                 sprintf(buf, "   reg%d = %08lx\n", reg, regs->uregs[reg]);
494                 printascii(buf);
495         }
496 }
497
498 static struct irqaction v3_int = {
499         name: "V3",
500         handler: v3_irq,
501 };
502 static struct irqaction v3_int2 = {
503         name: "V3TM",
504         handler: v3_irq,
505 };
506
507 extern int (*external_fault)(unsigned long addr, struct pt_regs *regs);
508
509 /*
510  * V3_LB_BASE? - local bus address
511  * V3_LB_MAP?  - pci bus address
512  */
513 void __init pci_v3_init(void *sysdata)
514 {
515         unsigned int pci_cmd;
516         unsigned long flags;
517
518         /*
519          * Hook in our fault handler for PCI errors
520          */
521         external_fault = v3_fault;
522
523         spin_lock_irqsave(&v3_lock, flags);
524
525         /*
526          * Setup window 0 - PCI non-prefetchable memory
527          *  Local: 0x40000000 Bus: 0x00000000 Size: 256MB
528          */
529         v3_writel(V3_LB_BASE0, v3_addr_to_lb_base(PHYS_PCI_MEM_BASE) |
530                         V3_LB_BASE_ADR_SIZE_256MB | V3_LB_BASE_ENABLE);
531         v3_writew(V3_LB_MAP0, v3_addr_to_lb_map(PCI_BUS_NONMEM_START) |
532                         V3_LB_MAP_TYPE_MEM);
533
534         /*
535          * Setup window 1 - PCI prefetchable memory
536          *  Local: 0x50000000 Bus: 0x10000000 Size: 256MB
537          */
538         v3_writel(V3_LB_BASE1, v3_addr_to_lb_base(PHYS_PCI_MEM_BASE + SZ_256M) |
539                         V3_LB_BASE_ADR_SIZE_256MB | V3_LB_BASE_PREFETCH |
540                         V3_LB_BASE_ENABLE);
541         v3_writew(V3_LB_MAP1, v3_addr_to_lb_map(PCI_BUS_PREMEM_START) |
542                         V3_LB_MAP_TYPE_MEM_MULTIPLE);
543
544         /*
545          * Setup window 2 - PCI IO
546          */
547         v3_writel(V3_LB_BASE2, v3_addr_to_lb_base2(PHYS_PCI_IO_BASE) |
548                         V3_LB_BASE_ENABLE);
549         v3_writew(V3_LB_MAP2, v3_addr_to_lb_map2(0));
550
551         spin_unlock_irqrestore(&v3_lock, flags);
552
553         pci_scan_bus(0, &pci_v3_ops, sysdata);
554
555         pci_cmd = PCI_COMMAND_MEMORY |
556                   PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE;
557
558         v3_writew(V3_PCI_CMD, pci_cmd);
559
560         /*
561          * Clear any error conditions.
562          */
563         __raw_writel(3, SC_PCI);
564         v3_writew(V3_LB_CFG, v3_readw(V3_LB_CFG) | (1 << 10));
565         v3_writeb(V3_LB_ISTAT, 0);
566         v3_writeb(V3_LB_IMASK, 0x68);
567
568         printk("LB_CFG: %04x LB_ISTAT: %02x LB_IMASK: %02x\n",
569                 v3_readw(V3_LB_CFG),
570                 v3_readb(V3_LB_ISTAT),
571                 v3_readb(V3_LB_IMASK));
572         setup_arm_irq(IRQ_V3INT, &v3_int);
573 //      setup_arm_irq(IRQ_LBUSTIMEOUT, &v3_int2);
574 }