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