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