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