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 virtfn->physfn = pci_dev_get(pdev); 136 rc = pci_iov_sysfs_link(pdev, virtfn, vfid); 137 if (rc) { 138 pci_dev_put(pdev); 139 virtfn->physfn = NULL; 140 return rc; 141 } 142 return 0; 143 } 144 145 static int zpci_bus_setup_virtfn(struct zpci_bus *zbus, 146 struct pci_dev *virtfn, int vfn) 147 { 148 int i, cand_devfn; 149 struct zpci_dev *zdev; 150 struct pci_dev *pdev; 151 int vfid = vfn - 1; /* Linux' vfid's start at 0 vfn at 1*/ 152 int rc = 0; 153 154 virtfn->is_virtfn = 1; 155 virtfn->multifunction = 0; 156 WARN_ON(vfid < 0); 157 /* If the parent PF for the given VF is also configured in the 158 * instance, it must be on the same zbus. 159 * We can then identify the parent PF by checking what 160 * devfn the VF would have if it belonged to that PF using the PF's 161 * stride and offset. Only if this candidate devfn matches the 162 * actual devfn will we link both functions. 163 */ 164 for (i = 0; i < ZPCI_FUNCTIONS_PER_BUS; i++) { 165 zdev = zbus->function[i]; 166 if (zdev && zdev->is_physfn) { 167 pdev = pci_get_slot(zbus->bus, zdev->devfn); 168 cand_devfn = pci_iov_virtfn_devfn(pdev, vfid); 169 if (cand_devfn == virtfn->devfn) { 170 rc = zpci_bus_link_virtfn(pdev, virtfn, vfid); 171 break; 172 } 173 } 174 } 175 return rc; 176 } 177 #else 178 static inline int zpci_bus_setup_virtfn(struct zpci_bus *zbus, 179 struct pci_dev *virtfn, int vfn) 180 { 181 virtfn->is_virtfn = 1; 182 virtfn->multifunction = 0; 183 return 0; 184 } 185 #endif 186 187 static int zpci_bus_add_device(struct zpci_bus *zbus, struct zpci_dev *zdev) 188 { 189 struct pci_bus *bus; 190 struct resource_entry *window, *n; 191 struct resource *res; 192 struct pci_dev *pdev; 193 int rc; 194 195 bus = zbus->bus; 196 if (!bus) 197 return -EINVAL; 198 199 pdev = pci_get_slot(bus, zdev->devfn); 200 if (pdev) { 201 /* Device is already known. */ 202 pci_dev_put(pdev); 203 return 0; 204 } 205 206 rc = zpci_init_slot(zdev); 207 if (rc) 208 return rc; 209 zdev->has_hp_slot = 1; 210 211 resource_list_for_each_entry_safe(window, n, &zbus->resources) { 212 res = window->res; 213 pci_bus_add_resource(bus, res, 0); 214 } 215 216 pdev = pci_scan_single_device(bus, zdev->devfn); 217 if (pdev) { 218 if (!zdev->is_physfn) { 219 rc = zpci_bus_setup_virtfn(zbus, pdev, zdev->vfn); 220 if (rc) 221 goto failed_with_pdev; 222 } 223 pci_bus_add_device(pdev); 224 } 225 return 0; 226 227 failed_with_pdev: 228 pci_stop_and_remove_bus_device(pdev); 229 pci_dev_put(pdev); 230 return rc; 231 } 232 233 static void zpci_bus_add_devices(struct zpci_bus *zbus) 234 { 235 int i; 236 237 for (i = 1; i < ZPCI_FUNCTIONS_PER_BUS; i++) 238 if (zbus->function[i]) 239 zpci_bus_add_device(zbus, zbus->function[i]); 240 241 pci_lock_rescan_remove(); 242 pci_bus_add_devices(zbus->bus); 243 pci_unlock_rescan_remove(); 244 } 245 246 int zpci_bus_device_register(struct zpci_dev *zdev, struct pci_ops *ops) 247 { 248 struct zpci_bus *zbus = NULL; 249 int rc = -EBADF; 250 251 if (zpci_nb_devices == ZPCI_NR_DEVICES) { 252 pr_warn("Adding PCI function %08x failed because the configured limit of %d is reached\n", 253 zdev->fid, ZPCI_NR_DEVICES); 254 return -ENOSPC; 255 } 256 zpci_nb_devices++; 257 258 if (zdev->devfn >= ZPCI_FUNCTIONS_PER_BUS) 259 return -EINVAL; 260 261 if (!s390_pci_no_rid && zdev->rid_available) 262 zbus = zpci_bus_get(zdev->pchid); 263 264 if (!zbus) { 265 zbus = zpci_bus_alloc(zdev->pchid); 266 if (!zbus) 267 return -ENOMEM; 268 } 269 270 zdev->zbus = zbus; 271 if (zbus->function[zdev->devfn]) { 272 pr_err("devfn %04x is already assigned\n", zdev->devfn); 273 goto error; /* rc already set */ 274 } 275 zbus->function[zdev->devfn] = zdev; 276 277 zpci_setup_bus_resources(zdev, &zbus->resources); 278 279 if (zbus->bus) { 280 if (!zbus->multifunction) { 281 WARN_ONCE(1, "zbus is not multifunction\n"); 282 goto error_bus; 283 } 284 if (!zdev->rid_available) { 285 WARN_ONCE(1, "rid_available not set for multifunction\n"); 286 goto error_bus; 287 } 288 rc = zpci_bus_add_device(zbus, zdev); 289 if (rc) 290 goto error_bus; 291 } else if (zdev->devfn == 0) { 292 if (zbus->multifunction && !zdev->rid_available) { 293 WARN_ONCE(1, "rid_available not set on function 0 for multifunction\n"); 294 goto error_bus; 295 } 296 rc = zpci_bus_scan(zbus, (u16)zdev->uid, ops); 297 if (rc) 298 goto error_bus; 299 zpci_bus_add_devices(zbus); 300 rc = zpci_init_slot(zdev); 301 if (rc) 302 goto error_bus; 303 zdev->has_hp_slot = 1; 304 zbus->multifunction = zdev->rid_available; 305 zbus->max_bus_speed = zdev->max_bus_speed; 306 } else { 307 zbus->multifunction = 1; 308 } 309 310 return 0; 311 312 error_bus: 313 zpci_nb_devices--; 314 zbus->function[zdev->devfn] = NULL; 315 error: 316 pr_err("Adding PCI function %08x failed\n", zdev->fid); 317 zpci_bus_put(zbus); 318 return rc; 319 } 320 321 void zpci_bus_device_unregister(struct zpci_dev *zdev) 322 { 323 struct zpci_bus *zbus = zdev->zbus; 324 325 zpci_nb_devices--; 326 zbus->function[zdev->devfn] = NULL; 327 zpci_bus_put(zbus); 328 } 329