1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2020 4 * 5 * Author(s): 6 * Pierre Morel <pmorel@linux.ibm.com> 7 * 8 */ 9 10 #define KMSG_COMPONENT "zpci" 11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 12 13 #include <linux/kernel.h> 14 #include <linux/slab.h> 15 #include <linux/err.h> 16 #include <linux/export.h> 17 #include <linux/delay.h> 18 #include <linux/seq_file.h> 19 #include <linux/jump_label.h> 20 #include <linux/pci.h> 21 #include <linux/printk.h> 22 23 #include <asm/pci_clp.h> 24 #include <asm/pci_dma.h> 25 26 #include "pci_bus.h" 27 28 static LIST_HEAD(zbus_list); 29 static DEFINE_SPINLOCK(zbus_list_lock); 30 static int zpci_nb_devices; 31 32 /* zpci_bus_scan 33 * @zbus: the zbus holding the zdevices 34 * @ops: the pci operations 35 * 36 * The domain number must be set before pci_scan_root_bus is called. 37 * This function can be called once the domain is known, hence 38 * when the function_0 is dicovered. 39 */ 40 static int zpci_bus_scan(struct zpci_bus *zbus, int domain, struct pci_ops *ops) 41 { 42 struct pci_bus *bus; 43 int rc; 44 45 rc = zpci_alloc_domain(domain); 46 if (rc < 0) 47 return rc; 48 zbus->domain_nr = rc; 49 50 bus = pci_scan_root_bus(NULL, ZPCI_BUS_NR, ops, zbus, &zbus->resources); 51 if (!bus) { 52 zpci_free_domain(zbus->domain_nr); 53 return -EFAULT; 54 } 55 56 zbus->bus = bus; 57 pci_bus_add_devices(bus); 58 return 0; 59 } 60 61 static void zpci_bus_release(struct kref *kref) 62 { 63 struct zpci_bus *zbus = container_of(kref, struct zpci_bus, kref); 64 65 if (zbus->bus) { 66 pci_lock_rescan_remove(); 67 pci_stop_root_bus(zbus->bus); 68 69 zpci_free_domain(zbus->domain_nr); 70 pci_free_resource_list(&zbus->resources); 71 72 pci_remove_root_bus(zbus->bus); 73 pci_unlock_rescan_remove(); 74 } 75 76 spin_lock(&zbus_list_lock); 77 list_del(&zbus->bus_next); 78 spin_unlock(&zbus_list_lock); 79 kfree(zbus); 80 } 81 82 static void zpci_bus_put(struct zpci_bus *zbus) 83 { 84 kref_put(&zbus->kref, zpci_bus_release); 85 } 86 87 static struct zpci_bus *zpci_bus_get(int pchid) 88 { 89 struct zpci_bus *zbus; 90 91 spin_lock(&zbus_list_lock); 92 list_for_each_entry(zbus, &zbus_list, bus_next) { 93 if (pchid == zbus->pchid) { 94 kref_get(&zbus->kref); 95 goto out_unlock; 96 } 97 } 98 zbus = NULL; 99 out_unlock: 100 spin_unlock(&zbus_list_lock); 101 return zbus; 102 } 103 104 static struct zpci_bus *zpci_bus_alloc(int pchid) 105 { 106 struct zpci_bus *zbus; 107 108 zbus = kzalloc(sizeof(*zbus), GFP_KERNEL); 109 if (!zbus) 110 return NULL; 111 112 zbus->pchid = pchid; 113 INIT_LIST_HEAD(&zbus->bus_next); 114 spin_lock(&zbus_list_lock); 115 list_add_tail(&zbus->bus_next, &zbus_list); 116 spin_unlock(&zbus_list_lock); 117 118 kref_init(&zbus->kref); 119 INIT_LIST_HEAD(&zbus->resources); 120 121 zbus->bus_resource.start = 0; 122 zbus->bus_resource.end = ZPCI_BUS_NR; 123 zbus->bus_resource.flags = IORESOURCE_BUS; 124 pci_add_resource(&zbus->resources, &zbus->bus_resource); 125 126 return zbus; 127 } 128 129 #ifdef CONFIG_PCI_IOV 130 static int zpci_bus_link_virtfn(struct pci_dev *pdev, 131 struct pci_dev *virtfn, int vfid) 132 { 133 int rc; 134 135 rc = pci_iov_sysfs_link(pdev, virtfn, vfid); 136 if (rc) 137 return rc; 138 139 virtfn->is_virtfn = 1; 140 virtfn->multifunction = 0; 141 virtfn->physfn = pci_dev_get(pdev); 142 143 return 0; 144 } 145 146 static int zpci_bus_setup_virtfn(struct zpci_bus *zbus, 147 struct pci_dev *virtfn, int vfn) 148 { 149 int i, cand_devfn; 150 struct zpci_dev *zdev; 151 struct pci_dev *pdev; 152 int vfid = vfn - 1; /* Linux' vfid's start at 0 vfn at 1*/ 153 int rc = 0; 154 155 if (!zbus->multifunction) 156 return 0; 157 158 /* If the parent PF for the given VF is also configured in the 159 * instance, it must be on the same zbus. 160 * We can then identify the parent PF by checking what 161 * devfn the VF would have if it belonged to that PF using the PF's 162 * stride and offset. Only if this candidate devfn matches the 163 * actual devfn will we link both functions. 164 */ 165 for (i = 0; i < ZPCI_FUNCTIONS_PER_BUS; i++) { 166 zdev = zbus->function[i]; 167 if (zdev && zdev->is_physfn) { 168 pdev = pci_get_slot(zbus->bus, zdev->devfn); 169 if (!pdev) 170 continue; 171 cand_devfn = pci_iov_virtfn_devfn(pdev, vfid); 172 if (cand_devfn == virtfn->devfn) { 173 rc = zpci_bus_link_virtfn(pdev, virtfn, vfid); 174 /* balance pci_get_slot() */ 175 pci_dev_put(pdev); 176 break; 177 } 178 /* balance pci_get_slot() */ 179 pci_dev_put(pdev); 180 } 181 } 182 return rc; 183 } 184 #else 185 static inline int zpci_bus_setup_virtfn(struct zpci_bus *zbus, 186 struct pci_dev *virtfn, int vfn) 187 { 188 return 0; 189 } 190 #endif 191 192 void pcibios_bus_add_device(struct pci_dev *pdev) 193 { 194 struct zpci_dev *zdev = to_zpci(pdev); 195 196 /* 197 * With pdev->no_vf_scan the common PCI probing code does not 198 * perform PF/VF linking. 199 */ 200 if (zdev->vfn) 201 zpci_bus_setup_virtfn(zdev->zbus, pdev, zdev->vfn); 202 203 } 204 205 static int zpci_bus_add_device(struct zpci_bus *zbus, struct zpci_dev *zdev) 206 { 207 struct pci_bus *bus; 208 struct resource_entry *window, *n; 209 struct resource *res; 210 struct pci_dev *pdev; 211 int rc; 212 213 bus = zbus->bus; 214 if (!bus) 215 return -EINVAL; 216 217 pdev = pci_get_slot(bus, zdev->devfn); 218 if (pdev) { 219 /* Device is already known. */ 220 pci_dev_put(pdev); 221 return 0; 222 } 223 224 rc = zpci_init_slot(zdev); 225 if (rc) 226 return rc; 227 zdev->has_hp_slot = 1; 228 229 resource_list_for_each_entry_safe(window, n, &zbus->resources) { 230 res = window->res; 231 pci_bus_add_resource(bus, res, 0); 232 } 233 234 pdev = pci_scan_single_device(bus, zdev->devfn); 235 if (pdev) 236 pci_bus_add_device(pdev); 237 238 return 0; 239 } 240 241 static void zpci_bus_add_devices(struct zpci_bus *zbus) 242 { 243 int i; 244 245 for (i = 1; i < ZPCI_FUNCTIONS_PER_BUS; i++) 246 if (zbus->function[i]) 247 zpci_bus_add_device(zbus, zbus->function[i]); 248 249 pci_lock_rescan_remove(); 250 pci_bus_add_devices(zbus->bus); 251 pci_unlock_rescan_remove(); 252 } 253 254 int zpci_bus_device_register(struct zpci_dev *zdev, struct pci_ops *ops) 255 { 256 struct zpci_bus *zbus = NULL; 257 int rc = -EBADF; 258 259 if (zpci_nb_devices == ZPCI_NR_DEVICES) { 260 pr_warn("Adding PCI function %08x failed because the configured limit of %d is reached\n", 261 zdev->fid, ZPCI_NR_DEVICES); 262 return -ENOSPC; 263 } 264 zpci_nb_devices++; 265 266 if (zdev->devfn >= ZPCI_FUNCTIONS_PER_BUS) 267 return -EINVAL; 268 269 if (!s390_pci_no_rid && zdev->rid_available) 270 zbus = zpci_bus_get(zdev->pchid); 271 272 if (!zbus) { 273 zbus = zpci_bus_alloc(zdev->pchid); 274 if (!zbus) 275 return -ENOMEM; 276 } 277 278 zdev->zbus = zbus; 279 if (zbus->function[zdev->devfn]) { 280 pr_err("devfn %04x is already assigned\n", zdev->devfn); 281 goto error; /* rc already set */ 282 } 283 zbus->function[zdev->devfn] = zdev; 284 285 zpci_setup_bus_resources(zdev, &zbus->resources); 286 287 if (zbus->bus) { 288 if (!zbus->multifunction) { 289 WARN_ONCE(1, "zbus is not multifunction\n"); 290 goto error_bus; 291 } 292 if (!zdev->rid_available) { 293 WARN_ONCE(1, "rid_available not set for multifunction\n"); 294 goto error_bus; 295 } 296 rc = zpci_bus_add_device(zbus, zdev); 297 if (rc) 298 goto error_bus; 299 } else if (zdev->devfn == 0) { 300 if (zbus->multifunction && !zdev->rid_available) { 301 WARN_ONCE(1, "rid_available not set on function 0 for multifunction\n"); 302 goto error_bus; 303 } 304 rc = zpci_bus_scan(zbus, (u16)zdev->uid, ops); 305 if (rc) 306 goto error_bus; 307 zpci_bus_add_devices(zbus); 308 rc = zpci_init_slot(zdev); 309 if (rc) 310 goto error_bus; 311 zdev->has_hp_slot = 1; 312 zbus->multifunction = zdev->rid_available; 313 zbus->max_bus_speed = zdev->max_bus_speed; 314 } else { 315 zbus->multifunction = 1; 316 } 317 318 return 0; 319 320 error_bus: 321 zpci_nb_devices--; 322 zbus->function[zdev->devfn] = NULL; 323 error: 324 pr_err("Adding PCI function %08x failed\n", zdev->fid); 325 zpci_bus_put(zbus); 326 return rc; 327 } 328 329 void zpci_bus_device_unregister(struct zpci_dev *zdev) 330 { 331 struct zpci_bus *zbus = zdev->zbus; 332 333 zpci_nb_devices--; 334 zbus->function[zdev->devfn] = NULL; 335 zpci_bus_put(zbus); 336 } 337