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 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (C) 2001,2002 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 <linux/smp_lock.h>
38 #include "../../arch/i386/kernel/pci-i386.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_PARM (debug, "i");
54 MODULE_PARM_DESC (debug, "Debugging mode enabled or not");
55 MODULE_LICENSE ("GPL");
56 MODULE_DESCRIPTION (DRIVER_DESC);
57
58 static int *ops[MAX_OPS + 1];
59 struct pci_ops *ibmphp_pci_root_ops;
60 static int max_slots;
61
62 static int irqs[16]; /* PIC mode IRQ's we're using so far (in case MPS 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 */
get_cur_bus_info(struct slot ** sl)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 = CURRENT_BUS_MODE (slot_cur->busstatus);
91 else
92 slot_cur->bus_on->current_bus_mode = 0xFF;
93
94 debug ("busstatus = %x, bus_speed = %x, bus_mode = %x\n", slot_cur->busstatus, slot_cur->bus_on->current_speed, slot_cur->bus_on->current_bus_mode);
95
96 *sl = slot_cur;
97 return 0;
98 }
99
slot_update(struct slot ** sl)100 static inline int slot_update (struct slot **sl)
101 {
102 int rc;
103 rc = ibmphp_hpc_readslot (*sl, READ_ALLSTAT, NULL);
104 if (rc)
105 return rc;
106 if (!init_flag)
107 return get_cur_bus_info (sl);
108 return rc;
109 }
110
get_max_slots(void)111 static int __init get_max_slots (void)
112 {
113 struct slot * slot_cur;
114 struct list_head * tmp;
115 u8 slot_count = 0;
116
117 list_for_each (tmp, &ibmphp_slot_head) {
118 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
119 /* sometimes the hot-pluggable slots start with 4 (not always from 1 */
120 slot_count = max (slot_count, slot_cur->number);
121 }
122 return slot_count;
123 }
124
125 /* This routine will put the correct slot->device information per slot. It's
126 * called from initialization of the slot structures. It will also assign
127 * interrupt numbers per each slot.
128 * Parameters: struct slot
129 * Returns 0 or errors
130 */
ibmphp_init_devno(struct slot ** cur_slot)131 int ibmphp_init_devno (struct slot **cur_slot)
132 {
133 struct irq_routing_table *rtable;
134 int len;
135 int loop;
136 int i;
137
138 rtable = pcibios_get_irq_routing_table ();
139 if (!rtable) {
140 err ("no BIOS routing table...\n");
141 return -ENOMEM;
142 }
143
144 len = (rtable->size - sizeof (struct irq_routing_table)) / sizeof (struct irq_info);
145
146 if (!len)
147 return -1;
148 for (loop = 0; loop < len; loop++) {
149 if ((*cur_slot)->number == rtable->slots[loop].slot) {
150 if ((*cur_slot)->bus == rtable->slots[loop].bus) {
151 (*cur_slot)->device = PCI_SLOT (rtable->slots[loop].devfn);
152 for (i = 0; i < 4; i++)
153 (*cur_slot)->irq[i] = IO_APIC_get_PCI_irq_vector ((int) (*cur_slot)->bus, (int) (*cur_slot)->device, i);
154
155 debug ("(*cur_slot)->irq[0] = %x\n", (*cur_slot)->irq[0]);
156 debug ("(*cur_slot)->irq[1] = %x\n", (*cur_slot)->irq[1]);
157 debug ("(*cur_slot)->irq[2] = %x\n", (*cur_slot)->irq[2]);
158 debug ("(*cur_slot)->irq[3] = %x\n", (*cur_slot)->irq[3]);
159
160 debug ("rtable->exlusive_irqs = %x\n", rtable->exclusive_irqs);
161 debug ("rtable->slots[loop].irq[0].bitmap = %x\n", rtable->slots[loop].irq[0].bitmap);
162 debug ("rtable->slots[loop].irq[1].bitmap = %x\n", rtable->slots[loop].irq[1].bitmap);
163 debug ("rtable->slots[loop].irq[2].bitmap = %x\n", rtable->slots[loop].irq[2].bitmap);
164 debug ("rtable->slots[loop].irq[3].bitmap = %x\n", rtable->slots[loop].irq[3].bitmap);
165
166 debug ("rtable->slots[loop].irq[0].link= %x\n", rtable->slots[loop].irq[0].link);
167 debug ("rtable->slots[loop].irq[1].link = %x\n", rtable->slots[loop].irq[1].link);
168 debug ("rtable->slots[loop].irq[2].link = %x\n", rtable->slots[loop].irq[2].link);
169 debug ("rtable->slots[loop].irq[3].link = %x\n", rtable->slots[loop].irq[3].link);
170 debug ("end of init_devno\n");
171 return 0;
172 }
173 }
174 }
175
176 return -1;
177 }
178
power_on(struct slot * slot_cur)179 static inline int power_on (struct slot *slot_cur)
180 {
181 u8 cmd = HPC_SLOT_ON;
182 int retval;
183
184 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
185 if (retval) {
186 err ("power on failed\n");
187 return retval;
188 }
189 if (CTLR_RESULT (slot_cur->ctrl->status)) {
190 err ("command not completed successfully in power_on \n");
191 return -EIO;
192 }
193 long_delay (3 * HZ); /* For ServeRAID cards, and some 66 PCI */
194 return 0;
195 }
196
power_off(struct slot * slot_cur)197 static inline int power_off (struct slot *slot_cur)
198 {
199 u8 cmd = HPC_SLOT_OFF;
200 int retval;
201
202 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
203 if (retval) {
204 err ("power off failed \n");
205 return retval;
206 }
207 if (CTLR_RESULT (slot_cur->ctrl->status)) {
208 err ("command not completed successfully in power_off \n");
209 return -EIO;
210 }
211 return 0;
212 }
213
set_attention_status(struct hotplug_slot * hotplug_slot,u8 value)214 static int set_attention_status (struct hotplug_slot *hotplug_slot, u8 value)
215 {
216 int rc = 0;
217 struct slot *pslot;
218 u8 cmd;
219 int hpcrc = 0;
220
221 debug ("set_attention_status - Entry hotplug_slot[%lx] value[%x]\n", (ulong) hotplug_slot, value);
222 ibmphp_lock_operations ();
223 cmd = 0x00; // avoid compiler warning
224
225 if (hotplug_slot) {
226 switch (value) {
227 case HPC_SLOT_ATTN_OFF:
228 cmd = HPC_SLOT_ATTNOFF;
229 break;
230 case HPC_SLOT_ATTN_ON:
231 cmd = HPC_SLOT_ATTNON;
232 break;
233 case HPC_SLOT_ATTN_BLINK:
234 cmd = HPC_SLOT_BLINKLED;
235 break;
236 default:
237 rc = -ENODEV;
238 err ("set_attention_status - Error : invalid input [%x]\n", value);
239 break;
240 }
241 if (rc == 0) {
242 pslot = (struct slot *) hotplug_slot->private;
243 if (pslot)
244 hpcrc = ibmphp_hpc_writeslot (pslot, cmd);
245 else
246 rc = -ENODEV;
247 }
248 } else
249 rc = -ENODEV;
250
251 if (hpcrc)
252 rc = hpcrc;
253
254 ibmphp_unlock_operations ();
255
256 debug ("set_attention_status - Exit rc[%d]\n", rc);
257 return rc;
258 }
259
get_attention_status(struct hotplug_slot * hotplug_slot,u8 * value)260 static int get_attention_status (struct hotplug_slot *hotplug_slot, u8 * value)
261 {
262 int rc = -ENODEV;
263 struct slot *pslot;
264 int hpcrc = 0;
265 struct slot myslot;
266
267 debug ("get_attention_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
268
269 ibmphp_lock_operations ();
270 if (hotplug_slot && value) {
271 pslot = (struct slot *) hotplug_slot->private;
272 if (pslot) {
273 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
274 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
275 if (!hpcrc)
276 hpcrc = ibmphp_hpc_readslot (pslot, READ_EXTSLOTSTATUS, &(myslot.ext_status));
277 if (!hpcrc) {
278 *value = SLOT_ATTN (myslot.status, myslot.ext_status);
279 rc = 0;
280 }
281 }
282 } else
283 rc = -ENODEV;
284
285 if (hpcrc)
286 rc = hpcrc;
287
288 ibmphp_unlock_operations ();
289 debug ("get_attention_status - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
290 return rc;
291 }
292
get_latch_status(struct hotplug_slot * hotplug_slot,u8 * value)293 static int get_latch_status (struct hotplug_slot *hotplug_slot, u8 * value)
294 {
295 int rc = -ENODEV;
296 struct slot *pslot;
297 int hpcrc = 0;
298 struct slot myslot;
299
300 debug ("get_latch_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
301 ibmphp_lock_operations ();
302 if (hotplug_slot && value) {
303 pslot = (struct slot *) hotplug_slot->private;
304 if (pslot) {
305 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
306 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
307 if (!hpcrc) {
308 *value = SLOT_LATCH (myslot.status);
309 rc = 0;
310 }
311 }
312 } else
313 rc = -ENODEV;
314
315 if (hpcrc)
316 rc = hpcrc;
317
318 ibmphp_unlock_operations ();
319 debug ("get_latch_status - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
320 return rc;
321 }
322
323
get_power_status(struct hotplug_slot * hotplug_slot,u8 * value)324 static int get_power_status (struct hotplug_slot *hotplug_slot, u8 * value)
325 {
326 int rc = -ENODEV;
327 struct slot *pslot;
328 int hpcrc = 0;
329 struct slot myslot;
330
331 debug ("get_power_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
332 ibmphp_lock_operations ();
333 if (hotplug_slot && value) {
334 pslot = (struct slot *) hotplug_slot->private;
335 if (pslot) {
336 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
337 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
338 if (!hpcrc) {
339 *value = SLOT_PWRGD (myslot.status);
340 rc = 0;
341 }
342 }
343 } else
344 rc = -ENODEV;
345
346 if (hpcrc)
347 rc = hpcrc;
348
349 ibmphp_unlock_operations ();
350 debug ("get_power_status - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
351 return rc;
352 }
353
get_adapter_present(struct hotplug_slot * hotplug_slot,u8 * value)354 static int get_adapter_present (struct hotplug_slot *hotplug_slot, u8 * value)
355 {
356 int rc = -ENODEV;
357 struct slot *pslot;
358 u8 present;
359 int hpcrc = 0;
360 struct slot myslot;
361
362 debug ("get_adapter_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
363 ibmphp_lock_operations ();
364 if (hotplug_slot && value) {
365 pslot = (struct slot *) hotplug_slot->private;
366 if (pslot) {
367 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
368 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
369 if (!hpcrc) {
370 present = SLOT_PRESENT (myslot.status);
371 if (present == HPC_SLOT_EMPTY)
372 *value = 0;
373 else
374 *value = 1;
375 rc = 0;
376 }
377 }
378 } else
379 rc = -ENODEV;
380 if (hpcrc)
381 rc = hpcrc;
382
383 ibmphp_unlock_operations ();
384 debug ("get_adapter_present - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
385 return rc;
386 }
387
get_max_bus_speed(struct hotplug_slot * hotplug_slot,enum pci_bus_speed * value)388 static int get_max_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
389 {
390 int rc = -ENODEV;
391 struct slot *pslot;
392 u8 mode = 0;
393
394 debug ("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
395 hotplug_slot, value);
396
397 ibmphp_lock_operations ();
398
399 if (hotplug_slot && value) {
400 pslot = (struct slot *) hotplug_slot->private;
401 if (pslot) {
402 rc = 0;
403 mode = pslot->supported_bus_mode;
404 *value = pslot->supported_speed;
405 switch (*value) {
406 case BUS_SPEED_33:
407 break;
408 case BUS_SPEED_66:
409 if (mode == BUS_MODE_PCIX)
410 *value += 0x01;
411 break;
412 case BUS_SPEED_100:
413 case BUS_SPEED_133:
414 *value = pslot->supported_speed + 0x01;
415 break;
416 default:
417 /* Note (will need to change): there would be soon 256, 512 also */
418 rc = -ENODEV;
419 }
420 }
421 } else
422 rc = -ENODEV;
423
424 ibmphp_unlock_operations ();
425 debug ("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
426 return rc;
427 }
428
get_cur_bus_speed(struct hotplug_slot * hotplug_slot,enum pci_bus_speed * value)429 static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
430 {
431 int rc = -ENODEV;
432 struct slot *pslot;
433 u8 mode = 0;
434
435 debug ("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
436 hotplug_slot, value);
437
438 ibmphp_lock_operations ();
439
440 if (hotplug_slot && value) {
441 pslot = (struct slot *) hotplug_slot->private;
442 if (pslot) {
443 rc = get_cur_bus_info (&pslot);
444 if (!rc) {
445 mode = pslot->bus_on->current_bus_mode;
446 *value = pslot->bus_on->current_speed;
447 switch (*value) {
448 case BUS_SPEED_33:
449 break;
450 case BUS_SPEED_66:
451 if (mode == BUS_MODE_PCIX)
452 *value += 0x01;
453 else if (mode == BUS_MODE_PCI)
454 ;
455 else
456 *value = PCI_SPEED_UNKNOWN;
457 break;
458 case BUS_SPEED_100:
459 case BUS_SPEED_133:
460 *value += 0x01;
461 break;
462 default:
463 /* Note of change: there would also be 256, 512 soon */
464 rc = -ENODEV;
465 }
466 }
467 }
468 } else
469 rc = -ENODEV;
470
471 ibmphp_unlock_operations ();
472 debug ("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
473 return rc;
474 }
475 /*
476 static int get_max_adapter_speed_1 (struct hotplug_slot *hotplug_slot, u8 * value, u8 flag)
477 {
478 int rc = -ENODEV;
479 struct slot *pslot;
480 int hpcrc = 0;
481 struct slot myslot;
482
483 debug ("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong)hotplug_slot, (ulong) value);
484
485 if (flag)
486 ibmphp_lock_operations ();
487
488 if (hotplug_slot && value) {
489 pslot = (struct slot *) hotplug_slot->private;
490 if (pslot) {
491 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
492 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
493
494 if (!(SLOT_LATCH (myslot.status)) && (SLOT_PRESENT (myslot.status))) {
495 hpcrc = ibmphp_hpc_readslot (pslot, READ_EXTSLOTSTATUS, &(myslot.ext_status));
496 if (!hpcrc) {
497 *value = SLOT_SPEED (myslot.ext_status);
498 rc = 0;
499 }
500 } else {
501 *value = MAX_ADAPTER_NONE;
502 rc = 0;
503 }
504 }
505 } else
506 rc = -ENODEV;
507
508 if (hpcrc)
509 rc = hpcrc;
510
511 if (flag)
512 ibmphp_unlock_operations ();
513
514 debug ("get_max_adapter_speed_1 - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
515 return rc;
516 }
517
518 static int get_bus_name (struct hotplug_slot *hotplug_slot, char * value)
519 {
520 int rc = -ENODEV;
521 struct slot *pslot = NULL;
522
523 debug ("get_bus_name - Entry hotplug_slot[%lx] \n", (ulong)hotplug_slot);
524
525 ibmphp_lock_operations ();
526
527 if (hotplug_slot) {
528 pslot = (struct slot *) hotplug_slot->private;
529 if (pslot) {
530 rc = 0;
531 snprintf (value, 100, "Bus %x", pslot->bus);
532 }
533 } else
534 rc = -ENODEV;
535
536 ibmphp_unlock_operations ();
537 debug ("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value);
538 return rc;
539 }
540 */
541
542 /*******************************************************************************
543 * This routine will initialize the ops data structure used in the validate
544 * function. It will also power off empty slots that are powered on since BIOS
545 * leaves those on, albeit disconnected
546 ******************************************************************************/
init_ops(void)547 static int __init init_ops (void)
548 {
549 struct slot *slot_cur;
550 struct list_head *tmp;
551 int retval;
552 int rc;
553 int j;
554
555 for (j = 0; j < MAX_OPS; j++) {
556 ops[j] = (int *) kmalloc ((max_slots + 1) * sizeof (int), GFP_KERNEL);
557 memset (ops[j], 0, (max_slots + 1) * sizeof (int));
558 if (!ops[j]) {
559 err ("out of system memory \n");
560 return -ENOMEM;
561 }
562 }
563
564 ops[ADD][0] = 0;
565 ops[REMOVE][0] = 0;
566 ops[DETAIL][0] = 0;
567
568 list_for_each (tmp, &ibmphp_slot_head) {
569 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
570
571 if (!slot_cur)
572 return -ENODEV;
573
574 debug ("BEFORE GETTING SLOT STATUS, slot # %x\n", slot_cur->number);
575 if (slot_cur->ctrl->revision == 0xFF)
576 if (get_ctrl_revision (slot_cur, &slot_cur->ctrl->revision))
577 return -1;
578
579 if (slot_cur->bus_on->current_speed == 0xFF)
580 if (get_cur_bus_info (&slot_cur))
581 return -1;
582
583 if (slot_cur->ctrl->options == 0xFF)
584 if (get_hpc_options (slot_cur, &slot_cur->ctrl->options))
585 return -1;
586
587 retval = slot_update (&slot_cur);
588 if (retval)
589 return retval;
590
591 debug ("status = %x, ext_status = %x\n", slot_cur->status, slot_cur->ext_status);
592 debug ("SLOT_POWER = %x, SLOT_PRESENT = %x, SLOT_LATCH = %x\n", SLOT_POWER (slot_cur->status), SLOT_PRESENT (slot_cur->status), SLOT_LATCH (slot_cur->status));
593
594 if (!(SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status)))
595 /* No power, adapter, and latch closed */
596 ops[ADD][slot_cur->number] = 1;
597 else
598 ops[ADD][slot_cur->number] = 0;
599
600 ops[DETAIL][slot_cur->number] = 1;
601
602 if ((SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status)))
603 /*Power,adapter,latch closed */
604 ops[REMOVE][slot_cur->number] = 1;
605 else
606 ops[REMOVE][slot_cur->number] = 0;
607
608 if ((SLOT_PWRGD (slot_cur->status)) && !(SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status))) {
609 debug ("BEFORE POWER OFF COMMAND\n");
610 rc = power_off (slot_cur);
611 if (rc)
612 return rc;
613
614 /* retval = slot_update (&slot_cur);
615 * if (retval)
616 * return retval;
617 * ibmphp_update_slot_info (slot_cur);
618 */
619 }
620 }
621 init_flag = 0;
622 return 0;
623 }
624
625 /* This operation will check whether the slot is within the bounds and
626 * the operation is valid to perform on that slot
627 * Parameters: slot, operation
628 * Returns: 0 or error codes
629 */
validate(struct slot * slot_cur,int opn)630 static int validate (struct slot *slot_cur, int opn)
631 {
632 int number;
633 int retval;
634
635 if (!slot_cur)
636 return -ENODEV;
637 number = slot_cur->number;
638 if ((number > max_slots) || (number < 0))
639 return -EBADSLT;
640 debug ("slot_number in validate is %d\n", slot_cur->number);
641
642 retval = slot_update (&slot_cur);
643 if (retval)
644 return retval;
645
646 if (!(SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status))
647 && !(SLOT_LATCH (slot_cur->status)))
648 ops[ADD][number] = 1;
649 else
650 ops[ADD][number] = 0;
651
652 ops[DETAIL][number] = 1;
653
654 if ((SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status))
655 && !(SLOT_LATCH (slot_cur->status)))
656 ops[REMOVE][number] = 1;
657 else
658 ops[REMOVE][number] = 0;
659
660 switch (opn) {
661 case ENABLE:
662 if (ops[ADD][number])
663 return 0;
664 break;
665 case DISABLE:
666 if (ops[REMOVE][number])
667 return 0;
668 break;
669 case DETAIL:
670 if (ops[DETAIL][number])
671 return 0;
672 break;
673 default:
674 return -EINVAL;
675 break;
676 }
677 err ("validate failed....\n");
678 return -EINVAL;
679 }
680
681 /********************************************************************************
682 * This routine is for updating the data structures in the hotplug core
683 * Parameters: struct slot
684 * Returns: 0 or error
685 *******************************************************************************/
ibmphp_update_slot_info(struct slot * slot_cur)686 int ibmphp_update_slot_info (struct slot *slot_cur)
687 {
688 struct hotplug_slot_info *info;
689 char buffer[30];
690 int rc;
691 u8 bus_speed;
692 u8 mode;
693
694 info = kmalloc (sizeof (struct hotplug_slot_info), GFP_KERNEL);
695 if (!info) {
696 err ("out of system memory \n");
697 return -ENOMEM;
698 }
699
700 strncpy (buffer, slot_cur->hotplug_slot->name, 30);
701 info->power_status = SLOT_PWRGD (slot_cur->status);
702 info->attention_status = SLOT_ATTN (slot_cur->status, slot_cur->ext_status);
703 info->latch_status = SLOT_LATCH (slot_cur->status);
704 if (!SLOT_PRESENT (slot_cur->status)) {
705 info->adapter_status = 0;
706 // info->max_adapter_speed_status = MAX_ADAPTER_NONE;
707 } else {
708 info->adapter_status = 1;
709 // get_max_adapter_speed_1 (slot_cur->hotplug_slot, &info->max_adapter_speed_status, 0);
710 }
711
712 bus_speed = slot_cur->bus_on->current_speed;
713 mode = slot_cur->bus_on->current_bus_mode;
714
715 switch (bus_speed) {
716 case BUS_SPEED_33:
717 break;
718 case BUS_SPEED_66:
719 if (mode == BUS_MODE_PCIX)
720 bus_speed += 0x01;
721 else if (mode == BUS_MODE_PCI)
722 ;
723 else
724 bus_speed = PCI_SPEED_UNKNOWN;
725 break;
726 case BUS_SPEED_100:
727 case BUS_SPEED_133:
728 bus_speed += 0x01;
729 break;
730 default:
731 bus_speed = PCI_SPEED_UNKNOWN;
732 }
733
734 info->cur_bus_speed = bus_speed;
735 info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed;
736 // To do: bus_names
737
738 rc = pci_hp_change_slot_info (buffer, info);
739 kfree (info);
740 return rc;
741 }
742
743
744 /******************************************************************************
745 * This function will return the pci_func, given bus and devfunc, or NULL. It
746 * is called from visit routines
747 ******************************************************************************/
748
ibm_slot_find(u8 busno,u8 device,u8 function)749 static struct pci_func *ibm_slot_find (u8 busno, u8 device, u8 function)
750 {
751 struct pci_func *func_cur;
752 struct slot *slot_cur;
753 struct list_head * tmp;
754 list_for_each (tmp, &ibmphp_slot_head) {
755 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
756 if (slot_cur->func) {
757 func_cur = slot_cur->func;
758 while (func_cur) {
759 if ((func_cur->busno == busno) && (func_cur->device == device) && (func_cur->function == function))
760 return func_cur;
761 func_cur = func_cur->next;
762 }
763 }
764 }
765 return NULL;
766 }
767
768 /* This routine is to find the pci_bus from kernel structures.
769 * Parameters: bus number
770 * Returns : pci_bus * or NULL if not found
771 */
find_bus(u8 busno)772 static struct pci_bus *find_bus (u8 busno)
773 {
774 const struct list_head *tmp;
775 struct pci_bus *bus;
776 debug ("inside find_bus, busno = %x \n", busno);
777
778 list_for_each (tmp, &pci_root_buses) {
779 bus = (struct pci_bus *) pci_bus_b (tmp);
780 if (bus)
781 if (bus->number == busno)
782 return bus;
783 }
784 return NULL;
785 }
786
787 /******************************************************************
788 * This function is here because we can no longer use pci_root_ops
789 ******************************************************************/
get_root_pci_ops(void)790 static struct pci_ops *get_root_pci_ops (void)
791 {
792 struct pci_bus * bus;
793
794 if ((bus = find_bus (0)))
795 return bus->ops;
796 return NULL;
797 }
798
799 /*************************************************************
800 * This routine frees up memory used by struct slot, including
801 * the pointers to pci_func, bus, hotplug_slot, controller,
802 * and deregistering from the hotplug core
803 *************************************************************/
free_slots(void)804 static void free_slots (void)
805 {
806 struct slot *slot_cur;
807 struct list_head * tmp;
808 struct list_head * next;
809
810 debug ("%s -- enter\n", __FUNCTION__);
811
812 list_for_each_safe (tmp, next, &ibmphp_slot_head) {
813
814 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
815
816 pci_hp_deregister (slot_cur->hotplug_slot);
817
818 if (slot_cur->hotplug_slot) {
819 kfree (slot_cur->hotplug_slot);
820 slot_cur->hotplug_slot = NULL;
821 }
822
823 if (slot_cur->ctrl)
824 slot_cur->ctrl = NULL;
825
826 if (slot_cur->bus_on)
827 slot_cur->bus_on = NULL;
828
829 ibmphp_unconfigure_card (&slot_cur, -1); /* we don't want to actually remove the resources, since free_resources will do just that */
830
831 kfree (slot_cur);
832 slot_cur = NULL;
833 }
834 debug ("%s -- exit\n", __FUNCTION__);
835 }
836
ibm_is_pci_dev_in_use(struct pci_dev * dev)837 static int ibm_is_pci_dev_in_use (struct pci_dev *dev)
838 {
839 int i = 0;
840 int inuse = 0;
841
842 if (dev->driver)
843 return 1;
844
845 for (i = 0; !dev->driver && !inuse && (i < 6); i++) {
846
847 if (!pci_resource_start (dev, i))
848 continue;
849
850 if (pci_resource_flags (dev, i) & IORESOURCE_IO)
851 inuse = check_region (pci_resource_start (dev, i), pci_resource_len (dev, i));
852
853 else if (pci_resource_flags (dev, i) & IORESOURCE_MEM)
854 inuse = check_mem_region (pci_resource_start (dev, i), pci_resource_len (dev, i));
855 }
856
857 return inuse;
858 }
859
ibm_pci_hp_remove_device(struct pci_dev * dev)860 static int ibm_pci_hp_remove_device (struct pci_dev *dev)
861 {
862 if (ibm_is_pci_dev_in_use (dev)) {
863 err ("***Cannot safely power down device -- it appears to be in use***\n");
864 return -EBUSY;
865 }
866 pci_remove_device (dev);
867 return 0;
868 }
869
ibm_unconfigure_visit_pci_dev_phase2(struct pci_dev_wrapped * wrapped_dev,struct pci_bus_wrapped * wrapped_bus)870 static int ibm_unconfigure_visit_pci_dev_phase2 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
871 {
872 struct pci_dev *dev = wrapped_dev->dev;
873 struct pci_func *temp_func;
874 int i = 0;
875
876 do {
877 temp_func = ibm_slot_find (dev->bus->number, dev->devfn >> 3, i++);
878 } while (temp_func && (temp_func->function != (dev->devfn & 0x07)));
879
880 if (dev) {
881 if (ibm_pci_hp_remove_device (dev) == 0)
882 kfree (dev); /* Now, remove */
883 else
884 return -1;
885 }
886
887 if (temp_func)
888 temp_func->dev = NULL;
889 else
890 debug ("No pci_func representation for bus, devfn = %d, %x\n", dev->bus->number, dev->devfn);
891
892 return 0;
893 }
894
ibm_unconfigure_visit_pci_bus_phase2(struct pci_bus_wrapped * wrapped_bus,struct pci_dev_wrapped * wrapped_dev)895 static int ibm_unconfigure_visit_pci_bus_phase2 (struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_dev)
896 {
897 struct pci_bus *bus = wrapped_bus->bus;
898
899 pci_proc_detach_bus (bus);
900 /* The cleanup code should live in the kernel... */
901 bus->self->subordinate = NULL;
902 /* unlink from parent bus */
903 list_del (&bus->node);
904
905 /* Now, remove */
906 if (bus)
907 kfree (bus);
908
909 return 0;
910 }
911
ibm_unconfigure_visit_pci_dev_phase1(struct pci_dev_wrapped * wrapped_dev,struct pci_bus_wrapped * wrapped_bus)912 static int ibm_unconfigure_visit_pci_dev_phase1 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
913 {
914 struct pci_dev *dev = wrapped_dev->dev;
915
916 debug ("attempting removal of driver for device (%x, %x, %x)\n", dev->bus->number, PCI_SLOT (dev->devfn), PCI_FUNC (dev->devfn));
917
918 /* Now, remove the Linux Driver Representation */
919 if (dev->driver) {
920 debug ("is there a driver?\n");
921 if (dev->driver->remove) {
922 dev->driver->remove (dev);
923 debug ("driver was properly removed\n");
924 }
925 dev->driver = NULL;
926 }
927
928 return ibm_is_pci_dev_in_use (dev);
929 }
930
931 static struct pci_visit ibm_unconfigure_functions_phase1 = {
932 .post_visit_pci_dev = ibm_unconfigure_visit_pci_dev_phase1,
933 };
934
935 static struct pci_visit ibm_unconfigure_functions_phase2 = {
936 .post_visit_pci_bus = ibm_unconfigure_visit_pci_bus_phase2,
937 .post_visit_pci_dev = ibm_unconfigure_visit_pci_dev_phase2,
938 };
939
ibm_unconfigure_device(struct pci_func * func)940 static int ibm_unconfigure_device (struct pci_func *func)
941 {
942 int rc = 0;
943 struct pci_dev_wrapped wrapped_dev;
944 struct pci_bus_wrapped wrapped_bus;
945 struct pci_dev *temp;
946 u8 j;
947
948 memset (&wrapped_dev, 0, sizeof (struct pci_dev_wrapped));
949 memset (&wrapped_bus, 0, sizeof (struct pci_bus_wrapped));
950
951 debug ("inside ibm_unconfigure_device\n");
952 debug ("func->device = %x, func->function = %x\n", func->device, func->function);
953 debug ("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0);
954
955 for (j = 0; j < 0x08; j++) {
956 temp = pci_find_slot (func->busno, (func->device << 3) | j);
957 if (temp) {
958 wrapped_dev.dev = temp;
959 wrapped_bus.bus = temp->bus;
960 rc = pci_visit_dev (&ibm_unconfigure_functions_phase1, &wrapped_dev, &wrapped_bus);
961 if (rc)
962 break;
963
964 rc = pci_visit_dev (&ibm_unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus);
965 if (rc)
966 break;
967 }
968 }
969 debug ("rc in ibm_unconfigure_device b4 returning is %d \n", rc);
970 return rc;
971 }
972
configure_visit_pci_dev(struct pci_dev_wrapped * wrapped_dev,struct pci_bus_wrapped * wrapped_bus)973 static int configure_visit_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
974 {
975 // struct pci_bus *bus = wrapped_bus->bus; /* We don't need this, since we don't create in the else statement */
976 struct pci_dev *dev = wrapped_dev->dev;
977 struct pci_func *temp_func;
978 int i = 0;
979
980 do {
981 temp_func = ibm_slot_find (dev->bus->number, dev->devfn >> 3, i++);
982 } while (temp_func && (temp_func->function != (dev->devfn & 0x07)));
983
984 if (temp_func)
985 temp_func->dev = dev;
986 else {
987 /* This should not really happen, since we create functions
988 first and then call to configure */
989 debug (" We shouldn't come here \n");
990 }
991
992 if (temp_func->dev) {
993 pci_proc_attach_device (temp_func->dev);
994 pci_announce_device_to_drivers (temp_func->dev);
995 }
996
997 return 0;
998 }
999
1000 static struct pci_visit configure_functions = {
1001 .visit_pci_dev =configure_visit_pci_dev,
1002 };
1003
1004
1005 /*
1006 * The following function is to fix kernel bug regarding
1007 * getting bus entries, here we manually add those primary
1008 * bus entries to kernel bus structure whenever apply
1009 */
1010
bus_structure_fixup(u8 busno)1011 static u8 bus_structure_fixup (u8 busno)
1012 {
1013 struct pci_bus bus_t;
1014 struct pci_dev dev_t;
1015 u16 l;
1016
1017 if (find_bus (busno) || !(ibmphp_find_same_bus_num (busno)))
1018 return 1;
1019 bus_t.number = busno;
1020 bus_t.ops = ibmphp_pci_root_ops;
1021 dev_t.bus = &bus_t;
1022 for (dev_t.devfn=0; dev_t.devfn<256; dev_t.devfn += 8) {
1023 if (!pci_read_config_word (&dev_t, PCI_VENDOR_ID, &l) && l != 0x0000 && l != 0xffff) {
1024 debug ("%s - Inside bus_struture_fixup() \n", __FUNCTION__);
1025 pci_scan_bus (busno, ibmphp_pci_root_ops, NULL);
1026 break;
1027 }
1028 }
1029 return 0;
1030 }
1031
ibm_configure_device(struct pci_func * func)1032 static int ibm_configure_device (struct pci_func *func)
1033 {
1034 unsigned char bus;
1035 struct pci_dev dev0;
1036 struct pci_bus *child;
1037 struct pci_dev *temp;
1038 int rc = 0;
1039 int flag = 0; /* this is to make sure we don't double scan the bus, for bridged devices primarily */
1040
1041 struct pci_dev_wrapped wrapped_dev;
1042 struct pci_bus_wrapped wrapped_bus;
1043
1044 memset (&wrapped_dev, 0, sizeof (struct pci_dev_wrapped));
1045 memset (&wrapped_bus, 0, sizeof (struct pci_bus_wrapped));
1046 memset (&dev0, 0, sizeof (struct pci_dev));
1047
1048 if (!(bus_structure_fixup (func->busno)))
1049 flag = 1;
1050 if (func->dev == NULL)
1051 func->dev = pci_find_slot (func->busno, (func->device << 3) | (func->function & 0x7));
1052
1053 if (func->dev == NULL) {
1054 dev0.bus = find_bus (func->busno);
1055 dev0.devfn = ((func->device << 3) + (func->function & 0x7));
1056 dev0.sysdata = dev0.bus->sysdata;
1057
1058 func->dev = pci_scan_slot (&dev0);
1059
1060 if (func->dev == NULL) {
1061 err ("ERROR... : pci_dev still NULL \n");
1062 return 0;
1063 }
1064 }
1065 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) {
1066 pci_read_config_byte (func->dev, PCI_SECONDARY_BUS, &bus);
1067 child = (struct pci_bus *) pci_add_new_bus (func->dev->bus, (func->dev), bus);
1068 pci_do_scan_bus (child);
1069 }
1070
1071 temp = func->dev;
1072 if (temp) {
1073 wrapped_dev.dev = temp;
1074 wrapped_bus.bus = temp->bus;
1075 rc = pci_visit_dev (&configure_functions, &wrapped_dev, &wrapped_bus);
1076 }
1077 return rc;
1078 }
1079
1080 /*******************************************************
1081 * Returns whether the bus is empty or not
1082 *******************************************************/
is_bus_empty(struct slot * slot_cur)1083 static int is_bus_empty (struct slot * slot_cur)
1084 {
1085 int rc;
1086 struct slot * tmp_slot;
1087 u8 i = slot_cur->bus_on->slot_min;
1088
1089 while (i <= slot_cur->bus_on->slot_max) {
1090 if (i == slot_cur->number) {
1091 i++;
1092 continue;
1093 }
1094 tmp_slot = ibmphp_get_slot_from_physical_num (i);
1095 rc = slot_update (&tmp_slot);
1096 if (rc)
1097 return 0;
1098 if (SLOT_PRESENT (tmp_slot->status) && SLOT_PWRGD (tmp_slot->status))
1099 return 0;
1100 i++;
1101 }
1102 return 1;
1103 }
1104
1105 /***********************************************************
1106 * If the HPC permits and the bus currently empty, tries to set the
1107 * bus speed and mode at the maximum card and bus capability
1108 * Parameters: slot
1109 * Returns: bus is set (0) or error code
1110 ***********************************************************/
set_bus(struct slot * slot_cur)1111 static int set_bus (struct slot * slot_cur)
1112 {
1113 int rc;
1114 u8 speed;
1115 u8 cmd = 0x0;
1116 const struct list_head *tmp;
1117 struct pci_dev * dev;
1118 int retval;
1119
1120 debug ("%s - entry slot # %d \n", __FUNCTION__, slot_cur->number);
1121 if (SET_BUS_STATUS (slot_cur->ctrl) && is_bus_empty (slot_cur)) {
1122 rc = slot_update (&slot_cur);
1123 if (rc)
1124 return rc;
1125 speed = SLOT_SPEED (slot_cur->ext_status);
1126 debug ("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
1127 switch (speed) {
1128 case HPC_SLOT_SPEED_33:
1129 cmd = HPC_BUS_33CONVMODE;
1130 break;
1131 case HPC_SLOT_SPEED_66:
1132 if (SLOT_PCIX (slot_cur->ext_status)) {
1133 if ((slot_cur->supported_speed >= BUS_SPEED_66) && (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
1134 cmd = HPC_BUS_66PCIXMODE;
1135 else if (!SLOT_BUS_MODE (slot_cur->ext_status))
1136 /* if max slot/bus capability is 66 pci
1137 and there's no bus mode mismatch, then
1138 the adapter supports 66 pci */
1139 cmd = HPC_BUS_66CONVMODE;
1140 else
1141 cmd = HPC_BUS_33CONVMODE;
1142 } else {
1143 if (slot_cur->supported_speed >= BUS_SPEED_66)
1144 cmd = HPC_BUS_66CONVMODE;
1145 else
1146 cmd = HPC_BUS_33CONVMODE;
1147 }
1148 break;
1149 case HPC_SLOT_SPEED_133:
1150 switch (slot_cur->supported_speed) {
1151 case BUS_SPEED_33:
1152 cmd = HPC_BUS_33CONVMODE;
1153 break;
1154 case BUS_SPEED_66:
1155 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
1156 cmd = HPC_BUS_66PCIXMODE;
1157 else
1158 cmd = HPC_BUS_66CONVMODE;
1159 break;
1160 case BUS_SPEED_100:
1161 cmd = HPC_BUS_100PCIXMODE;
1162 break;
1163 case BUS_SPEED_133:
1164 /* This is to take care of the bug in CIOBX chip*/
1165 list_for_each (tmp, &pci_devices) {
1166 dev = (struct pci_dev *) pci_dev_g (tmp);
1167 if (dev) {
1168 if ((dev->vendor == 0x1166) && (dev->device == 0x0101))
1169 ibmphp_hpc_writeslot (slot_cur, HPC_BUS_100PCIXMODE);
1170 }
1171 }
1172 cmd = HPC_BUS_133PCIXMODE;
1173 break;
1174 default:
1175 err ("Wrong bus speed \n");
1176 return -ENODEV;
1177 }
1178 break;
1179 default:
1180 err ("wrong slot speed \n");
1181 return -ENODEV;
1182 }
1183 debug ("setting bus speed for slot %d, cmd %x\n", slot_cur->number, cmd);
1184 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
1185 if (retval) {
1186 err ("setting bus speed failed\n");
1187 return retval;
1188 }
1189 if (CTLR_RESULT (slot_cur->ctrl->status)) {
1190 err ("command not completed successfully in set_bus \n");
1191 return -EIO;
1192 }
1193 }
1194 /* This is for x440, once Brandon fixes the firmware,
1195 will not need this delay */
1196 long_delay (1 * HZ);
1197 debug ("%s -Exit \n", __FUNCTION__);
1198 return 0;
1199 }
1200
1201 /* This routine checks the bus limitations that the slot is on from the BIOS.
1202 * This is used in deciding whether or not to power up the slot.
1203 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
1204 * same bus)
1205 * Parameters: slot
1206 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
1207 */
check_limitations(struct slot * slot_cur)1208 static int check_limitations (struct slot *slot_cur)
1209 {
1210 u8 i;
1211 struct slot * tmp_slot;
1212 u8 count = 0;
1213 u8 limitation = 0;
1214
1215 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
1216 tmp_slot = ibmphp_get_slot_from_physical_num (i);
1217 if ((SLOT_PWRGD (tmp_slot->status)) && !(SLOT_CONNECT (tmp_slot->status)))
1218 count++;
1219 }
1220 get_cur_bus_info (&slot_cur);
1221 switch (slot_cur->bus_on->current_speed) {
1222 case BUS_SPEED_33:
1223 limitation = slot_cur->bus_on->slots_at_33_conv;
1224 break;
1225 case BUS_SPEED_66:
1226 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
1227 limitation = slot_cur->bus_on->slots_at_66_pcix;
1228 else
1229 limitation = slot_cur->bus_on->slots_at_66_conv;
1230 break;
1231 case BUS_SPEED_100:
1232 limitation = slot_cur->bus_on->slots_at_100_pcix;
1233 break;
1234 case BUS_SPEED_133:
1235 limitation = slot_cur->bus_on->slots_at_133_pcix;
1236 break;
1237 }
1238
1239 if ((count + 1) > limitation)
1240 return -EINVAL;
1241 return 0;
1242 }
1243
print_card_capability(struct slot * slot_cur)1244 static inline void print_card_capability (struct slot *slot_cur)
1245 {
1246 info ("capability of the card is ");
1247 if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
1248 info (" 133 MHz PCI-X \n");
1249 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
1250 info (" 66 MHz PCI-X \n");
1251 else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
1252 info (" 66 MHz PCI \n");
1253 else
1254 info (" 33 MHz PCI \n");
1255
1256 }
1257
1258 /* This routine will power on the slot, configure the device(s) and find the
1259 * drivers for them.
1260 * Parameters: hotplug_slot
1261 * Returns: 0 or failure codes
1262 */
enable_slot(struct hotplug_slot * hs)1263 static int enable_slot (struct hotplug_slot *hs)
1264 {
1265 int rc, i, rcpr;
1266 struct slot *slot_cur;
1267 u8 function;
1268 u8 faulted = 0;
1269 struct pci_func *tmp_func;
1270
1271 ibmphp_lock_operations ();
1272
1273 debug ("ENABLING SLOT........ \n");
1274 slot_cur = (struct slot *) hs->private;
1275
1276 if ((rc = validate (slot_cur, ENABLE))) {
1277 err ("validate function failed \n");
1278 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1279 attn_on (slot_cur);
1280 rc = slot_update (&slot_cur);
1281 if (rc) {
1282 ibmphp_unlock_operations();
1283 return rc;
1284 }
1285 ibmphp_update_slot_info (slot_cur);
1286 ibmphp_unlock_operations ();
1287 return rc;
1288 }
1289
1290 attn_LED_blink (slot_cur);
1291
1292 rc = set_bus (slot_cur);
1293 if (rc) {
1294 err ("was not able to set the bus \n");
1295 attn_off (slot_cur);
1296 attn_on (slot_cur);
1297 ibmphp_unlock_operations ();
1298 return -ENODEV;
1299 }
1300
1301 /*-----------------debugging------------------------------*/
1302 get_cur_bus_info (&slot_cur);
1303 debug ("the current bus speed right after set_bus = %x \n", slot_cur->bus_on->current_speed);
1304 /*----------------------------------------------------------*/
1305
1306 rc = check_limitations (slot_cur);
1307 if (rc) {
1308 err ("Adding this card exceeds the limitations of this bus. \n");
1309 err ("(i.e., >1 133MHz cards running on same bus, or >2 66 PCI cards running on same bus \n. Try hot-adding into another bus \n");
1310 attn_off (slot_cur);
1311 attn_on (slot_cur);
1312
1313 if (slot_update (&slot_cur)) {
1314 ibmphp_unlock_operations ();
1315 return -ENODEV;
1316 }
1317 ibmphp_update_slot_info (slot_cur);
1318 ibmphp_unlock_operations ();
1319 return -EINVAL;
1320 }
1321
1322 rc = power_on (slot_cur);
1323
1324 if (rc) {
1325 err ("something wrong when powering up... please see below for details\n");
1326 /* need to turn off before on, otherwise, blinking overwrites */
1327 attn_off(slot_cur);
1328 attn_on (slot_cur);
1329 if (slot_update (&slot_cur)) {
1330 attn_off (slot_cur);
1331 attn_on (slot_cur);
1332 ibmphp_unlock_operations ();
1333 return -ENODEV;
1334 }
1335 /* Check to see the error of why it failed */
1336 if ((SLOT_POWER (slot_cur->status)) && !(SLOT_PWRGD (slot_cur->status)))
1337 err ("power fault occured trying to power up \n");
1338 else if (SLOT_BUS_SPEED (slot_cur->status)) {
1339 err ("bus speed mismatch occured. please check current bus speed and card capability \n");
1340 print_card_capability (slot_cur);
1341 } else if (SLOT_BUS_MODE (slot_cur->ext_status)) {
1342 err ("bus mode mismatch occured. please check current bus mode and card capability \n");
1343 print_card_capability (slot_cur);
1344 }
1345 ibmphp_update_slot_info (slot_cur);
1346 ibmphp_unlock_operations ();
1347 return rc;
1348 }
1349 debug ("after power_on\n");
1350 /*-----------------------debugging---------------------------*/
1351 get_cur_bus_info (&slot_cur);
1352 debug ("the current bus speed right after power_on = %x \n", slot_cur->bus_on->current_speed);
1353 /*----------------------------------------------------------*/
1354
1355 rc = slot_update (&slot_cur);
1356 if (rc) {
1357 attn_off (slot_cur);
1358 attn_on (slot_cur);
1359 rcpr = power_off (slot_cur);
1360 if (rcpr) {
1361 ibmphp_unlock_operations ();
1362 return rcpr;
1363 }
1364 ibmphp_unlock_operations ();
1365 return rc;
1366 }
1367
1368 if (SLOT_POWER (slot_cur->status) && !(SLOT_PWRGD (slot_cur->status))) {
1369 faulted = 1;
1370 err ("power fault occured trying to power up... \n");
1371 } else if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) {
1372 faulted = 1;
1373 err ("bus speed mismatch occured. please check current bus speed and card capability \n");
1374 print_card_capability (slot_cur);
1375 }
1376 /* Don't think this case will happen after above checks... but just in case, for paranoia sake */
1377 else if (!(SLOT_POWER (slot_cur->status))) {
1378 err ("power on failed... \n");
1379 faulted = 1;
1380 }
1381 if (faulted) {
1382 attn_off (slot_cur); /* need to turn off b4 on */
1383 attn_on (slot_cur);
1384 rcpr = power_off (slot_cur);
1385 if (rcpr) {
1386 ibmphp_unlock_operations ();
1387 return rcpr;
1388 }
1389
1390 if (slot_update (&slot_cur)) {
1391 ibmphp_unlock_operations ();
1392 return -ENODEV;
1393 }
1394 ibmphp_update_slot_info (slot_cur);
1395 ibmphp_unlock_operations ();
1396 return -EINVAL;
1397 }
1398
1399 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1400 if (!slot_cur->func) { /* We cannot do update_slot_info here, since no memory for kmalloc n.e.ways, and update_slot_info allocates some */
1401 err ("out of system memory \n");
1402 attn_off (slot_cur);
1403 attn_on (slot_cur);
1404 rcpr = power_off (slot_cur);
1405 if (rcpr) {
1406 ibmphp_unlock_operations ();
1407 return rcpr;
1408 }
1409 ibmphp_unlock_operations ();
1410 return -ENOMEM;
1411 }
1412 memset (slot_cur->func, 0, sizeof (struct pci_func));
1413 slot_cur->func->busno = slot_cur->bus;
1414 slot_cur->func->device = slot_cur->device;
1415 for (i = 0; i < 4; i++)
1416 slot_cur->func->irq[i] = slot_cur->irq[i];
1417
1418 debug ("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", slot_cur->bus, slot_cur->device);
1419
1420 if (ibmphp_configure_card (slot_cur->func, slot_cur->number)) {
1421 err ("configure_card was unsuccessful... \n");
1422 ibmphp_unconfigure_card (&slot_cur, 1); /* true because don't need to actually deallocate resources, just remove references */
1423 debug ("after unconfigure_card\n");
1424 slot_cur->func = NULL;
1425 attn_off (slot_cur); /* need to turn off in case was blinking */
1426 attn_on (slot_cur);
1427 rcpr = power_off (slot_cur);
1428 if (rcpr) {
1429 ibmphp_unlock_operations ();
1430 return rcpr;
1431 }
1432 if (slot_update (&slot_cur)) {
1433 ibmphp_unlock_operations();
1434 return -ENODEV;
1435 }
1436 ibmphp_update_slot_info (slot_cur);
1437 ibmphp_unlock_operations ();
1438 return -ENOMEM;
1439 }
1440 function = 0x00;
1441 do {
1442 tmp_func = ibm_slot_find (slot_cur->bus, slot_cur->func->device, function++);
1443 if (tmp_func && !(tmp_func->dev))
1444 ibm_configure_device (tmp_func);
1445 } while (tmp_func);
1446
1447 attn_off (slot_cur);
1448 if (slot_update (&slot_cur)) {
1449 ibmphp_unlock_operations ();
1450 return -EFAULT;
1451 }
1452 ibmphp_print_test ();
1453 rc = ibmphp_update_slot_info (slot_cur);
1454 ibmphp_unlock_operations();
1455 return rc;
1456 }
1457
1458 /**************************************************************
1459 * HOT REMOVING ADAPTER CARD *
1460 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE *
1461 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE *
1462 DISABLE POWER , *
1463 **************************************************************/
ibmphp_disable_slot(struct hotplug_slot * hotplug_slot)1464 int ibmphp_disable_slot (struct hotplug_slot *hotplug_slot)
1465 {
1466 int rc;
1467 struct slot *slot_cur = (struct slot *) hotplug_slot->private;
1468 u8 flag;
1469 int parm = 0;
1470
1471 debug ("DISABLING SLOT... \n");
1472
1473 if (slot_cur == NULL) {
1474 ibmphp_unlock_operations ();
1475 return -ENODEV;
1476 }
1477
1478 if (slot_cur->ctrl == NULL) {
1479 ibmphp_unlock_operations ();
1480 return -ENODEV;
1481 }
1482
1483 flag = slot_cur->flag; /* to see if got here from polling */
1484
1485 if (flag)
1486 ibmphp_lock_operations ();
1487
1488 slot_cur->flag = TRUE;
1489
1490 if (flag == TRUE) {
1491 rc = validate (slot_cur, DISABLE); /* checking if powered off already & valid slot # */
1492 if (rc) {
1493 /* Need to turn off if was blinking b4 */
1494 attn_off (slot_cur);
1495 attn_on (slot_cur);
1496 if (slot_update (&slot_cur)) {
1497 ibmphp_unlock_operations ();
1498 return -EFAULT;
1499 }
1500
1501 ibmphp_update_slot_info (slot_cur);
1502 ibmphp_unlock_operations ();
1503 return rc;
1504 }
1505 }
1506 attn_LED_blink (slot_cur);
1507
1508 if (slot_cur->func == NULL) {
1509 /* We need this for fncs's that were there on bootup */
1510 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1511 if (!slot_cur->func) {
1512 err ("out of system memory \n");
1513 attn_off (slot_cur);
1514 attn_on (slot_cur);
1515 ibmphp_unlock_operations ();
1516 return -ENOMEM;
1517 }
1518 memset (slot_cur->func, 0, sizeof (struct pci_func));
1519 slot_cur->func->busno = slot_cur->bus;
1520 slot_cur->func->device = slot_cur->device;
1521 }
1522
1523 if ((rc = ibm_unconfigure_device (slot_cur->func))) {
1524 err ("removing from kernel failed... \n");
1525 err ("Please check to see if it was statically linked or is in use otherwise. (perhaps the driver is not 'hot-removable')\n");
1526 attn_off (slot_cur);
1527 attn_on (slot_cur);
1528 ibmphp_unlock_operations ();
1529 return rc;
1530 }
1531
1532 /* If we got here from latch suddenly opening on operating card or
1533 a power fault, there's no power to the card, so cannot
1534 read from it to determine what resources it occupied. This operation
1535 is forbidden anyhow. The best we can do is remove it from kernel
1536 lists at least */
1537
1538 if (!flag) {
1539 attn_off (slot_cur);
1540 return 0;
1541 }
1542
1543 rc = ibmphp_unconfigure_card (&slot_cur, parm);
1544 slot_cur->func = NULL;
1545 debug ("in disable_slot. after unconfigure_card\n");
1546 if (rc) {
1547 err ("could not unconfigure card.\n");
1548 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1549 attn_on (slot_cur);
1550
1551 if (slot_update (&slot_cur)) {
1552 ibmphp_unlock_operations ();
1553 return -EFAULT;
1554 }
1555
1556 if (flag)
1557 ibmphp_update_slot_info (slot_cur);
1558 ibmphp_unlock_operations ();
1559 return -EFAULT;
1560 }
1561
1562 rc = ibmphp_hpc_writeslot (hotplug_slot->private, HPC_SLOT_OFF);
1563 if (rc) {
1564 attn_off (slot_cur);
1565 attn_on (slot_cur);
1566 if (slot_update (&slot_cur)) {
1567 ibmphp_unlock_operations ();
1568 return -EFAULT;
1569 }
1570
1571 ibmphp_update_slot_info (slot_cur);
1572 ibmphp_unlock_operations ();
1573 return rc;
1574 }
1575
1576 attn_off (slot_cur);
1577 if (slot_update (&slot_cur)) {
1578 ibmphp_unlock_operations ();
1579 return -EFAULT;
1580 }
1581 rc = ibmphp_update_slot_info (slot_cur);
1582 ibmphp_print_test ();
1583 ibmphp_unlock_operations();
1584 return rc;
1585 }
1586
1587 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1588 .owner = THIS_MODULE,
1589 .set_attention_status = set_attention_status,
1590 .enable_slot = enable_slot,
1591 .disable_slot = ibmphp_disable_slot,
1592 .hardware_test = NULL,
1593 .get_power_status = get_power_status,
1594 .get_attention_status = get_attention_status,
1595 .get_latch_status = get_latch_status,
1596 .get_adapter_status = get_adapter_present,
1597 .get_max_bus_speed = get_max_bus_speed,
1598 .get_cur_bus_speed = get_cur_bus_speed,
1599 /* .get_max_adapter_speed = get_max_adapter_speed,
1600 .get_bus_name_status = get_bus_name,
1601 */
1602 };
1603
ibmphp_unload(void)1604 static void ibmphp_unload (void)
1605 {
1606 free_slots ();
1607 debug ("after slots \n");
1608 ibmphp_free_resources ();
1609 debug ("after resources \n");
1610 ibmphp_free_bus_info_queue ();
1611 debug ("after bus info \n");
1612 ibmphp_free_ebda_hpc_queue ();
1613 debug ("after ebda hpc \n");
1614 ibmphp_free_ebda_pci_rsrc_queue ();
1615 debug ("after ebda pci rsrc \n");
1616 }
1617
ibmphp_init(void)1618 static int __init ibmphp_init (void)
1619 {
1620 int i = 0;
1621 int rc = 0;
1622
1623 init_flag = 1;
1624
1625 info (DRIVER_DESC " version: " DRIVER_VERSION "\n");
1626
1627 ibmphp_pci_root_ops = get_root_pci_ops ();
1628 if (ibmphp_pci_root_ops == NULL) {
1629 err ("cannot read bus operations... will not be able to read the cards. Please check your system\n");
1630 return -ENODEV;
1631 }
1632
1633 ibmphp_debug = debug;
1634
1635 ibmphp_hpc_initvars ();
1636
1637 for (i = 0; i < 16; i++)
1638 irqs[i] = 0;
1639
1640 if ((rc = ibmphp_access_ebda ())) {
1641 ibmphp_unload ();
1642 return rc;
1643 }
1644 debug ("after ibmphp_access_ebda ()\n");
1645
1646 if ((rc = ibmphp_rsrc_init ())) {
1647 ibmphp_unload ();
1648 return rc;
1649 }
1650 debug ("AFTER Resource & EBDA INITIALIZATIONS\n");
1651
1652 max_slots = get_max_slots ();
1653
1654 if ((rc = ibmphp_register_pci ())) {
1655 ibmphp_unload ();
1656 return rc;
1657 }
1658
1659 if (init_ops ()) {
1660 ibmphp_unload ();
1661 return -ENODEV;
1662 }
1663 ibmphp_print_test ();
1664 if ((rc = ibmphp_hpc_start_poll_thread ())) {
1665 ibmphp_unload ();
1666 return -ENODEV;
1667 }
1668
1669 /* if no NVRAM module selected, lock ourselves into memory with a
1670 * module count of -1 so that no one can unload us. */
1671 MOD_DEC_USE_COUNT;
1672 return 0;
1673 }
1674
ibmphp_exit(void)1675 static void __exit ibmphp_exit (void)
1676 {
1677 ibmphp_hpc_stop_poll_thread ();
1678 debug ("after polling\n");
1679 ibmphp_unload ();
1680 debug ("done\n");
1681 }
1682
1683 module_init (ibmphp_init);
1684 module_exit (ibmphp_exit);
1685