Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
shpchp_ctrl.c
Go to the documentation of this file.
1 /*
2  * Standard Hot Plug Controller Driver
3  *
4  * Copyright (C) 1995,2001 Compaq Computer Corporation
5  * Copyright (C) 2001 Greg Kroah-Hartman ([email protected])
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 <[email protected]>, <[email protected]>
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(shpchp_wq, &info->work);
55 
56  return 0;
57 }
58 
60 {
61  struct slot *p_slot;
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 
83 {
84  struct slot *p_slot;
85  u8 getstatus;
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 
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 
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 
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 
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 
390  struct slot *p_slot;
392 };
393 
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 
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  }
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(shpchp_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 }