1 /* 2 * Standard 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/kernel.h> 32 #include <linux/types.h> 33 #include <linux/slab.h> 34 #include <linux/pci.h> 35 #include "../pci.h" 36 #include "shpchp.h" 37 38 static void interrupt_event_handler(struct work_struct *work); 39 static int shpchp_enable_slot(struct slot *p_slot); 40 static int shpchp_disable_slot(struct slot *p_slot); 41 42 static int queue_interrupt_event(struct slot *p_slot, u32 event_type) 43 { 44 struct event_info *info; 45 46 info = kmalloc(sizeof(*info), GFP_ATOMIC); 47 if (!info) 48 return -ENOMEM; 49 50 info->event_type = event_type; 51 info->p_slot = p_slot; 52 INIT_WORK(&info->work, interrupt_event_handler); 53 54 queue_work(p_slot->wq, &info->work); 55 56 return 0; 57 } 58 59 u8 shpchp_handle_attention_button(u8 hp_slot, struct controller *ctrl) 60 { 61 struct slot *p_slot; 62 u32 event_type; 63 64 /* Attention Button Change */ 65 ctrl_dbg(ctrl, "Attention button interrupt received\n"); 66 67 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 68 p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save)); 69 70 /* 71 * Button pressed - See if need to TAKE ACTION!!! 72 */ 73 ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot)); 74 event_type = INT_BUTTON_PRESS; 75 76 queue_interrupt_event(p_slot, event_type); 77 78 return 0; 79 80 } 81 82 u8 shpchp_handle_switch_change(u8 hp_slot, struct controller *ctrl) 83 { 84 struct slot *p_slot; 85 u8 getstatus; 86 u32 event_type; 87 88 /* Switch Change */ 89 ctrl_dbg(ctrl, "Switch interrupt received\n"); 90 91 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 92 p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save)); 93 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 94 ctrl_dbg(ctrl, "Card present %x Power status %x\n", 95 p_slot->presence_save, p_slot->pwr_save); 96 97 if (getstatus) { 98 /* 99 * Switch opened 100 */ 101 ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot)); 102 event_type = INT_SWITCH_OPEN; 103 if (p_slot->pwr_save && p_slot->presence_save) { 104 event_type = INT_POWER_FAULT; 105 ctrl_err(ctrl, "Surprise Removal of card\n"); 106 } 107 } else { 108 /* 109 * Switch closed 110 */ 111 ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot)); 112 event_type = INT_SWITCH_CLOSE; 113 } 114 115 queue_interrupt_event(p_slot, event_type); 116 117 return 1; 118 } 119 120 u8 shpchp_handle_presence_change(u8 hp_slot, struct controller *ctrl) 121 { 122 struct slot *p_slot; 123 u32 event_type; 124 125 /* Presence Change */ 126 ctrl_dbg(ctrl, "Presence/Notify input change\n"); 127 128 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 129 130 /* 131 * Save the presence state 132 */ 133 p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save)); 134 if (p_slot->presence_save) { 135 /* 136 * Card Present 137 */ 138 ctrl_info(ctrl, "Card present on Slot(%s)\n", 139 slot_name(p_slot)); 140 event_type = INT_PRESENCE_ON; 141 } else { 142 /* 143 * Not Present 144 */ 145 ctrl_info(ctrl, "Card not present on Slot(%s)\n", 146 slot_name(p_slot)); 147 event_type = INT_PRESENCE_OFF; 148 } 149 150 queue_interrupt_event(p_slot, event_type); 151 152 return 1; 153 } 154 155 u8 shpchp_handle_power_fault(u8 hp_slot, struct controller *ctrl) 156 { 157 struct slot *p_slot; 158 u32 event_type; 159 160 /* Power fault */ 161 ctrl_dbg(ctrl, "Power fault interrupt received\n"); 162 163 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 164 165 if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) { 166 /* 167 * Power fault Cleared 168 */ 169 ctrl_info(ctrl, "Power fault cleared on Slot(%s)\n", 170 slot_name(p_slot)); 171 p_slot->status = 0x00; 172 event_type = INT_POWER_FAULT_CLEAR; 173 } else { 174 /* 175 * Power fault 176 */ 177 ctrl_info(ctrl, "Power fault on Slot(%s)\n", slot_name(p_slot)); 178 event_type = INT_POWER_FAULT; 179 /* set power fault status for this board */ 180 p_slot->status = 0xFF; 181 ctrl_info(ctrl, "Power fault bit %x set\n", hp_slot); 182 } 183 184 queue_interrupt_event(p_slot, event_type); 185 186 return 1; 187 } 188 189 /* The following routines constitute the bulk of the 190 hotplug controller logic 191 */ 192 static int change_bus_speed(struct controller *ctrl, struct slot *p_slot, 193 enum pci_bus_speed speed) 194 { 195 int rc = 0; 196 197 ctrl_dbg(ctrl, "Change speed to %d\n", speed); 198 if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, speed))) { 199 ctrl_err(ctrl, "%s: Issue of set bus speed mode command " 200 "failed\n", __func__); 201 return WRONG_BUS_FREQUENCY; 202 } 203 return rc; 204 } 205 206 static int fix_bus_speed(struct controller *ctrl, struct slot *pslot, 207 u8 flag, enum pci_bus_speed asp, enum pci_bus_speed bsp, 208 enum pci_bus_speed msp) 209 { 210 int rc = 0; 211 212 /* 213 * If other slots on the same bus are occupied, we cannot 214 * change the bus speed. 215 */ 216 if (flag) { 217 if (asp < bsp) { 218 ctrl_err(ctrl, "Speed of bus %x and adapter %x " 219 "mismatch\n", bsp, asp); 220 rc = WRONG_BUS_FREQUENCY; 221 } 222 return rc; 223 } 224 225 if (asp < msp) { 226 if (bsp != asp) 227 rc = change_bus_speed(ctrl, pslot, asp); 228 } else { 229 if (bsp != msp) 230 rc = change_bus_speed(ctrl, pslot, msp); 231 } 232 return rc; 233 } 234 235 /** 236 * board_added - Called after a board has been added to the system. 237 * @p_slot: target &slot 238 * 239 * Turns power on for the board. 240 * Configures board. 241 */ 242 static int board_added(struct slot *p_slot) 243 { 244 u8 hp_slot; 245 u8 slots_not_empty = 0; 246 int rc = 0; 247 enum pci_bus_speed asp, bsp, msp; 248 struct controller *ctrl = p_slot->ctrl; 249 struct pci_bus *parent = ctrl->pci_dev->subordinate; 250 251 hp_slot = p_slot->device - ctrl->slot_device_offset; 252 253 ctrl_dbg(ctrl, 254 "%s: p_slot->device, slot_offset, hp_slot = %d, %d ,%d\n", 255 __func__, p_slot->device, ctrl->slot_device_offset, hp_slot); 256 257 /* Power on slot without connecting to bus */ 258 rc = p_slot->hpc_ops->power_on_slot(p_slot); 259 if (rc) { 260 ctrl_err(ctrl, "Failed to power on slot\n"); 261 return -1; 262 } 263 264 if ((ctrl->pci_dev->vendor == 0x8086) && (ctrl->pci_dev->device == 0x0332)) { 265 if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, PCI_SPEED_33MHz))) { 266 ctrl_err(ctrl, "%s: Issue of set bus speed mode command" 267 " failed\n", __func__); 268 return WRONG_BUS_FREQUENCY; 269 } 270 271 /* turn on board, blink green LED, turn off Amber LED */ 272 if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) { 273 ctrl_err(ctrl, "Issue of Slot Enable command failed\n"); 274 return rc; 275 } 276 } 277 278 rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &asp); 279 if (rc) { 280 ctrl_err(ctrl, "Can't get adapter speed or " 281 "bus mode mismatch\n"); 282 return WRONG_BUS_FREQUENCY; 283 } 284 285 bsp = ctrl->pci_dev->bus->cur_bus_speed; 286 msp = ctrl->pci_dev->bus->max_bus_speed; 287 288 /* Check if there are other slots or devices on the same bus */ 289 if (!list_empty(&ctrl->pci_dev->subordinate->devices)) 290 slots_not_empty = 1; 291 292 ctrl_dbg(ctrl, "%s: slots_not_empty %d, adapter_speed %d, bus_speed %d," 293 " max_bus_speed %d\n", __func__, slots_not_empty, asp, 294 bsp, msp); 295 296 rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, asp, bsp, msp); 297 if (rc) 298 return rc; 299 300 /* turn on board, blink green LED, turn off Amber LED */ 301 if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) { 302 ctrl_err(ctrl, "Issue of Slot Enable command failed\n"); 303 return rc; 304 } 305 306 /* Wait for ~1 second */ 307 msleep(1000); 308 309 ctrl_dbg(ctrl, "%s: slot status = %x\n", __func__, p_slot->status); 310 /* Check for a power fault */ 311 if (p_slot->status == 0xFF) { 312 /* power fault occurred, but it was benign */ 313 ctrl_dbg(ctrl, "%s: Power fault\n", __func__); 314 rc = POWER_FAILURE; 315 p_slot->status = 0; 316 goto err_exit; 317 } 318 319 if (shpchp_configure_device(p_slot)) { 320 ctrl_err(ctrl, "Cannot add device at %04x:%02x:%02x\n", 321 pci_domain_nr(parent), p_slot->bus, p_slot->device); 322 goto err_exit; 323 } 324 325 p_slot->status = 0; 326 p_slot->is_a_board = 0x01; 327 p_slot->pwr_save = 1; 328 329 p_slot->hpc_ops->green_led_on(p_slot); 330 331 return 0; 332 333 err_exit: 334 /* turn off slot, turn on Amber LED, turn off Green LED */ 335 rc = p_slot->hpc_ops->slot_disable(p_slot); 336 if (rc) { 337 ctrl_err(ctrl, "%s: Issue of Slot Disable command failed\n", 338 __func__); 339 return rc; 340 } 341 342 return(rc); 343 } 344 345 346 /** 347 * remove_board - Turns off slot and LEDs 348 * @p_slot: target &slot 349 */ 350 static int remove_board(struct slot *p_slot) 351 { 352 struct controller *ctrl = p_slot->ctrl; 353 u8 hp_slot; 354 int rc; 355 356 if (shpchp_unconfigure_device(p_slot)) 357 return(1); 358 359 hp_slot = p_slot->device - ctrl->slot_device_offset; 360 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 361 362 ctrl_dbg(ctrl, "%s: hp_slot = %d\n", __func__, hp_slot); 363 364 /* Change status to shutdown */ 365 if (p_slot->is_a_board) 366 p_slot->status = 0x01; 367 368 /* turn off slot, turn on Amber LED, turn off Green LED */ 369 rc = p_slot->hpc_ops->slot_disable(p_slot); 370 if (rc) { 371 ctrl_err(ctrl, "%s: Issue of Slot Disable command failed\n", 372 __func__); 373 return rc; 374 } 375 376 rc = p_slot->hpc_ops->set_attention_status(p_slot, 0); 377 if (rc) { 378 ctrl_err(ctrl, "Issue of Set Attention command failed\n"); 379 return rc; 380 } 381 382 p_slot->pwr_save = 0; 383 p_slot->is_a_board = 0; 384 385 return 0; 386 } 387 388 389 struct pushbutton_work_info { 390 struct slot *p_slot; 391 struct work_struct work; 392 }; 393 394 /** 395 * shpchp_pushbutton_thread - handle pushbutton events 396 * @work: &struct work_struct to be handled 397 * 398 * Scheduled procedure to handle blocking stuff for the pushbuttons. 399 * Handles all pending events and exits. 400 */ 401 static void shpchp_pushbutton_thread(struct work_struct *work) 402 { 403 struct pushbutton_work_info *info = 404 container_of(work, struct pushbutton_work_info, work); 405 struct slot *p_slot = info->p_slot; 406 407 mutex_lock(&p_slot->lock); 408 switch (p_slot->state) { 409 case POWEROFF_STATE: 410 mutex_unlock(&p_slot->lock); 411 shpchp_disable_slot(p_slot); 412 mutex_lock(&p_slot->lock); 413 p_slot->state = STATIC_STATE; 414 break; 415 case POWERON_STATE: 416 mutex_unlock(&p_slot->lock); 417 if (shpchp_enable_slot(p_slot)) 418 p_slot->hpc_ops->green_led_off(p_slot); 419 mutex_lock(&p_slot->lock); 420 p_slot->state = STATIC_STATE; 421 break; 422 default: 423 break; 424 } 425 mutex_unlock(&p_slot->lock); 426 427 kfree(info); 428 } 429 430 void shpchp_queue_pushbutton_work(struct work_struct *work) 431 { 432 struct slot *p_slot = container_of(work, struct slot, work.work); 433 struct pushbutton_work_info *info; 434 435 info = kmalloc(sizeof(*info), GFP_KERNEL); 436 if (!info) { 437 ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n", 438 __func__); 439 return; 440 } 441 info->p_slot = p_slot; 442 INIT_WORK(&info->work, shpchp_pushbutton_thread); 443 444 mutex_lock(&p_slot->lock); 445 switch (p_slot->state) { 446 case BLINKINGOFF_STATE: 447 p_slot->state = POWEROFF_STATE; 448 break; 449 case BLINKINGON_STATE: 450 p_slot->state = POWERON_STATE; 451 break; 452 default: 453 kfree(info); 454 goto out; 455 } 456 queue_work(p_slot->wq, &info->work); 457 out: 458 mutex_unlock(&p_slot->lock); 459 } 460 461 static int update_slot_info (struct slot *slot) 462 { 463 struct hotplug_slot_info *info; 464 int result; 465 466 info = kmalloc(sizeof(*info), GFP_KERNEL); 467 if (!info) 468 return -ENOMEM; 469 470 slot->hpc_ops->get_power_status(slot, &(info->power_status)); 471 slot->hpc_ops->get_attention_status(slot, &(info->attention_status)); 472 slot->hpc_ops->get_latch_status(slot, &(info->latch_status)); 473 slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status)); 474 475 result = pci_hp_change_slot_info(slot->hotplug_slot, info); 476 kfree (info); 477 return result; 478 } 479 480 /* 481 * Note: This function must be called with slot->lock held 482 */ 483 static void handle_button_press_event(struct slot *p_slot) 484 { 485 u8 getstatus; 486 struct controller *ctrl = p_slot->ctrl; 487 488 switch (p_slot->state) { 489 case STATIC_STATE: 490 p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 491 if (getstatus) { 492 p_slot->state = BLINKINGOFF_STATE; 493 ctrl_info(ctrl, "PCI slot #%s - powering off due to " 494 "button press.\n", slot_name(p_slot)); 495 } else { 496 p_slot->state = BLINKINGON_STATE; 497 ctrl_info(ctrl, "PCI slot #%s - powering on due to " 498 "button press.\n", slot_name(p_slot)); 499 } 500 /* blink green LED and turn off amber */ 501 p_slot->hpc_ops->green_led_blink(p_slot); 502 p_slot->hpc_ops->set_attention_status(p_slot, 0); 503 504 queue_delayed_work(p_slot->wq, &p_slot->work, 5*HZ); 505 break; 506 case BLINKINGOFF_STATE: 507 case BLINKINGON_STATE: 508 /* 509 * Cancel if we are still blinking; this means that we 510 * press the attention again before the 5 sec. limit 511 * expires to cancel hot-add or hot-remove 512 */ 513 ctrl_info(ctrl, "Button cancel on Slot(%s)\n", 514 slot_name(p_slot)); 515 cancel_delayed_work(&p_slot->work); 516 if (p_slot->state == BLINKINGOFF_STATE) 517 p_slot->hpc_ops->green_led_on(p_slot); 518 else 519 p_slot->hpc_ops->green_led_off(p_slot); 520 p_slot->hpc_ops->set_attention_status(p_slot, 0); 521 ctrl_info(ctrl, "PCI slot #%s - action canceled due to " 522 "button press\n", slot_name(p_slot)); 523 p_slot->state = STATIC_STATE; 524 break; 525 case POWEROFF_STATE: 526 case POWERON_STATE: 527 /* 528 * Ignore if the slot is on power-on or power-off state; 529 * this means that the previous attention button action 530 * to hot-add or hot-remove is undergoing 531 */ 532 ctrl_info(ctrl, "Button ignore on Slot(%s)\n", 533 slot_name(p_slot)); 534 update_slot_info(p_slot); 535 break; 536 default: 537 ctrl_warn(ctrl, "Not a valid state\n"); 538 break; 539 } 540 } 541 542 static void interrupt_event_handler(struct work_struct *work) 543 { 544 struct event_info *info = container_of(work, struct event_info, work); 545 struct slot *p_slot = info->p_slot; 546 547 mutex_lock(&p_slot->lock); 548 switch (info->event_type) { 549 case INT_BUTTON_PRESS: 550 handle_button_press_event(p_slot); 551 break; 552 case INT_POWER_FAULT: 553 ctrl_dbg(p_slot->ctrl, "%s: Power fault\n", __func__); 554 p_slot->hpc_ops->set_attention_status(p_slot, 1); 555 p_slot->hpc_ops->green_led_off(p_slot); 556 break; 557 default: 558 update_slot_info(p_slot); 559 break; 560 } 561 mutex_unlock(&p_slot->lock); 562 563 kfree(info); 564 } 565 566 567 static int shpchp_enable_slot (struct slot *p_slot) 568 { 569 u8 getstatus = 0; 570 int rc, retval = -ENODEV; 571 struct controller *ctrl = p_slot->ctrl; 572 573 /* Check to see if (latch closed, card present, power off) */ 574 mutex_lock(&p_slot->ctrl->crit_sect); 575 rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus); 576 if (rc || !getstatus) { 577 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot)); 578 goto out; 579 } 580 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 581 if (rc || getstatus) { 582 ctrl_info(ctrl, "Latch open on slot(%s)\n", slot_name(p_slot)); 583 goto out; 584 } 585 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 586 if (rc || getstatus) { 587 ctrl_info(ctrl, "Already enabled on slot(%s)\n", 588 slot_name(p_slot)); 589 goto out; 590 } 591 592 p_slot->is_a_board = 1; 593 594 /* We have to save the presence info for these slots */ 595 p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save)); 596 p_slot->hpc_ops->get_power_status(p_slot, &(p_slot->pwr_save)); 597 ctrl_dbg(ctrl, "%s: p_slot->pwr_save %x\n", __func__, p_slot->pwr_save); 598 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 599 600 if(((p_slot->ctrl->pci_dev->vendor == PCI_VENDOR_ID_AMD) || 601 (p_slot->ctrl->pci_dev->device == PCI_DEVICE_ID_AMD_POGO_7458)) 602 && p_slot->ctrl->num_slots == 1) { 603 /* handle amd pogo errata; this must be done before enable */ 604 amd_pogo_errata_save_misc_reg(p_slot); 605 retval = board_added(p_slot); 606 /* handle amd pogo errata; this must be done after enable */ 607 amd_pogo_errata_restore_misc_reg(p_slot); 608 } else 609 retval = board_added(p_slot); 610 611 if (retval) { 612 p_slot->hpc_ops->get_adapter_status(p_slot, 613 &(p_slot->presence_save)); 614 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 615 } 616 617 update_slot_info(p_slot); 618 out: 619 mutex_unlock(&p_slot->ctrl->crit_sect); 620 return retval; 621 } 622 623 624 static int shpchp_disable_slot (struct slot *p_slot) 625 { 626 u8 getstatus = 0; 627 int rc, retval = -ENODEV; 628 struct controller *ctrl = p_slot->ctrl; 629 630 if (!p_slot->ctrl) 631 return -ENODEV; 632 633 /* Check to see if (latch closed, card present, power on) */ 634 mutex_lock(&p_slot->ctrl->crit_sect); 635 636 rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus); 637 if (rc || !getstatus) { 638 ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot)); 639 goto out; 640 } 641 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 642 if (rc || getstatus) { 643 ctrl_info(ctrl, "Latch open on slot(%s)\n", slot_name(p_slot)); 644 goto out; 645 } 646 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 647 if (rc || !getstatus) { 648 ctrl_info(ctrl, "Already disabled on slot(%s)\n", 649 slot_name(p_slot)); 650 goto out; 651 } 652 653 retval = remove_board(p_slot); 654 update_slot_info(p_slot); 655 out: 656 mutex_unlock(&p_slot->ctrl->crit_sect); 657 return retval; 658 } 659 660 int shpchp_sysfs_enable_slot(struct slot *p_slot) 661 { 662 int retval = -ENODEV; 663 struct controller *ctrl = p_slot->ctrl; 664 665 mutex_lock(&p_slot->lock); 666 switch (p_slot->state) { 667 case BLINKINGON_STATE: 668 cancel_delayed_work(&p_slot->work); 669 case STATIC_STATE: 670 p_slot->state = POWERON_STATE; 671 mutex_unlock(&p_slot->lock); 672 retval = shpchp_enable_slot(p_slot); 673 mutex_lock(&p_slot->lock); 674 p_slot->state = STATIC_STATE; 675 break; 676 case POWERON_STATE: 677 ctrl_info(ctrl, "Slot %s is already in powering on state\n", 678 slot_name(p_slot)); 679 break; 680 case BLINKINGOFF_STATE: 681 case POWEROFF_STATE: 682 ctrl_info(ctrl, "Already enabled on slot %s\n", 683 slot_name(p_slot)); 684 break; 685 default: 686 ctrl_err(ctrl, "Not a valid state on slot %s\n", 687 slot_name(p_slot)); 688 break; 689 } 690 mutex_unlock(&p_slot->lock); 691 692 return retval; 693 } 694 695 int shpchp_sysfs_disable_slot(struct slot *p_slot) 696 { 697 int retval = -ENODEV; 698 struct controller *ctrl = p_slot->ctrl; 699 700 mutex_lock(&p_slot->lock); 701 switch (p_slot->state) { 702 case BLINKINGOFF_STATE: 703 cancel_delayed_work(&p_slot->work); 704 case STATIC_STATE: 705 p_slot->state = POWEROFF_STATE; 706 mutex_unlock(&p_slot->lock); 707 retval = shpchp_disable_slot(p_slot); 708 mutex_lock(&p_slot->lock); 709 p_slot->state = STATIC_STATE; 710 break; 711 case POWEROFF_STATE: 712 ctrl_info(ctrl, "Slot %s is already in powering off state\n", 713 slot_name(p_slot)); 714 break; 715 case BLINKINGON_STATE: 716 case POWERON_STATE: 717 ctrl_info(ctrl, "Already disabled on slot %s\n", 718 slot_name(p_slot)); 719 break; 720 default: 721 ctrl_err(ctrl, "Not a valid state on slot %s\n", 722 slot_name(p_slot)); 723 break; 724 } 725 mutex_unlock(&p_slot->lock); 726 727 return retval; 728 } 729