f211839e2cae18f4d71999ec41ad8ed2a8ff1bca
[releases.git] / pci-vdk.c
1 /* pci-vdk.c: MB93090-MB00 (VDK) PCI support
2  *
3  * Copyright (C) 2003, 2004 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/pci.h>
16 #include <linux/init.h>
17 #include <linux/ioport.h>
18 #include <linux/delay.h>
19
20 #include <asm/segment.h>
21 #include <asm/io.h>
22 #include <asm/mb-regs.h>
23 #include <asm/mb86943a.h>
24 #include "pci-frv.h"
25
26 unsigned int __nongpreldata pci_probe = 1;
27
28 struct pci_ops *__nongpreldata pci_root_ops;
29
30 /*
31  * The accessible PCI window does not cover the entire CPU address space, but
32  * there are devices we want to access outside of that window, so we need to
33  * insert specific PCI bus resources instead of using the platform-level bus
34  * resources directly for the PCI root bus.
35  *
36  * These are configured and inserted by pcibios_init() and are attached to the
37  * root bus by pcibios_fixup_bus().
38  */
39 static struct resource pci_ioport_resource = {
40         .name   = "PCI IO",
41         .start  = 0,
42         .end    = IO_SPACE_LIMIT,
43         .flags  = IORESOURCE_IO,
44 };
45
46 static struct resource pci_iomem_resource = {
47         .name   = "PCI mem",
48         .start  = 0,
49         .end    = -1,
50         .flags  = IORESOURCE_MEM,
51 };
52
53 /*
54  * Functions for accessing PCI configuration space
55  */
56
57 #define CONFIG_CMD(bus, dev, where) \
58         (0x80000000 | (bus->number << 16) | (devfn << 8) | (where & ~3))
59
60 #define __set_PciCfgAddr(A) writel((A), (volatile void __iomem *) __region_CS1 + 0x80)
61
62 #define __get_PciCfgDataB(A) readb((volatile void __iomem *) __region_CS1 + 0x88 + ((A) & 3))
63 #define __get_PciCfgDataW(A) readw((volatile void __iomem *) __region_CS1 + 0x88 + ((A) & 2))
64 #define __get_PciCfgDataL(A) readl((volatile void __iomem *) __region_CS1 + 0x88)
65
66 #define __set_PciCfgDataB(A,V) \
67         writeb((V), (volatile void __iomem *) __region_CS1 + 0x88 + (3 - ((A) & 3)))
68
69 #define __set_PciCfgDataW(A,V) \
70         writew((V), (volatile void __iomem *) __region_CS1 + 0x88 + (2 - ((A) & 2)))
71
72 #define __set_PciCfgDataL(A,V) \
73         writel((V), (volatile void __iomem *) __region_CS1 + 0x88)
74
75 #define __get_PciBridgeDataB(A) readb((volatile void __iomem *) __region_CS1 + 0x800 + (A))
76 #define __get_PciBridgeDataW(A) readw((volatile void __iomem *) __region_CS1 + 0x800 + (A))
77 #define __get_PciBridgeDataL(A) readl((volatile void __iomem *) __region_CS1 + 0x800 + (A))
78
79 #define __set_PciBridgeDataB(A,V) writeb((V), (volatile void __iomem *) __region_CS1 + 0x800 + (A))
80 #define __set_PciBridgeDataW(A,V) writew((V), (volatile void __iomem *) __region_CS1 + 0x800 + (A))
81 #define __set_PciBridgeDataL(A,V) writel((V), (volatile void __iomem *) __region_CS1 + 0x800 + (A))
82
83 static inline int __query(const struct pci_dev *dev)
84 {
85 //      return dev->bus->number==0 && (dev->devfn==PCI_DEVFN(0,0));
86 //      return dev->bus->number==1;
87 //      return dev->bus->number==0 &&
88 //              (dev->devfn==PCI_DEVFN(2,0) || dev->devfn==PCI_DEVFN(3,0));
89         return 0;
90 }
91
92 /*****************************************************************************/
93 /*
94  *
95  */
96 static int pci_frv_read_config(struct pci_bus *bus, unsigned int devfn, int where, int size,
97                                u32 *val)
98 {
99         u32 _value;
100
101         if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
102                 _value = __get_PciBridgeDataL(where & ~3);
103         }
104         else {
105                 __set_PciCfgAddr(CONFIG_CMD(bus, devfn, where));
106                 _value = __get_PciCfgDataL(where & ~3);
107         }
108
109         switch (size) {
110         case 1:
111                 _value = _value >> ((where & 3) * 8);
112                 break;
113
114         case 2:
115                 _value = _value >> ((where & 2) * 8);
116                 break;
117
118         case 4:
119                 break;
120
121         default:
122                 BUG();
123         }
124
125         *val = _value;
126         return PCIBIOS_SUCCESSFUL;
127 }
128
129 static int pci_frv_write_config(struct pci_bus *bus, unsigned int devfn, int where, int size,
130                                 u32 value)
131 {
132         switch (size) {
133         case 1:
134                 if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
135                         __set_PciBridgeDataB(where, value);
136                 }
137                 else {
138                         __set_PciCfgAddr(CONFIG_CMD(bus, devfn, where));
139                         __set_PciCfgDataB(where, value);
140                 }
141                 break;
142
143         case 2:
144                 if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
145                         __set_PciBridgeDataW(where, value);
146                 }
147                 else {
148                         __set_PciCfgAddr(CONFIG_CMD(bus, devfn, where));
149                         __set_PciCfgDataW(where, value);
150                 }
151                 break;
152
153         case 4:
154                 if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
155                         __set_PciBridgeDataL(where, value);
156                 }
157                 else {
158                         __set_PciCfgAddr(CONFIG_CMD(bus, devfn, where));
159                         __set_PciCfgDataL(where, value);
160                 }
161                 break;
162
163         default:
164                 BUG();
165         }
166
167         return PCIBIOS_SUCCESSFUL;
168 }
169
170 static struct pci_ops pci_direct_frv = {
171         .read = pci_frv_read_config,
172         .write = pci_frv_write_config,
173 };
174
175 /*
176  * Before we decide to use direct hardware access mechanisms, we try to do some
177  * trivial checks to ensure it at least _seems_ to be working -- we just test
178  * whether bus 00 contains a host bridge (this is similar to checking
179  * techniques used in XFree86, but ours should be more reliable since we
180  * attempt to make use of direct access hints provided by the PCI BIOS).
181  *
182  * This should be close to trivial, but it isn't, because there are buggy
183  * chipsets (yes, you guessed it, by Intel and Compaq) that have no class ID.
184  */
185 static int __init pci_sanity_check(struct pci_ops *o)
186 {
187         struct pci_bus bus;             /* Fake bus and device */
188         u32 id;
189
190         bus.number      = 0;
191
192         if (o->read(&bus, 0, PCI_VENDOR_ID, 4, &id) == PCIBIOS_SUCCESSFUL) {
193                 printk("PCI: VDK Bridge device:vendor: %08x\n", id);
194                 if (id == 0x200e10cf)
195                         return 1;
196         }
197
198         printk("PCI: VDK Bridge: Sanity check failed\n");
199         return 0;
200 }
201
202 static struct pci_ops * __init pci_check_direct(void)
203 {
204         unsigned long flags;
205
206         local_irq_save(flags);
207
208         /* check if access works */
209         if (pci_sanity_check(&pci_direct_frv)) {
210                 local_irq_restore(flags);
211                 printk("PCI: Using configuration frv\n");
212 //              request_mem_region(0xBE040000, 256, "FRV bridge");
213 //              request_mem_region(0xBFFFFFF4, 12, "PCI frv");
214                 return &pci_direct_frv;
215         }
216
217         local_irq_restore(flags);
218         return NULL;
219 }
220
221 /*
222  * Exceptions for specific devices. Usually work-arounds for fatal design flaws.
223  */
224
225 static void __init pci_fixup_umc_ide(struct pci_dev *d)
226 {
227         /*
228          * UM8886BF IDE controller sets region type bits incorrectly,
229          * therefore they look like memory despite of them being I/O.
230          */
231         int i;
232
233         printk("PCI: Fixing base address flags for device %s\n", pci_name(d));
234         for(i=0; i<4; i++)
235                 d->resource[i].flags |= PCI_BASE_ADDRESS_SPACE_IO;
236 }
237
238 static void pci_fixup_ide_bases(struct pci_dev *d)
239 {
240         int i;
241
242         /*
243          * PCI IDE controllers use non-standard I/O port decoding, respect it.
244          */
245         if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE)
246                 return;
247         printk("PCI: IDE base address fixup for %s\n", pci_name(d));
248         for(i=0; i<4; i++) {
249                 struct resource *r = &d->resource[i];
250                 if ((r->start & ~0x80) == 0x374) {
251                         r->start |= 2;
252                         r->end = r->start;
253                 }
254         }
255 }
256
257 static void pci_fixup_ide_trash(struct pci_dev *d)
258 {
259         int i;
260
261         /*
262          * There exist PCI IDE controllers which have utter garbage
263          * in first four base registers. Ignore that.
264          */
265         printk("PCI: IDE base address trash cleared for %s\n", pci_name(d));
266         for(i=0; i<4; i++)
267                 d->resource[i].start = d->resource[i].end = d->resource[i].flags = 0;
268 }
269
270 static void pci_fixup_latency(struct pci_dev *d)
271 {
272         /*
273          *  SiS 5597 and 5598 chipsets require latency timer set to
274          *  at most 32 to avoid lockups.
275          */
276         DBG("PCI: Setting max latency to 32\n");
277         pcibios_max_latency = 32;
278 }
279
280 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_UMC, PCI_DEVICE_ID_UMC_UM8886BF, pci_fixup_umc_ide);
281 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_5513, pci_fixup_ide_trash);
282 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_5597, pci_fixup_latency);
283 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_5598, pci_fixup_latency);
284 DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_ide_bases);
285
286 /*
287  *  Called after each bus is probed, but before its children
288  *  are examined.
289  */
290
291 void pcibios_fixup_bus(struct pci_bus *bus)
292 {
293 #if 0
294         printk("### PCIBIOS_FIXUP_BUS(%d)\n",bus->number);
295 #endif
296
297         pci_read_bridge_bases(bus);
298
299         if (bus->number == 0) {
300                 struct pci_dev *dev;
301                 list_for_each_entry(dev, &bus->devices, bus_list) {
302                         if (dev->devfn == 0) {
303                                 dev->resource[0].start = 0;
304                                 dev->resource[0].end = 0;
305                         }
306                 }
307         }
308 }
309
310 /*
311  * Initialization. Try all known PCI access methods. Note that we support
312  * using both PCI BIOS and direct access: in such cases, we use I/O ports
313  * to access config space, but we still keep BIOS order of cards to be
314  * compatible with 2.0.X. This should go away some day.
315  */
316
317 int __init pcibios_init(void)
318 {
319         struct pci_bus *bus;
320         struct pci_ops *dir = NULL;
321         LIST_HEAD(resources);
322
323         if (!mb93090_mb00_detected)
324                 return -ENXIO;
325
326         __reg_MB86943_sl_ctl |= MB86943_SL_CTL_DRCT_MASTER_SWAP | MB86943_SL_CTL_DRCT_SLAVE_SWAP;
327
328         __reg_MB86943_ecs_base(1)       = ((__region_CS2 + 0x01000000) >> 9) | 0x08000000;
329         __reg_MB86943_ecs_base(2)       = ((__region_CS2 + 0x00000000) >> 9) | 0x08000000;
330
331         *(volatile uint32_t *) (__region_CS1 + 0x848) = 0xe0000000;
332         *(volatile uint32_t *) (__region_CS1 + 0x8b8) = 0x00000000;
333
334         __reg_MB86943_sl_pci_io_base    = (__region_CS2 + 0x04000000) >> 9;
335         __reg_MB86943_sl_pci_mem_base   = (__region_CS2 + 0x08000000) >> 9;
336         __reg_MB86943_pci_sl_io_base    = __region_CS2 + 0x04000000;
337         __reg_MB86943_pci_sl_mem_base   = __region_CS2 + 0x08000000;
338         mb();
339
340         /* enable PCI arbitration */
341         __reg_MB86943_pci_arbiter       = MB86943_PCIARB_EN;
342
343         pci_ioport_resource.start       = (__reg_MB86943_sl_pci_io_base << 9) & 0xfffffc00;
344         pci_ioport_resource.end         = (__reg_MB86943_sl_pci_io_range << 9) | 0x3ff;
345         pci_ioport_resource.end         += pci_ioport_resource.start;
346
347         printk("PCI IO window:  %08llx-%08llx\n",
348                (unsigned long long) pci_ioport_resource.start,
349                (unsigned long long) pci_ioport_resource.end);
350
351         pci_iomem_resource.start        = (__reg_MB86943_sl_pci_mem_base << 9) & 0xfffffc00;
352         pci_iomem_resource.end          = (__reg_MB86943_sl_pci_mem_range << 9) | 0x3ff;
353         pci_iomem_resource.end          += pci_iomem_resource.start;
354
355         /* Reserve somewhere to write to flush posted writes.  This is used by
356          * __flush_PCI_writes() from asm/io.h to force the write FIFO in the
357          * CPU-PCI bridge to flush as this doesn't happen automatically when a
358          * read is performed on the MB93090 development kit motherboard.
359          */
360         pci_iomem_resource.start        += 0x400;
361
362         printk("PCI MEM window: %08llx-%08llx\n",
363                (unsigned long long) pci_iomem_resource.start,
364                (unsigned long long) pci_iomem_resource.end);
365         printk("PCI DMA memory: %08lx-%08lx\n",
366                dma_coherent_mem_start, dma_coherent_mem_end);
367
368         if (insert_resource(&iomem_resource, &pci_iomem_resource) < 0)
369                 panic("Unable to insert PCI IOMEM resource\n");
370         if (insert_resource(&ioport_resource, &pci_ioport_resource) < 0)
371                 panic("Unable to insert PCI IOPORT resource\n");
372
373         if (!pci_probe)
374                 return -ENXIO;
375
376         dir = pci_check_direct();
377         if (dir)
378                 pci_root_ops = dir;
379         else {
380                 printk("PCI: No PCI bus detected\n");
381                 return -ENXIO;
382         }
383
384         printk("PCI: Probing PCI hardware\n");
385         pci_add_resource(&resources, &pci_ioport_resource);
386         pci_add_resource(&resources, &pci_iomem_resource);
387         bus = pci_scan_root_bus(NULL, 0, pci_root_ops, NULL, &resources);
388
389         pcibios_irq_init();
390         pcibios_fixup_irqs();
391         pcibios_resource_survey();
392         if (!bus)
393                 return 0;
394
395         pci_bus_add_devices(bus);
396         return 0;
397 }
398
399 arch_initcall(pcibios_init);
400
401 char * __init pcibios_setup(char *str)
402 {
403         if (!strcmp(str, "off")) {
404                 pci_probe = 0;
405                 return NULL;
406         }
407         return str;
408 }
409
410 int pcibios_enable_device(struct pci_dev *dev, int mask)
411 {
412         int err;
413
414         if ((err = pci_enable_resources(dev, mask)) < 0)
415                 return err;
416         if (!dev->msi_enabled)
417                 pcibios_enable_irq(dev);
418         return 0;
419 }