1 /* 2 * IBM Hot Plug Controller Driver 3 * 4 * Written By: Tong Yu, 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/module.h> 31 #include <linux/errno.h> 32 #include <linux/mm.h> 33 #include <linux/slab.h> 34 #include <linux/pci.h> 35 #include <linux/list.h> 36 #include <linux/init.h> 37 #include "ibmphp.h" 38 39 /* 40 * POST builds data blocks(in this data block definition, a char-1 41 * byte, short(or word)-2 byte, long(dword)-4 byte) in the Extended 42 * BIOS Data Area which describe the configuration of the hot-plug 43 * controllers and resources used by the PCI Hot-Plug devices. 44 * 45 * This file walks EBDA, maps data block from physical addr, 46 * reconstruct linked lists about all system resource(MEM, PFM, IO) 47 * already assigned by POST, as well as linked lists about hot plug 48 * controllers (ctlr#, slot#, bus&slot features...) 49 */ 50 51 /* Global lists */ 52 LIST_HEAD (ibmphp_ebda_pci_rsrc_head); 53 LIST_HEAD (ibmphp_slot_head); 54 55 /* Local variables */ 56 static struct ebda_hpc_list *hpc_list_ptr; 57 static struct ebda_rsrc_list *rsrc_list_ptr; 58 static struct rio_table_hdr *rio_table_ptr = NULL; 59 static LIST_HEAD (ebda_hpc_head); 60 static LIST_HEAD (bus_info_head); 61 static LIST_HEAD (rio_vg_head); 62 static LIST_HEAD (rio_lo_head); 63 static LIST_HEAD (opt_vg_head); 64 static LIST_HEAD (opt_lo_head); 65 static void __iomem *io_mem; 66 67 /* Local functions */ 68 static int ebda_rsrc_controller (void); 69 static int ebda_rsrc_rsrc (void); 70 static int ebda_rio_table (void); 71 72 static struct ebda_hpc_list * __init alloc_ebda_hpc_list (void) 73 { 74 return kzalloc(sizeof(struct ebda_hpc_list), GFP_KERNEL); 75 } 76 77 static struct controller *alloc_ebda_hpc (u32 slot_count, u32 bus_count) 78 { 79 struct controller *controller; 80 struct ebda_hpc_slot *slots; 81 struct ebda_hpc_bus *buses; 82 83 controller = kzalloc(sizeof(struct controller), GFP_KERNEL); 84 if (!controller) 85 goto error; 86 87 slots = kcalloc(slot_count, sizeof(struct ebda_hpc_slot), GFP_KERNEL); 88 if (!slots) 89 goto error_contr; 90 controller->slots = slots; 91 92 buses = kcalloc(bus_count, sizeof(struct ebda_hpc_bus), GFP_KERNEL); 93 if (!buses) 94 goto error_slots; 95 controller->buses = buses; 96 97 return controller; 98 error_slots: 99 kfree(controller->slots); 100 error_contr: 101 kfree(controller); 102 error: 103 return NULL; 104 } 105 106 static void free_ebda_hpc (struct controller *controller) 107 { 108 kfree (controller->slots); 109 kfree (controller->buses); 110 kfree (controller); 111 } 112 113 static struct ebda_rsrc_list * __init alloc_ebda_rsrc_list (void) 114 { 115 return kzalloc(sizeof(struct ebda_rsrc_list), GFP_KERNEL); 116 } 117 118 static struct ebda_pci_rsrc *alloc_ebda_pci_rsrc (void) 119 { 120 return kzalloc(sizeof(struct ebda_pci_rsrc), GFP_KERNEL); 121 } 122 123 static void __init print_bus_info (void) 124 { 125 struct bus_info *ptr; 126 127 list_for_each_entry(ptr, &bus_info_head, bus_info_list) { 128 debug ("%s - slot_min = %x\n", __func__, ptr->slot_min); 129 debug ("%s - slot_max = %x\n", __func__, ptr->slot_max); 130 debug ("%s - slot_count = %x\n", __func__, ptr->slot_count); 131 debug ("%s - bus# = %x\n", __func__, ptr->busno); 132 debug ("%s - current_speed = %x\n", __func__, ptr->current_speed); 133 debug ("%s - controller_id = %x\n", __func__, ptr->controller_id); 134 135 debug ("%s - slots_at_33_conv = %x\n", __func__, ptr->slots_at_33_conv); 136 debug ("%s - slots_at_66_conv = %x\n", __func__, ptr->slots_at_66_conv); 137 debug ("%s - slots_at_66_pcix = %x\n", __func__, ptr->slots_at_66_pcix); 138 debug ("%s - slots_at_100_pcix = %x\n", __func__, ptr->slots_at_100_pcix); 139 debug ("%s - slots_at_133_pcix = %x\n", __func__, ptr->slots_at_133_pcix); 140 141 } 142 } 143 144 static void print_lo_info (void) 145 { 146 struct rio_detail *ptr; 147 debug ("print_lo_info ----\n"); 148 list_for_each_entry(ptr, &rio_lo_head, rio_detail_list) { 149 debug ("%s - rio_node_id = %x\n", __func__, ptr->rio_node_id); 150 debug ("%s - rio_type = %x\n", __func__, ptr->rio_type); 151 debug ("%s - owner_id = %x\n", __func__, ptr->owner_id); 152 debug ("%s - first_slot_num = %x\n", __func__, ptr->first_slot_num); 153 debug ("%s - wpindex = %x\n", __func__, ptr->wpindex); 154 debug ("%s - chassis_num = %x\n", __func__, ptr->chassis_num); 155 156 } 157 } 158 159 static void print_vg_info (void) 160 { 161 struct rio_detail *ptr; 162 debug ("%s ---\n", __func__); 163 list_for_each_entry(ptr, &rio_vg_head, rio_detail_list) { 164 debug ("%s - rio_node_id = %x\n", __func__, ptr->rio_node_id); 165 debug ("%s - rio_type = %x\n", __func__, ptr->rio_type); 166 debug ("%s - owner_id = %x\n", __func__, ptr->owner_id); 167 debug ("%s - first_slot_num = %x\n", __func__, ptr->first_slot_num); 168 debug ("%s - wpindex = %x\n", __func__, ptr->wpindex); 169 debug ("%s - chassis_num = %x\n", __func__, ptr->chassis_num); 170 171 } 172 } 173 174 static void __init print_ebda_pci_rsrc (void) 175 { 176 struct ebda_pci_rsrc *ptr; 177 178 list_for_each_entry(ptr, &ibmphp_ebda_pci_rsrc_head, ebda_pci_rsrc_list) { 179 debug ("%s - rsrc type: %x bus#: %x dev_func: %x start addr: %x end addr: %x\n", 180 __func__, ptr->rsrc_type ,ptr->bus_num, ptr->dev_fun,ptr->start_addr, ptr->end_addr); 181 } 182 } 183 184 static void __init print_ibm_slot (void) 185 { 186 struct slot *ptr; 187 188 list_for_each_entry(ptr, &ibmphp_slot_head, ibm_slot_list) { 189 debug ("%s - slot_number: %x\n", __func__, ptr->number); 190 } 191 } 192 193 static void __init print_opt_vg (void) 194 { 195 struct opt_rio *ptr; 196 debug ("%s ---\n", __func__); 197 list_for_each_entry(ptr, &opt_vg_head, opt_rio_list) { 198 debug ("%s - rio_type %x\n", __func__, ptr->rio_type); 199 debug ("%s - chassis_num: %x\n", __func__, ptr->chassis_num); 200 debug ("%s - first_slot_num: %x\n", __func__, ptr->first_slot_num); 201 debug ("%s - middle_num: %x\n", __func__, ptr->middle_num); 202 } 203 } 204 205 static void __init print_ebda_hpc (void) 206 { 207 struct controller *hpc_ptr; 208 u16 index; 209 210 list_for_each_entry(hpc_ptr, &ebda_hpc_head, ebda_hpc_list) { 211 for (index = 0; index < hpc_ptr->slot_count; index++) { 212 debug ("%s - physical slot#: %x\n", __func__, hpc_ptr->slots[index].slot_num); 213 debug ("%s - pci bus# of the slot: %x\n", __func__, hpc_ptr->slots[index].slot_bus_num); 214 debug ("%s - index into ctlr addr: %x\n", __func__, hpc_ptr->slots[index].ctl_index); 215 debug ("%s - cap of the slot: %x\n", __func__, hpc_ptr->slots[index].slot_cap); 216 } 217 218 for (index = 0; index < hpc_ptr->bus_count; index++) { 219 debug ("%s - bus# of each bus controlled by this ctlr: %x\n", __func__, hpc_ptr->buses[index].bus_num); 220 } 221 222 debug ("%s - type of hpc: %x\n", __func__, hpc_ptr->ctlr_type); 223 switch (hpc_ptr->ctlr_type) { 224 case 1: 225 debug ("%s - bus: %x\n", __func__, hpc_ptr->u.pci_ctlr.bus); 226 debug ("%s - dev_fun: %x\n", __func__, hpc_ptr->u.pci_ctlr.dev_fun); 227 debug ("%s - irq: %x\n", __func__, hpc_ptr->irq); 228 break; 229 230 case 0: 231 debug ("%s - io_start: %x\n", __func__, hpc_ptr->u.isa_ctlr.io_start); 232 debug ("%s - io_end: %x\n", __func__, hpc_ptr->u.isa_ctlr.io_end); 233 debug ("%s - irq: %x\n", __func__, hpc_ptr->irq); 234 break; 235 236 case 2: 237 case 4: 238 debug ("%s - wpegbbar: %lx\n", __func__, hpc_ptr->u.wpeg_ctlr.wpegbbar); 239 debug ("%s - i2c_addr: %x\n", __func__, hpc_ptr->u.wpeg_ctlr.i2c_addr); 240 debug ("%s - irq: %x\n", __func__, hpc_ptr->irq); 241 break; 242 } 243 } 244 } 245 246 int __init ibmphp_access_ebda (void) 247 { 248 u8 format, num_ctlrs, rio_complete, hs_complete; 249 u16 ebda_seg, num_entries, next_offset, offset, blk_id, sub_addr, re, rc_id, re_id, base; 250 int rc = 0; 251 252 253 rio_complete = 0; 254 hs_complete = 0; 255 256 io_mem = ioremap ((0x40 << 4) + 0x0e, 2); 257 if (!io_mem ) 258 return -ENOMEM; 259 ebda_seg = readw (io_mem); 260 iounmap (io_mem); 261 debug ("returned ebda segment: %x\n", ebda_seg); 262 263 io_mem = ioremap(ebda_seg<<4, 1024); 264 if (!io_mem ) 265 return -ENOMEM; 266 next_offset = 0x180; 267 268 for (;;) { 269 offset = next_offset; 270 next_offset = readw (io_mem + offset); /* offset of next blk */ 271 272 offset += 2; 273 if (next_offset == 0) /* 0 indicate it's last blk */ 274 break; 275 blk_id = readw (io_mem + offset); /* this blk id */ 276 277 offset += 2; 278 /* check if it is hot swap block or rio block */ 279 if (blk_id != 0x4853 && blk_id != 0x4752) 280 continue; 281 /* found hs table */ 282 if (blk_id == 0x4853) { 283 debug ("now enter hot swap block---\n"); 284 debug ("hot blk id: %x\n", blk_id); 285 format = readb (io_mem + offset); 286 287 offset += 1; 288 if (format != 4) 289 goto error_nodev; 290 debug ("hot blk format: %x\n", format); 291 /* hot swap sub blk */ 292 base = offset; 293 294 sub_addr = base; 295 re = readw (io_mem + sub_addr); /* next sub blk */ 296 297 sub_addr += 2; 298 rc_id = readw (io_mem + sub_addr); /* sub blk id */ 299 300 sub_addr += 2; 301 if (rc_id != 0x5243) 302 goto error_nodev; 303 /* rc sub blk signature */ 304 num_ctlrs = readb (io_mem + sub_addr); 305 306 sub_addr += 1; 307 hpc_list_ptr = alloc_ebda_hpc_list (); 308 if (!hpc_list_ptr) { 309 rc = -ENOMEM; 310 goto out; 311 } 312 hpc_list_ptr->format = format; 313 hpc_list_ptr->num_ctlrs = num_ctlrs; 314 hpc_list_ptr->phys_addr = sub_addr; /* offset of RSRC_CONTROLLER blk */ 315 debug ("info about hpc descriptor---\n"); 316 debug ("hot blk format: %x\n", format); 317 debug ("num of controller: %x\n", num_ctlrs); 318 debug ("offset of hpc data structure enteries: %x\n ", sub_addr); 319 320 sub_addr = base + re; /* re sub blk */ 321 /* FIXME: rc is never used/checked */ 322 rc = readw (io_mem + sub_addr); /* next sub blk */ 323 324 sub_addr += 2; 325 re_id = readw (io_mem + sub_addr); /* sub blk id */ 326 327 sub_addr += 2; 328 if (re_id != 0x5245) 329 goto error_nodev; 330 331 /* signature of re */ 332 num_entries = readw (io_mem + sub_addr); 333 334 sub_addr += 2; /* offset of RSRC_ENTRIES blk */ 335 rsrc_list_ptr = alloc_ebda_rsrc_list (); 336 if (!rsrc_list_ptr ) { 337 rc = -ENOMEM; 338 goto out; 339 } 340 rsrc_list_ptr->format = format; 341 rsrc_list_ptr->num_entries = num_entries; 342 rsrc_list_ptr->phys_addr = sub_addr; 343 344 debug ("info about rsrc descriptor---\n"); 345 debug ("format: %x\n", format); 346 debug ("num of rsrc: %x\n", num_entries); 347 debug ("offset of rsrc data structure enteries: %x\n ", sub_addr); 348 349 hs_complete = 1; 350 } else { 351 /* found rio table, blk_id == 0x4752 */ 352 debug ("now enter io table ---\n"); 353 debug ("rio blk id: %x\n", blk_id); 354 355 rio_table_ptr = kzalloc(sizeof(struct rio_table_hdr), GFP_KERNEL); 356 if (!rio_table_ptr) 357 return -ENOMEM; 358 rio_table_ptr->ver_num = readb (io_mem + offset); 359 rio_table_ptr->scal_count = readb (io_mem + offset + 1); 360 rio_table_ptr->riodev_count = readb (io_mem + offset + 2); 361 rio_table_ptr->offset = offset +3 ; 362 363 debug("info about rio table hdr ---\n"); 364 debug("ver_num: %x\nscal_count: %x\nriodev_count: %x\noffset of rio table: %x\n ", 365 rio_table_ptr->ver_num, rio_table_ptr->scal_count, 366 rio_table_ptr->riodev_count, rio_table_ptr->offset); 367 368 rio_complete = 1; 369 } 370 } 371 372 if (!hs_complete && !rio_complete) 373 goto error_nodev; 374 375 if (rio_table_ptr) { 376 if (rio_complete && rio_table_ptr->ver_num == 3) { 377 rc = ebda_rio_table (); 378 if (rc) 379 goto out; 380 } 381 } 382 rc = ebda_rsrc_controller (); 383 if (rc) 384 goto out; 385 386 rc = ebda_rsrc_rsrc (); 387 goto out; 388 error_nodev: 389 rc = -ENODEV; 390 out: 391 iounmap (io_mem); 392 return rc; 393 } 394 395 /* 396 * map info of scalability details and rio details from physical address 397 */ 398 static int __init ebda_rio_table (void) 399 { 400 u16 offset; 401 u8 i; 402 struct rio_detail *rio_detail_ptr; 403 404 offset = rio_table_ptr->offset; 405 offset += 12 * rio_table_ptr->scal_count; 406 407 // we do concern about rio details 408 for (i = 0; i < rio_table_ptr->riodev_count; i++) { 409 rio_detail_ptr = kzalloc(sizeof(struct rio_detail), GFP_KERNEL); 410 if (!rio_detail_ptr) 411 return -ENOMEM; 412 rio_detail_ptr->rio_node_id = readb (io_mem + offset); 413 rio_detail_ptr->bbar = readl (io_mem + offset + 1); 414 rio_detail_ptr->rio_type = readb (io_mem + offset + 5); 415 rio_detail_ptr->owner_id = readb (io_mem + offset + 6); 416 rio_detail_ptr->port0_node_connect = readb (io_mem + offset + 7); 417 rio_detail_ptr->port0_port_connect = readb (io_mem + offset + 8); 418 rio_detail_ptr->port1_node_connect = readb (io_mem + offset + 9); 419 rio_detail_ptr->port1_port_connect = readb (io_mem + offset + 10); 420 rio_detail_ptr->first_slot_num = readb (io_mem + offset + 11); 421 rio_detail_ptr->status = readb (io_mem + offset + 12); 422 rio_detail_ptr->wpindex = readb (io_mem + offset + 13); 423 rio_detail_ptr->chassis_num = readb (io_mem + offset + 14); 424 // debug ("rio_node_id: %x\nbbar: %x\nrio_type: %x\nowner_id: %x\nport0_node: %x\nport0_port: %x\nport1_node: %x\nport1_port: %x\nfirst_slot_num: %x\nstatus: %x\n", rio_detail_ptr->rio_node_id, rio_detail_ptr->bbar, rio_detail_ptr->rio_type, rio_detail_ptr->owner_id, rio_detail_ptr->port0_node_connect, rio_detail_ptr->port0_port_connect, rio_detail_ptr->port1_node_connect, rio_detail_ptr->port1_port_connect, rio_detail_ptr->first_slot_num, rio_detail_ptr->status); 425 //create linked list of chassis 426 if (rio_detail_ptr->rio_type == 4 || rio_detail_ptr->rio_type == 5) 427 list_add (&rio_detail_ptr->rio_detail_list, &rio_vg_head); 428 //create linked list of expansion box 429 else if (rio_detail_ptr->rio_type == 6 || rio_detail_ptr->rio_type == 7) 430 list_add (&rio_detail_ptr->rio_detail_list, &rio_lo_head); 431 else 432 // not in my concern 433 kfree (rio_detail_ptr); 434 offset += 15; 435 } 436 print_lo_info (); 437 print_vg_info (); 438 return 0; 439 } 440 441 /* 442 * reorganizing linked list of chassis 443 */ 444 static struct opt_rio *search_opt_vg (u8 chassis_num) 445 { 446 struct opt_rio *ptr; 447 list_for_each_entry(ptr, &opt_vg_head, opt_rio_list) { 448 if (ptr->chassis_num == chassis_num) 449 return ptr; 450 } 451 return NULL; 452 } 453 454 static int __init combine_wpg_for_chassis (void) 455 { 456 struct opt_rio *opt_rio_ptr = NULL; 457 struct rio_detail *rio_detail_ptr = NULL; 458 459 list_for_each_entry(rio_detail_ptr, &rio_vg_head, rio_detail_list) { 460 opt_rio_ptr = search_opt_vg (rio_detail_ptr->chassis_num); 461 if (!opt_rio_ptr) { 462 opt_rio_ptr = kzalloc(sizeof(struct opt_rio), GFP_KERNEL); 463 if (!opt_rio_ptr) 464 return -ENOMEM; 465 opt_rio_ptr->rio_type = rio_detail_ptr->rio_type; 466 opt_rio_ptr->chassis_num = rio_detail_ptr->chassis_num; 467 opt_rio_ptr->first_slot_num = rio_detail_ptr->first_slot_num; 468 opt_rio_ptr->middle_num = rio_detail_ptr->first_slot_num; 469 list_add (&opt_rio_ptr->opt_rio_list, &opt_vg_head); 470 } else { 471 opt_rio_ptr->first_slot_num = min (opt_rio_ptr->first_slot_num, rio_detail_ptr->first_slot_num); 472 opt_rio_ptr->middle_num = max (opt_rio_ptr->middle_num, rio_detail_ptr->first_slot_num); 473 } 474 } 475 print_opt_vg (); 476 return 0; 477 } 478 479 /* 480 * reorganizing linked list of expansion box 481 */ 482 static struct opt_rio_lo *search_opt_lo (u8 chassis_num) 483 { 484 struct opt_rio_lo *ptr; 485 list_for_each_entry(ptr, &opt_lo_head, opt_rio_lo_list) { 486 if (ptr->chassis_num == chassis_num) 487 return ptr; 488 } 489 return NULL; 490 } 491 492 static int combine_wpg_for_expansion (void) 493 { 494 struct opt_rio_lo *opt_rio_lo_ptr = NULL; 495 struct rio_detail *rio_detail_ptr = NULL; 496 497 list_for_each_entry(rio_detail_ptr, &rio_lo_head, rio_detail_list) { 498 opt_rio_lo_ptr = search_opt_lo (rio_detail_ptr->chassis_num); 499 if (!opt_rio_lo_ptr) { 500 opt_rio_lo_ptr = kzalloc(sizeof(struct opt_rio_lo), GFP_KERNEL); 501 if (!opt_rio_lo_ptr) 502 return -ENOMEM; 503 opt_rio_lo_ptr->rio_type = rio_detail_ptr->rio_type; 504 opt_rio_lo_ptr->chassis_num = rio_detail_ptr->chassis_num; 505 opt_rio_lo_ptr->first_slot_num = rio_detail_ptr->first_slot_num; 506 opt_rio_lo_ptr->middle_num = rio_detail_ptr->first_slot_num; 507 opt_rio_lo_ptr->pack_count = 1; 508 509 list_add (&opt_rio_lo_ptr->opt_rio_lo_list, &opt_lo_head); 510 } else { 511 opt_rio_lo_ptr->first_slot_num = min (opt_rio_lo_ptr->first_slot_num, rio_detail_ptr->first_slot_num); 512 opt_rio_lo_ptr->middle_num = max (opt_rio_lo_ptr->middle_num, rio_detail_ptr->first_slot_num); 513 opt_rio_lo_ptr->pack_count = 2; 514 } 515 } 516 return 0; 517 } 518 519 520 /* Since we don't know the max slot number per each chassis, hence go 521 * through the list of all chassis to find out the range 522 * Arguments: slot_num, 1st slot number of the chassis we think we are on, 523 * var (0 = chassis, 1 = expansion box) 524 */ 525 static int first_slot_num (u8 slot_num, u8 first_slot, u8 var) 526 { 527 struct opt_rio *opt_vg_ptr = NULL; 528 struct opt_rio_lo *opt_lo_ptr = NULL; 529 int rc = 0; 530 531 if (!var) { 532 list_for_each_entry(opt_vg_ptr, &opt_vg_head, opt_rio_list) { 533 if ((first_slot < opt_vg_ptr->first_slot_num) && (slot_num >= opt_vg_ptr->first_slot_num)) { 534 rc = -ENODEV; 535 break; 536 } 537 } 538 } else { 539 list_for_each_entry(opt_lo_ptr, &opt_lo_head, opt_rio_lo_list) { 540 if ((first_slot < opt_lo_ptr->first_slot_num) && (slot_num >= opt_lo_ptr->first_slot_num)) { 541 rc = -ENODEV; 542 break; 543 } 544 } 545 } 546 return rc; 547 } 548 549 static struct opt_rio_lo * find_rxe_num (u8 slot_num) 550 { 551 struct opt_rio_lo *opt_lo_ptr; 552 553 list_for_each_entry(opt_lo_ptr, &opt_lo_head, opt_rio_lo_list) { 554 //check to see if this slot_num belongs to expansion box 555 if ((slot_num >= opt_lo_ptr->first_slot_num) && (!first_slot_num (slot_num, opt_lo_ptr->first_slot_num, 1))) 556 return opt_lo_ptr; 557 } 558 return NULL; 559 } 560 561 static struct opt_rio * find_chassis_num (u8 slot_num) 562 { 563 struct opt_rio *opt_vg_ptr; 564 565 list_for_each_entry(opt_vg_ptr, &opt_vg_head, opt_rio_list) { 566 //check to see if this slot_num belongs to chassis 567 if ((slot_num >= opt_vg_ptr->first_slot_num) && (!first_slot_num (slot_num, opt_vg_ptr->first_slot_num, 0))) 568 return opt_vg_ptr; 569 } 570 return NULL; 571 } 572 573 /* This routine will find out how many slots are in the chassis, so that 574 * the slot numbers for rxe100 would start from 1, and not from 7, or 6 etc 575 */ 576 static u8 calculate_first_slot (u8 slot_num) 577 { 578 u8 first_slot = 1; 579 struct slot * slot_cur; 580 581 list_for_each_entry(slot_cur, &ibmphp_slot_head, ibm_slot_list) { 582 if (slot_cur->ctrl) { 583 if ((slot_cur->ctrl->ctlr_type != 4) && (slot_cur->ctrl->ending_slot_num > first_slot) && (slot_num > slot_cur->ctrl->ending_slot_num)) 584 first_slot = slot_cur->ctrl->ending_slot_num; 585 } 586 } 587 return first_slot + 1; 588 589 } 590 591 #define SLOT_NAME_SIZE 30 592 593 static char *create_file_name (struct slot * slot_cur) 594 { 595 struct opt_rio *opt_vg_ptr = NULL; 596 struct opt_rio_lo *opt_lo_ptr = NULL; 597 static char str[SLOT_NAME_SIZE]; 598 int which = 0; /* rxe = 1, chassis = 0 */ 599 u8 number = 1; /* either chassis or rxe # */ 600 u8 first_slot = 1; 601 u8 slot_num; 602 u8 flag = 0; 603 604 if (!slot_cur) { 605 err ("Structure passed is empty\n"); 606 return NULL; 607 } 608 609 slot_num = slot_cur->number; 610 611 memset (str, 0, sizeof(str)); 612 613 if (rio_table_ptr) { 614 if (rio_table_ptr->ver_num == 3) { 615 opt_vg_ptr = find_chassis_num (slot_num); 616 opt_lo_ptr = find_rxe_num (slot_num); 617 } 618 } 619 if (opt_vg_ptr) { 620 if (opt_lo_ptr) { 621 if ((slot_num - opt_vg_ptr->first_slot_num) > (slot_num - opt_lo_ptr->first_slot_num)) { 622 number = opt_lo_ptr->chassis_num; 623 first_slot = opt_lo_ptr->first_slot_num; 624 which = 1; /* it is RXE */ 625 } else { 626 first_slot = opt_vg_ptr->first_slot_num; 627 number = opt_vg_ptr->chassis_num; 628 which = 0; 629 } 630 } else { 631 first_slot = opt_vg_ptr->first_slot_num; 632 number = opt_vg_ptr->chassis_num; 633 which = 0; 634 } 635 ++flag; 636 } else if (opt_lo_ptr) { 637 number = opt_lo_ptr->chassis_num; 638 first_slot = opt_lo_ptr->first_slot_num; 639 which = 1; 640 ++flag; 641 } else if (rio_table_ptr) { 642 if (rio_table_ptr->ver_num == 3) { 643 /* if both NULL and we DO have correct RIO table in BIOS */ 644 return NULL; 645 } 646 } 647 if (!flag) { 648 if (slot_cur->ctrl->ctlr_type == 4) { 649 first_slot = calculate_first_slot (slot_num); 650 which = 1; 651 } else { 652 which = 0; 653 } 654 } 655 656 sprintf(str, "%s%dslot%d", 657 which == 0 ? "chassis" : "rxe", 658 number, slot_num - first_slot + 1); 659 return str; 660 } 661 662 static int fillslotinfo(struct hotplug_slot *hotplug_slot) 663 { 664 struct slot *slot; 665 int rc = 0; 666 667 if (!hotplug_slot || !hotplug_slot->private) 668 return -EINVAL; 669 670 slot = hotplug_slot->private; 671 rc = ibmphp_hpc_readslot(slot, READ_ALLSTAT, NULL); 672 if (rc) 673 return rc; 674 675 // power - enabled:1 not:0 676 hotplug_slot->info->power_status = SLOT_POWER(slot->status); 677 678 // attention - off:0, on:1, blinking:2 679 hotplug_slot->info->attention_status = SLOT_ATTN(slot->status, slot->ext_status); 680 681 // latch - open:1 closed:0 682 hotplug_slot->info->latch_status = SLOT_LATCH(slot->status); 683 684 // pci board - present:1 not:0 685 if (SLOT_PRESENT (slot->status)) 686 hotplug_slot->info->adapter_status = 1; 687 else 688 hotplug_slot->info->adapter_status = 0; 689 /* 690 if (slot->bus_on->supported_bus_mode 691 && (slot->bus_on->supported_speed == BUS_SPEED_66)) 692 hotplug_slot->info->max_bus_speed_status = BUS_SPEED_66PCIX; 693 else 694 hotplug_slot->info->max_bus_speed_status = slot->bus_on->supported_speed; 695 */ 696 697 return rc; 698 } 699 700 static void release_slot(struct hotplug_slot *hotplug_slot) 701 { 702 struct slot *slot; 703 704 if (!hotplug_slot || !hotplug_slot->private) 705 return; 706 707 slot = hotplug_slot->private; 708 kfree(slot->hotplug_slot->info); 709 kfree(slot->hotplug_slot); 710 slot->ctrl = NULL; 711 slot->bus_on = NULL; 712 713 /* we don't want to actually remove the resources, since free_resources will do just that */ 714 ibmphp_unconfigure_card(&slot, -1); 715 716 kfree (slot); 717 } 718 719 static struct pci_driver ibmphp_driver; 720 721 /* 722 * map info (ctlr-id, slot count, slot#.. bus count, bus#, ctlr type...) of 723 * each hpc from physical address to a list of hot plug controllers based on 724 * hpc descriptors. 725 */ 726 static int __init ebda_rsrc_controller (void) 727 { 728 u16 addr, addr_slot, addr_bus; 729 u8 ctlr_id, temp, bus_index; 730 u16 ctlr, slot, bus; 731 u16 slot_num, bus_num, index; 732 struct hotplug_slot *hp_slot_ptr; 733 struct controller *hpc_ptr; 734 struct ebda_hpc_bus *bus_ptr; 735 struct ebda_hpc_slot *slot_ptr; 736 struct bus_info *bus_info_ptr1, *bus_info_ptr2; 737 int rc; 738 struct slot *tmp_slot; 739 char name[SLOT_NAME_SIZE]; 740 741 addr = hpc_list_ptr->phys_addr; 742 for (ctlr = 0; ctlr < hpc_list_ptr->num_ctlrs; ctlr++) { 743 bus_index = 1; 744 ctlr_id = readb (io_mem + addr); 745 addr += 1; 746 slot_num = readb (io_mem + addr); 747 748 addr += 1; 749 addr_slot = addr; /* offset of slot structure */ 750 addr += (slot_num * 4); 751 752 bus_num = readb (io_mem + addr); 753 754 addr += 1; 755 addr_bus = addr; /* offset of bus */ 756 addr += (bus_num * 9); /* offset of ctlr_type */ 757 temp = readb (io_mem + addr); 758 759 addr += 1; 760 /* init hpc structure */ 761 hpc_ptr = alloc_ebda_hpc (slot_num, bus_num); 762 if (!hpc_ptr ) { 763 rc = -ENOMEM; 764 goto error_no_hpc; 765 } 766 hpc_ptr->ctlr_id = ctlr_id; 767 hpc_ptr->ctlr_relative_id = ctlr; 768 hpc_ptr->slot_count = slot_num; 769 hpc_ptr->bus_count = bus_num; 770 debug ("now enter ctlr data struture ---\n"); 771 debug ("ctlr id: %x\n", ctlr_id); 772 debug ("ctlr_relative_id: %x\n", hpc_ptr->ctlr_relative_id); 773 debug ("count of slots controlled by this ctlr: %x\n", slot_num); 774 debug ("count of buses controlled by this ctlr: %x\n", bus_num); 775 776 /* init slot structure, fetch slot, bus, cap... */ 777 slot_ptr = hpc_ptr->slots; 778 for (slot = 0; slot < slot_num; slot++) { 779 slot_ptr->slot_num = readb (io_mem + addr_slot); 780 slot_ptr->slot_bus_num = readb (io_mem + addr_slot + slot_num); 781 slot_ptr->ctl_index = readb (io_mem + addr_slot + 2*slot_num); 782 slot_ptr->slot_cap = readb (io_mem + addr_slot + 3*slot_num); 783 784 // create bus_info lined list --- if only one slot per bus: slot_min = slot_max 785 786 bus_info_ptr2 = ibmphp_find_same_bus_num (slot_ptr->slot_bus_num); 787 if (!bus_info_ptr2) { 788 bus_info_ptr1 = kzalloc(sizeof(struct bus_info), GFP_KERNEL); 789 if (!bus_info_ptr1) { 790 rc = -ENOMEM; 791 goto error_no_hp_slot; 792 } 793 bus_info_ptr1->slot_min = slot_ptr->slot_num; 794 bus_info_ptr1->slot_max = slot_ptr->slot_num; 795 bus_info_ptr1->slot_count += 1; 796 bus_info_ptr1->busno = slot_ptr->slot_bus_num; 797 bus_info_ptr1->index = bus_index++; 798 bus_info_ptr1->current_speed = 0xff; 799 bus_info_ptr1->current_bus_mode = 0xff; 800 801 bus_info_ptr1->controller_id = hpc_ptr->ctlr_id; 802 803 list_add_tail (&bus_info_ptr1->bus_info_list, &bus_info_head); 804 805 } else { 806 bus_info_ptr2->slot_min = min (bus_info_ptr2->slot_min, slot_ptr->slot_num); 807 bus_info_ptr2->slot_max = max (bus_info_ptr2->slot_max, slot_ptr->slot_num); 808 bus_info_ptr2->slot_count += 1; 809 810 } 811 812 // end of creating the bus_info linked list 813 814 slot_ptr++; 815 addr_slot += 1; 816 } 817 818 /* init bus structure */ 819 bus_ptr = hpc_ptr->buses; 820 for (bus = 0; bus < bus_num; bus++) { 821 bus_ptr->bus_num = readb (io_mem + addr_bus + bus); 822 bus_ptr->slots_at_33_conv = readb (io_mem + addr_bus + bus_num + 8 * bus); 823 bus_ptr->slots_at_66_conv = readb (io_mem + addr_bus + bus_num + 8 * bus + 1); 824 825 bus_ptr->slots_at_66_pcix = readb (io_mem + addr_bus + bus_num + 8 * bus + 2); 826 827 bus_ptr->slots_at_100_pcix = readb (io_mem + addr_bus + bus_num + 8 * bus + 3); 828 829 bus_ptr->slots_at_133_pcix = readb (io_mem + addr_bus + bus_num + 8 * bus + 4); 830 831 bus_info_ptr2 = ibmphp_find_same_bus_num (bus_ptr->bus_num); 832 if (bus_info_ptr2) { 833 bus_info_ptr2->slots_at_33_conv = bus_ptr->slots_at_33_conv; 834 bus_info_ptr2->slots_at_66_conv = bus_ptr->slots_at_66_conv; 835 bus_info_ptr2->slots_at_66_pcix = bus_ptr->slots_at_66_pcix; 836 bus_info_ptr2->slots_at_100_pcix = bus_ptr->slots_at_100_pcix; 837 bus_info_ptr2->slots_at_133_pcix = bus_ptr->slots_at_133_pcix; 838 } 839 bus_ptr++; 840 } 841 842 hpc_ptr->ctlr_type = temp; 843 844 switch (hpc_ptr->ctlr_type) { 845 case 1: 846 hpc_ptr->u.pci_ctlr.bus = readb (io_mem + addr); 847 hpc_ptr->u.pci_ctlr.dev_fun = readb (io_mem + addr + 1); 848 hpc_ptr->irq = readb (io_mem + addr + 2); 849 addr += 3; 850 debug ("ctrl bus = %x, ctlr devfun = %x, irq = %x\n", 851 hpc_ptr->u.pci_ctlr.bus, 852 hpc_ptr->u.pci_ctlr.dev_fun, hpc_ptr->irq); 853 break; 854 855 case 0: 856 hpc_ptr->u.isa_ctlr.io_start = readw (io_mem + addr); 857 hpc_ptr->u.isa_ctlr.io_end = readw (io_mem + addr + 2); 858 if (!request_region (hpc_ptr->u.isa_ctlr.io_start, 859 (hpc_ptr->u.isa_ctlr.io_end - hpc_ptr->u.isa_ctlr.io_start + 1), 860 "ibmphp")) { 861 rc = -ENODEV; 862 goto error_no_hp_slot; 863 } 864 hpc_ptr->irq = readb (io_mem + addr + 4); 865 addr += 5; 866 break; 867 868 case 2: 869 case 4: 870 hpc_ptr->u.wpeg_ctlr.wpegbbar = readl (io_mem + addr); 871 hpc_ptr->u.wpeg_ctlr.i2c_addr = readb (io_mem + addr + 4); 872 hpc_ptr->irq = readb (io_mem + addr + 5); 873 addr += 6; 874 break; 875 default: 876 rc = -ENODEV; 877 goto error_no_hp_slot; 878 } 879 880 //reorganize chassis' linked list 881 combine_wpg_for_chassis (); 882 combine_wpg_for_expansion (); 883 hpc_ptr->revision = 0xff; 884 hpc_ptr->options = 0xff; 885 hpc_ptr->starting_slot_num = hpc_ptr->slots[0].slot_num; 886 hpc_ptr->ending_slot_num = hpc_ptr->slots[slot_num-1].slot_num; 887 888 // register slots with hpc core as well as create linked list of ibm slot 889 for (index = 0; index < hpc_ptr->slot_count; index++) { 890 891 hp_slot_ptr = kzalloc(sizeof(*hp_slot_ptr), GFP_KERNEL); 892 if (!hp_slot_ptr) { 893 rc = -ENOMEM; 894 goto error_no_hp_slot; 895 } 896 897 hp_slot_ptr->info = kzalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL); 898 if (!hp_slot_ptr->info) { 899 rc = -ENOMEM; 900 goto error_no_hp_info; 901 } 902 903 tmp_slot = kzalloc(sizeof(*tmp_slot), GFP_KERNEL); 904 if (!tmp_slot) { 905 rc = -ENOMEM; 906 goto error_no_slot; 907 } 908 909 tmp_slot->flag = 1; 910 911 tmp_slot->capabilities = hpc_ptr->slots[index].slot_cap; 912 if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_133_MAX) == EBDA_SLOT_133_MAX) 913 tmp_slot->supported_speed = 3; 914 else if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_100_MAX) == EBDA_SLOT_100_MAX) 915 tmp_slot->supported_speed = 2; 916 else if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_66_MAX) == EBDA_SLOT_66_MAX) 917 tmp_slot->supported_speed = 1; 918 919 if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_PCIX_CAP) == EBDA_SLOT_PCIX_CAP) 920 tmp_slot->supported_bus_mode = 1; 921 else 922 tmp_slot->supported_bus_mode = 0; 923 924 925 tmp_slot->bus = hpc_ptr->slots[index].slot_bus_num; 926 927 bus_info_ptr1 = ibmphp_find_same_bus_num (hpc_ptr->slots[index].slot_bus_num); 928 if (!bus_info_ptr1) { 929 kfree(tmp_slot); 930 rc = -ENODEV; 931 goto error; 932 } 933 tmp_slot->bus_on = bus_info_ptr1; 934 bus_info_ptr1 = NULL; 935 tmp_slot->ctrl = hpc_ptr; 936 937 tmp_slot->ctlr_index = hpc_ptr->slots[index].ctl_index; 938 tmp_slot->number = hpc_ptr->slots[index].slot_num; 939 tmp_slot->hotplug_slot = hp_slot_ptr; 940 941 hp_slot_ptr->private = tmp_slot; 942 hp_slot_ptr->release = release_slot; 943 944 rc = fillslotinfo(hp_slot_ptr); 945 if (rc) 946 goto error; 947 948 rc = ibmphp_init_devno ((struct slot **) &hp_slot_ptr->private); 949 if (rc) 950 goto error; 951 hp_slot_ptr->ops = &ibmphp_hotplug_slot_ops; 952 953 // end of registering ibm slot with hotplug core 954 955 list_add (& ((struct slot *)(hp_slot_ptr->private))->ibm_slot_list, &ibmphp_slot_head); 956 } 957 958 print_bus_info (); 959 list_add (&hpc_ptr->ebda_hpc_list, &ebda_hpc_head ); 960 961 } /* each hpc */ 962 963 list_for_each_entry(tmp_slot, &ibmphp_slot_head, ibm_slot_list) { 964 snprintf(name, SLOT_NAME_SIZE, "%s", create_file_name(tmp_slot)); 965 pci_hp_register(tmp_slot->hotplug_slot, 966 pci_find_bus(0, tmp_slot->bus), tmp_slot->device, name); 967 } 968 969 print_ebda_hpc (); 970 print_ibm_slot (); 971 return 0; 972 973 error: 974 kfree (hp_slot_ptr->private); 975 error_no_slot: 976 kfree (hp_slot_ptr->info); 977 error_no_hp_info: 978 kfree (hp_slot_ptr); 979 error_no_hp_slot: 980 free_ebda_hpc (hpc_ptr); 981 error_no_hpc: 982 iounmap (io_mem); 983 return rc; 984 } 985 986 /* 987 * map info (bus, devfun, start addr, end addr..) of i/o, memory, 988 * pfm from the physical addr to a list of resource. 989 */ 990 static int __init ebda_rsrc_rsrc (void) 991 { 992 u16 addr; 993 short rsrc; 994 u8 type, rsrc_type; 995 struct ebda_pci_rsrc *rsrc_ptr; 996 997 addr = rsrc_list_ptr->phys_addr; 998 debug ("now entering rsrc land\n"); 999 debug ("offset of rsrc: %x\n", rsrc_list_ptr->phys_addr); 1000 1001 for (rsrc = 0; rsrc < rsrc_list_ptr->num_entries; rsrc++) { 1002 type = readb (io_mem + addr); 1003 1004 addr += 1; 1005 rsrc_type = type & EBDA_RSRC_TYPE_MASK; 1006 1007 if (rsrc_type == EBDA_IO_RSRC_TYPE) { 1008 rsrc_ptr = alloc_ebda_pci_rsrc (); 1009 if (!rsrc_ptr) { 1010 iounmap (io_mem); 1011 return -ENOMEM; 1012 } 1013 rsrc_ptr->rsrc_type = type; 1014 1015 rsrc_ptr->bus_num = readb (io_mem + addr); 1016 rsrc_ptr->dev_fun = readb (io_mem + addr + 1); 1017 rsrc_ptr->start_addr = readw (io_mem + addr + 2); 1018 rsrc_ptr->end_addr = readw (io_mem + addr + 4); 1019 addr += 6; 1020 1021 debug ("rsrc from io type ----\n"); 1022 debug ("rsrc type: %x bus#: %x dev_func: %x start addr: %x end addr: %x\n", 1023 rsrc_ptr->rsrc_type, rsrc_ptr->bus_num, rsrc_ptr->dev_fun, rsrc_ptr->start_addr, rsrc_ptr->end_addr); 1024 1025 list_add (&rsrc_ptr->ebda_pci_rsrc_list, &ibmphp_ebda_pci_rsrc_head); 1026 } 1027 1028 if (rsrc_type == EBDA_MEM_RSRC_TYPE || rsrc_type == EBDA_PFM_RSRC_TYPE) { 1029 rsrc_ptr = alloc_ebda_pci_rsrc (); 1030 if (!rsrc_ptr ) { 1031 iounmap (io_mem); 1032 return -ENOMEM; 1033 } 1034 rsrc_ptr->rsrc_type = type; 1035 1036 rsrc_ptr->bus_num = readb (io_mem + addr); 1037 rsrc_ptr->dev_fun = readb (io_mem + addr + 1); 1038 rsrc_ptr->start_addr = readl (io_mem + addr + 2); 1039 rsrc_ptr->end_addr = readl (io_mem + addr + 6); 1040 addr += 10; 1041 1042 debug ("rsrc from mem or pfm ---\n"); 1043 debug ("rsrc type: %x bus#: %x dev_func: %x start addr: %x end addr: %x\n", 1044 rsrc_ptr->rsrc_type, rsrc_ptr->bus_num, rsrc_ptr->dev_fun, rsrc_ptr->start_addr, rsrc_ptr->end_addr); 1045 1046 list_add (&rsrc_ptr->ebda_pci_rsrc_list, &ibmphp_ebda_pci_rsrc_head); 1047 } 1048 } 1049 kfree (rsrc_list_ptr); 1050 rsrc_list_ptr = NULL; 1051 print_ebda_pci_rsrc (); 1052 return 0; 1053 } 1054 1055 u16 ibmphp_get_total_controllers (void) 1056 { 1057 return hpc_list_ptr->num_ctlrs; 1058 } 1059 1060 struct slot *ibmphp_get_slot_from_physical_num (u8 physical_num) 1061 { 1062 struct slot *slot; 1063 1064 list_for_each_entry(slot, &ibmphp_slot_head, ibm_slot_list) { 1065 if (slot->number == physical_num) 1066 return slot; 1067 } 1068 return NULL; 1069 } 1070 1071 /* To find: 1072 * - the smallest slot number 1073 * - the largest slot number 1074 * - the total number of the slots based on each bus 1075 * (if only one slot per bus slot_min = slot_max ) 1076 */ 1077 struct bus_info *ibmphp_find_same_bus_num (u32 num) 1078 { 1079 struct bus_info *ptr; 1080 1081 list_for_each_entry(ptr, &bus_info_head, bus_info_list) { 1082 if (ptr->busno == num) 1083 return ptr; 1084 } 1085 return NULL; 1086 } 1087 1088 /* Finding relative bus number, in order to map corresponding 1089 * bus register 1090 */ 1091 int ibmphp_get_bus_index (u8 num) 1092 { 1093 struct bus_info *ptr; 1094 1095 list_for_each_entry(ptr, &bus_info_head, bus_info_list) { 1096 if (ptr->busno == num) 1097 return ptr->index; 1098 } 1099 return -ENODEV; 1100 } 1101 1102 void ibmphp_free_bus_info_queue (void) 1103 { 1104 struct bus_info *bus_info; 1105 struct list_head *list; 1106 struct list_head *next; 1107 1108 list_for_each_safe (list, next, &bus_info_head ) { 1109 bus_info = list_entry (list, struct bus_info, bus_info_list); 1110 kfree (bus_info); 1111 } 1112 } 1113 1114 void ibmphp_free_ebda_hpc_queue (void) 1115 { 1116 struct controller *controller = NULL; 1117 struct list_head *list; 1118 struct list_head *next; 1119 int pci_flag = 0; 1120 1121 list_for_each_safe (list, next, &ebda_hpc_head) { 1122 controller = list_entry (list, struct controller, ebda_hpc_list); 1123 if (controller->ctlr_type == 0) 1124 release_region (controller->u.isa_ctlr.io_start, (controller->u.isa_ctlr.io_end - controller->u.isa_ctlr.io_start + 1)); 1125 else if ((controller->ctlr_type == 1) && (!pci_flag)) { 1126 ++pci_flag; 1127 pci_unregister_driver (&ibmphp_driver); 1128 } 1129 free_ebda_hpc (controller); 1130 } 1131 } 1132 1133 void ibmphp_free_ebda_pci_rsrc_queue (void) 1134 { 1135 struct ebda_pci_rsrc *resource; 1136 struct list_head *list; 1137 struct list_head *next; 1138 1139 list_for_each_safe (list, next, &ibmphp_ebda_pci_rsrc_head) { 1140 resource = list_entry (list, struct ebda_pci_rsrc, ebda_pci_rsrc_list); 1141 kfree (resource); 1142 resource = NULL; 1143 } 1144 } 1145 1146 static struct pci_device_id id_table[] = { 1147 { 1148 .vendor = PCI_VENDOR_ID_IBM, 1149 .device = HPC_DEVICE_ID, 1150 .subvendor = PCI_VENDOR_ID_IBM, 1151 .subdevice = HPC_SUBSYSTEM_ID, 1152 .class = ((PCI_CLASS_SYSTEM_PCI_HOTPLUG << 8) | 0x00), 1153 }, {} 1154 }; 1155 1156 MODULE_DEVICE_TABLE(pci, id_table); 1157 1158 static int ibmphp_probe (struct pci_dev *, const struct pci_device_id *); 1159 static struct pci_driver ibmphp_driver = { 1160 .name = "ibmphp", 1161 .id_table = id_table, 1162 .probe = ibmphp_probe, 1163 }; 1164 1165 int ibmphp_register_pci (void) 1166 { 1167 struct controller *ctrl; 1168 int rc = 0; 1169 1170 list_for_each_entry(ctrl, &ebda_hpc_head, ebda_hpc_list) { 1171 if (ctrl->ctlr_type == 1) { 1172 rc = pci_register_driver(&ibmphp_driver); 1173 break; 1174 } 1175 } 1176 return rc; 1177 } 1178 static int ibmphp_probe (struct pci_dev * dev, const struct pci_device_id *ids) 1179 { 1180 struct controller *ctrl; 1181 1182 debug ("inside ibmphp_probe\n"); 1183 1184 list_for_each_entry(ctrl, &ebda_hpc_head, ebda_hpc_list) { 1185 if (ctrl->ctlr_type == 1) { 1186 if ((dev->devfn == ctrl->u.pci_ctlr.dev_fun) && (dev->bus->number == ctrl->u.pci_ctlr.bus)) { 1187 ctrl->ctrl_dev = dev; 1188 debug ("found device!!!\n"); 1189 debug ("dev->device = %x, dev->subsystem_device = %x\n", dev->device, dev->subsystem_device); 1190 return 0; 1191 } 1192 } 1193 } 1194 return -ENODEV; 1195 } 1196 1197