~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/tile/kernel/pci.c

Version: ~ [ linux-5.7-rc7 ] ~ [ linux-5.6.14 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.42 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.124 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.181 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.224 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.224 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.84 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp