]>
Commit | Line | Data |
---|---|---|
66725152 GS |
1 | /* |
2 | * PCI Hotplug Driver for PowerPC PowerNV platform. | |
3 | * | |
4 | * Copyright Gavin Shan, IBM Corporation 2016. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/libfdt.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/pci.h> | |
15 | #include <linux/pci_hotplug.h> | |
16 | ||
17 | #include <asm/opal.h> | |
18 | #include <asm/pnv-pci.h> | |
19 | #include <asm/ppc-pci.h> | |
20 | ||
21 | #define DRIVER_VERSION "0.1" | |
22 | #define DRIVER_AUTHOR "Gavin Shan, IBM Corporation" | |
23 | #define DRIVER_DESC "PowerPC PowerNV PCI Hotplug Driver" | |
24 | ||
360aebd8 GS |
25 | struct pnv_php_event { |
26 | bool added; | |
27 | struct pnv_php_slot *php_slot; | |
28 | struct work_struct work; | |
29 | }; | |
30 | ||
66725152 GS |
31 | static LIST_HEAD(pnv_php_slot_list); |
32 | static DEFINE_SPINLOCK(pnv_php_lock); | |
33 | ||
34 | static void pnv_php_register(struct device_node *dn); | |
35 | static void pnv_php_unregister_one(struct device_node *dn); | |
36 | static void pnv_php_unregister(struct device_node *dn); | |
37 | ||
360aebd8 GS |
38 | static void pnv_php_disable_irq(struct pnv_php_slot *php_slot) |
39 | { | |
40 | struct pci_dev *pdev = php_slot->pdev; | |
41 | u16 ctrl; | |
42 | ||
43 | if (php_slot->irq > 0) { | |
44 | pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &ctrl); | |
45 | ctrl &= ~(PCI_EXP_SLTCTL_HPIE | | |
46 | PCI_EXP_SLTCTL_PDCE | | |
47 | PCI_EXP_SLTCTL_DLLSCE); | |
48 | pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, ctrl); | |
49 | ||
50 | free_irq(php_slot->irq, php_slot); | |
51 | php_slot->irq = 0; | |
52 | } | |
53 | ||
54 | if (php_slot->wq) { | |
55 | destroy_workqueue(php_slot->wq); | |
56 | php_slot->wq = NULL; | |
57 | } | |
58 | ||
59 | if (pdev->msix_enabled) | |
60 | pci_disable_msix(pdev); | |
61 | else if (pdev->msi_enabled) | |
62 | pci_disable_msi(pdev); | |
63 | } | |
64 | ||
66725152 GS |
65 | static void pnv_php_free_slot(struct kref *kref) |
66 | { | |
67 | struct pnv_php_slot *php_slot = container_of(kref, | |
68 | struct pnv_php_slot, kref); | |
69 | ||
70 | WARN_ON(!list_empty(&php_slot->children)); | |
360aebd8 | 71 | pnv_php_disable_irq(php_slot); |
66725152 GS |
72 | kfree(php_slot->name); |
73 | kfree(php_slot); | |
74 | } | |
75 | ||
76 | static inline void pnv_php_put_slot(struct pnv_php_slot *php_slot) | |
77 | { | |
78 | ||
71d6b5b9 | 79 | if (!php_slot) |
66725152 GS |
80 | return; |
81 | ||
82 | kref_put(&php_slot->kref, pnv_php_free_slot); | |
83 | } | |
84 | ||
85 | static struct pnv_php_slot *pnv_php_match(struct device_node *dn, | |
86 | struct pnv_php_slot *php_slot) | |
87 | { | |
88 | struct pnv_php_slot *target, *tmp; | |
89 | ||
90 | if (php_slot->dn == dn) { | |
91 | kref_get(&php_slot->kref); | |
92 | return php_slot; | |
93 | } | |
94 | ||
95 | list_for_each_entry(tmp, &php_slot->children, link) { | |
96 | target = pnv_php_match(dn, tmp); | |
97 | if (target) | |
98 | return target; | |
99 | } | |
100 | ||
101 | return NULL; | |
102 | } | |
103 | ||
89379f16 | 104 | struct pnv_php_slot *pnv_php_find_slot(struct device_node *dn) |
66725152 GS |
105 | { |
106 | struct pnv_php_slot *php_slot, *tmp; | |
107 | unsigned long flags; | |
108 | ||
109 | spin_lock_irqsave(&pnv_php_lock, flags); | |
110 | list_for_each_entry(tmp, &pnv_php_slot_list, link) { | |
111 | php_slot = pnv_php_match(dn, tmp); | |
112 | if (php_slot) { | |
113 | spin_unlock_irqrestore(&pnv_php_lock, flags); | |
114 | return php_slot; | |
115 | } | |
116 | } | |
117 | spin_unlock_irqrestore(&pnv_php_lock, flags); | |
118 | ||
119 | return NULL; | |
120 | } | |
89379f16 | 121 | EXPORT_SYMBOL_GPL(pnv_php_find_slot); |
66725152 GS |
122 | |
123 | /* | |
124 | * Remove pdn for all children of the indicated device node. | |
125 | * The function should remove pdn in a depth-first manner. | |
126 | */ | |
127 | static void pnv_php_rmv_pdns(struct device_node *dn) | |
128 | { | |
129 | struct device_node *child; | |
130 | ||
131 | for_each_child_of_node(dn, child) { | |
132 | pnv_php_rmv_pdns(child); | |
133 | ||
134 | pci_remove_device_node_info(child); | |
135 | } | |
136 | } | |
137 | ||
138 | /* | |
139 | * Detach all child nodes of the indicated device nodes. The | |
140 | * function should handle device nodes in depth-first manner. | |
141 | * | |
142 | * We should not invoke of_node_release() as the memory for | |
143 | * individual device node is part of large memory block. The | |
144 | * large block is allocated from memblock (system bootup) or | |
145 | * kmalloc() when unflattening the device tree by OF changeset. | |
146 | * We can not free the large block allocated from memblock. For | |
147 | * later case, it should be released at once. | |
148 | */ | |
149 | static void pnv_php_detach_device_nodes(struct device_node *parent) | |
150 | { | |
151 | struct device_node *dn; | |
152 | int refcount; | |
153 | ||
154 | for_each_child_of_node(parent, dn) { | |
155 | pnv_php_detach_device_nodes(dn); | |
156 | ||
157 | of_node_put(dn); | |
158 | refcount = atomic_read(&dn->kobj.kref.refcount); | |
149ba66a | 159 | if (refcount != 1) |
66725152 GS |
160 | pr_warn("Invalid refcount %d on <%s>\n", |
161 | refcount, of_node_full_name(dn)); | |
162 | ||
163 | of_detach_node(dn); | |
164 | } | |
165 | } | |
166 | ||
167 | static void pnv_php_rmv_devtree(struct pnv_php_slot *php_slot) | |
168 | { | |
169 | pnv_php_rmv_pdns(php_slot->dn); | |
170 | ||
171 | /* | |
172 | * Decrease the refcount if the device nodes were created | |
173 | * through OF changeset before detaching them. | |
174 | */ | |
175 | if (php_slot->fdt) | |
176 | of_changeset_destroy(&php_slot->ocs); | |
177 | pnv_php_detach_device_nodes(php_slot->dn); | |
178 | ||
179 | if (php_slot->fdt) { | |
180 | kfree(php_slot->dt); | |
181 | kfree(php_slot->fdt); | |
182 | php_slot->dt = NULL; | |
183 | php_slot->dn->child = NULL; | |
184 | php_slot->fdt = NULL; | |
185 | } | |
186 | } | |
187 | ||
188 | /* | |
189 | * As the nodes in OF changeset are applied in reverse order, we | |
190 | * need revert the nodes in advance so that we have correct node | |
191 | * order after the changeset is applied. | |
192 | */ | |
193 | static void pnv_php_reverse_nodes(struct device_node *parent) | |
194 | { | |
195 | struct device_node *child, *next; | |
196 | ||
197 | /* In-depth first */ | |
198 | for_each_child_of_node(parent, child) | |
199 | pnv_php_reverse_nodes(child); | |
200 | ||
201 | /* Reverse the nodes in the child list */ | |
202 | child = parent->child; | |
203 | parent->child = NULL; | |
204 | while (child) { | |
205 | next = child->sibling; | |
206 | ||
207 | child->sibling = parent->child; | |
208 | parent->child = child; | |
209 | child = next; | |
210 | } | |
211 | } | |
212 | ||
213 | static int pnv_php_populate_changeset(struct of_changeset *ocs, | |
214 | struct device_node *dn) | |
215 | { | |
216 | struct device_node *child; | |
217 | int ret = 0; | |
218 | ||
219 | for_each_child_of_node(dn, child) { | |
220 | ret = of_changeset_attach_node(ocs, child); | |
149ba66a | 221 | if (ret) |
66725152 GS |
222 | break; |
223 | ||
224 | ret = pnv_php_populate_changeset(ocs, child); | |
149ba66a | 225 | if (ret) |
66725152 GS |
226 | break; |
227 | } | |
228 | ||
229 | return ret; | |
230 | } | |
231 | ||
232 | static void *pnv_php_add_one_pdn(struct device_node *dn, void *data) | |
233 | { | |
234 | struct pci_controller *hose = (struct pci_controller *)data; | |
235 | struct pci_dn *pdn; | |
236 | ||
237 | pdn = pci_add_device_node_info(hose, dn); | |
149ba66a | 238 | if (!pdn) |
66725152 GS |
239 | return ERR_PTR(-ENOMEM); |
240 | ||
241 | return NULL; | |
242 | } | |
243 | ||
244 | static void pnv_php_add_pdns(struct pnv_php_slot *slot) | |
245 | { | |
246 | struct pci_controller *hose = pci_bus_to_host(slot->bus); | |
247 | ||
248 | pci_traverse_device_nodes(slot->dn, pnv_php_add_one_pdn, hose); | |
249 | } | |
250 | ||
251 | static int pnv_php_add_devtree(struct pnv_php_slot *php_slot) | |
252 | { | |
253 | void *fdt, *fdt1, *dt; | |
254 | int ret; | |
255 | ||
256 | /* We don't know the FDT blob size. We try to get it through | |
257 | * maximal memory chunk and then copy it to another chunk that | |
258 | * fits the real size. | |
259 | */ | |
260 | fdt1 = kzalloc(0x10000, GFP_KERNEL); | |
149ba66a | 261 | if (!fdt1) { |
66725152 GS |
262 | ret = -ENOMEM; |
263 | dev_warn(&php_slot->pdev->dev, "Cannot alloc FDT blob\n"); | |
264 | goto out; | |
265 | } | |
266 | ||
267 | ret = pnv_pci_get_device_tree(php_slot->dn->phandle, fdt1, 0x10000); | |
149ba66a | 268 | if (ret) { |
66725152 GS |
269 | dev_warn(&php_slot->pdev->dev, "Error %d getting FDT blob\n", |
270 | ret); | |
271 | goto free_fdt1; | |
272 | } | |
273 | ||
274 | fdt = kzalloc(fdt_totalsize(fdt1), GFP_KERNEL); | |
149ba66a | 275 | if (!fdt) { |
66725152 GS |
276 | ret = -ENOMEM; |
277 | dev_warn(&php_slot->pdev->dev, "Cannot %d bytes memory\n", | |
278 | fdt_totalsize(fdt1)); | |
279 | goto free_fdt1; | |
280 | } | |
281 | ||
282 | /* Unflatten device tree blob */ | |
283 | memcpy(fdt, fdt1, fdt_totalsize(fdt1)); | |
284 | dt = of_fdt_unflatten_tree(fdt, php_slot->dn, NULL); | |
149ba66a | 285 | if (!dt) { |
66725152 GS |
286 | ret = -EINVAL; |
287 | dev_warn(&php_slot->pdev->dev, "Cannot unflatten FDT\n"); | |
288 | goto free_fdt; | |
289 | } | |
290 | ||
291 | /* Initialize and apply the changeset */ | |
292 | of_changeset_init(&php_slot->ocs); | |
293 | pnv_php_reverse_nodes(php_slot->dn); | |
294 | ret = pnv_php_populate_changeset(&php_slot->ocs, php_slot->dn); | |
149ba66a | 295 | if (ret) { |
66725152 GS |
296 | pnv_php_reverse_nodes(php_slot->dn); |
297 | dev_warn(&php_slot->pdev->dev, "Error %d populating changeset\n", | |
298 | ret); | |
299 | goto free_dt; | |
300 | } | |
301 | ||
302 | php_slot->dn->child = NULL; | |
303 | ret = of_changeset_apply(&php_slot->ocs); | |
149ba66a | 304 | if (ret) { |
66725152 GS |
305 | dev_warn(&php_slot->pdev->dev, "Error %d applying changeset\n", |
306 | ret); | |
307 | goto destroy_changeset; | |
308 | } | |
309 | ||
310 | /* Add device node firmware data */ | |
311 | pnv_php_add_pdns(php_slot); | |
312 | php_slot->fdt = fdt; | |
313 | php_slot->dt = dt; | |
314 | kfree(fdt1); | |
315 | goto out; | |
316 | ||
317 | destroy_changeset: | |
318 | of_changeset_destroy(&php_slot->ocs); | |
319 | free_dt: | |
320 | kfree(dt); | |
321 | php_slot->dn->child = NULL; | |
322 | free_fdt: | |
323 | kfree(fdt); | |
324 | free_fdt1: | |
325 | kfree(fdt1); | |
326 | out: | |
327 | return ret; | |
328 | } | |
329 | ||
89379f16 AD |
330 | int pnv_php_set_slot_power_state(struct hotplug_slot *slot, |
331 | uint8_t state) | |
66725152 GS |
332 | { |
333 | struct pnv_php_slot *php_slot = slot->private; | |
334 | struct opal_msg msg; | |
335 | int ret; | |
336 | ||
337 | ret = pnv_pci_set_power_state(php_slot->id, state, &msg); | |
149ba66a | 338 | if (ret > 0) { |
66725152 GS |
339 | if (be64_to_cpu(msg.params[1]) != php_slot->dn->phandle || |
340 | be64_to_cpu(msg.params[2]) != state || | |
341 | be64_to_cpu(msg.params[3]) != OPAL_SUCCESS) { | |
342 | dev_warn(&php_slot->pdev->dev, "Wrong msg (%lld, %lld, %lld)\n", | |
343 | be64_to_cpu(msg.params[1]), | |
344 | be64_to_cpu(msg.params[2]), | |
345 | be64_to_cpu(msg.params[3])); | |
346 | return -ENOMSG; | |
347 | } | |
149ba66a | 348 | } else if (ret < 0) { |
66725152 GS |
349 | dev_warn(&php_slot->pdev->dev, "Error %d powering %s\n", |
350 | ret, (state == OPAL_PCI_SLOT_POWER_ON) ? "on" : "off"); | |
351 | return ret; | |
352 | } | |
353 | ||
5473a6bf | 354 | if (state == OPAL_PCI_SLOT_POWER_OFF || state == OPAL_PCI_SLOT_OFFLINE) |
66725152 GS |
355 | pnv_php_rmv_devtree(php_slot); |
356 | else | |
357 | ret = pnv_php_add_devtree(php_slot); | |
358 | ||
359 | return ret; | |
360 | } | |
89379f16 | 361 | EXPORT_SYMBOL_GPL(pnv_php_set_slot_power_state); |
66725152 GS |
362 | |
363 | static int pnv_php_get_power_state(struct hotplug_slot *slot, u8 *state) | |
364 | { | |
365 | struct pnv_php_slot *php_slot = slot->private; | |
366 | uint8_t power_state = OPAL_PCI_SLOT_POWER_ON; | |
367 | int ret; | |
368 | ||
369 | /* | |
370 | * Retrieve power status from firmware. If we fail | |
371 | * getting that, the power status fails back to | |
372 | * be on. | |
373 | */ | |
374 | ret = pnv_pci_get_power_state(php_slot->id, &power_state); | |
149ba66a | 375 | if (ret) { |
66725152 GS |
376 | dev_warn(&php_slot->pdev->dev, "Error %d getting power status\n", |
377 | ret); | |
378 | } else { | |
379 | *state = power_state; | |
380 | slot->info->power_status = power_state; | |
381 | } | |
382 | ||
383 | return 0; | |
384 | } | |
385 | ||
386 | static int pnv_php_get_adapter_state(struct hotplug_slot *slot, u8 *state) | |
387 | { | |
388 | struct pnv_php_slot *php_slot = slot->private; | |
389 | uint8_t presence = OPAL_PCI_SLOT_EMPTY; | |
390 | int ret; | |
391 | ||
392 | /* | |
393 | * Retrieve presence status from firmware. If we can't | |
394 | * get that, it will fail back to be empty. | |
395 | */ | |
396 | ret = pnv_pci_get_presence_state(php_slot->id, &presence); | |
149ba66a | 397 | if (ret >= 0) { |
66725152 GS |
398 | *state = presence; |
399 | slot->info->adapter_status = presence; | |
400 | ret = 0; | |
401 | } else { | |
402 | dev_warn(&php_slot->pdev->dev, "Error %d getting presence\n", | |
403 | ret); | |
404 | } | |
405 | ||
406 | return ret; | |
407 | } | |
408 | ||
409 | static int pnv_php_set_attention_state(struct hotplug_slot *slot, u8 state) | |
410 | { | |
411 | /* FIXME: Make it real once firmware supports it */ | |
412 | slot->info->attention_status = state; | |
413 | ||
414 | return 0; | |
415 | } | |
416 | ||
417 | static int pnv_php_enable(struct pnv_php_slot *php_slot, bool rescan) | |
418 | { | |
419 | struct hotplug_slot *slot = &php_slot->slot; | |
420 | uint8_t presence = OPAL_PCI_SLOT_EMPTY; | |
421 | uint8_t power_status = OPAL_PCI_SLOT_POWER_ON; | |
422 | int ret; | |
423 | ||
424 | /* Check if the slot has been configured */ | |
425 | if (php_slot->state != PNV_PHP_STATE_REGISTERED) | |
426 | return 0; | |
427 | ||
428 | /* Retrieve slot presence status */ | |
429 | ret = pnv_php_get_adapter_state(slot, &presence); | |
149ba66a | 430 | if (ret) |
66725152 GS |
431 | return ret; |
432 | ||
433 | /* Proceed if there have nothing behind the slot */ | |
434 | if (presence == OPAL_PCI_SLOT_EMPTY) | |
435 | goto scan; | |
436 | ||
437 | /* | |
438 | * If the power supply to the slot is off, we can't detect | |
439 | * adapter presence state. That means we have to turn the | |
440 | * slot on before going to probe slot's presence state. | |
441 | * | |
442 | * On the first time, we don't change the power status to | |
443 | * boost system boot with assumption that the firmware | |
444 | * supplies consistent slot power status: empty slot always | |
445 | * has its power off and non-empty slot has its power on. | |
446 | */ | |
447 | if (!php_slot->power_state_check) { | |
448 | php_slot->power_state_check = true; | |
449 | ||
450 | ret = pnv_php_get_power_state(slot, &power_status); | |
149ba66a | 451 | if (ret) |
66725152 GS |
452 | return ret; |
453 | ||
454 | if (power_status != OPAL_PCI_SLOT_POWER_ON) | |
455 | return 0; | |
456 | } | |
457 | ||
458 | /* Check the power status. Scan the slot if it is already on */ | |
459 | ret = pnv_php_get_power_state(slot, &power_status); | |
149ba66a | 460 | if (ret) |
66725152 GS |
461 | return ret; |
462 | ||
463 | if (power_status == OPAL_PCI_SLOT_POWER_ON) | |
464 | goto scan; | |
465 | ||
466 | /* Power is off, turn it on and then scan the slot */ | |
467 | ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_ON); | |
149ba66a | 468 | if (ret) |
66725152 GS |
469 | return ret; |
470 | ||
471 | scan: | |
472 | if (presence == OPAL_PCI_SLOT_PRESENT) { | |
473 | if (rescan) { | |
474 | pci_lock_rescan_remove(); | |
475 | pci_hp_add_devices(php_slot->bus); | |
476 | pci_unlock_rescan_remove(); | |
477 | } | |
478 | ||
479 | /* Rescan for child hotpluggable slots */ | |
480 | php_slot->state = PNV_PHP_STATE_POPULATED; | |
481 | if (rescan) | |
482 | pnv_php_register(php_slot->dn); | |
483 | } else { | |
484 | php_slot->state = PNV_PHP_STATE_POPULATED; | |
485 | } | |
486 | ||
487 | return 0; | |
488 | } | |
489 | ||
490 | static int pnv_php_enable_slot(struct hotplug_slot *slot) | |
491 | { | |
492 | struct pnv_php_slot *php_slot = container_of(slot, | |
493 | struct pnv_php_slot, slot); | |
494 | ||
495 | return pnv_php_enable(php_slot, true); | |
496 | } | |
497 | ||
498 | static int pnv_php_disable_slot(struct hotplug_slot *slot) | |
499 | { | |
500 | struct pnv_php_slot *php_slot = slot->private; | |
501 | int ret; | |
502 | ||
503 | if (php_slot->state != PNV_PHP_STATE_POPULATED) | |
504 | return 0; | |
505 | ||
506 | /* Remove all devices behind the slot */ | |
507 | pci_lock_rescan_remove(); | |
508 | pci_hp_remove_devices(php_slot->bus); | |
509 | pci_unlock_rescan_remove(); | |
510 | ||
511 | /* Detach the child hotpluggable slots */ | |
512 | pnv_php_unregister(php_slot->dn); | |
513 | ||
514 | /* Notify firmware and remove device nodes */ | |
515 | ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_OFF); | |
516 | ||
517 | php_slot->state = PNV_PHP_STATE_REGISTERED; | |
518 | return ret; | |
519 | } | |
520 | ||
521 | static struct hotplug_slot_ops php_slot_ops = { | |
522 | .get_power_status = pnv_php_get_power_state, | |
523 | .get_adapter_status = pnv_php_get_adapter_state, | |
524 | .set_attention_status = pnv_php_set_attention_state, | |
525 | .enable_slot = pnv_php_enable_slot, | |
526 | .disable_slot = pnv_php_disable_slot, | |
527 | }; | |
528 | ||
529 | static void pnv_php_release(struct hotplug_slot *slot) | |
530 | { | |
531 | struct pnv_php_slot *php_slot = slot->private; | |
532 | unsigned long flags; | |
533 | ||
534 | /* Remove from global or child list */ | |
535 | spin_lock_irqsave(&pnv_php_lock, flags); | |
536 | list_del(&php_slot->link); | |
537 | spin_unlock_irqrestore(&pnv_php_lock, flags); | |
538 | ||
539 | /* Detach from parent */ | |
540 | pnv_php_put_slot(php_slot); | |
541 | pnv_php_put_slot(php_slot->parent); | |
542 | } | |
543 | ||
544 | static struct pnv_php_slot *pnv_php_alloc_slot(struct device_node *dn) | |
545 | { | |
546 | struct pnv_php_slot *php_slot; | |
547 | struct pci_bus *bus; | |
548 | const char *label; | |
549 | uint64_t id; | |
39f0d6fb | 550 | int ret; |
66725152 | 551 | |
39f0d6fb GS |
552 | ret = of_property_read_string(dn, "ibm,slot-label", &label); |
553 | if (ret) | |
66725152 GS |
554 | return NULL; |
555 | ||
556 | if (pnv_pci_get_slot_id(dn, &id)) | |
557 | return NULL; | |
558 | ||
559 | bus = pci_find_bus_by_node(dn); | |
149ba66a | 560 | if (!bus) |
66725152 GS |
561 | return NULL; |
562 | ||
563 | php_slot = kzalloc(sizeof(*php_slot), GFP_KERNEL); | |
149ba66a | 564 | if (!php_slot) |
66725152 GS |
565 | return NULL; |
566 | ||
567 | php_slot->name = kstrdup(label, GFP_KERNEL); | |
149ba66a | 568 | if (!php_slot->name) { |
66725152 GS |
569 | kfree(php_slot); |
570 | return NULL; | |
571 | } | |
572 | ||
149ba66a | 573 | if (dn->child && PCI_DN(dn->child)) |
66725152 GS |
574 | php_slot->slot_no = PCI_SLOT(PCI_DN(dn->child)->devfn); |
575 | else | |
576 | php_slot->slot_no = -1; /* Placeholder slot */ | |
577 | ||
578 | kref_init(&php_slot->kref); | |
579 | php_slot->state = PNV_PHP_STATE_INITIALIZED; | |
580 | php_slot->dn = dn; | |
581 | php_slot->pdev = bus->self; | |
582 | php_slot->bus = bus; | |
583 | php_slot->id = id; | |
584 | php_slot->power_state_check = false; | |
585 | php_slot->slot.ops = &php_slot_ops; | |
586 | php_slot->slot.info = &php_slot->slot_info; | |
587 | php_slot->slot.release = pnv_php_release; | |
588 | php_slot->slot.private = php_slot; | |
589 | ||
590 | INIT_LIST_HEAD(&php_slot->children); | |
591 | INIT_LIST_HEAD(&php_slot->link); | |
592 | ||
593 | return php_slot; | |
594 | } | |
595 | ||
596 | static int pnv_php_register_slot(struct pnv_php_slot *php_slot) | |
597 | { | |
598 | struct pnv_php_slot *parent; | |
599 | struct device_node *dn = php_slot->dn; | |
600 | unsigned long flags; | |
601 | int ret; | |
602 | ||
603 | /* Check if the slot is registered or not */ | |
604 | parent = pnv_php_find_slot(php_slot->dn); | |
149ba66a | 605 | if (parent) { |
66725152 GS |
606 | pnv_php_put_slot(parent); |
607 | return -EEXIST; | |
608 | } | |
609 | ||
610 | /* Register PCI slot */ | |
611 | ret = pci_hp_register(&php_slot->slot, php_slot->bus, | |
612 | php_slot->slot_no, php_slot->name); | |
149ba66a | 613 | if (ret) { |
66725152 GS |
614 | dev_warn(&php_slot->pdev->dev, "Error %d registering slot\n", |
615 | ret); | |
616 | return ret; | |
617 | } | |
618 | ||
619 | /* Attach to the parent's child list or global list */ | |
620 | while ((dn = of_get_parent(dn))) { | |
621 | if (!PCI_DN(dn)) { | |
622 | of_node_put(dn); | |
623 | break; | |
624 | } | |
625 | ||
626 | parent = pnv_php_find_slot(dn); | |
627 | if (parent) { | |
628 | of_node_put(dn); | |
629 | break; | |
630 | } | |
631 | ||
632 | of_node_put(dn); | |
633 | } | |
634 | ||
635 | spin_lock_irqsave(&pnv_php_lock, flags); | |
636 | php_slot->parent = parent; | |
637 | if (parent) | |
638 | list_add_tail(&php_slot->link, &parent->children); | |
639 | else | |
640 | list_add_tail(&php_slot->link, &pnv_php_slot_list); | |
641 | spin_unlock_irqrestore(&pnv_php_lock, flags); | |
642 | ||
643 | php_slot->state = PNV_PHP_STATE_REGISTERED; | |
644 | return 0; | |
645 | } | |
646 | ||
360aebd8 GS |
647 | static int pnv_php_enable_msix(struct pnv_php_slot *php_slot) |
648 | { | |
649 | struct pci_dev *pdev = php_slot->pdev; | |
650 | struct msix_entry entry; | |
651 | int nr_entries, ret; | |
652 | u16 pcie_flag; | |
653 | ||
654 | /* Get total number of MSIx entries */ | |
655 | nr_entries = pci_msix_vec_count(pdev); | |
656 | if (nr_entries < 0) | |
657 | return nr_entries; | |
658 | ||
659 | /* Check hotplug MSIx entry is in range */ | |
660 | pcie_capability_read_word(pdev, PCI_EXP_FLAGS, &pcie_flag); | |
661 | entry.entry = (pcie_flag & PCI_EXP_FLAGS_IRQ) >> 9; | |
662 | if (entry.entry >= nr_entries) | |
663 | return -ERANGE; | |
664 | ||
665 | /* Enable MSIx */ | |
666 | ret = pci_enable_msix_exact(pdev, &entry, 1); | |
667 | if (ret) { | |
668 | dev_warn(&pdev->dev, "Error %d enabling MSIx\n", ret); | |
669 | return ret; | |
670 | } | |
671 | ||
672 | return entry.vector; | |
673 | } | |
674 | ||
675 | static void pnv_php_event_handler(struct work_struct *work) | |
676 | { | |
677 | struct pnv_php_event *event = | |
678 | container_of(work, struct pnv_php_event, work); | |
679 | struct pnv_php_slot *php_slot = event->php_slot; | |
680 | ||
681 | if (event->added) | |
682 | pnv_php_enable_slot(&php_slot->slot); | |
683 | else | |
684 | pnv_php_disable_slot(&php_slot->slot); | |
685 | ||
686 | kfree(event); | |
687 | } | |
688 | ||
689 | static irqreturn_t pnv_php_interrupt(int irq, void *data) | |
690 | { | |
691 | struct pnv_php_slot *php_slot = data; | |
692 | struct pci_dev *pchild, *pdev = php_slot->pdev; | |
693 | struct eeh_dev *edev; | |
694 | struct eeh_pe *pe; | |
695 | struct pnv_php_event *event; | |
696 | u16 sts, lsts; | |
697 | u8 presence; | |
698 | bool added; | |
699 | unsigned long flags; | |
700 | int ret; | |
701 | ||
702 | pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &sts); | |
703 | sts &= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC); | |
704 | pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, sts); | |
705 | if (sts & PCI_EXP_SLTSTA_DLLSC) { | |
706 | pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lsts); | |
707 | added = !!(lsts & PCI_EXP_LNKSTA_DLLLA); | |
708 | } else if (sts & PCI_EXP_SLTSTA_PDC) { | |
709 | ret = pnv_pci_get_presence_state(php_slot->id, &presence); | |
710 | if (!ret) | |
711 | return IRQ_HANDLED; | |
712 | added = !!(presence == OPAL_PCI_SLOT_PRESENT); | |
713 | } else { | |
714 | return IRQ_NONE; | |
715 | } | |
716 | ||
717 | /* Freeze the removed PE to avoid unexpected error reporting */ | |
718 | if (!added) { | |
719 | pchild = list_first_entry_or_null(&php_slot->bus->devices, | |
720 | struct pci_dev, bus_list); | |
721 | edev = pchild ? pci_dev_to_eeh_dev(pchild) : NULL; | |
722 | pe = edev ? edev->pe : NULL; | |
723 | if (pe) { | |
724 | eeh_serialize_lock(&flags); | |
725 | eeh_pe_state_mark(pe, EEH_PE_ISOLATED); | |
726 | eeh_serialize_unlock(flags); | |
727 | eeh_pe_set_option(pe, EEH_OPT_FREEZE_PE); | |
728 | } | |
729 | } | |
730 | ||
731 | /* | |
732 | * The PE is left in frozen state if the event is missed. It's | |
733 | * fine as the PCI devices (PE) aren't functional any more. | |
734 | */ | |
735 | event = kzalloc(sizeof(*event), GFP_ATOMIC); | |
736 | if (!event) { | |
737 | dev_warn(&pdev->dev, "PCI slot [%s] missed hotplug event 0x%04x\n", | |
738 | php_slot->name, sts); | |
739 | return IRQ_HANDLED; | |
740 | } | |
741 | ||
742 | dev_info(&pdev->dev, "PCI slot [%s] %s (IRQ: %d)\n", | |
743 | php_slot->name, added ? "added" : "removed", irq); | |
744 | INIT_WORK(&event->work, pnv_php_event_handler); | |
745 | event->added = added; | |
746 | event->php_slot = php_slot; | |
747 | queue_work(php_slot->wq, &event->work); | |
748 | ||
749 | return IRQ_HANDLED; | |
750 | } | |
751 | ||
752 | static void pnv_php_init_irq(struct pnv_php_slot *php_slot, int irq) | |
753 | { | |
754 | struct pci_dev *pdev = php_slot->pdev; | |
755 | u16 sts, ctrl; | |
756 | int ret; | |
757 | ||
758 | /* Allocate workqueue */ | |
759 | php_slot->wq = alloc_workqueue("pciehp-%s", 0, 0, php_slot->name); | |
760 | if (!php_slot->wq) { | |
761 | dev_warn(&pdev->dev, "Cannot alloc workqueue\n"); | |
762 | pnv_php_disable_irq(php_slot); | |
763 | return; | |
764 | } | |
765 | ||
766 | /* Clear pending interrupts */ | |
767 | pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &sts); | |
768 | sts |= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC); | |
769 | pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, sts); | |
770 | ||
771 | /* Request the interrupt */ | |
772 | ret = request_irq(irq, pnv_php_interrupt, IRQF_SHARED, | |
773 | php_slot->name, php_slot); | |
774 | if (ret) { | |
775 | pnv_php_disable_irq(php_slot); | |
776 | dev_warn(&pdev->dev, "Error %d enabling IRQ %d\n", ret, irq); | |
777 | return; | |
778 | } | |
779 | ||
780 | /* Enable the interrupts */ | |
781 | pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &ctrl); | |
782 | ctrl |= (PCI_EXP_SLTCTL_HPIE | | |
783 | PCI_EXP_SLTCTL_PDCE | | |
784 | PCI_EXP_SLTCTL_DLLSCE); | |
785 | pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, ctrl); | |
786 | ||
787 | /* The interrupt is initialized successfully when @irq is valid */ | |
788 | php_slot->irq = irq; | |
789 | } | |
790 | ||
791 | static void pnv_php_enable_irq(struct pnv_php_slot *php_slot) | |
792 | { | |
793 | struct pci_dev *pdev = php_slot->pdev; | |
794 | int irq, ret; | |
795 | ||
796 | ret = pci_enable_device(pdev); | |
797 | if (ret) { | |
798 | dev_warn(&pdev->dev, "Error %d enabling device\n", ret); | |
799 | return; | |
800 | } | |
801 | ||
802 | pci_set_master(pdev); | |
803 | ||
804 | /* Enable MSIx interrupt */ | |
805 | irq = pnv_php_enable_msix(php_slot); | |
806 | if (irq > 0) { | |
807 | pnv_php_init_irq(php_slot, irq); | |
808 | return; | |
809 | } | |
810 | ||
811 | /* | |
812 | * Use MSI if MSIx doesn't work. Fail back to legacy INTx | |
813 | * if MSI doesn't work either | |
814 | */ | |
815 | ret = pci_enable_msi(pdev); | |
816 | if (!ret || pdev->irq) { | |
817 | irq = pdev->irq; | |
818 | pnv_php_init_irq(php_slot, irq); | |
819 | } | |
820 | } | |
821 | ||
66725152 GS |
822 | static int pnv_php_register_one(struct device_node *dn) |
823 | { | |
824 | struct pnv_php_slot *php_slot; | |
39f0d6fb | 825 | u32 prop32; |
66725152 GS |
826 | int ret; |
827 | ||
828 | /* Check if it's hotpluggable slot */ | |
39f0d6fb GS |
829 | ret = of_property_read_u32(dn, "ibm,slot-pluggable", &prop32); |
830 | if (ret || !prop32) | |
66725152 GS |
831 | return -ENXIO; |
832 | ||
39f0d6fb GS |
833 | ret = of_property_read_u32(dn, "ibm,reset-by-firmware", &prop32); |
834 | if (ret || !prop32) | |
66725152 GS |
835 | return -ENXIO; |
836 | ||
837 | php_slot = pnv_php_alloc_slot(dn); | |
149ba66a | 838 | if (!php_slot) |
66725152 GS |
839 | return -ENODEV; |
840 | ||
841 | ret = pnv_php_register_slot(php_slot); | |
149ba66a | 842 | if (ret) |
66725152 GS |
843 | goto free_slot; |
844 | ||
845 | ret = pnv_php_enable(php_slot, false); | |
149ba66a | 846 | if (ret) |
66725152 GS |
847 | goto unregister_slot; |
848 | ||
360aebd8 | 849 | /* Enable interrupt if the slot supports surprise hotplug */ |
39f0d6fb GS |
850 | ret = of_property_read_u32(dn, "ibm,slot-surprise-pluggable", &prop32); |
851 | if (!ret && prop32) | |
360aebd8 GS |
852 | pnv_php_enable_irq(php_slot); |
853 | ||
66725152 GS |
854 | return 0; |
855 | ||
856 | unregister_slot: | |
857 | pnv_php_unregister_one(php_slot->dn); | |
858 | free_slot: | |
859 | pnv_php_put_slot(php_slot); | |
860 | return ret; | |
861 | } | |
862 | ||
863 | static void pnv_php_register(struct device_node *dn) | |
864 | { | |
865 | struct device_node *child; | |
866 | ||
867 | /* | |
868 | * The parent slots should be registered before their | |
869 | * child slots. | |
870 | */ | |
871 | for_each_child_of_node(dn, child) { | |
872 | pnv_php_register_one(child); | |
873 | pnv_php_register(child); | |
874 | } | |
875 | } | |
876 | ||
877 | static void pnv_php_unregister_one(struct device_node *dn) | |
878 | { | |
879 | struct pnv_php_slot *php_slot; | |
880 | ||
881 | php_slot = pnv_php_find_slot(dn); | |
882 | if (!php_slot) | |
883 | return; | |
884 | ||
885 | php_slot->state = PNV_PHP_STATE_OFFLINE; | |
886 | pnv_php_put_slot(php_slot); | |
887 | pci_hp_deregister(&php_slot->slot); | |
888 | } | |
889 | ||
890 | static void pnv_php_unregister(struct device_node *dn) | |
891 | { | |
892 | struct device_node *child; | |
893 | ||
894 | /* The child slots should go before their parent slots */ | |
895 | for_each_child_of_node(dn, child) { | |
896 | pnv_php_unregister(child); | |
897 | pnv_php_unregister_one(child); | |
898 | } | |
899 | } | |
900 | ||
901 | static int __init pnv_php_init(void) | |
902 | { | |
903 | struct device_node *dn; | |
904 | ||
905 | pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); | |
906 | for_each_compatible_node(dn, NULL, "ibm,ioda2-phb") | |
907 | pnv_php_register(dn); | |
908 | ||
909 | return 0; | |
910 | } | |
911 | ||
912 | static void __exit pnv_php_exit(void) | |
913 | { | |
914 | struct device_node *dn; | |
915 | ||
916 | for_each_compatible_node(dn, NULL, "ibm,ioda2-phb") | |
917 | pnv_php_unregister(dn); | |
918 | } | |
919 | ||
920 | module_init(pnv_php_init); | |
921 | module_exit(pnv_php_exit); | |
922 | ||
923 | MODULE_VERSION(DRIVER_VERSION); | |
924 | MODULE_LICENSE("GPL v2"); | |
925 | MODULE_AUTHOR(DRIVER_AUTHOR); | |
926 | MODULE_DESCRIPTION(DRIVER_DESC); |