projects/linux·blob master · refs

579 lines · 15.1 KiB

1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * PCI HotPlug Controller Core
4 *
5 * Copyright (C) 2001-2002 Greg Kroah-Hartman ([email protected])
6 * Copyright (C) 2001-2002 IBM Corp.
7 *
8 * All rights reserved.
9 *
10 * Send feedback to <[email protected]>
11 *
12 * Authors:
13 * Greg Kroah-Hartman <[email protected]>
14 * Scott Murray <[email protected]>
15 */
16
17#include <linux/module.h>
18#include <linux/moduleparam.h>
19#include <linux/kernel.h>
20#include <linux/types.h>
21#include <linux/kobject.h>
22#include <linux/sysfs.h>
23#include <linux/init.h>
24#include <linux/pci.h>
25#include <linux/pci_hotplug.h>
26#include "../pci.h"
27#include "cpci_hotplug.h"
28
29#define MY_NAME "pci_hotplug"
30
31#define dbg(fmt, arg...) do { if (debug) printk(KERN_DEBUG "%s: %s: " fmt, MY_NAME, __func__, ## arg); } while (0)
32#define err(format, arg...) printk(KERN_ERR "%s: " format, MY_NAME, ## arg)
33#define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME, ## arg)
34#define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME, ## arg)
35
36/* local variables */
37static bool debug;
38
39/* Weee, fun with macros... */
40#define GET_STATUS(name, type) \
41static int get_##name(struct hotplug_slot *slot, type *value) \
42{ \
43 const struct hotplug_slot_ops *ops = slot->ops; \
44 int retval = 0; \
45 if (ops->get_##name) \
46 retval = ops->get_##name(slot, value); \
47 return retval; \
48}
49
50GET_STATUS(power_status, u8)
51GET_STATUS(attention_status, u8)
52GET_STATUS(latch_status, u8)
53GET_STATUS(adapter_status, u8)
54
55static ssize_t power_read_file(struct pci_slot *pci_slot, char *buf)
56{
57 int retval;
58 u8 value;
59
60 retval = get_power_status(pci_slot->hotplug, &value);
61 if (retval)
62 return retval;
63
64 return sysfs_emit(buf, "%d\n", value);
65}
66
67static ssize_t power_write_file(struct pci_slot *pci_slot, const char *buf,
68 size_t count)
69{
70 struct hotplug_slot *slot = pci_slot->hotplug;
71 unsigned long lpower;
72 u8 power;
73 int retval = 0;
74
75 lpower = simple_strtoul(buf, NULL, 10);
76 power = (u8)(lpower & 0xff);
77 dbg("power = %d\n", power);
78
79 switch (power) {
80 case 0:
81 if (slot->ops->disable_slot)
82 retval = slot->ops->disable_slot(slot);
83 break;
84
85 case 1:
86 if (slot->ops->enable_slot)
87 retval = slot->ops->enable_slot(slot);
88 break;
89
90 default:
91 err("Illegal value specified for power\n");
92 retval = -EINVAL;
93 }
94
95 if (retval)
96 return retval;
97 return count;
98}
99
100static struct pci_slot_attribute hotplug_slot_attr_power = {
101 .attr = {.name = "power", .mode = S_IFREG | S_IRUGO | S_IWUSR},
102 .show = power_read_file,
103 .store = power_write_file
104};
105
106static ssize_t attention_read_file(struct pci_slot *pci_slot, char *buf)
107{
108 int retval;
109 u8 value;
110
111 retval = get_attention_status(pci_slot->hotplug, &value);
112 if (retval)
113 return retval;
114
115 return sysfs_emit(buf, "%d\n", value);
116}
117
118static ssize_t attention_write_file(struct pci_slot *pci_slot, const char *buf,
119 size_t count)
120{
121 struct hotplug_slot *slot = pci_slot->hotplug;
122 const struct hotplug_slot_ops *ops = slot->ops;
123 unsigned long lattention;
124 u8 attention;
125 int retval = 0;
126
127 lattention = simple_strtoul(buf, NULL, 10);
128 attention = (u8)(lattention & 0xff);
129 dbg(" - attention = %d\n", attention);
130
131 if (ops->set_attention_status)
132 retval = ops->set_attention_status(slot, attention);
133
134 if (retval)
135 return retval;
136 return count;
137}
138
139static struct pci_slot_attribute hotplug_slot_attr_attention = {
140 .attr = {.name = "attention", .mode = S_IFREG | S_IRUGO | S_IWUSR},
141 .show = attention_read_file,
142 .store = attention_write_file
143};
144
145static ssize_t latch_read_file(struct pci_slot *pci_slot, char *buf)
146{
147 int retval;
148 u8 value;
149
150 retval = get_latch_status(pci_slot->hotplug, &value);
151 if (retval)
152 return retval;
153
154 return sysfs_emit(buf, "%d\n", value);
155}
156
157static struct pci_slot_attribute hotplug_slot_attr_latch = {
158 .attr = {.name = "latch", .mode = S_IFREG | S_IRUGO},
159 .show = latch_read_file,
160};
161
162static ssize_t presence_read_file(struct pci_slot *pci_slot, char *buf)
163{
164 int retval;
165 u8 value;
166
167 retval = get_adapter_status(pci_slot->hotplug, &value);
168 if (retval)
169 return retval;
170
171 return sysfs_emit(buf, "%d\n", value);
172}
173
174static struct pci_slot_attribute hotplug_slot_attr_presence = {
175 .attr = {.name = "adapter", .mode = S_IFREG | S_IRUGO},
176 .show = presence_read_file,
177};
178
179static ssize_t test_write_file(struct pci_slot *pci_slot, const char *buf,
180 size_t count)
181{
182 struct hotplug_slot *slot = pci_slot->hotplug;
183 unsigned long ltest;
184 u32 test;
185 int retval = 0;
186
187 ltest = simple_strtoul(buf, NULL, 10);
188 test = (u32)(ltest & 0xffffffff);
189 dbg("test = %d\n", test);
190
191 if (slot->ops->hardware_test)
192 retval = slot->ops->hardware_test(slot, test);
193
194 if (retval)
195 return retval;
196 return count;
197}
198
199static struct pci_slot_attribute hotplug_slot_attr_test = {
200 .attr = {.name = "test", .mode = S_IFREG | S_IRUGO | S_IWUSR},
201 .store = test_write_file
202};
203
204static bool has_power_file(struct hotplug_slot *slot)
205{
206 if ((slot->ops->enable_slot) ||
207 (slot->ops->disable_slot) ||
208 (slot->ops->get_power_status))
209 return true;
210 return false;
211}
212
213static bool has_attention_file(struct hotplug_slot *slot)
214{
215 if ((slot->ops->set_attention_status) ||
216 (slot->ops->get_attention_status))
217 return true;
218 return false;
219}
220
221static bool has_latch_file(struct hotplug_slot *slot)
222{
223 if (slot->ops->get_latch_status)
224 return true;
225 return false;
226}
227
228static bool has_adapter_file(struct hotplug_slot *slot)
229{
230 if (slot->ops->get_adapter_status)
231 return true;
232 return false;
233}
234
235static bool has_test_file(struct hotplug_slot *slot)
236{
237 if (slot->ops->hardware_test)
238 return true;
239 return false;
240}
241
242static int fs_add_slot(struct hotplug_slot *slot, struct pci_slot *pci_slot)
243{
244 struct kobject *kobj;
245 int retval = 0;
246
247 /* Create symbolic link to the hotplug driver module */
248 kobj = kset_find_obj(module_kset, slot->mod_name);
249 if (kobj) {
250 retval = sysfs_create_link(&pci_slot->kobj, kobj, "module");
251 if (retval)
252 dev_err(&pci_slot->bus->dev,
253 "Error creating sysfs link (%d)\n", retval);
254 kobject_put(kobj);
255 }
256
257 if (has_power_file(slot)) {
258 retval = sysfs_create_file(&pci_slot->kobj,
259 &hotplug_slot_attr_power.attr);
260 if (retval)
261 goto exit_power;
262 }
263
264 if (has_attention_file(slot)) {
265 retval = sysfs_create_file(&pci_slot->kobj,
266 &hotplug_slot_attr_attention.attr);
267 if (retval)
268 goto exit_attention;
269 }
270
271 if (has_latch_file(slot)) {
272 retval = sysfs_create_file(&pci_slot->kobj,
273 &hotplug_slot_attr_latch.attr);
274 if (retval)
275 goto exit_latch;
276 }
277
278 if (has_adapter_file(slot)) {
279 retval = sysfs_create_file(&pci_slot->kobj,
280 &hotplug_slot_attr_presence.attr);
281 if (retval)
282 goto exit_adapter;
283 }
284
285 if (has_test_file(slot)) {
286 retval = sysfs_create_file(&pci_slot->kobj,
287 &hotplug_slot_attr_test.attr);
288 if (retval)
289 goto exit_test;
290 }
291
292 goto exit;
293
294exit_test:
295 if (has_adapter_file(slot))
296 sysfs_remove_file(&pci_slot->kobj,
297 &hotplug_slot_attr_presence.attr);
298exit_adapter:
299 if (has_latch_file(slot))
300 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_latch.attr);
301exit_latch:
302 if (has_attention_file(slot))
303 sysfs_remove_file(&pci_slot->kobj,
304 &hotplug_slot_attr_attention.attr);
305exit_attention:
306 if (has_power_file(slot))
307 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_power.attr);
308exit_power:
309 sysfs_remove_link(&pci_slot->kobj, "module");
310exit:
311 return retval;
312}
313
314static void fs_remove_slot(struct hotplug_slot *slot, struct pci_slot *pci_slot)
315{
316 if (has_power_file(slot))
317 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_power.attr);
318
319 if (has_attention_file(slot))
320 sysfs_remove_file(&pci_slot->kobj,
321 &hotplug_slot_attr_attention.attr);
322
323 if (has_latch_file(slot))
324 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_latch.attr);
325
326 if (has_adapter_file(slot))
327 sysfs_remove_file(&pci_slot->kobj,
328 &hotplug_slot_attr_presence.attr);
329
330 if (has_test_file(slot))
331 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_test.attr);
332
333 sysfs_remove_link(&pci_slot->kobj, "module");
334}
335
336/**
337 * __pci_hp_register - register a hotplug_slot with the PCI hotplug subsystem
338 * @slot: pointer to the &struct hotplug_slot to register
339 * @bus: bus this slot is on
340 * @devnr: device number
341 * @name: name registered with kobject core
342 * @owner: caller module owner
343 * @mod_name: caller module name
344 *
345 * Prepares a hotplug slot for in-kernel use and immediately publishes it to
346 * user space in one go. Drivers may alternatively carry out the two steps
347 * separately by invoking pci_hp_initialize() and pci_hp_add().
348 *
349 * Returns 0 if successful, anything else for an error.
350 */
351int __pci_hp_register(struct hotplug_slot *slot, struct pci_bus *bus,
352 int devnr, const char *name,
353 struct module *owner, const char *mod_name)
354{
355 int result;
356
357 result = __pci_hp_initialize(slot, bus, devnr, name, owner, mod_name);
358 if (result)
359 return result;
360
361 result = pci_hp_add(slot);
362 if (result)
363 pci_hp_destroy(slot);
364
365 return result;
366}
367EXPORT_SYMBOL_GPL(__pci_hp_register);
368
369/**
370 * __pci_hp_initialize - prepare hotplug slot for in-kernel use
371 * @slot: pointer to the &struct hotplug_slot to initialize
372 * @bus: bus this slot is on
373 * @devnr: slot number
374 * @name: name registered with kobject core
375 * @owner: caller module owner
376 * @mod_name: caller module name
377 *
378 * Allocate and fill in a PCI slot for use by a hotplug driver. Once this has
379 * been called, the driver may invoke hotplug_slot_name() to get the slot's
380 * unique name. The driver must be prepared to handle a ->reset_slot callback
381 * from this point on.
382 *
383 * Returns 0 on success or a negative int on error.
384 */
385int __pci_hp_initialize(struct hotplug_slot *slot, struct pci_bus *bus,
386 int devnr, const char *name, struct module *owner,
387 const char *mod_name)
388{
389 struct pci_slot *pci_slot;
390
391 if (slot == NULL)
392 return -ENODEV;
393 if (slot->ops == NULL)
394 return -EINVAL;
395
396 slot->owner = owner;
397 slot->mod_name = mod_name;
398
399 /*
400 * No problems if we call this interface from both ACPI_PCI_SLOT
401 * driver and call it here again. If we've already created the
402 * pci_slot, the interface will simply bump the refcount.
403 */
404 pci_slot = pci_create_slot(bus, devnr, name, slot);
405 if (IS_ERR(pci_slot))
406 return PTR_ERR(pci_slot);
407
408 slot->pci_slot = pci_slot;
409 pci_slot->hotplug = slot;
410 return 0;
411}
412EXPORT_SYMBOL_GPL(__pci_hp_initialize);
413
414/**
415 * pci_hp_add - publish hotplug slot to user space
416 * @slot: pointer to the &struct hotplug_slot to publish
417 *
418 * Make a hotplug slot's sysfs interface available and inform user space of its
419 * addition by sending a uevent. The hotplug driver must be prepared to handle
420 * all &struct hotplug_slot_ops callbacks from this point on.
421 *
422 * Returns 0 on success or a negative int on error.
423 */
424int pci_hp_add(struct hotplug_slot *slot)
425{
426 struct pci_slot *pci_slot;
427 int result;
428
429 if (WARN_ON(!slot))
430 return -EINVAL;
431
432 pci_slot = slot->pci_slot;
433
434 result = fs_add_slot(slot, pci_slot);
435 if (result)
436 return result;
437
438 kobject_uevent(&pci_slot->kobj, KOBJ_ADD);
439 return 0;
440}
441EXPORT_SYMBOL_GPL(pci_hp_add);
442
443/**
444 * pci_hp_deregister - deregister a hotplug_slot with the PCI hotplug subsystem
445 * @slot: pointer to the &struct hotplug_slot to deregister
446 *
447 * The @slot must have been registered with the pci hotplug subsystem
448 * previously with a call to pci_hp_register().
449 */
450void pci_hp_deregister(struct hotplug_slot *slot)
451{
452 pci_hp_del(slot);
453 pci_hp_destroy(slot);
454}
455EXPORT_SYMBOL_GPL(pci_hp_deregister);
456
457/**
458 * pci_hp_del - unpublish hotplug slot from user space
459 * @slot: pointer to the &struct hotplug_slot to unpublish
460 *
461 * Remove a hotplug slot's sysfs interface.
462 */
463void pci_hp_del(struct hotplug_slot *slot)
464{
465 if (WARN_ON(!slot))
466 return;
467
468 fs_remove_slot(slot, slot->pci_slot);
469}
470EXPORT_SYMBOL_GPL(pci_hp_del);
471
472/**
473 * pci_hp_destroy - remove hotplug slot from in-kernel use
474 * @slot: pointer to the &struct hotplug_slot to destroy
475 *
476 * Destroy a PCI slot used by a hotplug driver. Once this has been called,
477 * the driver may no longer invoke hotplug_slot_name() to get the slot's
478 * unique name. The driver no longer needs to handle a ->reset_slot callback
479 * from this point on.
480 */
481void pci_hp_destroy(struct hotplug_slot *slot)
482{
483 struct pci_slot *pci_slot = slot->pci_slot;
484
485 slot->pci_slot = NULL;
486 pci_slot->hotplug = NULL;
487 pci_destroy_slot(pci_slot);
488}
489EXPORT_SYMBOL_GPL(pci_hp_destroy);
490
491static DECLARE_WAIT_QUEUE_HEAD(pci_hp_link_change_wq);
492
493/**
494 * pci_hp_ignore_link_change - begin code section causing spurious link changes
495 * @pdev: PCI hotplug bridge
496 *
497 * Mark the beginning of a code section causing spurious link changes on the
498 * Secondary Bus of @pdev, e.g. as a side effect of a Secondary Bus Reset,
499 * D3cold transition, firmware update or FPGA reconfiguration.
500 *
501 * Hotplug drivers can thus check whether such a code section is executing
502 * concurrently, await it with pci_hp_spurious_link_change() and ignore the
503 * resulting link change events.
504 *
505 * Must be paired with pci_hp_unignore_link_change(). May be called both
506 * from the PCI core and from Endpoint drivers. May be called for bridges
507 * which are not hotplug-capable, in which case it has no effect because
508 * no hotplug driver is bound to the bridge.
509 */
510void pci_hp_ignore_link_change(struct pci_dev *pdev)
511{
512 set_bit(PCI_LINK_CHANGING, &pdev->priv_flags);
513 smp_mb__after_atomic(); /* pairs with implied barrier of wait_event() */
514}
515
516/**
517 * pci_hp_unignore_link_change - end code section causing spurious link changes
518 * @pdev: PCI hotplug bridge
519 *
520 * Mark the end of a code section causing spurious link changes on the
521 * Secondary Bus of @pdev. Must be paired with pci_hp_ignore_link_change().
522 */
523void pci_hp_unignore_link_change(struct pci_dev *pdev)
524{
525 set_bit(PCI_LINK_CHANGED, &pdev->priv_flags);
526 mb(); /* ensure pci_hp_spurious_link_change() sees either bit set */
527 clear_bit(PCI_LINK_CHANGING, &pdev->priv_flags);
528 wake_up_all(&pci_hp_link_change_wq);
529}
530
531/**
532 * pci_hp_spurious_link_change - check for spurious link changes
533 * @pdev: PCI hotplug bridge
534 *
535 * Check whether a code section is executing concurrently which is causing
536 * spurious link changes on the Secondary Bus of @pdev. Await the end of the
537 * code section if so.
538 *
539 * May be called by hotplug drivers to check whether a link change is spurious
540 * and can be ignored.
541 *
542 * Because a genuine link change may have occurred in-between a spurious link
543 * change and the invocation of this function, hotplug drivers should perform
544 * sanity checks such as retrieving the current link state and bringing down
545 * the slot if the link is down.
546 *
547 * Return: %true if such a code section has been executing concurrently,
548 * otherwise %false. Also return %true if such a code section has not been
549 * executing concurrently, but at least once since the last invocation of this
550 * function.
551 */
552bool pci_hp_spurious_link_change(struct pci_dev *pdev)
553{
554 wait_event(pci_hp_link_change_wq,
555 !test_bit(PCI_LINK_CHANGING, &pdev->priv_flags));
556
557 return test_and_clear_bit(PCI_LINK_CHANGED, &pdev->priv_flags);
558}
559
560static int __init pci_hotplug_init(void)
561{
562 int result;
563
564 result = cpci_hotplug_init(debug);
565 if (result) {
566 err("cpci_hotplug_init with error %d\n", result);
567 return result;
568 }
569
570 return result;
571}
572device_initcall(pci_hotplug_init);
573
574/*
575 * not really modular, but the easiest way to keep compat with existing
576 * bootargs behaviour is to continue using module_param here.
577 */
578module_param(debug, bool, 0644);
579MODULE_PARM_DESC(debug, "Debugging mode enabled or not");