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