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