]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * QLOGIC LINUX SOFTWARE | |
3 | * | |
4 | * QLogic ISP2x00 device driver for Linux 2.6.x | |
5 | * Copyright (C) 2003-2004 QLogic Corporation | |
6 | * (www.qlogic.com) | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the | |
10 | * Free Software Foundation; either version 2, or (at your option) any | |
11 | * later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | */ | |
19 | #include "qla_def.h" | |
20 | ||
1da177e4 LT |
21 | static inline struct ct_sns_req * |
22 | qla2x00_prep_ct_req(struct ct_sns_req *, uint16_t, uint16_t); | |
23 | ||
24 | static inline struct sns_cmd_pkt * | |
25 | qla2x00_prep_sns_cmd(scsi_qla_host_t *, uint16_t, uint16_t, uint16_t); | |
26 | ||
27 | static int qla2x00_sns_ga_nxt(scsi_qla_host_t *, fc_port_t *); | |
28 | static int qla2x00_sns_gid_pt(scsi_qla_host_t *, sw_info_t *); | |
29 | static int qla2x00_sns_gpn_id(scsi_qla_host_t *, sw_info_t *); | |
30 | static int qla2x00_sns_gnn_id(scsi_qla_host_t *, sw_info_t *); | |
31 | static int qla2x00_sns_rft_id(scsi_qla_host_t *); | |
32 | static int qla2x00_sns_rnn_id(scsi_qla_host_t *); | |
33 | ||
34 | /** | |
35 | * qla2x00_prep_ms_iocb() - Prepare common MS IOCB fields for SNS CT query. | |
36 | * @ha: HA context | |
37 | * @req_size: request size in bytes | |
38 | * @rsp_size: response size in bytes | |
39 | * | |
40 | * Returns a pointer to the @ha's ms_iocb. | |
41 | */ | |
abbd8870 | 42 | ms_iocb_entry_t * |
1da177e4 LT |
43 | qla2x00_prep_ms_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size) |
44 | { | |
45 | ms_iocb_entry_t *ms_pkt; | |
46 | ||
47 | ms_pkt = ha->ms_iocb; | |
48 | memset(ms_pkt, 0, sizeof(ms_iocb_entry_t)); | |
49 | ||
50 | ms_pkt->entry_type = MS_IOCB_TYPE; | |
51 | ms_pkt->entry_count = 1; | |
52 | SET_TARGET_ID(ha, ms_pkt->loop_id, SIMPLE_NAME_SERVER); | |
53 | ms_pkt->control_flags = __constant_cpu_to_le16(CF_READ | CF_HEAD_TAG); | |
54 | ms_pkt->timeout = __constant_cpu_to_le16(25); | |
55 | ms_pkt->cmd_dsd_count = __constant_cpu_to_le16(1); | |
56 | ms_pkt->total_dsd_count = __constant_cpu_to_le16(2); | |
57 | ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size); | |
58 | ms_pkt->req_bytecount = cpu_to_le32(req_size); | |
59 | ||
60 | ms_pkt->dseg_req_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); | |
61 | ms_pkt->dseg_req_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); | |
62 | ms_pkt->dseg_req_length = ms_pkt->req_bytecount; | |
63 | ||
64 | ms_pkt->dseg_rsp_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma)); | |
65 | ms_pkt->dseg_rsp_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma)); | |
66 | ms_pkt->dseg_rsp_length = ms_pkt->rsp_bytecount; | |
67 | ||
68 | return (ms_pkt); | |
69 | } | |
70 | ||
71 | /** | |
72 | * qla2x00_prep_ct_req() - Prepare common CT request fields for SNS query. | |
73 | * @ct_req: CT request buffer | |
74 | * @cmd: GS command | |
75 | * @rsp_size: response size in bytes | |
76 | * | |
77 | * Returns a pointer to the intitialized @ct_req. | |
78 | */ | |
79 | static inline struct ct_sns_req * | |
80 | qla2x00_prep_ct_req(struct ct_sns_req *ct_req, uint16_t cmd, uint16_t rsp_size) | |
81 | { | |
82 | memset(ct_req, 0, sizeof(struct ct_sns_pkt)); | |
83 | ||
84 | ct_req->header.revision = 0x01; | |
85 | ct_req->header.gs_type = 0xFC; | |
86 | ct_req->header.gs_subtype = 0x02; | |
87 | ct_req->command = cpu_to_be16(cmd); | |
88 | ct_req->max_rsp_size = cpu_to_be16((rsp_size - 16) / 4); | |
89 | ||
90 | return (ct_req); | |
91 | } | |
92 | ||
93 | ||
94 | /** | |
95 | * qla2x00_ga_nxt() - SNS scan for fabric devices via GA_NXT command. | |
96 | * @ha: HA context | |
97 | * @fcport: fcport entry to updated | |
98 | * | |
99 | * Returns 0 on success. | |
100 | */ | |
101 | int | |
102 | qla2x00_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport) | |
103 | { | |
104 | int rval; | |
105 | ||
106 | ms_iocb_entry_t *ms_pkt; | |
107 | struct ct_sns_req *ct_req; | |
108 | struct ct_sns_rsp *ct_rsp; | |
109 | ||
110 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
111 | return (qla2x00_sns_ga_nxt(ha, fcport)); | |
112 | } | |
113 | ||
114 | /* Issue GA_NXT */ | |
115 | /* Prepare common MS IOCB */ | |
116 | ms_pkt = qla2x00_prep_ms_iocb(ha, GA_NXT_REQ_SIZE, GA_NXT_RSP_SIZE); | |
117 | ||
118 | /* Prepare CT request */ | |
119 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GA_NXT_CMD, | |
120 | GA_NXT_RSP_SIZE); | |
121 | ct_rsp = &ha->ct_sns->p.rsp; | |
122 | ||
123 | /* Prepare CT arguments -- port_id */ | |
124 | ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain; | |
125 | ct_req->req.port_id.port_id[1] = fcport->d_id.b.area; | |
126 | ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa; | |
127 | ||
128 | /* Execute MS IOCB */ | |
129 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
130 | sizeof(ms_iocb_entry_t)); | |
131 | if (rval != QLA_SUCCESS) { | |
132 | /*EMPTY*/ | |
133 | DEBUG2_3(printk("scsi(%ld): GA_NXT issue IOCB failed (%d).\n", | |
134 | ha->host_no, rval)); | |
135 | } else if (ct_rsp->header.response != | |
136 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
137 | DEBUG2_3(printk("scsi(%ld): GA_NXT failed, rejected request, " | |
138 | "ga_nxt_rsp:\n", ha->host_no)); | |
139 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
140 | sizeof(struct ct_rsp_hdr))); | |
141 | rval = QLA_FUNCTION_FAILED; | |
142 | } else { | |
143 | /* Populate fc_port_t entry. */ | |
144 | fcport->d_id.b.domain = ct_rsp->rsp.ga_nxt.port_id[0]; | |
145 | fcport->d_id.b.area = ct_rsp->rsp.ga_nxt.port_id[1]; | |
146 | fcport->d_id.b.al_pa = ct_rsp->rsp.ga_nxt.port_id[2]; | |
147 | ||
148 | memcpy(fcport->node_name, ct_rsp->rsp.ga_nxt.node_name, | |
149 | WWN_SIZE); | |
150 | memcpy(fcport->port_name, ct_rsp->rsp.ga_nxt.port_name, | |
151 | WWN_SIZE); | |
152 | ||
153 | if (ct_rsp->rsp.ga_nxt.port_type != NS_N_PORT_TYPE && | |
154 | ct_rsp->rsp.ga_nxt.port_type != NS_NL_PORT_TYPE) | |
155 | fcport->d_id.b.domain = 0xf0; | |
156 | ||
157 | DEBUG2_3(printk("scsi(%ld): GA_NXT entry - " | |
158 | "nn %02x%02x%02x%02x%02x%02x%02x%02x " | |
159 | "pn %02x%02x%02x%02x%02x%02x%02x%02x " | |
160 | "portid=%02x%02x%02x.\n", | |
161 | ha->host_no, | |
162 | fcport->node_name[0], fcport->node_name[1], | |
163 | fcport->node_name[2], fcport->node_name[3], | |
164 | fcport->node_name[4], fcport->node_name[5], | |
165 | fcport->node_name[6], fcport->node_name[7], | |
166 | fcport->port_name[0], fcport->port_name[1], | |
167 | fcport->port_name[2], fcport->port_name[3], | |
168 | fcport->port_name[4], fcport->port_name[5], | |
169 | fcport->port_name[6], fcport->port_name[7], | |
170 | fcport->d_id.b.domain, fcport->d_id.b.area, | |
171 | fcport->d_id.b.al_pa)); | |
172 | } | |
173 | ||
174 | return (rval); | |
175 | } | |
176 | ||
177 | /** | |
178 | * qla2x00_gid_pt() - SNS scan for fabric devices via GID_PT command. | |
179 | * @ha: HA context | |
180 | * @list: switch info entries to populate | |
181 | * | |
182 | * NOTE: Non-Nx_Ports are not requested. | |
183 | * | |
184 | * Returns 0 on success. | |
185 | */ | |
186 | int | |
187 | qla2x00_gid_pt(scsi_qla_host_t *ha, sw_info_t *list) | |
188 | { | |
189 | int rval; | |
190 | uint16_t i; | |
191 | ||
192 | ms_iocb_entry_t *ms_pkt; | |
193 | struct ct_sns_req *ct_req; | |
194 | struct ct_sns_rsp *ct_rsp; | |
195 | ||
196 | struct ct_sns_gid_pt_data *gid_data; | |
197 | ||
198 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
199 | return (qla2x00_sns_gid_pt(ha, list)); | |
200 | } | |
201 | ||
202 | gid_data = NULL; | |
203 | ||
204 | /* Issue GID_PT */ | |
205 | /* Prepare common MS IOCB */ | |
206 | ms_pkt = qla2x00_prep_ms_iocb(ha, GID_PT_REQ_SIZE, GID_PT_RSP_SIZE); | |
207 | ||
208 | /* Prepare CT request */ | |
209 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GID_PT_CMD, | |
210 | GID_PT_RSP_SIZE); | |
211 | ct_rsp = &ha->ct_sns->p.rsp; | |
212 | ||
213 | /* Prepare CT arguments -- port_type */ | |
214 | ct_req->req.gid_pt.port_type = NS_NX_PORT_TYPE; | |
215 | ||
216 | /* Execute MS IOCB */ | |
217 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
218 | sizeof(ms_iocb_entry_t)); | |
219 | if (rval != QLA_SUCCESS) { | |
220 | /*EMPTY*/ | |
221 | DEBUG2_3(printk("scsi(%ld): GID_PT issue IOCB failed (%d).\n", | |
222 | ha->host_no, rval)); | |
223 | } else if (ct_rsp->header.response != | |
224 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
225 | DEBUG2_3(printk("scsi(%ld): GID_PT failed, rejected request, " | |
226 | "gid_pt_rsp:\n", ha->host_no)); | |
227 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
228 | sizeof(struct ct_rsp_hdr))); | |
229 | rval = QLA_FUNCTION_FAILED; | |
230 | } else { | |
231 | /* Set port IDs in switch info list. */ | |
232 | for (i = 0; i < MAX_FIBRE_DEVICES; i++) { | |
233 | gid_data = &ct_rsp->rsp.gid_pt.entries[i]; | |
234 | list[i].d_id.b.domain = gid_data->port_id[0]; | |
235 | list[i].d_id.b.area = gid_data->port_id[1]; | |
236 | list[i].d_id.b.al_pa = gid_data->port_id[2]; | |
237 | ||
238 | /* Last one exit. */ | |
239 | if (gid_data->control_byte & BIT_7) { | |
240 | list[i].d_id.b.rsvd_1 = gid_data->control_byte; | |
241 | break; | |
242 | } | |
243 | } | |
244 | ||
245 | /* | |
246 | * If we've used all available slots, then the switch is | |
247 | * reporting back more devices than we can handle with this | |
248 | * single call. Return a failed status, and let GA_NXT handle | |
249 | * the overload. | |
250 | */ | |
251 | if (i == MAX_FIBRE_DEVICES) | |
252 | rval = QLA_FUNCTION_FAILED; | |
253 | } | |
254 | ||
255 | return (rval); | |
256 | } | |
257 | ||
258 | /** | |
259 | * qla2x00_gpn_id() - SNS Get Port Name (GPN_ID) query. | |
260 | * @ha: HA context | |
261 | * @list: switch info entries to populate | |
262 | * | |
263 | * Returns 0 on success. | |
264 | */ | |
265 | int | |
266 | qla2x00_gpn_id(scsi_qla_host_t *ha, sw_info_t *list) | |
267 | { | |
268 | int rval; | |
269 | uint16_t i; | |
270 | ||
271 | ms_iocb_entry_t *ms_pkt; | |
272 | struct ct_sns_req *ct_req; | |
273 | struct ct_sns_rsp *ct_rsp; | |
274 | ||
275 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
276 | return (qla2x00_sns_gpn_id(ha, list)); | |
277 | } | |
278 | ||
279 | for (i = 0; i < MAX_FIBRE_DEVICES; i++) { | |
280 | /* Issue GPN_ID */ | |
281 | /* Prepare common MS IOCB */ | |
282 | ms_pkt = qla2x00_prep_ms_iocb(ha, GPN_ID_REQ_SIZE, | |
283 | GPN_ID_RSP_SIZE); | |
284 | ||
285 | /* Prepare CT request */ | |
286 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GPN_ID_CMD, | |
287 | GPN_ID_RSP_SIZE); | |
288 | ct_rsp = &ha->ct_sns->p.rsp; | |
289 | ||
290 | /* Prepare CT arguments -- port_id */ | |
291 | ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain; | |
292 | ct_req->req.port_id.port_id[1] = list[i].d_id.b.area; | |
293 | ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa; | |
294 | ||
295 | /* Execute MS IOCB */ | |
296 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
297 | sizeof(ms_iocb_entry_t)); | |
298 | if (rval != QLA_SUCCESS) { | |
299 | /*EMPTY*/ | |
300 | DEBUG2_3(printk("scsi(%ld): GPN_ID issue IOCB failed " | |
301 | "(%d).\n", ha->host_no, rval)); | |
302 | } else if (ct_rsp->header.response != | |
303 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
304 | DEBUG2_3(printk("scsi(%ld): GPN_ID failed, rejected " | |
305 | "request, gpn_id_rsp:\n", ha->host_no)); | |
306 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
307 | sizeof(struct ct_rsp_hdr))); | |
308 | rval = QLA_FUNCTION_FAILED; | |
309 | } else { | |
310 | /* Save portname */ | |
311 | memcpy(list[i].port_name, | |
312 | ct_rsp->rsp.gpn_id.port_name, WWN_SIZE); | |
313 | } | |
314 | ||
315 | /* Last device exit. */ | |
316 | if (list[i].d_id.b.rsvd_1 != 0) | |
317 | break; | |
318 | } | |
319 | ||
320 | return (rval); | |
321 | } | |
322 | ||
323 | /** | |
324 | * qla2x00_gnn_id() - SNS Get Node Name (GNN_ID) query. | |
325 | * @ha: HA context | |
326 | * @list: switch info entries to populate | |
327 | * | |
328 | * Returns 0 on success. | |
329 | */ | |
330 | int | |
331 | qla2x00_gnn_id(scsi_qla_host_t *ha, sw_info_t *list) | |
332 | { | |
333 | int rval; | |
334 | uint16_t i; | |
335 | ||
336 | ms_iocb_entry_t *ms_pkt; | |
337 | struct ct_sns_req *ct_req; | |
338 | struct ct_sns_rsp *ct_rsp; | |
339 | ||
340 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
341 | return (qla2x00_sns_gnn_id(ha, list)); | |
342 | } | |
343 | ||
344 | for (i = 0; i < MAX_FIBRE_DEVICES; i++) { | |
345 | /* Issue GNN_ID */ | |
346 | /* Prepare common MS IOCB */ | |
347 | ms_pkt = qla2x00_prep_ms_iocb(ha, GNN_ID_REQ_SIZE, | |
348 | GNN_ID_RSP_SIZE); | |
349 | ||
350 | /* Prepare CT request */ | |
351 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GNN_ID_CMD, | |
352 | GNN_ID_RSP_SIZE); | |
353 | ct_rsp = &ha->ct_sns->p.rsp; | |
354 | ||
355 | /* Prepare CT arguments -- port_id */ | |
356 | ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain; | |
357 | ct_req->req.port_id.port_id[1] = list[i].d_id.b.area; | |
358 | ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa; | |
359 | ||
360 | /* Execute MS IOCB */ | |
361 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
362 | sizeof(ms_iocb_entry_t)); | |
363 | if (rval != QLA_SUCCESS) { | |
364 | /*EMPTY*/ | |
365 | DEBUG2_3(printk("scsi(%ld): GNN_ID issue IOCB failed " | |
366 | "(%d).\n", ha->host_no, rval)); | |
367 | } else if (ct_rsp->header.response != | |
368 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
369 | DEBUG2_3(printk("scsi(%ld): GNN_ID failed, rejected " | |
370 | "request, gnn_id_rsp:\n", ha->host_no)); | |
371 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
372 | sizeof(struct ct_rsp_hdr))); | |
373 | rval = QLA_FUNCTION_FAILED; | |
374 | } else { | |
375 | /* Save nodename */ | |
376 | memcpy(list[i].node_name, | |
377 | ct_rsp->rsp.gnn_id.node_name, WWN_SIZE); | |
378 | ||
379 | DEBUG2_3(printk("scsi(%ld): GID_PT entry - " | |
380 | "nn %02x%02x%02x%02x%02x%02x%02x%02x " | |
381 | "pn %02x%02x%02x%02x%02x%02x%02x%02x " | |
382 | "portid=%02x%02x%02x.\n", | |
383 | ha->host_no, | |
384 | list[i].node_name[0], list[i].node_name[1], | |
385 | list[i].node_name[2], list[i].node_name[3], | |
386 | list[i].node_name[4], list[i].node_name[5], | |
387 | list[i].node_name[6], list[i].node_name[7], | |
388 | list[i].port_name[0], list[i].port_name[1], | |
389 | list[i].port_name[2], list[i].port_name[3], | |
390 | list[i].port_name[4], list[i].port_name[5], | |
391 | list[i].port_name[6], list[i].port_name[7], | |
392 | list[i].d_id.b.domain, list[i].d_id.b.area, | |
393 | list[i].d_id.b.al_pa)); | |
394 | } | |
395 | ||
396 | /* Last device exit. */ | |
397 | if (list[i].d_id.b.rsvd_1 != 0) | |
398 | break; | |
399 | } | |
400 | ||
401 | return (rval); | |
402 | } | |
403 | ||
404 | /** | |
405 | * qla2x00_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA. | |
406 | * @ha: HA context | |
407 | * | |
408 | * Returns 0 on success. | |
409 | */ | |
410 | int | |
411 | qla2x00_rft_id(scsi_qla_host_t *ha) | |
412 | { | |
413 | int rval; | |
414 | ||
415 | ms_iocb_entry_t *ms_pkt; | |
416 | struct ct_sns_req *ct_req; | |
417 | struct ct_sns_rsp *ct_rsp; | |
418 | ||
419 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
420 | return (qla2x00_sns_rft_id(ha)); | |
421 | } | |
422 | ||
423 | /* Issue RFT_ID */ | |
424 | /* Prepare common MS IOCB */ | |
425 | ms_pkt = qla2x00_prep_ms_iocb(ha, RFT_ID_REQ_SIZE, RFT_ID_RSP_SIZE); | |
426 | ||
427 | /* Prepare CT request */ | |
428 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RFT_ID_CMD, | |
429 | RFT_ID_RSP_SIZE); | |
430 | ct_rsp = &ha->ct_sns->p.rsp; | |
431 | ||
432 | /* Prepare CT arguments -- port_id, FC-4 types */ | |
433 | ct_req->req.rft_id.port_id[0] = ha->d_id.b.domain; | |
434 | ct_req->req.rft_id.port_id[1] = ha->d_id.b.area; | |
435 | ct_req->req.rft_id.port_id[2] = ha->d_id.b.al_pa; | |
436 | ||
437 | ct_req->req.rft_id.fc4_types[2] = 0x01; /* FCP-3 */ | |
438 | ||
439 | /* Execute MS IOCB */ | |
440 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
441 | sizeof(ms_iocb_entry_t)); | |
442 | if (rval != QLA_SUCCESS) { | |
443 | /*EMPTY*/ | |
444 | DEBUG2_3(printk("scsi(%ld): RFT_ID issue IOCB failed (%d).\n", | |
445 | ha->host_no, rval)); | |
446 | } else if (ct_rsp->header.response != | |
447 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
448 | DEBUG2_3(printk("scsi(%ld): RFT_ID failed, rejected " | |
449 | "request, rft_id_rsp:\n", ha->host_no)); | |
450 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
451 | sizeof(struct ct_rsp_hdr))); | |
452 | rval = QLA_FUNCTION_FAILED; | |
453 | } else { | |
454 | DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n", | |
455 | ha->host_no)); | |
456 | } | |
457 | ||
458 | return (rval); | |
459 | } | |
460 | ||
461 | /** | |
462 | * qla2x00_rff_id() - SNS Register FC-4 Features (RFF_ID) supported by the HBA. | |
463 | * @ha: HA context | |
464 | * | |
465 | * Returns 0 on success. | |
466 | */ | |
467 | int | |
468 | qla2x00_rff_id(scsi_qla_host_t *ha) | |
469 | { | |
470 | int rval; | |
471 | ||
472 | ms_iocb_entry_t *ms_pkt; | |
473 | struct ct_sns_req *ct_req; | |
474 | struct ct_sns_rsp *ct_rsp; | |
475 | ||
476 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
477 | DEBUG2(printk("scsi(%ld): RFF_ID call unsupported on " | |
478 | "ISP2100/ISP2200.\n", ha->host_no)); | |
479 | return (QLA_SUCCESS); | |
480 | } | |
481 | ||
482 | /* Issue RFF_ID */ | |
483 | /* Prepare common MS IOCB */ | |
484 | ms_pkt = qla2x00_prep_ms_iocb(ha, RFF_ID_REQ_SIZE, RFF_ID_RSP_SIZE); | |
485 | ||
486 | /* Prepare CT request */ | |
487 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RFF_ID_CMD, | |
488 | RFF_ID_RSP_SIZE); | |
489 | ct_rsp = &ha->ct_sns->p.rsp; | |
490 | ||
491 | /* Prepare CT arguments -- port_id, FC-4 feature, FC-4 type */ | |
492 | ct_req->req.rff_id.port_id[0] = ha->d_id.b.domain; | |
493 | ct_req->req.rff_id.port_id[1] = ha->d_id.b.area; | |
494 | ct_req->req.rff_id.port_id[2] = ha->d_id.b.al_pa; | |
495 | ||
496 | ct_req->req.rff_id.fc4_type = 0x08; /* SCSI - FCP */ | |
497 | ||
498 | /* Execute MS IOCB */ | |
499 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
500 | sizeof(ms_iocb_entry_t)); | |
501 | if (rval != QLA_SUCCESS) { | |
502 | /*EMPTY*/ | |
503 | DEBUG2_3(printk("scsi(%ld): RFF_ID issue IOCB failed (%d).\n", | |
504 | ha->host_no, rval)); | |
505 | } else if (ct_rsp->header.response != | |
506 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
507 | DEBUG2_3(printk("scsi(%ld): RFF_ID failed, rejected " | |
508 | "request, rff_id_rsp:\n", ha->host_no)); | |
509 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
510 | sizeof(struct ct_rsp_hdr))); | |
511 | rval = QLA_FUNCTION_FAILED; | |
512 | } else { | |
513 | DEBUG2(printk("scsi(%ld): RFF_ID exiting normally.\n", | |
514 | ha->host_no)); | |
515 | } | |
516 | ||
517 | return (rval); | |
518 | } | |
519 | ||
520 | /** | |
521 | * qla2x00_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA. | |
522 | * @ha: HA context | |
523 | * | |
524 | * Returns 0 on success. | |
525 | */ | |
526 | int | |
527 | qla2x00_rnn_id(scsi_qla_host_t *ha) | |
528 | { | |
529 | int rval; | |
530 | ||
531 | ms_iocb_entry_t *ms_pkt; | |
532 | struct ct_sns_req *ct_req; | |
533 | struct ct_sns_rsp *ct_rsp; | |
534 | ||
535 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
536 | return (qla2x00_sns_rnn_id(ha)); | |
537 | } | |
538 | ||
539 | /* Issue RNN_ID */ | |
540 | /* Prepare common MS IOCB */ | |
541 | ms_pkt = qla2x00_prep_ms_iocb(ha, RNN_ID_REQ_SIZE, RNN_ID_RSP_SIZE); | |
542 | ||
543 | /* Prepare CT request */ | |
544 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RNN_ID_CMD, | |
545 | RNN_ID_RSP_SIZE); | |
546 | ct_rsp = &ha->ct_sns->p.rsp; | |
547 | ||
548 | /* Prepare CT arguments -- port_id, node_name */ | |
549 | ct_req->req.rnn_id.port_id[0] = ha->d_id.b.domain; | |
550 | ct_req->req.rnn_id.port_id[1] = ha->d_id.b.area; | |
551 | ct_req->req.rnn_id.port_id[2] = ha->d_id.b.al_pa; | |
552 | ||
553 | memcpy(ct_req->req.rnn_id.node_name, ha->init_cb->node_name, WWN_SIZE); | |
554 | ||
555 | /* Execute MS IOCB */ | |
556 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
557 | sizeof(ms_iocb_entry_t)); | |
558 | if (rval != QLA_SUCCESS) { | |
559 | /*EMPTY*/ | |
560 | DEBUG2_3(printk("scsi(%ld): RNN_ID issue IOCB failed (%d).\n", | |
561 | ha->host_no, rval)); | |
562 | } else if (ct_rsp->header.response != | |
563 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
564 | DEBUG2_3(printk("scsi(%ld): RNN_ID failed, rejected " | |
565 | "request, rnn_id_rsp:\n", ha->host_no)); | |
566 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
567 | sizeof(struct ct_rsp_hdr))); | |
568 | rval = QLA_FUNCTION_FAILED; | |
569 | } else { | |
570 | DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n", | |
571 | ha->host_no)); | |
572 | } | |
573 | ||
574 | return (rval); | |
575 | } | |
576 | ||
577 | /** | |
578 | * qla2x00_rsnn_nn() - SNS Register Symbolic Node Name (RSNN_NN) of the HBA. | |
579 | * @ha: HA context | |
580 | * | |
581 | * Returns 0 on success. | |
582 | */ | |
583 | int | |
584 | qla2x00_rsnn_nn(scsi_qla_host_t *ha) | |
585 | { | |
586 | int rval; | |
587 | uint8_t *snn; | |
588 | uint8_t version[20]; | |
589 | ||
590 | ms_iocb_entry_t *ms_pkt; | |
591 | struct ct_sns_req *ct_req; | |
592 | struct ct_sns_rsp *ct_rsp; | |
593 | ||
594 | if (IS_QLA2100(ha) || IS_QLA2200(ha)) { | |
595 | DEBUG2(printk("scsi(%ld): RSNN_ID call unsupported on " | |
596 | "ISP2100/ISP2200.\n", ha->host_no)); | |
597 | return (QLA_SUCCESS); | |
598 | } | |
599 | ||
600 | /* Issue RSNN_NN */ | |
601 | /* Prepare common MS IOCB */ | |
602 | /* Request size adjusted after CT preparation */ | |
603 | ms_pkt = qla2x00_prep_ms_iocb(ha, 0, RSNN_NN_RSP_SIZE); | |
604 | ||
605 | /* Prepare CT request */ | |
606 | ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RSNN_NN_CMD, | |
607 | RSNN_NN_RSP_SIZE); | |
608 | ct_rsp = &ha->ct_sns->p.rsp; | |
609 | ||
610 | /* Prepare CT arguments -- node_name, symbolic node_name, size */ | |
611 | memcpy(ct_req->req.rsnn_nn.node_name, ha->init_cb->node_name, WWN_SIZE); | |
612 | ||
613 | /* Prepare the Symbolic Node Name */ | |
614 | /* Board type */ | |
615 | snn = ct_req->req.rsnn_nn.sym_node_name; | |
616 | strcpy(snn, ha->model_number); | |
617 | /* Firmware version */ | |
618 | strcat(snn, " FW:v"); | |
619 | sprintf(version, "%d.%02d.%02d", ha->fw_major_version, | |
620 | ha->fw_minor_version, ha->fw_subminor_version); | |
621 | strcat(snn, version); | |
622 | /* Driver version */ | |
623 | strcat(snn, " DVR:v"); | |
624 | strcat(snn, qla2x00_version_str); | |
625 | ||
626 | /* Calculate SNN length */ | |
627 | ct_req->req.rsnn_nn.name_len = (uint8_t)strlen(snn); | |
628 | ||
629 | /* Update MS IOCB request */ | |
630 | ms_pkt->req_bytecount = | |
631 | cpu_to_le32(24 + 1 + ct_req->req.rsnn_nn.name_len); | |
632 | ms_pkt->dseg_req_length = ms_pkt->req_bytecount; | |
633 | ||
634 | /* Execute MS IOCB */ | |
635 | rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma, | |
636 | sizeof(ms_iocb_entry_t)); | |
637 | if (rval != QLA_SUCCESS) { | |
638 | /*EMPTY*/ | |
639 | DEBUG2_3(printk("scsi(%ld): RSNN_NN issue IOCB failed (%d).\n", | |
640 | ha->host_no, rval)); | |
641 | } else if (ct_rsp->header.response != | |
642 | __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) { | |
643 | DEBUG2_3(printk("scsi(%ld): RSNN_NN failed, rejected " | |
644 | "request, rsnn_id_rsp:\n", ha->host_no)); | |
645 | DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header, | |
646 | sizeof(struct ct_rsp_hdr))); | |
647 | rval = QLA_FUNCTION_FAILED; | |
648 | } else { | |
649 | DEBUG2(printk("scsi(%ld): RSNN_NN exiting normally.\n", | |
650 | ha->host_no)); | |
651 | } | |
652 | ||
653 | return (rval); | |
654 | } | |
655 | ||
656 | ||
657 | /** | |
658 | * qla2x00_prep_sns_cmd() - Prepare common SNS command request fields for query. | |
659 | * @ha: HA context | |
660 | * @cmd: GS command | |
661 | * @scmd_len: Subcommand length | |
662 | * @data_size: response size in bytes | |
663 | * | |
664 | * Returns a pointer to the @ha's sns_cmd. | |
665 | */ | |
666 | static inline struct sns_cmd_pkt * | |
667 | qla2x00_prep_sns_cmd(scsi_qla_host_t *ha, uint16_t cmd, uint16_t scmd_len, | |
668 | uint16_t data_size) | |
669 | { | |
670 | uint16_t wc; | |
671 | struct sns_cmd_pkt *sns_cmd; | |
672 | ||
673 | sns_cmd = ha->sns_cmd; | |
674 | memset(sns_cmd, 0, sizeof(struct sns_cmd_pkt)); | |
675 | wc = data_size / 2; /* Size in 16bit words. */ | |
676 | sns_cmd->p.cmd.buffer_length = cpu_to_le16(wc); | |
677 | sns_cmd->p.cmd.buffer_address[0] = cpu_to_le32(LSD(ha->sns_cmd_dma)); | |
678 | sns_cmd->p.cmd.buffer_address[1] = cpu_to_le32(MSD(ha->sns_cmd_dma)); | |
679 | sns_cmd->p.cmd.subcommand_length = cpu_to_le16(scmd_len); | |
680 | sns_cmd->p.cmd.subcommand = cpu_to_le16(cmd); | |
681 | wc = (data_size - 16) / 4; /* Size in 32bit words. */ | |
682 | sns_cmd->p.cmd.size = cpu_to_le16(wc); | |
683 | ||
684 | return (sns_cmd); | |
685 | } | |
686 | ||
687 | /** | |
688 | * qla2x00_sns_ga_nxt() - SNS scan for fabric devices via GA_NXT command. | |
689 | * @ha: HA context | |
690 | * @fcport: fcport entry to updated | |
691 | * | |
692 | * This command uses the old Exectute SNS Command mailbox routine. | |
693 | * | |
694 | * Returns 0 on success. | |
695 | */ | |
696 | static int | |
697 | qla2x00_sns_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport) | |
698 | { | |
699 | int rval; | |
700 | ||
701 | struct sns_cmd_pkt *sns_cmd; | |
702 | ||
703 | /* Issue GA_NXT. */ | |
704 | /* Prepare SNS command request. */ | |
705 | sns_cmd = qla2x00_prep_sns_cmd(ha, GA_NXT_CMD, GA_NXT_SNS_SCMD_LEN, | |
706 | GA_NXT_SNS_DATA_SIZE); | |
707 | ||
708 | /* Prepare SNS command arguments -- port_id. */ | |
709 | sns_cmd->p.cmd.param[0] = fcport->d_id.b.al_pa; | |
710 | sns_cmd->p.cmd.param[1] = fcport->d_id.b.area; | |
711 | sns_cmd->p.cmd.param[2] = fcport->d_id.b.domain; | |
712 | ||
713 | /* Execute SNS command. */ | |
714 | rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, GA_NXT_SNS_CMD_SIZE / 2, | |
715 | sizeof(struct sns_cmd_pkt)); | |
716 | if (rval != QLA_SUCCESS) { | |
717 | /*EMPTY*/ | |
718 | DEBUG2_3(printk("scsi(%ld): GA_NXT Send SNS failed (%d).\n", | |
719 | ha->host_no, rval)); | |
720 | } else if (sns_cmd->p.gan_data[8] != 0x80 || | |
721 | sns_cmd->p.gan_data[9] != 0x02) { | |
722 | DEBUG2_3(printk("scsi(%ld): GA_NXT failed, rejected request, " | |
723 | "ga_nxt_rsp:\n", ha->host_no)); | |
724 | DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gan_data, 16)); | |
725 | rval = QLA_FUNCTION_FAILED; | |
726 | } else { | |
727 | /* Populate fc_port_t entry. */ | |
728 | fcport->d_id.b.domain = sns_cmd->p.gan_data[17]; | |
729 | fcport->d_id.b.area = sns_cmd->p.gan_data[18]; | |
730 | fcport->d_id.b.al_pa = sns_cmd->p.gan_data[19]; | |
731 | ||
732 | memcpy(fcport->node_name, &sns_cmd->p.gan_data[284], WWN_SIZE); | |
733 | memcpy(fcport->port_name, &sns_cmd->p.gan_data[20], WWN_SIZE); | |
734 | ||
735 | if (sns_cmd->p.gan_data[16] != NS_N_PORT_TYPE && | |
736 | sns_cmd->p.gan_data[16] != NS_NL_PORT_TYPE) | |
737 | fcport->d_id.b.domain = 0xf0; | |
738 | ||
739 | DEBUG2_3(printk("scsi(%ld): GA_NXT entry - " | |
740 | "nn %02x%02x%02x%02x%02x%02x%02x%02x " | |
741 | "pn %02x%02x%02x%02x%02x%02x%02x%02x " | |
742 | "portid=%02x%02x%02x.\n", | |
743 | ha->host_no, | |
744 | fcport->node_name[0], fcport->node_name[1], | |
745 | fcport->node_name[2], fcport->node_name[3], | |
746 | fcport->node_name[4], fcport->node_name[5], | |
747 | fcport->node_name[6], fcport->node_name[7], | |
748 | fcport->port_name[0], fcport->port_name[1], | |
749 | fcport->port_name[2], fcport->port_name[3], | |
750 | fcport->port_name[4], fcport->port_name[5], | |
751 | fcport->port_name[6], fcport->port_name[7], | |
752 | fcport->d_id.b.domain, fcport->d_id.b.area, | |
753 | fcport->d_id.b.al_pa)); | |
754 | } | |
755 | ||
756 | return (rval); | |
757 | } | |
758 | ||
759 | /** | |
760 | * qla2x00_sns_gid_pt() - SNS scan for fabric devices via GID_PT command. | |
761 | * @ha: HA context | |
762 | * @list: switch info entries to populate | |
763 | * | |
764 | * This command uses the old Exectute SNS Command mailbox routine. | |
765 | * | |
766 | * NOTE: Non-Nx_Ports are not requested. | |
767 | * | |
768 | * Returns 0 on success. | |
769 | */ | |
770 | static int | |
771 | qla2x00_sns_gid_pt(scsi_qla_host_t *ha, sw_info_t *list) | |
772 | { | |
773 | int rval; | |
774 | ||
775 | uint16_t i; | |
776 | uint8_t *entry; | |
777 | struct sns_cmd_pkt *sns_cmd; | |
778 | ||
779 | /* Issue GID_PT. */ | |
780 | /* Prepare SNS command request. */ | |
781 | sns_cmd = qla2x00_prep_sns_cmd(ha, GID_PT_CMD, GID_PT_SNS_SCMD_LEN, | |
782 | GID_PT_SNS_DATA_SIZE); | |
783 | ||
784 | /* Prepare SNS command arguments -- port_type. */ | |
785 | sns_cmd->p.cmd.param[0] = NS_NX_PORT_TYPE; | |
786 | ||
787 | /* Execute SNS command. */ | |
788 | rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, GID_PT_SNS_CMD_SIZE / 2, | |
789 | sizeof(struct sns_cmd_pkt)); | |
790 | if (rval != QLA_SUCCESS) { | |
791 | /*EMPTY*/ | |
792 | DEBUG2_3(printk("scsi(%ld): GID_PT Send SNS failed (%d).\n", | |
793 | ha->host_no, rval)); | |
794 | } else if (sns_cmd->p.gid_data[8] != 0x80 || | |
795 | sns_cmd->p.gid_data[9] != 0x02) { | |
796 | DEBUG2_3(printk("scsi(%ld): GID_PT failed, rejected request, " | |
797 | "gid_rsp:\n", ha->host_no)); | |
798 | DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gid_data, 16)); | |
799 | rval = QLA_FUNCTION_FAILED; | |
800 | } else { | |
801 | /* Set port IDs in switch info list. */ | |
802 | for (i = 0; i < MAX_FIBRE_DEVICES; i++) { | |
803 | entry = &sns_cmd->p.gid_data[(i * 4) + 16]; | |
804 | list[i].d_id.b.domain = entry[1]; | |
805 | list[i].d_id.b.area = entry[2]; | |
806 | list[i].d_id.b.al_pa = entry[3]; | |
807 | ||
808 | /* Last one exit. */ | |
809 | if (entry[0] & BIT_7) { | |
810 | list[i].d_id.b.rsvd_1 = entry[0]; | |
811 | break; | |
812 | } | |
813 | } | |
814 | ||
815 | /* | |
816 | * If we've used all available slots, then the switch is | |
817 | * reporting back more devices that we can handle with this | |
818 | * single call. Return a failed status, and let GA_NXT handle | |
819 | * the overload. | |
820 | */ | |
821 | if (i == MAX_FIBRE_DEVICES) | |
822 | rval = QLA_FUNCTION_FAILED; | |
823 | } | |
824 | ||
825 | return (rval); | |
826 | } | |
827 | ||
828 | /** | |
829 | * qla2x00_sns_gpn_id() - SNS Get Port Name (GPN_ID) query. | |
830 | * @ha: HA context | |
831 | * @list: switch info entries to populate | |
832 | * | |
833 | * This command uses the old Exectute SNS Command mailbox routine. | |
834 | * | |
835 | * Returns 0 on success. | |
836 | */ | |
837 | static int | |
838 | qla2x00_sns_gpn_id(scsi_qla_host_t *ha, sw_info_t *list) | |
839 | { | |
840 | int rval; | |
841 | ||
842 | uint16_t i; | |
843 | struct sns_cmd_pkt *sns_cmd; | |
844 | ||
845 | for (i = 0; i < MAX_FIBRE_DEVICES; i++) { | |
846 | /* Issue GPN_ID */ | |
847 | /* Prepare SNS command request. */ | |
848 | sns_cmd = qla2x00_prep_sns_cmd(ha, GPN_ID_CMD, | |
849 | GPN_ID_SNS_SCMD_LEN, GPN_ID_SNS_DATA_SIZE); | |
850 | ||
851 | /* Prepare SNS command arguments -- port_id. */ | |
852 | sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa; | |
853 | sns_cmd->p.cmd.param[1] = list[i].d_id.b.area; | |
854 | sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain; | |
855 | ||
856 | /* Execute SNS command. */ | |
857 | rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, | |
858 | GPN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt)); | |
859 | if (rval != QLA_SUCCESS) { | |
860 | /*EMPTY*/ | |
861 | DEBUG2_3(printk("scsi(%ld): GPN_ID Send SNS failed " | |
862 | "(%d).\n", ha->host_no, rval)); | |
863 | } else if (sns_cmd->p.gpn_data[8] != 0x80 || | |
864 | sns_cmd->p.gpn_data[9] != 0x02) { | |
865 | DEBUG2_3(printk("scsi(%ld): GPN_ID failed, rejected " | |
866 | "request, gpn_rsp:\n", ha->host_no)); | |
867 | DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gpn_data, 16)); | |
868 | rval = QLA_FUNCTION_FAILED; | |
869 | } else { | |
870 | /* Save portname */ | |
871 | memcpy(list[i].port_name, &sns_cmd->p.gpn_data[16], | |
872 | WWN_SIZE); | |
873 | } | |
874 | ||
875 | /* Last device exit. */ | |
876 | if (list[i].d_id.b.rsvd_1 != 0) | |
877 | break; | |
878 | } | |
879 | ||
880 | return (rval); | |
881 | } | |
882 | ||
883 | /** | |
884 | * qla2x00_sns_gnn_id() - SNS Get Node Name (GNN_ID) query. | |
885 | * @ha: HA context | |
886 | * @list: switch info entries to populate | |
887 | * | |
888 | * This command uses the old Exectute SNS Command mailbox routine. | |
889 | * | |
890 | * Returns 0 on success. | |
891 | */ | |
892 | static int | |
893 | qla2x00_sns_gnn_id(scsi_qla_host_t *ha, sw_info_t *list) | |
894 | { | |
895 | int rval; | |
896 | ||
897 | uint16_t i; | |
898 | struct sns_cmd_pkt *sns_cmd; | |
899 | ||
900 | for (i = 0; i < MAX_FIBRE_DEVICES; i++) { | |
901 | /* Issue GNN_ID */ | |
902 | /* Prepare SNS command request. */ | |
903 | sns_cmd = qla2x00_prep_sns_cmd(ha, GNN_ID_CMD, | |
904 | GNN_ID_SNS_SCMD_LEN, GNN_ID_SNS_DATA_SIZE); | |
905 | ||
906 | /* Prepare SNS command arguments -- port_id. */ | |
907 | sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa; | |
908 | sns_cmd->p.cmd.param[1] = list[i].d_id.b.area; | |
909 | sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain; | |
910 | ||
911 | /* Execute SNS command. */ | |
912 | rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, | |
913 | GNN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt)); | |
914 | if (rval != QLA_SUCCESS) { | |
915 | /*EMPTY*/ | |
916 | DEBUG2_3(printk("scsi(%ld): GNN_ID Send SNS failed " | |
917 | "(%d).\n", ha->host_no, rval)); | |
918 | } else if (sns_cmd->p.gnn_data[8] != 0x80 || | |
919 | sns_cmd->p.gnn_data[9] != 0x02) { | |
920 | DEBUG2_3(printk("scsi(%ld): GNN_ID failed, rejected " | |
921 | "request, gnn_rsp:\n", ha->host_no)); | |
922 | DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gnn_data, 16)); | |
923 | rval = QLA_FUNCTION_FAILED; | |
924 | } else { | |
925 | /* Save nodename */ | |
926 | memcpy(list[i].node_name, &sns_cmd->p.gnn_data[16], | |
927 | WWN_SIZE); | |
928 | ||
929 | DEBUG2_3(printk("scsi(%ld): GID_PT entry - " | |
930 | "nn %02x%02x%02x%02x%02x%02x%02x%02x " | |
931 | "pn %02x%02x%02x%02x%02x%02x%02x%02x " | |
932 | "portid=%02x%02x%02x.\n", | |
933 | ha->host_no, | |
934 | list[i].node_name[0], list[i].node_name[1], | |
935 | list[i].node_name[2], list[i].node_name[3], | |
936 | list[i].node_name[4], list[i].node_name[5], | |
937 | list[i].node_name[6], list[i].node_name[7], | |
938 | list[i].port_name[0], list[i].port_name[1], | |
939 | list[i].port_name[2], list[i].port_name[3], | |
940 | list[i].port_name[4], list[i].port_name[5], | |
941 | list[i].port_name[6], list[i].port_name[7], | |
942 | list[i].d_id.b.domain, list[i].d_id.b.area, | |
943 | list[i].d_id.b.al_pa)); | |
944 | } | |
945 | ||
946 | /* Last device exit. */ | |
947 | if (list[i].d_id.b.rsvd_1 != 0) | |
948 | break; | |
949 | } | |
950 | ||
951 | return (rval); | |
952 | } | |
953 | ||
954 | /** | |
955 | * qla2x00_snd_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA. | |
956 | * @ha: HA context | |
957 | * | |
958 | * This command uses the old Exectute SNS Command mailbox routine. | |
959 | * | |
960 | * Returns 0 on success. | |
961 | */ | |
962 | static int | |
963 | qla2x00_sns_rft_id(scsi_qla_host_t *ha) | |
964 | { | |
965 | int rval; | |
966 | ||
967 | struct sns_cmd_pkt *sns_cmd; | |
968 | ||
969 | /* Issue RFT_ID. */ | |
970 | /* Prepare SNS command request. */ | |
971 | sns_cmd = qla2x00_prep_sns_cmd(ha, RFT_ID_CMD, RFT_ID_SNS_SCMD_LEN, | |
972 | RFT_ID_SNS_DATA_SIZE); | |
973 | ||
974 | /* Prepare SNS command arguments -- port_id, FC-4 types */ | |
975 | sns_cmd->p.cmd.param[0] = ha->d_id.b.al_pa; | |
976 | sns_cmd->p.cmd.param[1] = ha->d_id.b.area; | |
977 | sns_cmd->p.cmd.param[2] = ha->d_id.b.domain; | |
978 | ||
979 | sns_cmd->p.cmd.param[5] = 0x01; /* FCP-3 */ | |
980 | ||
981 | /* Execute SNS command. */ | |
982 | rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, RFT_ID_SNS_CMD_SIZE / 2, | |
983 | sizeof(struct sns_cmd_pkt)); | |
984 | if (rval != QLA_SUCCESS) { | |
985 | /*EMPTY*/ | |
986 | DEBUG2_3(printk("scsi(%ld): RFT_ID Send SNS failed (%d).\n", | |
987 | ha->host_no, rval)); | |
988 | } else if (sns_cmd->p.rft_data[8] != 0x80 || | |
989 | sns_cmd->p.rft_data[9] != 0x02) { | |
990 | DEBUG2_3(printk("scsi(%ld): RFT_ID failed, rejected request, " | |
991 | "rft_rsp:\n", ha->host_no)); | |
992 | DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rft_data, 16)); | |
993 | rval = QLA_FUNCTION_FAILED; | |
994 | } else { | |
995 | DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n", | |
996 | ha->host_no)); | |
997 | } | |
998 | ||
999 | return (rval); | |
1000 | } | |
1001 | ||
1002 | /** | |
1003 | * qla2x00_sns_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA. | |
1004 | * HBA. | |
1005 | * @ha: HA context | |
1006 | * | |
1007 | * This command uses the old Exectute SNS Command mailbox routine. | |
1008 | * | |
1009 | * Returns 0 on success. | |
1010 | */ | |
1011 | static int | |
1012 | qla2x00_sns_rnn_id(scsi_qla_host_t *ha) | |
1013 | { | |
1014 | int rval; | |
1015 | ||
1016 | struct sns_cmd_pkt *sns_cmd; | |
1017 | ||
1018 | /* Issue RNN_ID. */ | |
1019 | /* Prepare SNS command request. */ | |
1020 | sns_cmd = qla2x00_prep_sns_cmd(ha, RNN_ID_CMD, RNN_ID_SNS_SCMD_LEN, | |
1021 | RNN_ID_SNS_DATA_SIZE); | |
1022 | ||
1023 | /* Prepare SNS command arguments -- port_id, nodename. */ | |
1024 | sns_cmd->p.cmd.param[0] = ha->d_id.b.al_pa; | |
1025 | sns_cmd->p.cmd.param[1] = ha->d_id.b.area; | |
1026 | sns_cmd->p.cmd.param[2] = ha->d_id.b.domain; | |
1027 | ||
1028 | sns_cmd->p.cmd.param[4] = ha->init_cb->node_name[7]; | |
1029 | sns_cmd->p.cmd.param[5] = ha->init_cb->node_name[6]; | |
1030 | sns_cmd->p.cmd.param[6] = ha->init_cb->node_name[5]; | |
1031 | sns_cmd->p.cmd.param[7] = ha->init_cb->node_name[4]; | |
1032 | sns_cmd->p.cmd.param[8] = ha->init_cb->node_name[3]; | |
1033 | sns_cmd->p.cmd.param[9] = ha->init_cb->node_name[2]; | |
1034 | sns_cmd->p.cmd.param[10] = ha->init_cb->node_name[1]; | |
1035 | sns_cmd->p.cmd.param[11] = ha->init_cb->node_name[0]; | |
1036 | ||
1037 | /* Execute SNS command. */ | |
1038 | rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, RNN_ID_SNS_CMD_SIZE / 2, | |
1039 | sizeof(struct sns_cmd_pkt)); | |
1040 | if (rval != QLA_SUCCESS) { | |
1041 | /*EMPTY*/ | |
1042 | DEBUG2_3(printk("scsi(%ld): RNN_ID Send SNS failed (%d).\n", | |
1043 | ha->host_no, rval)); | |
1044 | } else if (sns_cmd->p.rnn_data[8] != 0x80 || | |
1045 | sns_cmd->p.rnn_data[9] != 0x02) { | |
1046 | DEBUG2_3(printk("scsi(%ld): RNN_ID failed, rejected request, " | |
1047 | "rnn_rsp:\n", ha->host_no)); | |
1048 | DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rnn_data, 16)); | |
1049 | rval = QLA_FUNCTION_FAILED; | |
1050 | } else { | |
1051 | DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n", | |
1052 | ha->host_no)); | |
1053 | } | |
1054 | ||
1055 | return (rval); | |
1056 | } |