xref: /openbmc/linux/drivers/scsi/esas2r/esas2r_vda.c (revision b34081f1) 
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 (a->flags & AF_DEGRADED_MODE) {
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 
306 			cfg->data_length =
307 				cpu_to_le32(sizeof(struct atto_vda_cfg_init));
308 			cfg->data.init.vda_version =
309 				le32_to_cpu(rsp->vda_version);
310 			cfg->data.init.fw_build = rsp->fw_build;
311 
312 			sprintf((char *)&cfg->data.init.fw_release,
313 				"%1d.%02d",
314 				(int)LOBYTE(le16_to_cpu(rsp->fw_release)),
315 				(int)HIBYTE(le16_to_cpu(rsp->fw_release)));
316 
317 			if (LOWORD(LOBYTE(cfg->data.init.fw_build)) == 'A')
318 				cfg->data.init.fw_version =
319 					cfg->data.init.fw_build;
320 			else
321 				cfg->data.init.fw_version =
322 					cfg->data.init.fw_release;
323 		} else {
324 			esas2r_nuxi_cfg_data(rq->vrq->cfg.sub_func,
325 					     &vi->cmd.cfg.data);
326 		}
327 
328 		break;
329 
330 	case VDA_FUNC_CLI:
331 
332 		vi->cmd.cli.cmd_rsp_len =
333 			le32_to_cpu(rq->func_rsp.cli_rsp.cmd_rsp_len);
334 		break;
335 
336 	default:
337 
338 		break;
339 	}
340 }
341 
342 /* Build a flash VDA request. */
343 void esas2r_build_flash_req(struct esas2r_adapter *a,
344 			    struct esas2r_request *rq,
345 			    u8 sub_func,
346 			    u8 cksum,
347 			    u32 addr,
348 			    u32 length)
349 {
350 	struct atto_vda_flash_req *vrq = &rq->vrq->flash;
351 
352 	clear_vda_request(rq);
353 
354 	rq->vrq->scsi.function = VDA_FUNC_FLASH;
355 
356 	if (sub_func == VDA_FLASH_BEGINW
357 	    || sub_func == VDA_FLASH_WRITE
358 	    || sub_func == VDA_FLASH_READ)
359 		vrq->sg_list_offset = (u8)offsetof(struct atto_vda_flash_req,
360 						   data.sge);
361 
362 	vrq->length = cpu_to_le32(length);
363 	vrq->flash_addr = cpu_to_le32(addr);
364 	vrq->checksum = cksum;
365 	vrq->sub_func = sub_func;
366 }
367 
368 /* Build a VDA management request. */
369 void esas2r_build_mgt_req(struct esas2r_adapter *a,
370 			  struct esas2r_request *rq,
371 			  u8 sub_func,
372 			  u8 scan_gen,
373 			  u16 dev_index,
374 			  u32 length,
375 			  void *data)
376 {
377 	struct atto_vda_mgmt_req *vrq = &rq->vrq->mgt;
378 
379 	clear_vda_request(rq);
380 
381 	rq->vrq->scsi.function = VDA_FUNC_MGT;
382 
383 	vrq->mgt_func = sub_func;
384 	vrq->scan_generation = scan_gen;
385 	vrq->dev_index = cpu_to_le16(dev_index);
386 	vrq->length = cpu_to_le32(length);
387 
388 	if (vrq->length) {
389 		if (a->flags & AF_LEGACY_SGE_MODE) {
390 			vrq->sg_list_offset = (u8)offsetof(
391 				struct atto_vda_mgmt_req, sge);
392 
393 			vrq->sge[0].length = cpu_to_le32(SGE_LAST | length);
394 			vrq->sge[0].address = cpu_to_le64(
395 				rq->vrq_md->phys_addr +
396 				sizeof(union atto_vda_req));
397 		} else {
398 			vrq->sg_list_offset = (u8)offsetof(
399 				struct atto_vda_mgmt_req, prde);
400 
401 			vrq->prde[0].ctl_len = cpu_to_le32(length);
402 			vrq->prde[0].address = cpu_to_le64(
403 				rq->vrq_md->phys_addr +
404 				sizeof(union atto_vda_req));
405 		}
406 	}
407 
408 	if (data) {
409 		esas2r_nuxi_mgt_data(sub_func, data);
410 
411 		memcpy(&rq->vda_rsp_data->mgt_data.data.bytes[0], data,
412 		       length);
413 	}
414 }
415 
416 /* Build a VDA asyncronous event (AE) request. */
417 void esas2r_build_ae_req(struct esas2r_adapter *a, struct esas2r_request *rq)
418 {
419 	struct atto_vda_ae_req *vrq = &rq->vrq->ae;
420 
421 	clear_vda_request(rq);
422 
423 	rq->vrq->scsi.function = VDA_FUNC_AE;
424 
425 	vrq->length = cpu_to_le32(sizeof(struct atto_vda_ae_data));
426 
427 	if (a->flags & AF_LEGACY_SGE_MODE) {
428 		vrq->sg_list_offset =
429 			(u8)offsetof(struct atto_vda_ae_req, sge);
430 		vrq->sge[0].length = cpu_to_le32(SGE_LAST | vrq->length);
431 		vrq->sge[0].address = cpu_to_le64(
432 			rq->vrq_md->phys_addr +
433 			sizeof(union atto_vda_req));
434 	} else {
435 		vrq->sg_list_offset = (u8)offsetof(struct atto_vda_ae_req,
436 						   prde);
437 		vrq->prde[0].ctl_len = cpu_to_le32(vrq->length);
438 		vrq->prde[0].address = cpu_to_le64(
439 			rq->vrq_md->phys_addr +
440 			sizeof(union atto_vda_req));
441 	}
442 }
443 
444 /* Build a VDA CLI request. */
445 void esas2r_build_cli_req(struct esas2r_adapter *a,
446 			  struct esas2r_request *rq,
447 			  u32 length,
448 			  u32 cmd_rsp_len)
449 {
450 	struct atto_vda_cli_req *vrq = &rq->vrq->cli;
451 
452 	clear_vda_request(rq);
453 
454 	rq->vrq->scsi.function = VDA_FUNC_CLI;
455 
456 	vrq->length = cpu_to_le32(length);
457 	vrq->cmd_rsp_len = cpu_to_le32(cmd_rsp_len);
458 	vrq->sg_list_offset = (u8)offsetof(struct atto_vda_cli_req, sge);
459 }
460 
461 /* Build a VDA IOCTL request. */
462 void esas2r_build_ioctl_req(struct esas2r_adapter *a,
463 			    struct esas2r_request *rq,
464 			    u32 length,
465 			    u8 sub_func)
466 {
467 	struct atto_vda_ioctl_req *vrq = &rq->vrq->ioctl;
468 
469 	clear_vda_request(rq);
470 
471 	rq->vrq->scsi.function = VDA_FUNC_IOCTL;
472 
473 	vrq->length = cpu_to_le32(length);
474 	vrq->sub_func = sub_func;
475 	vrq->sg_list_offset = (u8)offsetof(struct atto_vda_ioctl_req, sge);
476 }
477 
478 /* Build a VDA configuration request. */
479 void esas2r_build_cfg_req(struct esas2r_adapter *a,
480 			  struct esas2r_request *rq,
481 			  u8 sub_func,
482 			  u32 length,
483 			  void *data)
484 {
485 	struct atto_vda_cfg_req *vrq = &rq->vrq->cfg;
486 
487 	clear_vda_request(rq);
488 
489 	rq->vrq->scsi.function = VDA_FUNC_CFG;
490 
491 	vrq->sub_func = sub_func;
492 	vrq->length = cpu_to_le32(length);
493 
494 	if (data) {
495 		esas2r_nuxi_cfg_data(sub_func, data);
496 
497 		memcpy(&vrq->data, data, length);
498 	}
499 }
500 
501 static void clear_vda_request(struct esas2r_request *rq)
502 {
503 	u32 handle = rq->vrq->scsi.handle;
504 
505 	memset(rq->vrq, 0, sizeof(*rq->vrq));
506 
507 	rq->vrq->scsi.handle = handle;
508 
509 	rq->req_stat = RS_PENDING;
510 
511 	/* since the data buffer is separate clear that too */
512 
513 	memset(rq->data_buf, 0, ESAS2R_DATA_BUF_LEN);
514 
515 	/*
516 	 * Setup next and prev pointer in case the request is not going through
517 	 * esas2r_start_request().
518 	 */
519 
520 	INIT_LIST_HEAD(&rq->req_list);
521 }
522