Merge branch 'devel' of master.kernel.org:/home/rmk/linux-2.6-mmc
[linux-2.6] / arch / sh / drivers / pci / pci-st40.c
1 /* 
2  * Copyright (C) 2001 David J. Mckay (david.mckay@st.com)
3  *
4  * May be copied or modified under the terms of the GNU General Public
5  * License.  See linux/COPYING for more information.                            
6  *
7  * Support functions for the ST40 PCI hardware.
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/smp.h>
12 #include <linux/smp_lock.h>
13 #include <linux/init.h>
14 #include <linux/errno.h>
15 #include <linux/pci.h>
16 #include <linux/delay.h>
17 #include <linux/types.h>
18 #include <asm/pci.h>
19 #include <linux/irq.h>
20 #include <linux/interrupt.h>    /* irqreturn_t */
21
22 #include "pci-st40.h"
23
24 /* This is in P2 of course */
25 #define ST40PCI_BASE_ADDRESS     (0xb0000000)
26 #define ST40PCI_MEM_ADDRESS      (ST40PCI_BASE_ADDRESS+0x0)
27 #define ST40PCI_IO_ADDRESS       (ST40PCI_BASE_ADDRESS+0x06000000)
28 #define ST40PCI_REG_ADDRESS      (ST40PCI_BASE_ADDRESS+0x07000000)
29
30 #define ST40PCI_REG(x) (ST40PCI_REG_ADDRESS+(ST40PCI_##x))
31 #define ST40PCI_REG_INDEXED(reg, index)                                 \
32         (ST40PCI_REG(reg##0) +                                  \
33           ((ST40PCI_REG(reg##1) - ST40PCI_REG(reg##0))*index))
34
35 #define ST40PCI_WRITE(reg,val) writel((val),ST40PCI_REG(reg))
36 #define ST40PCI_WRITE_SHORT(reg,val) writew((val),ST40PCI_REG(reg))
37 #define ST40PCI_WRITE_BYTE(reg,val) writeb((val),ST40PCI_REG(reg))
38 #define ST40PCI_WRITE_INDEXED(reg, index, val)                          \
39          writel((val), ST40PCI_REG_INDEXED(reg, index));
40
41 #define ST40PCI_READ(reg) readl(ST40PCI_REG(reg))
42 #define ST40PCI_READ_SHORT(reg) readw(ST40PCI_REG(reg))
43 #define ST40PCI_READ_BYTE(reg) readb(ST40PCI_REG(reg))
44
45 #define ST40PCI_SERR_IRQ        64
46 #define ST40PCI_ERR_IRQ         65
47
48
49 /* Macros to extract PLL params */
50 #define PLL_MDIV(reg)  ( ((unsigned)reg) & 0xff )
51 #define PLL_NDIV(reg) ( (((unsigned)reg)>>8) & 0xff )
52 #define PLL_PDIV(reg) ( (((unsigned)reg)>>16) & 0x3 )
53 #define PLL_SETUP(reg) ( (((unsigned)reg)>>19) & 0x1ff )
54
55 /* Build up the appropriate settings */
56 #define PLL_SET(mdiv,ndiv,pdiv,setup) \
57 ( ((mdiv)&0xff) | (((ndiv)&0xff)<<8) | (((pdiv)&3)<<16)| (((setup)&0x1ff)<<19))
58
59 #define PLLPCICR (0xbb040000+0x10)
60
61 #define PLLPCICR_POWERON (1<<28)
62 #define PLLPCICR_OUT_EN (1<<29)
63 #define PLLPCICR_LOCKSELECT (1<<30)
64 #define PLLPCICR_LOCK (1<<31)
65
66
67 #define PLL_25MHZ 0x793c8512
68 #define PLL_33MHZ PLL_SET(18,88,3,295)
69
70 static void pci_set_rbar_region(unsigned int region,     unsigned long localAddr,
71                          unsigned long pciOffset, unsigned long regionSize);
72
73 /*
74  * The pcibios_map_platform_irq function is defined in the appropriate
75  * board specific code and referenced here
76  */
77 extern int __init pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin);
78
79 static __init void SetPCIPLL(void)
80 {
81         {
82                 /* Lets play with the PLL values */
83                 unsigned long pll1cr1;
84                 unsigned long mdiv, ndiv, pdiv;
85                 unsigned long muxcr;
86                 unsigned int muxcr_ratios[4] = { 8, 16, 21, 1 };
87                 unsigned int freq;
88
89 #define CLKGENA            0xbb040000
90 #define CLKGENA_PLL2_MUXCR CLKGENA + 0x48
91                 pll1cr1 = ctrl_inl(PLLPCICR);
92                 printk("PLL1CR1 %08lx\n", pll1cr1);
93                 mdiv = PLL_MDIV(pll1cr1);
94                 ndiv = PLL_NDIV(pll1cr1);
95                 pdiv = PLL_PDIV(pll1cr1);
96                 printk("mdiv %02lx ndiv %02lx pdiv %02lx\n", mdiv, ndiv, pdiv);
97                 freq = ((2*27*ndiv)/mdiv) / (1 << pdiv);
98                 printk("PLL freq %dMHz\n", freq);
99                 muxcr = ctrl_inl(CLKGENA_PLL2_MUXCR);
100                 printk("PCI freq %dMhz\n", freq / muxcr_ratios[muxcr & 3]);
101         }
102 }
103
104
105 struct pci_err {
106   unsigned mask;
107   const char *error_string;
108 };
109
110 static struct pci_err int_error[]={
111   { INT_MNLTDIM,"MNLTDIM: Master non-lock transfer"},
112   { INT_TTADI,  "TTADI: Illegal byte enable in I/O transfer"},
113   { INT_TMTO,   "TMTO: Target memory read/write timeout"},
114   { INT_MDEI,   "MDEI: Master function disable error"},
115   { INT_APEDI,  "APEDI: Address parity error"},
116   { INT_SDI,    "SDI: SERR detected"},
117   { INT_DPEITW, "DPEITW: Data parity error target write"},
118   { INT_PEDITR, "PEDITR: PERR detected"},
119   { INT_TADIM,  "TADIM: Target abort detected"},
120   { INT_MADIM,  "MADIM: Master abort detected"},
121   { INT_MWPDI,  "MWPDI: PERR from target at data write"},
122   { INT_MRDPEI, "MRDPEI: Master read data parity error"}
123 };
124 #define NUM_PCI_INT_ERRS (sizeof(int_error)/sizeof(struct pci_err))
125
126 static struct pci_err aint_error[]={
127   { AINT_MBI,   "MBI: Master broken"},
128   { AINT_TBTOI, "TBTOI: Target bus timeout"},
129   { AINT_MBTOI, "MBTOI: Master bus timeout"},
130   { AINT_TAI,   "TAI: Target abort"},
131   { AINT_MAI,   "MAI: Master abort"},
132   { AINT_RDPEI, "RDPEI: Read data parity"},
133   { AINT_WDPE,  "WDPE: Write data parity"}
134 };
135
136 #define NUM_PCI_AINT_ERRS (sizeof(aint_error)/sizeof(struct pci_err))
137
138 static void print_pci_errors(unsigned reg,struct pci_err *error,int num_errors)
139 {
140   int i;
141
142   for(i=0;i<num_errors;i++) {
143     if(reg & error[i].mask) {
144       printk("%s\n",error[i].error_string);
145     }
146   }
147
148 }
149
150
151 static char * pci_commands[16]={
152         "Int Ack",
153         "Special Cycle",
154         "I/O Read",
155         "I/O Write",
156         "Reserved",
157         "Reserved",
158         "Memory Read",
159         "Memory Write",
160         "Reserved",
161         "Reserved",
162         "Configuration Read",
163         "Configuration Write",
164         "Memory Read Multiple",
165         "Dual Address Cycle",
166         "Memory Read Line",
167         "Memory Write-and-Invalidate"
168 };
169
170 static irqreturn_t st40_pci_irq(int irq, void *dev_instance, struct pt_regs *regs)
171 {
172         unsigned pci_int, pci_air, pci_cir, pci_aint;
173         static int count=0;
174
175
176         pci_int = ST40PCI_READ(INT);pci_aint = ST40PCI_READ(AINT);
177         pci_cir = ST40PCI_READ(CIR);pci_air = ST40PCI_READ(AIR);
178
179         /* Reset state to stop multiple interrupts */
180         ST40PCI_WRITE(INT, ~0); ST40PCI_WRITE(AINT, ~0);
181
182
183         if(++count>1) return IRQ_HANDLED;
184
185         printk("** PCI ERROR **\n");
186
187         if(pci_int) {
188                 printk("** INT register status\n");
189                 print_pci_errors(pci_int,int_error,NUM_PCI_INT_ERRS);
190         }
191
192         if(pci_aint) {
193                 printk("** AINT register status\n");
194                 print_pci_errors(pci_aint,aint_error,NUM_PCI_AINT_ERRS);
195         }
196
197         printk("** Address and command info\n");
198
199         printk("** Command  %s : Address 0x%x\n",
200                pci_commands[pci_cir&0xf],pci_air);
201
202         if(pci_cir&CIR_PIOTEM) {
203                 printk("CIR_PIOTEM:PIO transfer error for master\n");
204         }
205         if(pci_cir&CIR_RWTET) {
206                 printk("CIR_RWTET:Read/Write transfer error for target\n");
207         }
208
209         return IRQ_HANDLED;
210 }
211
212
213 /* Rounds a number UP to the nearest power of two. Used for
214  * sizing the PCI window.
215  */
216 static u32 r2p2(u32 num)
217 {
218         int i = 31;
219         u32 tmp = num;
220
221         if (num == 0)
222                 return 0;
223
224         do {
225                 if (tmp & (1 << 31))
226                         break;
227                 i--;
228                 tmp <<= 1;
229         } while (i >= 0);
230
231         tmp = 1 << i;
232         /* If the original number isn't a power of 2, round it up */
233         if (tmp != num)
234                 tmp <<= 1;
235
236         return tmp;
237 }
238
239 static void __init pci_fixup_ide_bases(struct pci_dev *d)
240 {
241         int i;
242
243         /*
244          * PCI IDE controllers use non-standard I/O port decoding, respect it.
245          */
246         if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE)
247                 return;
248         printk("PCI: IDE base address fixup for %s\n", pci_name(d));
249         for(i=0; i<4; i++) {
250                 struct resource *r = &d->resource[i];
251                 if ((r->start & ~0x80) == 0x374) {
252                         r->start |= 2;
253                         r->end = r->start;
254                 }
255         }
256 }
257 DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_ide_bases);
258
259 int __init st40pci_init(unsigned memStart, unsigned memSize)
260 {
261         u32 lsr0;
262
263         SetPCIPLL();
264
265         /* Initialises the ST40 pci subsystem, performing a reset, then programming
266          * up the address space decoders appropriately
267          */
268
269         /* Should reset core here as well methink */
270
271         ST40PCI_WRITE(CR, CR_LOCK_MASK | CR_SOFT_RESET);
272
273         /* Loop while core resets */
274         while (ST40PCI_READ(CR) & CR_SOFT_RESET);
275
276         /* Switch off interrupts */
277         ST40PCI_WRITE(INTM, 0);
278         ST40PCI_WRITE(AINT, 0);
279
280         /* Now, lets reset all the cards on the bus with extreme prejudice */
281         ST40PCI_WRITE(CR, CR_LOCK_MASK | CR_RSTCTL);
282         udelay(250);
283
284         /* Set bus active, take it out of reset */
285         ST40PCI_WRITE(CR, CR_LOCK_MASK | CR_BMAM | CR_CFINT | CR_PFCS | CR_PFE);
286
287         /* The PCI spec says that no access must be made to the bus until 1 second
288          * after reset. This seem ludicrously long, but some delay is needed here
289          */
290         mdelay(1000);
291
292         /* Switch off interrupts */
293         ST40PCI_WRITE(INTM, 0);
294         ST40PCI_WRITE(AINT, 0);
295
296         /* Allow it to be a master */
297
298         ST40PCI_WRITE_SHORT(CSR_CMD,
299                             PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
300                             PCI_COMMAND_IO);
301
302         /* Accesse to the 0xb0000000 -> 0xb6000000 area will go through to 0x10000000 -> 0x16000000
303          * on the PCI bus. This allows a nice 1-1 bus to phys mapping.
304          */
305
306
307         ST40PCI_WRITE(MBR, 0x10000000);
308         /* Always set the max size 128M (actually, it is only 96MB wide) */
309         ST40PCI_WRITE(MBMR, 0x07ff0000);
310
311         /* I/O addresses are mapped at 0xb6000000 -> 0xb7000000. These are changed to 0, to 
312          * allow cards that have legacy io such as vga to function correctly. This gives a 
313          * maximum of 64K of io/space as only the bottom 16 bits of the address are copied 
314          * over to the bus  when the transaction is made. 64K of io space is more than enough
315          */
316         ST40PCI_WRITE(IOBR, 0x0);
317         /* Set up the 64K window */
318         ST40PCI_WRITE(IOBMR, 0x0);
319
320         /* Now we set up the mbars so the PCI bus can see the local memory */
321         /* Expose a 256M window starting at PCI address 0... */
322         ST40PCI_WRITE(CSR_MBAR0, 0);
323         ST40PCI_WRITE(LSR0, 0x0fff0001);
324
325         /* ... and set up the initial incomming window to expose all of RAM */
326         pci_set_rbar_region(7, memStart, memStart, memSize);
327
328         /* Maximise timeout values */
329         ST40PCI_WRITE_BYTE(CSR_TRDY, 0xff);
330         ST40PCI_WRITE_BYTE(CSR_RETRY, 0xff);
331         ST40PCI_WRITE_BYTE(CSR_MIT, 0xff);
332
333         ST40PCI_WRITE_BYTE(PERF,PERF_MASTER_WRITE_POSTING);
334
335         return 1;
336 }
337
338 char * __init pcibios_setup(char *str)
339 {
340         return str;
341 }
342
343
344 #define SET_CONFIG_BITS(bus,devfn,where)\
345   (((bus) << 16) | ((devfn) << 8) | ((where) & ~3) | (bus!=0))
346
347 #define CONFIG_CMD(bus, devfn, where) SET_CONFIG_BITS(bus->number,devfn,where)
348
349
350 static int CheckForMasterAbort(void)
351 {
352         if (ST40PCI_READ(INT) & INT_MADIM) {
353                 /* Should we clear config space version as well ??? */
354                 ST40PCI_WRITE(INT, INT_MADIM);
355                 ST40PCI_WRITE_SHORT(CSR_STATUS, 0);
356                 return 1;
357         }
358
359         return 0;
360 }
361
362 /* Write to config register */
363 static int st40pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 * val)
364 {
365         ST40PCI_WRITE(PAR, CONFIG_CMD(bus, devfn, where));
366         switch (size) {
367                 case 1:
368                         *val = (u8)ST40PCI_READ_BYTE(PDR + (where & 3));
369                         break;
370                 case 2:
371                         *val = (u16)ST40PCI_READ_SHORT(PDR + (where & 2));
372                         break;
373                 case 4:
374                         *val = ST40PCI_READ(PDR);
375                         break;
376         }
377
378         if (CheckForMasterAbort()){
379                 switch (size) {
380                         case 1:
381                                 *val = (u8)0xff;
382                                 break;
383                         case 2:
384                                 *val = (u16)0xffff;
385                                 break;
386                         case 4:
387                                 *val = 0xffffffff;
388                                 break;
389                 }
390         }
391
392         return PCIBIOS_SUCCESSFUL;
393 }
394
395 static int st40pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val)
396 {
397         ST40PCI_WRITE(PAR, CONFIG_CMD(bus, devfn, where));
398
399         switch (size) {
400                 case 1:
401                         ST40PCI_WRITE_BYTE(PDR + (where & 3), (u8)val);
402                         break;
403                 case 2:
404                         ST40PCI_WRITE_SHORT(PDR + (where & 2), (u16)val);
405                         break;
406                 case 4:
407                         ST40PCI_WRITE(PDR, val);
408                         break;
409         }
410
411         CheckForMasterAbort();
412
413         return PCIBIOS_SUCCESSFUL;
414 }
415
416 struct pci_ops st40pci_config_ops = {
417         .read =         st40pci_read,
418         .write =        st40pci_write,
419 };
420
421
422 /* Everything hangs off this */
423 static struct pci_bus *pci_root_bus;
424
425
426 static u8 __init no_swizzle(struct pci_dev *dev, u8 * pin)
427 {
428         return PCI_SLOT(dev->devfn);
429 }
430
431
432 static int __init pcibios_init(void)
433 {
434         extern unsigned long memory_start, memory_end;
435
436         printk(KERN_ALERT "pci-st40.c: pcibios_init\n");
437
438         if (sh_mv.mv_init_pci != NULL) {
439                 sh_mv.mv_init_pci();
440         }
441
442         /* The pci subsytem needs to know where memory is and how much 
443          * of it there is. I've simply made these globals. A better mechanism
444          * is probably needed.
445          */
446         st40pci_init(PHYSADDR(memory_start),
447                      PHYSADDR(memory_end) - PHYSADDR(memory_start));
448
449         if (request_irq(ST40PCI_ERR_IRQ, st40_pci_irq, 
450                         IRQF_DISABLED, "st40pci", NULL)) {
451                 printk(KERN_ERR "st40pci: Cannot hook interrupt\n");
452                 return -EIO;
453         }
454
455         /* Enable the PCI interrupts on the device */
456         ST40PCI_WRITE(INTM, ~0);
457         ST40PCI_WRITE(AINT, ~0);
458
459         /* Map the io address apprioately */
460 #ifdef CONFIG_HD64465
461         hd64465_port_map(PCIBIOS_MIN_IO, (64 * 1024) - PCIBIOS_MIN_IO + 1,
462                          ST40_IO_ADDR + PCIBIOS_MIN_IO, 0);
463 #endif
464
465         /* ok, do the scan man */
466         pci_root_bus = pci_scan_bus(0, &st40pci_config_ops, NULL);
467         pci_assign_unassigned_resources();
468         pci_fixup_irqs(no_swizzle, pcibios_map_platform_irq);
469
470         return 0;
471 }
472
473 subsys_initcall(pcibios_init);
474
475 void __init pcibios_fixup_bus(struct pci_bus *bus)
476 {
477 }
478
479 /*
480  * Publish a region of local address space over the PCI bus
481  * to other devices.
482  */
483 static void pci_set_rbar_region(unsigned int region,     unsigned long localAddr,
484                          unsigned long pciOffset, unsigned long regionSize)
485 {
486         unsigned long mask;
487
488         if (region > 7)
489                 return;
490
491         if (regionSize > (512 * 1024 * 1024))
492                 return;
493
494         mask = r2p2(regionSize) - 0x10000;
495
496         /* Diable the region (in case currently in use, should never happen) */
497         ST40PCI_WRITE_INDEXED(RSR, region, 0);
498
499         /* Start of local address space to publish */
500         ST40PCI_WRITE_INDEXED(RLAR, region, PHYSADDR(localAddr) );
501
502         /* Start of region in PCI address space as an offset from MBAR0 */
503         ST40PCI_WRITE_INDEXED(RBAR, region, pciOffset);
504
505         /* Size of region */
506         ST40PCI_WRITE_INDEXED(RSR, region, mask | 1);
507 }
508