[SCSI] Initial Commit of qla4xxx
[sfrench/cifs-2.6.git] / drivers / scsi / qla4xxx / ql4_nvram.c
1 /*
2  * QLogic iSCSI HBA Driver
3  * Copyright (c)  2003-2006 QLogic Corporation
4  *
5  * See LICENSE.qla4xxx for copyright and licensing details.
6  */
7
8 #include "ql4_def.h"
9
10 static inline int eeprom_size(struct scsi_qla_host *ha)
11 {
12         return is_qla4022(ha) ? FM93C86A_SIZE_16 : FM93C66A_SIZE_16;
13 }
14
15 static inline int eeprom_no_addr_bits(struct scsi_qla_host *ha)
16 {
17         return is_qla4022(ha) ? FM93C86A_NO_ADDR_BITS_16 :
18                 FM93C56A_NO_ADDR_BITS_16;
19 }
20
21 static inline int eeprom_no_data_bits(struct scsi_qla_host *ha)
22 {
23         return FM93C56A_DATA_BITS_16;
24 }
25
26 static int fm93c56a_select(struct scsi_qla_host * ha)
27 {
28         DEBUG5(printk(KERN_ERR "fm93c56a_select:\n"));
29
30         ha->eeprom_cmd_data = AUBURN_EEPROM_CS_1 | 0x000f0000;
31         writel(ha->eeprom_cmd_data, isp_nvram(ha));
32         readl(isp_nvram(ha));
33         return 1;
34 }
35
36 static int fm93c56a_cmd(struct scsi_qla_host * ha, int cmd, int addr)
37 {
38         int i;
39         int mask;
40         int dataBit;
41         int previousBit;
42
43         /* Clock in a zero, then do the start bit. */
44         writel(ha->eeprom_cmd_data | AUBURN_EEPROM_DO_1, isp_nvram(ha));
45         writel(ha->eeprom_cmd_data | AUBURN_EEPROM_DO_1 |
46                AUBURN_EEPROM_CLK_RISE, isp_nvram(ha));
47         writel(ha->eeprom_cmd_data | AUBURN_EEPROM_DO_1 |
48                AUBURN_EEPROM_CLK_FALL, isp_nvram(ha));
49         readl(isp_nvram(ha));
50         mask = 1 << (FM93C56A_CMD_BITS - 1);
51
52         /* Force the previous data bit to be different. */
53         previousBit = 0xffff;
54         for (i = 0; i < FM93C56A_CMD_BITS; i++) {
55                 dataBit =
56                         (cmd & mask) ? AUBURN_EEPROM_DO_1 : AUBURN_EEPROM_DO_0;
57                 if (previousBit != dataBit) {
58
59                         /*
60                          * If the bit changed, then change the DO state to
61                          * match.
62                          */
63                         writel(ha->eeprom_cmd_data | dataBit, isp_nvram(ha));
64                         previousBit = dataBit;
65                 }
66                 writel(ha->eeprom_cmd_data | dataBit |
67                        AUBURN_EEPROM_CLK_RISE, isp_nvram(ha));
68                 writel(ha->eeprom_cmd_data | dataBit |
69                        AUBURN_EEPROM_CLK_FALL, isp_nvram(ha));
70                 readl(isp_nvram(ha));
71                 cmd = cmd << 1;
72         }
73         mask = 1 << (eeprom_no_addr_bits(ha) - 1);
74
75         /* Force the previous data bit to be different. */
76         previousBit = 0xffff;
77         for (i = 0; i < eeprom_no_addr_bits(ha); i++) {
78                 dataBit = addr & mask ? AUBURN_EEPROM_DO_1 :
79                         AUBURN_EEPROM_DO_0;
80                 if (previousBit != dataBit) {
81                         /*
82                          * If the bit changed, then change the DO state to
83                          * match.
84                          */
85                         writel(ha->eeprom_cmd_data | dataBit, isp_nvram(ha));
86                         previousBit = dataBit;
87                 }
88                 writel(ha->eeprom_cmd_data | dataBit |
89                        AUBURN_EEPROM_CLK_RISE, isp_nvram(ha));
90                 writel(ha->eeprom_cmd_data | dataBit |
91                        AUBURN_EEPROM_CLK_FALL, isp_nvram(ha));
92                 readl(isp_nvram(ha));
93                 addr = addr << 1;
94         }
95         return 1;
96 }
97
98 static int fm93c56a_deselect(struct scsi_qla_host * ha)
99 {
100         ha->eeprom_cmd_data = AUBURN_EEPROM_CS_0 | 0x000f0000;
101         writel(ha->eeprom_cmd_data, isp_nvram(ha));
102         readl(isp_nvram(ha));
103         return 1;
104 }
105
106 static int fm93c56a_datain(struct scsi_qla_host * ha, unsigned short *value)
107 {
108         int i;
109         int data = 0;
110         int dataBit;
111
112         /* Read the data bits
113          * The first bit is a dummy.  Clock right over it. */
114         for (i = 0; i < eeprom_no_data_bits(ha); i++) {
115                 writel(ha->eeprom_cmd_data |
116                        AUBURN_EEPROM_CLK_RISE, isp_nvram(ha));
117                 writel(ha->eeprom_cmd_data |
118                        AUBURN_EEPROM_CLK_FALL, isp_nvram(ha));
119                 dataBit =
120                         (readw(isp_nvram(ha)) & AUBURN_EEPROM_DI_1) ? 1 : 0;
121                 data = (data << 1) | dataBit;
122         }
123
124         *value = data;
125         return 1;
126 }
127
128 static int eeprom_readword(int eepromAddr, u16 * value,
129                            struct scsi_qla_host * ha)
130 {
131         fm93c56a_select(ha);
132         fm93c56a_cmd(ha, FM93C56A_READ, eepromAddr);
133         fm93c56a_datain(ha, value);
134         fm93c56a_deselect(ha);
135         return 1;
136 }
137
138 /* Hardware_lock must be set before calling */
139 u16 rd_nvram_word(struct scsi_qla_host * ha, int offset)
140 {
141         u16 val;
142
143         /* NOTE: NVRAM uses half-word addresses */
144         eeprom_readword(offset, &val, ha);
145         return val;
146 }
147
148 int qla4xxx_is_nvram_configuration_valid(struct scsi_qla_host * ha)
149 {
150         int status = QLA_ERROR;
151         uint16_t checksum = 0;
152         uint32_t index;
153         unsigned long flags;
154
155         spin_lock_irqsave(&ha->hardware_lock, flags);
156         for (index = 0; index < eeprom_size(ha); index++)
157                 checksum += rd_nvram_word(ha, index);
158         spin_unlock_irqrestore(&ha->hardware_lock, flags);
159
160         if (checksum == 0)
161                 status = QLA_SUCCESS;
162
163         return status;
164 }
165
166 /*************************************************************************
167  *
168  *                      Hardware Semaphore routines
169  *
170  *************************************************************************/
171 int ql4xxx_sem_spinlock(struct scsi_qla_host * ha, u32 sem_mask, u32 sem_bits)
172 {
173         uint32_t value;
174         unsigned long flags;
175         unsigned int seconds = 30;
176
177         DEBUG2(printk("scsi%ld : Trying to get SEM lock - mask= 0x%x, code = "
178                       "0x%x\n", ha->host_no, sem_mask, sem_bits));
179         do {
180                 spin_lock_irqsave(&ha->hardware_lock, flags);
181                 writel((sem_mask | sem_bits), isp_semaphore(ha));
182                 value = readw(isp_semaphore(ha));
183                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
184                 if ((value & (sem_mask >> 16)) == sem_bits) {
185                         DEBUG2(printk("scsi%ld : Got SEM LOCK - mask= 0x%x, "
186                                       "code = 0x%x\n", ha->host_no,
187                                       sem_mask, sem_bits));
188                         return QLA_SUCCESS;
189                 }
190                 ssleep(1);
191         } while (--seconds);
192         return QLA_ERROR;
193 }
194
195 void ql4xxx_sem_unlock(struct scsi_qla_host * ha, u32 sem_mask)
196 {
197         unsigned long flags;
198
199         spin_lock_irqsave(&ha->hardware_lock, flags);
200         writel(sem_mask, isp_semaphore(ha));
201         readl(isp_semaphore(ha));
202         spin_unlock_irqrestore(&ha->hardware_lock, flags);
203
204         DEBUG2(printk("scsi%ld : UNLOCK SEM - mask= 0x%x\n", ha->host_no,
205                       sem_mask));
206 }
207
208 int ql4xxx_sem_lock(struct scsi_qla_host * ha, u32 sem_mask, u32 sem_bits)
209 {
210         uint32_t value;
211         unsigned long flags;
212
213         spin_lock_irqsave(&ha->hardware_lock, flags);
214         writel((sem_mask | sem_bits), isp_semaphore(ha));
215         value = readw(isp_semaphore(ha));
216         spin_unlock_irqrestore(&ha->hardware_lock, flags);
217         if ((value & (sem_mask >> 16)) == sem_bits) {
218                 DEBUG2(printk("scsi%ld : Got SEM LOCK - mask= 0x%x, code = "
219                               "0x%x, sema code=0x%x\n", ha->host_no,
220                               sem_mask, sem_bits, value));
221                 return 1;
222         }
223         return 0;
224 }