pci root complex: support for tile architecture
[linux-3.10.git] / arch / tile / kernel / pci.c
1 /*
2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
3  *
4  *   This program is free software; you can redistribute it and/or
5  *   modify it under the terms of the GNU General Public License
6  *   as published by the Free Software Foundation, version 2.
7  *
8  *   This program is distributed in the hope that it will be useful, but
9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11  *   NON INFRINGEMENT.  See the GNU General Public License for
12  *   more details.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/pci.h>
17 #include <linux/delay.h>
18 #include <linux/string.h>
19 #include <linux/init.h>
20 #include <linux/capability.h>
21 #include <linux/sched.h>
22 #include <linux/errno.h>
23 #include <linux/bootmem.h>
24 #include <linux/irq.h>
25 #include <linux/io.h>
26 #include <linux/uaccess.h>
27
28 #include <asm/processor.h>
29 #include <asm/sections.h>
30 #include <asm/byteorder.h>
31 #include <asm/hv_driver.h>
32 #include <hv/drv_pcie_rc_intf.h>
33
34
35 /*
36  * Initialization flow and process
37  * -------------------------------
38  *
39  * This files containes the routines to search for PCI buses,
40  * enumerate the buses, and configure any attached devices.
41  *
42  * There are two entry points here:
43  * 1) tile_pci_init
44  *    This sets up the pci_controller structs, and opens the
45  *    FDs to the hypervisor.  This is called from setup_arch() early
46  *    in the boot process.
47  * 2) pcibios_init
48  *    This probes the PCI bus(es) for any attached hardware.  It's
49  *    called by subsys_initcall.  All of the real work is done by the
50  *    generic Linux PCI layer.
51  *
52  */
53
54 /*
55  * This flag tells if the platform is TILEmpower that needs
56  * special configuration for the PLX switch chip.
57  */
58 int __write_once tile_plx_gen1;
59
60 static struct pci_controller controllers[TILE_NUM_PCIE];
61 static int num_controllers;
62
63 static struct pci_ops tile_cfg_ops;
64
65
66 /*
67  * We don't need to worry about the alignment of resources.
68  */
69 resource_size_t pcibios_align_resource(void *data, const struct resource *res,
70                             resource_size_t size, resource_size_t align)
71 {
72         return res->start;
73 }
74 EXPORT_SYMBOL(pcibios_align_resource);
75
76 /*
77  * Open a FD to the hypervisor PCI device.
78  *
79  * controller_id is the controller number, config type is 0 or 1 for
80  * config0 or config1 operations.
81  */
82 static int __init tile_pcie_open(int controller_id, int config_type)
83 {
84         char filename[32];
85         int fd;
86
87         sprintf(filename, "pcie/%d/config%d", controller_id, config_type);
88
89         fd = hv_dev_open((HV_VirtAddr)filename, 0);
90
91         return fd;
92 }
93
94
95 /*
96  * Get the IRQ numbers from the HV and set up the handlers for them.
97  */
98 static int __init tile_init_irqs(int controller_id,
99                                  struct pci_controller *controller)
100 {
101         char filename[32];
102         int fd;
103         int ret;
104         int x;
105         struct pcie_rc_config rc_config;
106
107         sprintf(filename, "pcie/%d/ctl", controller_id);
108         fd = hv_dev_open((HV_VirtAddr)filename, 0);
109         if (fd < 0) {
110                 pr_err("PCI: hv_dev_open(%s) failed\n", filename);
111                 return -1;
112         }
113         ret = hv_dev_pread(fd, 0, (HV_VirtAddr)(&rc_config),
114                            sizeof(rc_config), PCIE_RC_CONFIG_MASK_OFF);
115         hv_dev_close(fd);
116         if (ret != sizeof(rc_config)) {
117                 pr_err("PCI: wanted %zd bytes, got %d\n",
118                        sizeof(rc_config), ret);
119                 return -1;
120         }
121         /* Record irq_base so that we can map INTx to IRQ # later. */
122         controller->irq_base = rc_config.intr;
123
124         for (x = 0; x < 4; x++)
125                 tile_irq_activate(rc_config.intr + x,
126                                   TILE_IRQ_HW_CLEAR);
127
128         if (rc_config.plx_gen1)
129                 controller->plx_gen1 = 1;
130
131         return 0;
132 }
133
134 /*
135  * First initialization entry point, called from setup_arch().
136  *
137  * Find valid controllers and fill in pci_controller structs for each
138  * of them.
139  *
140  * Returns the number of controllers discovered.
141  */
142 int __init tile_pci_init(void)
143 {
144         int i;
145
146         pr_info("PCI: Searching for controllers...\n");
147
148         /* Do any configuration we need before using the PCIe */
149
150         for (i = 0; i < TILE_NUM_PCIE; i++) {
151                 int hv_cfg_fd0 = -1;
152                 int hv_cfg_fd1 = -1;
153                 int hv_mem_fd = -1;
154                 char name[32];
155                 struct pci_controller *controller;
156
157                 /*
158                  * Open the fd to the HV.  If it fails then this
159                  * device doesn't exist.
160                  */
161                 hv_cfg_fd0 = tile_pcie_open(i, 0);
162                 if (hv_cfg_fd0 < 0)
163                         continue;
164                 hv_cfg_fd1 = tile_pcie_open(i, 1);
165                 if (hv_cfg_fd1 < 0) {
166                         pr_err("PCI: Couldn't open config fd to HV "
167                             "for controller %d\n", i);
168                         goto err_cont;
169                 }
170
171                 sprintf(name, "pcie/%d/mem", i);
172                 hv_mem_fd = hv_dev_open((HV_VirtAddr)name, 0);
173                 if (hv_mem_fd < 0) {
174                         pr_err("PCI: Could not open mem fd to HV!\n");
175                         goto err_cont;
176                 }
177
178                 pr_info("PCI: Found PCI controller #%d\n", i);
179
180                 controller = &controllers[num_controllers];
181
182                 if (tile_init_irqs(i, controller)) {
183                         pr_err("PCI: Could not initialize "
184                                "IRQs, aborting.\n");
185                         goto err_cont;
186                 }
187
188                 controller->index = num_controllers;
189                 controller->hv_cfg_fd[0] = hv_cfg_fd0;
190                 controller->hv_cfg_fd[1] = hv_cfg_fd1;
191                 controller->hv_mem_fd = hv_mem_fd;
192                 controller->first_busno = 0;
193                 controller->last_busno = 0xff;
194                 controller->ops = &tile_cfg_ops;
195
196                 num_controllers++;
197                 continue;
198
199 err_cont:
200                 if (hv_cfg_fd0 >= 0)
201                         hv_dev_close(hv_cfg_fd0);
202                 if (hv_cfg_fd1 >= 0)
203                         hv_dev_close(hv_cfg_fd1);
204                 if (hv_mem_fd >= 0)
205                         hv_dev_close(hv_mem_fd);
206                 continue;
207         }
208
209         /*
210          * Before using the PCIe, see if we need to do any platform-specific
211          * configuration, such as the PLX switch Gen 1 issue on TILEmpower.
212          */
213         for (i = 0; i < num_controllers; i++) {
214                 struct pci_controller *controller = &controllers[i];
215
216                 if (controller->plx_gen1)
217                         tile_plx_gen1 = 1;
218         }
219
220         return num_controllers;
221 }
222
223 /*
224  * (pin - 1) converts from the PCI standard's [1:4] convention to
225  * a normal [0:3] range.
226  */
227 static int tile_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
228 {
229         struct pci_controller *controller =
230                 (struct pci_controller *)dev->sysdata;
231         return (pin - 1) + controller->irq_base;
232 }
233
234
235 static void __init fixup_read_and_payload_sizes(void)
236 {
237         struct pci_dev *dev = NULL;
238         int smallest_max_payload = 0x1; /* Tile maxes out at 256 bytes. */
239         int max_read_size = 0x2; /* Limit to 512 byte reads. */
240         u16 new_values;
241
242         /* Scan for the smallest maximum payload size. */
243         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
244                 int pcie_caps_offset;
245                 u32 devcap;
246                 int max_payload;
247
248                 pcie_caps_offset = pci_find_capability(dev, PCI_CAP_ID_EXP);
249                 if (pcie_caps_offset == 0)
250                         continue;
251
252                 pci_read_config_dword(dev, pcie_caps_offset + PCI_EXP_DEVCAP,
253                                       &devcap);
254                 max_payload = devcap & PCI_EXP_DEVCAP_PAYLOAD;
255                 if (max_payload < smallest_max_payload)
256                         smallest_max_payload = max_payload;
257         }
258
259         /* Now, set the max_payload_size for all devices to that value. */
260         new_values = (max_read_size << 12) | (smallest_max_payload << 5);
261         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
262                 int pcie_caps_offset;
263                 u16 devctl;
264
265                 pcie_caps_offset = pci_find_capability(dev, PCI_CAP_ID_EXP);
266                 if (pcie_caps_offset == 0)
267                         continue;
268
269                 pci_read_config_word(dev, pcie_caps_offset + PCI_EXP_DEVCTL,
270                                      &devctl);
271                 devctl &= ~(PCI_EXP_DEVCTL_PAYLOAD | PCI_EXP_DEVCTL_READRQ);
272                 devctl |= new_values;
273                 pci_write_config_word(dev, pcie_caps_offset + PCI_EXP_DEVCTL,
274                                       devctl);
275         }
276 }
277
278
279 /*
280  * Second PCI initialization entry point, called by subsys_initcall.
281  *
282  * The controllers have been set up by the time we get here, by a call to
283  * tile_pci_init.
284  */
285 static int __init pcibios_init(void)
286 {
287         int i;
288
289         pr_info("PCI: Probing PCI hardware\n");
290
291         /*
292          * Delay a bit in case devices aren't ready.  Some devices are
293          * known to require at least 20ms here, but we use a more
294          * conservative value.
295          */
296         mdelay(250);
297
298         /* Scan all of the recorded PCI controllers.  */
299         for (i = 0; i < num_controllers; i++) {
300                 struct pci_controller *controller = &controllers[i];
301                 struct pci_bus *bus;
302
303                 pr_info("PCI: initializing controller #%d\n", i);
304
305                 /*
306                  * This comes from the generic Linux PCI driver.
307                  *
308                  * It reads the PCI tree for this bus into the Linux
309                  * data structures.
310                  *
311                  * This is inlined in linux/pci.h and calls into
312                  * pci_scan_bus_parented() in probe.c.
313                  */
314                 bus = pci_scan_bus(0, controller->ops, controller);
315                 controller->root_bus = bus;
316                 controller->last_busno = bus->subordinate;
317
318         }
319
320         /* Do machine dependent PCI interrupt routing */
321         pci_fixup_irqs(pci_common_swizzle, tile_map_irq);
322
323         /*
324          * This comes from the generic Linux PCI driver.
325          *
326          * It allocates all of the resources (I/O memory, etc)
327          * associated with the devices read in above.
328          */
329
330         pci_assign_unassigned_resources();
331
332         /* Configure the max_read_size and max_payload_size values. */
333         fixup_read_and_payload_sizes();
334
335         /* Record the I/O resources in the PCI controller structure. */
336         for (i = 0; i < num_controllers; i++) {
337                 struct pci_bus *root_bus = controllers[i].root_bus;
338                 struct pci_bus *next_bus;
339                 struct pci_dev *dev;
340
341                 list_for_each_entry(dev, &root_bus->devices, bus_list) {
342                         /* Find the PCI host controller, ie. the 1st bridge. */
343                         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
344                                 (PCI_SLOT(dev->devfn) == 0)) {
345                                 next_bus = dev->subordinate;
346                                 controllers[i].mem_resources[0] =
347                                         *next_bus->resource[0];
348                                 controllers[i].mem_resources[1] =
349                                          *next_bus->resource[1];
350                                 controllers[i].mem_resources[2] =
351                                          *next_bus->resource[2];
352
353                                 break;
354                         }
355                 }
356
357         }
358
359         return 0;
360 }
361 subsys_initcall(pcibios_init);
362
363 /*
364  * No bus fixups needed.
365  */
366 void __devinit pcibios_fixup_bus(struct pci_bus *bus)
367 {
368         /* Nothing needs to be done. */
369 }
370
371 /*
372  * This can be called from the generic PCI layer, but doesn't need to
373  * do anything.
374  */
375 char __devinit *pcibios_setup(char *str)
376 {
377         /* Nothing needs to be done. */
378         return str;
379 }
380
381 /*
382  * This is called from the generic Linux layer.
383  */
384 void __init pcibios_update_irq(struct pci_dev *dev, int irq)
385 {
386         pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
387 }
388
389 /*
390  * Enable memory and/or address decoding, as appropriate, for the
391  * device described by the 'dev' struct.
392  *
393  * This is called from the generic PCI layer, and can be called
394  * for bridges or endpoints.
395  */
396 int pcibios_enable_device(struct pci_dev *dev, int mask)
397 {
398         u16 cmd, old_cmd;
399         u8 header_type;
400         int i;
401         struct resource *r;
402
403         pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
404
405         pci_read_config_word(dev, PCI_COMMAND, &cmd);
406         old_cmd = cmd;
407         if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
408                 /*
409                  * For bridges, we enable both memory and I/O decoding
410                  * in call cases.
411                  */
412                 cmd |= PCI_COMMAND_IO;
413                 cmd |= PCI_COMMAND_MEMORY;
414         } else {
415                 /*
416                  * For endpoints, we enable memory and/or I/O decoding
417                  * only if they have a memory resource of that type.
418                  */
419                 for (i = 0; i < 6; i++) {
420                         r = &dev->resource[i];
421                         if (r->flags & IORESOURCE_UNSET) {
422                                 pr_err("PCI: Device %s not available "
423                                        "because of resource collisions\n",
424                                        pci_name(dev));
425                                 return -EINVAL;
426                         }
427                         if (r->flags & IORESOURCE_IO)
428                                 cmd |= PCI_COMMAND_IO;
429                         if (r->flags & IORESOURCE_MEM)
430                                 cmd |= PCI_COMMAND_MEMORY;
431                 }
432         }
433
434         /*
435          * We only write the command if it changed.
436          */
437         if (cmd != old_cmd)
438                 pci_write_config_word(dev, PCI_COMMAND, cmd);
439         return 0;
440 }
441
442 void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max)
443 {
444         unsigned long start = pci_resource_start(dev, bar);
445         unsigned long len = pci_resource_len(dev, bar);
446         unsigned long flags = pci_resource_flags(dev, bar);
447
448         if (!len)
449                 return NULL;
450         if (max && len > max)
451                 len = max;
452
453         if (!(flags & IORESOURCE_MEM)) {
454                 pr_info("PCI: Trying to map invalid resource %#lx\n", flags);
455                 start = 0;
456         }
457
458         return (void __iomem *)start;
459 }
460 EXPORT_SYMBOL(pci_iomap);
461
462
463 /****************************************************************
464  *
465  * Tile PCI config space read/write routines
466  *
467  ****************************************************************/
468
469 /*
470  * These are the normal read and write ops
471  * These are expanded with macros from  pci_bus_read_config_byte() etc.
472  *
473  * devfn is the combined PCI slot & function.
474  *
475  * offset is in bytes, from the start of config space for the
476  * specified bus & slot.
477  */
478
479 static int __devinit tile_cfg_read(struct pci_bus *bus,
480                                    unsigned int devfn,
481                                    int offset,
482                                    int size,
483                                    u32 *val)
484 {
485         struct pci_controller *controller = bus->sysdata;
486         int busnum = bus->number & 0xff;
487         int slot = (devfn >> 3) & 0x1f;
488         int function = devfn & 0x7;
489         u32 addr;
490         int config_mode = 1;
491
492         /*
493          * There is no bridge between the Tile and bus 0, so we
494          * use config0 to talk to bus 0.
495          *
496          * If we're talking to a bus other than zero then we
497          * must have found a bridge.
498          */
499         if (busnum == 0) {
500                 /*
501                  * We fake an empty slot for (busnum == 0) && (slot > 0),
502                  * since there is only one slot on bus 0.
503                  */
504                 if (slot) {
505                         *val = 0xFFFFFFFF;
506                         return 0;
507                 }
508                 config_mode = 0;
509         }
510
511         addr = busnum << 20;            /* Bus in 27:20 */
512         addr |= slot << 15;             /* Slot (device) in 19:15 */
513         addr |= function << 12;         /* Function is in 14:12 */
514         addr |= (offset & 0xFFF);       /* byte address in 0:11 */
515
516         return hv_dev_pread(controller->hv_cfg_fd[config_mode], 0,
517                             (HV_VirtAddr)(val), size, addr);
518 }
519
520
521 /*
522  * See tile_cfg_read() for relevent comments.
523  * Note that "val" is the value to write, not a pointer to that value.
524  */
525 static int __devinit tile_cfg_write(struct pci_bus *bus,
526                                     unsigned int devfn,
527                                     int offset,
528                                     int size,
529                                     u32 val)
530 {
531         struct pci_controller *controller = bus->sysdata;
532         int busnum = bus->number & 0xff;
533         int slot = (devfn >> 3) & 0x1f;
534         int function = devfn & 0x7;
535         u32 addr;
536         int config_mode = 1;
537         HV_VirtAddr valp = (HV_VirtAddr)&val;
538
539         /*
540          * For bus 0 slot 0 we use config 0 accesses.
541          */
542         if (busnum == 0) {
543                 /*
544                  * We fake an empty slot for (busnum == 0) && (slot > 0),
545                  * since there is only one slot on bus 0.
546                  */
547                 if (slot)
548                         return 0;
549                 config_mode = 0;
550         }
551
552         addr = busnum << 20;            /* Bus in 27:20 */
553         addr |= slot << 15;             /* Slot (device) in 19:15 */
554         addr |= function << 12;         /* Function is in 14:12 */
555         addr |= (offset & 0xFFF);       /* byte address in 0:11 */
556
557 #ifdef __BIG_ENDIAN
558         /* Point to the correct part of the 32-bit "val". */
559         valp += 4 - size;
560 #endif
561
562         return hv_dev_pwrite(controller->hv_cfg_fd[config_mode], 0,
563                              valp, size, addr);
564 }
565
566
567 static struct pci_ops tile_cfg_ops = {
568         .read =         tile_cfg_read,
569         .write =        tile_cfg_write,
570 };
571
572
573 /*
574  * In the following, each PCI controller's mem_resources[1]
575  * represents its (non-prefetchable) PCI memory resource.
576  * mem_resources[0] and mem_resources[2] refer to its PCI I/O and
577  * prefetchable PCI memory resources, respectively.
578  * For more details, see pci_setup_bridge() in setup-bus.c.
579  * By comparing the target PCI memory address against the
580  * end address of controller 0, we can determine the controller
581  * that should accept the PCI memory access.
582  */
583 #define TILE_READ(size, type)                                           \
584 type _tile_read##size(unsigned long addr)                               \
585 {                                                                       \
586         type val;                                                       \
587         int idx = 0;                                                    \
588         if (addr > controllers[0].mem_resources[1].end &&               \
589             addr > controllers[0].mem_resources[2].end)                 \
590                 idx = 1;                                                \
591         if (hv_dev_pread(controllers[idx].hv_mem_fd, 0,                 \
592                          (HV_VirtAddr)(&val), sizeof(type), addr))      \
593                 pr_err("PCI: read %zd bytes at 0x%lX failed\n",         \
594                        sizeof(type), addr);                             \
595         return val;                                                     \
596 }                                                                       \
597 EXPORT_SYMBOL(_tile_read##size)
598
599 TILE_READ(b, u8);
600 TILE_READ(w, u16);
601 TILE_READ(l, u32);
602 TILE_READ(q, u64);
603
604 #define TILE_WRITE(size, type)                                          \
605 void _tile_write##size(type val, unsigned long addr)                    \
606 {                                                                       \
607         int idx = 0;                                                    \
608         if (addr > controllers[0].mem_resources[1].end &&               \
609             addr > controllers[0].mem_resources[2].end)                 \
610                 idx = 1;                                                \
611         if (hv_dev_pwrite(controllers[idx].hv_mem_fd, 0,                \
612                           (HV_VirtAddr)(&val), sizeof(type), addr))     \
613                 pr_err("PCI: write %zd bytes at 0x%lX failed\n",        \
614                        sizeof(type), addr);                             \
615 }                                                                       \
616 EXPORT_SYMBOL(_tile_write##size)
617
618 TILE_WRITE(b, u8);
619 TILE_WRITE(w, u16);
620 TILE_WRITE(l, u32);
621 TILE_WRITE(q, u64);