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