Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pci.c
Go to the documentation of this file.
1 /* ASB2305 PCI support
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells ([email protected])
5  * Derived from arch/i386/kernel/pci-pc.c
6  * (c) 1999--2000 Martin Mares <[email protected]>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public Licence
10  * as published by the Free Software Foundation; either version
11  * 2 of the Licence, or (at your option) any later version.
12  */
13 #include <linux/types.h>
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
16 #include <linux/pci.h>
17 #include <linux/init.h>
18 #include <linux/ioport.h>
19 #include <linux/delay.h>
20 #include <asm/io.h>
21 #include "pci-asb2305.h"
22 
23 unsigned int pci_probe = 1;
24 
28 
29 /*
30  * The accessible PCI window does not cover the entire CPU address space, but
31  * there are devices we want to access outside of that window, so we need to
32  * insert specific PCI bus resources instead of using the platform-level bus
33  * resources directly for the PCI root bus.
34  *
35  * These are configured and inserted by pcibios_init().
36  */
37 static struct resource pci_ioport_resource = {
38  .name = "PCI IO",
39  .start = 0xbe000000,
40  .end = 0xbe03ffff,
41  .flags = IORESOURCE_IO,
42 };
43 
44 static struct resource pci_iomem_resource = {
45  .name = "PCI mem",
46  .start = 0xb8000000,
47  .end = 0xbbffffff,
48  .flags = IORESOURCE_MEM,
49 };
50 
51 /*
52  * Functions for accessing PCI configuration space
53  */
54 
55 #define CONFIG_CMD(bus, devfn, where) \
56  (0x80000000 | (bus->number << 16) | (devfn << 8) | (where & ~3))
57 
58 #define MEM_PAGING_REG (*(volatile __u32 *) 0xBFFFFFF4)
59 #define CONFIG_ADDRESS (*(volatile __u32 *) 0xBFFFFFF8)
60 #define CONFIG_DATAL(X) (*(volatile __u32 *) 0xBFFFFFFC)
61 #define CONFIG_DATAW(X) (*(volatile __u16 *) (0xBFFFFFFC + ((X) & 2)))
62 #define CONFIG_DATAB(X) (*(volatile __u8 *) (0xBFFFFFFC + ((X) & 3)))
63 
64 #define BRIDGEREGB(X) (*(volatile __u8 *) (0xBE040000 + (X)))
65 #define BRIDGEREGW(X) (*(volatile __u16 *) (0xBE040000 + (X)))
66 #define BRIDGEREGL(X) (*(volatile __u32 *) (0xBE040000 + (X)))
67 
68 static inline int __query(const struct pci_bus *bus, unsigned int devfn)
69 {
70 #if 0
71  return bus->number == 0 && (devfn == PCI_DEVFN(0, 0));
72  return bus->number == 1;
73  return bus->number == 0 &&
74  (devfn == PCI_DEVFN(2, 0) || devfn == PCI_DEVFN(3, 0));
75 #endif
76  return 1;
77 }
78 
79 /*
80  *
81  */
82 static int pci_ampci_read_config_byte(struct pci_bus *bus, unsigned int devfn,
83  int where, u32 *_value)
84 {
85  u32 rawval, value;
86 
87  if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
88  value = BRIDGEREGB(where);
89  __pcbdebug("=> %02hx", &BRIDGEREGL(where), value);
90  } else {
91  CONFIG_ADDRESS = CONFIG_CMD(bus, devfn, where);
92  rawval = CONFIG_ADDRESS;
93  value = CONFIG_DATAB(where);
94  if (__query(bus, devfn))
95  __pcidebug("=> %02hx", bus, devfn, where, value);
96  }
97 
98  *_value = value;
99  return PCIBIOS_SUCCESSFUL;
100 }
101 
102 static int pci_ampci_read_config_word(struct pci_bus *bus, unsigned int devfn,
103  int where, u32 *_value)
104 {
105  u32 rawval, value;
106 
107  if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
108  value = BRIDGEREGW(where);
109  __pcbdebug("=> %04hx", &BRIDGEREGL(where), value);
110  } else {
111  CONFIG_ADDRESS = CONFIG_CMD(bus, devfn, where);
112  rawval = CONFIG_ADDRESS;
113  value = CONFIG_DATAW(where);
114  if (__query(bus, devfn))
115  __pcidebug("=> %04hx", bus, devfn, where, value);
116  }
117 
118  *_value = value;
119  return PCIBIOS_SUCCESSFUL;
120 }
121 
122 static int pci_ampci_read_config_dword(struct pci_bus *bus, unsigned int devfn,
123  int where, u32 *_value)
124 {
125  u32 rawval, value;
126 
127  if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
128  value = BRIDGEREGL(where);
129  __pcbdebug("=> %08x", &BRIDGEREGL(where), value);
130  } else {
131  CONFIG_ADDRESS = CONFIG_CMD(bus, devfn, where);
132  rawval = CONFIG_ADDRESS;
133  value = CONFIG_DATAL(where);
134  if (__query(bus, devfn))
135  __pcidebug("=> %08x", bus, devfn, where, value);
136  }
137 
138  *_value = value;
139  return PCIBIOS_SUCCESSFUL;
140 }
141 
142 static int pci_ampci_write_config_byte(struct pci_bus *bus, unsigned int devfn,
143  int where, u8 value)
144 {
145  u32 rawval;
146 
147  if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
148  __pcbdebug("<= %02x", &BRIDGEREGB(where), value);
149  BRIDGEREGB(where) = value;
150  } else {
151  if (bus->number == 0 &&
152  (devfn == PCI_DEVFN(2, 0) || devfn == PCI_DEVFN(3, 0))
153  )
154  __pcidebug("<= %02x", bus, devfn, where, value);
155  CONFIG_ADDRESS = CONFIG_CMD(bus, devfn, where);
156  rawval = CONFIG_ADDRESS;
157  CONFIG_DATAB(where) = value;
158  }
159  return PCIBIOS_SUCCESSFUL;
160 }
161 
162 static int pci_ampci_write_config_word(struct pci_bus *bus, unsigned int devfn,
163  int where, u16 value)
164 {
165  u32 rawval;
166 
167  if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
168  __pcbdebug("<= %04hx", &BRIDGEREGW(where), value);
169  BRIDGEREGW(where) = value;
170  } else {
171  if (__query(bus, devfn))
172  __pcidebug("<= %04hx", bus, devfn, where, value);
173  CONFIG_ADDRESS = CONFIG_CMD(bus, devfn, where);
174  rawval = CONFIG_ADDRESS;
175  CONFIG_DATAW(where) = value;
176  }
177  return PCIBIOS_SUCCESSFUL;
178 }
179 
180 static int pci_ampci_write_config_dword(struct pci_bus *bus, unsigned int devfn,
181  int where, u32 value)
182 {
183  u32 rawval;
184 
185  if (bus->number == 0 && devfn == PCI_DEVFN(0, 0)) {
186  __pcbdebug("<= %08x", &BRIDGEREGL(where), value);
187  BRIDGEREGL(where) = value;
188  } else {
189  if (__query(bus, devfn))
190  __pcidebug("<= %08x", bus, devfn, where, value);
191  CONFIG_ADDRESS = CONFIG_CMD(bus, devfn, where);
192  rawval = CONFIG_ADDRESS;
193  CONFIG_DATAL(where) = value;
194  }
195  return PCIBIOS_SUCCESSFUL;
196 }
197 
198 static int pci_ampci_read_config(struct pci_bus *bus, unsigned int devfn,
199  int where, int size, u32 *val)
200 {
201  switch (size) {
202  case 1:
203  return pci_ampci_read_config_byte(bus, devfn, where, val);
204  case 2:
205  return pci_ampci_read_config_word(bus, devfn, where, val);
206  case 4:
207  return pci_ampci_read_config_dword(bus, devfn, where, val);
208  default:
209  BUG();
210  return -EOPNOTSUPP;
211  }
212 }
213 
214 static int pci_ampci_write_config(struct pci_bus *bus, unsigned int devfn,
215  int where, int size, u32 val)
216 {
217  switch (size) {
218  case 1:
219  return pci_ampci_write_config_byte(bus, devfn, where, val);
220  case 2:
221  return pci_ampci_write_config_word(bus, devfn, where, val);
222  case 4:
223  return pci_ampci_write_config_dword(bus, devfn, where, val);
224  default:
225  BUG();
226  return -EOPNOTSUPP;
227  }
228 }
229 
230 static struct pci_ops pci_direct_ampci = {
231  pci_ampci_read_config,
232  pci_ampci_write_config,
233 };
234 
235 /*
236  * Before we decide to use direct hardware access mechanisms, we try to do some
237  * trivial checks to ensure it at least _seems_ to be working -- we just test
238  * whether bus 00 contains a host bridge (this is similar to checking
239  * techniques used in XFree86, but ours should be more reliable since we
240  * attempt to make use of direct access hints provided by the PCI BIOS).
241  *
242  * This should be close to trivial, but it isn't, because there are buggy
243  * chipsets (yes, you guessed it, by Intel and Compaq) that have no class ID.
244  */
245 static int __init pci_sanity_check(struct pci_ops *o)
246 {
247  struct pci_bus bus; /* Fake bus and device */
248  u32 x;
249 
250  bus.number = 0;
251 
252  if ((!o->read(&bus, 0, PCI_CLASS_DEVICE, 2, &x) &&
254  (!o->read(&bus, 0, PCI_VENDOR_ID, 2, &x) &&
256  return 1;
257 
258  printk(KERN_ERR "PCI: Sanity check failed\n");
259  return 0;
260 }
261 
262 static int __init pci_check_direct(void)
263 {
264  unsigned long flags;
265 
266  local_irq_save(flags);
267 
268  /*
269  * Check if access works.
270  */
271  if (pci_sanity_check(&pci_direct_ampci)) {
272  local_irq_restore(flags);
273  printk(KERN_INFO "PCI: Using configuration ampci\n");
274  request_mem_region(0xBE040000, 256, "AMPCI bridge");
275  request_mem_region(0xBFFFFFF4, 12, "PCI ampci");
276  request_mem_region(0xBC000000, 32 * 1024 * 1024, "PCI SRAM");
277  return 0;
278  }
279 
280  local_irq_restore(flags);
281  return -ENODEV;
282 }
283 
284 static int __devinit is_valid_resource(struct pci_dev *dev, int idx)
285 {
286  unsigned int i, type_mask = IORESOURCE_IO | IORESOURCE_MEM;
287  struct resource *devr = &dev->resource[idx], *busr;
288 
289  if (dev->bus) {
290  pci_bus_for_each_resource(dev->bus, busr, i) {
291  if (!busr || (busr->flags ^ devr->flags) & type_mask)
292  continue;
293 
294  if (devr->start &&
295  devr->start >= busr->start &&
296  devr->end <= busr->end)
297  return 1;
298  }
299  }
300 
301  return 0;
302 }
303 
304 static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
305 {
306  struct pci_bus_region region;
307  int i;
308  int limit;
309 
310  if (dev->bus->number != 0)
311  return;
312 
313  limit = (dev->hdr_type == PCI_HEADER_TYPE_NORMAL) ?
315 
316  for (i = 0; i < limit; i++) {
317  if (!dev->resource[i].flags)
318  continue;
319 
320  if (is_valid_resource(dev, i))
321  pci_claim_resource(dev, i);
322  }
323 }
324 
325 /*
326  * Called after each bus is probed, but before its children
327  * are examined.
328  */
330 {
331  struct pci_dev *dev;
332 
333  if (bus->self) {
336  }
337 
340 }
341 
342 /*
343  * Initialization. Try all known PCI access methods. Note that we support
344  * using both PCI BIOS and direct access: in such cases, we use I/O ports
345  * to access config space, but we still keep BIOS order of cards to be
346  * compatible with 2.0.X. This should go away some day.
347  */
348 static int __init pcibios_init(void)
349 {
350  resource_size_t io_offset, mem_offset;
352 
353  ioport_resource.start = 0xA0000000;
354  ioport_resource.end = 0xDFFFFFFF;
355  iomem_resource.start = 0xA0000000;
356  iomem_resource.end = 0xDFFFFFFF;
357 
358  if (insert_resource(&iomem_resource, &pci_iomem_resource) < 0)
359  panic("Unable to insert PCI IOMEM resource\n");
360  if (insert_resource(&ioport_resource, &pci_ioport_resource) < 0)
361  panic("Unable to insert PCI IOPORT resource\n");
362 
363  if (!pci_probe)
364  return 0;
365 
366  if (pci_check_direct() < 0) {
367  printk(KERN_WARNING "PCI: No PCI bus detected\n");
368  return 0;
369  }
370 
371  printk(KERN_INFO "PCI: Probing PCI hardware [mempage %08x]\n",
373 
374  io_offset = pci_ioport_resource.start -
375  (pci_ioport_resource.start & 0x00ffffff);
376  mem_offset = pci_iomem_resource.start -
377  ((pci_iomem_resource.start & 0x03ffffff) | MEM_PAGING_REG);
378 
379  pci_add_resource_offset(&resources, &pci_ioport_resource, io_offset);
380  pci_add_resource_offset(&resources, &pci_iomem_resource, mem_offset);
381  pci_root_bus = pci_scan_root_bus(NULL, 0, &pci_direct_ampci, NULL,
382  &resources);
383 
387  return 0;
388 }
389 
390 arch_initcall(pcibios_init);
391 
393 {
394  if (!strcmp(str, "off")) {
395  pci_probe = 0;
396  return NULL;
397 
398  } else if (!strncmp(str, "lastbus=", 8)) {
399  pcibios_last_bus = simple_strtol(str+8, NULL, 0);
400  return NULL;
401  }
402 
403  return str;
404 }
405 
406 int pcibios_enable_device(struct pci_dev *dev, int mask)
407 {
408  int err;
409 
410  err = pci_enable_resources(dev, mask);
411  if (err == 0)
412  pcibios_enable_irq(dev);
413  return err;
414 }
415 
416 /*
417  * disable the ethernet chipset
418  */
419 static void __init unit_disable_pcnet(struct pci_bus *bus, struct pci_ops *o)
420 {
421  u32 x;
422 
423  bus->number = 0;
424 
425  o->read (bus, PCI_DEVFN(2, 0), PCI_VENDOR_ID, 4, &x);
426  o->read (bus, PCI_DEVFN(2, 0), PCI_COMMAND, 2, &x);
427  x |= PCI_COMMAND_MASTER |
430  o->write(bus, PCI_DEVFN(2, 0), PCI_COMMAND, 2, x);
431  o->read (bus, PCI_DEVFN(2, 0), PCI_COMMAND, 2, &x);
432  o->write(bus, PCI_DEVFN(2, 0), PCI_BASE_ADDRESS_0, 4, 0x00030001);
433  o->read (bus, PCI_DEVFN(2, 0), PCI_BASE_ADDRESS_0, 4, &x);
434 
435 #define RDP (*(volatile u32 *) 0xBE030010)
436 #define RAP (*(volatile u32 *) 0xBE030014)
437 #define __set_RAP(X) do { RAP = (X); x = RAP; } while (0)
438 #define __set_RDP(X) do { RDP = (X); x = RDP; } while (0)
439 #define __get_RDP() ({ RDP & 0xffff; })
440 
441  __set_RAP(0);
442  __set_RDP(0x0004); /* CSR0 = STOP */
443 
444  __set_RAP(88); /* check CSR88 indicates an Am79C973 */
445  BUG_ON(__get_RDP() != 0x5003);
446 
447  for (x = 0; x < 100; x++)
448  asm volatile("nop");
449 
450  __set_RDP(0x0004); /* CSR0 = STOP */
451 }
452 
453 /*
454  * initialise the unit hardware
455  */
457 {
458  struct pci_bus bus; /* Fake bus and device */
459  struct pci_ops *o = &pci_direct_ampci;
460  u32 x;
461 
462  set_intr_level(XIRQ1, NUM2GxICR_LEVEL(CONFIG_PCI_IRQ_LEVEL));
463 
464  memset(&bus, 0, sizeof(bus));
465 
466  MEM_PAGING_REG = 0xE8000000;
467 
468  /* we need to set up the bridge _now_ or we won't be able to access the
469  * PCI config registers
470  */
474  BRIDGEREGW(PCI_STATUS) = 0xF800;
476  BRIDGEREGL(PCI_BASE_ADDRESS_0) = 0x80000000;
478  BRIDGEREGL(0x48) = 0x98000000; /* AMPCI base addr */
479  BRIDGEREGB(0x41) = 0x00; /* secondary bus
480  * number */
481  BRIDGEREGB(0x42) = 0x01; /* subordinate bus
482  * number */
483  BRIDGEREGB(0x44) = 0x01;
484  BRIDGEREGL(0x50) = 0x00000001;
485  BRIDGEREGL(0x58) = 0x00001002;
486  BRIDGEREGL(0x5C) = 0x00000011;
487 
488  /* we also need to set up the PCI-PCI bridge */
489  bus.number = 0;
490 
491  /* IO: 0x00000000-0x00020000 */
492  o->read (&bus, PCI_DEVFN(3, 0), PCI_COMMAND, 2, &x);
493  x |= PCI_COMMAND_MASTER |
496  o->write(&bus, PCI_DEVFN(3, 0), PCI_COMMAND, 2, x);
497 
498  o->read (&bus, PCI_DEVFN(3, 0), PCI_IO_BASE, 1, &x);
499  o->read (&bus, PCI_DEVFN(3, 0), PCI_IO_BASE_UPPER16, 4, &x);
500  o->read (&bus, PCI_DEVFN(3, 0), PCI_MEMORY_BASE, 4, &x);
501  o->read (&bus, PCI_DEVFN(3, 0), PCI_PREF_MEMORY_BASE, 4, &x);
502 
503  o->write(&bus, PCI_DEVFN(3, 0), PCI_IO_BASE, 1, 0x01);
504  o->read (&bus, PCI_DEVFN(3, 0), PCI_IO_BASE, 1, &x);
505  o->write(&bus, PCI_DEVFN(3, 0), PCI_IO_BASE_UPPER16, 4, 0x00020000);
506  o->read (&bus, PCI_DEVFN(3, 0), PCI_IO_BASE_UPPER16, 4, &x);
507  o->write(&bus, PCI_DEVFN(3, 0), PCI_MEMORY_BASE, 4, 0xEBB0EA00);
508  o->read (&bus, PCI_DEVFN(3, 0), PCI_MEMORY_BASE, 4, &x);
509  o->write(&bus, PCI_DEVFN(3, 0), PCI_PREF_MEMORY_BASE, 4, 0xE9F0E800);
510  o->read (&bus, PCI_DEVFN(3, 0), PCI_PREF_MEMORY_BASE, 4, &x);
511 
512  unit_disable_pcnet(&bus, o);
513 }