2 * QLogic iSCSI HBA Driver
3 * Copyright (c) 2003-2010 QLogic Corporation
5 * See LICENSE.qla4xxx for copyright and licensing details.
7 #include <linux/delay.h>
13 #define MASK(n) DMA_BIT_MASK(n)
14 #define MN_WIN(addr) (((addr & 0x1fc0000) >> 1) | ((addr >> 25) & 0x3ff))
15 #define OCM_WIN(addr) (((addr & 0x1ff0000) >> 1) | ((addr >> 25) & 0x3ff))
16 #define MS_WIN(addr) (addr & 0x0ffc0000)
17 #define QLA82XX_PCI_MN_2M (0)
18 #define QLA82XX_PCI_MS_2M (0x80000)
19 #define QLA82XX_PCI_OCM0_2M (0xc0000)
20 #define VALID_OCM_ADDR(addr) (((addr) & 0x3f800) != 0x3f800)
21 #define GET_MEM_OFFS_2M(addr) (addr & MASK(18))
23 /* CRB window related */
24 #define CRB_BLK(off) ((off >> 20) & 0x3f)
25 #define CRB_SUBBLK(off) ((off >> 16) & 0xf)
26 #define CRB_WINDOW_2M (0x130060)
27 #define CRB_HI(off) ((qla4_8xxx_crb_hub_agt[CRB_BLK(off)] << 20) | \
29 #define QLA82XX_PCI_CAMQM_2M_END (0x04800800UL)
30 #define QLA82XX_PCI_CAMQM_2M_BASE (0x000ff800UL)
31 #define CRB_INDIRECT_2M (0x1e0000UL)
33 static inline void __iomem
*
34 qla4_8xxx_pci_base_offsetfset(struct scsi_qla_host
*ha
, unsigned long off
)
36 if ((off
< ha
->first_page_group_end
) &&
37 (off
>= ha
->first_page_group_start
))
38 return (void __iomem
*)(ha
->nx_pcibase
+ off
);
43 #define MAX_CRB_XFORM 60
44 static unsigned long crb_addr_xform
[MAX_CRB_XFORM
];
45 static int qla4_8xxx_crb_table_initialized
;
47 #define qla4_8xxx_crb_addr_transform(name) \
48 (crb_addr_xform[QLA82XX_HW_PX_MAP_CRB_##name] = \
49 QLA82XX_HW_CRB_HUB_AGT_ADR_##name << 20)
51 qla4_8xxx_crb_addr_transform_setup(void)
53 qla4_8xxx_crb_addr_transform(XDMA
);
54 qla4_8xxx_crb_addr_transform(TIMR
);
55 qla4_8xxx_crb_addr_transform(SRE
);
56 qla4_8xxx_crb_addr_transform(SQN3
);
57 qla4_8xxx_crb_addr_transform(SQN2
);
58 qla4_8xxx_crb_addr_transform(SQN1
);
59 qla4_8xxx_crb_addr_transform(SQN0
);
60 qla4_8xxx_crb_addr_transform(SQS3
);
61 qla4_8xxx_crb_addr_transform(SQS2
);
62 qla4_8xxx_crb_addr_transform(SQS1
);
63 qla4_8xxx_crb_addr_transform(SQS0
);
64 qla4_8xxx_crb_addr_transform(RPMX7
);
65 qla4_8xxx_crb_addr_transform(RPMX6
);
66 qla4_8xxx_crb_addr_transform(RPMX5
);
67 qla4_8xxx_crb_addr_transform(RPMX4
);
68 qla4_8xxx_crb_addr_transform(RPMX3
);
69 qla4_8xxx_crb_addr_transform(RPMX2
);
70 qla4_8xxx_crb_addr_transform(RPMX1
);
71 qla4_8xxx_crb_addr_transform(RPMX0
);
72 qla4_8xxx_crb_addr_transform(ROMUSB
);
73 qla4_8xxx_crb_addr_transform(SN
);
74 qla4_8xxx_crb_addr_transform(QMN
);
75 qla4_8xxx_crb_addr_transform(QMS
);
76 qla4_8xxx_crb_addr_transform(PGNI
);
77 qla4_8xxx_crb_addr_transform(PGND
);
78 qla4_8xxx_crb_addr_transform(PGN3
);
79 qla4_8xxx_crb_addr_transform(PGN2
);
80 qla4_8xxx_crb_addr_transform(PGN1
);
81 qla4_8xxx_crb_addr_transform(PGN0
);
82 qla4_8xxx_crb_addr_transform(PGSI
);
83 qla4_8xxx_crb_addr_transform(PGSD
);
84 qla4_8xxx_crb_addr_transform(PGS3
);
85 qla4_8xxx_crb_addr_transform(PGS2
);
86 qla4_8xxx_crb_addr_transform(PGS1
);
87 qla4_8xxx_crb_addr_transform(PGS0
);
88 qla4_8xxx_crb_addr_transform(PS
);
89 qla4_8xxx_crb_addr_transform(PH
);
90 qla4_8xxx_crb_addr_transform(NIU
);
91 qla4_8xxx_crb_addr_transform(I2Q
);
92 qla4_8xxx_crb_addr_transform(EG
);
93 qla4_8xxx_crb_addr_transform(MN
);
94 qla4_8xxx_crb_addr_transform(MS
);
95 qla4_8xxx_crb_addr_transform(CAS2
);
96 qla4_8xxx_crb_addr_transform(CAS1
);
97 qla4_8xxx_crb_addr_transform(CAS0
);
98 qla4_8xxx_crb_addr_transform(CAM
);
99 qla4_8xxx_crb_addr_transform(C2C1
);
100 qla4_8xxx_crb_addr_transform(C2C0
);
101 qla4_8xxx_crb_addr_transform(SMB
);
102 qla4_8xxx_crb_addr_transform(OCM0
);
103 qla4_8xxx_crb_addr_transform(I2C0
);
105 qla4_8xxx_crb_table_initialized
= 1;
108 static struct crb_128M_2M_block_map crb_128M_2M_map
[64] = {
109 {{{0, 0, 0, 0} } }, /* 0: PCI */
110 {{{1, 0x0100000, 0x0102000, 0x120000}, /* 1: PCIE */
111 {1, 0x0110000, 0x0120000, 0x130000},
112 {1, 0x0120000, 0x0122000, 0x124000},
113 {1, 0x0130000, 0x0132000, 0x126000},
114 {1, 0x0140000, 0x0142000, 0x128000},
115 {1, 0x0150000, 0x0152000, 0x12a000},
116 {1, 0x0160000, 0x0170000, 0x110000},
117 {1, 0x0170000, 0x0172000, 0x12e000},
118 {0, 0x0000000, 0x0000000, 0x000000},
119 {0, 0x0000000, 0x0000000, 0x000000},
120 {0, 0x0000000, 0x0000000, 0x000000},
121 {0, 0x0000000, 0x0000000, 0x000000},
122 {0, 0x0000000, 0x0000000, 0x000000},
123 {0, 0x0000000, 0x0000000, 0x000000},
124 {1, 0x01e0000, 0x01e0800, 0x122000},
125 {0, 0x0000000, 0x0000000, 0x000000} } },
126 {{{1, 0x0200000, 0x0210000, 0x180000} } },/* 2: MN */
127 {{{0, 0, 0, 0} } }, /* 3: */
128 {{{1, 0x0400000, 0x0401000, 0x169000} } },/* 4: P2NR1 */
129 {{{1, 0x0500000, 0x0510000, 0x140000} } },/* 5: SRE */
130 {{{1, 0x0600000, 0x0610000, 0x1c0000} } },/* 6: NIU */
131 {{{1, 0x0700000, 0x0704000, 0x1b8000} } },/* 7: QM */
132 {{{1, 0x0800000, 0x0802000, 0x170000}, /* 8: SQM0 */
133 {0, 0x0000000, 0x0000000, 0x000000},
134 {0, 0x0000000, 0x0000000, 0x000000},
135 {0, 0x0000000, 0x0000000, 0x000000},
136 {0, 0x0000000, 0x0000000, 0x000000},
137 {0, 0x0000000, 0x0000000, 0x000000},
138 {0, 0x0000000, 0x0000000, 0x000000},
139 {0, 0x0000000, 0x0000000, 0x000000},
140 {0, 0x0000000, 0x0000000, 0x000000},
141 {0, 0x0000000, 0x0000000, 0x000000},
142 {0, 0x0000000, 0x0000000, 0x000000},
143 {0, 0x0000000, 0x0000000, 0x000000},
144 {0, 0x0000000, 0x0000000, 0x000000},
145 {0, 0x0000000, 0x0000000, 0x000000},
146 {0, 0x0000000, 0x0000000, 0x000000},
147 {1, 0x08f0000, 0x08f2000, 0x172000} } },
148 {{{1, 0x0900000, 0x0902000, 0x174000}, /* 9: SQM1*/
149 {0, 0x0000000, 0x0000000, 0x000000},
150 {0, 0x0000000, 0x0000000, 0x000000},
151 {0, 0x0000000, 0x0000000, 0x000000},
152 {0, 0x0000000, 0x0000000, 0x000000},
153 {0, 0x0000000, 0x0000000, 0x000000},
154 {0, 0x0000000, 0x0000000, 0x000000},
155 {0, 0x0000000, 0x0000000, 0x000000},
156 {0, 0x0000000, 0x0000000, 0x000000},
157 {0, 0x0000000, 0x0000000, 0x000000},
158 {0, 0x0000000, 0x0000000, 0x000000},
159 {0, 0x0000000, 0x0000000, 0x000000},
160 {0, 0x0000000, 0x0000000, 0x000000},
161 {0, 0x0000000, 0x0000000, 0x000000},
162 {0, 0x0000000, 0x0000000, 0x000000},
163 {1, 0x09f0000, 0x09f2000, 0x176000} } },
164 {{{0, 0x0a00000, 0x0a02000, 0x178000}, /* 10: SQM2*/
165 {0, 0x0000000, 0x0000000, 0x000000},
166 {0, 0x0000000, 0x0000000, 0x000000},
167 {0, 0x0000000, 0x0000000, 0x000000},
168 {0, 0x0000000, 0x0000000, 0x000000},
169 {0, 0x0000000, 0x0000000, 0x000000},
170 {0, 0x0000000, 0x0000000, 0x000000},
171 {0, 0x0000000, 0x0000000, 0x000000},
172 {0, 0x0000000, 0x0000000, 0x000000},
173 {0, 0x0000000, 0x0000000, 0x000000},
174 {0, 0x0000000, 0x0000000, 0x000000},
175 {0, 0x0000000, 0x0000000, 0x000000},
176 {0, 0x0000000, 0x0000000, 0x000000},
177 {0, 0x0000000, 0x0000000, 0x000000},
178 {0, 0x0000000, 0x0000000, 0x000000},
179 {1, 0x0af0000, 0x0af2000, 0x17a000} } },
180 {{{0, 0x0b00000, 0x0b02000, 0x17c000}, /* 11: SQM3*/
181 {0, 0x0000000, 0x0000000, 0x000000},
182 {0, 0x0000000, 0x0000000, 0x000000},
183 {0, 0x0000000, 0x0000000, 0x000000},
184 {0, 0x0000000, 0x0000000, 0x000000},
185 {0, 0x0000000, 0x0000000, 0x000000},
186 {0, 0x0000000, 0x0000000, 0x000000},
187 {0, 0x0000000, 0x0000000, 0x000000},
188 {0, 0x0000000, 0x0000000, 0x000000},
189 {0, 0x0000000, 0x0000000, 0x000000},
190 {0, 0x0000000, 0x0000000, 0x000000},
191 {0, 0x0000000, 0x0000000, 0x000000},
192 {0, 0x0000000, 0x0000000, 0x000000},
193 {0, 0x0000000, 0x0000000, 0x000000},
194 {0, 0x0000000, 0x0000000, 0x000000},
195 {1, 0x0bf0000, 0x0bf2000, 0x17e000} } },
196 {{{1, 0x0c00000, 0x0c04000, 0x1d4000} } },/* 12: I2Q */
197 {{{1, 0x0d00000, 0x0d04000, 0x1a4000} } },/* 13: TMR */
198 {{{1, 0x0e00000, 0x0e04000, 0x1a0000} } },/* 14: ROMUSB */
199 {{{1, 0x0f00000, 0x0f01000, 0x164000} } },/* 15: PEG4 */
200 {{{0, 0x1000000, 0x1004000, 0x1a8000} } },/* 16: XDMA */
201 {{{1, 0x1100000, 0x1101000, 0x160000} } },/* 17: PEG0 */
202 {{{1, 0x1200000, 0x1201000, 0x161000} } },/* 18: PEG1 */
203 {{{1, 0x1300000, 0x1301000, 0x162000} } },/* 19: PEG2 */
204 {{{1, 0x1400000, 0x1401000, 0x163000} } },/* 20: PEG3 */
205 {{{1, 0x1500000, 0x1501000, 0x165000} } },/* 21: P2ND */
206 {{{1, 0x1600000, 0x1601000, 0x166000} } },/* 22: P2NI */
207 {{{0, 0, 0, 0} } }, /* 23: */
208 {{{0, 0, 0, 0} } }, /* 24: */
209 {{{0, 0, 0, 0} } }, /* 25: */
210 {{{0, 0, 0, 0} } }, /* 26: */
211 {{{0, 0, 0, 0} } }, /* 27: */
212 {{{0, 0, 0, 0} } }, /* 28: */
213 {{{1, 0x1d00000, 0x1d10000, 0x190000} } },/* 29: MS */
214 {{{1, 0x1e00000, 0x1e01000, 0x16a000} } },/* 30: P2NR2 */
215 {{{1, 0x1f00000, 0x1f10000, 0x150000} } },/* 31: EPG */
216 {{{0} } }, /* 32: PCI */
217 {{{1, 0x2100000, 0x2102000, 0x120000}, /* 33: PCIE */
218 {1, 0x2110000, 0x2120000, 0x130000},
219 {1, 0x2120000, 0x2122000, 0x124000},
220 {1, 0x2130000, 0x2132000, 0x126000},
221 {1, 0x2140000, 0x2142000, 0x128000},
222 {1, 0x2150000, 0x2152000, 0x12a000},
223 {1, 0x2160000, 0x2170000, 0x110000},
224 {1, 0x2170000, 0x2172000, 0x12e000},
225 {0, 0x0000000, 0x0000000, 0x000000},
226 {0, 0x0000000, 0x0000000, 0x000000},
227 {0, 0x0000000, 0x0000000, 0x000000},
228 {0, 0x0000000, 0x0000000, 0x000000},
229 {0, 0x0000000, 0x0000000, 0x000000},
230 {0, 0x0000000, 0x0000000, 0x000000},
231 {0, 0x0000000, 0x0000000, 0x000000},
232 {0, 0x0000000, 0x0000000, 0x000000} } },
233 {{{1, 0x2200000, 0x2204000, 0x1b0000} } },/* 34: CAM */
239 {{{1, 0x2800000, 0x2804000, 0x1a4000} } },/* 40: TMR */
240 {{{1, 0x2900000, 0x2901000, 0x16b000} } },/* 41: P2NR3 */
241 {{{1, 0x2a00000, 0x2a00400, 0x1ac400} } },/* 42: RPMX1 */
242 {{{1, 0x2b00000, 0x2b00400, 0x1ac800} } },/* 43: RPMX2 */
243 {{{1, 0x2c00000, 0x2c00400, 0x1acc00} } },/* 44: RPMX3 */
244 {{{1, 0x2d00000, 0x2d00400, 0x1ad000} } },/* 45: RPMX4 */
245 {{{1, 0x2e00000, 0x2e00400, 0x1ad400} } },/* 46: RPMX5 */
246 {{{1, 0x2f00000, 0x2f00400, 0x1ad800} } },/* 47: RPMX6 */
247 {{{1, 0x3000000, 0x3000400, 0x1adc00} } },/* 48: RPMX7 */
248 {{{0, 0x3100000, 0x3104000, 0x1a8000} } },/* 49: XDMA */
249 {{{1, 0x3200000, 0x3204000, 0x1d4000} } },/* 50: I2Q */
250 {{{1, 0x3300000, 0x3304000, 0x1a0000} } },/* 51: ROMUSB */
252 {{{1, 0x3500000, 0x3500400, 0x1ac000} } },/* 53: RPMX0 */
253 {{{1, 0x3600000, 0x3600400, 0x1ae000} } },/* 54: RPMX8 */
254 {{{1, 0x3700000, 0x3700400, 0x1ae400} } },/* 55: RPMX9 */
255 {{{1, 0x3800000, 0x3804000, 0x1d0000} } },/* 56: OCM0 */
256 {{{1, 0x3900000, 0x3904000, 0x1b4000} } },/* 57: CRYPTO */
257 {{{1, 0x3a00000, 0x3a04000, 0x1d8000} } },/* 58: SMB */
258 {{{0} } }, /* 59: I2C0 */
259 {{{0} } }, /* 60: I2C1 */
260 {{{1, 0x3d00000, 0x3d04000, 0x1dc000} } },/* 61: LPC */
261 {{{1, 0x3e00000, 0x3e01000, 0x167000} } },/* 62: P2NC */
262 {{{1, 0x3f00000, 0x3f01000, 0x168000} } } /* 63: P2NR0 */
266 * top 12 bits of crb internal address (hub, agent)
268 static unsigned qla4_8xxx_crb_hub_agt
[64] = {
270 QLA82XX_HW_CRB_HUB_AGT_ADR_PS
,
271 QLA82XX_HW_CRB_HUB_AGT_ADR_MN
,
272 QLA82XX_HW_CRB_HUB_AGT_ADR_MS
,
274 QLA82XX_HW_CRB_HUB_AGT_ADR_SRE
,
275 QLA82XX_HW_CRB_HUB_AGT_ADR_NIU
,
276 QLA82XX_HW_CRB_HUB_AGT_ADR_QMN
,
277 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN0
,
278 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN1
,
279 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN2
,
280 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN3
,
281 QLA82XX_HW_CRB_HUB_AGT_ADR_I2Q
,
282 QLA82XX_HW_CRB_HUB_AGT_ADR_TIMR
,
283 QLA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB
,
284 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN4
,
285 QLA82XX_HW_CRB_HUB_AGT_ADR_XDMA
,
286 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN0
,
287 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN1
,
288 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN2
,
289 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN3
,
290 QLA82XX_HW_CRB_HUB_AGT_ADR_PGND
,
291 QLA82XX_HW_CRB_HUB_AGT_ADR_PGNI
,
292 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS0
,
293 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS1
,
294 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS2
,
295 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS3
,
297 QLA82XX_HW_CRB_HUB_AGT_ADR_PGSI
,
298 QLA82XX_HW_CRB_HUB_AGT_ADR_SN
,
300 QLA82XX_HW_CRB_HUB_AGT_ADR_EG
,
302 QLA82XX_HW_CRB_HUB_AGT_ADR_PS
,
303 QLA82XX_HW_CRB_HUB_AGT_ADR_CAM
,
309 QLA82XX_HW_CRB_HUB_AGT_ADR_TIMR
,
311 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX1
,
312 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX2
,
313 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX3
,
314 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX4
,
315 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX5
,
316 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX6
,
317 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX7
,
318 QLA82XX_HW_CRB_HUB_AGT_ADR_XDMA
,
319 QLA82XX_HW_CRB_HUB_AGT_ADR_I2Q
,
320 QLA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB
,
322 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX0
,
323 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX8
,
324 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX9
,
325 QLA82XX_HW_CRB_HUB_AGT_ADR_OCM0
,
327 QLA82XX_HW_CRB_HUB_AGT_ADR_SMB
,
328 QLA82XX_HW_CRB_HUB_AGT_ADR_I2C0
,
329 QLA82XX_HW_CRB_HUB_AGT_ADR_I2C1
,
331 QLA82XX_HW_CRB_HUB_AGT_ADR_PGNC
,
336 static char *qdev_state
[] = {
348 * In: 'off' is offset from CRB space in 128M pci map
349 * Out: 'off' is 2M pci map addr
350 * side effect: lock crb window
353 qla4_8xxx_pci_set_crbwindow_2M(struct scsi_qla_host
*ha
, ulong
*off
)
357 ha
->crb_win
= CRB_HI(*off
);
359 (void __iomem
*)(CRB_WINDOW_2M
+ ha
->nx_pcibase
));
361 /* Read back value to make sure write has gone through before trying
363 win_read
= readl((void __iomem
*)(CRB_WINDOW_2M
+ ha
->nx_pcibase
));
364 if (win_read
!= ha
->crb_win
) {
365 DEBUG2(ql4_printk(KERN_INFO
, ha
,
366 "%s: Written crbwin (0x%x) != Read crbwin (0x%x),"
367 " off=0x%lx\n", __func__
, ha
->crb_win
, win_read
, *off
));
369 *off
= (*off
& MASK(16)) + CRB_INDIRECT_2M
+ ha
->nx_pcibase
;
373 qla4_8xxx_wr_32(struct scsi_qla_host
*ha
, ulong off
, u32 data
)
375 unsigned long flags
= 0;
378 rv
= qla4_8xxx_pci_get_crb_addr_2M(ha
, &off
);
383 write_lock_irqsave(&ha
->hw_lock
, flags
);
384 qla4_8xxx_crb_win_lock(ha
);
385 qla4_8xxx_pci_set_crbwindow_2M(ha
, &off
);
388 writel(data
, (void __iomem
*)off
);
391 qla4_8xxx_crb_win_unlock(ha
);
392 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
397 qla4_8xxx_rd_32(struct scsi_qla_host
*ha
, ulong off
)
399 unsigned long flags
= 0;
403 rv
= qla4_8xxx_pci_get_crb_addr_2M(ha
, &off
);
408 write_lock_irqsave(&ha
->hw_lock
, flags
);
409 qla4_8xxx_crb_win_lock(ha
);
410 qla4_8xxx_pci_set_crbwindow_2M(ha
, &off
);
412 data
= readl((void __iomem
*)off
);
415 qla4_8xxx_crb_win_unlock(ha
);
416 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
421 #define CRB_WIN_LOCK_TIMEOUT 100000000
423 int qla4_8xxx_crb_win_lock(struct scsi_qla_host
*ha
)
426 int done
= 0, timeout
= 0;
429 /* acquire semaphore3 from PCI HW block */
430 done
= qla4_8xxx_rd_32(ha
, QLA82XX_PCIE_REG(PCIE_SEM7_LOCK
));
433 if (timeout
>= CRB_WIN_LOCK_TIMEOUT
)
442 for (i
= 0; i
< 20; i
++)
443 cpu_relax(); /*This a nop instr on i386*/
446 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_WIN_LOCK_ID
, ha
->func_num
);
450 void qla4_8xxx_crb_win_unlock(struct scsi_qla_host
*ha
)
452 qla4_8xxx_rd_32(ha
, QLA82XX_PCIE_REG(PCIE_SEM7_UNLOCK
));
455 #define IDC_LOCK_TIMEOUT 100000000
458 * qla4_8xxx_idc_lock - hw_lock
459 * @ha: pointer to adapter structure
461 * General purpose lock used to synchronize access to
462 * CRB_DEV_STATE, CRB_DEV_REF_COUNT, etc.
464 int qla4_8xxx_idc_lock(struct scsi_qla_host
*ha
)
467 int done
= 0, timeout
= 0;
470 /* acquire semaphore5 from PCI HW block */
471 done
= qla4_8xxx_rd_32(ha
, QLA82XX_PCIE_REG(PCIE_SEM5_LOCK
));
474 if (timeout
>= IDC_LOCK_TIMEOUT
)
483 for (i
= 0; i
< 20; i
++)
484 cpu_relax(); /*This a nop instr on i386*/
490 void qla4_8xxx_idc_unlock(struct scsi_qla_host
*ha
)
492 qla4_8xxx_rd_32(ha
, QLA82XX_PCIE_REG(PCIE_SEM5_UNLOCK
));
496 qla4_8xxx_pci_get_crb_addr_2M(struct scsi_qla_host
*ha
, ulong
*off
)
498 struct crb_128M_2M_sub_block_map
*m
;
500 if (*off
>= QLA82XX_CRB_MAX
)
503 if (*off
>= QLA82XX_PCI_CAMQM
&& (*off
< QLA82XX_PCI_CAMQM_2M_END
)) {
504 *off
= (*off
- QLA82XX_PCI_CAMQM
) +
505 QLA82XX_PCI_CAMQM_2M_BASE
+ ha
->nx_pcibase
;
509 if (*off
< QLA82XX_PCI_CRBSPACE
)
512 *off
-= QLA82XX_PCI_CRBSPACE
;
517 m
= &crb_128M_2M_map
[CRB_BLK(*off
)].sub_block
[CRB_SUBBLK(*off
)];
519 if (m
->valid
&& (m
->start_128M
<= *off
) && (m
->end_128M
> *off
)) {
520 *off
= *off
+ m
->start_2M
- m
->start_128M
+ ha
->nx_pcibase
;
525 * Not in direct map, use crb window
530 /* PCI Windowing for DDR regions. */
531 #define QLA82XX_ADDR_IN_RANGE(addr, low, high) \
532 (((addr) <= (high)) && ((addr) >= (low)))
535 * check memory access boundary.
536 * used by test agent. support ddr access only for now
539 qla4_8xxx_pci_mem_bound_check(struct scsi_qla_host
*ha
,
540 unsigned long long addr
, int size
)
542 if (!QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_DDR_NET
,
543 QLA82XX_ADDR_DDR_NET_MAX
) ||
544 !QLA82XX_ADDR_IN_RANGE(addr
+ size
- 1,
545 QLA82XX_ADDR_DDR_NET
, QLA82XX_ADDR_DDR_NET_MAX
) ||
546 ((size
!= 1) && (size
!= 2) && (size
!= 4) && (size
!= 8))) {
552 static int qla4_8xxx_pci_set_window_warning_count
;
555 qla4_8xxx_pci_set_window(struct scsi_qla_host
*ha
, unsigned long long addr
)
560 if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_DDR_NET
,
561 QLA82XX_ADDR_DDR_NET_MAX
)) {
562 /* DDR network side */
563 window
= MN_WIN(addr
);
564 ha
->ddr_mn_window
= window
;
565 qla4_8xxx_wr_32(ha
, ha
->mn_win_crb
|
566 QLA82XX_PCI_CRBSPACE
, window
);
567 win_read
= qla4_8xxx_rd_32(ha
, ha
->mn_win_crb
|
568 QLA82XX_PCI_CRBSPACE
);
569 if ((win_read
<< 17) != window
) {
570 ql4_printk(KERN_WARNING
, ha
,
571 "%s: Written MNwin (0x%x) != Read MNwin (0x%x)\n",
572 __func__
, window
, win_read
);
574 addr
= GET_MEM_OFFS_2M(addr
) + QLA82XX_PCI_DDR_NET
;
575 } else if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_OCM0
,
576 QLA82XX_ADDR_OCM0_MAX
)) {
578 /* if bits 19:18&17:11 are on */
579 if ((addr
& 0x00ff800) == 0xff800) {
580 printk("%s: QM access not handled.\n", __func__
);
584 window
= OCM_WIN(addr
);
585 ha
->ddr_mn_window
= window
;
586 qla4_8xxx_wr_32(ha
, ha
->mn_win_crb
|
587 QLA82XX_PCI_CRBSPACE
, window
);
588 win_read
= qla4_8xxx_rd_32(ha
, ha
->mn_win_crb
|
589 QLA82XX_PCI_CRBSPACE
);
590 temp1
= ((window
& 0x1FF) << 7) |
591 ((window
& 0x0FFFE0000) >> 17);
592 if (win_read
!= temp1
) {
593 printk("%s: Written OCMwin (0x%x) != Read"
594 " OCMwin (0x%x)\n", __func__
, temp1
, win_read
);
596 addr
= GET_MEM_OFFS_2M(addr
) + QLA82XX_PCI_OCM0_2M
;
598 } else if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_QDR_NET
,
599 QLA82XX_P3_ADDR_QDR_NET_MAX
)) {
600 /* QDR network side */
601 window
= MS_WIN(addr
);
602 ha
->qdr_sn_window
= window
;
603 qla4_8xxx_wr_32(ha
, ha
->ms_win_crb
|
604 QLA82XX_PCI_CRBSPACE
, window
);
605 win_read
= qla4_8xxx_rd_32(ha
,
606 ha
->ms_win_crb
| QLA82XX_PCI_CRBSPACE
);
607 if (win_read
!= window
) {
608 printk("%s: Written MSwin (0x%x) != Read "
609 "MSwin (0x%x)\n", __func__
, window
, win_read
);
611 addr
= GET_MEM_OFFS_2M(addr
) + QLA82XX_PCI_QDR_NET
;
615 * peg gdb frequently accesses memory that doesn't exist,
616 * this limits the chit chat so debugging isn't slowed down.
618 if ((qla4_8xxx_pci_set_window_warning_count
++ < 8) ||
619 (qla4_8xxx_pci_set_window_warning_count
%64 == 0)) {
620 printk("%s: Warning:%s Unknown address range!\n",
621 __func__
, DRIVER_NAME
);
628 /* check if address is in the same windows as the previous access */
629 static int qla4_8xxx_pci_is_same_window(struct scsi_qla_host
*ha
,
630 unsigned long long addr
)
633 unsigned long long qdr_max
;
635 qdr_max
= QLA82XX_P3_ADDR_QDR_NET_MAX
;
637 if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_DDR_NET
,
638 QLA82XX_ADDR_DDR_NET_MAX
)) {
639 /* DDR network side */
640 BUG(); /* MN access can not come here */
641 } else if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_OCM0
,
642 QLA82XX_ADDR_OCM0_MAX
)) {
644 } else if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_OCM1
,
645 QLA82XX_ADDR_OCM1_MAX
)) {
647 } else if (QLA82XX_ADDR_IN_RANGE(addr
, QLA82XX_ADDR_QDR_NET
,
649 /* QDR network side */
650 window
= ((addr
- QLA82XX_ADDR_QDR_NET
) >> 22) & 0x3f;
651 if (ha
->qdr_sn_window
== window
)
659 static inline __u64
readq(const volatile void __iomem
*addr
)
661 const volatile u32 __iomem
*p
= addr
;
667 return low
+ ((u64
)high
<< 32);
672 static inline void writeq(__u64 val
, volatile void __iomem
*addr
)
675 writel(val
>> 32, addr
+4);
679 static int qla4_8xxx_pci_mem_read_direct(struct scsi_qla_host
*ha
,
680 u64 off
, void *data
, int size
)
686 void __iomem
*mem_ptr
= NULL
;
687 unsigned long mem_base
;
688 unsigned long mem_page
;
690 write_lock_irqsave(&ha
->hw_lock
, flags
);
693 * If attempting to access unknown address or straddle hw windows,
696 start
= qla4_8xxx_pci_set_window(ha
, off
);
697 if ((start
== -1UL) ||
698 (qla4_8xxx_pci_is_same_window(ha
, off
+ size
- 1) == 0)) {
699 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
700 printk(KERN_ERR
"%s out of bound pci memory access. "
701 "offset is 0x%llx\n", DRIVER_NAME
, off
);
705 addr
= qla4_8xxx_pci_base_offsetfset(ha
, start
);
707 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
708 mem_base
= pci_resource_start(ha
->pdev
, 0);
709 mem_page
= start
& PAGE_MASK
;
710 /* Map two pages whenever user tries to access addresses in two
713 if (mem_page
!= ((start
+ size
- 1) & PAGE_MASK
))
714 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
* 2);
716 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
);
718 if (mem_ptr
== NULL
) {
723 addr
+= start
& (PAGE_SIZE
- 1);
724 write_lock_irqsave(&ha
->hw_lock
, flags
);
729 *(u8
*)data
= readb(addr
);
732 *(u16
*)data
= readw(addr
);
735 *(u32
*)data
= readl(addr
);
738 *(u64
*)data
= readq(addr
);
744 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
752 qla4_8xxx_pci_mem_write_direct(struct scsi_qla_host
*ha
, u64 off
,
753 void *data
, int size
)
759 void __iomem
*mem_ptr
= NULL
;
760 unsigned long mem_base
;
761 unsigned long mem_page
;
763 write_lock_irqsave(&ha
->hw_lock
, flags
);
766 * If attempting to access unknown address or straddle hw windows,
769 start
= qla4_8xxx_pci_set_window(ha
, off
);
770 if ((start
== -1UL) ||
771 (qla4_8xxx_pci_is_same_window(ha
, off
+ size
- 1) == 0)) {
772 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
773 printk(KERN_ERR
"%s out of bound pci memory access. "
774 "offset is 0x%llx\n", DRIVER_NAME
, off
);
778 addr
= qla4_8xxx_pci_base_offsetfset(ha
, start
);
780 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
781 mem_base
= pci_resource_start(ha
->pdev
, 0);
782 mem_page
= start
& PAGE_MASK
;
783 /* Map two pages whenever user tries to access addresses in two
786 if (mem_page
!= ((start
+ size
- 1) & PAGE_MASK
))
787 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
*2);
789 mem_ptr
= ioremap(mem_base
+ mem_page
, PAGE_SIZE
);
794 addr
+= start
& (PAGE_SIZE
- 1);
795 write_lock_irqsave(&ha
->hw_lock
, flags
);
800 writeb(*(u8
*)data
, addr
);
803 writew(*(u16
*)data
, addr
);
806 writel(*(u32
*)data
, addr
);
809 writeq(*(u64
*)data
, addr
);
815 write_unlock_irqrestore(&ha
->hw_lock
, flags
);
821 #define MTU_FUDGE_FACTOR 100
824 qla4_8xxx_decode_crb_addr(unsigned long addr
)
827 unsigned long base_addr
, offset
, pci_base
;
829 if (!qla4_8xxx_crb_table_initialized
)
830 qla4_8xxx_crb_addr_transform_setup();
832 pci_base
= ADDR_ERROR
;
833 base_addr
= addr
& 0xfff00000;
834 offset
= addr
& 0x000fffff;
836 for (i
= 0; i
< MAX_CRB_XFORM
; i
++) {
837 if (crb_addr_xform
[i
] == base_addr
) {
842 if (pci_base
== ADDR_ERROR
)
845 return pci_base
+ offset
;
848 static long rom_max_timeout
= 100;
849 static long qla4_8xxx_rom_lock_timeout
= 100;
852 qla4_8xxx_rom_lock(struct scsi_qla_host
*ha
)
855 int done
= 0, timeout
= 0;
858 /* acquire semaphore2 from PCI HW block */
860 done
= qla4_8xxx_rd_32(ha
, QLA82XX_PCIE_REG(PCIE_SEM2_LOCK
));
863 if (timeout
>= qla4_8xxx_rom_lock_timeout
) {
864 ql4_printk(KERN_WARNING
, ha
,
865 "%s: Failed to acquire rom lock", __func__
);
875 for (i
= 0; i
< 20; i
++)
876 cpu_relax(); /*This a nop instr on i386*/
879 qla4_8xxx_wr_32(ha
, QLA82XX_ROM_LOCK_ID
, ROM_LOCK_DRIVER
);
884 qla4_8xxx_rom_unlock(struct scsi_qla_host
*ha
)
886 qla4_8xxx_rd_32(ha
, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK
));
890 qla4_8xxx_wait_rom_done(struct scsi_qla_host
*ha
)
896 done
= qla4_8xxx_rd_32(ha
, QLA82XX_ROMUSB_GLB_STATUS
);
899 if (timeout
>= rom_max_timeout
) {
900 printk("%s: Timeout reached waiting for rom done",
909 qla4_8xxx_do_rom_fast_read(struct scsi_qla_host
*ha
, int addr
, int *valp
)
911 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_ROM_ADDRESS
, addr
);
912 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_ROM_DUMMY_BYTE_CNT
, 0);
913 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_ROM_ABYTE_CNT
, 3);
914 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_ROM_INSTR_OPCODE
, 0xb);
915 if (qla4_8xxx_wait_rom_done(ha
)) {
916 printk("%s: Error waiting for rom done\n", DRIVER_NAME
);
919 /* reset abyte_cnt and dummy_byte_cnt */
920 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_ROM_DUMMY_BYTE_CNT
, 0);
922 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_ROM_ABYTE_CNT
, 0);
924 *valp
= qla4_8xxx_rd_32(ha
, QLA82XX_ROMUSB_ROM_RDATA
);
929 qla4_8xxx_rom_fast_read(struct scsi_qla_host
*ha
, int addr
, int *valp
)
933 while ((qla4_8xxx_rom_lock(ha
) != 0) && (loops
< 50000)) {
937 if (loops
>= 50000) {
938 printk("%s: qla4_8xxx_rom_lock failed\n", DRIVER_NAME
);
941 ret
= qla4_8xxx_do_rom_fast_read(ha
, addr
, valp
);
942 qla4_8xxx_rom_unlock(ha
);
947 * This routine does CRB initialize sequence
948 * to put the ISP into operational state
951 qla4_8xxx_pinit_from_rom(struct scsi_qla_host
*ha
, int verbose
)
955 struct crb_addr_pair
*buf
;
959 struct crb_addr_pair
{
964 /* Halt all the indiviual PEGs and other blocks of the ISP */
965 qla4_8xxx_rom_lock(ha
);
967 /* mask all niu interrupts */
968 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_NIU
+ 0x40, 0xff);
969 /* disable xge rx/tx */
970 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_NIU
+ 0x70000, 0x00);
971 /* disable xg1 rx/tx */
972 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_NIU
+ 0x80000, 0x00);
975 val
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_SRE
+ 0x1000);
976 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_SRE
+ 0x1000, val
& (~(0x1)));
979 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_EPG
+ 0x1300, 0x1);
982 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_TIMER
+ 0x0, 0x0);
983 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_TIMER
+ 0x8, 0x0);
984 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_TIMER
+ 0x10, 0x0);
985 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_TIMER
+ 0x18, 0x0);
986 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_TIMER
+ 0x100, 0x0);
989 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_0
+ 0x3c, 1);
990 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_1
+ 0x3c, 1);
991 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_2
+ 0x3c, 1);
992 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_3
+ 0x3c, 1);
993 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_4
+ 0x3c, 1);
997 if (test_bit(DPC_RESET_HA
, &ha
->dpc_flags
))
998 /* don't reset CAM block on reset */
999 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_GLB_SW_RESET
, 0xfeffffff);
1001 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_GLB_SW_RESET
, 0xffffffff);
1004 val
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_QDR_NET
+ 0xe4);
1006 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_QDR_NET
+ 0xe4, val
);
1010 val
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_QDR_NET
+ 0xe4);
1012 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_QDR_NET
+ 0xe4, val
);
1015 qla4_8xxx_rom_unlock(ha
);
1017 /* Read the signature value from the flash.
1018 * Offset 0: Contain signature (0xcafecafe)
1019 * Offset 4: Offset and number of addr/value pairs
1020 * that present in CRB initialize sequence
1022 if (qla4_8xxx_rom_fast_read(ha
, 0, &n
) != 0 || n
!= 0xcafecafeUL
||
1023 qla4_8xxx_rom_fast_read(ha
, 4, &n
) != 0) {
1024 ql4_printk(KERN_WARNING
, ha
,
1025 "[ERROR] Reading crb_init area: n: %08x\n", n
);
1029 /* Offset in flash = lower 16 bits
1030 * Number of enteries = upper 16 bits
1032 offset
= n
& 0xffffU
;
1033 n
= (n
>> 16) & 0xffffU
;
1035 /* number of addr/value pair should not exceed 1024 enteries */
1037 ql4_printk(KERN_WARNING
, ha
,
1038 "%s: %s:n=0x%x [ERROR] Card flash not initialized.\n",
1039 DRIVER_NAME
, __func__
, n
);
1043 ql4_printk(KERN_INFO
, ha
,
1044 "%s: %d CRB init values found in ROM.\n", DRIVER_NAME
, n
);
1046 buf
= kmalloc(n
* sizeof(struct crb_addr_pair
), GFP_KERNEL
);
1048 ql4_printk(KERN_WARNING
, ha
,
1049 "%s: [ERROR] Unable to malloc memory.\n", DRIVER_NAME
);
1053 for (i
= 0; i
< n
; i
++) {
1054 if (qla4_8xxx_rom_fast_read(ha
, 8*i
+ 4*offset
, &val
) != 0 ||
1055 qla4_8xxx_rom_fast_read(ha
, 8*i
+ 4*offset
+ 4, &addr
) !=
1065 for (i
= 0; i
< n
; i
++) {
1066 /* Translate internal CRB initialization
1067 * address to PCI bus address
1069 off
= qla4_8xxx_decode_crb_addr((unsigned long)buf
[i
].addr
) +
1070 QLA82XX_PCI_CRBSPACE
;
1071 /* Not all CRB addr/value pair to be written,
1072 * some of them are skipped
1075 /* skip if LS bit is set*/
1077 DEBUG2(ql4_printk(KERN_WARNING
, ha
,
1078 "Skip CRB init replay for offset = 0x%lx\n", off
));
1082 /* skipping cold reboot MAGIC */
1083 if (off
== QLA82XX_CAM_RAM(0x1fc))
1086 /* do not reset PCI */
1087 if (off
== (ROMUSB_GLB
+ 0xbc))
1090 /* skip core clock, so that firmware can increase the clock */
1091 if (off
== (ROMUSB_GLB
+ 0xc8))
1094 /* skip the function enable register */
1095 if (off
== QLA82XX_PCIE_REG(PCIE_SETUP_FUNCTION
))
1098 if (off
== QLA82XX_PCIE_REG(PCIE_SETUP_FUNCTION2
))
1101 if ((off
& 0x0ff00000) == QLA82XX_CRB_SMB
)
1104 if ((off
& 0x0ff00000) == QLA82XX_CRB_DDR_NET
)
1107 if (off
== ADDR_ERROR
) {
1108 ql4_printk(KERN_WARNING
, ha
,
1109 "%s: [ERROR] Unknown addr: 0x%08lx\n",
1110 DRIVER_NAME
, buf
[i
].addr
);
1114 qla4_8xxx_wr_32(ha
, off
, buf
[i
].data
);
1116 /* ISP requires much bigger delay to settle down,
1117 * else crb_window returns 0xffffffff
1119 if (off
== QLA82XX_ROMUSB_GLB_SW_RESET
)
1122 /* ISP requires millisec delay between
1123 * successive CRB register updation
1130 /* Resetting the data and instruction cache */
1131 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_D
+0xec, 0x1e);
1132 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_D
+0x4c, 8);
1133 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_I
+0x4c, 8);
1135 /* Clear all protocol processing engines */
1136 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_0
+0x8, 0);
1137 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_0
+0xc, 0);
1138 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_1
+0x8, 0);
1139 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_1
+0xc, 0);
1140 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_2
+0x8, 0);
1141 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_2
+0xc, 0);
1142 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_3
+0x8, 0);
1143 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_3
+0xc, 0);
1149 qla4_8xxx_load_from_flash(struct scsi_qla_host
*ha
, uint32_t image_start
)
1153 long flashaddr
, memaddr
;
1157 flashaddr
= memaddr
= ha
->hw
.flt_region_bootload
;
1158 size
= (image_start
- flashaddr
) / 8;
1160 DEBUG2(printk("scsi%ld: %s: bootldr=0x%lx, fw_image=0x%x\n",
1161 ha
->host_no
, __func__
, flashaddr
, image_start
));
1163 for (i
= 0; i
< size
; i
++) {
1164 if ((qla4_8xxx_rom_fast_read(ha
, flashaddr
, (int *)&low
)) ||
1165 (qla4_8xxx_rom_fast_read(ha
, flashaddr
+ 4,
1168 goto exit_load_from_flash
;
1170 data
= ((u64
)high
<< 32) | low
;
1171 rval
= qla4_8xxx_pci_mem_write_2M(ha
, memaddr
, &data
, 8);
1173 goto exit_load_from_flash
;
1178 if (i
% 0x1000 == 0)
1185 read_lock(&ha
->hw_lock
);
1186 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_PEG_NET_0
+ 0x18, 0x1020);
1187 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_GLB_SW_RESET
, 0x80001e);
1188 read_unlock(&ha
->hw_lock
);
1190 exit_load_from_flash
:
1194 static int qla4_8xxx_load_fw(struct scsi_qla_host
*ha
, uint32_t image_start
)
1198 qla4_8xxx_wr_32(ha
, CRB_CMDPEG_STATE
, 0);
1199 if (qla4_8xxx_pinit_from_rom(ha
, 0) != QLA_SUCCESS
) {
1200 printk(KERN_WARNING
"%s: Error during CRB Initialization\n",
1207 /* at this point, QM is in reset. This could be a problem if there are
1208 * incoming d* transition queue messages. QM/PCIE could wedge.
1209 * To get around this, QM is brought out of reset.
1212 rst
= qla4_8xxx_rd_32(ha
, QLA82XX_ROMUSB_GLB_SW_RESET
);
1215 qla4_8xxx_wr_32(ha
, QLA82XX_ROMUSB_GLB_SW_RESET
, rst
);
1217 if (qla4_8xxx_load_from_flash(ha
, image_start
)) {
1218 printk("%s: Error trying to load fw from flash!\n", __func__
);
1226 qla4_8xxx_pci_mem_read_2M(struct scsi_qla_host
*ha
,
1227 u64 off
, void *data
, int size
)
1229 int i
, j
= 0, k
, start
, end
, loop
, sz
[2], off0
[2];
1232 uint64_t off8
, val
, mem_crb
, word
[2] = {0, 0};
1235 * If not MN, go check for MS or invalid.
1238 if (off
>= QLA82XX_ADDR_QDR_NET
&& off
<= QLA82XX_P3_ADDR_QDR_NET_MAX
)
1239 mem_crb
= QLA82XX_CRB_QDR_NET
;
1241 mem_crb
= QLA82XX_CRB_DDR_NET
;
1242 if (qla4_8xxx_pci_mem_bound_check(ha
, off
, size
) == 0)
1243 return qla4_8xxx_pci_mem_read_direct(ha
,
1248 off8
= off
& 0xfffffff0;
1249 off0
[0] = off
& 0xf;
1250 sz
[0] = (size
< (16 - off0
[0])) ? size
: (16 - off0
[0]);
1253 loop
= ((off0
[0] + size
- 1) >> shift_amount
) + 1;
1255 sz
[1] = size
- sz
[0];
1257 for (i
= 0; i
< loop
; i
++) {
1258 temp
= off8
+ (i
<< shift_amount
);
1259 qla4_8xxx_wr_32(ha
, mem_crb
+ MIU_TEST_AGT_ADDR_LO
, temp
);
1261 qla4_8xxx_wr_32(ha
, mem_crb
+ MIU_TEST_AGT_ADDR_HI
, temp
);
1262 temp
= MIU_TA_CTL_ENABLE
;
1263 qla4_8xxx_wr_32(ha
, mem_crb
+ MIU_TEST_AGT_CTRL
, temp
);
1264 temp
= MIU_TA_CTL_START
| MIU_TA_CTL_ENABLE
;
1265 qla4_8xxx_wr_32(ha
, mem_crb
+ MIU_TEST_AGT_CTRL
, temp
);
1267 for (j
= 0; j
< MAX_CTL_CHECK
; j
++) {
1268 temp
= qla4_8xxx_rd_32(ha
, mem_crb
+ MIU_TEST_AGT_CTRL
);
1269 if ((temp
& MIU_TA_CTL_BUSY
) == 0)
1273 if (j
>= MAX_CTL_CHECK
) {
1274 if (printk_ratelimit())
1275 ql4_printk(KERN_ERR
, ha
,
1276 "failed to read through agent\n");
1280 start
= off0
[i
] >> 2;
1281 end
= (off0
[i
] + sz
[i
] - 1) >> 2;
1282 for (k
= start
; k
<= end
; k
++) {
1283 temp
= qla4_8xxx_rd_32(ha
,
1284 mem_crb
+ MIU_TEST_AGT_RDDATA(k
));
1285 word
[i
] |= ((uint64_t)temp
<< (32 * (k
& 1)));
1289 if (j
>= MAX_CTL_CHECK
)
1292 if ((off0
[0] & 7) == 0) {
1295 val
= ((word
[0] >> (off0
[0] * 8)) & (~(~0ULL << (sz
[0] * 8)))) |
1296 ((word
[1] & (~(~0ULL << (sz
[1] * 8)))) << (sz
[0] * 8));
1301 *(uint8_t *)data
= val
;
1304 *(uint16_t *)data
= val
;
1307 *(uint32_t *)data
= val
;
1310 *(uint64_t *)data
= val
;
1317 qla4_8xxx_pci_mem_write_2M(struct scsi_qla_host
*ha
,
1318 u64 off
, void *data
, int size
)
1320 int i
, j
, ret
= 0, loop
, sz
[2], off0
;
1321 int scale
, shift_amount
, startword
;
1323 uint64_t off8
, mem_crb
, tmpw
, word
[2] = {0, 0};
1326 * If not MN, go check for MS or invalid.
1328 if (off
>= QLA82XX_ADDR_QDR_NET
&& off
<= QLA82XX_P3_ADDR_QDR_NET_MAX
)
1329 mem_crb
= QLA82XX_CRB_QDR_NET
;
1331 mem_crb
= QLA82XX_CRB_DDR_NET
;
1332 if (qla4_8xxx_pci_mem_bound_check(ha
, off
, size
) == 0)
1333 return qla4_8xxx_pci_mem_write_direct(ha
,
1338 sz
[0] = (size
< (8 - off0
)) ? size
: (8 - off0
);
1339 sz
[1] = size
- sz
[0];
1341 off8
= off
& 0xfffffff0;
1342 loop
= (((off
& 0xf) + size
- 1) >> 4) + 1;
1345 startword
= (off
& 0xf)/8;
1347 for (i
= 0; i
< loop
; i
++) {
1348 if (qla4_8xxx_pci_mem_read_2M(ha
, off8
+
1349 (i
<< shift_amount
), &word
[i
* scale
], 8))
1355 tmpw
= *((uint8_t *)data
);
1358 tmpw
= *((uint16_t *)data
);
1361 tmpw
= *((uint32_t *)data
);
1365 tmpw
= *((uint64_t *)data
);
1370 word
[startword
] = tmpw
;
1373 ~((~(~0ULL << (sz
[0] * 8))) << (off0
* 8));
1374 word
[startword
] |= tmpw
<< (off0
* 8);
1378 word
[startword
+1] &= ~(~0ULL << (sz
[1] * 8));
1379 word
[startword
+1] |= tmpw
>> (sz
[0] * 8);
1382 for (i
= 0; i
< loop
; i
++) {
1383 temp
= off8
+ (i
<< shift_amount
);
1384 qla4_8xxx_wr_32(ha
, mem_crb
+MIU_TEST_AGT_ADDR_LO
, temp
);
1386 qla4_8xxx_wr_32(ha
, mem_crb
+MIU_TEST_AGT_ADDR_HI
, temp
);
1387 temp
= word
[i
* scale
] & 0xffffffff;
1388 qla4_8xxx_wr_32(ha
, mem_crb
+MIU_TEST_AGT_WRDATA_LO
, temp
);
1389 temp
= (word
[i
* scale
] >> 32) & 0xffffffff;
1390 qla4_8xxx_wr_32(ha
, mem_crb
+MIU_TEST_AGT_WRDATA_HI
, temp
);
1391 temp
= word
[i
*scale
+ 1] & 0xffffffff;
1392 qla4_8xxx_wr_32(ha
, mem_crb
+ MIU_TEST_AGT_WRDATA_UPPER_LO
,
1394 temp
= (word
[i
*scale
+ 1] >> 32) & 0xffffffff;
1395 qla4_8xxx_wr_32(ha
, mem_crb
+ MIU_TEST_AGT_WRDATA_UPPER_HI
,
1398 temp
= MIU_TA_CTL_ENABLE
| MIU_TA_CTL_WRITE
;
1399 qla4_8xxx_wr_32(ha
, mem_crb
+MIU_TEST_AGT_CTRL
, temp
);
1400 temp
= MIU_TA_CTL_START
| MIU_TA_CTL_ENABLE
| MIU_TA_CTL_WRITE
;
1401 qla4_8xxx_wr_32(ha
, mem_crb
+MIU_TEST_AGT_CTRL
, temp
);
1403 for (j
= 0; j
< MAX_CTL_CHECK
; j
++) {
1404 temp
= qla4_8xxx_rd_32(ha
, mem_crb
+ MIU_TEST_AGT_CTRL
);
1405 if ((temp
& MIU_TA_CTL_BUSY
) == 0)
1409 if (j
>= MAX_CTL_CHECK
) {
1410 if (printk_ratelimit())
1411 ql4_printk(KERN_ERR
, ha
,
1412 "failed to write through agent\n");
1421 static int qla4_8xxx_cmdpeg_ready(struct scsi_qla_host
*ha
, int pegtune_val
)
1428 val
= qla4_8xxx_rd_32(ha
, CRB_CMDPEG_STATE
);
1429 if ((val
== PHAN_INITIALIZE_COMPLETE
) ||
1430 (val
== PHAN_INITIALIZE_ACK
))
1432 set_current_state(TASK_UNINTERRUPTIBLE
);
1433 schedule_timeout(500);
1435 } while (--retries
);
1438 pegtune_val
= qla4_8xxx_rd_32(ha
,
1439 QLA82XX_ROMUSB_GLB_PEGTUNE_DONE
);
1440 printk(KERN_WARNING
"%s: init failed, "
1441 "pegtune_val = %x\n", __func__
, pegtune_val
);
1448 static int qla4_8xxx_rcvpeg_ready(struct scsi_qla_host
*ha
)
1454 read_lock(&ha
->hw_lock
);
1455 state
= qla4_8xxx_rd_32(ha
, CRB_RCVPEG_STATE
);
1456 read_unlock(&ha
->hw_lock
);
1458 while ((state
!= PHAN_PEG_RCV_INITIALIZED
) && (loops
< 30000)) {
1461 read_lock(&ha
->hw_lock
);
1462 state
= qla4_8xxx_rd_32(ha
, CRB_RCVPEG_STATE
);
1463 read_unlock(&ha
->hw_lock
);
1468 if (loops
>= 30000) {
1469 DEBUG2(ql4_printk(KERN_INFO
, ha
,
1470 "Receive Peg initialization not complete: 0x%x.\n", state
));
1478 qla4_8xxx_set_drv_active(struct scsi_qla_host
*ha
)
1480 uint32_t drv_active
;
1482 drv_active
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_ACTIVE
);
1483 drv_active
|= (1 << (ha
->func_num
* 4));
1484 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DRV_ACTIVE
, drv_active
);
1488 qla4_8xxx_clear_drv_active(struct scsi_qla_host
*ha
)
1490 uint32_t drv_active
;
1492 drv_active
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_ACTIVE
);
1493 drv_active
&= ~(1 << (ha
->func_num
* 4));
1494 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DRV_ACTIVE
, drv_active
);
1498 qla4_8xxx_need_reset(struct scsi_qla_host
*ha
)
1500 uint32_t drv_state
, drv_active
;
1503 drv_active
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_ACTIVE
);
1504 drv_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_STATE
);
1505 rval
= drv_state
& (1 << (ha
->func_num
* 4));
1506 if ((test_bit(AF_EEH_BUSY
, &ha
->flags
)) && drv_active
)
1513 qla4_8xxx_set_rst_ready(struct scsi_qla_host
*ha
)
1517 drv_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_STATE
);
1518 drv_state
|= (1 << (ha
->func_num
* 4));
1519 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DRV_STATE
, drv_state
);
1523 qla4_8xxx_clear_rst_ready(struct scsi_qla_host
*ha
)
1527 drv_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_STATE
);
1528 drv_state
&= ~(1 << (ha
->func_num
* 4));
1529 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DRV_STATE
, drv_state
);
1533 qla4_8xxx_set_qsnt_ready(struct scsi_qla_host
*ha
)
1535 uint32_t qsnt_state
;
1537 qsnt_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_STATE
);
1538 qsnt_state
|= (2 << (ha
->func_num
* 4));
1539 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DRV_STATE
, qsnt_state
);
1544 qla4_8xxx_start_firmware(struct scsi_qla_host
*ha
, uint32_t image_start
)
1549 /* scrub dma mask expansion register */
1550 qla4_8xxx_wr_32(ha
, CRB_DMA_SHIFT
, 0x55555555);
1552 /* Overwrite stale initialization register values */
1553 qla4_8xxx_wr_32(ha
, CRB_CMDPEG_STATE
, 0);
1554 qla4_8xxx_wr_32(ha
, CRB_RCVPEG_STATE
, 0);
1555 qla4_8xxx_wr_32(ha
, QLA82XX_PEG_HALT_STATUS1
, 0);
1556 qla4_8xxx_wr_32(ha
, QLA82XX_PEG_HALT_STATUS2
, 0);
1558 if (qla4_8xxx_load_fw(ha
, image_start
) != QLA_SUCCESS
) {
1559 printk("%s: Error trying to start fw!\n", __func__
);
1563 /* Handshake with the card before we register the devices. */
1564 if (qla4_8xxx_cmdpeg_ready(ha
, 0) != QLA_SUCCESS
) {
1565 printk("%s: Error during card handshake!\n", __func__
);
1569 /* Negotiated Link width */
1570 pcie_cap
= pci_find_capability(ha
->pdev
, PCI_CAP_ID_EXP
);
1571 pci_read_config_word(ha
->pdev
, pcie_cap
+ PCI_EXP_LNKSTA
, &lnk
);
1572 ha
->link_width
= (lnk
>> 4) & 0x3f;
1574 /* Synchronize with Receive peg */
1575 return qla4_8xxx_rcvpeg_ready(ha
);
1579 qla4_8xxx_try_start_fw(struct scsi_qla_host
*ha
)
1581 int rval
= QLA_ERROR
;
1585 * 1) Operational firmware residing in flash.
1589 ql4_printk(KERN_INFO
, ha
,
1590 "FW: Retrieving flash offsets from FLT/FDT ...\n");
1591 rval
= qla4_8xxx_get_flash_info(ha
);
1592 if (rval
!= QLA_SUCCESS
)
1595 ql4_printk(KERN_INFO
, ha
,
1596 "FW: Attempting to load firmware from flash...\n");
1597 rval
= qla4_8xxx_start_firmware(ha
, ha
->hw
.flt_region_fw
);
1599 if (rval
!= QLA_SUCCESS
) {
1600 ql4_printk(KERN_ERR
, ha
, "FW: Load firmware from flash"
1608 static void qla4_8xxx_rom_lock_recovery(struct scsi_qla_host
*ha
)
1610 if (qla4_8xxx_rom_lock(ha
)) {
1611 /* Someone else is holding the lock. */
1612 dev_info(&ha
->pdev
->dev
, "Resetting rom_lock\n");
1616 * Either we got the lock, or someone
1617 * else died while holding it.
1618 * In either case, unlock.
1620 qla4_8xxx_rom_unlock(ha
);
1624 * qla4_8xxx_device_bootstrap - Initialize device, set DEV_READY, start fw
1625 * @ha: pointer to adapter structure
1627 * Note: IDC lock must be held upon entry
1630 qla4_8xxx_device_bootstrap(struct scsi_qla_host
*ha
)
1632 int rval
= QLA_ERROR
;
1634 uint32_t old_count
, count
;
1635 int need_reset
= 0, peg_stuck
= 1;
1637 need_reset
= qla4_8xxx_need_reset(ha
);
1639 old_count
= qla4_8xxx_rd_32(ha
, QLA82XX_PEG_ALIVE_COUNTER
);
1641 for (i
= 0; i
< 10; i
++) {
1642 timeout
= msleep_interruptible(200);
1644 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
,
1645 QLA82XX_DEV_FAILED
);
1649 count
= qla4_8xxx_rd_32(ha
, QLA82XX_PEG_ALIVE_COUNTER
);
1650 if (count
!= old_count
)
1655 /* We are trying to perform a recovery here. */
1657 qla4_8xxx_rom_lock_recovery(ha
);
1658 goto dev_initialize
;
1660 /* Start of day for this ha context. */
1662 /* Either we are the first or recovery in progress. */
1663 qla4_8xxx_rom_lock_recovery(ha
);
1664 goto dev_initialize
;
1666 /* Firmware already running. */
1673 /* set to DEV_INITIALIZING */
1674 ql4_printk(KERN_INFO
, ha
, "HW State: INITIALIZING\n");
1675 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
, QLA82XX_DEV_INITIALIZING
);
1677 /* Driver that sets device state to initializating sets IDC version */
1678 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DRV_IDC_VERSION
, QLA82XX_IDC_VERSION
);
1680 qla4_8xxx_idc_unlock(ha
);
1681 rval
= qla4_8xxx_try_start_fw(ha
);
1682 qla4_8xxx_idc_lock(ha
);
1684 if (rval
!= QLA_SUCCESS
) {
1685 ql4_printk(KERN_INFO
, ha
, "HW State: FAILED\n");
1686 qla4_8xxx_clear_drv_active(ha
);
1687 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
, QLA82XX_DEV_FAILED
);
1692 ql4_printk(KERN_INFO
, ha
, "HW State: READY\n");
1693 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
, QLA82XX_DEV_READY
);
1699 * qla4_8xxx_need_reset_handler - Code to start reset sequence
1700 * @ha: pointer to adapter structure
1702 * Note: IDC lock must be held upon entry
1705 qla4_8xxx_need_reset_handler(struct scsi_qla_host
*ha
)
1707 uint32_t dev_state
, drv_state
, drv_active
;
1708 unsigned long reset_timeout
;
1710 ql4_printk(KERN_INFO
, ha
,
1711 "Performing ISP error recovery\n");
1713 if (test_and_clear_bit(AF_ONLINE
, &ha
->flags
)) {
1714 qla4_8xxx_idc_unlock(ha
);
1715 ha
->isp_ops
->disable_intrs(ha
);
1716 qla4_8xxx_idc_lock(ha
);
1719 qla4_8xxx_set_rst_ready(ha
);
1721 /* wait for 10 seconds for reset ack from all functions */
1722 reset_timeout
= jiffies
+ (ha
->nx_reset_timeout
* HZ
);
1724 drv_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_STATE
);
1725 drv_active
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_ACTIVE
);
1727 ql4_printk(KERN_INFO
, ha
,
1728 "%s(%ld): drv_state = 0x%x, drv_active = 0x%x\n",
1729 __func__
, ha
->host_no
, drv_state
, drv_active
);
1731 while (drv_state
!= drv_active
) {
1732 if (time_after_eq(jiffies
, reset_timeout
)) {
1733 printk("%s: RESET TIMEOUT!\n", DRIVER_NAME
);
1737 qla4_8xxx_idc_unlock(ha
);
1739 qla4_8xxx_idc_lock(ha
);
1741 drv_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_STATE
);
1742 drv_active
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DRV_ACTIVE
);
1745 dev_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DEV_STATE
);
1746 ql4_printk(KERN_INFO
, ha
, "3:Device state is 0x%x = %s\n", dev_state
,
1747 dev_state
< MAX_STATES
? qdev_state
[dev_state
] : "Unknown");
1749 /* Force to DEV_COLD unless someone else is starting a reset */
1750 if (dev_state
!= QLA82XX_DEV_INITIALIZING
) {
1751 ql4_printk(KERN_INFO
, ha
, "HW State: COLD/RE-INIT\n");
1752 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
, QLA82XX_DEV_COLD
);
1757 * qla4_8xxx_need_qsnt_handler - Code to start qsnt
1758 * @ha: pointer to adapter structure
1761 qla4_8xxx_need_qsnt_handler(struct scsi_qla_host
*ha
)
1763 qla4_8xxx_idc_lock(ha
);
1764 qla4_8xxx_set_qsnt_ready(ha
);
1765 qla4_8xxx_idc_unlock(ha
);
1769 * qla4_8xxx_device_state_handler - Adapter state machine
1770 * @ha: pointer to host adapter structure.
1772 * Note: IDC lock must be UNLOCKED upon entry
1774 int qla4_8xxx_device_state_handler(struct scsi_qla_host
*ha
)
1777 int rval
= QLA_SUCCESS
;
1778 unsigned long dev_init_timeout
;
1780 if (!test_bit(AF_INIT_DONE
, &ha
->flags
))
1781 qla4_8xxx_set_drv_active(ha
);
1783 dev_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DEV_STATE
);
1784 ql4_printk(KERN_INFO
, ha
, "1:Device state is 0x%x = %s\n", dev_state
,
1785 dev_state
< MAX_STATES
? qdev_state
[dev_state
] : "Unknown");
1787 /* wait for 30 seconds for device to go ready */
1788 dev_init_timeout
= jiffies
+ (ha
->nx_dev_init_timeout
* HZ
);
1791 qla4_8xxx_idc_lock(ha
);
1793 if (time_after_eq(jiffies
, dev_init_timeout
)) {
1794 ql4_printk(KERN_WARNING
, ha
, "Device init failed!\n");
1795 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
,
1796 QLA82XX_DEV_FAILED
);
1799 dev_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DEV_STATE
);
1800 ql4_printk(KERN_INFO
, ha
,
1801 "2:Device state is 0x%x = %s\n", dev_state
,
1802 dev_state
< MAX_STATES
? qdev_state
[dev_state
] : "Unknown");
1804 /* NOTE: Make sure idc unlocked upon exit of switch statement */
1805 switch (dev_state
) {
1806 case QLA82XX_DEV_READY
:
1807 qla4_8xxx_idc_unlock(ha
);
1809 case QLA82XX_DEV_COLD
:
1810 rval
= qla4_8xxx_device_bootstrap(ha
);
1811 qla4_8xxx_idc_unlock(ha
);
1813 case QLA82XX_DEV_INITIALIZING
:
1814 qla4_8xxx_idc_unlock(ha
);
1817 case QLA82XX_DEV_NEED_RESET
:
1818 if (!ql4xdontresethba
) {
1819 qla4_8xxx_need_reset_handler(ha
);
1820 /* Update timeout value after need
1822 dev_init_timeout
= jiffies
+
1823 (ha
->nx_dev_init_timeout
* HZ
);
1825 qla4_8xxx_idc_unlock(ha
);
1827 case QLA82XX_DEV_NEED_QUIESCENT
:
1828 qla4_8xxx_idc_unlock(ha
);
1829 /* idc locked/unlocked in handler */
1830 qla4_8xxx_need_qsnt_handler(ha
);
1831 qla4_8xxx_idc_lock(ha
);
1832 /* fall thru needs idc_locked */
1833 case QLA82XX_DEV_QUIESCENT
:
1834 qla4_8xxx_idc_unlock(ha
);
1837 case QLA82XX_DEV_FAILED
:
1838 qla4_8xxx_idc_unlock(ha
);
1839 qla4xxx_dead_adapter_cleanup(ha
);
1843 qla4_8xxx_idc_unlock(ha
);
1844 qla4xxx_dead_adapter_cleanup(ha
);
1853 int qla4_8xxx_load_risc(struct scsi_qla_host
*ha
)
1856 retval
= qla4_8xxx_device_state_handler(ha
);
1858 if (retval
== QLA_SUCCESS
&& !test_bit(AF_INIT_DONE
, &ha
->flags
))
1859 retval
= qla4xxx_request_irqs(ha
);
1864 /*****************************************************************************/
1865 /* Flash Manipulation Routines */
1866 /*****************************************************************************/
1868 #define OPTROM_BURST_SIZE 0x1000
1869 #define OPTROM_BURST_DWORDS (OPTROM_BURST_SIZE / 4)
1871 #define FARX_DATA_FLAG BIT_31
1872 #define FARX_ACCESS_FLASH_CONF 0x7FFD0000
1873 #define FARX_ACCESS_FLASH_DATA 0x7FF00000
1875 static inline uint32_t
1876 flash_conf_addr(struct ql82xx_hw_data
*hw
, uint32_t faddr
)
1878 return hw
->flash_conf_off
| faddr
;
1881 static inline uint32_t
1882 flash_data_addr(struct ql82xx_hw_data
*hw
, uint32_t faddr
)
1884 return hw
->flash_data_off
| faddr
;
1888 qla4_8xxx_read_flash_data(struct scsi_qla_host
*ha
, uint32_t *dwptr
,
1889 uint32_t faddr
, uint32_t length
)
1894 while ((qla4_8xxx_rom_lock(ha
) != 0) && (loops
< 50000)) {
1899 if (loops
>= 50000) {
1900 ql4_printk(KERN_WARNING
, ha
, "ROM lock failed\n");
1904 /* Dword reads to flash. */
1905 for (i
= 0; i
< length
/4; i
++, faddr
+= 4) {
1906 if (qla4_8xxx_do_rom_fast_read(ha
, faddr
, &val
)) {
1907 ql4_printk(KERN_WARNING
, ha
,
1908 "Do ROM fast read failed\n");
1911 dwptr
[i
] = __constant_cpu_to_le32(val
);
1915 qla4_8xxx_rom_unlock(ha
);
1920 * Address and length are byte address
1923 qla4_8xxx_read_optrom_data(struct scsi_qla_host
*ha
, uint8_t *buf
,
1924 uint32_t offset
, uint32_t length
)
1926 qla4_8xxx_read_flash_data(ha
, (uint32_t *)buf
, offset
, length
);
1931 qla4_8xxx_find_flt_start(struct scsi_qla_host
*ha
, uint32_t *start
)
1933 const char *loc
, *locations
[] = { "DEF", "PCI" };
1936 * FLT-location structure resides after the last PCI region.
1939 /* Begin with sane defaults. */
1941 *start
= FA_FLASH_LAYOUT_ADDR_82
;
1943 DEBUG2(ql4_printk(KERN_INFO
, ha
, "FLTL[%s] = 0x%x.\n", loc
, *start
));
1948 qla4_8xxx_get_flt_info(struct scsi_qla_host
*ha
, uint32_t flt_addr
)
1950 const char *loc
, *locations
[] = { "DEF", "FLT" };
1952 uint16_t cnt
, chksum
;
1954 struct qla_flt_header
*flt
;
1955 struct qla_flt_region
*region
;
1956 struct ql82xx_hw_data
*hw
= &ha
->hw
;
1958 hw
->flt_region_flt
= flt_addr
;
1959 wptr
= (uint16_t *)ha
->request_ring
;
1960 flt
= (struct qla_flt_header
*)ha
->request_ring
;
1961 region
= (struct qla_flt_region
*)&flt
[1];
1962 qla4_8xxx_read_optrom_data(ha
, (uint8_t *)ha
->request_ring
,
1963 flt_addr
<< 2, OPTROM_BURST_SIZE
);
1964 if (*wptr
== __constant_cpu_to_le16(0xffff))
1966 if (flt
->version
!= __constant_cpu_to_le16(1)) {
1967 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Unsupported FLT detected: "
1968 "version=0x%x length=0x%x checksum=0x%x.\n",
1969 le16_to_cpu(flt
->version
), le16_to_cpu(flt
->length
),
1970 le16_to_cpu(flt
->checksum
)));
1974 cnt
= (sizeof(struct qla_flt_header
) + le16_to_cpu(flt
->length
)) >> 1;
1975 for (chksum
= 0; cnt
; cnt
--)
1976 chksum
+= le16_to_cpu(*wptr
++);
1978 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Inconsistent FLT detected: "
1979 "version=0x%x length=0x%x checksum=0x%x.\n",
1980 le16_to_cpu(flt
->version
), le16_to_cpu(flt
->length
),
1986 cnt
= le16_to_cpu(flt
->length
) / sizeof(struct qla_flt_region
);
1987 for ( ; cnt
; cnt
--, region
++) {
1988 /* Store addresses as DWORD offsets. */
1989 start
= le32_to_cpu(region
->start
) >> 2;
1991 DEBUG3(ql4_printk(KERN_DEBUG
, ha
, "FLT[%02x]: start=0x%x "
1992 "end=0x%x size=0x%x.\n", le32_to_cpu(region
->code
), start
,
1993 le32_to_cpu(region
->end
) >> 2, le32_to_cpu(region
->size
)));
1995 switch (le32_to_cpu(region
->code
) & 0xff) {
1997 hw
->flt_region_fdt
= start
;
1999 case FLT_REG_BOOT_CODE_82
:
2000 hw
->flt_region_boot
= start
;
2003 hw
->flt_region_fw
= start
;
2005 case FLT_REG_BOOTLOAD_82
:
2006 hw
->flt_region_bootload
= start
;
2013 /* Use hardcoded defaults. */
2016 hw
->flt_region_fdt
= FA_FLASH_DESCR_ADDR_82
;
2017 hw
->flt_region_boot
= FA_BOOT_CODE_ADDR_82
;
2018 hw
->flt_region_bootload
= FA_BOOT_LOAD_ADDR_82
;
2019 hw
->flt_region_fw
= FA_RISC_CODE_ADDR_82
;
2021 DEBUG2(ql4_printk(KERN_INFO
, ha
, "FLT[%s]: flt=0x%x fdt=0x%x "
2022 "boot=0x%x bootload=0x%x fw=0x%x\n", loc
, hw
->flt_region_flt
,
2023 hw
->flt_region_fdt
, hw
->flt_region_boot
, hw
->flt_region_bootload
,
2024 hw
->flt_region_fw
));
2028 qla4_8xxx_get_fdt_info(struct scsi_qla_host
*ha
)
2030 #define FLASH_BLK_SIZE_4K 0x1000
2031 #define FLASH_BLK_SIZE_32K 0x8000
2032 #define FLASH_BLK_SIZE_64K 0x10000
2033 const char *loc
, *locations
[] = { "MID", "FDT" };
2034 uint16_t cnt
, chksum
;
2036 struct qla_fdt_layout
*fdt
;
2039 struct ql82xx_hw_data
*hw
= &ha
->hw
;
2041 hw
->flash_conf_off
= FARX_ACCESS_FLASH_CONF
;
2042 hw
->flash_data_off
= FARX_ACCESS_FLASH_DATA
;
2044 wptr
= (uint16_t *)ha
->request_ring
;
2045 fdt
= (struct qla_fdt_layout
*)ha
->request_ring
;
2046 qla4_8xxx_read_optrom_data(ha
, (uint8_t *)ha
->request_ring
,
2047 hw
->flt_region_fdt
<< 2, OPTROM_BURST_SIZE
);
2049 if (*wptr
== __constant_cpu_to_le16(0xffff))
2052 if (fdt
->sig
[0] != 'Q' || fdt
->sig
[1] != 'L' || fdt
->sig
[2] != 'I' ||
2056 for (cnt
= 0, chksum
= 0; cnt
< sizeof(struct qla_fdt_layout
) >> 1;
2058 chksum
+= le16_to_cpu(*wptr
++);
2061 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Inconsistent FDT detected: "
2062 "checksum=0x%x id=%c version=0x%x.\n", chksum
, fdt
->sig
[0],
2063 le16_to_cpu(fdt
->version
)));
2068 mid
= le16_to_cpu(fdt
->man_id
);
2069 fid
= le16_to_cpu(fdt
->id
);
2070 hw
->fdt_wrt_disable
= fdt
->wrt_disable_bits
;
2071 hw
->fdt_erase_cmd
= flash_conf_addr(hw
, 0x0300 | fdt
->erase_cmd
);
2072 hw
->fdt_block_size
= le32_to_cpu(fdt
->block_size
);
2074 if (fdt
->unprotect_sec_cmd
) {
2075 hw
->fdt_unprotect_sec_cmd
= flash_conf_addr(hw
, 0x0300 |
2076 fdt
->unprotect_sec_cmd
);
2077 hw
->fdt_protect_sec_cmd
= fdt
->protect_sec_cmd
?
2078 flash_conf_addr(hw
, 0x0300 | fdt
->protect_sec_cmd
) :
2079 flash_conf_addr(hw
, 0x0336);
2085 hw
->fdt_block_size
= FLASH_BLK_SIZE_64K
;
2087 DEBUG2(ql4_printk(KERN_INFO
, ha
, "FDT[%s]: (0x%x/0x%x) erase=0x%x "
2088 "pro=%x upro=%x wrtd=0x%x blk=0x%x.\n", loc
, mid
, fid
,
2089 hw
->fdt_erase_cmd
, hw
->fdt_protect_sec_cmd
,
2090 hw
->fdt_unprotect_sec_cmd
, hw
->fdt_wrt_disable
,
2091 hw
->fdt_block_size
));
2095 qla4_8xxx_get_idc_param(struct scsi_qla_host
*ha
)
2097 #define QLA82XX_IDC_PARAM_ADDR 0x003e885c
2100 if (!is_qla8022(ha
))
2102 wptr
= (uint32_t *)ha
->request_ring
;
2103 qla4_8xxx_read_optrom_data(ha
, (uint8_t *)ha
->request_ring
,
2104 QLA82XX_IDC_PARAM_ADDR
, 8);
2106 if (*wptr
== __constant_cpu_to_le32(0xffffffff)) {
2107 ha
->nx_dev_init_timeout
= ROM_DEV_INIT_TIMEOUT
;
2108 ha
->nx_reset_timeout
= ROM_DRV_RESET_ACK_TIMEOUT
;
2110 ha
->nx_dev_init_timeout
= le32_to_cpu(*wptr
++);
2111 ha
->nx_reset_timeout
= le32_to_cpu(*wptr
);
2114 DEBUG2(ql4_printk(KERN_DEBUG
, ha
,
2115 "ha->nx_dev_init_timeout = %d\n", ha
->nx_dev_init_timeout
));
2116 DEBUG2(ql4_printk(KERN_DEBUG
, ha
,
2117 "ha->nx_reset_timeout = %d\n", ha
->nx_reset_timeout
));
2122 qla4_8xxx_get_flash_info(struct scsi_qla_host
*ha
)
2127 ret
= qla4_8xxx_find_flt_start(ha
, &flt_addr
);
2128 if (ret
!= QLA_SUCCESS
)
2131 qla4_8xxx_get_flt_info(ha
, flt_addr
);
2132 qla4_8xxx_get_fdt_info(ha
);
2133 qla4_8xxx_get_idc_param(ha
);
2139 * qla4_8xxx_stop_firmware - stops firmware on specified adapter instance
2140 * @ha: pointer to host adapter structure.
2143 * For iSCSI, throws away all I/O and AENs into bit bucket, so they will
2144 * not be available after successful return. Driver must cleanup potential
2145 * outstanding I/O's after calling this funcion.
2148 qla4_8xxx_stop_firmware(struct scsi_qla_host
*ha
)
2151 uint32_t mbox_cmd
[MBOX_REG_COUNT
];
2152 uint32_t mbox_sts
[MBOX_REG_COUNT
];
2154 memset(&mbox_cmd
, 0, sizeof(mbox_cmd
));
2155 memset(&mbox_sts
, 0, sizeof(mbox_sts
));
2157 mbox_cmd
[0] = MBOX_CMD_STOP_FW
;
2158 status
= qla4xxx_mailbox_command(ha
, MBOX_REG_COUNT
, 1,
2159 &mbox_cmd
[0], &mbox_sts
[0]);
2161 DEBUG2(printk("scsi%ld: %s: status = %d\n", ha
->host_no
,
2167 * qla4_8xxx_isp_reset - Resets ISP and aborts all outstanding commands.
2168 * @ha: pointer to host adapter structure.
2171 qla4_8xxx_isp_reset(struct scsi_qla_host
*ha
)
2176 qla4_8xxx_idc_lock(ha
);
2177 dev_state
= qla4_8xxx_rd_32(ha
, QLA82XX_CRB_DEV_STATE
);
2179 if (dev_state
== QLA82XX_DEV_READY
) {
2180 ql4_printk(KERN_INFO
, ha
, "HW State: NEED RESET\n");
2181 qla4_8xxx_wr_32(ha
, QLA82XX_CRB_DEV_STATE
,
2182 QLA82XX_DEV_NEED_RESET
);
2184 ql4_printk(KERN_INFO
, ha
, "HW State: DEVICE INITIALIZING\n");
2186 qla4_8xxx_idc_unlock(ha
);
2188 rval
= qla4_8xxx_device_state_handler(ha
);
2190 qla4_8xxx_idc_lock(ha
);
2191 qla4_8xxx_clear_rst_ready(ha
);
2192 qla4_8xxx_idc_unlock(ha
);
2194 if (rval
== QLA_SUCCESS
)
2195 clear_bit(AF_FW_RECOVERY
, &ha
->flags
);
2201 * qla4_8xxx_get_sys_info - get adapter MAC address(es) and serial number
2202 * @ha: pointer to host adapter structure.
2205 int qla4_8xxx_get_sys_info(struct scsi_qla_host
*ha
)
2207 uint32_t mbox_cmd
[MBOX_REG_COUNT
];
2208 uint32_t mbox_sts
[MBOX_REG_COUNT
];
2209 struct mbx_sys_info
*sys_info
;
2210 dma_addr_t sys_info_dma
;
2211 int status
= QLA_ERROR
;
2213 sys_info
= dma_alloc_coherent(&ha
->pdev
->dev
, sizeof(*sys_info
),
2214 &sys_info_dma
, GFP_KERNEL
);
2215 if (sys_info
== NULL
) {
2216 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
2217 ha
->host_no
, __func__
));
2221 memset(sys_info
, 0, sizeof(*sys_info
));
2222 memset(&mbox_cmd
, 0, sizeof(mbox_cmd
));
2223 memset(&mbox_sts
, 0, sizeof(mbox_sts
));
2225 mbox_cmd
[0] = MBOX_CMD_GET_SYS_INFO
;
2226 mbox_cmd
[1] = LSDW(sys_info_dma
);
2227 mbox_cmd
[2] = MSDW(sys_info_dma
);
2228 mbox_cmd
[4] = sizeof(*sys_info
);
2230 if (qla4xxx_mailbox_command(ha
, MBOX_REG_COUNT
, 6, &mbox_cmd
[0],
2231 &mbox_sts
[0]) != QLA_SUCCESS
) {
2232 DEBUG2(printk("scsi%ld: %s: GET_SYS_INFO failed\n",
2233 ha
->host_no
, __func__
));
2234 goto exit_validate_mac82
;
2237 /* Make sure we receive the minimum required data to cache internally */
2238 if (mbox_sts
[4] < offsetof(struct mbx_sys_info
, reserved
)) {
2239 DEBUG2(printk("scsi%ld: %s: GET_SYS_INFO data receive"
2240 " error (%x)\n", ha
->host_no
, __func__
, mbox_sts
[4]));
2241 goto exit_validate_mac82
;
2245 /* Save M.A.C. address & serial_number */
2246 memcpy(ha
->my_mac
, &sys_info
->mac_addr
[0],
2247 min(sizeof(ha
->my_mac
), sizeof(sys_info
->mac_addr
)));
2248 memcpy(ha
->serial_number
, &sys_info
->serial_number
,
2249 min(sizeof(ha
->serial_number
), sizeof(sys_info
->serial_number
)));
2251 DEBUG2(printk("scsi%ld: %s: "
2252 "mac %02x:%02x:%02x:%02x:%02x:%02x "
2253 "serial %s\n", ha
->host_no
, __func__
,
2254 ha
->my_mac
[0], ha
->my_mac
[1], ha
->my_mac
[2],
2255 ha
->my_mac
[3], ha
->my_mac
[4], ha
->my_mac
[5],
2256 ha
->serial_number
));
2258 status
= QLA_SUCCESS
;
2260 exit_validate_mac82
:
2261 dma_free_coherent(&ha
->pdev
->dev
, sizeof(*sys_info
), sys_info
,
2266 /* Interrupt handling helpers. */
2269 qla4_8xxx_mbx_intr_enable(struct scsi_qla_host
*ha
)
2271 uint32_t mbox_cmd
[MBOX_REG_COUNT
];
2272 uint32_t mbox_sts
[MBOX_REG_COUNT
];
2274 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s\n", __func__
));
2276 memset(&mbox_cmd
, 0, sizeof(mbox_cmd
));
2277 memset(&mbox_sts
, 0, sizeof(mbox_sts
));
2278 mbox_cmd
[0] = MBOX_CMD_ENABLE_INTRS
;
2279 mbox_cmd
[1] = INTR_ENABLE
;
2280 if (qla4xxx_mailbox_command(ha
, MBOX_REG_COUNT
, 1, &mbox_cmd
[0],
2281 &mbox_sts
[0]) != QLA_SUCCESS
) {
2282 DEBUG2(ql4_printk(KERN_INFO
, ha
,
2283 "%s: MBOX_CMD_ENABLE_INTRS failed (0x%04x)\n",
2284 __func__
, mbox_sts
[0]));
2291 qla4_8xxx_mbx_intr_disable(struct scsi_qla_host
*ha
)
2293 uint32_t mbox_cmd
[MBOX_REG_COUNT
];
2294 uint32_t mbox_sts
[MBOX_REG_COUNT
];
2296 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s\n", __func__
));
2298 memset(&mbox_cmd
, 0, sizeof(mbox_cmd
));
2299 memset(&mbox_sts
, 0, sizeof(mbox_sts
));
2300 mbox_cmd
[0] = MBOX_CMD_ENABLE_INTRS
;
2301 mbox_cmd
[1] = INTR_DISABLE
;
2302 if (qla4xxx_mailbox_command(ha
, MBOX_REG_COUNT
, 1, &mbox_cmd
[0],
2303 &mbox_sts
[0]) != QLA_SUCCESS
) {
2304 DEBUG2(ql4_printk(KERN_INFO
, ha
,
2305 "%s: MBOX_CMD_ENABLE_INTRS failed (0x%04x)\n",
2306 __func__
, mbox_sts
[0]));
2314 qla4_8xxx_enable_intrs(struct scsi_qla_host
*ha
)
2316 qla4_8xxx_mbx_intr_enable(ha
);
2318 spin_lock_irq(&ha
->hardware_lock
);
2319 /* BIT 10 - reset */
2320 qla4_8xxx_wr_32(ha
, ha
->nx_legacy_intr
.tgt_mask_reg
, 0xfbff);
2321 spin_unlock_irq(&ha
->hardware_lock
);
2322 set_bit(AF_INTERRUPTS_ON
, &ha
->flags
);
2326 qla4_8xxx_disable_intrs(struct scsi_qla_host
*ha
)
2328 if (test_and_clear_bit(AF_INTERRUPTS_ON
, &ha
->flags
))
2329 qla4_8xxx_mbx_intr_disable(ha
);
2331 spin_lock_irq(&ha
->hardware_lock
);
2333 qla4_8xxx_wr_32(ha
, ha
->nx_legacy_intr
.tgt_mask_reg
, 0x0400);
2334 spin_unlock_irq(&ha
->hardware_lock
);
2337 struct ql4_init_msix_entry
{
2341 irq_handler_t handler
;
2344 static struct ql4_init_msix_entry qla4_8xxx_msix_entries
[QLA_MSIX_ENTRIES
] = {
2345 { QLA_MSIX_DEFAULT
, QLA_MIDX_DEFAULT
,
2346 "qla4xxx (default)",
2347 (irq_handler_t
)qla4_8xxx_default_intr_handler
},
2348 { QLA_MSIX_RSP_Q
, QLA_MIDX_RSP_Q
,
2349 "qla4xxx (rsp_q)", (irq_handler_t
)qla4_8xxx_msix_rsp_q
},
2353 qla4_8xxx_disable_msix(struct scsi_qla_host
*ha
)
2356 struct ql4_msix_entry
*qentry
;
2358 for (i
= 0; i
< QLA_MSIX_ENTRIES
; i
++) {
2359 qentry
= &ha
->msix_entries
[qla4_8xxx_msix_entries
[i
].index
];
2360 if (qentry
->have_irq
) {
2361 free_irq(qentry
->msix_vector
, ha
);
2362 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s: %s\n",
2363 __func__
, qla4_8xxx_msix_entries
[i
].name
));
2366 pci_disable_msix(ha
->pdev
);
2367 clear_bit(AF_MSIX_ENABLED
, &ha
->flags
);
2371 qla4_8xxx_enable_msix(struct scsi_qla_host
*ha
)
2374 struct msix_entry entries
[QLA_MSIX_ENTRIES
];
2375 struct ql4_msix_entry
*qentry
;
2377 for (i
= 0; i
< QLA_MSIX_ENTRIES
; i
++)
2378 entries
[i
].entry
= qla4_8xxx_msix_entries
[i
].entry
;
2380 ret
= pci_enable_msix(ha
->pdev
, entries
, ARRAY_SIZE(entries
));
2382 ql4_printk(KERN_WARNING
, ha
,
2383 "MSI-X: Failed to enable support -- %d/%d\n",
2384 QLA_MSIX_ENTRIES
, ret
);
2387 set_bit(AF_MSIX_ENABLED
, &ha
->flags
);
2389 for (i
= 0; i
< QLA_MSIX_ENTRIES
; i
++) {
2390 qentry
= &ha
->msix_entries
[qla4_8xxx_msix_entries
[i
].index
];
2391 qentry
->msix_vector
= entries
[i
].vector
;
2392 qentry
->msix_entry
= entries
[i
].entry
;
2393 qentry
->have_irq
= 0;
2394 ret
= request_irq(qentry
->msix_vector
,
2395 qla4_8xxx_msix_entries
[i
].handler
, 0,
2396 qla4_8xxx_msix_entries
[i
].name
, ha
);
2398 ql4_printk(KERN_WARNING
, ha
,
2399 "MSI-X: Unable to register handler -- %x/%d.\n",
2400 qla4_8xxx_msix_entries
[i
].index
, ret
);
2401 qla4_8xxx_disable_msix(ha
);
2404 qentry
->have_irq
= 1;
2405 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s: %s\n",
2406 __func__
, qla4_8xxx_msix_entries
[i
].name
));