xref: /linux/drivers/scsi/esas2r/esas2r_vda.c (revision 827634added7f38b7d724cab1dccdb2b004c13c3) 
1 /*
2  *  linux/drivers/scsi/esas2r/esas2r_vda.c
3  *      esas2r driver VDA firmware interface functions
4  *
5  *  Copyright (c) 2001-2013 ATTO Technology, Inc.
6  *  (mailto:linuxdrivers@attotech.com)
7  */
8 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9 /*
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; version 2 of the License.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  NO WARRANTY
20  *  THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21  *  CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22  *  LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23  *  MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24  *  solely responsible for determining the appropriateness of using and
25  *  distributing the Program and assumes all risks associated with its
26  *  exercise of rights under this Agreement, including but not limited to
27  *  the risks and costs of program errors, damage to or loss of data,
28  *  programs or equipment, and unavailability or interruption of operations.
29  *
30  *  DISCLAIMER OF LIABILITY
31  *  NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32  *  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33  *  DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36  *  USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37  *  HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38  *
39  *  You should have received a copy of the GNU General Public License
40  *  along with this program; if not, write to the Free Software
41  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
42  */
43 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
44 
45 #include "esas2r.h"
46 
47 static u8 esas2r_vdaioctl_versions[] = {
48 	ATTO_VDA_VER_UNSUPPORTED,
49 	ATTO_VDA_FLASH_VER,
50 	ATTO_VDA_VER_UNSUPPORTED,
51 	ATTO_VDA_VER_UNSUPPORTED,
52 	ATTO_VDA_CLI_VER,
53 	ATTO_VDA_VER_UNSUPPORTED,
54 	ATTO_VDA_CFG_VER,
55 	ATTO_VDA_MGT_VER,
56 	ATTO_VDA_GSV_VER
57 };
58 
59 static void clear_vda_request(struct esas2r_request *rq);
60 
61 static void esas2r_complete_vda_ioctl(struct esas2r_adapter *a,
62 				      struct esas2r_request *rq);
63 
64 /* Prepare a VDA IOCTL request to be sent to the firmware. */
65 bool esas2r_process_vda_ioctl(struct esas2r_adapter *a,
66 			      struct atto_ioctl_vda *vi,
67 			      struct esas2r_request *rq,
68 			      struct esas2r_sg_context *sgc)
69 {
70 	u32 datalen = 0;
71 	struct atto_vda_sge *firstsg = NULL;
72 	u8 vercnt = (u8)ARRAY_SIZE(esas2r_vdaioctl_versions);
73 
74 	vi->status = ATTO_STS_SUCCESS;
75 	vi->vda_status = RS_PENDING;
76 
77 	if (vi->function >= vercnt) {
78 		vi->status = ATTO_STS_INV_FUNC;
79 		return false;
80 	}
81 
82 	if (vi->version > esas2r_vdaioctl_versions[vi->function]) {
83 		vi->status = ATTO_STS_INV_VERSION;
84 		return false;
85 	}
86 
87 	if (test_bit(AF_DEGRADED_MODE, &a->flags)) {
88 		vi->status = ATTO_STS_DEGRADED;
89 		return false;
90 	}
91 
92 	if (vi->function != VDA_FUNC_SCSI)
93 		clear_vda_request(rq);
94 
95 	rq->vrq->scsi.function = vi->function;
96 	rq->interrupt_cb = esas2r_complete_vda_ioctl;
97 	rq->interrupt_cx = vi;
98 
99 	switch (vi->function) {
100 	case VDA_FUNC_FLASH:
101 
102 		if (vi->cmd.flash.sub_func != VDA_FLASH_FREAD
103 		    && vi->cmd.flash.sub_func != VDA_FLASH_FWRITE
104 		    && vi->cmd.flash.sub_func != VDA_FLASH_FINFO) {
105 			vi->status = ATTO_STS_INV_FUNC;
106 			return false;
107 		}
108 
109 		if (vi->cmd.flash.sub_func != VDA_FLASH_FINFO)
110 			datalen = vi->data_length;
111 
112 		rq->vrq->flash.length = cpu_to_le32(datalen);
113 		rq->vrq->flash.sub_func = vi->cmd.flash.sub_func;
114 
115 		memcpy(rq->vrq->flash.data.file.file_name,
116 		       vi->cmd.flash.data.file.file_name,
117 		       sizeof(vi->cmd.flash.data.file.file_name));
118 
119 		firstsg = rq->vrq->flash.data.file.sge;
120 		break;
121 
122 	case VDA_FUNC_CLI:
123 
124 		datalen = vi->data_length;
125 
126 		rq->vrq->cli.cmd_rsp_len =
127 			cpu_to_le32(vi->cmd.cli.cmd_rsp_len);
128 		rq->vrq->cli.length = cpu_to_le32(datalen);
129 
130 		firstsg = rq->vrq->cli.sge;
131 		break;
132 
133 	case VDA_FUNC_MGT:
134 	{
135 		u8 *cmdcurr_offset = sgc->cur_offset
136 				     - offsetof(struct atto_ioctl_vda, data)
137 				     + offsetof(struct atto_ioctl_vda, cmd)
138 				     + offsetof(struct atto_ioctl_vda_mgt_cmd,
139 						data);
140 		/*
141 		 * build the data payload SGL here first since
142 		 * esas2r_sgc_init() will modify the S/G list offset for the
143 		 * management SGL (which is built below where the data SGL is
144 		 * usually built).
145 		 */
146 
147 		if (vi->data_length) {
148 			u32 payldlen = 0;
149 
150 			if (vi->cmd.mgt.mgt_func == VDAMGT_DEV_HEALTH_REQ
151 			    || vi->cmd.mgt.mgt_func == VDAMGT_DEV_METRICS) {
152 				rq->vrq->mgt.payld_sglst_offset =
153 					(u8)offsetof(struct atto_vda_mgmt_req,
154 						     payld_sge);
155 
156 				payldlen = vi->data_length;
157 				datalen = vi->cmd.mgt.data_length;
158 			} else if (vi->cmd.mgt.mgt_func == VDAMGT_DEV_INFO2
159 				   || vi->cmd.mgt.mgt_func ==
160 				   VDAMGT_DEV_INFO2_BYADDR) {
161 				datalen = vi->data_length;
162 				cmdcurr_offset = sgc->cur_offset;
163 			} else {
164 				vi->status = ATTO_STS_INV_PARAM;
165 				return false;
166 			}
167 
168 			/* Setup the length so building the payload SGL works */
169 			rq->vrq->mgt.length = cpu_to_le32(datalen);
170 
171 			if (payldlen) {
172 				rq->vrq->mgt.payld_length =
173 					cpu_to_le32(payldlen);
174 
175 				esas2r_sgc_init(sgc, a, rq,
176 						rq->vrq->mgt.payld_sge);
177 				sgc->length = payldlen;
178 
179 				if (!esas2r_build_sg_list(a, rq, sgc)) {
180 					vi->status = ATTO_STS_OUT_OF_RSRC;
181 					return false;
182 				}
183 			}
184 		} else {
185 			datalen = vi->cmd.mgt.data_length;
186 
187 			rq->vrq->mgt.length = cpu_to_le32(datalen);
188 		}
189 
190 		/*
191 		 * Now that the payload SGL is built, if any, setup to build
192 		 * the management SGL.
193 		 */
194 		firstsg = rq->vrq->mgt.sge;
195 		sgc->cur_offset = cmdcurr_offset;
196 
197 		/* Finish initializing the management request. */
198 		rq->vrq->mgt.mgt_func = vi->cmd.mgt.mgt_func;
199 		rq->vrq->mgt.scan_generation = vi->cmd.mgt.scan_generation;
200 		rq->vrq->mgt.dev_index =
201 			cpu_to_le32(vi->cmd.mgt.dev_index);
202 
203 		esas2r_nuxi_mgt_data(rq->vrq->mgt.mgt_func, &vi->cmd.mgt.data);
204 		break;
205 	}
206 
207 	case VDA_FUNC_CFG:
208 
209 		if (vi->data_length
210 		    || vi->cmd.cfg.data_length == 0) {
211 			vi->status = ATTO_STS_INV_PARAM;
212 			return false;
213 		}
214 
215 		if (vi->cmd.cfg.cfg_func == VDA_CFG_INIT) {
216 			vi->status = ATTO_STS_INV_FUNC;
217 			return false;
218 		}
219 
220 		rq->vrq->cfg.sub_func = vi->cmd.cfg.cfg_func;
221 		rq->vrq->cfg.length = cpu_to_le32(vi->cmd.cfg.data_length);
222 
223 		if (vi->cmd.cfg.cfg_func == VDA_CFG_GET_INIT) {
224 			memcpy(&rq->vrq->cfg.data,
225 			       &vi->cmd.cfg.data,
226 			       vi->cmd.cfg.data_length);
227 
228 			esas2r_nuxi_cfg_data(rq->vrq->cfg.sub_func,
229 					     &rq->vrq->cfg.data);
230 		} else {
231 			vi->status = ATTO_STS_INV_FUNC;
232 
233 			return false;
234 		}
235 
236 		break;
237 
238 	case VDA_FUNC_GSV:
239 
240 		vi->cmd.gsv.rsp_len = vercnt;
241 
242 		memcpy(vi->cmd.gsv.version_info, esas2r_vdaioctl_versions,
243 		       vercnt);
244 
245 		vi->vda_status = RS_SUCCESS;
246 		break;
247 
248 	default:
249 
250 		vi->status = ATTO_STS_INV_FUNC;
251 		return false;
252 	}
253 
254 	if (datalen) {
255 		esas2r_sgc_init(sgc, a, rq, firstsg);
256 		sgc->length = datalen;
257 
258 		if (!esas2r_build_sg_list(a, rq, sgc)) {
259 			vi->status = ATTO_STS_OUT_OF_RSRC;
260 			return false;
261 		}
262 	}
263 
264 	esas2r_start_request(a, rq);
265 
266 	return true;
267 }
268 
269 static void esas2r_complete_vda_ioctl(struct esas2r_adapter *a,
270 				      struct esas2r_request *rq)
271 {
272 	struct atto_ioctl_vda *vi = (struct atto_ioctl_vda *)rq->interrupt_cx;
273 
274 	vi->vda_status = rq->req_stat;
275 
276 	switch (vi->function) {
277 	case VDA_FUNC_FLASH:
278 
279 		if (vi->cmd.flash.sub_func == VDA_FLASH_FINFO
280 		    || vi->cmd.flash.sub_func == VDA_FLASH_FREAD)
281 			vi->cmd.flash.data.file.file_size =
282 				le32_to_cpu(rq->func_rsp.flash_rsp.file_size);
283 
284 		break;
285 
286 	case VDA_FUNC_MGT:
287 
288 		vi->cmd.mgt.scan_generation =
289 			rq->func_rsp.mgt_rsp.scan_generation;
290 		vi->cmd.mgt.dev_index = le16_to_cpu(
291 			rq->func_rsp.mgt_rsp.dev_index);
292 
293 		if (vi->data_length == 0)
294 			vi->cmd.mgt.data_length =
295 				le32_to_cpu(rq->func_rsp.mgt_rsp.length);
296 
297 		esas2r_nuxi_mgt_data(rq->vrq->mgt.mgt_func, &vi->cmd.mgt.data);
298 		break;
299 
300 	case VDA_FUNC_CFG:
301 
302 		if (vi->cmd.cfg.cfg_func == VDA_CFG_GET_INIT) {
303 			struct atto_ioctl_vda_cfg_cmd *cfg = &vi->cmd.cfg;
304 			struct atto_vda_cfg_rsp *rsp = &rq->func_rsp.cfg_rsp;
305 			char buf[sizeof(cfg->data.init.fw_release) + 1];
306 
307 			cfg->data_length =
308 				cpu_to_le32(sizeof(struct atto_vda_cfg_init));
309 			cfg->data.init.vda_version =
310 				le32_to_cpu(rsp->vda_version);
311 			cfg->data.init.fw_build = rsp->fw_build;
312 
313 			snprintf(buf, sizeof(buf), "%1.1u.%2.2u",
314 				 (int)LOBYTE(le16_to_cpu(rsp->fw_release)),
315 				 (int)HIBYTE(le16_to_cpu(rsp->fw_release)));
316 
317 			memcpy(&cfg->data.init.fw_release, buf,
318 			       sizeof(cfg->data.init.fw_release));
319 
320 			if (LOWORD(LOBYTE(cfg->data.init.fw_build)) == 'A')
321 				cfg->data.init.fw_version =
322 					cfg->data.init.fw_build;
323 			else
324 				cfg->data.init.fw_version =
325 					cfg->data.init.fw_release;
326 		} else {
327 			esas2r_nuxi_cfg_data(rq->vrq->cfg.sub_func,
328 					     &vi->cmd.cfg.data);
329 		}
330 
331 		break;
332 
333 	case VDA_FUNC_CLI:
334 
335 		vi->cmd.cli.cmd_rsp_len =
336 			le32_to_cpu(rq->func_rsp.cli_rsp.cmd_rsp_len);
337 		break;
338 
339 	default:
340 
341 		break;
342 	}
343 }
344 
345 /* Build a flash VDA request. */
346 void esas2r_build_flash_req(struct esas2r_adapter *a,
347 			    struct esas2r_request *rq,
348 			    u8 sub_func,
349 			    u8 cksum,
350 			    u32 addr,
351 			    u32 length)
352 {
353 	struct atto_vda_flash_req *vrq = &rq->vrq->flash;
354 
355 	clear_vda_request(rq);
356 
357 	rq->vrq->scsi.function = VDA_FUNC_FLASH;
358 
359 	if (sub_func == VDA_FLASH_BEGINW
360 	    || sub_func == VDA_FLASH_WRITE
361 	    || sub_func == VDA_FLASH_READ)
362 		vrq->sg_list_offset = (u8)offsetof(struct atto_vda_flash_req,
363 						   data.sge);
364 
365 	vrq->length = cpu_to_le32(length);
366 	vrq->flash_addr = cpu_to_le32(addr);
367 	vrq->checksum = cksum;
368 	vrq->sub_func = sub_func;
369 }
370 
371 /* Build a VDA management request. */
372 void esas2r_build_mgt_req(struct esas2r_adapter *a,
373 			  struct esas2r_request *rq,
374 			  u8 sub_func,
375 			  u8 scan_gen,
376 			  u16 dev_index,
377 			  u32 length,
378 			  void *data)
379 {
380 	struct atto_vda_mgmt_req *vrq = &rq->vrq->mgt;
381 
382 	clear_vda_request(rq);
383 
384 	rq->vrq->scsi.function = VDA_FUNC_MGT;
385 
386 	vrq->mgt_func = sub_func;
387 	vrq->scan_generation = scan_gen;
388 	vrq->dev_index = cpu_to_le16(dev_index);
389 	vrq->length = cpu_to_le32(length);
390 
391 	if (vrq->length) {
392 		if (test_bit(AF_LEGACY_SGE_MODE, &a->flags)) {
393 			vrq->sg_list_offset = (u8)offsetof(
394 				struct atto_vda_mgmt_req, sge);
395 
396 			vrq->sge[0].length = cpu_to_le32(SGE_LAST | length);
397 			vrq->sge[0].address = cpu_to_le64(
398 				rq->vrq_md->phys_addr +
399 				sizeof(union atto_vda_req));
400 		} else {
401 			vrq->sg_list_offset = (u8)offsetof(
402 				struct atto_vda_mgmt_req, prde);
403 
404 			vrq->prde[0].ctl_len = cpu_to_le32(length);
405 			vrq->prde[0].address = cpu_to_le64(
406 				rq->vrq_md->phys_addr +
407 				sizeof(union atto_vda_req));
408 		}
409 	}
410 
411 	if (data) {
412 		esas2r_nuxi_mgt_data(sub_func, data);
413 
414 		memcpy(&rq->vda_rsp_data->mgt_data.data.bytes[0], data,
415 		       length);
416 	}
417 }
418 
419 /* Build a VDA asyncronous event (AE) request. */
420 void esas2r_build_ae_req(struct esas2r_adapter *a, struct esas2r_request *rq)
421 {
422 	struct atto_vda_ae_req *vrq = &rq->vrq->ae;
423 
424 	clear_vda_request(rq);
425 
426 	rq->vrq->scsi.function = VDA_FUNC_AE;
427 
428 	vrq->length = cpu_to_le32(sizeof(struct atto_vda_ae_data));
429 
430 	if (test_bit(AF_LEGACY_SGE_MODE, &a->flags)) {
431 		vrq->sg_list_offset =
432 			(u8)offsetof(struct atto_vda_ae_req, sge);
433 		vrq->sge[0].length = cpu_to_le32(SGE_LAST | vrq->length);
434 		vrq->sge[0].address = cpu_to_le64(
435 			rq->vrq_md->phys_addr +
436 			sizeof(union atto_vda_req));
437 	} else {
438 		vrq->sg_list_offset = (u8)offsetof(struct atto_vda_ae_req,
439 						   prde);
440 		vrq->prde[0].ctl_len = cpu_to_le32(vrq->length);
441 		vrq->prde[0].address = cpu_to_le64(
442 			rq->vrq_md->phys_addr +
443 			sizeof(union atto_vda_req));
444 	}
445 }
446 
447 /* Build a VDA CLI request. */
448 void esas2r_build_cli_req(struct esas2r_adapter *a,
449 			  struct esas2r_request *rq,
450 			  u32 length,
451 			  u32 cmd_rsp_len)
452 {
453 	struct atto_vda_cli_req *vrq = &rq->vrq->cli;
454 
455 	clear_vda_request(rq);
456 
457 	rq->vrq->scsi.function = VDA_FUNC_CLI;
458 
459 	vrq->length = cpu_to_le32(length);
460 	vrq->cmd_rsp_len = cpu_to_le32(cmd_rsp_len);
461 	vrq->sg_list_offset = (u8)offsetof(struct atto_vda_cli_req, sge);
462 }
463 
464 /* Build a VDA IOCTL request. */
465 void esas2r_build_ioctl_req(struct esas2r_adapter *a,
466 			    struct esas2r_request *rq,
467 			    u32 length,
468 			    u8 sub_func)
469 {
470 	struct atto_vda_ioctl_req *vrq = &rq->vrq->ioctl;
471 
472 	clear_vda_request(rq);
473 
474 	rq->vrq->scsi.function = VDA_FUNC_IOCTL;
475 
476 	vrq->length = cpu_to_le32(length);
477 	vrq->sub_func = sub_func;
478 	vrq->sg_list_offset = (u8)offsetof(struct atto_vda_ioctl_req, sge);
479 }
480 
481 /* Build a VDA configuration request. */
482 void esas2r_build_cfg_req(struct esas2r_adapter *a,
483 			  struct esas2r_request *rq,
484 			  u8 sub_func,
485 			  u32 length,
486 			  void *data)
487 {
488 	struct atto_vda_cfg_req *vrq = &rq->vrq->cfg;
489 
490 	clear_vda_request(rq);
491 
492 	rq->vrq->scsi.function = VDA_FUNC_CFG;
493 
494 	vrq->sub_func = sub_func;
495 	vrq->length = cpu_to_le32(length);
496 
497 	if (data) {
498 		esas2r_nuxi_cfg_data(sub_func, data);
499 
500 		memcpy(&vrq->data, data, length);
501 	}
502 }
503 
504 static void clear_vda_request(struct esas2r_request *rq)
505 {
506 	u32 handle = rq->vrq->scsi.handle;
507 
508 	memset(rq->vrq, 0, sizeof(*rq->vrq));
509 
510 	rq->vrq->scsi.handle = handle;
511 
512 	rq->req_stat = RS_PENDING;
513 
514 	/* since the data buffer is separate clear that too */
515 
516 	memset(rq->data_buf, 0, ESAS2R_DATA_BUF_LEN);
517 
518 	/*
519 	 * Setup next and prev pointer in case the request is not going through
520 	 * esas2r_start_request().
521 	 */
522 
523 	INIT_LIST_HEAD(&rq->req_list);
524 }
525