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