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