blob: 30af105271a2883d559c7ec89a2f5b0efe8f3ed6 [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);
Scott Murray03e49d42005-06-06 15:48:04 -0400220 if (slot->dev)
221 pci_dev_put(slot->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 kfree(slot);
223}
224
225#define SLOT_NAME_SIZE 6
226static void
227make_slot_name(struct slot *slot)
228{
229 snprintf(slot->hotplug_slot->name,
230 SLOT_NAME_SIZE, "%02x:%02x", slot->bus->number, slot->number);
231}
232
233int
234cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
235{
236 struct slot *slot;
237 struct hotplug_slot *hotplug_slot;
238 struct hotplug_slot_info *info;
239 char *name;
240 int status = -ENOMEM;
241 int i;
242
Scott Murraybcc488a2005-05-27 16:48:52 -0400243 if (!(controller && bus))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
246 /*
247 * Create a structure for each slot, and register that slot
248 * with the pci_hotplug subsystem.
249 */
250 for (i = first; i <= last; ++i) {
251 slot = kmalloc(sizeof (struct slot), GFP_KERNEL);
252 if (!slot)
253 goto error;
254 memset(slot, 0, sizeof (struct slot));
255
256 hotplug_slot =
257 kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
258 if (!hotplug_slot)
259 goto error_slot;
260 memset(hotplug_slot, 0, sizeof (struct hotplug_slot));
261 slot->hotplug_slot = hotplug_slot;
262
263 info = kmalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
264 if (!info)
265 goto error_hpslot;
266 memset(info, 0, sizeof (struct hotplug_slot_info));
267 hotplug_slot->info = info;
268
269 name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
270 if (!name)
271 goto error_info;
272 hotplug_slot->name = name;
273
274 slot->bus = bus;
275 slot->number = i;
276 slot->devfn = PCI_DEVFN(i, 0);
277
278 hotplug_slot->private = slot;
279 hotplug_slot->release = &release_slot;
280 make_slot_name(slot);
281 hotplug_slot->ops = &cpci_hotplug_slot_ops;
282
283 /*
284 * Initialize the slot info structure with some known
285 * good values.
286 */
287 dbg("initializing slot %s", slot->hotplug_slot->name);
288 info->power_status = cpci_get_power_status(slot);
289 info->attention_status = cpci_get_attention_status(slot);
290
291 dbg("registering slot %s", slot->hotplug_slot->name);
292 status = pci_hp_register(slot->hotplug_slot);
293 if (status) {
294 err("pci_hp_register failed with error %d", status);
295 goto error_name;
296 }
297
298 /* Add slot to our internal list */
Scott Murray43b7d7c2005-05-09 17:31:50 -0400299 down_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 list_add(&slot->slot_list, &slot_list);
301 slots++;
Scott Murray43b7d7c2005-05-09 17:31:50 -0400302 up_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 }
304 return 0;
305error_name:
306 kfree(name);
307error_info:
308 kfree(info);
309error_hpslot:
310 kfree(hotplug_slot);
311error_slot:
312 kfree(slot);
313error:
314 return status;
315}
316
317int
318cpci_hp_unregister_bus(struct pci_bus *bus)
319{
320 struct slot *slot;
Scott Murraybcc488a2005-05-27 16:48:52 -0400321 struct slot *tmp;
322 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Scott Murray43b7d7c2005-05-09 17:31:50 -0400324 down_write(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400325 if (!slots) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400326 up_write(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return -1;
328 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400329 list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
330 if (slot->bus == bus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 list_del(&slot->slot_list);
332 slots--;
Scott Murraybcc488a2005-05-27 16:48:52 -0400333
334 dbg("deregistering slot %s", slot->hotplug_slot->name);
335 status = pci_hp_deregister(slot->hotplug_slot);
336 if (status) {
337 err("pci_hp_deregister failed with error %d",
338 status);
339 break;
340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 }
342 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400343 up_write(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400344 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345}
346
347/* This is the interrupt mode interrupt handler */
348static irqreturn_t
349cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
350{
351 dbg("entered cpci_hp_intr");
352
353 /* Check to see if it was our interrupt */
Scott Murraybcc488a2005-05-27 16:48:52 -0400354 if ((controller->irq_flags & SA_SHIRQ) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 !controller->ops->check_irq(controller->dev_id)) {
356 dbg("exited cpci_hp_intr, not our interrupt");
357 return IRQ_NONE;
358 }
359
360 /* Disable ENUM interrupt */
361 controller->ops->disable_irq();
362
363 /* Trigger processing by the event thread */
364 dbg("Signal event_semaphore");
365 up(&event_semaphore);
366 dbg("exited cpci_hp_intr");
367 return IRQ_HANDLED;
368}
369
370/*
Scott Murray43b7d7c2005-05-09 17:31:50 -0400371 * According to PICMG 2.1 R2.0, section 6.3.2, upon
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 * initialization, the system driver shall clear the
373 * INS bits of the cold-inserted devices.
374 */
375static int
Scott Murraybcc488a2005-05-27 16:48:52 -0400376init_slots(int clear_ins)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
378 struct slot *slot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 struct pci_dev* dev;
380
381 dbg("%s - enter", __FUNCTION__);
Scott Murray43b7d7c2005-05-09 17:31:50 -0400382 down_read(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400383 if (!slots) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400384 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 return -1;
386 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400387 list_for_each_entry(slot, &slot_list, slot_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 dbg("%s - looking at slot %s",
389 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400390 if (clear_ins && cpci_check_and_clear_ins(slot))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 dbg("%s - cleared INS for slot %s",
392 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400393 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
394 if (dev) {
395 if (update_adapter_status(slot->hotplug_slot, 1))
396 warn("failure to update adapter file");
397 if (update_latch_status(slot->hotplug_slot, 1))
398 warn("failure to update latch file");
399 slot->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 }
401 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400402 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 dbg("%s - exit", __FUNCTION__);
404 return 0;
405}
406
407static int
408check_slots(void)
409{
410 struct slot *slot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 int extracted;
412 int inserted;
Scott Murray43b7d7c2005-05-09 17:31:50 -0400413 u16 hs_csr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Scott Murray43b7d7c2005-05-09 17:31:50 -0400415 down_read(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400416 if (!slots) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400417 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 err("no slots registered, shutting down");
419 return -1;
420 }
421 extracted = inserted = 0;
Scott Murraybcc488a2005-05-27 16:48:52 -0400422 list_for_each_entry(slot, &slot_list, slot_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 dbg("%s - looking at slot %s",
424 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400425 if (cpci_check_and_clear_ins(slot)) {
426 /*
427 * Some broken hardware (e.g. PLX 9054AB) asserts
428 * ENUM# twice...
429 */
430 if (slot->dev) {
431 warn("slot %s already inserted",
432 slot->hotplug_slot->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 inserted++;
434 continue;
435 }
436
437 /* Process insertion */
438 dbg("%s - slot %s inserted",
439 __FUNCTION__, slot->hotplug_slot->name);
440
441 /* GSM, debug */
442 hs_csr = cpci_get_hs_csr(slot);
443 dbg("%s - slot %s HS_CSR (1) = %04x",
444 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
445
446 /* Configure device */
447 dbg("%s - configuring slot %s",
448 __FUNCTION__, slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400449 if (cpci_configure_slot(slot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 err("%s - could not configure slot %s",
451 __FUNCTION__, slot->hotplug_slot->name);
452 continue;
453 }
454 dbg("%s - finished configuring slot %s",
455 __FUNCTION__, slot->hotplug_slot->name);
456
457 /* GSM, debug */
458 hs_csr = cpci_get_hs_csr(slot);
459 dbg("%s - slot %s HS_CSR (2) = %04x",
460 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
461
Scott Murraybcc488a2005-05-27 16:48:52 -0400462 if (update_latch_status(slot->hotplug_slot, 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 warn("failure to update latch file");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
Scott Murraybcc488a2005-05-27 16:48:52 -0400465 if (update_adapter_status(slot->hotplug_slot, 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 warn("failure to update adapter file");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468 cpci_led_off(slot);
469
470 /* GSM, debug */
471 hs_csr = cpci_get_hs_csr(slot);
472 dbg("%s - slot %s HS_CSR (3) = %04x",
473 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
474
475 inserted++;
Scott Murraybcc488a2005-05-27 16:48:52 -0400476 } else if (cpci_check_ext(slot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /* Process extraction request */
478 dbg("%s - slot %s extracted",
479 __FUNCTION__, slot->hotplug_slot->name);
480
481 /* GSM, debug */
482 hs_csr = cpci_get_hs_csr(slot);
483 dbg("%s - slot %s HS_CSR = %04x",
484 __FUNCTION__, slot->hotplug_slot->name, hs_csr);
485
Scott Murraybcc488a2005-05-27 16:48:52 -0400486 if (!slot->extracting) {
487 if (update_latch_status(slot->hotplug_slot, 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 warn("failure to update latch file");
489 }
490 slot->extracting = 1;
Scott Murraybcc488a2005-05-27 16:48:52 -0400491 atomic_inc(&extracting);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 }
493 extracted++;
Scott Murraybcc488a2005-05-27 16:48:52 -0400494 } else if (slot->extracting) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400495 hs_csr = cpci_get_hs_csr(slot);
Scott Murraybcc488a2005-05-27 16:48:52 -0400496 if (hs_csr == 0xffff) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400497 /*
498 * Hmmm, we're likely hosed at this point, should we
499 * bother trying to tell the driver or not?
500 */
501 err("card in slot %s was improperly removed",
502 slot->hotplug_slot->name);
Scott Murraybcc488a2005-05-27 16:48:52 -0400503 if (update_adapter_status(slot->hotplug_slot, 0))
Scott Murray43b7d7c2005-05-09 17:31:50 -0400504 warn("failure to update adapter file");
Scott Murray43b7d7c2005-05-09 17:31:50 -0400505 slot->extracting = 0;
506 atomic_dec(&extracting);
507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
509 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400510 up_read(&list_rwsem);
511 dbg("inserted=%d, extracted=%d, extracting=%d",
512 inserted, extracted, atomic_read(&extracting));
Scott Murraybcc488a2005-05-27 16:48:52 -0400513 if (inserted || extracted)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 return extracted;
Scott Murraybcc488a2005-05-27 16:48:52 -0400515 else if (!atomic_read(&extracting)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 err("cannot find ENUM# source, shutting down");
517 return -1;
518 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400519 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520}
521
522/* This is the interrupt mode worker thread body */
523static int
524event_thread(void *data)
525{
526 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 lock_kernel();
529 daemonize("cpci_hp_eventd");
530 unlock_kernel();
531
532 dbg("%s - event thread started", __FUNCTION__);
Scott Murraybcc488a2005-05-27 16:48:52 -0400533 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 dbg("event thread sleeping");
535 down_interruptible(&event_semaphore);
536 dbg("event thread woken, thread_finished = %d",
537 thread_finished);
Scott Murraybcc488a2005-05-27 16:48:52 -0400538 if (thread_finished || signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 break;
Scott Murray43b7d7c2005-05-09 17:31:50 -0400540 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 rc = check_slots();
Scott Murray43b7d7c2005-05-09 17:31:50 -0400542 if (rc > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 /* Give userspace a chance to handle extraction */
544 msleep(500);
Scott Murray43b7d7c2005-05-09 17:31:50 -0400545 } else if (rc < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 dbg("%s - error checking slots", __FUNCTION__);
547 thread_finished = 1;
548 break;
549 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400550 } while (atomic_read(&extracting) && !thread_finished);
551 if (thread_finished)
552 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 /* Re-enable ENUM# interrupt */
555 dbg("%s - re-enabling irq", __FUNCTION__);
556 controller->ops->enable_irq();
557 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 dbg("%s - event thread signals exit", __FUNCTION__);
559 up(&thread_exit);
560 return 0;
561}
562
563/* This is the polling mode worker thread body */
564static int
565poll_thread(void *data)
566{
567 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 lock_kernel();
570 daemonize("cpci_hp_polld");
571 unlock_kernel();
572
Scott Murraybcc488a2005-05-27 16:48:52 -0400573 while (1) {
574 if (thread_finished || signal_pending(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 break;
Scott Murraybcc488a2005-05-27 16:48:52 -0400576 if (controller->ops->query_enum()) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400577 do {
578 rc = check_slots();
Scott Murraybcc488a2005-05-27 16:48:52 -0400579 if (rc > 0) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400580 /* Give userspace a chance to handle extraction */
581 msleep(500);
Scott Murraybcc488a2005-05-27 16:48:52 -0400582 } else if (rc < 0) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400583 dbg("%s - error checking slots", __FUNCTION__);
584 thread_finished = 1;
585 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400587 } while (atomic_read(&extracting) && !thread_finished);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 msleep(100);
590 }
591 dbg("poll thread signals exit");
592 up(&thread_exit);
593 return 0;
594}
595
596static int
597cpci_start_thread(void)
598{
599 int pid;
600
601 /* initialize our semaphores */
602 init_MUTEX_LOCKED(&event_semaphore);
603 init_MUTEX_LOCKED(&thread_exit);
604 thread_finished = 0;
605
Scott Murraybcc488a2005-05-27 16:48:52 -0400606 if (controller->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 pid = kernel_thread(event_thread, NULL, 0);
Scott Murraybcc488a2005-05-27 16:48:52 -0400608 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 pid = kernel_thread(poll_thread, NULL, 0);
Scott Murraybcc488a2005-05-27 16:48:52 -0400610 if (pid < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 err("Can't start up our thread");
612 return -1;
613 }
614 dbg("Our thread pid = %d", pid);
615 return 0;
616}
617
618static void
619cpci_stop_thread(void)
620{
621 thread_finished = 1;
622 dbg("thread finish command given");
Scott Murraybcc488a2005-05-27 16:48:52 -0400623 if (controller->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 up(&event_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 dbg("wait for thread to exit");
626 down(&thread_exit);
627}
628
629int
630cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
631{
632 int status = 0;
633
Scott Murraybcc488a2005-05-27 16:48:52 -0400634 if (controller)
635 return -1;
636 if (!(new_controller && new_controller->ops))
637 return -EINVAL;
638 if (new_controller->irq) {
639 if (!(new_controller->ops->enable_irq &&
640 new_controller->ops->disable_irq))
641 status = -EINVAL;
642 if (request_irq(new_controller->irq,
643 cpci_hp_intr,
644 new_controller->irq_flags,
645 MY_NAME,
646 new_controller->dev_id)) {
647 err("Can't get irq %d for the hotplug cPCI controller",
648 new_controller->irq);
649 status = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400651 dbg("%s - acquired controller irq %d",
652 __FUNCTION__, new_controller->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 }
Scott Murraybcc488a2005-05-27 16:48:52 -0400654 if (!status)
655 controller = new_controller;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return status;
657}
658
Scott Murraybcc488a2005-05-27 16:48:52 -0400659static void
660cleanup_slots(void)
661{
662 struct slot *slot;
663 struct slot *tmp;
664
665 /*
666 * Unregister all of our slots with the pci_hotplug subsystem,
667 * and free up all memory that we had allocated.
668 */
669 down_write(&list_rwsem);
670 if (!slots)
671 goto cleanup_null;
672 list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
673 list_del(&slot->slot_list);
674 pci_hp_deregister(slot->hotplug_slot);
675 }
676cleanup_null:
677 up_write(&list_rwsem);
678 return;
679}
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681int
682cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
683{
684 int status = 0;
685
Scott Murraybcc488a2005-05-27 16:48:52 -0400686 if (controller) {
687 if (!thread_finished)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 cpci_stop_thread();
Scott Murraybcc488a2005-05-27 16:48:52 -0400689 if (controller->irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 free_irq(controller->irq, controller->dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 controller = NULL;
Scott Murraybcc488a2005-05-27 16:48:52 -0400692 cleanup_slots();
693 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 status = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 return status;
696}
697
698int
699cpci_hp_start(void)
700{
701 static int first = 1;
702 int status;
703
704 dbg("%s - enter", __FUNCTION__);
Scott Murraybcc488a2005-05-27 16:48:52 -0400705 if (!controller)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Scott Murray43b7d7c2005-05-09 17:31:50 -0400708 down_read(&list_rwsem);
Scott Murraybcc488a2005-05-27 16:48:52 -0400709 if (list_empty(&slot_list)) {
Scott Murray43b7d7c2005-05-09 17:31:50 -0400710 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 return -ENODEV;
712 }
Scott Murray43b7d7c2005-05-09 17:31:50 -0400713 up_read(&list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Scott Murraybcc488a2005-05-27 16:48:52 -0400715 status = init_slots(first);
716 if (first)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 first = 0;
Scott Murraybcc488a2005-05-27 16:48:52 -0400718 if (status)
719 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 status = cpci_start_thread();
Scott Murraybcc488a2005-05-27 16:48:52 -0400722 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 dbg("%s - thread started", __FUNCTION__);
725
Scott Murraybcc488a2005-05-27 16:48:52 -0400726 if (controller->irq) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 /* Start enum interrupt processing */
728 dbg("%s - enabling irq", __FUNCTION__);
729 controller->ops->enable_irq();
730 }
731 dbg("%s - exit", __FUNCTION__);
732 return 0;
733}
734
735int
736cpci_hp_stop(void)
737{
Scott Murraybcc488a2005-05-27 16:48:52 -0400738 if (!controller)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return -ENODEV;
Scott Murraybcc488a2005-05-27 16:48:52 -0400740 if (controller->irq) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 /* Stop enum interrupt processing */
742 dbg("%s - disabling irq", __FUNCTION__);
743 controller->ops->disable_irq();
744 }
745 cpci_stop_thread();
746 return 0;
747}
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749int __init
750cpci_hotplug_init(int debug)
751{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 cpci_debug = debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return 0;
754}
755
756void __exit
757cpci_hotplug_exit(void)
758{
759 /*
760 * Clean everything up.
761 */
Scott Murraybcc488a2005-05-27 16:48:52 -0400762 cpci_hp_stop();
763 cpci_hp_unregister_controller(controller);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}
765
766EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
767EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
768EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
769EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
770EXPORT_SYMBOL_GPL(cpci_hp_start);
771EXPORT_SYMBOL_GPL(cpci_hp_stop);