xref: /openbmc/linux/arch/alpha/kernel/pci.c (revision 87c2ce3b) 
1 /*
2  *	linux/arch/alpha/kernel/pci.c
3  *
4  * Extruded from code written by
5  *	Dave Rusling (david.rusling@reo.mts.dec.com)
6  *	David Mosberger (davidm@cs.arizona.edu)
7  */
8 
9 /* 2.3.x PCI/resources, 1999 Andrea Arcangeli <andrea@suse.de> */
10 
11 /*
12  * Nov 2000, Ivan Kokshaysky <ink@jurassic.park.msu.ru>
13  *	     PCI-PCI bridges cleanup
14  */
15 #include <linux/config.h>
16 #include <linux/string.h>
17 #include <linux/pci.h>
18 #include <linux/init.h>
19 #include <linux/ioport.h>
20 #include <linux/kernel.h>
21 #include <linux/bootmem.h>
22 #include <linux/module.h>
23 #include <linux/cache.h>
24 #include <linux/slab.h>
25 #include <asm/machvec.h>
26 
27 #include "proto.h"
28 #include "pci_impl.h"
29 
30 
31 /*
32  * Some string constants used by the various core logics.
33  */
34 
35 const char *const pci_io_names[] = {
36   "PCI IO bus 0", "PCI IO bus 1", "PCI IO bus 2", "PCI IO bus 3",
37   "PCI IO bus 4", "PCI IO bus 5", "PCI IO bus 6", "PCI IO bus 7"
38 };
39 
40 const char *const pci_mem_names[] = {
41   "PCI mem bus 0", "PCI mem bus 1", "PCI mem bus 2", "PCI mem bus 3",
42   "PCI mem bus 4", "PCI mem bus 5", "PCI mem bus 6", "PCI mem bus 7"
43 };
44 
45 const char pci_hae0_name[] = "HAE0";
46 
47 /* Indicate whether we respect the PCI setup left by console. */
48 /*
49  * Make this long-lived  so that we know when shutting down
50  * whether we probed only or not.
51  */
52 int pci_probe_only;
53 
54 /*
55  * The PCI controller list.
56  */
57 
58 struct pci_controller *hose_head, **hose_tail = &hose_head;
59 struct pci_controller *pci_isa_hose;
60 
61 /*
62  * Quirks.
63  */
64 
65 static void __init
66 quirk_isa_bridge(struct pci_dev *dev)
67 {
68 	dev->class = PCI_CLASS_BRIDGE_ISA << 8;
69 }
70 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82378, quirk_isa_bridge);
71 
72 static void __init
73 quirk_cypress(struct pci_dev *dev)
74 {
75 	/* The Notorious Cy82C693 chip.  */
76 
77 	/* The Cypress IDE controller doesn't support native mode, but it
78 	   has programmable addresses of IDE command/control registers.
79 	   This violates PCI specifications, confuses the IDE subsystem and
80 	   causes resource conflicts between the primary HD_CMD register and
81 	   the floppy controller.  Ugh.  Fix that.  */
82 	if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE) {
83 		dev->resource[0].flags = 0;
84 		dev->resource[1].flags = 0;
85 	}
86 
87 	/* The Cypress bridge responds on the PCI bus in the address range
88 	   0xffff0000-0xffffffff (conventional x86 BIOS ROM).  There is no
89 	   way to turn this off.  The bridge also supports several extended
90 	   BIOS ranges (disabled after power-up), and some consoles do turn
91 	   them on.  So if we use a large direct-map window, or a large SG
92 	   window, we must avoid the entire 0xfff00000-0xffffffff region.  */
93 	else if (dev->class >> 8 == PCI_CLASS_BRIDGE_ISA) {
94 		if (__direct_map_base + __direct_map_size >= 0xfff00000UL)
95 			__direct_map_size = 0xfff00000UL - __direct_map_base;
96 		else {
97 			struct pci_controller *hose = dev->sysdata;
98 			struct pci_iommu_arena *pci = hose->sg_pci;
99 			if (pci && pci->dma_base + pci->size >= 0xfff00000UL)
100 				pci->size = 0xfff00000UL - pci->dma_base;
101 		}
102 	}
103 }
104 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693, quirk_cypress);
105 
106 /* Called for each device after PCI setup is done. */
107 static void __init
108 pcibios_fixup_final(struct pci_dev *dev)
109 {
110 	unsigned int class = dev->class >> 8;
111 
112 	if (class == PCI_CLASS_BRIDGE_ISA || class == PCI_CLASS_BRIDGE_EISA) {
113 		dev->dma_mask = MAX_ISA_DMA_ADDRESS - 1;
114 		isa_bridge = dev;
115 	}
116 }
117 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_final);
118 
119 /* Just declaring that the power-of-ten prefixes are actually the
120    power-of-two ones doesn't make it true :) */
121 #define KB			1024
122 #define MB			(1024*KB)
123 #define GB			(1024*MB)
124 
125 void
126 pcibios_align_resource(void *data, struct resource *res,
127 		       unsigned long size, unsigned long align)
128 {
129 	struct pci_dev *dev = data;
130 	struct pci_controller *hose = dev->sysdata;
131 	unsigned long alignto;
132 	unsigned long start = res->start;
133 
134 	if (res->flags & IORESOURCE_IO) {
135 		/* Make sure we start at our min on all hoses */
136 		if (start - hose->io_space->start < PCIBIOS_MIN_IO)
137 			start = PCIBIOS_MIN_IO + hose->io_space->start;
138 
139 		/*
140 		 * Put everything into 0x00-0xff region modulo 0x400
141 		 */
142 		if (start & 0x300)
143 			start = (start + 0x3ff) & ~0x3ff;
144 	}
145 	else if	(res->flags & IORESOURCE_MEM) {
146 		/* Make sure we start at our min on all hoses */
147 		if (start - hose->mem_space->start < PCIBIOS_MIN_MEM)
148 			start = PCIBIOS_MIN_MEM + hose->mem_space->start;
149 
150 		/*
151 		 * The following holds at least for the Low Cost
152 		 * Alpha implementation of the PCI interface:
153 		 *
154 		 * In sparse memory address space, the first
155 		 * octant (16MB) of every 128MB segment is
156 		 * aliased to the very first 16 MB of the
157 		 * address space (i.e., it aliases the ISA
158 		 * memory address space).  Thus, we try to
159 		 * avoid allocating PCI devices in that range.
160 		 * Can be allocated in 2nd-7th octant only.
161 		 * Devices that need more than 112MB of
162 		 * address space must be accessed through
163 		 * dense memory space only!
164 		 */
165 
166 		/* Align to multiple of size of minimum base.  */
167 		alignto = max(0x1000UL, align);
168 		start = ALIGN(start, alignto);
169 		if (hose->sparse_mem_base && size <= 7 * 16*MB) {
170 			if (((start / (16*MB)) & 0x7) == 0) {
171 				start &= ~(128*MB - 1);
172 				start += 16*MB;
173 				start  = ALIGN(start, alignto);
174 			}
175 			if (start/(128*MB) != (start + size - 1)/(128*MB)) {
176 				start &= ~(128*MB - 1);
177 				start += (128 + 16)*MB;
178 				start  = ALIGN(start, alignto);
179 			}
180 		}
181 	}
182 
183 	res->start = start;
184 }
185 #undef KB
186 #undef MB
187 #undef GB
188 
189 static int __init
190 pcibios_init(void)
191 {
192 	if (alpha_mv.init_pci)
193 		alpha_mv.init_pci();
194 	return 0;
195 }
196 
197 subsys_initcall(pcibios_init);
198 
199 char * __init
200 pcibios_setup(char *str)
201 {
202 	return str;
203 }
204 
205 #ifdef ALPHA_RESTORE_SRM_SETUP
206 static struct pdev_srm_saved_conf *srm_saved_configs;
207 
208 void __init
209 pdev_save_srm_config(struct pci_dev *dev)
210 {
211 	struct pdev_srm_saved_conf *tmp;
212 	static int printed = 0;
213 
214 	if (!alpha_using_srm || pci_probe_only)
215 		return;
216 
217 	if (!printed) {
218 		printk(KERN_INFO "pci: enabling save/restore of SRM state\n");
219 		printed = 1;
220 	}
221 
222 	tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
223 	if (!tmp) {
224 		printk(KERN_ERR "%s: kmalloc() failed!\n", __FUNCTION__);
225 		return;
226 	}
227 	tmp->next = srm_saved_configs;
228 	tmp->dev = dev;
229 
230 	pci_save_state(dev);
231 
232 	srm_saved_configs = tmp;
233 }
234 
235 void
236 pci_restore_srm_config(void)
237 {
238 	struct pdev_srm_saved_conf *tmp;
239 
240 	/* No need to restore if probed only. */
241 	if (pci_probe_only)
242 		return;
243 
244 	/* Restore SRM config. */
245 	for (tmp = srm_saved_configs; tmp; tmp = tmp->next) {
246 		pci_restore_state(tmp->dev);
247 	}
248 }
249 #endif
250 
251 void __init
252 pcibios_fixup_resource(struct resource *res, struct resource *root)
253 {
254 	res->start += root->start;
255 	res->end += root->start;
256 }
257 
258 void __init
259 pcibios_fixup_device_resources(struct pci_dev *dev, struct pci_bus *bus)
260 {
261 	/* Update device resources.  */
262 	struct pci_controller *hose = (struct pci_controller *)bus->sysdata;
263 	int i;
264 
265 	for (i = 0; i < PCI_NUM_RESOURCES; i++) {
266 		if (!dev->resource[i].start)
267 			continue;
268 		if (dev->resource[i].flags & IORESOURCE_IO)
269 			pcibios_fixup_resource(&dev->resource[i],
270 					       hose->io_space);
271 		else if (dev->resource[i].flags & IORESOURCE_MEM)
272 			pcibios_fixup_resource(&dev->resource[i],
273 					       hose->mem_space);
274 	}
275 }
276 
277 void __init
278 pcibios_fixup_bus(struct pci_bus *bus)
279 {
280 	/* Propagate hose info into the subordinate devices.  */
281 
282 	struct pci_controller *hose = bus->sysdata;
283 	struct pci_dev *dev = bus->self;
284 
285 	if (!dev) {
286 		/* Root bus. */
287 		u32 pci_mem_end;
288 		u32 sg_base = hose->sg_pci ? hose->sg_pci->dma_base : ~0;
289 		unsigned long end;
290 
291 		bus->resource[0] = hose->io_space;
292 		bus->resource[1] = hose->mem_space;
293 
294 		/* Adjust hose mem_space limit to prevent PCI allocations
295 		   in the iommu windows. */
296 		pci_mem_end = min((u32)__direct_map_base, sg_base) - 1;
297 		end = hose->mem_space->start + pci_mem_end;
298 		if (hose->mem_space->end > end)
299 			hose->mem_space->end = end;
300  	} else if (pci_probe_only &&
301  		   (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
302  		pci_read_bridge_bases(bus);
303  		pcibios_fixup_device_resources(dev, bus);
304 	}
305 
306 	list_for_each_entry(dev, &bus->devices, bus_list) {
307 		pdev_save_srm_config(dev);
308 		if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI)
309 			pcibios_fixup_device_resources(dev, bus);
310 	}
311 }
312 
313 void __init
314 pcibios_update_irq(struct pci_dev *dev, int irq)
315 {
316 	pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
317 }
318 
319 /* Most Alphas have straight-forward swizzling needs.  */
320 
321 u8 __init
322 common_swizzle(struct pci_dev *dev, u8 *pinp)
323 {
324 	u8 pin = *pinp;
325 
326 	while (dev->bus->parent) {
327 		pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
328 		/* Move up the chain of bridges. */
329 		dev = dev->bus->self;
330         }
331 	*pinp = pin;
332 
333 	/* The slot is the slot of the last bridge. */
334 	return PCI_SLOT(dev->devfn);
335 }
336 
337 void __devinit
338 pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
339 			 struct resource *res)
340 {
341 	struct pci_controller *hose = (struct pci_controller *)dev->sysdata;
342 	unsigned long offset = 0;
343 
344 	if (res->flags & IORESOURCE_IO)
345 		offset = hose->io_space->start;
346 	else if (res->flags & IORESOURCE_MEM)
347 		offset = hose->mem_space->start;
348 
349 	region->start = res->start - offset;
350 	region->end = res->end - offset;
351 }
352 
353 void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
354 			     struct pci_bus_region *region)
355 {
356 	struct pci_controller *hose = (struct pci_controller *)dev->sysdata;
357 	unsigned long offset = 0;
358 
359 	if (res->flags & IORESOURCE_IO)
360 		offset = hose->io_space->start;
361 	else if (res->flags & IORESOURCE_MEM)
362 		offset = hose->mem_space->start;
363 
364 	res->start = region->start + offset;
365 	res->end = region->end + offset;
366 }
367 
368 #ifdef CONFIG_HOTPLUG
369 EXPORT_SYMBOL(pcibios_resource_to_bus);
370 EXPORT_SYMBOL(pcibios_bus_to_resource);
371 #endif
372 
373 int
374 pcibios_enable_device(struct pci_dev *dev, int mask)
375 {
376 	u16 cmd, oldcmd;
377 	int i;
378 
379 	pci_read_config_word(dev, PCI_COMMAND, &cmd);
380 	oldcmd = cmd;
381 
382 	for (i = 0; i < PCI_NUM_RESOURCES; i++) {
383 		struct resource *res = &dev->resource[i];
384 
385 		if (res->flags & IORESOURCE_IO)
386 			cmd |= PCI_COMMAND_IO;
387 		else if (res->flags & IORESOURCE_MEM)
388 			cmd |= PCI_COMMAND_MEMORY;
389 	}
390 
391 	if (cmd != oldcmd) {
392 		printk(KERN_DEBUG "PCI: Enabling device: (%s), cmd %x\n",
393 		       pci_name(dev), cmd);
394 		/* Enable the appropriate bits in the PCI command register.  */
395 		pci_write_config_word(dev, PCI_COMMAND, cmd);
396 	}
397 	return 0;
398 }
399 
400 /*
401  *  If we set up a device for bus mastering, we need to check the latency
402  *  timer as certain firmware forgets to set it properly, as seen
403  *  on SX164 and LX164 with SRM.
404  */
405 void
406 pcibios_set_master(struct pci_dev *dev)
407 {
408 	u8 lat;
409 	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
410 	if (lat >= 16) return;
411 	printk("PCI: Setting latency timer of device %s to 64\n",
412 							pci_name(dev));
413 	pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
414 }
415 
416 static void __init
417 pcibios_claim_one_bus(struct pci_bus *b)
418 {
419 	struct pci_dev *dev;
420 	struct pci_bus *child_bus;
421 
422 	list_for_each_entry(dev, &b->devices, bus_list) {
423 		int i;
424 
425 		for (i = 0; i < PCI_NUM_RESOURCES; i++) {
426 			struct resource *r = &dev->resource[i];
427 
428 			if (r->parent || !r->start || !r->flags)
429 				continue;
430 			pci_claim_resource(dev, i);
431 		}
432 	}
433 
434 	list_for_each_entry(child_bus, &b->children, node)
435 		pcibios_claim_one_bus(child_bus);
436 }
437 
438 static void __init
439 pcibios_claim_console_setup(void)
440 {
441 	struct pci_bus *b;
442 
443 	list_for_each_entry(b, &pci_root_buses, node)
444 		pcibios_claim_one_bus(b);
445 }
446 
447 void __init
448 common_init_pci(void)
449 {
450 	struct pci_controller *hose;
451 	struct pci_bus *bus;
452 	int next_busno;
453 	int need_domain_info = 0;
454 
455 	/* Scan all of the recorded PCI controllers.  */
456 	for (next_busno = 0, hose = hose_head; hose; hose = hose->next) {
457 		bus = pci_scan_bus(next_busno, alpha_mv.pci_ops, hose);
458 		hose->bus = bus;
459 		hose->need_domain_info = need_domain_info;
460 		next_busno = bus->subordinate + 1;
461 		/* Don't allow 8-bit bus number overflow inside the hose -
462 		   reserve some space for bridges. */
463 		if (next_busno > 224) {
464 			next_busno = 0;
465 			need_domain_info = 1;
466 		}
467 	}
468 
469 	if (pci_probe_only)
470 		pcibios_claim_console_setup();
471 
472 	pci_assign_unassigned_resources();
473 	pci_fixup_irqs(alpha_mv.pci_swizzle, alpha_mv.pci_map_irq);
474 }
475 
476 
477 struct pci_controller * __init
478 alloc_pci_controller(void)
479 {
480 	struct pci_controller *hose;
481 
482 	hose = alloc_bootmem(sizeof(*hose));
483 
484 	*hose_tail = hose;
485 	hose_tail = &hose->next;
486 
487 	return hose;
488 }
489 
490 struct resource * __init
491 alloc_resource(void)
492 {
493 	struct resource *res;
494 
495 	res = alloc_bootmem(sizeof(*res));
496 
497 	return res;
498 }
499 
500 
501 /* Provide information on locations of various I/O regions in physical
502    memory.  Do this on a per-card basis so that we choose the right hose.  */
503 
504 asmlinkage long
505 sys_pciconfig_iobase(long which, unsigned long bus, unsigned long dfn)
506 {
507 	struct pci_controller *hose;
508 	struct pci_dev *dev;
509 
510 	/* from hose or from bus.devfn */
511 	if (which & IOBASE_FROM_HOSE) {
512 		for(hose = hose_head; hose; hose = hose->next)
513 			if (hose->index == bus) break;
514 		if (!hose) return -ENODEV;
515 	} else {
516 		/* Special hook for ISA access.  */
517 		if (bus == 0 && dfn == 0) {
518 			hose = pci_isa_hose;
519 		} else {
520 			dev = pci_find_slot(bus, dfn);
521 			if (!dev)
522 				return -ENODEV;
523 			hose = dev->sysdata;
524 		}
525 	}
526 
527 	switch (which & ~IOBASE_FROM_HOSE) {
528 	case IOBASE_HOSE:
529 		return hose->index;
530 	case IOBASE_SPARSE_MEM:
531 		return hose->sparse_mem_base;
532 	case IOBASE_DENSE_MEM:
533 		return hose->dense_mem_base;
534 	case IOBASE_SPARSE_IO:
535 		return hose->sparse_io_base;
536 	case IOBASE_DENSE_IO:
537 		return hose->dense_io_base;
538 	case IOBASE_ROOT_BUS:
539 		return hose->bus->number;
540 	}
541 
542 	return -EOPNOTSUPP;
543 }
544 
545 /* Create an __iomem token from a PCI BAR.  Copied from lib/iomap.c with
546    no changes, since we don't want the other things in that object file.  */
547 
548 void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
549 {
550 	unsigned long start = pci_resource_start(dev, bar);
551 	unsigned long len = pci_resource_len(dev, bar);
552 	unsigned long flags = pci_resource_flags(dev, bar);
553 
554 	if (!len || !start)
555 		return NULL;
556 	if (maxlen && len > maxlen)
557 		len = maxlen;
558 	if (flags & IORESOURCE_IO)
559 		return ioport_map(start, len);
560 	if (flags & IORESOURCE_MEM) {
561 		/* Not checking IORESOURCE_CACHEABLE because alpha does
562 		   not distinguish between ioremap and ioremap_nocache.  */
563 		return ioremap(start, len);
564 	}
565 	return NULL;
566 }
567 
568 /* Destroy that token.  Not copied from lib/iomap.c.  */
569 
570 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
571 {
572 	if (__is_mmio(addr))
573 		iounmap(addr);
574 }
575 
576 EXPORT_SYMBOL(pci_iomap);
577 EXPORT_SYMBOL(pci_iounmap);
578