Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
| 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>,<dely.l.sy@intel.com> |
| 27 | * |
| 28 | */ |
| 29 | #ifndef _SHPCHP_H |
| 30 | #define _SHPCHP_H |
| 31 | |
| 32 | #include <linux/types.h> |
| 33 | #include <linux/pci.h> |
| 34 | #include <linux/delay.h> |
| 35 | #include <asm/semaphore.h> |
| 36 | #include <asm/io.h> |
| 37 | #include "pci_hotplug.h" |
| 38 | |
| 39 | #if !defined(MODULE) |
| 40 | #define MY_NAME "shpchp" |
| 41 | #else |
| 42 | #define MY_NAME THIS_MODULE->name |
| 43 | #endif |
| 44 | |
| 45 | extern int shpchp_poll_mode; |
| 46 | extern int shpchp_poll_time; |
| 47 | extern int shpchp_debug; |
| 48 | |
| 49 | /*#define dbg(format, arg...) do { if (shpchp_debug) printk(KERN_DEBUG "%s: " format, MY_NAME , ## arg); } while (0)*/ |
| 50 | #define dbg(format, arg...) do { if (shpchp_debug) printk("%s: " format, MY_NAME , ## arg); } while (0) |
| 51 | #define err(format, arg...) printk(KERN_ERR "%s: " format, MY_NAME , ## arg) |
| 52 | #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg) |
| 53 | #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg) |
| 54 | |
| 55 | struct pci_func { |
| 56 | struct pci_func *next; |
| 57 | u8 bus; |
| 58 | u8 device; |
| 59 | u8 function; |
| 60 | u8 is_a_board; |
| 61 | u16 status; |
| 62 | u8 configured; |
| 63 | u8 switch_save; |
| 64 | u8 presence_save; |
| 65 | u8 pwr_save; |
| 66 | u32 base_length[0x06]; |
| 67 | u8 base_type[0x06]; |
| 68 | u16 reserved2; |
| 69 | u32 config_space[0x20]; |
| 70 | struct pci_resource *mem_head; |
| 71 | struct pci_resource *p_mem_head; |
| 72 | struct pci_resource *io_head; |
| 73 | struct pci_resource *bus_head; |
| 74 | struct pci_dev* pci_dev; |
| 75 | }; |
| 76 | |
| 77 | #define SLOT_MAGIC 0x67267321 |
| 78 | struct slot { |
| 79 | u32 magic; |
| 80 | struct slot *next; |
| 81 | u8 bus; |
| 82 | u8 device; |
| 83 | u32 number; |
| 84 | u8 is_a_board; |
| 85 | u8 configured; |
| 86 | u8 state; |
| 87 | u8 switch_save; |
| 88 | u8 presence_save; |
| 89 | u32 capabilities; |
| 90 | u16 reserved2; |
| 91 | struct timer_list task_event; |
| 92 | u8 hp_slot; |
| 93 | struct controller *ctrl; |
| 94 | struct hpc_ops *hpc_ops; |
| 95 | struct hotplug_slot *hotplug_slot; |
| 96 | struct list_head slot_list; |
| 97 | }; |
| 98 | |
| 99 | struct pci_resource { |
| 100 | struct pci_resource * next; |
| 101 | u32 base; |
| 102 | u32 length; |
| 103 | }; |
| 104 | |
| 105 | struct event_info { |
| 106 | u32 event_type; |
| 107 | u8 hp_slot; |
| 108 | }; |
| 109 | |
| 110 | struct controller { |
| 111 | struct controller *next; |
| 112 | struct semaphore crit_sect; /* critical section semaphore */ |
| 113 | void * hpc_ctlr_handle; /* HPC controller handle */ |
| 114 | int num_slots; /* Number of slots on ctlr */ |
| 115 | int slot_num_inc; /* 1 or -1 */ |
| 116 | struct pci_resource *mem_head; |
| 117 | struct pci_resource *p_mem_head; |
| 118 | struct pci_resource *io_head; |
| 119 | struct pci_resource *bus_head; |
| 120 | struct pci_dev *pci_dev; |
| 121 | struct pci_bus *pci_bus; |
| 122 | struct event_info event_queue[10]; |
| 123 | struct slot *slot; |
| 124 | struct hpc_ops *hpc_ops; |
| 125 | wait_queue_head_t queue; /* sleep & wake process */ |
| 126 | u8 next_event; |
| 127 | u8 seg; |
| 128 | u8 bus; |
| 129 | u8 device; |
| 130 | u8 function; |
| 131 | u8 rev; |
| 132 | u8 slot_device_offset; |
| 133 | u8 add_support; |
| 134 | enum pci_bus_speed speed; |
| 135 | u32 first_slot; /* First physical slot number */ |
| 136 | u8 slot_bus; /* Bus where the slots handled by this controller sit */ |
| 137 | u8 push_flag; |
| 138 | u16 ctlrcap; |
| 139 | u16 vendor_id; |
| 140 | }; |
| 141 | |
| 142 | struct irq_mapping { |
| 143 | u8 barber_pole; |
| 144 | u8 valid_INT; |
| 145 | u8 interrupt[4]; |
| 146 | }; |
| 147 | |
| 148 | struct resource_lists { |
| 149 | struct pci_resource *mem_head; |
| 150 | struct pci_resource *p_mem_head; |
| 151 | struct pci_resource *io_head; |
| 152 | struct pci_resource *bus_head; |
| 153 | struct irq_mapping *irqs; |
| 154 | }; |
| 155 | |
| 156 | /* Define AMD SHPC ID */ |
| 157 | #define PCI_DEVICE_ID_AMD_GOLAM_7450 0x7450 |
| 158 | |
| 159 | #define INT_BUTTON_IGNORE 0 |
| 160 | #define INT_PRESENCE_ON 1 |
| 161 | #define INT_PRESENCE_OFF 2 |
| 162 | #define INT_SWITCH_CLOSE 3 |
| 163 | #define INT_SWITCH_OPEN 4 |
| 164 | #define INT_POWER_FAULT 5 |
| 165 | #define INT_POWER_FAULT_CLEAR 6 |
| 166 | #define INT_BUTTON_PRESS 7 |
| 167 | #define INT_BUTTON_RELEASE 8 |
| 168 | #define INT_BUTTON_CANCEL 9 |
| 169 | |
| 170 | #define STATIC_STATE 0 |
| 171 | #define BLINKINGON_STATE 1 |
| 172 | #define BLINKINGOFF_STATE 2 |
| 173 | #define POWERON_STATE 3 |
| 174 | #define POWEROFF_STATE 4 |
| 175 | |
| 176 | #define PCI_TO_PCI_BRIDGE_CLASS 0x00060400 |
| 177 | |
| 178 | /* Error messages */ |
| 179 | #define INTERLOCK_OPEN 0x00000002 |
| 180 | #define ADD_NOT_SUPPORTED 0x00000003 |
| 181 | #define CARD_FUNCTIONING 0x00000005 |
| 182 | #define ADAPTER_NOT_SAME 0x00000006 |
| 183 | #define NO_ADAPTER_PRESENT 0x00000009 |
| 184 | #define NOT_ENOUGH_RESOURCES 0x0000000B |
| 185 | #define DEVICE_TYPE_NOT_SUPPORTED 0x0000000C |
| 186 | #define WRONG_BUS_FREQUENCY 0x0000000D |
| 187 | #define POWER_FAILURE 0x0000000E |
| 188 | |
| 189 | #define REMOVE_NOT_SUPPORTED 0x00000003 |
| 190 | |
| 191 | #define DISABLE_CARD 1 |
| 192 | |
| 193 | /* |
| 194 | * error Messages |
| 195 | */ |
| 196 | #define msg_initialization_err "Initialization failure, error=%d\n" |
| 197 | #define msg_HPC_rev_error "Unsupported revision of the PCI hot plug controller found.\n" |
| 198 | #define msg_HPC_non_shpc "The PCI hot plug controller is not supported by this driver.\n" |
| 199 | #define msg_HPC_not_supported "This system is not supported by this version of shpcphd mdoule. Upgrade to a newer version of shpchpd\n" |
| 200 | #define msg_unable_to_save "Unable to store PCI hot plug add resource information. This system must be rebooted before adding any PCI devices.\n" |
| 201 | #define msg_button_on "PCI slot #%d - powering on due to button press.\n" |
| 202 | #define msg_button_off "PCI slot #%d - powering off due to button press.\n" |
| 203 | #define msg_button_cancel "PCI slot #%d - action canceled due to button press.\n" |
| 204 | #define msg_button_ignore "PCI slot #%d - button press ignored. (action in progress...)\n" |
| 205 | |
| 206 | /* sysfs functions for the hotplug controller info */ |
| 207 | extern void shpchp_create_ctrl_files (struct controller *ctrl); |
| 208 | |
| 209 | /* controller functions */ |
| 210 | extern int shpchprm_find_available_resources(struct controller *ctrl); |
| 211 | extern int shpchp_event_start_thread(void); |
| 212 | extern void shpchp_event_stop_thread(void); |
| 213 | extern struct pci_func *shpchp_slot_create(unsigned char busnumber); |
| 214 | extern struct pci_func *shpchp_slot_find(unsigned char bus, unsigned char device, unsigned char index); |
| 215 | extern int shpchp_enable_slot(struct slot *slot); |
| 216 | extern int shpchp_disable_slot(struct slot *slot); |
| 217 | |
| 218 | extern u8 shpchp_handle_attention_button(u8 hp_slot, void *inst_id); |
| 219 | extern u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id); |
| 220 | extern u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id); |
| 221 | extern u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id); |
| 222 | |
| 223 | /* resource functions */ |
| 224 | extern int shpchp_resource_sort_and_combine(struct pci_resource **head); |
| 225 | |
| 226 | /* pci functions */ |
| 227 | extern int shpchp_set_irq(u8 bus_num, u8 dev_num, u8 int_pin, u8 irq_num); |
| 228 | /*extern int shpchp_get_bus_dev(struct controller *ctrl, u8 *bus_num, u8 *dev_num, struct slot *slot);*/ |
| 229 | extern int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num); |
| 230 | extern int shpchp_save_used_resources(struct controller *ctrl, struct pci_func * func, int flag); |
| 231 | extern int shpchp_save_slot_config(struct controller *ctrl, struct pci_func * new_slot); |
| 232 | extern void shpchp_destroy_board_resources(struct pci_func * func); |
| 233 | extern int shpchp_return_board_resources(struct pci_func * func, struct resource_lists * resources); |
| 234 | extern void shpchp_destroy_resource_list(struct resource_lists * resources); |
| 235 | extern int shpchp_configure_device(struct controller* ctrl, struct pci_func* func); |
| 236 | extern int shpchp_unconfigure_device(struct pci_func* func); |
| 237 | |
| 238 | |
| 239 | /* Global variables */ |
| 240 | extern struct controller *shpchp_ctrl_list; |
| 241 | extern struct pci_func *shpchp_slot_list[256]; |
| 242 | |
| 243 | /* These are added to support AMD shpc */ |
| 244 | extern u8 shpchp_nic_irq; |
| 245 | extern u8 shpchp_disk_irq; |
| 246 | |
| 247 | struct ctrl_reg { |
| 248 | volatile u32 base_offset; |
| 249 | volatile u32 slot_avail1; |
| 250 | volatile u32 slot_avail2; |
| 251 | volatile u32 slot_config; |
| 252 | volatile u16 sec_bus_config; |
| 253 | volatile u8 msi_ctrl; |
| 254 | volatile u8 prog_interface; |
| 255 | volatile u16 cmd; |
| 256 | volatile u16 cmd_status; |
| 257 | volatile u32 intr_loc; |
| 258 | volatile u32 serr_loc; |
| 259 | volatile u32 serr_intr_enable; |
| 260 | volatile u32 slot1; |
| 261 | volatile u32 slot2; |
| 262 | volatile u32 slot3; |
| 263 | volatile u32 slot4; |
| 264 | volatile u32 slot5; |
| 265 | volatile u32 slot6; |
| 266 | volatile u32 slot7; |
| 267 | volatile u32 slot8; |
| 268 | volatile u32 slot9; |
| 269 | volatile u32 slot10; |
| 270 | volatile u32 slot11; |
| 271 | volatile u32 slot12; |
| 272 | } __attribute__ ((packed)); |
| 273 | |
| 274 | /* offsets to the controller registers based on the above structure layout */ |
| 275 | enum ctrl_offsets { |
| 276 | BASE_OFFSET = offsetof(struct ctrl_reg, base_offset), |
| 277 | SLOT_AVAIL1 = offsetof(struct ctrl_reg, slot_avail1), |
| 278 | SLOT_AVAIL2 = offsetof(struct ctrl_reg, slot_avail2), |
| 279 | SLOT_CONFIG = offsetof(struct ctrl_reg, slot_config), |
| 280 | SEC_BUS_CONFIG = offsetof(struct ctrl_reg, sec_bus_config), |
| 281 | MSI_CTRL = offsetof(struct ctrl_reg, msi_ctrl), |
| 282 | PROG_INTERFACE = offsetof(struct ctrl_reg, prog_interface), |
| 283 | CMD = offsetof(struct ctrl_reg, cmd), |
| 284 | CMD_STATUS = offsetof(struct ctrl_reg, cmd_status), |
| 285 | INTR_LOC = offsetof(struct ctrl_reg, intr_loc), |
| 286 | SERR_LOC = offsetof(struct ctrl_reg, serr_loc), |
| 287 | SERR_INTR_ENABLE = offsetof(struct ctrl_reg, serr_intr_enable), |
| 288 | SLOT1 = offsetof(struct ctrl_reg, slot1), |
| 289 | SLOT2 = offsetof(struct ctrl_reg, slot2), |
| 290 | SLOT3 = offsetof(struct ctrl_reg, slot3), |
| 291 | SLOT4 = offsetof(struct ctrl_reg, slot4), |
| 292 | SLOT5 = offsetof(struct ctrl_reg, slot5), |
| 293 | SLOT6 = offsetof(struct ctrl_reg, slot6), |
| 294 | SLOT7 = offsetof(struct ctrl_reg, slot7), |
| 295 | SLOT8 = offsetof(struct ctrl_reg, slot8), |
| 296 | SLOT9 = offsetof(struct ctrl_reg, slot9), |
| 297 | SLOT10 = offsetof(struct ctrl_reg, slot10), |
| 298 | SLOT11 = offsetof(struct ctrl_reg, slot11), |
| 299 | SLOT12 = offsetof(struct ctrl_reg, slot12), |
| 300 | }; |
| 301 | typedef u8(*php_intr_callback_t) (unsigned int change_id, void *instance_id); |
| 302 | struct php_ctlr_state_s { |
| 303 | struct php_ctlr_state_s *pnext; |
| 304 | struct pci_dev *pci_dev; |
| 305 | unsigned int irq; |
| 306 | unsigned long flags; /* spinlock's */ |
| 307 | u32 slot_device_offset; |
| 308 | u32 num_slots; |
| 309 | struct timer_list int_poll_timer; /* Added for poll event */ |
| 310 | php_intr_callback_t attention_button_callback; |
| 311 | php_intr_callback_t switch_change_callback; |
| 312 | php_intr_callback_t presence_change_callback; |
| 313 | php_intr_callback_t power_fault_callback; |
| 314 | void *callback_instance_id; |
| 315 | void __iomem *creg; /* Ptr to controller register space */ |
| 316 | }; |
| 317 | /* Inline functions */ |
| 318 | |
| 319 | |
| 320 | /* Inline functions to check the sanity of a pointer that is passed to us */ |
| 321 | static inline int slot_paranoia_check (struct slot *slot, const char *function) |
| 322 | { |
| 323 | if (!slot) { |
| 324 | dbg("%s - slot == NULL", function); |
| 325 | return -1; |
| 326 | } |
| 327 | if (slot->magic != SLOT_MAGIC) { |
| 328 | dbg("%s - bad magic number for slot", function); |
| 329 | return -1; |
| 330 | } |
| 331 | if (!slot->hotplug_slot) { |
| 332 | dbg("%s - slot->hotplug_slot == NULL!", function); |
| 333 | return -1; |
| 334 | } |
| 335 | return 0; |
| 336 | } |
| 337 | |
| 338 | static inline struct slot *get_slot (struct hotplug_slot *hotplug_slot, const char *function) |
| 339 | { |
| 340 | struct slot *slot; |
| 341 | |
| 342 | if (!hotplug_slot) { |
| 343 | dbg("%s - hotplug_slot == NULL\n", function); |
| 344 | return NULL; |
| 345 | } |
| 346 | |
| 347 | slot = (struct slot *)hotplug_slot->private; |
| 348 | if (slot_paranoia_check (slot, function)) |
| 349 | return NULL; |
| 350 | return slot; |
| 351 | } |
| 352 | |
| 353 | static inline struct slot *shpchp_find_slot (struct controller *ctrl, u8 device) |
| 354 | { |
| 355 | struct slot *p_slot, *tmp_slot = NULL; |
| 356 | |
| 357 | if (!ctrl) |
| 358 | return NULL; |
| 359 | |
| 360 | p_slot = ctrl->slot; |
| 361 | |
| 362 | dbg("p_slot = %p\n", p_slot); |
| 363 | |
| 364 | while (p_slot && (p_slot->device != device)) { |
| 365 | tmp_slot = p_slot; |
| 366 | p_slot = p_slot->next; |
| 367 | dbg("In while loop, p_slot = %p\n", p_slot); |
| 368 | } |
| 369 | if (p_slot == NULL) { |
| 370 | err("ERROR: shpchp_find_slot device=0x%x\n", device); |
| 371 | p_slot = tmp_slot; |
| 372 | } |
| 373 | |
| 374 | return (p_slot); |
| 375 | } |
| 376 | |
| 377 | static inline int wait_for_ctrl_irq (struct controller *ctrl) |
| 378 | { |
| 379 | DECLARE_WAITQUEUE(wait, current); |
| 380 | int retval = 0; |
| 381 | |
| 382 | dbg("%s : start\n",__FUNCTION__); |
| 383 | |
| 384 | add_wait_queue(&ctrl->queue, &wait); |
| 385 | |
| 386 | if (!shpchp_poll_mode) { |
| 387 | /* Sleep for up to 1 second */ |
| 388 | msleep_interruptible(1000); |
| 389 | } else { |
| 390 | /* Sleep for up to 2 seconds */ |
| 391 | msleep_interruptible(2000); |
| 392 | } |
| 393 | remove_wait_queue(&ctrl->queue, &wait); |
| 394 | if (signal_pending(current)) |
| 395 | retval = -EINTR; |
| 396 | |
| 397 | dbg("%s : end\n", __FUNCTION__); |
| 398 | return retval; |
| 399 | } |
| 400 | |
| 401 | /* Puts node back in the resource list pointed to by head */ |
| 402 | static inline void return_resource(struct pci_resource **head, struct pci_resource *node) |
| 403 | { |
| 404 | if (!node || !head) |
| 405 | return; |
| 406 | node->next = *head; |
| 407 | *head = node; |
| 408 | } |
| 409 | |
| 410 | #define SLOT_NAME_SIZE 10 |
| 411 | |
| 412 | static inline void make_slot_name(char *buffer, int buffer_size, struct slot *slot) |
| 413 | { |
| 414 | snprintf(buffer, buffer_size, "%d", slot->number); |
| 415 | } |
| 416 | |
| 417 | enum php_ctlr_type { |
| 418 | PCI, |
| 419 | ISA, |
| 420 | ACPI |
| 421 | }; |
| 422 | |
| 423 | int shpc_init( struct controller *ctrl, struct pci_dev *pdev, |
| 424 | php_intr_callback_t attention_button_callback, |
| 425 | php_intr_callback_t switch_change_callback, |
| 426 | php_intr_callback_t presence_change_callback, |
| 427 | php_intr_callback_t power_fault_callback); |
| 428 | |
| 429 | int shpc_get_ctlr_slot_config( struct controller *ctrl, |
| 430 | int *num_ctlr_slots, |
| 431 | int *first_device_num, |
| 432 | int *physical_slot_num, |
| 433 | int *updown, |
| 434 | int *flags); |
| 435 | |
| 436 | struct hpc_ops { |
| 437 | int (*power_on_slot ) (struct slot *slot); |
| 438 | int (*slot_enable ) (struct slot *slot); |
| 439 | int (*slot_disable ) (struct slot *slot); |
| 440 | int (*enable_all_slots) (struct slot *slot); |
| 441 | int (*pwr_on_all_slots) (struct slot *slot); |
| 442 | int (*set_bus_speed_mode) (struct slot *slot, enum pci_bus_speed speed); |
| 443 | int (*get_power_status) (struct slot *slot, u8 *status); |
| 444 | int (*get_attention_status) (struct slot *slot, u8 *status); |
| 445 | int (*set_attention_status) (struct slot *slot, u8 status); |
| 446 | int (*get_latch_status) (struct slot *slot, u8 *status); |
| 447 | int (*get_adapter_status) (struct slot *slot, u8 *status); |
| 448 | |
| 449 | int (*get_max_bus_speed) (struct slot *slot, enum pci_bus_speed *speed); |
| 450 | int (*get_cur_bus_speed) (struct slot *slot, enum pci_bus_speed *speed); |
| 451 | int (*get_adapter_speed) (struct slot *slot, enum pci_bus_speed *speed); |
| 452 | int (*get_mode1_ECC_cap) (struct slot *slot, u8 *mode); |
| 453 | int (*get_prog_int) (struct slot *slot, u8 *prog_int); |
| 454 | |
| 455 | int (*query_power_fault) (struct slot *slot); |
| 456 | void (*green_led_on) (struct slot *slot); |
| 457 | void (*green_led_off) (struct slot *slot); |
| 458 | void (*green_led_blink) (struct slot *slot); |
| 459 | void (*release_ctlr) (struct controller *ctrl); |
| 460 | int (*check_cmd_status) (struct controller *ctrl); |
| 461 | }; |
| 462 | |
| 463 | #endif /* _SHPCHP_H */ |