2 * IBM Hot Plug Controller Driver
4 * Written By: Jyoti Shah, IBM Corporation
6 * Copyright (c) 2001-2003 IBM Corp.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
18 * NON INFRINGEMENT. See the GNU General Public License for more
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Send feedback to <gregkh@us.ibm.com>
30 #include <linux/wait.h>
31 #include <linux/time.h>
32 #include <linux/module.h>
33 #include <linux/pci.h>
34 #include <linux/smp_lock.h>
35 #include <linux/init.h>
38 static int to_debug
= FALSE
;
39 #define debug_polling(fmt, arg...) do { if (to_debug) debug (fmt, arg); } while (0)
41 //----------------------------------------------------------------------------
43 //----------------------------------------------------------------------------
44 #define CMD_COMPLETE_TOUT_SEC 60 // give HPC 60 sec to finish cmd
45 #define HPC_CTLR_WORKING_TOUT 60 // give HPC 60 sec to finish cmd
46 #define HPC_GETACCESS_TIMEOUT 60 // seconds
47 #define POLL_INTERVAL_SEC 2 // poll HPC every 2 seconds
48 #define POLL_LATCH_CNT 5 // poll latch 5 times, then poll slots
50 //----------------------------------------------------------------------------
51 // Winnipeg Architected Register Offsets
52 //----------------------------------------------------------------------------
53 #define WPG_I2CMBUFL_OFFSET 0x08 // I2C Message Buffer Low
54 #define WPG_I2CMOSUP_OFFSET 0x10 // I2C Master Operation Setup Reg
55 #define WPG_I2CMCNTL_OFFSET 0x20 // I2C Master Control Register
56 #define WPG_I2CPARM_OFFSET 0x40 // I2C Parameter Register
57 #define WPG_I2CSTAT_OFFSET 0x70 // I2C Status Register
59 //----------------------------------------------------------------------------
60 // Winnipeg Store Type commands (Add this commands to the register offset)
61 //----------------------------------------------------------------------------
62 #define WPG_I2C_AND 0x1000 // I2C AND operation
63 #define WPG_I2C_OR 0x2000 // I2C OR operation
65 //----------------------------------------------------------------------------
66 // Command set for I2C Master Operation Setup Regisetr
67 //----------------------------------------------------------------------------
68 #define WPG_READATADDR_MASK 0x00010000 // read,bytes,I2C shifted,index
69 #define WPG_WRITEATADDR_MASK 0x40010000 // write,bytes,I2C shifted,index
70 #define WPG_READDIRECT_MASK 0x10010000
71 #define WPG_WRITEDIRECT_MASK 0x60010000
74 //----------------------------------------------------------------------------
75 // bit masks for I2C Master Control Register
76 //----------------------------------------------------------------------------
77 #define WPG_I2CMCNTL_STARTOP_MASK 0x00000002 // Start the Operation
79 //----------------------------------------------------------------------------
81 //----------------------------------------------------------------------------
82 #define WPG_I2C_IOREMAP_SIZE 0x2044 // size of linear address interval
84 //----------------------------------------------------------------------------
86 //----------------------------------------------------------------------------
87 #define WPG_1ST_SLOT_INDEX 0x01 // index - 1st slot for ctlr
88 #define WPG_CTLR_INDEX 0x0F // index - ctlr
89 #define WPG_1ST_EXTSLOT_INDEX 0x10 // index - 1st ext slot for ctlr
90 #define WPG_1ST_BUS_INDEX 0x1F // index - 1st bus for ctlr
92 //----------------------------------------------------------------------------
94 //----------------------------------------------------------------------------
95 // if bits 20,22,25,26,27,29,30 are OFF return TRUE
96 #define HPC_I2CSTATUS_CHECK(s) ((u8)((s & 0x00000A76) ? FALSE : TRUE))
98 //----------------------------------------------------------------------------
100 //----------------------------------------------------------------------------
101 static int ibmphp_shutdown
;
103 static struct semaphore sem_hpcaccess
; // lock access to HPC
104 static struct semaphore semOperations
; // lock all operations and
105 // access to data structures
106 static struct semaphore sem_exit
; // make sure polling thread goes away
107 //----------------------------------------------------------------------------
108 // local function prototypes
109 //----------------------------------------------------------------------------
110 static u8
i2c_ctrl_read (struct controller
*, void *, u8
);
111 static u8
i2c_ctrl_write (struct controller
*, void *, u8
, u8
);
112 static u8
hpc_writecmdtoindex (u8
, u8
);
113 static u8
hpc_readcmdtoindex (u8
, u8
);
114 static void get_hpc_access (void);
115 static void free_hpc_access (void);
116 static void poll_hpc (void);
117 static int process_changeinstatus (struct slot
*, struct slot
*);
118 static int process_changeinlatch (u8
, u8
, struct controller
*);
119 static int hpc_poll_thread (void *);
120 static int hpc_wait_ctlr_notworking (int, struct controller
*, void *, u8
*);
121 //----------------------------------------------------------------------------
124 /*----------------------------------------------------------------------
125 * Name: ibmphp_hpc_initvars
127 * Action: initialize semaphores and variables
128 *---------------------------------------------------------------------*/
129 void __init
ibmphp_hpc_initvars (void)
131 debug ("%s - Entry\n", __FUNCTION__
);
133 init_MUTEX (&sem_hpcaccess
);
134 init_MUTEX (&semOperations
);
135 init_MUTEX_LOCKED (&sem_exit
);
137 ibmphp_shutdown
= FALSE
;
140 debug ("%s - Exit\n", __FUNCTION__
);
143 /*----------------------------------------------------------------------
144 * Name: i2c_ctrl_read
146 * Action: read from HPC over I2C
148 *---------------------------------------------------------------------*/
149 static u8
i2c_ctrl_read (struct controller
*ctlr_ptr
, void *WPGBbar
, u8 index
)
153 void *wpg_addr
; // base addr + offset
154 unsigned long wpg_data
; // data to/from WPG LOHI format
155 unsigned long ultemp
;
156 unsigned long data
; // actual data HILO format
158 debug_polling ("%s - Entry WPGBbar[%p] index[%x] \n", __FUNCTION__
, WPGBbar
, index
);
160 //--------------------------------------------------------------------
162 // read at address, byte length, I2C address (shifted), index
163 // or read direct, byte length, index
164 if (ctlr_ptr
->ctlr_type
== 0x02) {
165 data
= WPG_READATADDR_MASK
;
166 // fill in I2C address
167 ultemp
= (unsigned long)ctlr_ptr
->u
.wpeg_ctlr
.i2c_addr
;
168 ultemp
= ultemp
>> 1;
169 data
|= (ultemp
<< 8);
172 data
|= (unsigned long)index
;
173 } else if (ctlr_ptr
->ctlr_type
== 0x04) {
174 data
= WPG_READDIRECT_MASK
;
177 ultemp
= (unsigned long)index
;
178 ultemp
= ultemp
<< 8;
181 err ("this controller type is not supported \n");
185 wpg_data
= swab32 (data
); // swap data before writing
186 wpg_addr
= WPGBbar
+ WPG_I2CMOSUP_OFFSET
;
187 writel (wpg_data
, wpg_addr
);
189 //--------------------------------------------------------------------
190 // READ - step 2 : clear the message buffer
192 wpg_data
= swab32 (data
);
193 wpg_addr
= WPGBbar
+ WPG_I2CMBUFL_OFFSET
;
194 writel (wpg_data
, wpg_addr
);
196 //--------------------------------------------------------------------
197 // READ - step 3 : issue start operation, I2C master control bit 30:ON
198 // 2020 : [20] OR operation at [20] offset 0x20
199 data
= WPG_I2CMCNTL_STARTOP_MASK
;
200 wpg_data
= swab32 (data
);
201 wpg_addr
= WPGBbar
+ WPG_I2CMCNTL_OFFSET
+ WPG_I2C_OR
;
202 writel (wpg_data
, wpg_addr
);
204 //--------------------------------------------------------------------
205 // READ - step 4 : wait until start operation bit clears
206 i
= CMD_COMPLETE_TOUT_SEC
;
208 long_delay (1 * HZ
/ 100);
209 wpg_addr
= WPGBbar
+ WPG_I2CMCNTL_OFFSET
;
210 wpg_data
= readl (wpg_addr
);
211 data
= swab32 (wpg_data
);
212 if (!(data
& WPG_I2CMCNTL_STARTOP_MASK
))
217 debug ("%s - Error : WPG timeout\n", __FUNCTION__
);
220 //--------------------------------------------------------------------
221 // READ - step 5 : read I2C status register
222 i
= CMD_COMPLETE_TOUT_SEC
;
224 long_delay (1 * HZ
/ 100);
225 wpg_addr
= WPGBbar
+ WPG_I2CSTAT_OFFSET
;
226 wpg_data
= readl (wpg_addr
);
227 data
= swab32 (wpg_data
);
228 if (HPC_I2CSTATUS_CHECK (data
))
233 debug ("ctrl_read - Exit Error:I2C timeout\n");
237 //--------------------------------------------------------------------
238 // READ - step 6 : get DATA
239 wpg_addr
= WPGBbar
+ WPG_I2CMBUFL_OFFSET
;
240 wpg_data
= readl (wpg_addr
);
241 data
= swab32 (wpg_data
);
245 debug_polling ("%s - Exit index[%x] status[%x]\n", __FUNCTION__
, index
, status
);
250 /*----------------------------------------------------------------------
251 * Name: i2c_ctrl_write
253 * Action: write to HPC over I2C
255 * Return 0 or error codes
256 *---------------------------------------------------------------------*/
257 static u8
i2c_ctrl_write (struct controller
*ctlr_ptr
, void *WPGBbar
, u8 index
, u8 cmd
)
260 void *wpg_addr
; // base addr + offset
261 unsigned long wpg_data
; // data to/from WPG LOHI format
262 unsigned long ultemp
;
263 unsigned long data
; // actual data HILO format
266 debug_polling ("%s - Entry WPGBbar[%p] index[%x] cmd[%x]\n", __FUNCTION__
, WPGBbar
, index
, cmd
);
269 //--------------------------------------------------------------------
271 // write at address, byte length, I2C address (shifted), index
272 // or write direct, byte length, index
275 if (ctlr_ptr
->ctlr_type
== 0x02) {
276 data
= WPG_WRITEATADDR_MASK
;
277 // fill in I2C address
278 ultemp
= (unsigned long)ctlr_ptr
->u
.wpeg_ctlr
.i2c_addr
;
279 ultemp
= ultemp
>> 1;
280 data
|= (ultemp
<< 8);
283 data
|= (unsigned long)index
;
284 } else if (ctlr_ptr
->ctlr_type
== 0x04) {
285 data
= WPG_WRITEDIRECT_MASK
;
288 ultemp
= (unsigned long)index
;
289 ultemp
= ultemp
<< 8;
292 err ("this controller type is not supported \n");
296 wpg_data
= swab32 (data
); // swap data before writing
297 wpg_addr
= WPGBbar
+ WPG_I2CMOSUP_OFFSET
;
298 writel (wpg_data
, wpg_addr
);
300 //--------------------------------------------------------------------
301 // WRITE - step 2 : clear the message buffer
302 data
= 0x00000000 | (unsigned long)cmd
;
303 wpg_data
= swab32 (data
);
304 wpg_addr
= WPGBbar
+ WPG_I2CMBUFL_OFFSET
;
305 writel (wpg_data
, wpg_addr
);
307 //--------------------------------------------------------------------
308 // WRITE - step 3 : issue start operation,I2C master control bit 30:ON
309 // 2020 : [20] OR operation at [20] offset 0x20
310 data
= WPG_I2CMCNTL_STARTOP_MASK
;
311 wpg_data
= swab32 (data
);
312 wpg_addr
= WPGBbar
+ WPG_I2CMCNTL_OFFSET
+ WPG_I2C_OR
;
313 writel (wpg_data
, wpg_addr
);
315 //--------------------------------------------------------------------
316 // WRITE - step 4 : wait until start operation bit clears
317 i
= CMD_COMPLETE_TOUT_SEC
;
319 long_delay (1 * HZ
/ 100);
320 wpg_addr
= WPGBbar
+ WPG_I2CMCNTL_OFFSET
;
321 wpg_data
= readl (wpg_addr
);
322 data
= swab32 (wpg_data
);
323 if (!(data
& WPG_I2CMCNTL_STARTOP_MASK
))
328 debug ("%s - Exit Error:WPG timeout\n", __FUNCTION__
);
332 //--------------------------------------------------------------------
333 // WRITE - step 5 : read I2C status register
334 i
= CMD_COMPLETE_TOUT_SEC
;
336 long_delay (1 * HZ
/ 100);
337 wpg_addr
= WPGBbar
+ WPG_I2CSTAT_OFFSET
;
338 wpg_data
= readl (wpg_addr
);
339 data
= swab32 (wpg_data
);
340 if (HPC_I2CSTATUS_CHECK (data
))
345 debug ("ctrl_read - Error : I2C timeout\n");
349 debug_polling ("%s Exit rc[%x]\n", __FUNCTION__
, rc
);
353 //------------------------------------------------------------
354 // Read from ISA type HPC
355 //------------------------------------------------------------
356 static u8
isa_ctrl_read (struct controller
*ctlr_ptr
, u8 offset
)
362 start_address
= ctlr_ptr
->u
.isa_ctlr
.io_start
;
363 end_address
= ctlr_ptr
->u
.isa_ctlr
.io_end
;
364 data
= inb (start_address
+ offset
);
368 //--------------------------------------------------------------
369 // Write to ISA type HPC
370 //--------------------------------------------------------------
371 static void isa_ctrl_write (struct controller
*ctlr_ptr
, u8 offset
, u8 data
)
376 start_address
= ctlr_ptr
->u
.isa_ctlr
.io_start
;
377 port_address
= start_address
+ (u16
) offset
;
378 outb (data
, port_address
);
381 static u8
pci_ctrl_read (struct controller
*ctrl
, u8 offset
)
384 debug ("inside pci_ctrl_read\n");
386 pci_read_config_byte (ctrl
->ctrl_dev
, HPC_PCI_OFFSET
+ offset
, &data
);
390 static u8
pci_ctrl_write (struct controller
*ctrl
, u8 offset
, u8 data
)
393 debug ("inside pci_ctrl_write\n");
394 if (ctrl
->ctrl_dev
) {
395 pci_write_config_byte (ctrl
->ctrl_dev
, HPC_PCI_OFFSET
+ offset
, data
);
401 static u8
ctrl_read (struct controller
*ctlr
, void *base
, u8 offset
)
404 switch (ctlr
->ctlr_type
) {
406 rc
= isa_ctrl_read (ctlr
, offset
);
409 rc
= pci_ctrl_read (ctlr
, offset
);
413 rc
= i2c_ctrl_read (ctlr
, base
, offset
);
421 static u8
ctrl_write (struct controller
*ctlr
, void *base
, u8 offset
, u8 data
)
424 switch (ctlr
->ctlr_type
) {
426 isa_ctrl_write(ctlr
, offset
, data
);
429 rc
= pci_ctrl_write (ctlr
, offset
, data
);
433 rc
= i2c_ctrl_write(ctlr
, base
, offset
, data
);
440 /*----------------------------------------------------------------------
441 * Name: hpc_writecmdtoindex()
443 * Action: convert a write command to proper index within a controller
445 * Return index, HPC_ERROR
446 *---------------------------------------------------------------------*/
447 static u8
hpc_writecmdtoindex (u8 cmd
, u8 index
)
452 case HPC_CTLR_ENABLEIRQ
: // 0x00.N.15
453 case HPC_CTLR_CLEARIRQ
: // 0x06.N.15
454 case HPC_CTLR_RESET
: // 0x07.N.15
455 case HPC_CTLR_IRQSTEER
: // 0x08.N.15
456 case HPC_CTLR_DISABLEIRQ
: // 0x01.N.15
457 case HPC_ALLSLOT_ON
: // 0x11.N.15
458 case HPC_ALLSLOT_OFF
: // 0x12.N.15
462 case HPC_SLOT_OFF
: // 0x02.Y.0-14
463 case HPC_SLOT_ON
: // 0x03.Y.0-14
464 case HPC_SLOT_ATTNOFF
: // 0x04.N.0-14
465 case HPC_SLOT_ATTNON
: // 0x05.N.0-14
466 case HPC_SLOT_BLINKLED
: // 0x13.N.0-14
470 case HPC_BUS_33CONVMODE
:
471 case HPC_BUS_66CONVMODE
:
472 case HPC_BUS_66PCIXMODE
:
473 case HPC_BUS_100PCIXMODE
:
474 case HPC_BUS_133PCIXMODE
:
475 rc
= index
+ WPG_1ST_BUS_INDEX
- 1;
479 err ("hpc_writecmdtoindex - Error invalid cmd[%x]\n", cmd
);
486 /*----------------------------------------------------------------------
487 * Name: hpc_readcmdtoindex()
489 * Action: convert a read command to proper index within a controller
491 * Return index, HPC_ERROR
492 *---------------------------------------------------------------------*/
493 static u8
hpc_readcmdtoindex (u8 cmd
, u8 index
)
498 case READ_CTLRSTATUS
:
501 case READ_SLOTSTATUS
:
505 case READ_EXTSLOTSTATUS
:
506 rc
= index
+ WPG_1ST_EXTSLOT_INDEX
;
509 rc
= index
+ WPG_1ST_BUS_INDEX
- 1;
511 case READ_SLOTLATCHLOWREG
:
517 case READ_HPCOPTIONS
:
526 /*----------------------------------------------------------------------
527 * Name: HPCreadslot()
529 * Action: issue a READ command to HPC
531 * Input: pslot - can not be NULL for READ_ALLSTAT
532 * pstatus - can be NULL for READ_ALLSTAT
534 * Return 0 or error codes
535 *---------------------------------------------------------------------*/
536 int ibmphp_hpc_readslot (struct slot
* pslot
, u8 cmd
, u8
* pstatus
)
538 void *wpg_bbar
= NULL
;
539 struct controller
*ctlr_ptr
;
540 struct list_head
*pslotlist
;
545 debug_polling ("%s - Entry pslot[%p] cmd[%x] pstatus[%p]\n", __FUNCTION__
, pslot
, cmd
, pstatus
);
548 || ((pstatus
== NULL
) && (cmd
!= READ_ALLSTAT
) && (cmd
!= READ_BUSSTATUS
))) {
550 err ("%s - Error invalid pointer, rc[%d]\n", __FUNCTION__
, rc
);
554 if (cmd
== READ_BUSSTATUS
) {
555 busindex
= ibmphp_get_bus_index (pslot
->bus
);
558 err ("%s - Exit Error:invalid bus, rc[%d]\n", __FUNCTION__
, rc
);
561 index
= (u8
) busindex
;
563 index
= pslot
->ctlr_index
;
565 index
= hpc_readcmdtoindex (cmd
, index
);
567 if (index
== HPC_ERROR
) {
569 err ("%s - Exit Error:invalid index, rc[%d]\n", __FUNCTION__
, rc
);
573 ctlr_ptr
= pslot
->ctrl
;
577 //--------------------------------------------------------------------
578 // map physical address to logical address
579 //--------------------------------------------------------------------
580 if ((ctlr_ptr
->ctlr_type
== 2) || (ctlr_ptr
->ctlr_type
== 4))
581 wpg_bbar
= ioremap (ctlr_ptr
->u
.wpeg_ctlr
.wpegbbar
, WPG_I2C_IOREMAP_SIZE
);
583 //--------------------------------------------------------------------
584 // check controller status before reading
585 //--------------------------------------------------------------------
586 rc
= hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT
, ctlr_ptr
, wpg_bbar
, &status
);
590 // update the slot structure
591 pslot
->ctrl
->status
= status
;
592 pslot
->status
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
593 rc
= hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT
, ctlr_ptr
, wpg_bbar
,
596 pslot
->ext_status
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
+ WPG_1ST_EXTSLOT_INDEX
);
600 case READ_SLOTSTATUS
:
601 // DO NOT update the slot structure
602 *pstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
605 case READ_EXTSLOTSTATUS
:
606 // DO NOT update the slot structure
607 *pstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
610 case READ_CTLRSTATUS
:
611 // DO NOT update the slot structure
616 pslot
->busstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
619 *pstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
621 case READ_HPCOPTIONS
:
622 *pstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
624 case READ_SLOTLATCHLOWREG
:
625 // DO NOT update the slot structure
626 *pstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
631 list_for_each (pslotlist
, &ibmphp_slot_head
) {
632 pslot
= list_entry (pslotlist
, struct slot
, ibm_slot_list
);
633 index
= pslot
->ctlr_index
;
634 rc
= hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT
, ctlr_ptr
,
637 pslot
->status
= ctrl_read (ctlr_ptr
, wpg_bbar
, index
);
638 rc
= hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT
,
639 ctlr_ptr
, wpg_bbar
, &status
);
642 ctrl_read (ctlr_ptr
, wpg_bbar
,
643 index
+ WPG_1ST_EXTSLOT_INDEX
);
645 err ("%s - Error ctrl_read failed\n", __FUNCTION__
);
656 //--------------------------------------------------------------------
658 //--------------------------------------------------------------------
660 // remove physical to logical address mapping
661 if ((ctlr_ptr
->ctlr_type
== 2) || (ctlr_ptr
->ctlr_type
== 4))
666 debug_polling ("%s - Exit rc[%d]\n", __FUNCTION__
, rc
);
670 /*----------------------------------------------------------------------
671 * Name: ibmphp_hpc_writeslot()
673 * Action: issue a WRITE command to HPC
674 *---------------------------------------------------------------------*/
675 int ibmphp_hpc_writeslot (struct slot
* pslot
, u8 cmd
)
677 void *wpg_bbar
= NULL
;
678 struct controller
*ctlr_ptr
;
685 debug_polling ("%s - Entry pslot[%p] cmd[%x]\n", __FUNCTION__
, pslot
, cmd
);
688 err ("%s - Error Exit rc[%d]\n", __FUNCTION__
, rc
);
692 if ((cmd
== HPC_BUS_33CONVMODE
) || (cmd
== HPC_BUS_66CONVMODE
) ||
693 (cmd
== HPC_BUS_66PCIXMODE
) || (cmd
== HPC_BUS_100PCIXMODE
) ||
694 (cmd
== HPC_BUS_133PCIXMODE
)) {
695 busindex
= ibmphp_get_bus_index (pslot
->bus
);
698 err ("%s - Exit Error:invalid bus, rc[%d]\n", __FUNCTION__
, rc
);
701 index
= (u8
) busindex
;
703 index
= pslot
->ctlr_index
;
705 index
= hpc_writecmdtoindex (cmd
, index
);
707 if (index
== HPC_ERROR
) {
709 err ("%s - Error Exit rc[%d]\n", __FUNCTION__
, rc
);
713 ctlr_ptr
= pslot
->ctrl
;
717 //--------------------------------------------------------------------
718 // map physical address to logical address
719 //--------------------------------------------------------------------
720 if ((ctlr_ptr
->ctlr_type
== 2) || (ctlr_ptr
->ctlr_type
== 4)) {
721 wpg_bbar
= ioremap (ctlr_ptr
->u
.wpeg_ctlr
.wpegbbar
, WPG_I2C_IOREMAP_SIZE
);
723 debug ("%s - ctlr id[%x] physical[%lx] logical[%lx] i2c[%x]\n", __FUNCTION__
,
724 ctlr_ptr
->ctlr_id
, (ulong
) (ctlr_ptr
->u
.wpeg_ctlr
.wpegbbar
), (ulong
) wpg_bbar
,
725 ctlr_ptr
->u
.wpeg_ctlr
.i2c_addr
);
727 //--------------------------------------------------------------------
728 // check controller status before writing
729 //--------------------------------------------------------------------
730 rc
= hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT
, ctlr_ptr
, wpg_bbar
, &status
);
733 ctrl_write (ctlr_ptr
, wpg_bbar
, index
, cmd
);
735 //--------------------------------------------------------------------
736 // check controller is still not working on the command
737 //--------------------------------------------------------------------
738 timeout
= CMD_COMPLETE_TOUT_SEC
;
741 rc
= hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT
, ctlr_ptr
, wpg_bbar
,
744 if (NEEDTOCHECK_CMDSTATUS (cmd
)) {
745 if (CTLR_FINISHED (status
) == HPC_CTLR_FINISHED_YES
)
754 err ("%s - Error command complete timeout\n", __FUNCTION__
);
760 ctlr_ptr
->status
= status
;
764 // remove physical to logical address mapping
765 if ((ctlr_ptr
->ctlr_type
== 2) || (ctlr_ptr
->ctlr_type
== 4))
769 debug_polling ("%s - Exit rc[%d]\n", __FUNCTION__
, rc
);
773 /*----------------------------------------------------------------------
774 * Name: get_hpc_access()
776 * Action: make sure only one process can access HPC at one time
777 *---------------------------------------------------------------------*/
778 static void get_hpc_access (void)
780 down (&sem_hpcaccess
);
783 /*----------------------------------------------------------------------
784 * Name: free_hpc_access()
785 *---------------------------------------------------------------------*/
786 void free_hpc_access (void)
791 /*----------------------------------------------------------------------
792 * Name: ibmphp_lock_operations()
794 * Action: make sure only one process can change the data structure
795 *---------------------------------------------------------------------*/
796 void ibmphp_lock_operations (void)
798 down (&semOperations
);
802 /*----------------------------------------------------------------------
803 * Name: ibmphp_unlock_operations()
804 *---------------------------------------------------------------------*/
805 void ibmphp_unlock_operations (void)
807 debug ("%s - Entry\n", __FUNCTION__
);
810 debug ("%s - Exit\n", __FUNCTION__
);
813 /*----------------------------------------------------------------------
815 *---------------------------------------------------------------------*/
816 #define POLL_LATCH_REGISTER 0
819 static void poll_hpc (void)
822 struct slot
*pslot
= NULL
;
823 struct list_head
*pslotlist
;
825 int poll_state
= POLL_LATCH_REGISTER
;
826 u8 oldlatchlow
= 0x00;
827 u8 curlatchlow
= 0x00;
829 u8 ctrl_count
= 0x00;
831 debug ("%s - Entry\n", __FUNCTION__
);
833 while (!ibmphp_shutdown
) {
837 /* try to get the lock to do some kind of harware access */
838 down (&semOperations
);
840 switch (poll_state
) {
841 case POLL_LATCH_REGISTER
:
842 oldlatchlow
= curlatchlow
;
844 list_for_each (pslotlist
, &ibmphp_slot_head
) {
845 if (ctrl_count
>= ibmphp_get_total_controllers())
847 pslot
= list_entry (pslotlist
, struct slot
, ibm_slot_list
);
848 if (pslot
->ctrl
->ctlr_relative_id
== ctrl_count
) {
850 if (READ_SLOT_LATCH (pslot
->ctrl
)) {
851 rc
= ibmphp_hpc_readslot (pslot
,
852 READ_SLOTLATCHLOWREG
,
854 if (oldlatchlow
!= curlatchlow
)
855 process_changeinlatch (oldlatchlow
,
862 poll_state
= POLL_SLEEP
;
865 list_for_each (pslotlist
, &ibmphp_slot_head
) {
866 pslot
= list_entry (pslotlist
, struct slot
, ibm_slot_list
);
867 // make a copy of the old status
868 memcpy ((void *) &myslot
, (void *) pslot
,
869 sizeof (struct slot
));
870 rc
= ibmphp_hpc_readslot (pslot
, READ_ALLSTAT
, NULL
);
871 if ((myslot
.status
!= pslot
->status
)
872 || (myslot
.ext_status
!= pslot
->ext_status
))
873 process_changeinstatus (pslot
, &myslot
);
876 list_for_each (pslotlist
, &ibmphp_slot_head
) {
877 if (ctrl_count
>= ibmphp_get_total_controllers())
879 pslot
= list_entry (pslotlist
, struct slot
, ibm_slot_list
);
880 if (pslot
->ctrl
->ctlr_relative_id
== ctrl_count
) {
882 if (READ_SLOT_LATCH (pslot
->ctrl
))
883 rc
= ibmphp_hpc_readslot (pslot
,
884 READ_SLOTLATCHLOWREG
,
889 poll_state
= POLL_SLEEP
;
892 /* don't sleep with a lock on the hardware */
894 long_delay (POLL_INTERVAL_SEC
* HZ
);
899 down (&semOperations
);
901 if (poll_count
>= POLL_LATCH_CNT
) {
903 poll_state
= POLL_SLOTS
;
905 poll_state
= POLL_LATCH_REGISTER
;
908 /* give up the harware semaphore */
910 /* sleep for a short time just for good measure */
911 set_current_state (TASK_INTERRUPTIBLE
);
912 schedule_timeout (HZ
/10);
915 debug ("%s - Exit\n", __FUNCTION__
);
919 /*----------------------------------------------------------------------
920 * Name: process_changeinstatus
922 * Action: compare old and new slot status, process the change in status
924 * Input: pointer to slot struct, old slot struct
926 * Return 0 or error codes
933 *---------------------------------------------------------------------*/
934 static int process_changeinstatus (struct slot
*pslot
, struct slot
*poldslot
)
941 debug ("process_changeinstatus - Entry pslot[%p], poldslot[%p]\n", pslot
, poldslot
);
943 // bit 0 - HPC_SLOT_POWER
944 if ((pslot
->status
& 0x01) != (poldslot
->status
& 0x01))
947 // bit 1 - HPC_SLOT_CONNECT
950 // bit 2 - HPC_SLOT_ATTN
951 if ((pslot
->status
& 0x04) != (poldslot
->status
& 0x04))
954 // bit 3 - HPC_SLOT_PRSNT2
955 // bit 4 - HPC_SLOT_PRSNT1
956 if (((pslot
->status
& 0x08) != (poldslot
->status
& 0x08))
957 || ((pslot
->status
& 0x10) != (poldslot
->status
& 0x10)))
960 // bit 5 - HPC_SLOT_PWRGD
961 if ((pslot
->status
& 0x20) != (poldslot
->status
& 0x20))
962 // OFF -> ON: ignore, ON -> OFF: disable slot
963 if ((poldslot
->status
& 0x20) && (SLOT_CONNECT (poldslot
->status
) == HPC_SLOT_CONNECTED
) && (SLOT_PRESENT (poldslot
->status
)))
966 // bit 6 - HPC_SLOT_BUS_SPEED
969 // bit 7 - HPC_SLOT_LATCH
970 if ((pslot
->status
& 0x80) != (poldslot
->status
& 0x80)) {
973 if (pslot
->status
& 0x80) {
974 if (SLOT_PWRGD (pslot
->status
)) {
975 // power goes on and off after closing latch
976 // check again to make sure power is still ON
978 rc
= ibmphp_hpc_readslot (pslot
, READ_SLOTSTATUS
, &status
);
979 if (SLOT_PWRGD (status
))
981 else // overwrite power in pslot to OFF
982 pslot
->status
&= ~HPC_SLOT_POWER
;
986 else if ((SLOT_PWRGD (poldslot
->status
) == HPC_SLOT_PWRGD_GOOD
)
987 && (SLOT_CONNECT (poldslot
->status
) == HPC_SLOT_CONNECTED
) && (SLOT_PRESENT (poldslot
->status
))) {
992 // bit 4 - HPC_SLOT_BLINK_ATTN
993 if ((pslot
->ext_status
& 0x08) != (poldslot
->ext_status
& 0x08))
997 debug ("process_changeinstatus - disable slot\n");
999 rc
= ibmphp_do_disable_slot (pslot
);
1002 if (update
|| disable
) {
1003 ibmphp_update_slot_info (pslot
);
1006 debug ("%s - Exit rc[%d] disable[%x] update[%x]\n", __FUNCTION__
, rc
, disable
, update
);
1011 /*----------------------------------------------------------------------
1012 * Name: process_changeinlatch
1014 * Action: compare old and new latch reg status, process the change
1016 * Input: old and current latch register status
1018 * Return 0 or error codes
1020 *---------------------------------------------------------------------*/
1021 static int process_changeinlatch (u8 old
, u8
new, struct controller
*ctrl
)
1023 struct slot myslot
, *pslot
;
1028 debug ("%s - Entry old[%x], new[%x]\n", __FUNCTION__
, old
, new);
1029 // bit 0 reserved, 0 is LSB, check bit 1-6 for 6 slots
1031 for (i
= ctrl
->starting_slot_num
; i
<= ctrl
->ending_slot_num
; i
++) {
1033 if ((mask
& old
) != (mask
& new)) {
1034 pslot
= ibmphp_get_slot_from_physical_num (i
);
1036 memcpy ((void *) &myslot
, (void *) pslot
, sizeof (struct slot
));
1037 rc
= ibmphp_hpc_readslot (pslot
, READ_ALLSTAT
, NULL
);
1038 debug ("%s - call process_changeinstatus for slot[%d]\n", __FUNCTION__
, i
);
1039 process_changeinstatus (pslot
, &myslot
);
1042 err ("%s - Error bad pointer for slot[%d]\n", __FUNCTION__
, i
);
1046 debug ("%s - Exit rc[%d]\n", __FUNCTION__
, rc
);
1050 /*----------------------------------------------------------------------
1051 * Name: hpc_poll_thread
1057 *---------------------------------------------------------------------*/
1058 static int hpc_poll_thread (void *data
)
1060 debug ("%s - Entry\n", __FUNCTION__
);
1062 daemonize("hpc_poll");
1063 allow_signal(SIGKILL
);
1068 debug ("%s - Exit\n", __FUNCTION__
);
1073 /*----------------------------------------------------------------------
1074 * Name: ibmphp_hpc_start_poll_thread
1076 * Action: start polling thread
1077 *---------------------------------------------------------------------*/
1078 int __init
ibmphp_hpc_start_poll_thread (void)
1082 debug ("%s - Entry\n", __FUNCTION__
);
1084 tid_poll
= kernel_thread (hpc_poll_thread
, 0, 0);
1086 err ("%s - Error, thread not started\n", __FUNCTION__
);
1090 debug ("%s - Exit tid_poll[%d] rc[%d]\n", __FUNCTION__
, tid_poll
, rc
);
1094 /*----------------------------------------------------------------------
1095 * Name: ibmphp_hpc_stop_poll_thread
1097 * Action: stop polling thread and cleanup
1098 *---------------------------------------------------------------------*/
1099 void __exit
ibmphp_hpc_stop_poll_thread (void)
1101 debug ("%s - Entry\n", __FUNCTION__
);
1103 ibmphp_shutdown
= TRUE
;
1104 debug ("before locking operations \n");
1105 ibmphp_lock_operations ();
1106 debug ("after locking operations \n");
1108 // wait for poll thread to exit
1109 debug ("before sem_exit down \n");
1111 debug ("after sem_exit down \n");
1114 debug ("before free_hpc_access \n");
1116 debug ("after free_hpc_access \n");
1117 ibmphp_unlock_operations ();
1118 debug ("after unlock operations \n");
1120 debug ("after sem exit up\n");
1122 debug ("%s - Exit\n", __FUNCTION__
);
1125 /*----------------------------------------------------------------------
1126 * Name: hpc_wait_ctlr_notworking
1128 * Action: wait until the controller is in a not working state
1130 * Return 0, HPC_ERROR
1132 *---------------------------------------------------------------------*/
1133 static int hpc_wait_ctlr_notworking (int timeout
, struct controller
*ctlr_ptr
, void *wpg_bbar
,
1139 debug_polling ("hpc_wait_ctlr_notworking - Entry timeout[%d]\n", timeout
);
1142 *pstatus
= ctrl_read (ctlr_ptr
, wpg_bbar
, WPG_CTLR_INDEX
);
1143 if (*pstatus
== HPC_ERROR
) {
1147 if (CTLR_WORKING (*pstatus
) == HPC_CTLR_WORKING_NO
)
1150 long_delay (1 * HZ
);
1153 err ("HPCreadslot - Error ctlr timeout\n");
1159 debug_polling ("hpc_wait_ctlr_notworking - Exit rc[%x] status[%x]\n", rc
, *pstatus
);