blob: 8132d946c384865287a3271358752aaf34a5e987 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * CompactPCI Hot Plug Driver
3 *
Scott Murraybcc488a2005-05-27 16:48:52 -04004 * Copyright (C) 2002,2005 SOMA Networks, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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/config.h>
29#include <linux/module.h>
30#include <linux/kernel.h>
31#include <linux/slab.h>
32#include <linux/pci.h>
33#include <linux/init.h>
34#include <linux/interrupt.h>
35#include <linux/smp_lock.h>
Scott Murray43b7d7c2005-05-09 17:31:50 -040036#include <asm/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/delay.h>
38#include "pci_hotplug.h"
39#include "cpci_hotplug.h"
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#define DRIVER_AUTHOR "Scott Murray <scottm@somanetworks.com>"
42#define DRIVER_DESC "CompactPCI Hot Plug Core"
43
44#define MY_NAME "cpci_hotplug"
45
46#define dbg(format, arg...) \
47 do { \
Scott Murraybcc488a2005-05-27 16:48:52 -040048 if (cpci_debug) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 printk (KERN_DEBUG "%s: " format "\n", \
50 MY_NAME , ## arg); \
Scott Murraybcc488a2005-05-27 16:48:52 -040051 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
53#define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
54#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
55
56/* local variables */
Scott Murray43b7d7c2005-05-09 17:31:50 -040057static DECLARE_RWSEM(list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static LIST_HEAD(slot_list);
59static int slots;
Scott Murray43b7d7c2005-05-09 17:31:50 -040060static atomic_t extracting;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061int cpci_debug;
62static struct cpci_hp_controller *controller;
63static struct semaphore event_semaphore; /* mutex for process loop (up if something to process) */
64static struct semaphore thread_exit; /* guard ensure thread has exited before calling it quits */
65static int thread_finished = 1;
66
67static int enable_slot(struct hotplug_slot *slot);
68static int disable_slot(struct hotplug_slot *slot);
69static int set_attention_status(struct hotplug_slot *slot, u8 value);
70static int get_power_status(struct hotplug_slot *slot, u8 * value);
71static int get_attention_status(struct hotplug_slot *slot, u8 * value);
Scott Murray43b7d7c2005-05-09 17:31:50 -040072static int get_adapter_status(struct hotplug_slot *slot, u8 * value);
73static int get_latch_status(struct hotplug_slot *slot, u8 * value);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75static struct hotplug_slot_ops cpci_hotplug_slot_ops = {
76 .owner = THIS_MODULE,
77 .enable_slot = enable_slot,
78 .disable_slot = disable_slot,
79 .set_attention_status = set_attention_status,
80 .get_power_status = get_power_status,
81 .get_attention_status = get_attention_status,
Scott Murray43b7d7c2005-05-09 17:31:50 -040082 .get_adapter_status = get_adapter_status,
83 .get_latch_status = get_latch_status,
Linus Torvalds1da177e2005-04-16 15:20:36 -070084};
85
86static int
87update_latch_status(struct hotplug_slot *hotplug_slot, u8 value)
88{
89 struct hotplug_slot_info info;
90
91 memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
92 info.latch_status = value;
93 return pci_hp_change_slot_info(hotplug_slot, &info);
94}
95
96static int
97update_adapter_status(struct hotplug_slot *hotplug_slot, u8 value)
98{
99 struct hotplug_slot_info info;
100
101 memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
102 info.adapter_status = value;
103 return pci_hp_change_slot_info(hotplug_slot, &info);
104}
105
106static int
107enable_slot(struct hotplug_slot *hotplug_slot)
108{
109 struct slot *slot = hotplug_slot->private;
110 int retval = 0;
111
112 dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
113
Scott Murraybcc488a2005-05-27 16:48:52 -0400114 if (controller->ops->set_power)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 retval = controller->ops->set_power(slot, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return retval;
117}
118
119static int
120disable_slot(struct hotplug_slot *hotplug_slot)
121{
122 struct slot *slot = hotplug_slot->private;
123 int retval = 0;
124
125 dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
126
Scott Murraybcc488a2005-05-27 16:48:52 -0400127 down_write(&list_rwsem);
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 /* Unconfigure device */
130 dbg("%s - unconfiguring slot %s",
131 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400132 if ((retval = cpci_unconfigure_slot(slot))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 err("%s - could not unconfigure slot %s",
134 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400135 goto disable_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137 dbg("%s - finished unconfiguring slot %s",
138 __FUNCTION__, slot->hotplug_slot->name);
139
140 /* Clear EXT (by setting it) */
Scott Murraybcc488a2005-05-27 16:48:52 -0400141 if (cpci_clear_ext(slot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 err("%s - could not clear EXT for slot %s",
143 __FUNCTION__, slot->hotplug_slot->name);
144 retval = -ENODEV;
Scott Murraybcc488a2005-05-27 16:48:52 -0400145 goto disable_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 }
147 cpci_led_on(slot);
148
Scott Murraybcc488a2005-05-27 16:48:52 -0400149 if (controller->ops->set_power)
150 if ((retval = controller->ops->set_power(slot, 0)))
151 goto disable_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Scott Murraybcc488a2005-05-27 16:48:52 -0400153 if (update_adapter_status(slot->hotplug_slot, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 warn("failure to update adapter file");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Scott Murraybcc488a2005-05-27 16:48:52 -0400156 if (slot->extracting) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400157 slot->extracting = 0;
158 atomic_dec(&extracting);
159 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400160disable_error:
161 up_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 return retval;
163}
164
165static u8
166cpci_get_power_status(struct slot *slot)
167{
168 u8 power = 1;
169
Scott Murraybcc488a2005-05-27 16:48:52 -0400170 if (controller->ops->get_power)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 power = controller->ops->get_power(slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return power;
173}
174
175static int
176get_power_status(struct hotplug_slot *hotplug_slot, u8 * value)
177{
178 struct slot *slot = hotplug_slot->private;
179
180 *value = cpci_get_power_status(slot);
181 return 0;
182}
183
184static int
185get_attention_status(struct hotplug_slot *hotplug_slot, u8 * value)
186{
187 struct slot *slot = hotplug_slot->private;
188
189 *value = cpci_get_attention_status(slot);
190 return 0;
191}
192
193static int
194set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
195{
196 return cpci_set_attention_status(hotplug_slot->private, status);
197}
198
Scott Murray43b7d7c2005-05-09 17:31:50 -0400199static int
200get_adapter_status(struct hotplug_slot *hotplug_slot, u8 * value)
201{
202 *value = hotplug_slot->info->adapter_status;
203 return 0;
204}
205
206static int
207get_latch_status(struct hotplug_slot *hotplug_slot, u8 * value)
208{
209 *value = hotplug_slot->info->latch_status;
210 return 0;
211}
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213static void release_slot(struct hotplug_slot *hotplug_slot)
214{
215 struct slot *slot = hotplug_slot->private;
216
217 kfree(slot->hotplug_slot->info);
218 kfree(slot->hotplug_slot->name);
219 kfree(slot->hotplug_slot);
220 kfree(slot);
221}
222
223#define SLOT_NAME_SIZE 6
224static void
225make_slot_name(struct slot *slot)
226{
227 snprintf(slot->hotplug_slot->name,
228 SLOT_NAME_SIZE, "%02x:%02x", slot->bus->number, slot->number);
229}
230
231int
232cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
233{
234 struct slot *slot;
235 struct hotplug_slot *hotplug_slot;
236 struct hotplug_slot_info *info;
237 char *name;
238 int status = -ENOMEM;
239 int i;
240
Scott Murraybcc488a2005-05-27 16:48:52 -0400241 if (!(controller && bus))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 /*
245 * Create a structure for each slot, and register that slot
246 * with the pci_hotplug subsystem.
247 */
248 for (i = first; i <= last; ++i) {
249 slot = kmalloc(sizeof (struct slot), GFP_KERNEL);
250 if (!slot)
251 goto error;
252 memset(slot, 0, sizeof (struct slot));
253
254 hotplug_slot =
255 kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
256 if (!hotplug_slot)
257 goto error_slot;
258 memset(hotplug_slot, 0, sizeof (struct hotplug_slot));
259 slot->hotplug_slot = hotplug_slot;
260
261 info = kmalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
262 if (!info)
263 goto error_hpslot;
264 memset(info, 0, sizeof (struct hotplug_slot_info));
265 hotplug_slot->info = info;
266
267 name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
268 if (!name)
269 goto error_info;
270 hotplug_slot->name = name;
271
272 slot->bus = bus;
273 slot->number = i;
274 slot->devfn = PCI_DEVFN(i, 0);
275
276 hotplug_slot->private = slot;
277 hotplug_slot->release = &release_slot;
278 make_slot_name(slot);
279 hotplug_slot->ops = &cpci_hotplug_slot_ops;
280
281 /*
282 * Initialize the slot info structure with some known
283 * good values.
284 */
285 dbg("initializing slot %s", slot->hotplug_slot->name);
286 info->power_status = cpci_get_power_status(slot);
287 info->attention_status = cpci_get_attention_status(slot);
288
289 dbg("registering slot %s", slot->hotplug_slot->name);
290 status = pci_hp_register(slot->hotplug_slot);
291 if (status) {
292 err("pci_hp_register failed with error %d", status);
293 goto error_name;
294 }
295
296 /* Add slot to our internal list */
Scott Murray43b7d7c2005-05-09 17:31:50 -0400297 down_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 list_add(&slot->slot_list, &slot_list);
299 slots++;
Scott Murray43b7d7c2005-05-09 17:31:50 -0400300 up_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 }
302 return 0;
303error_name:
304 kfree(name);
305error_info:
306 kfree(info);
307error_hpslot:
308 kfree(hotplug_slot);
309error_slot:
310 kfree(slot);
311error:
312 return status;
313}
314
315int
316cpci_hp_unregister_bus(struct pci_bus *bus)
317{
318 struct slot *slot;
Scott Murraybcc488a2005-05-27 16:48:52 -0400319 struct slot *tmp;
320 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
Scott Murray43b7d7c2005-05-09 17:31:50 -0400322 down_write(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400323 if (!slots) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400324 up_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return -1;
326 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400327 list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
328 if (slot->bus == bus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 list_del(&slot->slot_list);
330 slots--;
Scott Murraybcc488a2005-05-27 16:48:52 -0400331
332 dbg("deregistering slot %s", slot->hotplug_slot->name);
333 status = pci_hp_deregister(slot->hotplug_slot);
334 if (status) {
335 err("pci_hp_deregister failed with error %d",
336 status);
337 break;
338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
340 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400341 up_write(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400342 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344
345/* This is the interrupt mode interrupt handler */
346static irqreturn_t
347cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
348{
349 dbg("entered cpci_hp_intr");
350
351 /* Check to see if it was our interrupt */
Scott Murraybcc488a2005-05-27 16:48:52 -0400352 if ((controller->irq_flags & SA_SHIRQ) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 !controller->ops->check_irq(controller->dev_id)) {
354 dbg("exited cpci_hp_intr, not our interrupt");
355 return IRQ_NONE;
356 }
357
358 /* Disable ENUM interrupt */
359 controller->ops->disable_irq();
360
361 /* Trigger processing by the event thread */
362 dbg("Signal event_semaphore");
363 up(&event_semaphore);
364 dbg("exited cpci_hp_intr");
365 return IRQ_HANDLED;
366}
367
368/*
Scott Murray43b7d7c2005-05-09 17:31:50 -0400369 * According to PICMG 2.1 R2.0, section 6.3.2, upon
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 * initialization, the system driver shall clear the
371 * INS bits of the cold-inserted devices.
372 */
373static int
Scott Murraybcc488a2005-05-27 16:48:52 -0400374init_slots(int clear_ins)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
376 struct slot *slot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 struct pci_dev* dev;
378
379 dbg("%s - enter", __FUNCTION__);
Scott Murray43b7d7c2005-05-09 17:31:50 -0400380 down_read(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400381 if (!slots) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400382 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 return -1;
384 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400385 list_for_each_entry(slot, &slot_list, slot_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 dbg("%s - looking at slot %s",
387 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400388 if (clear_ins && cpci_check_and_clear_ins(slot))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 dbg("%s - cleared INS for slot %s",
390 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400391 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
392 if (dev) {
393 if (update_adapter_status(slot->hotplug_slot, 1))
394 warn("failure to update adapter file");
395 if (update_latch_status(slot->hotplug_slot, 1))
396 warn("failure to update latch file");
397 slot->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 }
399 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400400 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 dbg("%s - exit", __FUNCTION__);
402 return 0;
403}
404
405static int
406check_slots(void)
407{
408 struct slot *slot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 int extracted;
410 int inserted;
Scott Murray43b7d7c2005-05-09 17:31:50 -0400411 u16 hs_csr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Scott Murray43b7d7c2005-05-09 17:31:50 -0400413 down_read(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400414 if (!slots) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400415 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 err("no slots registered, shutting down");
417 return -1;
418 }
419 extracted = inserted = 0;
Scott Murraybcc488a2005-05-27 16:48:52 -0400420 list_for_each_entry(slot, &slot_list, slot_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 dbg("%s - looking at slot %s",
422 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400423 if (cpci_check_and_clear_ins(slot)) {
424 /*
425 * Some broken hardware (e.g. PLX 9054AB) asserts
426 * ENUM# twice...
427 */
428 if (slot->dev) {
429 warn("slot %s already inserted",
430 slot->hotplug_slot->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 inserted++;
432 continue;
433 }
434
435 /* Process insertion */
436 dbg("%s - slot %s inserted",
437 __FUNCTION__, slot->hotplug_slot->name);
438
439 /* GSM, debug */
440 hs_csr = cpci_get_hs_csr(slot);
441 dbg("%s - slot %s HS_CSR (1) = %04x",
442 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
443
444 /* Configure device */
445 dbg("%s - configuring slot %s",
446 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400447 if (cpci_configure_slot(slot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 err("%s - could not configure slot %s",
449 __FUNCTION__, slot->hotplug_slot->name);
450 continue;
451 }
452 dbg("%s - finished configuring slot %s",
453 __FUNCTION__, slot->hotplug_slot->name);
454
455 /* GSM, debug */
456 hs_csr = cpci_get_hs_csr(slot);
457 dbg("%s - slot %s HS_CSR (2) = %04x",
458 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
459
Scott Murraybcc488a2005-05-27 16:48:52 -0400460 if (update_latch_status(slot->hotplug_slot, 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 warn("failure to update latch file");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Scott Murraybcc488a2005-05-27 16:48:52 -0400463 if (update_adapter_status(slot->hotplug_slot, 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 warn("failure to update adapter file");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 cpci_led_off(slot);
467
468 /* GSM, debug */
469 hs_csr = cpci_get_hs_csr(slot);
470 dbg("%s - slot %s HS_CSR (3) = %04x",
471 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
472
473 inserted++;
Scott Murraybcc488a2005-05-27 16:48:52 -0400474 } else if (cpci_check_ext(slot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 /* Process extraction request */
476 dbg("%s - slot %s extracted",
477 __FUNCTION__, slot->hotplug_slot->name);
478
479 /* GSM, debug */
480 hs_csr = cpci_get_hs_csr(slot);
481 dbg("%s - slot %s HS_CSR = %04x",
482 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
483
Scott Murraybcc488a2005-05-27 16:48:52 -0400484 if (!slot->extracting) {
485 if (update_latch_status(slot->hotplug_slot, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 warn("failure to update latch file");
487 }
488 slot->extracting = 1;
Scott Murraybcc488a2005-05-27 16:48:52 -0400489 atomic_inc(&extracting);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 }
491 extracted++;
Scott Murraybcc488a2005-05-27 16:48:52 -0400492 } else if (slot->extracting) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400493 hs_csr = cpci_get_hs_csr(slot);
Scott Murraybcc488a2005-05-27 16:48:52 -0400494 if (hs_csr == 0xffff) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400495 /*
496 * Hmmm, we're likely hosed at this point, should we
497 * bother trying to tell the driver or not?
498 */
499 err("card in slot %s was improperly removed",
500 slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400501 if (update_adapter_status(slot->hotplug_slot, 0))
Scott Murray43b7d7c2005-05-09 17:31:50 -0400502 warn("failure to update adapter file");
Scott Murray43b7d7c2005-05-09 17:31:50 -0400503 slot->extracting = 0;
504 atomic_dec(&extracting);
505 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400508 up_read(&list_rwsem);
509 dbg("inserted=%d, extracted=%d, extracting=%d",
510 inserted, extracted, atomic_read(&extracting));
Scott Murraybcc488a2005-05-27 16:48:52 -0400511 if (inserted || extracted)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 return extracted;
Scott Murraybcc488a2005-05-27 16:48:52 -0400513 else if (!atomic_read(&extracting)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 err("cannot find ENUM# source, shutting down");
515 return -1;
516 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400517 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518}
519
520/* This is the interrupt mode worker thread body */
521static int
522event_thread(void *data)
523{
524 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 lock_kernel();
527 daemonize("cpci_hp_eventd");
528 unlock_kernel();
529
530 dbg("%s - event thread started", __FUNCTION__);
Scott Murraybcc488a2005-05-27 16:48:52 -0400531 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 dbg("event thread sleeping");
533 down_interruptible(&event_semaphore);
534 dbg("event thread woken, thread_finished = %d",
535 thread_finished);
Scott Murraybcc488a2005-05-27 16:48:52 -0400536 if (thread_finished || signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 break;
Scott Murray43b7d7c2005-05-09 17:31:50 -0400538 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 rc = check_slots();
Scott Murray43b7d7c2005-05-09 17:31:50 -0400540 if (rc > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 /* Give userspace a chance to handle extraction */
542 msleep(500);
Scott Murray43b7d7c2005-05-09 17:31:50 -0400543 } else if (rc < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 dbg("%s - error checking slots", __FUNCTION__);
545 thread_finished = 1;
546 break;
547 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400548 } while (atomic_read(&extracting) && !thread_finished);
549 if (thread_finished)
550 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 /* Re-enable ENUM# interrupt */
553 dbg("%s - re-enabling irq", __FUNCTION__);
554 controller->ops->enable_irq();
555 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 dbg("%s - event thread signals exit", __FUNCTION__);
557 up(&thread_exit);
558 return 0;
559}
560
561/* This is the polling mode worker thread body */
562static int
563poll_thread(void *data)
564{
565 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 lock_kernel();
568 daemonize("cpci_hp_polld");
569 unlock_kernel();
570
Scott Murraybcc488a2005-05-27 16:48:52 -0400571 while (1) {
572 if (thread_finished || signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 break;
Scott Murraybcc488a2005-05-27 16:48:52 -0400574 if (controller->ops->query_enum()) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400575 do {
576 rc = check_slots();
Scott Murraybcc488a2005-05-27 16:48:52 -0400577 if (rc > 0) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400578 /* Give userspace a chance to handle extraction */
579 msleep(500);
Scott Murraybcc488a2005-05-27 16:48:52 -0400580 } else if (rc < 0) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400581 dbg("%s - error checking slots", __FUNCTION__);
582 thread_finished = 1;
583 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400585 } while (atomic_read(&extracting) && !thread_finished);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 msleep(100);
588 }
589 dbg("poll thread signals exit");
590 up(&thread_exit);
591 return 0;
592}
593
594static int
595cpci_start_thread(void)
596{
597 int pid;
598
599 /* initialize our semaphores */
600 init_MUTEX_LOCKED(&event_semaphore);
601 init_MUTEX_LOCKED(&thread_exit);
602 thread_finished = 0;
603
Scott Murraybcc488a2005-05-27 16:48:52 -0400604 if (controller->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 pid = kernel_thread(event_thread, NULL, 0);
Scott Murraybcc488a2005-05-27 16:48:52 -0400606 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 pid = kernel_thread(poll_thread, NULL, 0);
Scott Murraybcc488a2005-05-27 16:48:52 -0400608 if (pid < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 err("Can't start up our thread");
610 return -1;
611 }
612 dbg("Our thread pid = %d", pid);
613 return 0;
614}
615
616static void
617cpci_stop_thread(void)
618{
619 thread_finished = 1;
620 dbg("thread finish command given");
Scott Murraybcc488a2005-05-27 16:48:52 -0400621 if (controller->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 up(&event_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 dbg("wait for thread to exit");
624 down(&thread_exit);
625}
626
627int
628cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
629{
630 int status = 0;
631
Scott Murraybcc488a2005-05-27 16:48:52 -0400632 if (controller)
633 return -1;
634 if (!(new_controller && new_controller->ops))
635 return -EINVAL;
636 if (new_controller->irq) {
637 if (!(new_controller->ops->enable_irq &&
638 new_controller->ops->disable_irq))
639 status = -EINVAL;
640 if (request_irq(new_controller->irq,
641 cpci_hp_intr,
642 new_controller->irq_flags,
643 MY_NAME,
644 new_controller->dev_id)) {
645 err("Can't get irq %d for the hotplug cPCI controller",
646 new_controller->irq);
647 status = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400649 dbg("%s - acquired controller irq %d",
650 __FUNCTION__, new_controller->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400652 if (!status)
653 controller = new_controller;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 return status;
655}
656
Scott Murraybcc488a2005-05-27 16:48:52 -0400657static void
658cleanup_slots(void)
659{
660 struct slot *slot;
661 struct slot *tmp;
662
663 /*
664 * Unregister all of our slots with the pci_hotplug subsystem,
665 * and free up all memory that we had allocated.
666 */
667 down_write(&list_rwsem);
668 if (!slots)
669 goto cleanup_null;
670 list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
671 list_del(&slot->slot_list);
672 pci_hp_deregister(slot->hotplug_slot);
673 }
674cleanup_null:
675 up_write(&list_rwsem);
676 return;
677}
678
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679int
680cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
681{
682 int status = 0;
683
Scott Murraybcc488a2005-05-27 16:48:52 -0400684 if (controller) {
685 if (!thread_finished)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 cpci_stop_thread();
Scott Murraybcc488a2005-05-27 16:48:52 -0400687 if (controller->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 free_irq(controller->irq, controller->dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 controller = NULL;
Scott Murraybcc488a2005-05-27 16:48:52 -0400690 cleanup_slots();
691 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 status = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 return status;
694}
695
696int
697cpci_hp_start(void)
698{
699 static int first = 1;
700 int status;
701
702 dbg("%s - enter", __FUNCTION__);
Scott Murraybcc488a2005-05-27 16:48:52 -0400703 if (!controller)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Scott Murray43b7d7c2005-05-09 17:31:50 -0400706 down_read(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400707 if (list_empty(&slot_list)) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400708 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 return -ENODEV;
710 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400711 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Scott Murraybcc488a2005-05-27 16:48:52 -0400713 status = init_slots(first);
714 if (first)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 first = 0;
Scott Murraybcc488a2005-05-27 16:48:52 -0400716 if (status)
717 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 status = cpci_start_thread();
Scott Murraybcc488a2005-05-27 16:48:52 -0400720 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 dbg("%s - thread started", __FUNCTION__);
723
Scott Murraybcc488a2005-05-27 16:48:52 -0400724 if (controller->irq) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 /* Start enum interrupt processing */
726 dbg("%s - enabling irq", __FUNCTION__);
727 controller->ops->enable_irq();
728 }
729 dbg("%s - exit", __FUNCTION__);
730 return 0;
731}
732
733int
734cpci_hp_stop(void)
735{
Scott Murraybcc488a2005-05-27 16:48:52 -0400736 if (!controller)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 return -ENODEV;
Scott Murraybcc488a2005-05-27 16:48:52 -0400738 if (controller->irq) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 /* Stop enum interrupt processing */
740 dbg("%s - disabling irq", __FUNCTION__);
741 controller->ops->disable_irq();
742 }
743 cpci_stop_thread();
744 return 0;
745}
746
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747int __init
748cpci_hotplug_init(int debug)
749{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 cpci_debug = debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 return 0;
752}
753
754void __exit
755cpci_hotplug_exit(void)
756{
757 /*
758 * Clean everything up.
759 */
Scott Murraybcc488a2005-05-27 16:48:52 -0400760 cpci_hp_stop();
761 cpci_hp_unregister_controller(controller);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762}
763
764EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
765EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
766EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
767EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
768EXPORT_SYMBOL_GPL(cpci_hp_start);
769EXPORT_SYMBOL_GPL(cpci_hp_stop);