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 | #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(bus: zdev->zbus->bus, res: zdev->bars[i].res, flags: 0); |
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(bus: zdev->zbus->bus, devfn: zdev->devfn); |
80 | if (!pdev) |
81 | return -ENODEV; |
82 | |
83 | pci_lock_rescan_remove(); |
84 | pci_bus_add_device(dev: 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(bus: zbus->bus, devfn: 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, vfn: zdev->vfn); |
113 | /* balance pci_get_slot */ |
114 | pci_dev_put(dev: pdev); |
115 | return; |
116 | } |
117 | pci_stop_and_remove_bus_device_locked(dev: pdev); |
118 | /* balance pci_get_slot */ |
119 | pci_dev_put(dev: 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(bus: zbus->bus); |
148 | pci_bus_add_devices(bus: 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(lock: &zbus_list_lock); |
169 | } |
170 | |
171 | /* zpci_bus_create_pci_bus - Create the PCI bus associated with this zbus |
172 | * @zbus: the zbus holding the zdevices |
173 | * @fr: PCI root function that will determine the bus's domain, and bus speeed |
174 | * @ops: the pci operations |
175 | * |
176 | * The PCI function @fr determines the domain (its UID), multifunction property |
177 | * and maximum bus speed of the entire bus. |
178 | * |
179 | * Return: 0 on success, an error code otherwise |
180 | */ |
181 | static int zpci_bus_create_pci_bus(struct zpci_bus *zbus, struct zpci_dev *fr, struct pci_ops *ops) |
182 | { |
183 | struct pci_bus *bus; |
184 | int domain; |
185 | |
186 | domain = zpci_alloc_domain(domain: (u16)fr->uid); |
187 | if (domain < 0) |
188 | return domain; |
189 | |
190 | zbus->domain_nr = domain; |
191 | zbus->multifunction = fr->rid_available; |
192 | zbus->max_bus_speed = fr->max_bus_speed; |
193 | |
194 | /* |
195 | * Note that the zbus->resources are taken over and zbus->resources |
196 | * is empty after a successful call |
197 | */ |
198 | bus = pci_create_root_bus(NULL, bus: ZPCI_BUS_NR, ops, sysdata: zbus, resources: &zbus->resources); |
199 | if (!bus) { |
200 | zpci_free_domain(domain: zbus->domain_nr); |
201 | return -EFAULT; |
202 | } |
203 | |
204 | zbus->bus = bus; |
205 | |
206 | return 0; |
207 | } |
208 | |
209 | static void zpci_bus_release(struct kref *kref) |
210 | { |
211 | struct zpci_bus *zbus = container_of(kref, struct zpci_bus, kref); |
212 | |
213 | if (zbus->bus) { |
214 | pci_lock_rescan_remove(); |
215 | pci_stop_root_bus(bus: zbus->bus); |
216 | |
217 | zpci_free_domain(domain: zbus->domain_nr); |
218 | pci_free_resource_list(resources: &zbus->resources); |
219 | |
220 | pci_remove_root_bus(bus: zbus->bus); |
221 | pci_unlock_rescan_remove(); |
222 | } |
223 | |
224 | mutex_lock(&zbus_list_lock); |
225 | list_del(entry: &zbus->bus_next); |
226 | mutex_unlock(lock: &zbus_list_lock); |
227 | kfree(objp: zbus); |
228 | } |
229 | |
230 | static void zpci_bus_put(struct zpci_bus *zbus) |
231 | { |
232 | kref_put(kref: &zbus->kref, release: zpci_bus_release); |
233 | } |
234 | |
235 | static struct zpci_bus *zpci_bus_get(int pchid) |
236 | { |
237 | struct zpci_bus *zbus; |
238 | |
239 | mutex_lock(&zbus_list_lock); |
240 | list_for_each_entry(zbus, &zbus_list, bus_next) { |
241 | if (pchid == zbus->pchid) { |
242 | kref_get(kref: &zbus->kref); |
243 | goto out_unlock; |
244 | } |
245 | } |
246 | zbus = NULL; |
247 | out_unlock: |
248 | mutex_unlock(lock: &zbus_list_lock); |
249 | return zbus; |
250 | } |
251 | |
252 | static struct zpci_bus *zpci_bus_alloc(int pchid) |
253 | { |
254 | struct zpci_bus *zbus; |
255 | |
256 | zbus = kzalloc(sizeof(*zbus), GFP_KERNEL); |
257 | if (!zbus) |
258 | return NULL; |
259 | |
260 | zbus->pchid = pchid; |
261 | INIT_LIST_HEAD(list: &zbus->bus_next); |
262 | mutex_lock(&zbus_list_lock); |
263 | list_add_tail(new: &zbus->bus_next, head: &zbus_list); |
264 | mutex_unlock(lock: &zbus_list_lock); |
265 | |
266 | kref_init(kref: &zbus->kref); |
267 | INIT_LIST_HEAD(list: &zbus->resources); |
268 | |
269 | zbus->bus_resource.start = 0; |
270 | zbus->bus_resource.end = ZPCI_BUS_NR; |
271 | zbus->bus_resource.flags = IORESOURCE_BUS; |
272 | pci_add_resource(resources: &zbus->resources, res: &zbus->bus_resource); |
273 | |
274 | return zbus; |
275 | } |
276 | |
277 | void pcibios_bus_add_device(struct pci_dev *pdev) |
278 | { |
279 | struct zpci_dev *zdev = to_zpci(pdev); |
280 | |
281 | /* |
282 | * With pdev->no_vf_scan the common PCI probing code does not |
283 | * perform PF/VF linking. |
284 | */ |
285 | if (zdev->vfn) { |
286 | zpci_iov_setup_virtfn(zbus: zdev->zbus, virtfn: pdev, vfn: zdev->vfn); |
287 | pdev->no_command_memory = 1; |
288 | } |
289 | } |
290 | |
291 | static int zpci_bus_add_device(struct zpci_bus *zbus, struct zpci_dev *zdev) |
292 | { |
293 | int rc = -EINVAL; |
294 | |
295 | if (zbus->function[zdev->devfn]) { |
296 | pr_err("devfn %04x is already assigned\n" , zdev->devfn); |
297 | return rc; |
298 | } |
299 | |
300 | zdev->zbus = zbus; |
301 | zbus->function[zdev->devfn] = zdev; |
302 | zpci_nb_devices++; |
303 | |
304 | if (zbus->multifunction && !zdev->rid_available) { |
305 | WARN_ONCE(1, "rid_available not set for multifunction\n" ); |
306 | goto error; |
307 | } |
308 | rc = zpci_init_slot(zdev); |
309 | if (rc) |
310 | goto error; |
311 | zdev->has_hp_slot = 1; |
312 | |
313 | return 0; |
314 | |
315 | error: |
316 | zbus->function[zdev->devfn] = NULL; |
317 | zdev->zbus = NULL; |
318 | zpci_nb_devices--; |
319 | return rc; |
320 | } |
321 | |
322 | int zpci_bus_device_register(struct zpci_dev *zdev, struct pci_ops *ops) |
323 | { |
324 | struct zpci_bus *zbus = NULL; |
325 | int rc = -EBADF; |
326 | |
327 | if (zpci_nb_devices == ZPCI_NR_DEVICES) { |
328 | pr_warn("Adding PCI function %08x failed because the configured limit of %d is reached\n" , |
329 | zdev->fid, ZPCI_NR_DEVICES); |
330 | return -ENOSPC; |
331 | } |
332 | |
333 | if (zdev->devfn >= ZPCI_FUNCTIONS_PER_BUS) |
334 | return -EINVAL; |
335 | |
336 | if (!s390_pci_no_rid && zdev->rid_available) |
337 | zbus = zpci_bus_get(pchid: zdev->pchid); |
338 | |
339 | if (!zbus) { |
340 | zbus = zpci_bus_alloc(pchid: zdev->pchid); |
341 | if (!zbus) |
342 | return -ENOMEM; |
343 | } |
344 | |
345 | if (!zbus->bus) { |
346 | /* The UID of the first PCI function registered with a zpci_bus |
347 | * is used as the domain number for that bus. Currently there |
348 | * is exactly one zpci_bus per domain. |
349 | */ |
350 | rc = zpci_bus_create_pci_bus(zbus, fr: zdev, ops); |
351 | if (rc) |
352 | goto error; |
353 | } |
354 | |
355 | rc = zpci_bus_add_device(zbus, zdev); |
356 | if (rc) |
357 | goto error; |
358 | |
359 | return 0; |
360 | |
361 | error: |
362 | pr_err("Adding PCI function %08x failed\n" , zdev->fid); |
363 | zpci_bus_put(zbus); |
364 | return rc; |
365 | } |
366 | |
367 | void zpci_bus_device_unregister(struct zpci_dev *zdev) |
368 | { |
369 | struct zpci_bus *zbus = zdev->zbus; |
370 | |
371 | zpci_nb_devices--; |
372 | zbus->function[zdev->devfn] = NULL; |
373 | zpci_bus_put(zbus); |
374 | } |
375 | |