[PATCH] 64bit resource: fix up printks for resources in pci core and hotplug drivers
[linux-2.6.git] / drivers / pci / hotplug / pciehp_hpc.c
1 /*
2  * PCI Express PCI Hot Plug 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/kernel.h>
31 #include <linux/module.h>
32 #include <linux/types.h>
33 #include <linux/signal.h>
34 #include <linux/jiffies.h>
35 #include <linux/timer.h>
36 #include <linux/pci.h>
37 #include <linux/interrupt.h>
38
39 #include "../pci.h"
40 #include "pciehp.h"
41 #include <acpi/acpi.h>
42 #include <acpi/acpi_bus.h>
43 #include <acpi/actypes.h>
44 #include <linux/pci-acpi.h>
45 #ifdef DEBUG
46 #define DBG_K_TRACE_ENTRY      ((unsigned int)0x00000001)       /* On function entry */
47 #define DBG_K_TRACE_EXIT       ((unsigned int)0x00000002)       /* On function exit */
48 #define DBG_K_INFO             ((unsigned int)0x00000004)       /* Info messages */
49 #define DBG_K_ERROR            ((unsigned int)0x00000008)       /* Error messages */
50 #define DBG_K_TRACE            (DBG_K_TRACE_ENTRY|DBG_K_TRACE_EXIT)
51 #define DBG_K_STANDARD         (DBG_K_INFO|DBG_K_ERROR|DBG_K_TRACE)
52 /* Redefine this flagword to set debug level */
53 #define DEBUG_LEVEL            DBG_K_STANDARD
54
55 #define DEFINE_DBG_BUFFER     char __dbg_str_buf[256];
56
57 #define DBG_PRINT( dbg_flags, args... )              \
58         do {                                             \
59           if ( DEBUG_LEVEL & ( dbg_flags ) )             \
60           {                                              \
61             int len;                                     \
62             len = sprintf( __dbg_str_buf, "%s:%d: %s: ", \
63                   __FILE__, __LINE__, __FUNCTION__ );    \
64             sprintf( __dbg_str_buf + len, args );        \
65             printk( KERN_NOTICE "%s\n", __dbg_str_buf ); \
66           }                                              \
67         } while (0)
68
69 #define DBG_ENTER_ROUTINE       DBG_PRINT (DBG_K_TRACE_ENTRY, "%s", "[Entry]");
70 #define DBG_LEAVE_ROUTINE       DBG_PRINT (DBG_K_TRACE_EXIT, "%s", "[Exit]");
71 #else
72 #define DEFINE_DBG_BUFFER
73 #define DBG_ENTER_ROUTINE
74 #define DBG_LEAVE_ROUTINE
75 #endif                          /* DEBUG */
76
77 struct ctrl_reg {
78         u8 cap_id;
79         u8 nxt_ptr;
80         u16 cap_reg;
81         u32 dev_cap;
82         u16 dev_ctrl;
83         u16 dev_status;
84         u32 lnk_cap;
85         u16 lnk_ctrl;
86         u16 lnk_status;
87         u32 slot_cap;
88         u16 slot_ctrl;
89         u16 slot_status;
90         u16 root_ctrl;
91         u16 rsvp;
92         u32 root_status;
93 } __attribute__ ((packed));
94
95 /* offsets to the controller registers based on the above structure layout */
96 enum ctrl_offsets {
97         PCIECAPID       =       offsetof(struct ctrl_reg, cap_id),
98         NXTCAPPTR       =       offsetof(struct ctrl_reg, nxt_ptr),
99         CAPREG          =       offsetof(struct ctrl_reg, cap_reg),
100         DEVCAP          =       offsetof(struct ctrl_reg, dev_cap),
101         DEVCTRL         =       offsetof(struct ctrl_reg, dev_ctrl),
102         DEVSTATUS       =       offsetof(struct ctrl_reg, dev_status),
103         LNKCAP          =       offsetof(struct ctrl_reg, lnk_cap),
104         LNKCTRL         =       offsetof(struct ctrl_reg, lnk_ctrl),
105         LNKSTATUS       =       offsetof(struct ctrl_reg, lnk_status),
106         SLOTCAP         =       offsetof(struct ctrl_reg, slot_cap),
107         SLOTCTRL        =       offsetof(struct ctrl_reg, slot_ctrl),
108         SLOTSTATUS      =       offsetof(struct ctrl_reg, slot_status),
109         ROOTCTRL        =       offsetof(struct ctrl_reg, root_ctrl),
110         ROOTSTATUS      =       offsetof(struct ctrl_reg, root_status),
111 };
112 static int pcie_cap_base = 0;           /* Base of the PCI Express capability item structure */ 
113
114 #define PCIE_CAP_ID(cb) ( cb + PCIECAPID )
115 #define NXT_CAP_PTR(cb) ( cb + NXTCAPPTR )
116 #define CAP_REG(cb)     ( cb + CAPREG )
117 #define DEV_CAP(cb)     ( cb + DEVCAP )
118 #define DEV_CTRL(cb)    ( cb + DEVCTRL )
119 #define DEV_STATUS(cb)  ( cb + DEVSTATUS )
120 #define LNK_CAP(cb)     ( cb + LNKCAP )
121 #define LNK_CTRL(cb)    ( cb + LNKCTRL )
122 #define LNK_STATUS(cb)  ( cb + LNKSTATUS )
123 #define SLOT_CAP(cb)    ( cb + SLOTCAP )
124 #define SLOT_CTRL(cb)   ( cb + SLOTCTRL )
125 #define SLOT_STATUS(cb) ( cb + SLOTSTATUS )
126 #define ROOT_CTRL(cb)   ( cb + ROOTCTRL )
127 #define ROOT_STATUS(cb) ( cb + ROOTSTATUS )
128
129 #define hp_register_read_word(pdev, reg , value)                \
130         pci_read_config_word(pdev, reg, &value)
131
132 #define hp_register_read_dword(pdev, reg , value)               \
133         pci_read_config_dword(pdev, reg, &value)
134  
135 #define hp_register_write_word(pdev, reg , value)               \
136         pci_write_config_word(pdev, reg, value)
137
138 #define hp_register_dwrite_word(pdev, reg , value)              \
139         pci_write_config_dword(pdev, reg, value)
140
141 /* Field definitions in PCI Express Capabilities Register */
142 #define CAP_VER                 0x000F
143 #define DEV_PORT_TYPE           0x00F0
144 #define SLOT_IMPL               0x0100
145 #define MSG_NUM                 0x3E00
146
147 /* Device or Port Type */
148 #define NAT_ENDPT               0x00
149 #define LEG_ENDPT               0x01
150 #define ROOT_PORT               0x04
151 #define UP_STREAM               0x05
152 #define DN_STREAM               0x06
153 #define PCIE_PCI_BRDG           0x07
154 #define PCI_PCIE_BRDG           0x10
155
156 /* Field definitions in Device Capabilities Register */
157 #define DATTN_BUTTN_PRSN        0x1000
158 #define DATTN_LED_PRSN          0x2000
159 #define DPWR_LED_PRSN           0x4000
160
161 /* Field definitions in Link Capabilities Register */
162 #define MAX_LNK_SPEED           0x000F
163 #define MAX_LNK_WIDTH           0x03F0
164
165 /* Link Width Encoding */
166 #define LNK_X1          0x01
167 #define LNK_X2          0x02
168 #define LNK_X4          0x04    
169 #define LNK_X8          0x08
170 #define LNK_X12         0x0C
171 #define LNK_X16         0x10    
172 #define LNK_X32         0x20
173
174 /*Field definitions of Link Status Register */
175 #define LNK_SPEED       0x000F
176 #define NEG_LINK_WD     0x03F0
177 #define LNK_TRN_ERR     0x0400
178 #define LNK_TRN         0x0800
179 #define SLOT_CLK_CONF   0x1000
180
181 /* Field definitions in Slot Capabilities Register */
182 #define ATTN_BUTTN_PRSN 0x00000001
183 #define PWR_CTRL_PRSN   0x00000002
184 #define MRL_SENS_PRSN   0x00000004
185 #define ATTN_LED_PRSN   0x00000008
186 #define PWR_LED_PRSN    0x00000010
187 #define HP_SUPR_RM_SUP  0x00000020
188 #define HP_CAP          0x00000040
189 #define SLOT_PWR_VALUE  0x000003F8
190 #define SLOT_PWR_LIMIT  0x00000C00
191 #define PSN             0xFFF80000      /* PSN: Physical Slot Number */
192
193 /* Field definitions in Slot Control Register */
194 #define ATTN_BUTTN_ENABLE               0x0001
195 #define PWR_FAULT_DETECT_ENABLE         0x0002
196 #define MRL_DETECT_ENABLE               0x0004
197 #define PRSN_DETECT_ENABLE              0x0008
198 #define CMD_CMPL_INTR_ENABLE            0x0010
199 #define HP_INTR_ENABLE                  0x0020
200 #define ATTN_LED_CTRL                   0x00C0
201 #define PWR_LED_CTRL                    0x0300
202 #define PWR_CTRL                        0x0400
203
204 /* Attention indicator and Power indicator states */
205 #define LED_ON          0x01
206 #define LED_BLINK       0x10
207 #define LED_OFF         0x11
208
209 /* Power Control Command */
210 #define POWER_ON        0
211 #define POWER_OFF       0x0400
212
213 /* Field definitions in Slot Status Register */
214 #define ATTN_BUTTN_PRESSED      0x0001
215 #define PWR_FAULT_DETECTED      0x0002
216 #define MRL_SENS_CHANGED        0x0004
217 #define PRSN_DETECT_CHANGED     0x0008
218 #define CMD_COMPLETED           0x0010
219 #define MRL_STATE               0x0020
220 #define PRSN_STATE              0x0040
221
222 static spinlock_t hpc_event_lock;
223
224 DEFINE_DBG_BUFFER               /* Debug string buffer for entire HPC defined here */
225 static struct php_ctlr_state_s *php_ctlr_list_head; /* HPC state linked list */
226 static int ctlr_seq_num = 0;    /* Controller sequence # */
227 static spinlock_t list_lock;
228
229 static irqreturn_t pcie_isr(int IRQ, void *dev_id, struct pt_regs *regs);
230
231 static void start_int_poll_timer(struct php_ctlr_state_s *php_ctlr, int seconds);
232
233 /* This is the interrupt polling timeout function. */
234 static void int_poll_timeout(unsigned long lphp_ctlr)
235 {
236         struct php_ctlr_state_s *php_ctlr = (struct php_ctlr_state_s *)lphp_ctlr;
237
238         DBG_ENTER_ROUTINE
239
240         if ( !php_ctlr ) {
241                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
242                 return;
243         }
244
245         /* Poll for interrupt events.  regs == NULL => polling */
246         pcie_isr( 0, (void *)php_ctlr, NULL );
247
248         init_timer(&php_ctlr->int_poll_timer);
249
250         if (!pciehp_poll_time)
251                 pciehp_poll_time = 2; /* reset timer to poll in 2 secs if user doesn't specify at module installation*/
252
253         start_int_poll_timer(php_ctlr, pciehp_poll_time);  
254         
255         return;
256 }
257
258 /* This function starts the interrupt polling timer. */
259 static void start_int_poll_timer(struct php_ctlr_state_s *php_ctlr, int seconds)
260 {
261         if (!php_ctlr) {
262                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
263                 return;
264         }
265
266         if ( ( seconds <= 0 ) || ( seconds > 60 ) )
267                 seconds = 2;            /* Clamp to sane value */
268
269         php_ctlr->int_poll_timer.function = &int_poll_timeout;
270         php_ctlr->int_poll_timer.data = (unsigned long)php_ctlr;    /* Instance data */
271         php_ctlr->int_poll_timer.expires = jiffies + seconds * HZ;
272         add_timer(&php_ctlr->int_poll_timer);
273
274         return;
275 }
276
277 static int pcie_write_cmd(struct slot *slot, u16 cmd)
278 {
279         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
280         int retval = 0;
281         u16 slot_status;
282
283         DBG_ENTER_ROUTINE 
284         
285         if (!php_ctlr) {
286                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
287                 return -1;
288         }
289
290         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(slot->ctrl->cap_base), slot_status);
291         if (retval) {
292                         err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
293                         return retval;
294                 }
295         
296         if ((slot_status & CMD_COMPLETED) == CMD_COMPLETED ) { 
297                 /* After 1 sec and CMD_COMPLETED still not set, just proceed forward to issue 
298                    the next command according to spec.  Just print out the error message */
299                 dbg("%s : CMD_COMPLETED not clear after 1 sec.\n", __FUNCTION__);
300         }
301
302         retval = hp_register_write_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), cmd | CMD_CMPL_INTR_ENABLE);
303         if (retval) {
304                 err("%s : hp_register_write_word SLOT_CTRL failed\n", __FUNCTION__);
305                 return retval;
306         }
307
308         DBG_LEAVE_ROUTINE 
309         return retval;
310 }
311
312 static int hpc_check_lnk_status(struct controller *ctrl)
313 {
314         struct php_ctlr_state_s *php_ctlr = ctrl->hpc_ctlr_handle;
315         u16 lnk_status;
316         int retval = 0;
317
318         DBG_ENTER_ROUTINE 
319
320         if (!php_ctlr) {
321                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
322                 return -1;
323         }
324         
325         retval = hp_register_read_word(php_ctlr->pci_dev, LNK_STATUS(ctrl->cap_base), lnk_status);
326
327         if (retval) {
328                 err("%s : hp_register_read_word LNK_STATUS failed\n", __FUNCTION__);
329                 return retval;
330         }
331
332         dbg("%s: lnk_status = %x\n", __FUNCTION__, lnk_status);
333         if ( (lnk_status & LNK_TRN) || (lnk_status & LNK_TRN_ERR) || 
334                 !(lnk_status & NEG_LINK_WD)) {
335                 err("%s : Link Training Error occurs \n", __FUNCTION__);
336                 retval = -1;
337                 return retval;
338         }
339
340         DBG_LEAVE_ROUTINE 
341         return retval;
342 }
343
344
345 static int hpc_get_attention_status(struct slot *slot, u8 *status)
346 {
347         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
348         u16 slot_ctrl;
349         u8 atten_led_state;
350         int retval = 0;
351         
352         DBG_ENTER_ROUTINE 
353
354         if (!php_ctlr) {
355                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
356                 return -1;
357         }
358
359         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
360
361         if (retval) {
362                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
363                 return retval;
364         }
365
366         dbg("%s: SLOT_CTRL %x, value read %x\n", __FUNCTION__,SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
367
368         atten_led_state = (slot_ctrl & ATTN_LED_CTRL) >> 6;
369
370         switch (atten_led_state) {
371         case 0:
372                 *status = 0xFF; /* Reserved */
373                 break;
374         case 1:
375                 *status = 1;    /* On */
376                 break;
377         case 2:
378                 *status = 2;    /* Blink */
379                 break;
380         case 3:
381                 *status = 0;    /* Off */
382                 break;
383         default:
384                 *status = 0xFF;
385                 break;
386         }
387
388         DBG_LEAVE_ROUTINE 
389         return 0;
390 }
391
392 static int hpc_get_power_status(struct slot * slot, u8 *status)
393 {
394         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
395         u16 slot_ctrl;
396         u8 pwr_state;
397         int     retval = 0;
398         
399         DBG_ENTER_ROUTINE 
400
401         if (!php_ctlr) {
402                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
403                 return -1;
404         }
405
406         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
407
408         if (retval) {
409                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
410                 return retval;
411         }
412         dbg("%s: SLOT_CTRL %x value read %x\n", __FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
413
414         pwr_state = (slot_ctrl & PWR_CTRL) >> 10;
415
416         switch (pwr_state) {
417         case 0:
418                 *status = 1;
419                 break;
420         case 1:
421                 *status = 0;    
422                 break;
423         default:
424                 *status = 0xFF;
425                 break;
426         }
427
428         DBG_LEAVE_ROUTINE 
429         return retval;
430 }
431
432
433 static int hpc_get_latch_status(struct slot *slot, u8 *status)
434 {
435         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
436         u16 slot_status;
437         int retval = 0;
438
439         DBG_ENTER_ROUTINE 
440
441         if (!php_ctlr) {
442                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
443                 return -1;
444         }
445
446         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(slot->ctrl->cap_base), slot_status);
447
448         if (retval) {
449                 err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
450                 return retval;
451         }
452
453         *status = (((slot_status & MRL_STATE) >> 5) == 0) ? 0 : 1;  
454
455         DBG_LEAVE_ROUTINE 
456         return 0;
457 }
458
459 static int hpc_get_adapter_status(struct slot *slot, u8 *status)
460 {
461         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
462         u16 slot_status;
463         u8 card_state;
464         int retval = 0;
465
466         DBG_ENTER_ROUTINE 
467
468         if (!php_ctlr) {
469                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
470                 return -1;
471         }
472
473         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(slot->ctrl->cap_base), slot_status);
474
475         if (retval) {
476                 err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
477                 return retval;
478         }
479         card_state = (u8)((slot_status & PRSN_STATE) >> 6);
480         *status = (card_state == 1) ? 1 : 0;
481
482         DBG_LEAVE_ROUTINE 
483         return 0;
484 }
485
486 static int hpc_query_power_fault(struct slot * slot)
487 {
488         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
489         u16 slot_status;
490         u8 pwr_fault;
491         int retval = 0;
492
493         DBG_ENTER_ROUTINE 
494
495         if (!php_ctlr) {
496                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
497                 return -1;
498         }
499
500         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(slot->ctrl->cap_base), slot_status);
501
502         if (retval) {
503                 err("%s : Cannot check for power fault\n", __FUNCTION__);
504                 return retval;
505         }
506         pwr_fault = (u8)((slot_status & PWR_FAULT_DETECTED) >> 1);
507         
508         DBG_LEAVE_ROUTINE
509         return pwr_fault;
510 }
511
512 static int hpc_set_attention_status(struct slot *slot, u8 value)
513 {
514         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
515         u16 slot_cmd = 0;
516         u16 slot_ctrl;
517         int rc = 0;
518
519         DBG_ENTER_ROUTINE
520
521         if (!php_ctlr) {
522                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
523                 return -1;
524         }
525
526         if (slot->hp_slot >= php_ctlr->num_slots) {
527                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
528                 return -1;
529         }
530         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
531
532         if (rc) {
533                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
534                 return rc;
535         }
536
537         switch (value) {
538                 case 0 :        /* turn off */
539                         slot_cmd = (slot_ctrl & ~ATTN_LED_CTRL) | 0x00C0;
540                         break;
541                 case 1:         /* turn on */
542                         slot_cmd = (slot_ctrl & ~ATTN_LED_CTRL) | 0x0040;
543                         break;
544                 case 2:         /* turn blink */
545                         slot_cmd = (slot_ctrl & ~ATTN_LED_CTRL) | 0x0080;
546                         break;
547                 default:
548                         return -1;
549         }
550         if (!pciehp_poll_mode)
551                 slot_cmd = slot_cmd | HP_INTR_ENABLE; 
552
553         pcie_write_cmd(slot, slot_cmd);
554         dbg("%s: SLOT_CTRL %x write cmd %x\n", __FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_cmd);
555         
556         DBG_LEAVE_ROUTINE
557         return rc;
558 }
559
560
561 static void hpc_set_green_led_on(struct slot *slot)
562 {
563         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
564         u16 slot_cmd;
565         u16 slot_ctrl;
566         int rc = 0;
567         
568         DBG_ENTER_ROUTINE
569
570         if (!php_ctlr) {
571                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
572                 return ;
573         }
574
575         if (slot->hp_slot >= php_ctlr->num_slots) {
576                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
577                 return ;
578         }
579
580         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
581
582         if (rc) {
583                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
584                 return;
585         }
586         slot_cmd = (slot_ctrl & ~PWR_LED_CTRL) | 0x0100;
587         if (!pciehp_poll_mode)
588                 slot_cmd = slot_cmd | HP_INTR_ENABLE; 
589
590         pcie_write_cmd(slot, slot_cmd);
591
592         dbg("%s: SLOT_CTRL %x write cmd %x\n",__FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_cmd);
593         DBG_LEAVE_ROUTINE
594         return;
595 }
596
597 static void hpc_set_green_led_off(struct slot *slot)
598 {
599         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
600         u16 slot_cmd;
601         u16 slot_ctrl;
602         int rc = 0;
603
604         DBG_ENTER_ROUTINE
605
606         if (!php_ctlr) {
607                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
608                 return ;
609         }
610
611         if (slot->hp_slot >= php_ctlr->num_slots) {
612                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
613                 return ;
614         }
615
616         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
617
618         if (rc) {
619                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
620                 return;
621         }
622
623         slot_cmd = (slot_ctrl & ~PWR_LED_CTRL) | 0x0300;
624
625         if (!pciehp_poll_mode)
626                 slot_cmd = slot_cmd | HP_INTR_ENABLE; 
627         pcie_write_cmd(slot, slot_cmd);
628         dbg("%s: SLOT_CTRL %x write cmd %x\n", __FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_cmd);
629
630         DBG_LEAVE_ROUTINE
631         return;
632 }
633
634 static void hpc_set_green_led_blink(struct slot *slot)
635 {
636         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
637         u16 slot_cmd;
638         u16 slot_ctrl;
639         int rc = 0; 
640         
641         DBG_ENTER_ROUTINE
642
643         if (!php_ctlr) {
644                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
645                 return ;
646         }
647
648         if (slot->hp_slot >= php_ctlr->num_slots) {
649                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
650                 return ;
651         }
652
653         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
654
655         if (rc) {
656                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
657                 return;
658         }
659
660         slot_cmd = (slot_ctrl & ~PWR_LED_CTRL) | 0x0200;
661
662         if (!pciehp_poll_mode)
663                 slot_cmd = slot_cmd | HP_INTR_ENABLE; 
664         pcie_write_cmd(slot, slot_cmd);
665
666         dbg("%s: SLOT_CTRL %x write cmd %x\n",__FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_cmd);
667         DBG_LEAVE_ROUTINE
668         return;
669 }
670
671 int pcie_get_ctlr_slot_config(struct controller *ctrl,
672         int *num_ctlr_slots,    /* number of slots in this HPC; only 1 in PCIE  */      
673         int *first_device_num,  /* PCI dev num of the first slot in this PCIE   */
674         int *physical_slot_num, /* phy slot num of the first slot in this PCIE  */
675         u8 *ctrlcap)
676 {
677         struct php_ctlr_state_s *php_ctlr = ctrl->hpc_ctlr_handle;
678         u32 slot_cap;
679         int rc = 0;
680         
681         DBG_ENTER_ROUTINE 
682
683         if (!php_ctlr) {
684                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
685                 return -1;
686         }
687
688         *first_device_num = 0;
689         *num_ctlr_slots = 1; 
690
691         rc = hp_register_read_dword(php_ctlr->pci_dev, SLOT_CAP(ctrl->cap_base), slot_cap);
692
693         if (rc) {
694                 err("%s : hp_register_read_dword SLOT_CAP failed\n", __FUNCTION__);
695                 return -1;
696         }
697         
698         *physical_slot_num = slot_cap >> 19;
699         dbg("%s: PSN %d \n", __FUNCTION__, *physical_slot_num);
700         
701         *ctrlcap = slot_cap & 0x0000007f;
702
703         DBG_LEAVE_ROUTINE 
704         return 0;
705 }
706
707 static void hpc_release_ctlr(struct controller *ctrl)
708 {
709         struct php_ctlr_state_s *php_ctlr = ctrl->hpc_ctlr_handle;
710         struct php_ctlr_state_s *p, *p_prev;
711
712         DBG_ENTER_ROUTINE 
713
714         if (!php_ctlr) {
715                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
716                 return ;
717         }
718
719         if (pciehp_poll_mode) {
720             del_timer(&php_ctlr->int_poll_timer);
721         } else {        
722                 if (php_ctlr->irq) {
723                         free_irq(php_ctlr->irq, ctrl);
724                         php_ctlr->irq = 0;
725                         if (!pcie_mch_quirk) 
726                                 pci_disable_msi(php_ctlr->pci_dev);
727                 }
728         }
729         if (php_ctlr->pci_dev) 
730                 php_ctlr->pci_dev = NULL;
731
732         spin_lock(&list_lock);
733         p = php_ctlr_list_head;
734         p_prev = NULL;
735         while (p) {
736                 if (p == php_ctlr) {
737                         if (p_prev)
738                                 p_prev->pnext = p->pnext;
739                         else
740                                 php_ctlr_list_head = p->pnext;
741                         break;
742                 } else {
743                         p_prev = p;
744                         p = p->pnext;
745                 }
746         }
747         spin_unlock(&list_lock);
748
749         kfree(php_ctlr);
750
751         DBG_LEAVE_ROUTINE
752                           
753 }
754
755 static int hpc_power_on_slot(struct slot * slot)
756 {
757         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
758         u16 slot_cmd;
759         u16 slot_ctrl, slot_status;
760
761         int retval = 0;
762
763         DBG_ENTER_ROUTINE 
764
765         if (!php_ctlr) {
766                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
767                 return -1;
768         }
769
770         dbg("%s: slot->hp_slot %x\n", __FUNCTION__, slot->hp_slot);
771         if (slot->hp_slot >= php_ctlr->num_slots) {
772                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
773                 return -1;
774         }
775
776         /* Clear sticky power-fault bit from previous power failures */
777         hp_register_read_word(php_ctlr->pci_dev,
778                         SLOT_STATUS(slot->ctrl->cap_base), slot_status);
779         slot_status &= PWR_FAULT_DETECTED;
780         if (slot_status)
781                 hp_register_write_word(php_ctlr->pci_dev,
782                         SLOT_STATUS(slot->ctrl->cap_base), slot_status);
783
784         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
785
786         if (retval) {
787                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
788                 return retval;
789         }
790
791         slot_cmd = (slot_ctrl & ~PWR_CTRL) | POWER_ON;
792
793         /* Enable detection that we turned off at slot power-off time */
794         if (!pciehp_poll_mode)
795                 slot_cmd = slot_cmd |
796                            PWR_FAULT_DETECT_ENABLE |
797                            MRL_DETECT_ENABLE |
798                            PRSN_DETECT_ENABLE |
799                            HP_INTR_ENABLE;
800
801         retval = pcie_write_cmd(slot, slot_cmd);
802
803         if (retval) {
804                 err("%s: Write %x command failed!\n", __FUNCTION__, slot_cmd);
805                 return -1;
806         }
807         dbg("%s: SLOT_CTRL %x write cmd %x\n",__FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_cmd);
808
809         DBG_LEAVE_ROUTINE
810
811         return retval;
812 }
813
814 static int hpc_power_off_slot(struct slot * slot)
815 {
816         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
817         u16 slot_cmd;
818         u16 slot_ctrl;
819
820         int retval = 0;
821
822         DBG_ENTER_ROUTINE 
823
824         if (!php_ctlr) {
825                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
826                 return -1;
827         }
828
829         dbg("%s: slot->hp_slot %x\n", __FUNCTION__, slot->hp_slot);
830         slot->hp_slot = 0;
831         if (slot->hp_slot >= php_ctlr->num_slots) {
832                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
833                 return -1;
834         }
835         retval = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(slot->ctrl->cap_base), slot_ctrl);
836
837         if (retval) {
838                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
839                 return retval;
840         }
841
842         slot_cmd = (slot_ctrl & ~PWR_CTRL) | POWER_OFF;
843
844         /*
845          * If we get MRL or presence detect interrupts now, the isr
846          * will notice the sticky power-fault bit too and issue power
847          * indicator change commands. This will lead to an endless loop
848          * of command completions, since the power-fault bit remains on
849          * till the slot is powered on again.
850          */
851         if (!pciehp_poll_mode)
852                 slot_cmd = (slot_cmd &
853                             ~PWR_FAULT_DETECT_ENABLE &
854                             ~MRL_DETECT_ENABLE &
855                             ~PRSN_DETECT_ENABLE) | HP_INTR_ENABLE;
856
857         retval = pcie_write_cmd(slot, slot_cmd);
858
859         if (retval) {
860                 err("%s: Write command failed!\n", __FUNCTION__);
861                 return -1;
862         }
863         dbg("%s: SLOT_CTRL %x write cmd %x\n",__FUNCTION__, SLOT_CTRL(slot->ctrl->cap_base), slot_cmd);
864
865         DBG_LEAVE_ROUTINE
866
867         return retval;
868 }
869
870 static irqreturn_t pcie_isr(int IRQ, void *dev_id, struct pt_regs *regs)
871 {
872         struct controller *ctrl = NULL;
873         struct php_ctlr_state_s *php_ctlr;
874         u8 schedule_flag = 0;
875         u16 slot_status, intr_detect, intr_loc;
876         u16 temp_word;
877         int hp_slot = 0;        /* only 1 slot per PCI Express port */
878         int rc = 0;
879
880         if (!dev_id)
881                 return IRQ_NONE;
882
883         if (!pciehp_poll_mode) { 
884                 ctrl = dev_id;
885                 php_ctlr = ctrl->hpc_ctlr_handle;
886         } else {
887                 php_ctlr = dev_id;
888                 ctrl = (struct controller *)php_ctlr->callback_instance_id;
889         }
890
891         if (!ctrl) {
892                 dbg("%s: dev_id %p ctlr == NULL\n", __FUNCTION__, (void*) dev_id);
893                 return IRQ_NONE;
894         }
895         
896         if (!php_ctlr) {
897                 dbg("%s: php_ctlr == NULL\n", __FUNCTION__);
898                 return IRQ_NONE;
899         }
900
901         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), slot_status);
902         if (rc) {
903                 err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
904                 return IRQ_NONE;
905         }
906
907         intr_detect = ( ATTN_BUTTN_PRESSED | PWR_FAULT_DETECTED | MRL_SENS_CHANGED |
908                                         PRSN_DETECT_CHANGED | CMD_COMPLETED );
909
910         intr_loc = slot_status & intr_detect;
911
912         /* Check to see if it was our interrupt */
913         if ( !intr_loc )
914                 return IRQ_NONE;
915
916         dbg("%s: intr_loc %x\n", __FUNCTION__, intr_loc);
917         /* Mask Hot-plug Interrupt Enable */
918         if (!pciehp_poll_mode) {
919                 rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(ctrl->cap_base), temp_word);
920                 if (rc) {
921                         err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
922                         return IRQ_NONE;
923                 }
924
925                 dbg("%s: hp_register_read_word SLOT_CTRL with value %x\n", __FUNCTION__, temp_word);
926                 temp_word = (temp_word & ~HP_INTR_ENABLE & ~CMD_CMPL_INTR_ENABLE) | 0x00;
927
928                 rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_CTRL(ctrl->cap_base), temp_word);
929                 if (rc) {
930                         err("%s : hp_register_write_word SLOT_CTRL failed\n", __FUNCTION__);
931                         return IRQ_NONE;
932                 }
933                 
934                 rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), slot_status);
935                 if (rc) {
936                         err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
937                         return IRQ_NONE;
938                 }
939                 dbg("%s: hp_register_read_word SLOT_STATUS with value %x\n", __FUNCTION__, slot_status); 
940                 
941                 /* Clear command complete interrupt caused by this write */
942                 temp_word = 0x1f;
943                 rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), temp_word);
944                 if (rc) {
945                         err("%s : hp_register_write_word SLOT_STATUS failed\n", __FUNCTION__);
946                         return IRQ_NONE;
947                 }
948         }
949         
950         if (intr_loc & CMD_COMPLETED) {
951                 /* 
952                  * Command Complete Interrupt Pending 
953                  */
954                 wake_up_interruptible(&ctrl->queue);
955         }
956
957         if ((php_ctlr->switch_change_callback) && (intr_loc & MRL_SENS_CHANGED))
958                 schedule_flag += php_ctlr->switch_change_callback(
959                         hp_slot, php_ctlr->callback_instance_id);
960         if ((php_ctlr->attention_button_callback) && (intr_loc & ATTN_BUTTN_PRESSED))
961                 schedule_flag += php_ctlr->attention_button_callback(
962                         hp_slot, php_ctlr->callback_instance_id);
963         if ((php_ctlr->presence_change_callback) && (intr_loc & PRSN_DETECT_CHANGED))
964                 schedule_flag += php_ctlr->presence_change_callback(
965                         hp_slot , php_ctlr->callback_instance_id);
966         if ((php_ctlr->power_fault_callback) && (intr_loc & PWR_FAULT_DETECTED))
967                 schedule_flag += php_ctlr->power_fault_callback(
968                         hp_slot, php_ctlr->callback_instance_id);
969
970         /* Clear all events after serving them */
971         temp_word = 0x1F;
972         rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), temp_word);
973         if (rc) {
974                 err("%s : hp_register_write_word SLOT_STATUS failed\n", __FUNCTION__);
975                 return IRQ_NONE;
976         }
977         /* Unmask Hot-plug Interrupt Enable */
978         if (!pciehp_poll_mode) {
979                 rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(ctrl->cap_base), temp_word);
980                 if (rc) {
981                         err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
982                         return IRQ_NONE;
983                 }
984
985                 dbg("%s: Unmask Hot-plug Interrupt Enable\n", __FUNCTION__);
986                 temp_word = (temp_word & ~HP_INTR_ENABLE) | HP_INTR_ENABLE;
987
988                 rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_CTRL(ctrl->cap_base), temp_word);
989                 if (rc) {
990                         err("%s : hp_register_write_word SLOT_CTRL failed\n", __FUNCTION__);
991                         return IRQ_NONE;
992                 }
993         
994                 rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), slot_status);
995                 if (rc) {
996                         err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
997                         return IRQ_NONE;
998                 }
999                 
1000                 /* Clear command complete interrupt caused by this write */
1001                 temp_word = 0x1F;
1002                 rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), temp_word);
1003                 if (rc) {
1004                         err("%s : hp_register_write_word SLOT_STATUS failed\n", __FUNCTION__);
1005                         return IRQ_NONE;
1006                 }
1007                 dbg("%s: hp_register_write_word SLOT_STATUS with value %x\n", __FUNCTION__, temp_word); 
1008         }
1009         
1010         return IRQ_HANDLED;
1011 }
1012
1013 static int hpc_get_max_lnk_speed (struct slot *slot, enum pci_bus_speed *value)
1014 {
1015         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
1016         enum pcie_link_speed lnk_speed;
1017         u32     lnk_cap;
1018         int retval = 0;
1019
1020         DBG_ENTER_ROUTINE 
1021
1022         if (!php_ctlr) {
1023                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
1024                 return -1;
1025         }
1026
1027         if (slot->hp_slot >= php_ctlr->num_slots) {
1028                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
1029                 return -1;
1030         }
1031
1032         retval = hp_register_read_dword(php_ctlr->pci_dev, LNK_CAP(slot->ctrl->cap_base), lnk_cap);
1033
1034         if (retval) {
1035                 err("%s : hp_register_read_dword  LNK_CAP failed\n", __FUNCTION__);
1036                 return retval;
1037         }
1038
1039         switch (lnk_cap & 0x000F) {
1040         case 1:
1041                 lnk_speed = PCIE_2PT5GB;
1042                 break;
1043         default:
1044                 lnk_speed = PCIE_LNK_SPEED_UNKNOWN;
1045                 break;
1046         }
1047
1048         *value = lnk_speed;
1049         dbg("Max link speed = %d\n", lnk_speed);
1050         DBG_LEAVE_ROUTINE 
1051         return retval;
1052 }
1053
1054 static int hpc_get_max_lnk_width (struct slot *slot, enum pcie_link_width *value)
1055 {
1056         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
1057         enum pcie_link_width lnk_wdth;
1058         u32     lnk_cap;
1059         int retval = 0;
1060
1061         DBG_ENTER_ROUTINE 
1062
1063         if (!php_ctlr) {
1064                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
1065                 return -1;
1066         }
1067
1068         if (slot->hp_slot >= php_ctlr->num_slots) {
1069                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
1070                 return -1;
1071         }
1072
1073         retval = hp_register_read_dword(php_ctlr->pci_dev, LNK_CAP(slot->ctrl->cap_base), lnk_cap);
1074
1075         if (retval) {
1076                 err("%s : hp_register_read_dword  LNK_CAP failed\n", __FUNCTION__);
1077                 return retval;
1078         }
1079
1080         switch ((lnk_cap & 0x03F0) >> 4){
1081         case 0:
1082                 lnk_wdth = PCIE_LNK_WIDTH_RESRV;
1083                 break;
1084         case 1:
1085                 lnk_wdth = PCIE_LNK_X1;
1086                 break;
1087         case 2:
1088                 lnk_wdth = PCIE_LNK_X2;
1089                 break;
1090         case 4:
1091                 lnk_wdth = PCIE_LNK_X4;
1092                 break;
1093         case 8:
1094                 lnk_wdth = PCIE_LNK_X8;
1095                 break;
1096         case 12:
1097                 lnk_wdth = PCIE_LNK_X12;
1098                 break;
1099         case 16:
1100                 lnk_wdth = PCIE_LNK_X16;
1101                 break;
1102         case 32:
1103                 lnk_wdth = PCIE_LNK_X32;
1104                 break;
1105         default:
1106                 lnk_wdth = PCIE_LNK_WIDTH_UNKNOWN;
1107                 break;
1108         }
1109
1110         *value = lnk_wdth;
1111         dbg("Max link width = %d\n", lnk_wdth);
1112         DBG_LEAVE_ROUTINE 
1113         return retval;
1114 }
1115
1116 static int hpc_get_cur_lnk_speed (struct slot *slot, enum pci_bus_speed *value)
1117 {
1118         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
1119         enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN;
1120         int retval = 0;
1121         u16 lnk_status;
1122
1123         DBG_ENTER_ROUTINE 
1124
1125         if (!php_ctlr) {
1126                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
1127                 return -1;
1128         }
1129
1130         if (slot->hp_slot >= php_ctlr->num_slots) {
1131                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
1132                 return -1;
1133         }
1134
1135         retval = hp_register_read_word(php_ctlr->pci_dev, LNK_STATUS(slot->ctrl->cap_base), lnk_status);
1136
1137         if (retval) {
1138                 err("%s : hp_register_read_word LNK_STATUS failed\n", __FUNCTION__);
1139                 return retval;
1140         }
1141
1142         switch (lnk_status & 0x0F) {
1143         case 1:
1144                 lnk_speed = PCIE_2PT5GB;
1145                 break;
1146         default:
1147                 lnk_speed = PCIE_LNK_SPEED_UNKNOWN;
1148                 break;
1149         }
1150
1151         *value = lnk_speed;
1152         dbg("Current link speed = %d\n", lnk_speed);
1153         DBG_LEAVE_ROUTINE 
1154         return retval;
1155 }
1156
1157 static int hpc_get_cur_lnk_width (struct slot *slot, enum pcie_link_width *value)
1158 {
1159         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
1160         enum pcie_link_width lnk_wdth = PCIE_LNK_WIDTH_UNKNOWN;
1161         int retval = 0;
1162         u16 lnk_status;
1163
1164         DBG_ENTER_ROUTINE 
1165
1166         if (!php_ctlr) {
1167                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
1168                 return -1;
1169         }
1170
1171         if (slot->hp_slot >= php_ctlr->num_slots) {
1172                 err("%s: Invalid HPC slot number!\n", __FUNCTION__);
1173                 return -1;
1174         }
1175
1176         retval = hp_register_read_word(php_ctlr->pci_dev, LNK_STATUS(slot->ctrl->cap_base), lnk_status);
1177
1178         if (retval) {
1179                 err("%s : hp_register_read_word LNK_STATUS failed\n", __FUNCTION__);
1180                 return retval;
1181         }
1182         
1183         switch ((lnk_status & 0x03F0) >> 4){
1184         case 0:
1185                 lnk_wdth = PCIE_LNK_WIDTH_RESRV;
1186                 break;
1187         case 1:
1188                 lnk_wdth = PCIE_LNK_X1;
1189                 break;
1190         case 2:
1191                 lnk_wdth = PCIE_LNK_X2;
1192                 break;
1193         case 4:
1194                 lnk_wdth = PCIE_LNK_X4;
1195                 break;
1196         case 8:
1197                 lnk_wdth = PCIE_LNK_X8;
1198                 break;
1199         case 12:
1200                 lnk_wdth = PCIE_LNK_X12;
1201                 break;
1202         case 16:
1203                 lnk_wdth = PCIE_LNK_X16;
1204                 break;
1205         case 32:
1206                 lnk_wdth = PCIE_LNK_X32;
1207                 break;
1208         default:
1209                 lnk_wdth = PCIE_LNK_WIDTH_UNKNOWN;
1210                 break;
1211         }
1212
1213         *value = lnk_wdth;
1214         dbg("Current link width = %d\n", lnk_wdth);
1215         DBG_LEAVE_ROUTINE 
1216         return retval;
1217 }
1218
1219 static struct hpc_ops pciehp_hpc_ops = {
1220         .power_on_slot                  = hpc_power_on_slot,
1221         .power_off_slot                 = hpc_power_off_slot,
1222         .set_attention_status           = hpc_set_attention_status,
1223         .get_power_status               = hpc_get_power_status,
1224         .get_attention_status           = hpc_get_attention_status,
1225         .get_latch_status               = hpc_get_latch_status,
1226         .get_adapter_status             = hpc_get_adapter_status,
1227
1228         .get_max_bus_speed              = hpc_get_max_lnk_speed,
1229         .get_cur_bus_speed              = hpc_get_cur_lnk_speed,
1230         .get_max_lnk_width              = hpc_get_max_lnk_width,
1231         .get_cur_lnk_width              = hpc_get_cur_lnk_width,
1232         
1233         .query_power_fault              = hpc_query_power_fault,
1234         .green_led_on                   = hpc_set_green_led_on,
1235         .green_led_off                  = hpc_set_green_led_off,
1236         .green_led_blink                = hpc_set_green_led_blink,
1237         
1238         .release_ctlr                   = hpc_release_ctlr,
1239         .check_lnk_status               = hpc_check_lnk_status,
1240 };
1241
1242 #ifdef CONFIG_ACPI
1243 int pciehp_acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev)
1244 {
1245         acpi_status status;
1246         acpi_handle chandle, handle = DEVICE_ACPI_HANDLE(&(dev->dev));
1247         struct pci_dev *pdev = dev;
1248         struct pci_bus *parent;
1249         struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL };
1250
1251         /*
1252          * Per PCI firmware specification, we should run the ACPI _OSC
1253          * method to get control of hotplug hardware before using it.
1254          * If an _OSC is missing, we look for an OSHP to do the same thing.
1255          * To handle different BIOS behavior, we look for _OSC and OSHP
1256          * within the scope of the hotplug controller and its parents, upto
1257          * the host bridge under which this controller exists.
1258          */
1259         while (!handle) {
1260                 /*
1261                  * This hotplug controller was not listed in the ACPI name
1262                  * space at all. Try to get acpi handle of parent pci bus.
1263                  */
1264                 if (!pdev || !pdev->bus->parent)
1265                         break;
1266                 parent = pdev->bus->parent;
1267                 dbg("Could not find %s in acpi namespace, trying parent\n",
1268                                 pci_name(pdev));
1269                 if (!parent->self)
1270                         /* Parent must be a host bridge */
1271                         handle = acpi_get_pci_rootbridge_handle(
1272                                         pci_domain_nr(parent),
1273                                         parent->number);
1274                 else
1275                         handle = DEVICE_ACPI_HANDLE(
1276                                         &(parent->self->dev));
1277                 pdev = parent->self;
1278         }
1279
1280         while (handle) {
1281                 acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
1282                 dbg("Trying to get hotplug control for %s \n",
1283                         (char *)string.pointer);
1284                 status = pci_osc_control_set(handle,
1285                                 OSC_PCI_EXPRESS_NATIVE_HP_CONTROL);
1286                 if (status == AE_NOT_FOUND)
1287                         status = acpi_run_oshp(handle);
1288                 if (ACPI_SUCCESS(status)) {
1289                         dbg("Gained control for hotplug HW for pci %s (%s)\n",
1290                                 pci_name(dev), (char *)string.pointer);
1291                         kfree(string.pointer);
1292                         return 0;
1293                 }
1294                 if (acpi_root_bridge(handle))
1295                         break;
1296                 chandle = handle;
1297                 status = acpi_get_parent(chandle, &handle);
1298                 if (ACPI_FAILURE(status))
1299                         break;
1300         }
1301
1302         err("Cannot get control of hotplug hardware for pci %s\n",
1303                         pci_name(dev));
1304
1305         kfree(string.pointer);
1306         return -1;
1307 }
1308 #endif
1309
1310
1311
1312 int pcie_init(struct controller * ctrl, struct pcie_device *dev)
1313 {
1314         struct php_ctlr_state_s *php_ctlr, *p;
1315         void *instance_id = ctrl;
1316         int rc;
1317         static int first = 1;
1318         u16 temp_word;
1319         u16 cap_reg;
1320         u16 intr_enable = 0;
1321         u32 slot_cap;
1322         int cap_base, saved_cap_base;
1323         u16 slot_status, slot_ctrl;
1324         struct pci_dev *pdev;
1325
1326         DBG_ENTER_ROUTINE
1327         
1328         spin_lock_init(&list_lock);     
1329         php_ctlr = (struct php_ctlr_state_s *) kmalloc(sizeof(struct php_ctlr_state_s), GFP_KERNEL);
1330
1331         if (!php_ctlr) {        /* allocate controller state data */
1332                 err("%s: HPC controller memory allocation error!\n", __FUNCTION__);
1333                 goto abort;
1334         }
1335
1336         memset(php_ctlr, 0, sizeof(struct php_ctlr_state_s));
1337         
1338         pdev = dev->port;
1339         php_ctlr->pci_dev = pdev;       /* save pci_dev in context */
1340
1341         dbg("%s: hotplug controller vendor id 0x%x device id 0x%x\n",
1342                         __FUNCTION__, pdev->vendor, pdev->device);
1343
1344         saved_cap_base = pcie_cap_base;
1345
1346         if ((cap_base = pci_find_capability(pdev, PCI_CAP_ID_EXP)) == 0) {
1347                 dbg("%s: Can't find PCI_CAP_ID_EXP (0x10)\n", __FUNCTION__);
1348                 goto abort_free_ctlr;
1349         }
1350
1351         ctrl->cap_base = cap_base;
1352
1353         dbg("%s: pcie_cap_base %x\n", __FUNCTION__, pcie_cap_base);
1354
1355         rc = hp_register_read_word(pdev, CAP_REG(ctrl->cap_base), cap_reg);
1356         if (rc) {
1357                 err("%s : hp_register_read_word CAP_REG failed\n", __FUNCTION__);
1358                 goto abort_free_ctlr;
1359         }
1360         dbg("%s: CAP_REG offset %x cap_reg %x\n", __FUNCTION__, CAP_REG(ctrl->cap_base), cap_reg);
1361
1362         if (((cap_reg & SLOT_IMPL) == 0) || (((cap_reg & DEV_PORT_TYPE) != 0x0040)
1363                 && ((cap_reg & DEV_PORT_TYPE) != 0x0060))) {
1364                 dbg("%s : This is not a root port or the port is not connected to a slot\n", __FUNCTION__);
1365                 goto abort_free_ctlr;
1366         }
1367
1368         rc = hp_register_read_dword(php_ctlr->pci_dev, SLOT_CAP(ctrl->cap_base), slot_cap);
1369         if (rc) {
1370                 err("%s : hp_register_read_word CAP_REG failed\n", __FUNCTION__);
1371                 goto abort_free_ctlr;
1372         }
1373         dbg("%s: SLOT_CAP offset %x slot_cap %x\n", __FUNCTION__, SLOT_CAP(ctrl->cap_base), slot_cap);
1374
1375         if (!(slot_cap & HP_CAP)) {
1376                 dbg("%s : This slot is not hot-plug capable\n", __FUNCTION__);
1377                 goto abort_free_ctlr;
1378         }
1379         /* For debugging purpose */
1380         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), slot_status);
1381         if (rc) {
1382                 err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
1383                 goto abort_free_ctlr;
1384         }
1385         dbg("%s: SLOT_STATUS offset %x slot_status %x\n", __FUNCTION__, SLOT_STATUS(ctrl->cap_base), slot_status);
1386
1387         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL(ctrl->cap_base), slot_ctrl);
1388         if (rc) {
1389                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
1390                 goto abort_free_ctlr;
1391         }
1392         dbg("%s: SLOT_CTRL offset %x slot_ctrl %x\n", __FUNCTION__, SLOT_CTRL(ctrl->cap_base), slot_ctrl);
1393
1394         if (first) {
1395                 spin_lock_init(&hpc_event_lock);
1396                 first = 0;
1397         }
1398
1399         for ( rc = 0; rc < DEVICE_COUNT_RESOURCE; rc++)
1400                 if (pci_resource_len(pdev, rc) > 0)
1401                         dbg("pci resource[%d] start=0x%llx(len=0x%llx)\n", rc,
1402                             (unsigned long long)pci_resource_start(pdev, rc),
1403                             (unsigned long long)pci_resource_len(pdev, rc));
1404
1405         info("HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n", pdev->vendor, pdev->device, 
1406                 pdev->subsystem_vendor, pdev->subsystem_device);
1407
1408         mutex_init(&ctrl->crit_sect);
1409         /* setup wait queue */
1410         init_waitqueue_head(&ctrl->queue);
1411
1412         /* find the IRQ */
1413         php_ctlr->irq = dev->irq;
1414
1415         /* Save interrupt callback info */
1416         php_ctlr->attention_button_callback = pciehp_handle_attention_button;
1417         php_ctlr->switch_change_callback = pciehp_handle_switch_change;
1418         php_ctlr->presence_change_callback = pciehp_handle_presence_change;
1419         php_ctlr->power_fault_callback = pciehp_handle_power_fault;
1420         php_ctlr->callback_instance_id = instance_id;
1421
1422         /* return PCI Controller Info */
1423         php_ctlr->slot_device_offset = 0;
1424         php_ctlr->num_slots = 1;
1425
1426         /* Mask Hot-plug Interrupt Enable */
1427         rc = hp_register_read_word(pdev, SLOT_CTRL(ctrl->cap_base), temp_word);
1428         if (rc) {
1429                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
1430                 goto abort_free_ctlr;
1431         }
1432
1433         dbg("%s: SLOT_CTRL %x value read %x\n", __FUNCTION__, SLOT_CTRL(ctrl->cap_base), temp_word);
1434         temp_word = (temp_word & ~HP_INTR_ENABLE & ~CMD_CMPL_INTR_ENABLE) | 0x00;
1435
1436         rc = hp_register_write_word(pdev, SLOT_CTRL(ctrl->cap_base), temp_word);
1437         if (rc) {
1438                 err("%s : hp_register_write_word SLOT_CTRL failed\n", __FUNCTION__);
1439                 goto abort_free_ctlr;
1440         }
1441
1442         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), slot_status);
1443         if (rc) {
1444                 err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
1445                 goto abort_free_ctlr;
1446         }
1447
1448         temp_word = 0x1F; /* Clear all events */
1449         rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), temp_word);
1450         if (rc) {
1451                 err("%s : hp_register_write_word SLOT_STATUS failed\n", __FUNCTION__);
1452                 goto abort_free_ctlr;
1453         }
1454
1455         if (pciehp_poll_mode)  {/* Install interrupt polling code */
1456                 /* Install and start the interrupt polling timer */
1457                 init_timer(&php_ctlr->int_poll_timer);
1458                 start_int_poll_timer( php_ctlr, 10 );   /* start with 10 second delay */
1459         } else {
1460                 /* Installs the interrupt handler */
1461                 rc = request_irq(php_ctlr->irq, pcie_isr, SA_SHIRQ, MY_NAME, (void *) ctrl);
1462                 dbg("%s: request_irq %d for hpc%d (returns %d)\n", __FUNCTION__, php_ctlr->irq, ctlr_seq_num, rc);
1463                 if (rc) {
1464                         err("Can't get irq %d for the hotplug controller\n", php_ctlr->irq);
1465                         goto abort_free_ctlr;
1466                 }
1467         }
1468
1469         dbg("pciehp ctrl b:d:f:irq=0x%x:%x:%x:%x\n", pdev->bus->number,
1470                 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn), dev->irq);
1471
1472         rc = hp_register_read_word(pdev, SLOT_CTRL(ctrl->cap_base), temp_word);
1473         if (rc) {
1474                 err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
1475                 goto abort_free_irq;
1476         }
1477
1478         intr_enable = intr_enable | PRSN_DETECT_ENABLE;
1479
1480         if (ATTN_BUTTN(slot_cap))
1481                 intr_enable = intr_enable | ATTN_BUTTN_ENABLE;
1482         
1483         if (POWER_CTRL(slot_cap))
1484                 intr_enable = intr_enable | PWR_FAULT_DETECT_ENABLE;
1485         
1486         if (MRL_SENS(slot_cap))
1487                 intr_enable = intr_enable | MRL_DETECT_ENABLE;
1488
1489         temp_word = (temp_word & ~intr_enable) | intr_enable; 
1490
1491         if (pciehp_poll_mode) {
1492                 temp_word = (temp_word & ~HP_INTR_ENABLE) | 0x0;
1493         } else {
1494                 temp_word = (temp_word & ~HP_INTR_ENABLE) | HP_INTR_ENABLE;
1495         }
1496
1497         /* Unmask Hot-plug Interrupt Enable for the interrupt notification mechanism case */
1498         rc = hp_register_write_word(pdev, SLOT_CTRL(ctrl->cap_base), temp_word);
1499         if (rc) {
1500                 err("%s : hp_register_write_word SLOT_CTRL failed\n", __FUNCTION__);
1501                 goto abort_free_irq;
1502         }
1503         rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), slot_status);
1504         if (rc) {
1505                 err("%s : hp_register_read_word SLOT_STATUS failed\n", __FUNCTION__);
1506                 goto abort_disable_intr;
1507         }
1508         
1509         temp_word =  0x1F; /* Clear all events */
1510         rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_STATUS(ctrl->cap_base), temp_word);
1511         if (rc) {
1512                 err("%s : hp_register_write_word SLOT_STATUS failed\n", __FUNCTION__);
1513                 goto abort_disable_intr;
1514         }
1515         
1516         if (pciehp_force) {
1517                 dbg("Bypassing BIOS check for pciehp use on %s\n",
1518                                 pci_name(ctrl->pci_dev));
1519         } else {
1520                 rc = pciehp_get_hp_hw_control_from_firmware(ctrl->pci_dev);
1521                 if (rc)
1522                         goto abort_disable_intr;
1523         }
1524
1525         /*  Add this HPC instance into the HPC list */
1526         spin_lock(&list_lock);
1527         if (php_ctlr_list_head == 0) {
1528                 php_ctlr_list_head = php_ctlr;
1529                 p = php_ctlr_list_head;
1530                 p->pnext = NULL;
1531         } else {
1532                 p = php_ctlr_list_head;
1533
1534                 while (p->pnext)
1535                         p = p->pnext;
1536
1537                 p->pnext = php_ctlr;
1538         }
1539         spin_unlock(&list_lock);
1540
1541         ctlr_seq_num++;
1542         ctrl->hpc_ctlr_handle = php_ctlr;
1543         ctrl->hpc_ops = &pciehp_hpc_ops;
1544
1545         DBG_LEAVE_ROUTINE
1546         return 0;
1547
1548         /* We end up here for the many possible ways to fail this API.  */
1549 abort_disable_intr:
1550         rc = hp_register_read_word(pdev, SLOT_CTRL(ctrl->cap_base), temp_word);
1551         if (!rc) {
1552                 temp_word &= ~(intr_enable | HP_INTR_ENABLE);
1553                 rc = hp_register_write_word(pdev, SLOT_CTRL(ctrl->cap_base), temp_word);
1554         }
1555         if (rc)
1556                 err("%s : disabling interrupts failed\n", __FUNCTION__);
1557
1558 abort_free_irq:
1559         if (pciehp_poll_mode)
1560                 del_timer_sync(&php_ctlr->int_poll_timer);
1561         else
1562                 free_irq(php_ctlr->irq, ctrl);
1563
1564 abort_free_ctlr:
1565         pcie_cap_base = saved_cap_base;
1566         kfree(php_ctlr);
1567 abort:
1568         DBG_LEAVE_ROUTINE
1569         return -1;
1570 }