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/delay.h> 17 #include <linux/seq_file.h> 18 #include <linux/jump_label.h> 19 #include <linux/pci.h> 20 #include <linux/printk.h> 21 #include <linux/dma-direct.h> 22 23 #include <asm/pci_clp.h> 24 #include <asm/pci_dma.h> 25 26 #include "pci_bus.h" 27 #include "pci_iov.h" 28 29 static LIST_HEAD(zbus_list); 30 static DEFINE_MUTEX(zbus_list_lock); 31 static int zpci_nb_devices; 32 33 /* zpci_bus_prepare_device - Prepare a zPCI function for scanning 34 * @zdev: the zPCI function to be prepared 35 * 36 * The PCI resources for the function are set up and added to its zbus and the 37 * function is enabled. The function must be added to a zbus which must have 38 * a PCI bus created. If an error occurs the zPCI function is not enabled. 39 * 40 * Return: 0 on success, an error code otherwise 41 */ 42 static int zpci_bus_prepare_device(struct zpci_dev *zdev) 43 { 44 int rc, i; 45 46 if (!zdev_enabled(zdev)) { 47 rc = zpci_enable_device(zdev); 48 if (rc) 49 return rc; 50 } 51 52 if (!zdev->has_resources) { 53 zpci_setup_bus_resources(zdev); 54 for (i = 0; i < PCI_STD_NUM_BARS; i++) { 55 if (zdev->bars[i].res) 56 pci_bus_add_resource(zdev->zbus->bus, zdev->bars[i].res); 57 } 58 } 59 60 return 0; 61 } 62 63 /* zpci_bus_scan_device - Scan a single device adding it to the PCI core 64 * @zdev: the zdev to be scanned 65 * 66 * Scans the PCI function making it available to the common PCI code. 67 * 68 * Return: 0 on success, an error value otherwise 69 */ 70 int zpci_bus_scan_device(struct zpci_dev *zdev) 71 { 72 struct pci_dev *pdev; 73 int rc; 74 75 rc = zpci_bus_prepare_device(zdev); 76 if (rc) 77 return rc; 78 79 pdev = pci_scan_single_device(zdev->zbus->bus, zdev->devfn); 80 if (!pdev) 81 return -ENODEV; 82 83 pci_lock_rescan_remove(); 84 pci_bus_add_device(pdev); 85 pci_unlock_rescan_remove(); 86 87 return 0; 88 } 89 90 /* zpci_bus_remove_device - Removes the given zdev from the PCI core 91 * @zdev: the zdev to be removed from the PCI core 92 * @set_error: if true the device's error state is set to permanent failure 93 * 94 * Sets a zPCI device to a configured but offline state; the zPCI 95 * device is still accessible through its hotplug slot and the zPCI 96 * API but is removed from the common code PCI bus, making it 97 * no longer available to drivers. 98 */ 99 void zpci_bus_remove_device(struct zpci_dev *zdev, bool set_error) 100 { 101 struct zpci_bus *zbus = zdev->zbus; 102 struct pci_dev *pdev; 103 104 if (!zdev->zbus->bus) 105 return; 106 107 pdev = pci_get_slot(zbus->bus, zdev->devfn); 108 if (pdev) { 109 if (set_error) 110 pdev->error_state = pci_channel_io_perm_failure; 111 if (pdev->is_virtfn) { 112 zpci_iov_remove_virtfn(pdev, zdev->vfn); 113 /* balance pci_get_slot */ 114 pci_dev_put(pdev); 115 return; 116 } 117 pci_stop_and_remove_bus_device_locked(pdev); 118 /* balance pci_get_slot */ 119 pci_dev_put(pdev); 120 } 121 } 122 123 /* zpci_bus_scan_bus - Scan all configured zPCI functions on the bus 124 * @zbus: the zbus to be scanned 125 * 126 * Enables and scans all PCI functions on the bus making them available to the 127 * common PCI code. If a PCI function fails to be initialized an error will be 128 * returned but attempts will still be made for all other functions on the bus. 129 * 130 * Return: 0 on success, an error value otherwise 131 */ 132 int zpci_bus_scan_bus(struct zpci_bus *zbus) 133 { 134 struct zpci_dev *zdev; 135 int devfn, rc, ret = 0; 136 137 for (devfn = 0; devfn < ZPCI_FUNCTIONS_PER_BUS; devfn++) { 138 zdev = zbus->function[devfn]; 139 if (zdev && zdev->state == ZPCI_FN_STATE_CONFIGURED) { 140 rc = zpci_bus_prepare_device(zdev); 141 if (rc) 142 ret = -EIO; 143 } 144 } 145 146 pci_lock_rescan_remove(); 147 pci_scan_child_bus(zbus->bus); 148 pci_bus_add_devices(zbus->bus); 149 pci_unlock_rescan_remove(); 150 151 return ret; 152 } 153 154 /* zpci_bus_scan_busses - Scan all registered busses 155 * 156 * Scan all available zbusses 157 * 158 */ 159 void zpci_bus_scan_busses(void) 160 { 161 struct zpci_bus *zbus = NULL; 162 163 mutex_lock(&zbus_list_lock); 164 list_for_each_entry(zbus, &zbus_list, bus_next) { 165 zpci_bus_scan_bus(zbus); 166 cond_resched(); 167 } 168 mutex_unlock(&zbus_list_lock); 169 } 170 171 static bool zpci_bus_is_multifunction_root(struct zpci_dev *zdev) 172 { 173 return !s390_pci_no_rid && zdev->rid_available && 174 !zdev->vfn; 175 } 176 177 /* zpci_bus_create_pci_bus - Create the PCI bus associated with this zbus 178 * @zbus: the zbus holding the zdevices 179 * @fr: PCI root function that will determine the bus's domain, and bus speed 180 * @ops: the pci operations 181 * 182 * The PCI function @fr determines the domain (its UID), multifunction property 183 * and maximum bus speed of the entire bus. 184 * 185 * Return: 0 on success, an error code otherwise 186 */ 187 static int zpci_bus_create_pci_bus(struct zpci_bus *zbus, struct zpci_dev *fr, struct pci_ops *ops) 188 { 189 struct pci_bus *bus; 190 int domain; 191 192 domain = zpci_alloc_domain((u16)fr->uid); 193 if (domain < 0) 194 return domain; 195 196 zbus->domain_nr = domain; 197 zbus->multifunction = zpci_bus_is_multifunction_root(fr); 198 zbus->max_bus_speed = fr->max_bus_speed; 199 200 /* 201 * Note that the zbus->resources are taken over and zbus->resources 202 * is empty after a successful call 203 */ 204 bus = pci_create_root_bus(NULL, ZPCI_BUS_NR, ops, zbus, &zbus->resources); 205 if (!bus) { 206 zpci_free_domain(zbus->domain_nr); 207 return -EFAULT; 208 } 209 210 zbus->bus = bus; 211 212 return 0; 213 } 214 215 static void zpci_bus_release(struct kref *kref) 216 { 217 struct zpci_bus *zbus = container_of(kref, struct zpci_bus, kref); 218 219 if (zbus->bus) { 220 pci_lock_rescan_remove(); 221 pci_stop_root_bus(zbus->bus); 222 223 zpci_free_domain(zbus->domain_nr); 224 pci_free_resource_list(&zbus->resources); 225 226 pci_remove_root_bus(zbus->bus); 227 pci_unlock_rescan_remove(); 228 } 229 230 mutex_lock(&zbus_list_lock); 231 list_del(&zbus->bus_next); 232 mutex_unlock(&zbus_list_lock); 233 kfree(zbus); 234 } 235 236 static void zpci_bus_put(struct zpci_bus *zbus) 237 { 238 kref_put(&zbus->kref, zpci_bus_release); 239 } 240 241 static struct zpci_bus *zpci_bus_get(int topo, bool topo_is_tid) 242 { 243 struct zpci_bus *zbus; 244 245 mutex_lock(&zbus_list_lock); 246 list_for_each_entry(zbus, &zbus_list, bus_next) { 247 if (!zbus->multifunction) 248 continue; 249 if (topo_is_tid == zbus->topo_is_tid && topo == zbus->topo) { 250 kref_get(&zbus->kref); 251 goto out_unlock; 252 } 253 } 254 zbus = NULL; 255 out_unlock: 256 mutex_unlock(&zbus_list_lock); 257 return zbus; 258 } 259 260 static struct zpci_bus *zpci_bus_alloc(int topo, bool topo_is_tid) 261 { 262 struct zpci_bus *zbus; 263 264 zbus = kzalloc(sizeof(*zbus), GFP_KERNEL); 265 if (!zbus) 266 return NULL; 267 268 zbus->topo = topo; 269 zbus->topo_is_tid = topo_is_tid; 270 INIT_LIST_HEAD(&zbus->bus_next); 271 mutex_lock(&zbus_list_lock); 272 list_add_tail(&zbus->bus_next, &zbus_list); 273 mutex_unlock(&zbus_list_lock); 274 275 kref_init(&zbus->kref); 276 INIT_LIST_HEAD(&zbus->resources); 277 278 zbus->bus_resource.start = 0; 279 zbus->bus_resource.end = ZPCI_BUS_NR; 280 zbus->bus_resource.flags = IORESOURCE_BUS; 281 pci_add_resource(&zbus->resources, &zbus->bus_resource); 282 283 return zbus; 284 } 285 286 static void pci_dma_range_setup(struct pci_dev *pdev) 287 { 288 struct zpci_dev *zdev = to_zpci(pdev); 289 u64 aligned_end, size; 290 dma_addr_t dma_start; 291 int ret; 292 293 dma_start = PAGE_ALIGN(zdev->start_dma); 294 aligned_end = PAGE_ALIGN_DOWN(zdev->end_dma + 1); 295 if (aligned_end >= dma_start) 296 size = aligned_end - dma_start; 297 else 298 size = 0; 299 WARN_ON_ONCE(size == 0); 300 301 ret = dma_direct_set_offset(&pdev->dev, 0, dma_start, size); 302 if (ret) 303 pr_err("Failed to allocate DMA range map for %s\n", pci_name(pdev)); 304 } 305 306 void pcibios_bus_add_device(struct pci_dev *pdev) 307 { 308 struct zpci_dev *zdev = to_zpci(pdev); 309 310 pci_dma_range_setup(pdev); 311 312 /* 313 * With pdev->no_vf_scan the common PCI probing code does not 314 * perform PF/VF linking. 315 */ 316 if (zdev->vfn) { 317 zpci_iov_setup_virtfn(zdev->zbus, pdev, zdev->vfn); 318 pdev->no_command_memory = 1; 319 } 320 } 321 322 static int zpci_bus_add_device(struct zpci_bus *zbus, struct zpci_dev *zdev) 323 { 324 int rc = -EINVAL; 325 326 if (zbus->multifunction) { 327 if (!zdev->rid_available) { 328 WARN_ONCE(1, "rid_available not set for multifunction\n"); 329 return rc; 330 } 331 zdev->devfn = zdev->rid & ZPCI_RID_MASK_DEVFN; 332 } 333 334 if (zbus->function[zdev->devfn]) { 335 pr_err("devfn %04x is already assigned\n", zdev->devfn); 336 return rc; 337 } 338 zdev->zbus = zbus; 339 zbus->function[zdev->devfn] = zdev; 340 zpci_nb_devices++; 341 342 rc = zpci_init_slot(zdev); 343 if (rc) 344 goto error; 345 zdev->has_hp_slot = 1; 346 347 return 0; 348 349 error: 350 zbus->function[zdev->devfn] = NULL; 351 zdev->zbus = NULL; 352 zpci_nb_devices--; 353 return rc; 354 } 355 356 static bool zpci_bus_is_isolated_vf(struct zpci_bus *zbus, struct zpci_dev *zdev) 357 { 358 struct pci_dev *pdev; 359 360 if (!zdev->vfn) 361 return false; 362 363 pdev = zpci_iov_find_parent_pf(zbus, zdev); 364 if (!pdev) 365 return true; 366 pci_dev_put(pdev); 367 return false; 368 } 369 370 int zpci_bus_device_register(struct zpci_dev *zdev, struct pci_ops *ops) 371 { 372 bool topo_is_tid = zdev->tid_avail; 373 struct zpci_bus *zbus = NULL; 374 int topo, rc = -EBADF; 375 376 if (zpci_nb_devices == ZPCI_NR_DEVICES) { 377 pr_warn("Adding PCI function %08x failed because the configured limit of %d is reached\n", 378 zdev->fid, ZPCI_NR_DEVICES); 379 return -ENOSPC; 380 } 381 382 topo = topo_is_tid ? zdev->tid : zdev->pchid; 383 zbus = zpci_bus_get(topo, topo_is_tid); 384 /* 385 * An isolated VF gets its own domain/bus even if there exists 386 * a matching domain/bus already 387 */ 388 if (zbus && zpci_bus_is_isolated_vf(zbus, zdev)) { 389 zpci_bus_put(zbus); 390 zbus = NULL; 391 } 392 393 if (!zbus) { 394 zbus = zpci_bus_alloc(topo, topo_is_tid); 395 if (!zbus) 396 return -ENOMEM; 397 } 398 399 if (!zbus->bus) { 400 /* The UID of the first PCI function registered with a zpci_bus 401 * is used as the domain number for that bus. Currently there 402 * is exactly one zpci_bus per domain. 403 */ 404 rc = zpci_bus_create_pci_bus(zbus, zdev, ops); 405 if (rc) 406 goto error; 407 } 408 409 rc = zpci_bus_add_device(zbus, zdev); 410 if (rc) 411 goto error; 412 413 return 0; 414 415 error: 416 pr_err("Adding PCI function %08x failed\n", zdev->fid); 417 zpci_bus_put(zbus); 418 return rc; 419 } 420 421 void zpci_bus_device_unregister(struct zpci_dev *zdev) 422 { 423 struct zpci_bus *zbus = zdev->zbus; 424 425 zpci_nb_devices--; 426 zbus->function[zdev->devfn] = NULL; 427 zpci_bus_put(zbus); 428 } 429