1 /* 2 * PCI Express Hot Plug Controller Driver 3 * 4 * Copyright (C) 1995,2001 Compaq Computer Corporation 5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com) 6 * Copyright (C) 2001 IBM Corp. 7 * Copyright (C) 2003-2004 Intel Corporation 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 <greg@kroah.com>, <kristen.c.accardi@intel.com> 27 * 28 */ 29 30 #include <linux/module.h> 31 #include <linux/moduleparam.h> 32 #include <linux/kernel.h> 33 #include <linux/types.h> 34 #include <linux/pci.h> 35 #include "pciehp.h" 36 #include <linux/interrupt.h> 37 38 /* Global variables */ 39 int pciehp_debug; 40 int pciehp_poll_mode; 41 int pciehp_poll_time; 42 int pciehp_force; 43 struct controller *pciehp_ctrl_list; 44 45 #define DRIVER_VERSION "0.4" 46 #define DRIVER_AUTHOR "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>" 47 #define DRIVER_DESC "PCI Express Hot Plug Controller Driver" 48 49 MODULE_AUTHOR(DRIVER_AUTHOR); 50 MODULE_DESCRIPTION(DRIVER_DESC); 51 MODULE_LICENSE("GPL"); 52 53 module_param(pciehp_debug, bool, 0644); 54 module_param(pciehp_poll_mode, bool, 0644); 55 module_param(pciehp_poll_time, int, 0644); 56 module_param(pciehp_force, bool, 0644); 57 MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not"); 58 MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not"); 59 MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds"); 60 MODULE_PARM_DESC(pciehp_force, "Force pciehp, even if _OSC and OSHP are missing"); 61 62 #define PCIE_MODULE_NAME "pciehp" 63 64 static int pcie_start_thread (void); 65 static int set_attention_status (struct hotplug_slot *slot, u8 value); 66 static int enable_slot (struct hotplug_slot *slot); 67 static int disable_slot (struct hotplug_slot *slot); 68 static int get_power_status (struct hotplug_slot *slot, u8 *value); 69 static int get_attention_status (struct hotplug_slot *slot, u8 *value); 70 static int get_latch_status (struct hotplug_slot *slot, u8 *value); 71 static int get_adapter_status (struct hotplug_slot *slot, u8 *value); 72 static int get_max_bus_speed (struct hotplug_slot *slot, enum pci_bus_speed *value); 73 static int get_cur_bus_speed (struct hotplug_slot *slot, enum pci_bus_speed *value); 74 75 static struct hotplug_slot_ops pciehp_hotplug_slot_ops = { 76 .owner = THIS_MODULE, 77 .set_attention_status = set_attention_status, 78 .enable_slot = enable_slot, 79 .disable_slot = disable_slot, 80 .get_power_status = get_power_status, 81 .get_attention_status = get_attention_status, 82 .get_latch_status = get_latch_status, 83 .get_adapter_status = get_adapter_status, 84 .get_max_bus_speed = get_max_bus_speed, 85 .get_cur_bus_speed = get_cur_bus_speed, 86 }; 87 88 /** 89 * release_slot - free up the memory used by a slot 90 * @hotplug_slot: slot to free 91 */ 92 static void release_slot(struct hotplug_slot *hotplug_slot) 93 { 94 struct slot *slot = hotplug_slot->private; 95 96 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 97 98 kfree(slot->hotplug_slot->info); 99 kfree(slot->hotplug_slot->name); 100 kfree(slot->hotplug_slot); 101 kfree(slot); 102 } 103 104 static int init_slots(struct controller *ctrl) 105 { 106 struct slot *slot; 107 struct hpc_ops *hpc_ops; 108 struct hotplug_slot *hotplug_slot; 109 struct hotplug_slot_info *hotplug_slot_info; 110 u8 number_of_slots; 111 u8 slot_device; 112 u32 slot_number; 113 int result = -ENOMEM; 114 115 number_of_slots = ctrl->num_slots; 116 slot_device = ctrl->slot_device_offset; 117 slot_number = ctrl->first_slot; 118 119 while (number_of_slots) { 120 slot = kzalloc(sizeof(*slot), GFP_KERNEL); 121 if (!slot) 122 goto error; 123 124 slot->hotplug_slot = 125 kzalloc(sizeof(*(slot->hotplug_slot)), 126 GFP_KERNEL); 127 if (!slot->hotplug_slot) 128 goto error_slot; 129 hotplug_slot = slot->hotplug_slot; 130 131 hotplug_slot->info = 132 kzalloc(sizeof(*(hotplug_slot->info)), 133 GFP_KERNEL); 134 if (!hotplug_slot->info) 135 goto error_hpslot; 136 hotplug_slot_info = hotplug_slot->info; 137 hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL); 138 if (!hotplug_slot->name) 139 goto error_info; 140 141 slot->ctrl = ctrl; 142 slot->bus = ctrl->slot_bus; 143 slot->device = slot_device; 144 slot->hpc_ops = hpc_ops = ctrl->hpc_ops; 145 146 slot->number = ctrl->first_slot; 147 slot->hp_slot = slot_device - ctrl->slot_device_offset; 148 149 /* register this slot with the hotplug pci core */ 150 hotplug_slot->private = slot; 151 hotplug_slot->release = &release_slot; 152 make_slot_name(hotplug_slot->name, SLOT_NAME_SIZE, slot); 153 hotplug_slot->ops = &pciehp_hotplug_slot_ops; 154 155 hpc_ops->get_power_status(slot, 156 &(hotplug_slot_info->power_status)); 157 hpc_ops->get_attention_status(slot, 158 &(hotplug_slot_info->attention_status)); 159 hpc_ops->get_latch_status(slot, 160 &(hotplug_slot_info->latch_status)); 161 hpc_ops->get_adapter_status(slot, 162 &(hotplug_slot_info->adapter_status)); 163 164 dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x " 165 "slot_device_offset=%x\n", 166 slot->bus, slot->device, slot->hp_slot, slot->number, 167 ctrl->slot_device_offset); 168 result = pci_hp_register(hotplug_slot); 169 if (result) { 170 err ("pci_hp_register failed with error %d\n", result); 171 goto error_name; 172 } 173 174 slot->next = ctrl->slot; 175 ctrl->slot = slot; 176 177 number_of_slots--; 178 slot_device++; 179 slot_number += ctrl->slot_num_inc; 180 } 181 182 return 0; 183 184 error_name: 185 kfree(hotplug_slot->name); 186 error_info: 187 kfree(hotplug_slot_info); 188 error_hpslot: 189 kfree(hotplug_slot); 190 error_slot: 191 kfree(slot); 192 error: 193 return result; 194 } 195 196 197 static int cleanup_slots (struct controller * ctrl) 198 { 199 struct slot *old_slot, *next_slot; 200 201 old_slot = ctrl->slot; 202 ctrl->slot = NULL; 203 204 while (old_slot) { 205 next_slot = old_slot->next; 206 pci_hp_deregister (old_slot->hotplug_slot); 207 old_slot = next_slot; 208 } 209 210 211 return(0); 212 } 213 214 static int get_ctlr_slot_config(struct controller *ctrl) 215 { 216 int num_ctlr_slots; /* Not needed; PCI Express has 1 slot per port*/ 217 int first_device_num; /* Not needed */ 218 int physical_slot_num; 219 u8 ctrlcap; 220 int rc; 221 222 rc = pcie_get_ctlr_slot_config(ctrl, &num_ctlr_slots, &first_device_num, &physical_slot_num, &ctrlcap); 223 if (rc) { 224 err("%s: get_ctlr_slot_config fail for b:d (%x:%x)\n", __FUNCTION__, ctrl->bus, ctrl->device); 225 return (-1); 226 } 227 228 ctrl->num_slots = num_ctlr_slots; /* PCI Express has 1 slot per port */ 229 ctrl->slot_device_offset = first_device_num; 230 ctrl->first_slot = physical_slot_num; 231 ctrl->ctrlcap = ctrlcap; 232 233 dbg("%s: bus(0x%x) num_slot(0x%x) 1st_dev(0x%x) psn(0x%x) ctrlcap(%x) for b:d (%x:%x)\n", 234 __FUNCTION__, ctrl->slot_bus, num_ctlr_slots, first_device_num, physical_slot_num, ctrlcap, 235 ctrl->bus, ctrl->device); 236 237 return (0); 238 } 239 240 241 /* 242 * set_attention_status - Turns the Amber LED for a slot on, off or blink 243 */ 244 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status) 245 { 246 struct slot *slot = hotplug_slot->private; 247 248 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 249 250 hotplug_slot->info->attention_status = status; 251 252 if (ATTN_LED(slot->ctrl->ctrlcap)) 253 slot->hpc_ops->set_attention_status(slot, status); 254 255 return 0; 256 } 257 258 259 static int enable_slot(struct hotplug_slot *hotplug_slot) 260 { 261 struct slot *slot = hotplug_slot->private; 262 263 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 264 265 return pciehp_enable_slot(slot); 266 } 267 268 269 static int disable_slot(struct hotplug_slot *hotplug_slot) 270 { 271 struct slot *slot = hotplug_slot->private; 272 273 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 274 275 return pciehp_disable_slot(slot); 276 } 277 278 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value) 279 { 280 struct slot *slot = hotplug_slot->private; 281 int retval; 282 283 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 284 285 retval = slot->hpc_ops->get_power_status(slot, value); 286 if (retval < 0) 287 *value = hotplug_slot->info->power_status; 288 289 return 0; 290 } 291 292 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value) 293 { 294 struct slot *slot = hotplug_slot->private; 295 int retval; 296 297 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 298 299 retval = slot->hpc_ops->get_attention_status(slot, value); 300 if (retval < 0) 301 *value = hotplug_slot->info->attention_status; 302 303 return 0; 304 } 305 306 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value) 307 { 308 struct slot *slot = hotplug_slot->private; 309 int retval; 310 311 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 312 313 retval = slot->hpc_ops->get_latch_status(slot, value); 314 if (retval < 0) 315 *value = hotplug_slot->info->latch_status; 316 317 return 0; 318 } 319 320 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value) 321 { 322 struct slot *slot = hotplug_slot->private; 323 int retval; 324 325 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 326 327 retval = slot->hpc_ops->get_adapter_status(slot, value); 328 if (retval < 0) 329 *value = hotplug_slot->info->adapter_status; 330 331 return 0; 332 } 333 334 static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value) 335 { 336 struct slot *slot = hotplug_slot->private; 337 int retval; 338 339 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 340 341 retval = slot->hpc_ops->get_max_bus_speed(slot, value); 342 if (retval < 0) 343 *value = PCI_SPEED_UNKNOWN; 344 345 return 0; 346 } 347 348 static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value) 349 { 350 struct slot *slot = hotplug_slot->private; 351 int retval; 352 353 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name); 354 355 retval = slot->hpc_ops->get_cur_bus_speed(slot, value); 356 if (retval < 0) 357 *value = PCI_SPEED_UNKNOWN; 358 359 return 0; 360 } 361 362 static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_id *id) 363 { 364 int rc; 365 struct controller *ctrl; 366 struct slot *t_slot; 367 int first_device_num = 0 ; /* first PCI device number supported by this PCIE */ 368 int num_ctlr_slots; /* number of slots supported by this HPC */ 369 u8 value; 370 struct pci_dev *pdev; 371 372 ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL); 373 if (!ctrl) { 374 err("%s : out of memory\n", __FUNCTION__); 375 goto err_out_none; 376 } 377 378 pdev = dev->port; 379 ctrl->pci_dev = pdev; 380 381 rc = pcie_init(ctrl, dev); 382 if (rc) { 383 dbg("%s: controller initialization failed\n", PCIE_MODULE_NAME); 384 goto err_out_free_ctrl; 385 } 386 387 pci_set_drvdata(pdev, ctrl); 388 389 ctrl->pci_bus = kmalloc(sizeof(*ctrl->pci_bus), GFP_KERNEL); 390 if (!ctrl->pci_bus) { 391 err("%s: out of memory\n", __FUNCTION__); 392 rc = -ENOMEM; 393 goto err_out_unmap_mmio_region; 394 } 395 memcpy (ctrl->pci_bus, pdev->bus, sizeof (*ctrl->pci_bus)); 396 ctrl->bus = pdev->bus->number; /* ctrl bus */ 397 ctrl->slot_bus = pdev->subordinate->number; /* bus controlled by this HPC */ 398 399 ctrl->device = PCI_SLOT(pdev->devfn); 400 ctrl->function = PCI_FUNC(pdev->devfn); 401 dbg("%s: ctrl bus=0x%x, device=%x, function=%x, irq=%x\n", __FUNCTION__, 402 ctrl->bus, ctrl->device, ctrl->function, pdev->irq); 403 404 /* 405 * Save configuration headers for this and subordinate PCI buses 406 */ 407 408 rc = get_ctlr_slot_config(ctrl); 409 if (rc) { 410 err(msg_initialization_err, rc); 411 goto err_out_free_ctrl_bus; 412 } 413 first_device_num = ctrl->slot_device_offset; 414 num_ctlr_slots = ctrl->num_slots; 415 416 /* Setup the slot information structures */ 417 rc = init_slots(ctrl); 418 if (rc) { 419 err(msg_initialization_err, 6); 420 goto err_out_free_ctrl_slot; 421 } 422 423 t_slot = pciehp_find_slot(ctrl, first_device_num); 424 425 /* Finish setting up the hot plug ctrl device */ 426 ctrl->next_event = 0; 427 428 if (!pciehp_ctrl_list) { 429 pciehp_ctrl_list = ctrl; 430 ctrl->next = NULL; 431 } else { 432 ctrl->next = pciehp_ctrl_list; 433 pciehp_ctrl_list = ctrl; 434 } 435 436 /* Wait for exclusive access to hardware */ 437 mutex_lock(&ctrl->crit_sect); 438 439 t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */ 440 441 if ((POWER_CTRL(ctrl->ctrlcap)) && !value) { 442 rc = t_slot->hpc_ops->power_off_slot(t_slot); /* Power off slot if not occupied*/ 443 if (rc) { 444 /* Done with exclusive hardware access */ 445 mutex_unlock(&ctrl->crit_sect); 446 goto err_out_free_ctrl_slot; 447 } else 448 /* Wait for the command to complete */ 449 wait_for_ctrl_irq (ctrl); 450 } 451 452 /* Done with exclusive hardware access */ 453 mutex_unlock(&ctrl->crit_sect); 454 455 return 0; 456 457 err_out_free_ctrl_slot: 458 cleanup_slots(ctrl); 459 err_out_free_ctrl_bus: 460 kfree(ctrl->pci_bus); 461 err_out_unmap_mmio_region: 462 ctrl->hpc_ops->release_ctlr(ctrl); 463 err_out_free_ctrl: 464 kfree(ctrl); 465 err_out_none: 466 return -ENODEV; 467 } 468 469 470 static int pcie_start_thread(void) 471 { 472 int retval = 0; 473 474 dbg("Initialize + Start the notification/polling mechanism \n"); 475 476 retval = pciehp_event_start_thread(); 477 if (retval) { 478 dbg("pciehp_event_start_thread() failed\n"); 479 return retval; 480 } 481 482 return retval; 483 } 484 485 static void __exit unload_pciehpd(void) 486 { 487 struct controller *ctrl; 488 struct controller *tctrl; 489 490 ctrl = pciehp_ctrl_list; 491 492 while (ctrl) { 493 cleanup_slots(ctrl); 494 495 kfree (ctrl->pci_bus); 496 497 ctrl->hpc_ops->release_ctlr(ctrl); 498 499 tctrl = ctrl; 500 ctrl = ctrl->next; 501 502 kfree(tctrl); 503 } 504 505 /* Stop the notification mechanism */ 506 pciehp_event_stop_thread(); 507 508 } 509 510 static int hpdriver_context = 0; 511 512 static void pciehp_remove (struct pcie_device *device) 513 { 514 printk("%s ENTRY\n", __FUNCTION__); 515 printk("%s -> Call free_irq for irq = %d\n", 516 __FUNCTION__, device->irq); 517 free_irq(device->irq, &hpdriver_context); 518 } 519 520 #ifdef CONFIG_PM 521 static int pciehp_suspend (struct pcie_device *dev, pm_message_t state) 522 { 523 printk("%s ENTRY\n", __FUNCTION__); 524 return 0; 525 } 526 527 static int pciehp_resume (struct pcie_device *dev) 528 { 529 printk("%s ENTRY\n", __FUNCTION__); 530 return 0; 531 } 532 #endif 533 534 static struct pcie_port_service_id port_pci_ids[] = { { 535 .vendor = PCI_ANY_ID, 536 .device = PCI_ANY_ID, 537 .port_type = PCIE_ANY_PORT, 538 .service_type = PCIE_PORT_SERVICE_HP, 539 .driver_data = 0, 540 }, { /* end: all zeroes */ } 541 }; 542 static const char device_name[] = "hpdriver"; 543 544 static struct pcie_port_service_driver hpdriver_portdrv = { 545 .name = (char *)device_name, 546 .id_table = &port_pci_ids[0], 547 548 .probe = pciehp_probe, 549 .remove = pciehp_remove, 550 551 #ifdef CONFIG_PM 552 .suspend = pciehp_suspend, 553 .resume = pciehp_resume, 554 #endif /* PM */ 555 }; 556 557 static int __init pcied_init(void) 558 { 559 int retval = 0; 560 561 #ifdef CONFIG_HOTPLUG_PCI_PCIE_POLL_EVENT_MODE 562 pciehp_poll_mode = 1; 563 #endif 564 565 retval = pcie_start_thread(); 566 if (retval) 567 goto error_hpc_init; 568 569 retval = pcie_port_service_register(&hpdriver_portdrv); 570 dbg("pcie_port_service_register = %d\n", retval); 571 info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); 572 if (retval) 573 dbg("%s: Failure to register service\n", __FUNCTION__); 574 575 error_hpc_init: 576 if (retval) { 577 pciehp_event_stop_thread(); 578 }; 579 580 return retval; 581 } 582 583 static void __exit pcied_cleanup(void) 584 { 585 dbg("unload_pciehpd()\n"); 586 unload_pciehpd(); 587 588 pcie_port_service_unregister(&hpdriver_portdrv); 589 590 info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n"); 591 } 592 593 module_init(pcied_init); 594 module_exit(pcied_cleanup); 595