1 /*
2  * CompactPCI Hot Plug Driver
3  *
4  * Copyright (C) 2002,2005 SOMA Networks, Inc.
5  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6  * Copyright (C) 2001 IBM Corp.
7  *
8  * All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or (at
13  * your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
18  * NON INFRINGEMENT.  See the GNU General Public License for more
19  * details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  *
25  * Send feedback to <scottm@somanetworks.com>
26  */
27 
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/slab.h>
31 #include <linux/pci.h>
32 #include <linux/pci_hotplug.h>
33 #include <linux/init.h>
34 #include <linux/interrupt.h>
35 #include <linux/atomic.h>
36 #include <linux/delay.h>
37 #include <linux/kthread.h>
38 #include "cpci_hotplug.h"
39 
40 #define DRIVER_AUTHOR	"Scott Murray <scottm@somanetworks.com>"
41 #define DRIVER_DESC	"CompactPCI Hot Plug Core"
42 
43 #define MY_NAME	"cpci_hotplug"
44 
45 #define dbg(format, arg...)					\
46 	do {							\
47 		if (cpci_debug)					\
48 			printk (KERN_DEBUG "%s: " format "\n",	\
49 				MY_NAME , ## arg);		\
50 	} while (0)
51 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
52 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
53 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
54 
55 /* local variables */
56 static DECLARE_RWSEM(list_rwsem);
57 static LIST_HEAD(slot_list);
58 static int slots;
59 static atomic_t extracting;
60 int cpci_debug;
61 static struct cpci_hp_controller *controller;
62 static struct task_struct *cpci_thread;
63 static int thread_finished;
64 
65 static int enable_slot(struct hotplug_slot *slot);
66 static int disable_slot(struct hotplug_slot *slot);
67 static int set_attention_status(struct hotplug_slot *slot, u8 value);
68 static int get_power_status(struct hotplug_slot *slot, u8 *value);
69 static int get_attention_status(struct hotplug_slot *slot, u8 *value);
70 static int get_adapter_status(struct hotplug_slot *slot, u8 *value);
71 static int get_latch_status(struct hotplug_slot *slot, u8 *value);
72 
73 static struct hotplug_slot_ops cpci_hotplug_slot_ops = {
74 	.enable_slot = enable_slot,
75 	.disable_slot = disable_slot,
76 	.set_attention_status = set_attention_status,
77 	.get_power_status = get_power_status,
78 	.get_attention_status = get_attention_status,
79 	.get_adapter_status = get_adapter_status,
80 	.get_latch_status = get_latch_status,
81 };
82 
83 static int
84 update_latch_status(struct hotplug_slot *hotplug_slot, u8 value)
85 {
86 	struct hotplug_slot_info info;
87 
88 	memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
89 	info.latch_status = value;
90 	return pci_hp_change_slot_info(hotplug_slot, &info);
91 }
92 
93 static int
94 update_adapter_status(struct hotplug_slot *hotplug_slot, u8 value)
95 {
96 	struct hotplug_slot_info info;
97 
98 	memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
99 	info.adapter_status = value;
100 	return pci_hp_change_slot_info(hotplug_slot, &info);
101 }
102 
103 static int
104 enable_slot(struct hotplug_slot *hotplug_slot)
105 {
106 	struct slot *slot = hotplug_slot->private;
107 	int retval = 0;
108 
109 	dbg("%s - physical_slot = %s", __func__, slot_name(slot));
110 
111 	if (controller->ops->set_power)
112 		retval = controller->ops->set_power(slot, 1);
113 	return retval;
114 }
115 
116 static int
117 disable_slot(struct hotplug_slot *hotplug_slot)
118 {
119 	struct slot *slot = hotplug_slot->private;
120 	int retval = 0;
121 
122 	dbg("%s - physical_slot = %s", __func__, slot_name(slot));
123 
124 	down_write(&list_rwsem);
125 
126 	/* Unconfigure device */
127 	dbg("%s - unconfiguring slot %s", __func__, slot_name(slot));
128 	retval = cpci_unconfigure_slot(slot);
129 	if (retval) {
130 		err("%s - could not unconfigure slot %s",
131 		    __func__, slot_name(slot));
132 		goto disable_error;
133 	}
134 	dbg("%s - finished unconfiguring slot %s", __func__, slot_name(slot));
135 
136 	/* Clear EXT (by setting it) */
137 	if (cpci_clear_ext(slot)) {
138 		err("%s - could not clear EXT for slot %s",
139 		    __func__, slot_name(slot));
140 		retval = -ENODEV;
141 		goto disable_error;
142 	}
143 	cpci_led_on(slot);
144 
145 	if (controller->ops->set_power) {
146 		retval = controller->ops->set_power(slot, 0);
147 		if (retval)
148 			goto disable_error;
149 	}
150 
151 	if (update_adapter_status(slot->hotplug_slot, 0))
152 		warn("failure to update adapter file");
153 
154 	if (slot->extracting) {
155 		slot->extracting = 0;
156 		atomic_dec(&extracting);
157 	}
158 disable_error:
159 	up_write(&list_rwsem);
160 	return retval;
161 }
162 
163 static u8
164 cpci_get_power_status(struct slot *slot)
165 {
166 	u8 power = 1;
167 
168 	if (controller->ops->get_power)
169 		power = controller->ops->get_power(slot);
170 	return power;
171 }
172 
173 static int
174 get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
175 {
176 	struct slot *slot = hotplug_slot->private;
177 
178 	*value = cpci_get_power_status(slot);
179 	return 0;
180 }
181 
182 static int
183 get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
184 {
185 	struct slot *slot = hotplug_slot->private;
186 
187 	*value = cpci_get_attention_status(slot);
188 	return 0;
189 }
190 
191 static int
192 set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
193 {
194 	return cpci_set_attention_status(hotplug_slot->private, status);
195 }
196 
197 static int
198 get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
199 {
200 	*value = hotplug_slot->info->adapter_status;
201 	return 0;
202 }
203 
204 static int
205 get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
206 {
207 	*value = hotplug_slot->info->latch_status;
208 	return 0;
209 }
210 
211 static void release_slot(struct hotplug_slot *hotplug_slot)
212 {
213 	struct slot *slot = hotplug_slot->private;
214 
215 	kfree(slot->hotplug_slot->info);
216 	kfree(slot->hotplug_slot);
217 	pci_dev_put(slot->dev);
218 	kfree(slot);
219 }
220 
221 #define SLOT_NAME_SIZE	6
222 
223 int
224 cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
225 {
226 	struct slot *slot;
227 	struct hotplug_slot *hotplug_slot;
228 	struct hotplug_slot_info *info;
229 	char name[SLOT_NAME_SIZE];
230 	int status;
231 	int i;
232 
233 	if (!(controller && bus))
234 		return -ENODEV;
235 
236 	/*
237 	 * Create a structure for each slot, and register that slot
238 	 * with the pci_hotplug subsystem.
239 	 */
240 	for (i = first; i <= last; ++i) {
241 		slot = kzalloc(sizeof (struct slot), GFP_KERNEL);
242 		if (!slot) {
243 			status = -ENOMEM;
244 			goto error;
245 		}
246 
247 		hotplug_slot =
248 			kzalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
249 		if (!hotplug_slot) {
250 			status = -ENOMEM;
251 			goto error_slot;
252 		}
253 		slot->hotplug_slot = hotplug_slot;
254 
255 		info = kzalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
256 		if (!info) {
257 			status = -ENOMEM;
258 			goto error_hpslot;
259 		}
260 		hotplug_slot->info = info;
261 
262 		slot->bus = bus;
263 		slot->number = i;
264 		slot->devfn = PCI_DEVFN(i, 0);
265 
266 		snprintf(name, SLOT_NAME_SIZE, "%02x:%02x", bus->number, i);
267 
268 		hotplug_slot->private = slot;
269 		hotplug_slot->release = &release_slot;
270 		hotplug_slot->ops = &cpci_hotplug_slot_ops;
271 
272 		/*
273 		 * Initialize the slot info structure with some known
274 		 * good values.
275 		 */
276 		dbg("initializing slot %s", name);
277 		info->power_status = cpci_get_power_status(slot);
278 		info->attention_status = cpci_get_attention_status(slot);
279 
280 		dbg("registering slot %s", name);
281 		status = pci_hp_register(slot->hotplug_slot, bus, i, name);
282 		if (status) {
283 			err("pci_hp_register failed with error %d", status);
284 			goto error_info;
285 		}
286 		dbg("slot registered with name: %s", slot_name(slot));
287 
288 		/* Add slot to our internal list */
289 		down_write(&list_rwsem);
290 		list_add(&slot->slot_list, &slot_list);
291 		slots++;
292 		up_write(&list_rwsem);
293 	}
294 	return 0;
295 error_info:
296 	kfree(info);
297 error_hpslot:
298 	kfree(hotplug_slot);
299 error_slot:
300 	kfree(slot);
301 error:
302 	return status;
303 }
304 EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
305 
306 int
307 cpci_hp_unregister_bus(struct pci_bus *bus)
308 {
309 	struct slot *slot;
310 	struct slot *tmp;
311 	int status = 0;
312 
313 	down_write(&list_rwsem);
314 	if (!slots) {
315 		up_write(&list_rwsem);
316 		return -1;
317 	}
318 	list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
319 		if (slot->bus == bus) {
320 			list_del(&slot->slot_list);
321 			slots--;
322 
323 			dbg("deregistering slot %s", slot_name(slot));
324 			status = pci_hp_deregister(slot->hotplug_slot);
325 			if (status) {
326 				err("pci_hp_deregister failed with error %d",
327 				    status);
328 				break;
329 			}
330 		}
331 	}
332 	up_write(&list_rwsem);
333 	return status;
334 }
335 EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
336 
337 /* This is the interrupt mode interrupt handler */
338 static irqreturn_t
339 cpci_hp_intr(int irq, void *data)
340 {
341 	dbg("entered cpci_hp_intr");
342 
343 	/* Check to see if it was our interrupt */
344 	if ((controller->irq_flags & IRQF_SHARED) &&
345 	    !controller->ops->check_irq(controller->dev_id)) {
346 		dbg("exited cpci_hp_intr, not our interrupt");
347 		return IRQ_NONE;
348 	}
349 
350 	/* Disable ENUM interrupt */
351 	controller->ops->disable_irq();
352 
353 	/* Trigger processing by the event thread */
354 	wake_up_process(cpci_thread);
355 	return IRQ_HANDLED;
356 }
357 
358 /*
359  * According to PICMG 2.1 R2.0, section 6.3.2, upon
360  * initialization, the system driver shall clear the
361  * INS bits of the cold-inserted devices.
362  */
363 static int
364 init_slots(int clear_ins)
365 {
366 	struct slot *slot;
367 	struct pci_dev *dev;
368 
369 	dbg("%s - enter", __func__);
370 	down_read(&list_rwsem);
371 	if (!slots) {
372 		up_read(&list_rwsem);
373 		return -1;
374 	}
375 	list_for_each_entry(slot, &slot_list, slot_list) {
376 		dbg("%s - looking at slot %s", __func__, slot_name(slot));
377 		if (clear_ins && cpci_check_and_clear_ins(slot))
378 			dbg("%s - cleared INS for slot %s",
379 			    __func__, slot_name(slot));
380 		dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
381 		if (dev) {
382 			if (update_adapter_status(slot->hotplug_slot, 1))
383 				warn("failure to update adapter file");
384 			if (update_latch_status(slot->hotplug_slot, 1))
385 				warn("failure to update latch file");
386 			slot->dev = dev;
387 		}
388 	}
389 	up_read(&list_rwsem);
390 	dbg("%s - exit", __func__);
391 	return 0;
392 }
393 
394 static int
395 check_slots(void)
396 {
397 	struct slot *slot;
398 	int extracted;
399 	int inserted;
400 	u16 hs_csr;
401 
402 	down_read(&list_rwsem);
403 	if (!slots) {
404 		up_read(&list_rwsem);
405 		err("no slots registered, shutting down");
406 		return -1;
407 	}
408 	extracted = inserted = 0;
409 	list_for_each_entry(slot, &slot_list, slot_list) {
410 		dbg("%s - looking at slot %s", __func__, slot_name(slot));
411 		if (cpci_check_and_clear_ins(slot)) {
412 			/*
413 			 * Some broken hardware (e.g. PLX 9054AB) asserts
414 			 * ENUM# twice...
415 			 */
416 			if (slot->dev) {
417 				warn("slot %s already inserted",
418 				     slot_name(slot));
419 				inserted++;
420 				continue;
421 			}
422 
423 			/* Process insertion */
424 			dbg("%s - slot %s inserted", __func__, slot_name(slot));
425 
426 			/* GSM, debug */
427 			hs_csr = cpci_get_hs_csr(slot);
428 			dbg("%s - slot %s HS_CSR (1) = %04x",
429 			    __func__, slot_name(slot), hs_csr);
430 
431 			/* Configure device */
432 			dbg("%s - configuring slot %s",
433 			    __func__, slot_name(slot));
434 			if (cpci_configure_slot(slot)) {
435 				err("%s - could not configure slot %s",
436 				    __func__, slot_name(slot));
437 				continue;
438 			}
439 			dbg("%s - finished configuring slot %s",
440 			    __func__, slot_name(slot));
441 
442 			/* GSM, debug */
443 			hs_csr = cpci_get_hs_csr(slot);
444 			dbg("%s - slot %s HS_CSR (2) = %04x",
445 			    __func__, slot_name(slot), hs_csr);
446 
447 			if (update_latch_status(slot->hotplug_slot, 1))
448 				warn("failure to update latch file");
449 
450 			if (update_adapter_status(slot->hotplug_slot, 1))
451 				warn("failure to update adapter file");
452 
453 			cpci_led_off(slot);
454 
455 			/* GSM, debug */
456 			hs_csr = cpci_get_hs_csr(slot);
457 			dbg("%s - slot %s HS_CSR (3) = %04x",
458 			    __func__, slot_name(slot), hs_csr);
459 
460 			inserted++;
461 		} else if (cpci_check_ext(slot)) {
462 			/* Process extraction request */
463 			dbg("%s - slot %s extracted",
464 			    __func__, slot_name(slot));
465 
466 			/* GSM, debug */
467 			hs_csr = cpci_get_hs_csr(slot);
468 			dbg("%s - slot %s HS_CSR = %04x",
469 			    __func__, slot_name(slot), hs_csr);
470 
471 			if (!slot->extracting) {
472 				if (update_latch_status(slot->hotplug_slot, 0))
473 					warn("failure to update latch file");
474 
475 				slot->extracting = 1;
476 				atomic_inc(&extracting);
477 			}
478 			extracted++;
479 		} else if (slot->extracting) {
480 			hs_csr = cpci_get_hs_csr(slot);
481 			if (hs_csr == 0xffff) {
482 				/*
483 				 * Hmmm, we're likely hosed at this point, should we
484 				 * bother trying to tell the driver or not?
485 				 */
486 				err("card in slot %s was improperly removed",
487 				    slot_name(slot));
488 				if (update_adapter_status(slot->hotplug_slot, 0))
489 					warn("failure to update adapter file");
490 				slot->extracting = 0;
491 				atomic_dec(&extracting);
492 			}
493 		}
494 	}
495 	up_read(&list_rwsem);
496 	dbg("inserted=%d, extracted=%d, extracting=%d",
497 	    inserted, extracted, atomic_read(&extracting));
498 	if (inserted || extracted)
499 		return extracted;
500 	else if (!atomic_read(&extracting)) {
501 		err("cannot find ENUM# source, shutting down");
502 		return -1;
503 	}
504 	return 0;
505 }
506 
507 /* This is the interrupt mode worker thread body */
508 static int
509 event_thread(void *data)
510 {
511 	int rc;
512 
513 	dbg("%s - event thread started", __func__);
514 	while (1) {
515 		dbg("event thread sleeping");
516 		set_current_state(TASK_INTERRUPTIBLE);
517 		schedule();
518 		if (kthread_should_stop())
519 			break;
520 		do {
521 			rc = check_slots();
522 			if (rc > 0) {
523 				/* Give userspace a chance to handle extraction */
524 				msleep(500);
525 			} else if (rc < 0) {
526 				dbg("%s - error checking slots", __func__);
527 				thread_finished = 1;
528 				goto out;
529 			}
530 		} while (atomic_read(&extracting) && !kthread_should_stop());
531 		if (kthread_should_stop())
532 			break;
533 
534 		/* Re-enable ENUM# interrupt */
535 		dbg("%s - re-enabling irq", __func__);
536 		controller->ops->enable_irq();
537 	}
538  out:
539 	return 0;
540 }
541 
542 /* This is the polling mode worker thread body */
543 static int
544 poll_thread(void *data)
545 {
546 	int rc;
547 
548 	while (1) {
549 		if (kthread_should_stop() || signal_pending(current))
550 			break;
551 		if (controller->ops->query_enum()) {
552 			do {
553 				rc = check_slots();
554 				if (rc > 0) {
555 					/* Give userspace a chance to handle extraction */
556 					msleep(500);
557 				} else if (rc < 0) {
558 					dbg("%s - error checking slots", __func__);
559 					thread_finished = 1;
560 					goto out;
561 				}
562 			} while (atomic_read(&extracting) && !kthread_should_stop());
563 		}
564 		msleep(100);
565 	}
566  out:
567 	return 0;
568 }
569 
570 static int
571 cpci_start_thread(void)
572 {
573 	if (controller->irq)
574 		cpci_thread = kthread_run(event_thread, NULL, "cpci_hp_eventd");
575 	else
576 		cpci_thread = kthread_run(poll_thread, NULL, "cpci_hp_polld");
577 	if (IS_ERR(cpci_thread)) {
578 		err("Can't start up our thread");
579 		return PTR_ERR(cpci_thread);
580 	}
581 	thread_finished = 0;
582 	return 0;
583 }
584 
585 static void
586 cpci_stop_thread(void)
587 {
588 	kthread_stop(cpci_thread);
589 	thread_finished = 1;
590 }
591 
592 int
593 cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
594 {
595 	int status = 0;
596 
597 	if (controller)
598 		return -1;
599 	if (!(new_controller && new_controller->ops))
600 		return -EINVAL;
601 	if (new_controller->irq) {
602 		if (!(new_controller->ops->enable_irq &&
603 		     new_controller->ops->disable_irq))
604 			status = -EINVAL;
605 		if (request_irq(new_controller->irq,
606 			       cpci_hp_intr,
607 			       new_controller->irq_flags,
608 			       MY_NAME,
609 			       new_controller->dev_id)) {
610 			err("Can't get irq %d for the hotplug cPCI controller",
611 			    new_controller->irq);
612 			status = -ENODEV;
613 		}
614 		dbg("%s - acquired controller irq %d",
615 		    __func__, new_controller->irq);
616 	}
617 	if (!status)
618 		controller = new_controller;
619 	return status;
620 }
621 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
622 
623 static void
624 cleanup_slots(void)
625 {
626 	struct slot *slot;
627 	struct slot *tmp;
628 
629 	/*
630 	 * Unregister all of our slots with the pci_hotplug subsystem,
631 	 * and free up all memory that we had allocated.
632 	 */
633 	down_write(&list_rwsem);
634 	if (!slots)
635 		goto cleanup_null;
636 	list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
637 		list_del(&slot->slot_list);
638 		pci_hp_deregister(slot->hotplug_slot);
639 	}
640 cleanup_null:
641 	up_write(&list_rwsem);
642 	return;
643 }
644 
645 int
646 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
647 {
648 	int status = 0;
649 
650 	if (controller) {
651 		if (!thread_finished)
652 			cpci_stop_thread();
653 		if (controller->irq)
654 			free_irq(controller->irq, controller->dev_id);
655 		controller = NULL;
656 		cleanup_slots();
657 	} else
658 		status = -ENODEV;
659 	return status;
660 }
661 EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
662 
663 int
664 cpci_hp_start(void)
665 {
666 	static int first = 1;
667 	int status;
668 
669 	dbg("%s - enter", __func__);
670 	if (!controller)
671 		return -ENODEV;
672 
673 	down_read(&list_rwsem);
674 	if (list_empty(&slot_list)) {
675 		up_read(&list_rwsem);
676 		return -ENODEV;
677 	}
678 	up_read(&list_rwsem);
679 
680 	status = init_slots(first);
681 	if (first)
682 		first = 0;
683 	if (status)
684 		return status;
685 
686 	status = cpci_start_thread();
687 	if (status)
688 		return status;
689 	dbg("%s - thread started", __func__);
690 
691 	if (controller->irq) {
692 		/* Start enum interrupt processing */
693 		dbg("%s - enabling irq", __func__);
694 		controller->ops->enable_irq();
695 	}
696 	dbg("%s - exit", __func__);
697 	return 0;
698 }
699 EXPORT_SYMBOL_GPL(cpci_hp_start);
700 
701 int
702 cpci_hp_stop(void)
703 {
704 	if (!controller)
705 		return -ENODEV;
706 	if (controller->irq) {
707 		/* Stop enum interrupt processing */
708 		dbg("%s - disabling irq", __func__);
709 		controller->ops->disable_irq();
710 	}
711 	cpci_stop_thread();
712 	return 0;
713 }
714 EXPORT_SYMBOL_GPL(cpci_hp_stop);
715 
716 int __init
717 cpci_hotplug_init(int debug)
718 {
719 	cpci_debug = debug;
720 	return 0;
721 }
722 
723 void __exit
724 cpci_hotplug_exit(void)
725 {
726 	/*
727 	 * Clean everything up.
728 	 */
729 	cpci_hp_stop();
730 	cpci_hp_unregister_controller(controller);
731 }
732