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