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