?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Blackfin Serial Driver: macro away the IER differences between processors
[linux/fpc-iii.git] / drivers / pci / hotplug / ibmphp_core.c
blobc892daae74d6dc325a77dc9050c0f6cd8a5105c8
1 /*
2 * IBM Hot Plug Controller Driver
3 *
4 * Written By: Chuck Cole, Jyoti Shah, Tong Yu, Irene Zubarev, IBM Corporation
5 *
6 * Copyright (C) 2001,2003 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (C) 2001-2003 IBM Corp.
8 *
9 * All rights reserved.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
19 * NON INFRINGEMENT. See the GNU General Public License for more
20 * details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 * Send feedback to <gregkh@us.ibm.com>
27 *
28 */
29
30 #include <linux/init.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/pci.h>
34 #include <linux/interrupt.h>
35 #include <linux/delay.h>
36 #include <linux/wait.h>
37 #include "../pci.h"
38 #include "../../../arch/x86/pci/pci.h" /* for struct irq_routing_table */
39 #include "ibmphp.h"
40
41 #define attn_on(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNON)
42 #define attn_off(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNOFF)
43 #define attn_LED_blink(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_BLINKLED)
44 #define get_ctrl_revision(sl, rev) ibmphp_hpc_readslot (sl, READ_REVLEVEL, rev)
45 #define get_hpc_options(sl, opt) ibmphp_hpc_readslot (sl, READ_HPCOPTIONS, opt)
46
47 #define DRIVER_VERSION "0.6"
48 #define DRIVER_DESC "IBM Hot Plug PCI Controller Driver"
49
50 int ibmphp_debug;
51
52 static int debug;
53 module_param(debug, bool, S_IRUGO | S_IWUSR);
54 MODULE_PARM_DESC (debug, "Debugging mode enabled or not");
55 MODULE_LICENSE ("GPL");
56 MODULE_DESCRIPTION (DRIVER_DESC);
57
58 struct pci_bus *ibmphp_pci_bus;
59 static int max_slots;
60
61 static int irqs[16]; /* PIC mode IRQ's we're using so far (in case MPS
62 * tables don't provide default info for empty slots */
63
64 static int init_flag;
65
66 /*
67 static int get_max_adapter_speed_1 (struct hotplug_slot *, u8 *, u8);
68
69 static inline int get_max_adapter_speed (struct hotplug_slot *hs, u8 *value)
70 {
71 return get_max_adapter_speed_1 (hs, value, 1);
72 }
73 */
74 static inline int get_cur_bus_info(struct slot **sl)
75 {
76 int rc = 1;
77 struct slot * slot_cur = *sl;
78
79 debug("options = %x\n", slot_cur->ctrl->options);
80 debug("revision = %x\n", slot_cur->ctrl->revision);
81
82 if (READ_BUS_STATUS(slot_cur->ctrl))
83 rc = ibmphp_hpc_readslot(slot_cur, READ_BUSSTATUS, NULL);
84
85 if (rc)
86 return rc;
87
88 slot_cur->bus_on->current_speed = CURRENT_BUS_SPEED(slot_cur->busstatus);
89 if (READ_BUS_MODE(slot_cur->ctrl))
90 slot_cur->bus_on->current_bus_mode =
91 CURRENT_BUS_MODE(slot_cur->busstatus);
92 else
93 slot_cur->bus_on->current_bus_mode = 0xFF;
94
95 debug("busstatus = %x, bus_speed = %x, bus_mode = %x\n",
96 slot_cur->busstatus,
97 slot_cur->bus_on->current_speed,
98 slot_cur->bus_on->current_bus_mode);
99
100 *sl = slot_cur;
101 return 0;
102 }
103
104 static inline int slot_update(struct slot **sl)
105 {
106 int rc;
107 rc = ibmphp_hpc_readslot(*sl, READ_ALLSTAT, NULL);
108 if (rc)
109 return rc;
110 if (!init_flag)
111 rc = get_cur_bus_info(sl);
112 return rc;
113 }
114
115 static int __init get_max_slots (void)
116 {
117 struct slot * slot_cur;
118 struct list_head * tmp;
119 u8 slot_count = 0;
120
121 list_for_each(tmp, &ibmphp_slot_head) {
122 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
123 /* sometimes the hot-pluggable slots start with 4 (not always from 1) */
124 slot_count = max(slot_count, slot_cur->number);
125 }
126 return slot_count;
127 }
128
129 /* This routine will put the correct slot->device information per slot. It's
130 * called from initialization of the slot structures. It will also assign
131 * interrupt numbers per each slot.
132 * Parameters: struct slot
133 * Returns 0 or errors
134 */
135 int ibmphp_init_devno(struct slot **cur_slot)
136 {
137 struct irq_routing_table *rtable;
138 int len;
139 int loop;
140 int i;
141
142 rtable = pcibios_get_irq_routing_table();
143 if (!rtable) {
144 err("no BIOS routing table...\n");
145 return -ENOMEM;
146 }
147
148 len = (rtable->size - sizeof(struct irq_routing_table)) /
149 sizeof(struct irq_info);
150
151 if (!len) {
152 kfree(rtable);
153 return -1;
154 }
155 for (loop = 0; loop < len; loop++) {
156 if ((*cur_slot)->number == rtable->slots[loop].slot) {
157 if ((*cur_slot)->bus == rtable->slots[loop].bus) {
158 (*cur_slot)->device = PCI_SLOT(rtable->slots[loop].devfn);
159 for (i = 0; i < 4; i++)
160 (*cur_slot)->irq[i] = IO_APIC_get_PCI_irq_vector((int) (*cur_slot)->bus,
161 (int) (*cur_slot)->device, i);
162
163 debug("(*cur_slot)->irq[0] = %x\n",
164 (*cur_slot)->irq[0]);
165 debug("(*cur_slot)->irq[1] = %x\n",
166 (*cur_slot)->irq[1]);
167 debug("(*cur_slot)->irq[2] = %x\n",
168 (*cur_slot)->irq[2]);
169 debug("(*cur_slot)->irq[3] = %x\n",
170 (*cur_slot)->irq[3]);
171
172 debug("rtable->exlusive_irqs = %x\n",
173 rtable->exclusive_irqs);
174 debug("rtable->slots[loop].irq[0].bitmap = %x\n",
175 rtable->slots[loop].irq[0].bitmap);
176 debug("rtable->slots[loop].irq[1].bitmap = %x\n",
177 rtable->slots[loop].irq[1].bitmap);
178 debug("rtable->slots[loop].irq[2].bitmap = %x\n",
179 rtable->slots[loop].irq[2].bitmap);
180 debug("rtable->slots[loop].irq[3].bitmap = %x\n",
181 rtable->slots[loop].irq[3].bitmap);
182
183 debug("rtable->slots[loop].irq[0].link = %x\n",
184 rtable->slots[loop].irq[0].link);
185 debug("rtable->slots[loop].irq[1].link = %x\n",
186 rtable->slots[loop].irq[1].link);
187 debug("rtable->slots[loop].irq[2].link = %x\n",
188 rtable->slots[loop].irq[2].link);
189 debug("rtable->slots[loop].irq[3].link = %x\n",
190 rtable->slots[loop].irq[3].link);
191 debug("end of init_devno\n");
192 kfree(rtable);
193 return 0;
194 }
195 }
196 }
197
198 kfree(rtable);
199 return -1;
200 }
201
202 static inline int power_on(struct slot *slot_cur)
203 {
204 u8 cmd = HPC_SLOT_ON;
205 int retval;
206
207 retval = ibmphp_hpc_writeslot(slot_cur, cmd);
208 if (retval) {
209 err("power on failed\n");
210 return retval;
211 }
212 if (CTLR_RESULT(slot_cur->ctrl->status)) {
213 err("command not completed successfully in power_on\n");
214 return -EIO;
215 }
216 msleep(3000); /* For ServeRAID cards, and some 66 PCI */
217 return 0;
218 }
219
220 static inline int power_off(struct slot *slot_cur)
221 {
222 u8 cmd = HPC_SLOT_OFF;
223 int retval;
224
225 retval = ibmphp_hpc_writeslot(slot_cur, cmd);
226 if (retval) {
227 err("power off failed\n");
228 return retval;
229 }
230 if (CTLR_RESULT(slot_cur->ctrl->status)) {
231 err("command not completed successfully in power_off\n");
232 retval = -EIO;
233 }
234 return retval;
235 }
236
237 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 value)
238 {
239 int rc = 0;
240 struct slot *pslot;
241 u8 cmd = 0x00; /* avoid compiler warning */
242
243 debug("set_attention_status - Entry hotplug_slot[%lx] value[%x]\n",
244 (ulong) hotplug_slot, value);
245 ibmphp_lock_operations();
246
247
248 if (hotplug_slot) {
249 switch (value) {
250 case HPC_SLOT_ATTN_OFF:
251 cmd = HPC_SLOT_ATTNOFF;
252 break;
253 case HPC_SLOT_ATTN_ON:
254 cmd = HPC_SLOT_ATTNON;
255 break;
256 case HPC_SLOT_ATTN_BLINK:
257 cmd = HPC_SLOT_BLINKLED;
258 break;
259 default:
260 rc = -ENODEV;
261 err("set_attention_status - Error : invalid input [%x]\n",
262 value);
263 break;
264 }
265 if (rc == 0) {
266 pslot = hotplug_slot->private;
267 if (pslot)
268 rc = ibmphp_hpc_writeslot(pslot, cmd);
269 else
270 rc = -ENODEV;
271 }
272 } else
273 rc = -ENODEV;
274
275 ibmphp_unlock_operations();
276
277 debug("set_attention_status - Exit rc[%d]\n", rc);
278 return rc;
279 }
280
281 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 * value)
282 {
283 int rc = -ENODEV;
284 struct slot *pslot;
285 struct slot myslot;
286
287 debug("get_attention_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
288 (ulong) hotplug_slot, (ulong) value);
289
290 ibmphp_lock_operations();
291 if (hotplug_slot) {
292 pslot = hotplug_slot->private;
293 if (pslot) {
294 memcpy(&myslot, pslot, sizeof(struct slot));
295 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
296 &(myslot.status));
297 if (!rc)
298 rc = ibmphp_hpc_readslot(pslot,
299 READ_EXTSLOTSTATUS,
300 &(myslot.ext_status));
301 if (!rc)
302 *value = SLOT_ATTN(myslot.status,
303 myslot.ext_status);
304 }
305 }
306
307 ibmphp_unlock_operations();
308 debug("get_attention_status - Exit rc[%d] value[%x]\n", rc, *value);
309 return rc;
310 }
311
312 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 * value)
313 {
314 int rc = -ENODEV;
315 struct slot *pslot;
316 struct slot myslot;
317
318 debug("get_latch_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
319 (ulong) hotplug_slot, (ulong) value);
320 ibmphp_lock_operations();
321 if (hotplug_slot) {
322 pslot = hotplug_slot->private;
323 if (pslot) {
324 memcpy(&myslot, pslot, sizeof(struct slot));
325 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
326 &(myslot.status));
327 if (!rc)
328 *value = SLOT_LATCH(myslot.status);
329 }
330 }
331
332 ibmphp_unlock_operations();
333 debug("get_latch_status - Exit rc[%d] rc[%x] value[%x]\n",
334 rc, rc, *value);
335 return rc;
336 }
337
338
339 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 * value)
340 {
341 int rc = -ENODEV;
342 struct slot *pslot;
343 struct slot myslot;
344
345 debug("get_power_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
346 (ulong) hotplug_slot, (ulong) value);
347 ibmphp_lock_operations();
348 if (hotplug_slot) {
349 pslot = hotplug_slot->private;
350 if (pslot) {
351 memcpy(&myslot, pslot, sizeof(struct slot));
352 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
353 &(myslot.status));
354 if (!rc)
355 *value = SLOT_PWRGD(myslot.status);
356 }
357 }
358
359 ibmphp_unlock_operations();
360 debug("get_power_status - Exit rc[%d] rc[%x] value[%x]\n",
361 rc, rc, *value);
362 return rc;
363 }
364
365 static int get_adapter_present(struct hotplug_slot *hotplug_slot, u8 * value)
366 {
367 int rc = -ENODEV;
368 struct slot *pslot;
369 u8 present;
370 struct slot myslot;
371
372 debug("get_adapter_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
373 (ulong) hotplug_slot, (ulong) value);
374 ibmphp_lock_operations();
375 if (hotplug_slot) {
376 pslot = hotplug_slot->private;
377 if (pslot) {
378 memcpy(&myslot, pslot, sizeof(struct slot));
379 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
380 &(myslot.status));
381 if (!rc) {
382 present = SLOT_PRESENT(myslot.status);
383 if (present == HPC_SLOT_EMPTY)
384 *value = 0;
385 else
386 *value = 1;
387 }
388 }
389 }
390
391 ibmphp_unlock_operations();
392 debug("get_adapter_present - Exit rc[%d] value[%x]\n", rc, *value);
393 return rc;
394 }
395
396 static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
397 {
398 int rc = -ENODEV;
399 struct slot *pslot;
400 u8 mode = 0;
401
402 debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __func__,
403 hotplug_slot, value);
404
405 ibmphp_lock_operations();
406
407 if (hotplug_slot) {
408 pslot = hotplug_slot->private;
409 if (pslot) {
410 rc = 0;
411 mode = pslot->supported_bus_mode;
412 *value = pslot->supported_speed;
413 switch (*value) {
414 case BUS_SPEED_33:
415 break;
416 case BUS_SPEED_66:
417 if (mode == BUS_MODE_PCIX)
418 *value += 0x01;
419 break;
420 case BUS_SPEED_100:
421 case BUS_SPEED_133:
422 *value = pslot->supported_speed + 0x01;
423 break;
424 default:
425 /* Note (will need to change): there would be soon 256, 512 also */
426 rc = -ENODEV;
427 }
428 }
429 }
430
431 ibmphp_unlock_operations();
432 debug("%s - Exit rc[%d] value[%x]\n", __func__, rc, *value);
433 return rc;
434 }
435
436 static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
437 {
438 int rc = -ENODEV;
439 struct slot *pslot;
440 u8 mode = 0;
441
442 debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __func__,
443 hotplug_slot, value);
444
445 ibmphp_lock_operations();
446
447 if (hotplug_slot) {
448 pslot = hotplug_slot->private;
449 if (pslot) {
450 rc = get_cur_bus_info(&pslot);
451 if (!rc) {
452 mode = pslot->bus_on->current_bus_mode;
453 *value = pslot->bus_on->current_speed;
454 switch (*value) {
455 case BUS_SPEED_33:
456 break;
457 case BUS_SPEED_66:
458 if (mode == BUS_MODE_PCIX)
459 *value += 0x01;
460 else if (mode == BUS_MODE_PCI)
461 ;
462 else
463 *value = PCI_SPEED_UNKNOWN;
464 break;
465 case BUS_SPEED_100:
466 case BUS_SPEED_133:
467 *value += 0x01;
468 break;
469 default:
470 /* Note of change: there would also be 256, 512 soon */
471 rc = -ENODEV;
472 }
473 }
474 }
475 }
476
477 ibmphp_unlock_operations();
478 debug("%s - Exit rc[%d] value[%x]\n", __func__, rc, *value);
479 return rc;
480 }
481
482 /*
483 static int get_max_adapter_speed_1(struct hotplug_slot *hotplug_slot, u8 * value, u8 flag)
484 {
485 int rc = -ENODEV;
486 struct slot *pslot;
487 struct slot myslot;
488
489 debug("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n",
490 (ulong)hotplug_slot, (ulong) value);
491
492 if (flag)
493 ibmphp_lock_operations();
494
495 if (hotplug_slot && value) {
496 pslot = hotplug_slot->private;
497 if (pslot) {
498 memcpy(&myslot, pslot, sizeof(struct slot));
499 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
500 &(myslot.status));
501
502 if (!(SLOT_LATCH (myslot.status)) &&
503 (SLOT_PRESENT (myslot.status))) {
504 rc = ibmphp_hpc_readslot(pslot,
505 READ_EXTSLOTSTATUS,
506 &(myslot.ext_status));
507 if (!rc)
508 *value = SLOT_SPEED(myslot.ext_status);
509 } else
510 *value = MAX_ADAPTER_NONE;
511 }
512 }
513
514 if (flag)
515 ibmphp_unlock_operations();
516
517 debug("get_max_adapter_speed_1 - Exit rc[%d] value[%x]\n", rc, *value);
518 return rc;
519 }
520
521 static int get_bus_name(struct hotplug_slot *hotplug_slot, char * value)
522 {
523 int rc = -ENODEV;
524 struct slot *pslot = NULL;
525
526 debug("get_bus_name - Entry hotplug_slot[%lx]\n", (ulong)hotplug_slot);
527
528 ibmphp_lock_operations();
529
530 if (hotplug_slot) {
531 pslot = hotplug_slot->private;
532 if (pslot) {
533 rc = 0;
534 snprintf(value, 100, "Bus %x", pslot->bus);
535 }
536 } else
537 rc = -ENODEV;
538
539 ibmphp_unlock_operations();
540 debug("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value);
541 return rc;
542 }
543 */
544
545 /****************************************************************************
546 * This routine will initialize the ops data structure used in the validate
547 * function. It will also power off empty slots that are powered on since BIOS
548 * leaves those on, albeit disconnected
549 ****************************************************************************/
550 static int __init init_ops(void)
551 {
552 struct slot *slot_cur;
553 struct list_head *tmp;
554 int retval;
555 int rc;
556
557 list_for_each(tmp, &ibmphp_slot_head) {
558 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
559
560 if (!slot_cur)
561 return -ENODEV;
562
563 debug("BEFORE GETTING SLOT STATUS, slot # %x\n",
564 slot_cur->number);
565 if (slot_cur->ctrl->revision == 0xFF)
566 if (get_ctrl_revision(slot_cur,
567 &slot_cur->ctrl->revision))
568 return -1;
569
570 if (slot_cur->bus_on->current_speed == 0xFF)
571 if (get_cur_bus_info(&slot_cur))
572 return -1;
573
574 if (slot_cur->ctrl->options == 0xFF)
575 if (get_hpc_options(slot_cur, &slot_cur->ctrl->options))
576 return -1;
577
578 retval = slot_update(&slot_cur);
579 if (retval)
580 return retval;
581
582 debug("status = %x\n", slot_cur->status);
583 debug("ext_status = %x\n", slot_cur->ext_status);
584 debug("SLOT_POWER = %x\n", SLOT_POWER(slot_cur->status));
585 debug("SLOT_PRESENT = %x\n", SLOT_PRESENT(slot_cur->status));
586 debug("SLOT_LATCH = %x\n", SLOT_LATCH(slot_cur->status));
587
588 if ((SLOT_PWRGD(slot_cur->status)) &&
589 !(SLOT_PRESENT(slot_cur->status)) &&
590 !(SLOT_LATCH(slot_cur->status))) {
591 debug("BEFORE POWER OFF COMMAND\n");
592 rc = power_off(slot_cur);
593 if (rc)
594 return rc;
595
596 /* retval = slot_update(&slot_cur);
597 * if (retval)
598 * return retval;
599 * ibmphp_update_slot_info(slot_cur);
600 */
601 }
602 }
603 init_flag = 0;
604 return 0;
605 }
606
607 /* This operation will check whether the slot is within the bounds and
608 * the operation is valid to perform on that slot
609 * Parameters: slot, operation
610 * Returns: 0 or error codes
611 */
612 static int validate(struct slot *slot_cur, int opn)
613 {
614 int number;
615 int retval;
616
617 if (!slot_cur)
618 return -ENODEV;
619 number = slot_cur->number;
620 if ((number > max_slots) || (number < 0))
621 return -EBADSLT;
622 debug("slot_number in validate is %d\n", slot_cur->number);
623
624 retval = slot_update(&slot_cur);
625 if (retval)
626 return retval;
627
628 switch (opn) {
629 case ENABLE:
630 if (!(SLOT_PWRGD(slot_cur->status)) &&
631 (SLOT_PRESENT(slot_cur->status)) &&
632 !(SLOT_LATCH(slot_cur->status)))
633 return 0;
634 break;
635 case DISABLE:
636 if ((SLOT_PWRGD(slot_cur->status)) &&
637 (SLOT_PRESENT(slot_cur->status)) &&
638 !(SLOT_LATCH(slot_cur->status)))
639 return 0;
640 break;
641 default:
642 break;
643 }
644 err("validate failed....\n");
645 return -EINVAL;
646 }
647
648 /****************************************************************************
649 * This routine is for updating the data structures in the hotplug core
650 * Parameters: struct slot
651 * Returns: 0 or error
652 ****************************************************************************/
653 int ibmphp_update_slot_info(struct slot *slot_cur)
654 {
655 struct hotplug_slot_info *info;
656 int rc;
657 u8 bus_speed;
658 u8 mode;
659
660 info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
661 if (!info) {
662 err("out of system memory\n");
663 return -ENOMEM;
664 }
665
666 info->power_status = SLOT_PWRGD(slot_cur->status);
667 info->attention_status = SLOT_ATTN(slot_cur->status,
668 slot_cur->ext_status);
669 info->latch_status = SLOT_LATCH(slot_cur->status);
670 if (!SLOT_PRESENT(slot_cur->status)) {
671 info->adapter_status = 0;
672 /* info->max_adapter_speed_status = MAX_ADAPTER_NONE; */
673 } else {
674 info->adapter_status = 1;
675 /* get_max_adapter_speed_1(slot_cur->hotplug_slot,
676 &info->max_adapter_speed_status, 0); */
677 }
678
679 bus_speed = slot_cur->bus_on->current_speed;
680 mode = slot_cur->bus_on->current_bus_mode;
681
682 switch (bus_speed) {
683 case BUS_SPEED_33:
684 break;
685 case BUS_SPEED_66:
686 if (mode == BUS_MODE_PCIX)
687 bus_speed += 0x01;
688 else if (mode == BUS_MODE_PCI)
689 ;
690 else
691 bus_speed = PCI_SPEED_UNKNOWN;
692 break;
693 case BUS_SPEED_100:
694 case BUS_SPEED_133:
695 bus_speed += 0x01;
696 break;
697 default:
698 bus_speed = PCI_SPEED_UNKNOWN;
699 }
700
701 info->cur_bus_speed = bus_speed;
702 info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed;
703 // To do: bus_names
704
705 rc = pci_hp_change_slot_info(slot_cur->hotplug_slot, info);
706 kfree(info);
707 return rc;
708 }
709
710
711 /******************************************************************************
712 * This function will return the pci_func, given bus and devfunc, or NULL. It
713 * is called from visit routines
714 ******************************************************************************/
715
716 static struct pci_func *ibm_slot_find(u8 busno, u8 device, u8 function)
717 {
718 struct pci_func *func_cur;
719 struct slot *slot_cur;
720 struct list_head * tmp;
721 list_for_each(tmp, &ibmphp_slot_head) {
722 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
723 if (slot_cur->func) {
724 func_cur = slot_cur->func;
725 while (func_cur) {
726 if ((func_cur->busno == busno) &&
727 (func_cur->device == device) &&
728 (func_cur->function == function))
729 return func_cur;
730 func_cur = func_cur->next;
731 }
732 }
733 }
734 return NULL;
735 }
736
737 /*************************************************************
738 * This routine frees up memory used by struct slot, including
739 * the pointers to pci_func, bus, hotplug_slot, controller,
740 * and deregistering from the hotplug core
741 *************************************************************/
742 static void free_slots(void)
743 {
744 struct slot *slot_cur;
745 struct list_head * tmp;
746 struct list_head * next;
747
748 debug("%s -- enter\n", __func__);
749
750 list_for_each_safe(tmp, next, &ibmphp_slot_head) {
751 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
752 pci_hp_deregister(slot_cur->hotplug_slot);
753 }
754 debug("%s -- exit\n", __func__);
755 }
756
757 static void ibm_unconfigure_device(struct pci_func *func)
758 {
759 struct pci_dev *temp;
760 u8 j;
761
762 debug("inside %s\n", __func__);
763 debug("func->device = %x, func->function = %x\n",
764 func->device, func->function);
765 debug("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0);
766
767 for (j = 0; j < 0x08; j++) {
768 temp = pci_get_bus_and_slot(func->busno, (func->device << 3) | j);
769 if (temp) {
770 pci_remove_bus_device(temp);
771 pci_dev_put(temp);
772 }
773 }
774 pci_dev_put(func->dev);
775 }
776
777 /*
778 * The following function is to fix kernel bug regarding
779 * getting bus entries, here we manually add those primary
780 * bus entries to kernel bus structure whenever apply
781 */
782 static u8 bus_structure_fixup(u8 busno)
783 {
784 struct pci_bus *bus;
785 struct pci_dev *dev;
786 u16 l;
787
788 if (pci_find_bus(0, busno) || !(ibmphp_find_same_bus_num(busno)))
789 return 1;
790
791 bus = kmalloc(sizeof(*bus), GFP_KERNEL);
792 if (!bus) {
793 err("%s - out of memory\n", __func__);
794 return 1;
795 }
796 dev = kmalloc(sizeof(*dev), GFP_KERNEL);
797 if (!dev) {
798 kfree(bus);
799 err("%s - out of memory\n", __func__);
800 return 1;
801 }
802
803 bus->number = busno;
804 bus->ops = ibmphp_pci_bus->ops;
805 dev->bus = bus;
806 for (dev->devfn = 0; dev->devfn < 256; dev->devfn += 8) {
807 if (!pci_read_config_word(dev, PCI_VENDOR_ID, &l) &&
808 (l != 0x0000) && (l != 0xffff)) {
809 debug("%s - Inside bus_struture_fixup()\n",
810 __func__);
811 pci_scan_bus(busno, ibmphp_pci_bus->ops, NULL);
812 break;
813 }
814 }
815
816 kfree(dev);
817 kfree(bus);
818
819 return 0;
820 }
821
822 static int ibm_configure_device(struct pci_func *func)
823 {
824 unsigned char bus;
825 struct pci_bus *child;
826 int num;
827 int flag = 0; /* this is to make sure we don't double scan the bus,
828 for bridged devices primarily */
829
830 if (!(bus_structure_fixup(func->busno)))
831 flag = 1;
832 if (func->dev == NULL)
833 func->dev = pci_get_bus_and_slot(func->busno,
834 PCI_DEVFN(func->device, func->function));
835
836 if (func->dev == NULL) {
837 struct pci_bus *bus = pci_find_bus(0, func->busno);
838 if (!bus)
839 return 0;
840
841 num = pci_scan_slot(bus,
842 PCI_DEVFN(func->device, func->function));
843 if (num)
844 pci_bus_add_devices(bus);
845
846 func->dev = pci_get_bus_and_slot(func->busno,
847 PCI_DEVFN(func->device, func->function));
848 if (func->dev == NULL) {
849 err("ERROR... : pci_dev still NULL\n");
850 return 0;
851 }
852 }
853 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) {
854 pci_read_config_byte(func->dev, PCI_SECONDARY_BUS, &bus);
855 child = pci_add_new_bus(func->dev->bus, func->dev, bus);
856 pci_do_scan_bus(child);
857 }
858
859 return 0;
860 }
861
862 /*******************************************************
863 * Returns whether the bus is empty or not
864 *******************************************************/
865 static int is_bus_empty(struct slot * slot_cur)
866 {
867 int rc;
868 struct slot * tmp_slot;
869 u8 i = slot_cur->bus_on->slot_min;
870
871 while (i <= slot_cur->bus_on->slot_max) {
872 if (i == slot_cur->number) {
873 i++;
874 continue;
875 }
876 tmp_slot = ibmphp_get_slot_from_physical_num(i);
877 if (!tmp_slot)
878 return 0;
879 rc = slot_update(&tmp_slot);
880 if (rc)
881 return 0;
882 if (SLOT_PRESENT(tmp_slot->status) &&
883 SLOT_PWRGD(tmp_slot->status))
884 return 0;
885 i++;
886 }
887 return 1;
888 }
889
890 /***********************************************************
891 * If the HPC permits and the bus currently empty, tries to set the
892 * bus speed and mode at the maximum card and bus capability
893 * Parameters: slot
894 * Returns: bus is set (0) or error code
895 ***********************************************************/
896 static int set_bus(struct slot * slot_cur)
897 {
898 int rc;
899 u8 speed;
900 u8 cmd = 0x0;
901 int retval;
902 static struct pci_device_id ciobx[] = {
903 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 0x0101) },
904 { },
905 };
906
907 debug("%s - entry slot # %d\n", __func__, slot_cur->number);
908 if (SET_BUS_STATUS(slot_cur->ctrl) && is_bus_empty(slot_cur)) {
909 rc = slot_update(&slot_cur);
910 if (rc)
911 return rc;
912 speed = SLOT_SPEED(slot_cur->ext_status);
913 debug("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
914 switch (speed) {
915 case HPC_SLOT_SPEED_33:
916 cmd = HPC_BUS_33CONVMODE;
917 break;
918 case HPC_SLOT_SPEED_66:
919 if (SLOT_PCIX(slot_cur->ext_status)) {
920 if ((slot_cur->supported_speed >= BUS_SPEED_66) &&
921 (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
922 cmd = HPC_BUS_66PCIXMODE;
923 else if (!SLOT_BUS_MODE(slot_cur->ext_status))
924 /* if max slot/bus capability is 66 pci
925 and there's no bus mode mismatch, then
926 the adapter supports 66 pci */
927 cmd = HPC_BUS_66CONVMODE;
928 else
929 cmd = HPC_BUS_33CONVMODE;
930 } else {
931 if (slot_cur->supported_speed >= BUS_SPEED_66)
932 cmd = HPC_BUS_66CONVMODE;
933 else
934 cmd = HPC_BUS_33CONVMODE;
935 }
936 break;
937 case HPC_SLOT_SPEED_133:
938 switch (slot_cur->supported_speed) {
939 case BUS_SPEED_33:
940 cmd = HPC_BUS_33CONVMODE;
941 break;
942 case BUS_SPEED_66:
943 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
944 cmd = HPC_BUS_66PCIXMODE;
945 else
946 cmd = HPC_BUS_66CONVMODE;
947 break;
948 case BUS_SPEED_100:
949 cmd = HPC_BUS_100PCIXMODE;
950 break;
951 case BUS_SPEED_133:
952 /* This is to take care of the bug in CIOBX chip */
953 if (pci_dev_present(ciobx))
954 ibmphp_hpc_writeslot(slot_cur,
955 HPC_BUS_100PCIXMODE);
956 cmd = HPC_BUS_133PCIXMODE;
957 break;
958 default:
959 err("Wrong bus speed\n");
960 return -ENODEV;
961 }
962 break;
963 default:
964 err("wrong slot speed\n");
965 return -ENODEV;
966 }
967 debug("setting bus speed for slot %d, cmd %x\n",
968 slot_cur->number, cmd);
969 retval = ibmphp_hpc_writeslot(slot_cur, cmd);
970 if (retval) {
971 err("setting bus speed failed\n");
972 return retval;
973 }
974 if (CTLR_RESULT(slot_cur->ctrl->status)) {
975 err("command not completed successfully in set_bus\n");
976 return -EIO;
977 }
978 }
979 /* This is for x440, once Brandon fixes the firmware,
980 will not need this delay */
981 msleep(1000);
982 debug("%s -Exit\n", __func__);
983 return 0;
984 }
985
986 /* This routine checks the bus limitations that the slot is on from the BIOS.
987 * This is used in deciding whether or not to power up the slot.
988 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
989 * same bus)
990 * Parameters: slot
991 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
992 */
993 static int check_limitations(struct slot *slot_cur)
994 {
995 u8 i;
996 struct slot * tmp_slot;
997 u8 count = 0;
998 u8 limitation = 0;
999
1000 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
1001 tmp_slot = ibmphp_get_slot_from_physical_num(i);
1002 if (!tmp_slot)
1003 return -ENODEV;
1004 if ((SLOT_PWRGD(tmp_slot->status)) &&
1005 !(SLOT_CONNECT(tmp_slot->status)))
1006 count++;
1007 }
1008 get_cur_bus_info(&slot_cur);
1009 switch (slot_cur->bus_on->current_speed) {
1010 case BUS_SPEED_33:
1011 limitation = slot_cur->bus_on->slots_at_33_conv;
1012 break;
1013 case BUS_SPEED_66:
1014 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
1015 limitation = slot_cur->bus_on->slots_at_66_pcix;
1016 else
1017 limitation = slot_cur->bus_on->slots_at_66_conv;
1018 break;
1019 case BUS_SPEED_100:
1020 limitation = slot_cur->bus_on->slots_at_100_pcix;
1021 break;
1022 case BUS_SPEED_133:
1023 limitation = slot_cur->bus_on->slots_at_133_pcix;
1024 break;
1025 }
1026
1027 if ((count + 1) > limitation)
1028 return -EINVAL;
1029 return 0;
1030 }
1031
1032 static inline void print_card_capability(struct slot *slot_cur)
1033 {
1034 info("capability of the card is ");
1035 if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
1036 info(" 133 MHz PCI-X\n");
1037 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
1038 info(" 66 MHz PCI-X\n");
1039 else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
1040 info(" 66 MHz PCI\n");
1041 else
1042 info(" 33 MHz PCI\n");
1043
1044 }
1045
1046 /* This routine will power on the slot, configure the device(s) and find the
1047 * drivers for them.
1048 * Parameters: hotplug_slot
1049 * Returns: 0 or failure codes
1050 */
1051 static int enable_slot(struct hotplug_slot *hs)
1052 {
1053 int rc, i, rcpr;
1054 struct slot *slot_cur;
1055 u8 function;
1056 struct pci_func *tmp_func;
1057
1058 ibmphp_lock_operations();
1059
1060 debug("ENABLING SLOT........\n");
1061 slot_cur = hs->private;
1062
1063 if ((rc = validate(slot_cur, ENABLE))) {
1064 err("validate function failed\n");
1065 goto error_nopower;
1066 }
1067
1068 attn_LED_blink(slot_cur);
1069
1070 rc = set_bus(slot_cur);
1071 if (rc) {
1072 err("was not able to set the bus\n");
1073 goto error_nopower;
1074 }
1075
1076 /*-----------------debugging------------------------------*/
1077 get_cur_bus_info(&slot_cur);
1078 debug("the current bus speed right after set_bus = %x\n",
1079 slot_cur->bus_on->current_speed);
1080 /*----------------------------------------------------------*/
1081
1082 rc = check_limitations(slot_cur);
1083 if (rc) {
1084 err("Adding this card exceeds the limitations of this bus.\n");
1085 err("(i.e., >1 133MHz cards running on same bus, or "
1086 ">2 66 PCI cards running on same bus.\n");
1087 err("Try hot-adding into another bus\n");
1088 rc = -EINVAL;
1089 goto error_nopower;
1090 }
1091
1092 rc = power_on(slot_cur);
1093
1094 if (rc) {
1095 err("something wrong when powering up... please see below for details\n");
1096 /* need to turn off before on, otherwise, blinking overwrites */
1097 attn_off(slot_cur);
1098 attn_on(slot_cur);
1099 if (slot_update(&slot_cur)) {
1100 attn_off(slot_cur);
1101 attn_on(slot_cur);
1102 rc = -ENODEV;
1103 goto exit;
1104 }
1105 /* Check to see the error of why it failed */
1106 if ((SLOT_POWER(slot_cur->status)) &&
1107 !(SLOT_PWRGD(slot_cur->status)))
1108 err("power fault occurred trying to power up\n");
1109 else if (SLOT_BUS_SPEED(slot_cur->status)) {
1110 err("bus speed mismatch occurred. please check "
1111 "current bus speed and card capability\n");
1112 print_card_capability(slot_cur);
1113 } else if (SLOT_BUS_MODE(slot_cur->ext_status)) {
1114 err("bus mode mismatch occurred. please check "
1115 "current bus mode and card capability\n");
1116 print_card_capability(slot_cur);
1117 }
1118 ibmphp_update_slot_info(slot_cur);
1119 goto exit;
1120 }
1121 debug("after power_on\n");
1122 /*-----------------------debugging---------------------------*/
1123 get_cur_bus_info(&slot_cur);
1124 debug("the current bus speed right after power_on = %x\n",
1125 slot_cur->bus_on->current_speed);
1126 /*----------------------------------------------------------*/
1127
1128 rc = slot_update(&slot_cur);
1129 if (rc)
1130 goto error_power;
1131
1132 rc = -EINVAL;
1133 if (SLOT_POWER(slot_cur->status) && !(SLOT_PWRGD(slot_cur->status))) {
1134 err("power fault occurred trying to power up...\n");
1135 goto error_power;
1136 }
1137 if (SLOT_POWER(slot_cur->status) && (SLOT_BUS_SPEED(slot_cur->status))) {
1138 err("bus speed mismatch occurred. please check current bus "
1139 "speed and card capability\n");
1140 print_card_capability(slot_cur);
1141 goto error_power;
1142 }
1143 /* Don't think this case will happen after above checks...
1144 * but just in case, for paranoia sake */
1145 if (!(SLOT_POWER(slot_cur->status))) {
1146 err("power on failed...\n");
1147 goto error_power;
1148 }
1149
1150 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
1151 if (!slot_cur->func) {
1152 /* We cannot do update_slot_info here, since no memory for
1153 * kmalloc n.e.ways, and update_slot_info allocates some */
1154 err("out of system memory\n");
1155 rc = -ENOMEM;
1156 goto error_power;
1157 }
1158 slot_cur->func->busno = slot_cur->bus;
1159 slot_cur->func->device = slot_cur->device;
1160 for (i = 0; i < 4; i++)
1161 slot_cur->func->irq[i] = slot_cur->irq[i];
1162
1163 debug("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n",
1164 slot_cur->bus, slot_cur->device);
1165
1166 if (ibmphp_configure_card(slot_cur->func, slot_cur->number)) {
1167 err("configure_card was unsuccessful...\n");
1168 /* true because don't need to actually deallocate resources,
1169 * just remove references */
1170 ibmphp_unconfigure_card(&slot_cur, 1);
1171 debug("after unconfigure_card\n");
1172 slot_cur->func = NULL;
1173 rc = -ENOMEM;
1174 goto error_power;
1175 }
1176
1177 function = 0x00;
1178 do {
1179 tmp_func = ibm_slot_find(slot_cur->bus, slot_cur->func->device,
1180 function++);
1181 if (tmp_func && !(tmp_func->dev))
1182 ibm_configure_device(tmp_func);
1183 } while (tmp_func);
1184
1185 attn_off(slot_cur);
1186 if (slot_update(&slot_cur)) {
1187 rc = -EFAULT;
1188 goto exit;
1189 }
1190 ibmphp_print_test();
1191 rc = ibmphp_update_slot_info(slot_cur);
1192 exit:
1193 ibmphp_unlock_operations();
1194 return rc;
1195
1196 error_nopower:
1197 attn_off(slot_cur); /* need to turn off if was blinking b4 */
1198 attn_on(slot_cur);
1199 error_cont:
1200 rcpr = slot_update(&slot_cur);
1201 if (rcpr) {
1202 rc = rcpr;
1203 goto exit;
1204 }
1205 ibmphp_update_slot_info(slot_cur);
1206 goto exit;
1207
1208 error_power:
1209 attn_off(slot_cur); /* need to turn off if was blinking b4 */
1210 attn_on(slot_cur);
1211 rcpr = power_off(slot_cur);
1212 if (rcpr) {
1213 rc = rcpr;
1214 goto exit;
1215 }
1216 goto error_cont;
1217 }
1218
1219 /**************************************************************
1220 * HOT REMOVING ADAPTER CARD *
1221 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE *
1222 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE *
1223 DISABLE POWER , *
1224 **************************************************************/
1225 static int ibmphp_disable_slot(struct hotplug_slot *hotplug_slot)
1226 {
1227 struct slot *slot = hotplug_slot->private;
1228 int rc;
1229
1230 ibmphp_lock_operations();
1231 rc = ibmphp_do_disable_slot(slot);
1232 ibmphp_unlock_operations();
1233 return rc;
1234 }
1235
1236 int ibmphp_do_disable_slot(struct slot *slot_cur)
1237 {
1238 int rc;
1239 u8 flag;
1240
1241 debug("DISABLING SLOT...\n");
1242
1243 if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) {
1244 return -ENODEV;
1245 }
1246
1247 flag = slot_cur->flag;
1248 slot_cur->flag = 1;
1249
1250 if (flag == 1) {
1251 rc = validate(slot_cur, DISABLE);
1252 /* checking if powered off already & valid slot # */
1253 if (rc)
1254 goto error;
1255 }
1256 attn_LED_blink(slot_cur);
1257
1258 if (slot_cur->func == NULL) {
1259 /* We need this for fncs's that were there on bootup */
1260 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
1261 if (!slot_cur->func) {
1262 err("out of system memory\n");
1263 rc = -ENOMEM;
1264 goto error;
1265 }
1266 slot_cur->func->busno = slot_cur->bus;
1267 slot_cur->func->device = slot_cur->device;
1268 }
1269
1270 ibm_unconfigure_device(slot_cur->func);
1271
1272 /* If we got here from latch suddenly opening on operating card or
1273 a power fault, there's no power to the card, so cannot
1274 read from it to determine what resources it occupied. This operation
1275 is forbidden anyhow. The best we can do is remove it from kernel
1276 lists at least */
1277
1278 if (!flag) {
1279 attn_off(slot_cur);
1280 return 0;
1281 }
1282
1283 rc = ibmphp_unconfigure_card(&slot_cur, 0);
1284 slot_cur->func = NULL;
1285 debug("in disable_slot. after unconfigure_card\n");
1286 if (rc) {
1287 err("could not unconfigure card.\n");
1288 goto error;
1289 }
1290
1291 rc = ibmphp_hpc_writeslot(slot_cur, HPC_SLOT_OFF);
1292 if (rc)
1293 goto error;
1294
1295 attn_off(slot_cur);
1296 rc = slot_update(&slot_cur);
1297 if (rc)
1298 goto exit;
1299
1300 rc = ibmphp_update_slot_info(slot_cur);
1301 ibmphp_print_test();
1302 exit:
1303 return rc;
1304
1305 error:
1306 /* Need to turn off if was blinking b4 */
1307 attn_off(slot_cur);
1308 attn_on(slot_cur);
1309 if (slot_update(&slot_cur)) {
1310 rc = -EFAULT;
1311 goto exit;
1312 }
1313 if (flag)
1314 ibmphp_update_slot_info(slot_cur);
1315 goto exit;
1316 }
1317
1318 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1319 .owner = THIS_MODULE,
1320 .set_attention_status = set_attention_status,
1321 .enable_slot = enable_slot,
1322 .disable_slot = ibmphp_disable_slot,
1323 .hardware_test = NULL,
1324 .get_power_status = get_power_status,
1325 .get_attention_status = get_attention_status,
1326 .get_latch_status = get_latch_status,
1327 .get_adapter_status = get_adapter_present,
1328 .get_max_bus_speed = get_max_bus_speed,
1329 .get_cur_bus_speed = get_cur_bus_speed,
1330 /* .get_max_adapter_speed = get_max_adapter_speed,
1331 .get_bus_name_status = get_bus_name,
1332 */
1333 };
1334
1335 static void ibmphp_unload(void)
1336 {
1337 free_slots();
1338 debug("after slots\n");
1339 ibmphp_free_resources();
1340 debug("after resources\n");
1341 ibmphp_free_bus_info_queue();
1342 debug("after bus info\n");
1343 ibmphp_free_ebda_hpc_queue();
1344 debug("after ebda hpc\n");
1345 ibmphp_free_ebda_pci_rsrc_queue();
1346 debug("after ebda pci rsrc\n");
1347 kfree(ibmphp_pci_bus);
1348 }
1349
1350 static int __init ibmphp_init(void)
1351 {
1352 struct pci_bus *bus;
1353 int i = 0;
1354 int rc = 0;
1355
1356 init_flag = 1;
1357
1358 info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
1359
1360 ibmphp_pci_bus = kmalloc(sizeof(*ibmphp_pci_bus), GFP_KERNEL);
1361 if (!ibmphp_pci_bus) {
1362 err("out of memory\n");
1363 rc = -ENOMEM;
1364 goto exit;
1365 }
1366
1367 bus = pci_find_bus(0, 0);
1368 if (!bus) {
1369 err("Can't find the root pci bus, can not continue\n");
1370 rc = -ENODEV;
1371 goto error;
1372 }
1373 memcpy(ibmphp_pci_bus, bus, sizeof(*ibmphp_pci_bus));
1374
1375 ibmphp_debug = debug;
1376
1377 ibmphp_hpc_initvars();
1378
1379 for (i = 0; i < 16; i++)
1380 irqs[i] = 0;
1381
1382 if ((rc = ibmphp_access_ebda()))
1383 goto error;
1384 debug("after ibmphp_access_ebda()\n");
1385
1386 if ((rc = ibmphp_rsrc_init()))
1387 goto error;
1388 debug("AFTER Resource & EBDA INITIALIZATIONS\n");
1389
1390 max_slots = get_max_slots();
1391
1392 if ((rc = ibmphp_register_pci()))
1393 goto error;
1394
1395 if (init_ops()) {
1396 rc = -ENODEV;
1397 goto error;
1398 }
1399
1400 ibmphp_print_test();
1401 if ((rc = ibmphp_hpc_start_poll_thread())) {
1402 goto error;
1403 }
1404
1405 /* lock ourselves into memory with a module
1406 * count of -1 so that no one can unload us. */
1407 module_put(THIS_MODULE);
1408
1409 exit:
1410 return rc;
1411
1412 error:
1413 ibmphp_unload();
1414 goto exit;
1415 }
1416
1417 static void __exit ibmphp_exit(void)
1418 {
1419 ibmphp_hpc_stop_poll_thread();
1420 debug("after polling\n");
1421 ibmphp_unload();
1422 debug("done\n");
1423 }
1424
1425 module_init(ibmphp_init);
1426 module_exit(ibmphp_exit);
Linux with added FPC-III support