1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Driver for Broadcom MPI3 Storage Controllers
4 *
5 * Copyright (C) 2017-2023 Broadcom Inc.
6 * (mailto: mpi3mr-linuxdrv.pdl@broadcom.com)
7 *
8 */
9
10 #include "mpi3mr.h"
11 #include <linux/bsg-lib.h>
12 #include <uapi/scsi/scsi_bsg_mpi3mr.h>
13
14 /**
15 * mpi3mr_alloc_trace_buffer: Allocate trace buffer
16 * @mrioc: Adapter instance reference
17 * @trace_size: Trace buffer size
18 *
19 * Allocate trace buffer
20 * Return: 0 on success, non-zero on failure.
21 */
mpi3mr_alloc_trace_buffer(struct mpi3mr_ioc * mrioc,u32 trace_size)22 static int mpi3mr_alloc_trace_buffer(struct mpi3mr_ioc *mrioc, u32 trace_size)
23 {
24 struct diag_buffer_desc *diag_buffer = &mrioc->diag_buffers[0];
25
26 diag_buffer->addr = dma_alloc_coherent(&mrioc->pdev->dev,
27 trace_size, &diag_buffer->dma_addr, GFP_KERNEL);
28 if (diag_buffer->addr) {
29 dprint_init(mrioc, "trace diag buffer is allocated successfully\n");
30 return 0;
31 }
32 return -1;
33 }
34
35 /**
36 * mpi3mr_alloc_diag_bufs - Allocate memory for diag buffers
37 * @mrioc: Adapter instance reference
38 *
39 * This functions checks whether the driver defined buffer sizes
40 * are greater than IOCFacts provided controller local buffer
41 * sizes and if the driver defined sizes are more then the
42 * driver allocates the specific buffer by reading driver page1
43 *
44 * Return: Nothing.
45 */
mpi3mr_alloc_diag_bufs(struct mpi3mr_ioc * mrioc)46 void mpi3mr_alloc_diag_bufs(struct mpi3mr_ioc *mrioc)
47 {
48 struct diag_buffer_desc *diag_buffer;
49 struct mpi3_driver_page1 driver_pg1;
50 u32 trace_dec_size, trace_min_size, fw_dec_size, fw_min_size,
51 trace_size, fw_size;
52 u16 pg_sz = sizeof(driver_pg1);
53 int retval = 0;
54 bool retry = false;
55
56 if (mrioc->diag_buffers[0].addr || mrioc->diag_buffers[1].addr)
57 return;
58
59 retval = mpi3mr_cfg_get_driver_pg1(mrioc, &driver_pg1, pg_sz);
60 if (retval) {
61 ioc_warn(mrioc,
62 "%s: driver page 1 read failed, allocating trace\n"
63 "and firmware diag buffers of default size\n", __func__);
64 trace_size = fw_size = MPI3MR_DEFAULT_HDB_MAX_SZ;
65 trace_dec_size = fw_dec_size = MPI3MR_DEFAULT_HDB_DEC_SZ;
66 trace_min_size = fw_min_size = MPI3MR_DEFAULT_HDB_MIN_SZ;
67
68 } else {
69 trace_size = driver_pg1.host_diag_trace_max_size * 1024;
70 trace_dec_size = driver_pg1.host_diag_trace_decrement_size
71 * 1024;
72 trace_min_size = driver_pg1.host_diag_trace_min_size * 1024;
73 fw_size = driver_pg1.host_diag_fw_max_size * 1024;
74 fw_dec_size = driver_pg1.host_diag_fw_decrement_size * 1024;
75 fw_min_size = driver_pg1.host_diag_fw_min_size * 1024;
76 dprint_init(mrioc,
77 "%s:trace diag buffer sizes read from driver\n"
78 "page1: maximum size = %dKB, decrement size = %dKB\n"
79 ", minimum size = %dKB\n", __func__, driver_pg1.host_diag_trace_max_size,
80 driver_pg1.host_diag_trace_decrement_size,
81 driver_pg1.host_diag_trace_min_size);
82 dprint_init(mrioc,
83 "%s:firmware diag buffer sizes read from driver\n"
84 "page1: maximum size = %dKB, decrement size = %dKB\n"
85 ", minimum size = %dKB\n", __func__, driver_pg1.host_diag_fw_max_size,
86 driver_pg1.host_diag_fw_decrement_size,
87 driver_pg1.host_diag_fw_min_size);
88 if ((trace_size == 0) && (fw_size == 0))
89 return;
90 }
91
92
93 retry_trace:
94 diag_buffer = &mrioc->diag_buffers[0];
95 diag_buffer->type = MPI3_DIAG_BUFFER_TYPE_TRACE;
96 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_NOT_ALLOCATED;
97 if ((mrioc->facts.diag_trace_sz < trace_size) && (trace_size >=
98 trace_min_size)) {
99 if (!retry)
100 dprint_init(mrioc,
101 "trying to allocate trace diag buffer of size = %dKB\n",
102 trace_size / 1024);
103 if (get_order(trace_size) > MAX_PAGE_ORDER ||
104 mpi3mr_alloc_trace_buffer(mrioc, trace_size)) {
105 retry = true;
106 trace_size -= trace_dec_size;
107 dprint_init(mrioc, "trace diag buffer allocation failed\n"
108 "retrying smaller size %dKB\n", trace_size / 1024);
109 goto retry_trace;
110 } else
111 diag_buffer->size = trace_size;
112 }
113
114 retry = false;
115 retry_fw:
116
117 diag_buffer = &mrioc->diag_buffers[1];
118
119 diag_buffer->type = MPI3_DIAG_BUFFER_TYPE_FW;
120 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_NOT_ALLOCATED;
121 if ((mrioc->facts.diag_fw_sz < fw_size) && (fw_size >= fw_min_size)) {
122 if (get_order(fw_size) <= MAX_PAGE_ORDER) {
123 diag_buffer->addr
124 = dma_alloc_coherent(&mrioc->pdev->dev, fw_size,
125 &diag_buffer->dma_addr,
126 GFP_KERNEL);
127 }
128 if (!retry)
129 dprint_init(mrioc,
130 "%s:trying to allocate firmware diag buffer of size = %dKB\n",
131 __func__, fw_size / 1024);
132 if (diag_buffer->addr) {
133 dprint_init(mrioc, "%s:firmware diag buffer allocated successfully\n",
134 __func__);
135 diag_buffer->size = fw_size;
136 } else {
137 retry = true;
138 fw_size -= fw_dec_size;
139 dprint_init(mrioc, "%s:trace diag buffer allocation failed,\n"
140 "retrying smaller size %dKB\n",
141 __func__, fw_size / 1024);
142 goto retry_fw;
143 }
144 }
145 }
146
147 /**
148 * mpi3mr_issue_diag_buf_post - Send diag buffer post req
149 * @mrioc: Adapter instance reference
150 * @diag_buffer: Diagnostic buffer descriptor
151 *
152 * Issue diagnostic buffer post MPI request through admin queue
153 * and wait for the completion of it or time out.
154 *
155 * Return: 0 on success, non-zero on failures.
156 */
mpi3mr_issue_diag_buf_post(struct mpi3mr_ioc * mrioc,struct diag_buffer_desc * diag_buffer)157 int mpi3mr_issue_diag_buf_post(struct mpi3mr_ioc *mrioc,
158 struct diag_buffer_desc *diag_buffer)
159 {
160 struct mpi3_diag_buffer_post_request diag_buf_post_req;
161 u8 prev_status;
162 int retval = 0;
163
164 memset(&diag_buf_post_req, 0, sizeof(diag_buf_post_req));
165 mutex_lock(&mrioc->init_cmds.mutex);
166 if (mrioc->init_cmds.state & MPI3MR_CMD_PENDING) {
167 dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
168 mutex_unlock(&mrioc->init_cmds.mutex);
169 return -1;
170 }
171 mrioc->init_cmds.state = MPI3MR_CMD_PENDING;
172 mrioc->init_cmds.is_waiting = 1;
173 mrioc->init_cmds.callback = NULL;
174 diag_buf_post_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_INITCMDS);
175 diag_buf_post_req.function = MPI3_FUNCTION_DIAG_BUFFER_POST;
176 diag_buf_post_req.type = diag_buffer->type;
177 diag_buf_post_req.address = le64_to_cpu(diag_buffer->dma_addr);
178 diag_buf_post_req.length = le32_to_cpu(diag_buffer->size);
179
180 dprint_bsg_info(mrioc, "%s: posting diag buffer type %d\n", __func__,
181 diag_buffer->type);
182 prev_status = diag_buffer->status;
183 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED;
184 init_completion(&mrioc->init_cmds.done);
185 retval = mpi3mr_admin_request_post(mrioc, &diag_buf_post_req,
186 sizeof(diag_buf_post_req), 1);
187 if (retval) {
188 dprint_bsg_err(mrioc, "%s: admin request post failed\n",
189 __func__);
190 goto out_unlock;
191 }
192 wait_for_completion_timeout(&mrioc->init_cmds.done,
193 (MPI3MR_INTADMCMD_TIMEOUT * HZ));
194 if (!(mrioc->init_cmds.state & MPI3MR_CMD_COMPLETE)) {
195 mrioc->init_cmds.is_waiting = 0;
196 dprint_bsg_err(mrioc, "%s: command timedout\n", __func__);
197 mpi3mr_check_rh_fault_ioc(mrioc,
198 MPI3MR_RESET_FROM_DIAG_BUFFER_POST_TIMEOUT);
199 retval = -1;
200 goto out_unlock;
201 }
202 if ((mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
203 != MPI3_IOCSTATUS_SUCCESS) {
204 dprint_bsg_err(mrioc,
205 "%s: command failed, buffer_type (%d) ioc_status(0x%04x) log_info(0x%08x)\n",
206 __func__, diag_buffer->type,
207 (mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
208 mrioc->init_cmds.ioc_loginfo);
209 retval = -1;
210 goto out_unlock;
211 }
212 dprint_bsg_info(mrioc, "%s: diag buffer type %d posted successfully\n",
213 __func__, diag_buffer->type);
214
215 out_unlock:
216 if (retval)
217 diag_buffer->status = prev_status;
218 mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED;
219 mutex_unlock(&mrioc->init_cmds.mutex);
220 return retval;
221 }
222
223 /**
224 * mpi3mr_post_diag_bufs - Post diag buffers to the controller
225 * @mrioc: Adapter instance reference
226 *
227 * This function calls helper function to post both trace and
228 * firmware buffers to the controller.
229 *
230 * Return: None
231 */
mpi3mr_post_diag_bufs(struct mpi3mr_ioc * mrioc)232 int mpi3mr_post_diag_bufs(struct mpi3mr_ioc *mrioc)
233 {
234 u8 i;
235 struct diag_buffer_desc *diag_buffer;
236
237 for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
238 diag_buffer = &mrioc->diag_buffers[i];
239 if (!(diag_buffer->addr))
240 continue;
241 if (mpi3mr_issue_diag_buf_post(mrioc, diag_buffer))
242 return -1;
243 }
244 return 0;
245 }
246
247 /**
248 * mpi3mr_issue_diag_buf_release - Send diag buffer release req
249 * @mrioc: Adapter instance reference
250 * @diag_buffer: Diagnostic buffer descriptor
251 *
252 * Issue diagnostic buffer manage MPI request with release
253 * action request through admin queue and wait for the
254 * completion of it or time out.
255 *
256 * Return: 0 on success, non-zero on failures.
257 */
mpi3mr_issue_diag_buf_release(struct mpi3mr_ioc * mrioc,struct diag_buffer_desc * diag_buffer)258 int mpi3mr_issue_diag_buf_release(struct mpi3mr_ioc *mrioc,
259 struct diag_buffer_desc *diag_buffer)
260 {
261 struct mpi3_diag_buffer_manage_request diag_buf_manage_req;
262 int retval = 0;
263
264 if ((diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
265 (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
266 return retval;
267
268 memset(&diag_buf_manage_req, 0, sizeof(diag_buf_manage_req));
269 mutex_lock(&mrioc->init_cmds.mutex);
270 if (mrioc->init_cmds.state & MPI3MR_CMD_PENDING) {
271 dprint_reset(mrioc, "%s: command is in use\n", __func__);
272 mutex_unlock(&mrioc->init_cmds.mutex);
273 return -1;
274 }
275 mrioc->init_cmds.state = MPI3MR_CMD_PENDING;
276 mrioc->init_cmds.is_waiting = 1;
277 mrioc->init_cmds.callback = NULL;
278 diag_buf_manage_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_INITCMDS);
279 diag_buf_manage_req.function = MPI3_FUNCTION_DIAG_BUFFER_MANAGE;
280 diag_buf_manage_req.type = diag_buffer->type;
281 diag_buf_manage_req.action = MPI3_DIAG_BUFFER_ACTION_RELEASE;
282
283
284 dprint_reset(mrioc, "%s: releasing diag buffer type %d\n", __func__,
285 diag_buffer->type);
286 init_completion(&mrioc->init_cmds.done);
287 retval = mpi3mr_admin_request_post(mrioc, &diag_buf_manage_req,
288 sizeof(diag_buf_manage_req), 1);
289 if (retval) {
290 dprint_reset(mrioc, "%s: admin request post failed\n", __func__);
291 mpi3mr_set_trigger_data_in_hdb(diag_buffer,
292 MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN, NULL, 1);
293 goto out_unlock;
294 }
295 wait_for_completion_timeout(&mrioc->init_cmds.done,
296 (MPI3MR_INTADMCMD_TIMEOUT * HZ));
297 if (!(mrioc->init_cmds.state & MPI3MR_CMD_COMPLETE)) {
298 mrioc->init_cmds.is_waiting = 0;
299 dprint_reset(mrioc, "%s: command timedout\n", __func__);
300 mpi3mr_check_rh_fault_ioc(mrioc,
301 MPI3MR_RESET_FROM_DIAG_BUFFER_RELEASE_TIMEOUT);
302 retval = -1;
303 goto out_unlock;
304 }
305 if ((mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
306 != MPI3_IOCSTATUS_SUCCESS) {
307 dprint_reset(mrioc,
308 "%s: command failed, buffer_type (%d) ioc_status(0x%04x) log_info(0x%08x)\n",
309 __func__, diag_buffer->type,
310 (mrioc->init_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
311 mrioc->init_cmds.ioc_loginfo);
312 retval = -1;
313 goto out_unlock;
314 }
315 dprint_reset(mrioc, "%s: diag buffer type %d released successfully\n",
316 __func__, diag_buffer->type);
317
318 out_unlock:
319 mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED;
320 mutex_unlock(&mrioc->init_cmds.mutex);
321 return retval;
322 }
323
324 /**
325 * mpi3mr_process_trigger - Generic HDB Trigger handler
326 * @mrioc: Adapter instance reference
327 * @trigger_type: Trigger type
328 * @trigger_data: Trigger data
329 * @trigger_flags: Trigger flags
330 *
331 * This function checks validity of HDB, triggers and based on
332 * trigger information, creates an event to be processed in the
333 * firmware event worker thread .
334 *
335 * This function should be called with trigger spinlock held
336 *
337 * Return: Nothing
338 */
mpi3mr_process_trigger(struct mpi3mr_ioc * mrioc,u8 trigger_type,union mpi3mr_trigger_data * trigger_data,u8 trigger_flags)339 static void mpi3mr_process_trigger(struct mpi3mr_ioc *mrioc, u8 trigger_type,
340 union mpi3mr_trigger_data *trigger_data, u8 trigger_flags)
341 {
342 struct trigger_event_data event_data;
343 struct diag_buffer_desc *trace_hdb = NULL;
344 struct diag_buffer_desc *fw_hdb = NULL;
345 u64 global_trigger;
346
347 trace_hdb = mpi3mr_diag_buffer_for_type(mrioc,
348 MPI3_DIAG_BUFFER_TYPE_TRACE);
349 if (trace_hdb &&
350 (trace_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
351 (trace_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
352 trace_hdb = NULL;
353
354 fw_hdb = mpi3mr_diag_buffer_for_type(mrioc, MPI3_DIAG_BUFFER_TYPE_FW);
355
356 if (fw_hdb &&
357 (fw_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
358 (fw_hdb->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
359 fw_hdb = NULL;
360
361 if (mrioc->snapdump_trigger_active || (mrioc->fw_release_trigger_active
362 && mrioc->trace_release_trigger_active) ||
363 (!trace_hdb && !fw_hdb) || (!mrioc->driver_pg2) ||
364 ((trigger_type == MPI3MR_HDB_TRIGGER_TYPE_ELEMENT)
365 && (!mrioc->driver_pg2->num_triggers)))
366 return;
367
368 memset(&event_data, 0, sizeof(event_data));
369 event_data.trigger_type = trigger_type;
370 memcpy(&event_data.trigger_specific_data, trigger_data,
371 sizeof(*trigger_data));
372 global_trigger = le64_to_cpu(mrioc->driver_pg2->global_trigger);
373
374 if (global_trigger & MPI3_DRIVER2_GLOBALTRIGGER_SNAPDUMP_ENABLED) {
375 event_data.snapdump = true;
376 event_data.trace_hdb = trace_hdb;
377 event_data.fw_hdb = fw_hdb;
378 mrioc->snapdump_trigger_active = true;
379 } else if (trigger_type == MPI3MR_HDB_TRIGGER_TYPE_GLOBAL) {
380 if ((trace_hdb) && (global_trigger &
381 MPI3_DRIVER2_GLOBALTRIGGER_DIAG_TRACE_RELEASE) &&
382 (!mrioc->trace_release_trigger_active)) {
383 event_data.trace_hdb = trace_hdb;
384 mrioc->trace_release_trigger_active = true;
385 }
386 if ((fw_hdb) && (global_trigger &
387 MPI3_DRIVER2_GLOBALTRIGGER_DIAG_FW_RELEASE) &&
388 (!mrioc->fw_release_trigger_active)) {
389 event_data.fw_hdb = fw_hdb;
390 mrioc->fw_release_trigger_active = true;
391 }
392 } else if (trigger_type == MPI3MR_HDB_TRIGGER_TYPE_ELEMENT) {
393 if ((trace_hdb) && (trigger_flags &
394 MPI3_DRIVER2_TRIGGER_FLAGS_DIAG_TRACE_RELEASE) &&
395 (!mrioc->trace_release_trigger_active)) {
396 event_data.trace_hdb = trace_hdb;
397 mrioc->trace_release_trigger_active = true;
398 }
399 if ((fw_hdb) && (trigger_flags &
400 MPI3_DRIVER2_TRIGGER_FLAGS_DIAG_FW_RELEASE) &&
401 (!mrioc->fw_release_trigger_active)) {
402 event_data.fw_hdb = fw_hdb;
403 mrioc->fw_release_trigger_active = true;
404 }
405 }
406
407 if (event_data.trace_hdb || event_data.fw_hdb)
408 mpi3mr_hdb_trigger_data_event(mrioc, &event_data);
409 }
410
411 /**
412 * mpi3mr_global_trigger - Global HDB trigger handler
413 * @mrioc: Adapter instance reference
414 * @trigger_data: Trigger data
415 *
416 * This function checks whether the given global trigger is
417 * enabled in the driver page 2 and if so calls generic trigger
418 * handler to queue event for HDB release.
419 *
420 * Return: Nothing
421 */
mpi3mr_global_trigger(struct mpi3mr_ioc * mrioc,u64 trigger_data)422 void mpi3mr_global_trigger(struct mpi3mr_ioc *mrioc, u64 trigger_data)
423 {
424 unsigned long flags;
425 union mpi3mr_trigger_data trigger_specific_data;
426
427 spin_lock_irqsave(&mrioc->trigger_lock, flags);
428 if (le64_to_cpu(mrioc->driver_pg2->global_trigger) & trigger_data) {
429 memset(&trigger_specific_data, 0,
430 sizeof(trigger_specific_data));
431 trigger_specific_data.global = trigger_data;
432 mpi3mr_process_trigger(mrioc, MPI3MR_HDB_TRIGGER_TYPE_GLOBAL,
433 &trigger_specific_data, 0);
434 }
435 spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
436 }
437
438 /**
439 * mpi3mr_scsisense_trigger - SCSI sense HDB trigger handler
440 * @mrioc: Adapter instance reference
441 * @sensekey: Sense Key
442 * @asc: Additional Sense Code
443 * @ascq: Additional Sense Code Qualifier
444 *
445 * This function compares SCSI sense trigger values with driver
446 * page 2 values and calls generic trigger handler to release
447 * HDBs if match found
448 *
449 * Return: Nothing
450 */
mpi3mr_scsisense_trigger(struct mpi3mr_ioc * mrioc,u8 sensekey,u8 asc,u8 ascq)451 void mpi3mr_scsisense_trigger(struct mpi3mr_ioc *mrioc, u8 sensekey, u8 asc,
452 u8 ascq)
453 {
454 struct mpi3_driver2_trigger_scsi_sense *scsi_sense_trigger = NULL;
455 u64 i = 0;
456 unsigned long flags;
457 u8 num_triggers, trigger_flags;
458
459 if (mrioc->scsisense_trigger_present) {
460 spin_lock_irqsave(&mrioc->trigger_lock, flags);
461 scsi_sense_trigger = (struct mpi3_driver2_trigger_scsi_sense *)
462 mrioc->driver_pg2->trigger;
463 num_triggers = mrioc->driver_pg2->num_triggers;
464 for (i = 0; i < num_triggers; i++, scsi_sense_trigger++) {
465 if (scsi_sense_trigger->type !=
466 MPI3_DRIVER2_TRIGGER_TYPE_SCSI_SENSE)
467 continue;
468 if (!(scsi_sense_trigger->sense_key ==
469 MPI3_DRIVER2_TRIGGER_SCSI_SENSE_SENSE_KEY_MATCH_ALL
470 || scsi_sense_trigger->sense_key == sensekey))
471 continue;
472 if (!(scsi_sense_trigger->asc ==
473 MPI3_DRIVER2_TRIGGER_SCSI_SENSE_ASC_MATCH_ALL ||
474 scsi_sense_trigger->asc == asc))
475 continue;
476 if (!(scsi_sense_trigger->ascq ==
477 MPI3_DRIVER2_TRIGGER_SCSI_SENSE_ASCQ_MATCH_ALL ||
478 scsi_sense_trigger->ascq == ascq))
479 continue;
480 trigger_flags = scsi_sense_trigger->flags;
481 mpi3mr_process_trigger(mrioc,
482 MPI3MR_HDB_TRIGGER_TYPE_ELEMENT,
483 (union mpi3mr_trigger_data *)scsi_sense_trigger,
484 trigger_flags);
485 break;
486 }
487 spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
488 }
489 }
490
491 /**
492 * mpi3mr_event_trigger - MPI event HDB trigger handler
493 * @mrioc: Adapter instance reference
494 * @event: MPI Event
495 *
496 * This function compares event trigger values with driver page
497 * 2 values and calls generic trigger handler to release
498 * HDBs if match found.
499 *
500 * Return: Nothing
501 */
mpi3mr_event_trigger(struct mpi3mr_ioc * mrioc,u8 event)502 void mpi3mr_event_trigger(struct mpi3mr_ioc *mrioc, u8 event)
503 {
504 struct mpi3_driver2_trigger_event *event_trigger = NULL;
505 u64 i = 0;
506 unsigned long flags;
507 u8 num_triggers, trigger_flags;
508
509 if (mrioc->event_trigger_present) {
510 spin_lock_irqsave(&mrioc->trigger_lock, flags);
511 event_trigger = (struct mpi3_driver2_trigger_event *)
512 mrioc->driver_pg2->trigger;
513 num_triggers = mrioc->driver_pg2->num_triggers;
514
515 for (i = 0; i < num_triggers; i++, event_trigger++) {
516 if (event_trigger->type !=
517 MPI3_DRIVER2_TRIGGER_TYPE_EVENT)
518 continue;
519 if (event_trigger->event != event)
520 continue;
521 trigger_flags = event_trigger->flags;
522 mpi3mr_process_trigger(mrioc,
523 MPI3MR_HDB_TRIGGER_TYPE_ELEMENT,
524 (union mpi3mr_trigger_data *)event_trigger,
525 trigger_flags);
526 break;
527 }
528 spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
529 }
530 }
531
532 /**
533 * mpi3mr_reply_trigger - MPI Reply HDB trigger handler
534 * @mrioc: Adapter instance reference
535 * @ioc_status: Masked value of IOC Status from MPI Reply
536 * @ioc_loginfo: IOC Log Info from MPI Reply
537 *
538 * This function compares IOC status and IOC log info trigger
539 * values with driver page 2 values and calls generic trigger
540 * handler to release HDBs if match found.
541 *
542 * Return: Nothing
543 */
mpi3mr_reply_trigger(struct mpi3mr_ioc * mrioc,u16 ioc_status,u32 ioc_loginfo)544 void mpi3mr_reply_trigger(struct mpi3mr_ioc *mrioc, u16 ioc_status,
545 u32 ioc_loginfo)
546 {
547 struct mpi3_driver2_trigger_reply *reply_trigger = NULL;
548 u64 i = 0;
549 unsigned long flags;
550 u8 num_triggers, trigger_flags;
551
552 if (mrioc->reply_trigger_present) {
553 spin_lock_irqsave(&mrioc->trigger_lock, flags);
554 reply_trigger = (struct mpi3_driver2_trigger_reply *)
555 mrioc->driver_pg2->trigger;
556 num_triggers = mrioc->driver_pg2->num_triggers;
557 for (i = 0; i < num_triggers; i++, reply_trigger++) {
558 if (reply_trigger->type !=
559 MPI3_DRIVER2_TRIGGER_TYPE_REPLY)
560 continue;
561 if ((le16_to_cpu(reply_trigger->ioc_status) !=
562 ioc_status)
563 && (le16_to_cpu(reply_trigger->ioc_status) !=
564 MPI3_DRIVER2_TRIGGER_REPLY_IOCSTATUS_MATCH_ALL))
565 continue;
566 if ((le32_to_cpu(reply_trigger->ioc_log_info) !=
567 (le32_to_cpu(reply_trigger->ioc_log_info_mask) &
568 ioc_loginfo)))
569 continue;
570 trigger_flags = reply_trigger->flags;
571 mpi3mr_process_trigger(mrioc,
572 MPI3MR_HDB_TRIGGER_TYPE_ELEMENT,
573 (union mpi3mr_trigger_data *)reply_trigger,
574 trigger_flags);
575 break;
576 }
577 spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
578 }
579 }
580
581 /**
582 * mpi3mr_get_num_trigger - Gets number of HDB triggers
583 * @mrioc: Adapter instance reference
584 * @num_triggers: Number of triggers
585 * @page_action: Page action
586 *
587 * This function reads number of triggers by reading driver page
588 * 2
589 *
590 * Return: 0 on success and proper error codes on failure
591 */
mpi3mr_get_num_trigger(struct mpi3mr_ioc * mrioc,u8 * num_triggers,u8 page_action)592 static int mpi3mr_get_num_trigger(struct mpi3mr_ioc *mrioc, u8 *num_triggers,
593 u8 page_action)
594 {
595 struct mpi3_driver_page2 drvr_page2;
596 int retval = 0;
597
598 *num_triggers = 0;
599
600 retval = mpi3mr_cfg_get_driver_pg2(mrioc, &drvr_page2,
601 sizeof(struct mpi3_driver_page2), page_action);
602
603 if (retval) {
604 dprint_init(mrioc, "%s: driver page 2 read failed\n", __func__);
605 return retval;
606 }
607 *num_triggers = drvr_page2.num_triggers;
608 return retval;
609 }
610
611 /**
612 * mpi3mr_refresh_trigger - Handler for Refresh trigger BSG
613 * @mrioc: Adapter instance reference
614 * @page_action: Page action
615 *
616 * This function caches the driver page 2 in the driver's memory
617 * by reading driver page 2 from the controller for a given page
618 * type and updates the HDB trigger values
619 *
620 * Return: 0 on success and proper error codes on failure
621 */
mpi3mr_refresh_trigger(struct mpi3mr_ioc * mrioc,u8 page_action)622 int mpi3mr_refresh_trigger(struct mpi3mr_ioc *mrioc, u8 page_action)
623 {
624 u16 pg_sz = sizeof(struct mpi3_driver_page2);
625 struct mpi3_driver_page2 *drvr_page2 = NULL;
626 u8 trigger_type, num_triggers;
627 int retval;
628 int i = 0;
629 unsigned long flags;
630
631 retval = mpi3mr_get_num_trigger(mrioc, &num_triggers, page_action);
632
633 if (retval)
634 goto out;
635
636 pg_sz = offsetof(struct mpi3_driver_page2, trigger) +
637 (num_triggers * sizeof(union mpi3_driver2_trigger_element));
638 drvr_page2 = kzalloc(pg_sz, GFP_KERNEL);
639 if (!drvr_page2) {
640 retval = -ENOMEM;
641 goto out;
642 }
643
644 retval = mpi3mr_cfg_get_driver_pg2(mrioc, drvr_page2, pg_sz, page_action);
645 if (retval) {
646 dprint_init(mrioc, "%s: driver page 2 read failed\n", __func__);
647 kfree(drvr_page2);
648 goto out;
649 }
650 spin_lock_irqsave(&mrioc->trigger_lock, flags);
651 kfree(mrioc->driver_pg2);
652 mrioc->driver_pg2 = drvr_page2;
653 mrioc->reply_trigger_present = false;
654 mrioc->event_trigger_present = false;
655 mrioc->scsisense_trigger_present = false;
656
657 for (i = 0; (i < mrioc->driver_pg2->num_triggers); i++) {
658 trigger_type = mrioc->driver_pg2->trigger[i].event.type;
659 switch (trigger_type) {
660 case MPI3_DRIVER2_TRIGGER_TYPE_REPLY:
661 mrioc->reply_trigger_present = true;
662 break;
663 case MPI3_DRIVER2_TRIGGER_TYPE_EVENT:
664 mrioc->event_trigger_present = true;
665 break;
666 case MPI3_DRIVER2_TRIGGER_TYPE_SCSI_SENSE:
667 mrioc->scsisense_trigger_present = true;
668 break;
669 default:
670 break;
671 }
672 }
673 spin_unlock_irqrestore(&mrioc->trigger_lock, flags);
674 out:
675 return retval;
676 }
677
678 /**
679 * mpi3mr_release_diag_bufs - Release diag buffers
680 * @mrioc: Adapter instance reference
681 * @skip_rel_action: Skip release action and set buffer state
682 *
683 * This function calls helper function to release both trace and
684 * firmware buffers from the controller.
685 *
686 * Return: None
687 */
mpi3mr_release_diag_bufs(struct mpi3mr_ioc * mrioc,u8 skip_rel_action)688 void mpi3mr_release_diag_bufs(struct mpi3mr_ioc *mrioc, u8 skip_rel_action)
689 {
690 u8 i;
691 struct diag_buffer_desc *diag_buffer;
692
693 for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
694 diag_buffer = &mrioc->diag_buffers[i];
695 if (!(diag_buffer->addr))
696 continue;
697 if (diag_buffer->status == MPI3MR_HDB_BUFSTATUS_RELEASED)
698 continue;
699 if (!skip_rel_action)
700 mpi3mr_issue_diag_buf_release(mrioc, diag_buffer);
701 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_RELEASED;
702 atomic64_inc(&event_counter);
703 }
704 }
705
706 /**
707 * mpi3mr_set_trigger_data_in_hdb - Updates HDB trigger type and
708 * trigger data
709 *
710 * @hdb: HDB pointer
711 * @type: Trigger type
712 * @data: Trigger data
713 * @force: Trigger overwrite flag
714 * @trigger_data: Pointer to trigger data information
715 *
716 * Updates trigger type and trigger data based on parameter
717 * passed to this function
718 *
719 * Return: Nothing
720 */
mpi3mr_set_trigger_data_in_hdb(struct diag_buffer_desc * hdb,u8 type,union mpi3mr_trigger_data * trigger_data,bool force)721 void mpi3mr_set_trigger_data_in_hdb(struct diag_buffer_desc *hdb,
722 u8 type, union mpi3mr_trigger_data *trigger_data, bool force)
723 {
724 if ((!force) && (hdb->trigger_type != MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN))
725 return;
726 hdb->trigger_type = type;
727 if (!trigger_data)
728 memset(&hdb->trigger_data, 0, sizeof(*trigger_data));
729 else
730 memcpy(&hdb->trigger_data, trigger_data, sizeof(*trigger_data));
731 }
732
733 /**
734 * mpi3mr_set_trigger_data_in_all_hdb - Updates HDB trigger type
735 * and trigger data for all HDB
736 *
737 * @mrioc: Adapter instance reference
738 * @type: Trigger type
739 * @data: Trigger data
740 * @force: Trigger overwrite flag
741 * @trigger_data: Pointer to trigger data information
742 *
743 * Updates trigger type and trigger data based on parameter
744 * passed to this function
745 *
746 * Return: Nothing
747 */
mpi3mr_set_trigger_data_in_all_hdb(struct mpi3mr_ioc * mrioc,u8 type,union mpi3mr_trigger_data * trigger_data,bool force)748 void mpi3mr_set_trigger_data_in_all_hdb(struct mpi3mr_ioc *mrioc,
749 u8 type, union mpi3mr_trigger_data *trigger_data, bool force)
750 {
751 struct diag_buffer_desc *hdb = NULL;
752
753 hdb = mpi3mr_diag_buffer_for_type(mrioc, MPI3_DIAG_BUFFER_TYPE_TRACE);
754 if (hdb)
755 mpi3mr_set_trigger_data_in_hdb(hdb, type, trigger_data, force);
756 hdb = mpi3mr_diag_buffer_for_type(mrioc, MPI3_DIAG_BUFFER_TYPE_FW);
757 if (hdb)
758 mpi3mr_set_trigger_data_in_hdb(hdb, type, trigger_data, force);
759 }
760
761 /**
762 * mpi3mr_hdbstatuschg_evt_th - HDB status change evt tophalf
763 * @mrioc: Adapter instance reference
764 * @event_reply: event data
765 *
766 * Modifies the status of the applicable diag buffer descriptors
767 *
768 * Return: Nothing
769 */
mpi3mr_hdbstatuschg_evt_th(struct mpi3mr_ioc * mrioc,struct mpi3_event_notification_reply * event_reply)770 void mpi3mr_hdbstatuschg_evt_th(struct mpi3mr_ioc *mrioc,
771 struct mpi3_event_notification_reply *event_reply)
772 {
773 struct mpi3_event_data_diag_buffer_status_change *evtdata;
774 struct diag_buffer_desc *diag_buffer;
775
776 evtdata = (struct mpi3_event_data_diag_buffer_status_change *)
777 event_reply->event_data;
778
779 diag_buffer = mpi3mr_diag_buffer_for_type(mrioc, evtdata->type);
780 if (!diag_buffer)
781 return;
782 if ((diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED) &&
783 (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED))
784 return;
785 switch (evtdata->reason_code) {
786 case MPI3_EVENT_DIAG_BUFFER_STATUS_CHANGE_RC_RELEASED:
787 {
788 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_RELEASED;
789 mpi3mr_set_trigger_data_in_hdb(diag_buffer,
790 MPI3MR_HDB_TRIGGER_TYPE_FW_RELEASED, NULL, 0);
791 atomic64_inc(&event_counter);
792 break;
793 }
794 case MPI3_EVENT_DIAG_BUFFER_STATUS_CHANGE_RC_RESUMED:
795 {
796 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED;
797 break;
798 }
799 case MPI3_EVENT_DIAG_BUFFER_STATUS_CHANGE_RC_PAUSED:
800 {
801 diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED;
802 break;
803 }
804 default:
805 dprint_event_th(mrioc, "%s: unknown reason_code(%d)\n",
806 __func__, evtdata->reason_code);
807 break;
808 }
809 }
810
811 /**
812 * mpi3mr_diag_buffer_for_type - returns buffer desc for type
813 * @mrioc: Adapter instance reference
814 * @buf_type: Diagnostic buffer type
815 *
816 * Identifies matching diag descriptor from mrioc for given diag
817 * buffer type.
818 *
819 * Return: diag buffer descriptor on success, NULL on failures.
820 */
821
822 struct diag_buffer_desc *
mpi3mr_diag_buffer_for_type(struct mpi3mr_ioc * mrioc,u8 buf_type)823 mpi3mr_diag_buffer_for_type(struct mpi3mr_ioc *mrioc, u8 buf_type)
824 {
825 u8 i;
826
827 for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
828 if (mrioc->diag_buffers[i].type == buf_type)
829 return &mrioc->diag_buffers[i];
830 }
831 return NULL;
832 }
833
834 /**
835 * mpi3mr_bsg_pel_abort - sends PEL abort request
836 * @mrioc: Adapter instance reference
837 *
838 * This function sends PEL abort request to the firmware through
839 * admin request queue.
840 *
841 * Return: 0 on success, -1 on failure
842 */
mpi3mr_bsg_pel_abort(struct mpi3mr_ioc * mrioc)843 static int mpi3mr_bsg_pel_abort(struct mpi3mr_ioc *mrioc)
844 {
845 struct mpi3_pel_req_action_abort pel_abort_req;
846 struct mpi3_pel_reply *pel_reply;
847 int retval = 0;
848 u16 pe_log_status;
849
850 if (mrioc->reset_in_progress) {
851 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
852 return -1;
853 }
854 if (mrioc->stop_bsgs || mrioc->block_on_pci_err) {
855 dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
856 return -1;
857 }
858
859 memset(&pel_abort_req, 0, sizeof(pel_abort_req));
860 mutex_lock(&mrioc->pel_abort_cmd.mutex);
861 if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_PENDING) {
862 dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
863 mutex_unlock(&mrioc->pel_abort_cmd.mutex);
864 return -1;
865 }
866 mrioc->pel_abort_cmd.state = MPI3MR_CMD_PENDING;
867 mrioc->pel_abort_cmd.is_waiting = 1;
868 mrioc->pel_abort_cmd.callback = NULL;
869 pel_abort_req.host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_ABORT);
870 pel_abort_req.function = MPI3_FUNCTION_PERSISTENT_EVENT_LOG;
871 pel_abort_req.action = MPI3_PEL_ACTION_ABORT;
872 pel_abort_req.abort_host_tag = cpu_to_le16(MPI3MR_HOSTTAG_PEL_WAIT);
873
874 mrioc->pel_abort_requested = 1;
875 init_completion(&mrioc->pel_abort_cmd.done);
876 retval = mpi3mr_admin_request_post(mrioc, &pel_abort_req,
877 sizeof(pel_abort_req), 0);
878 if (retval) {
879 retval = -1;
880 dprint_bsg_err(mrioc, "%s: admin request post failed\n",
881 __func__);
882 mrioc->pel_abort_requested = 0;
883 goto out_unlock;
884 }
885
886 wait_for_completion_timeout(&mrioc->pel_abort_cmd.done,
887 (MPI3MR_INTADMCMD_TIMEOUT * HZ));
888 if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_COMPLETE)) {
889 mrioc->pel_abort_cmd.is_waiting = 0;
890 dprint_bsg_err(mrioc, "%s: command timedout\n", __func__);
891 if (!(mrioc->pel_abort_cmd.state & MPI3MR_CMD_RESET))
892 mpi3mr_soft_reset_handler(mrioc,
893 MPI3MR_RESET_FROM_PELABORT_TIMEOUT, 1);
894 retval = -1;
895 goto out_unlock;
896 }
897 if ((mrioc->pel_abort_cmd.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
898 != MPI3_IOCSTATUS_SUCCESS) {
899 dprint_bsg_err(mrioc,
900 "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n",
901 __func__, (mrioc->pel_abort_cmd.ioc_status &
902 MPI3_IOCSTATUS_STATUS_MASK),
903 mrioc->pel_abort_cmd.ioc_loginfo);
904 retval = -1;
905 goto out_unlock;
906 }
907 if (mrioc->pel_abort_cmd.state & MPI3MR_CMD_REPLY_VALID) {
908 pel_reply = (struct mpi3_pel_reply *)mrioc->pel_abort_cmd.reply;
909 pe_log_status = le16_to_cpu(pel_reply->pe_log_status);
910 if (pe_log_status != MPI3_PEL_STATUS_SUCCESS) {
911 dprint_bsg_err(mrioc,
912 "%s: command failed, pel_status(0x%04x)\n",
913 __func__, pe_log_status);
914 retval = -1;
915 }
916 }
917
918 out_unlock:
919 mrioc->pel_abort_cmd.state = MPI3MR_CMD_NOTUSED;
920 mutex_unlock(&mrioc->pel_abort_cmd.mutex);
921 return retval;
922 }
923 /**
924 * mpi3mr_bsg_verify_adapter - verify adapter number is valid
925 * @ioc_number: Adapter number
926 *
927 * This function returns the adapter instance pointer of given
928 * adapter number. If adapter number does not match with the
929 * driver's adapter list, driver returns NULL.
930 *
931 * Return: adapter instance reference
932 */
mpi3mr_bsg_verify_adapter(int ioc_number)933 static struct mpi3mr_ioc *mpi3mr_bsg_verify_adapter(int ioc_number)
934 {
935 struct mpi3mr_ioc *mrioc = NULL;
936
937 spin_lock(&mrioc_list_lock);
938 list_for_each_entry(mrioc, &mrioc_list, list) {
939 if (mrioc->id == ioc_number) {
940 spin_unlock(&mrioc_list_lock);
941 return mrioc;
942 }
943 }
944 spin_unlock(&mrioc_list_lock);
945 return NULL;
946 }
947
948 /**
949 * mpi3mr_bsg_refresh_hdb_triggers - Refresh HDB trigger data
950 * @mrioc: Adapter instance reference
951 * @job: BSG Job pointer
952 *
953 * This function reads the controller trigger config page as
954 * defined by the input page type and refreshes the driver's
955 * local trigger information structures with the controller's
956 * config page data.
957 *
958 * Return: 0 on success and proper error codes on failure
959 */
960 static long
mpi3mr_bsg_refresh_hdb_triggers(struct mpi3mr_ioc * mrioc,struct bsg_job * job)961 mpi3mr_bsg_refresh_hdb_triggers(struct mpi3mr_ioc *mrioc,
962 struct bsg_job *job)
963 {
964 struct mpi3mr_bsg_out_refresh_hdb_triggers refresh_triggers;
965 uint32_t data_out_sz;
966 u8 page_action;
967 long rval = -EINVAL;
968
969 data_out_sz = job->request_payload.payload_len;
970
971 if (data_out_sz != sizeof(refresh_triggers)) {
972 dprint_bsg_err(mrioc, "%s: invalid size argument\n",
973 __func__);
974 return rval;
975 }
976
977 if (mrioc->unrecoverable) {
978 dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
979 __func__);
980 return -EFAULT;
981 }
982 if (mrioc->reset_in_progress) {
983 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
984 return -EAGAIN;
985 }
986
987 sg_copy_to_buffer(job->request_payload.sg_list,
988 job->request_payload.sg_cnt,
989 &refresh_triggers, sizeof(refresh_triggers));
990
991 switch (refresh_triggers.page_type) {
992 case MPI3MR_HDB_REFRESH_TYPE_CURRENT:
993 page_action = MPI3_CONFIG_ACTION_READ_CURRENT;
994 break;
995 case MPI3MR_HDB_REFRESH_TYPE_DEFAULT:
996 page_action = MPI3_CONFIG_ACTION_READ_DEFAULT;
997 break;
998 case MPI3MR_HDB_HDB_REFRESH_TYPE_PERSISTENT:
999 page_action = MPI3_CONFIG_ACTION_READ_PERSISTENT;
1000 break;
1001 default:
1002 dprint_bsg_err(mrioc,
1003 "%s: unsupported refresh trigger, page_type %d\n",
1004 __func__, refresh_triggers.page_type);
1005 return rval;
1006 }
1007 rval = mpi3mr_refresh_trigger(mrioc, page_action);
1008
1009 return rval;
1010 }
1011
1012 /**
1013 * mpi3mr_bsg_upload_hdb - Upload a specific HDB to user space
1014 * @mrioc: Adapter instance reference
1015 * @job: BSG Job pointer
1016 *
1017 * Return: 0 on success and proper error codes on failure
1018 */
mpi3mr_bsg_upload_hdb(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1019 static long mpi3mr_bsg_upload_hdb(struct mpi3mr_ioc *mrioc,
1020 struct bsg_job *job)
1021 {
1022 struct mpi3mr_bsg_out_upload_hdb upload_hdb;
1023 struct diag_buffer_desc *diag_buffer;
1024 uint32_t data_out_size;
1025 uint32_t data_in_size;
1026
1027 data_out_size = job->request_payload.payload_len;
1028 data_in_size = job->reply_payload.payload_len;
1029
1030 if (data_out_size != sizeof(upload_hdb)) {
1031 dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1032 __func__);
1033 return -EINVAL;
1034 }
1035
1036 sg_copy_to_buffer(job->request_payload.sg_list,
1037 job->request_payload.sg_cnt,
1038 &upload_hdb, sizeof(upload_hdb));
1039
1040 if ((!upload_hdb.length) || (data_in_size != upload_hdb.length)) {
1041 dprint_bsg_err(mrioc, "%s: invalid length argument\n",
1042 __func__);
1043 return -EINVAL;
1044 }
1045 diag_buffer = mpi3mr_diag_buffer_for_type(mrioc, upload_hdb.buf_type);
1046 if ((!diag_buffer) || (!diag_buffer->addr)) {
1047 dprint_bsg_err(mrioc, "%s: invalid buffer type %d\n",
1048 __func__, upload_hdb.buf_type);
1049 return -EINVAL;
1050 }
1051
1052 if ((diag_buffer->status != MPI3MR_HDB_BUFSTATUS_RELEASED) &&
1053 (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED)) {
1054 dprint_bsg_err(mrioc,
1055 "%s: invalid buffer status %d for type %d\n",
1056 __func__, diag_buffer->status, upload_hdb.buf_type);
1057 return -EINVAL;
1058 }
1059
1060 if ((upload_hdb.start_offset + upload_hdb.length) > diag_buffer->size) {
1061 dprint_bsg_err(mrioc,
1062 "%s: invalid start offset %d, length %d for type %d\n",
1063 __func__, upload_hdb.start_offset, upload_hdb.length,
1064 upload_hdb.buf_type);
1065 return -EINVAL;
1066 }
1067 sg_copy_from_buffer(job->reply_payload.sg_list,
1068 job->reply_payload.sg_cnt,
1069 (diag_buffer->addr + upload_hdb.start_offset),
1070 data_in_size);
1071 return 0;
1072 }
1073
1074 /**
1075 * mpi3mr_bsg_repost_hdb - Re-post HDB
1076 * @mrioc: Adapter instance reference
1077 * @job: BSG job pointer
1078 *
1079 * This function retrieves the HDB descriptor corresponding to a
1080 * given buffer type and if the HDB is in released status then
1081 * posts the HDB with the firmware.
1082 *
1083 * Return: 0 on success and proper error codes on failure
1084 */
mpi3mr_bsg_repost_hdb(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1085 static long mpi3mr_bsg_repost_hdb(struct mpi3mr_ioc *mrioc,
1086 struct bsg_job *job)
1087 {
1088 struct mpi3mr_bsg_out_repost_hdb repost_hdb;
1089 struct diag_buffer_desc *diag_buffer;
1090 uint32_t data_out_sz;
1091
1092 data_out_sz = job->request_payload.payload_len;
1093
1094 if (data_out_sz != sizeof(repost_hdb)) {
1095 dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1096 __func__);
1097 return -EINVAL;
1098 }
1099 if (mrioc->unrecoverable) {
1100 dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
1101 __func__);
1102 return -EFAULT;
1103 }
1104 if (mrioc->reset_in_progress) {
1105 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
1106 return -EAGAIN;
1107 }
1108
1109 sg_copy_to_buffer(job->request_payload.sg_list,
1110 job->request_payload.sg_cnt,
1111 &repost_hdb, sizeof(repost_hdb));
1112
1113 diag_buffer = mpi3mr_diag_buffer_for_type(mrioc, repost_hdb.buf_type);
1114 if ((!diag_buffer) || (!diag_buffer->addr)) {
1115 dprint_bsg_err(mrioc, "%s: invalid buffer type %d\n",
1116 __func__, repost_hdb.buf_type);
1117 return -EINVAL;
1118 }
1119
1120 if (diag_buffer->status != MPI3MR_HDB_BUFSTATUS_RELEASED) {
1121 dprint_bsg_err(mrioc,
1122 "%s: invalid buffer status %d for type %d\n",
1123 __func__, diag_buffer->status, repost_hdb.buf_type);
1124 return -EINVAL;
1125 }
1126
1127 if (mpi3mr_issue_diag_buf_post(mrioc, diag_buffer)) {
1128 dprint_bsg_err(mrioc, "%s: post failed for type %d\n",
1129 __func__, repost_hdb.buf_type);
1130 return -EFAULT;
1131 }
1132 mpi3mr_set_trigger_data_in_hdb(diag_buffer,
1133 MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN, NULL, 1);
1134
1135 return 0;
1136 }
1137
1138 /**
1139 * mpi3mr_bsg_query_hdb - Handler for query HDB command
1140 * @mrioc: Adapter instance reference
1141 * @job: BSG job pointer
1142 *
1143 * This function prepares and copies the host diagnostic buffer
1144 * entries to the user buffer.
1145 *
1146 * Return: 0 on success and proper error codes on failure
1147 */
mpi3mr_bsg_query_hdb(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1148 static long mpi3mr_bsg_query_hdb(struct mpi3mr_ioc *mrioc,
1149 struct bsg_job *job)
1150 {
1151 long rval = 0;
1152 struct mpi3mr_bsg_in_hdb_status *hbd_status;
1153 struct mpi3mr_hdb_entry *hbd_status_entry;
1154 u32 length, min_length;
1155 u8 i;
1156 struct diag_buffer_desc *diag_buffer;
1157 uint32_t data_in_sz = 0;
1158
1159 data_in_sz = job->request_payload.payload_len;
1160
1161 length = (sizeof(*hbd_status) + ((MPI3MR_MAX_NUM_HDB - 1) *
1162 sizeof(*hbd_status_entry)));
1163 hbd_status = kmalloc(length, GFP_KERNEL);
1164 if (!hbd_status)
1165 return -ENOMEM;
1166 hbd_status_entry = &hbd_status->entry[0];
1167
1168 hbd_status->num_hdb_types = MPI3MR_MAX_NUM_HDB;
1169 for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
1170 diag_buffer = &mrioc->diag_buffers[i];
1171 hbd_status_entry->buf_type = diag_buffer->type;
1172 hbd_status_entry->status = diag_buffer->status;
1173 hbd_status_entry->trigger_type = diag_buffer->trigger_type;
1174 memcpy(&hbd_status_entry->trigger_data,
1175 &diag_buffer->trigger_data,
1176 sizeof(hbd_status_entry->trigger_data));
1177 hbd_status_entry->size = (diag_buffer->size / 1024);
1178 hbd_status_entry++;
1179 }
1180 hbd_status->element_trigger_format =
1181 MPI3MR_HDB_QUERY_ELEMENT_TRIGGER_FORMAT_DATA;
1182
1183 if (data_in_sz < 4) {
1184 dprint_bsg_err(mrioc, "%s: invalid size passed\n", __func__);
1185 rval = -EINVAL;
1186 goto out;
1187 }
1188 min_length = min(data_in_sz, length);
1189 if (job->request_payload.payload_len >= min_length) {
1190 sg_copy_from_buffer(job->request_payload.sg_list,
1191 job->request_payload.sg_cnt,
1192 hbd_status, min_length);
1193 rval = 0;
1194 }
1195 out:
1196 kfree(hbd_status);
1197 return rval;
1198 }
1199
1200
1201 /**
1202 * mpi3mr_enable_logdata - Handler for log data enable
1203 * @mrioc: Adapter instance reference
1204 * @job: BSG job reference
1205 *
1206 * This function enables log data caching in the driver if not
1207 * already enabled and return the maximum number of log data
1208 * entries that can be cached in the driver.
1209 *
1210 * Return: 0 on success and proper error codes on failure
1211 */
mpi3mr_enable_logdata(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1212 static long mpi3mr_enable_logdata(struct mpi3mr_ioc *mrioc,
1213 struct bsg_job *job)
1214 {
1215 struct mpi3mr_logdata_enable logdata_enable;
1216
1217 if (!mrioc->logdata_buf) {
1218 mrioc->logdata_entry_sz =
1219 (mrioc->reply_sz - (sizeof(struct mpi3_event_notification_reply) - 4))
1220 + MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ;
1221 mrioc->logdata_buf_idx = 0;
1222 mrioc->logdata_buf = kcalloc(MPI3MR_BSG_LOGDATA_MAX_ENTRIES,
1223 mrioc->logdata_entry_sz, GFP_KERNEL);
1224
1225 if (!mrioc->logdata_buf)
1226 return -ENOMEM;
1227 }
1228
1229 memset(&logdata_enable, 0, sizeof(logdata_enable));
1230 logdata_enable.max_entries =
1231 MPI3MR_BSG_LOGDATA_MAX_ENTRIES;
1232 if (job->request_payload.payload_len >= sizeof(logdata_enable)) {
1233 sg_copy_from_buffer(job->request_payload.sg_list,
1234 job->request_payload.sg_cnt,
1235 &logdata_enable, sizeof(logdata_enable));
1236 return 0;
1237 }
1238
1239 return -EINVAL;
1240 }
1241 /**
1242 * mpi3mr_get_logdata - Handler for get log data
1243 * @mrioc: Adapter instance reference
1244 * @job: BSG job pointer
1245 * This function copies the log data entries to the user buffer
1246 * when log caching is enabled in the driver.
1247 *
1248 * Return: 0 on success and proper error codes on failure
1249 */
mpi3mr_get_logdata(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1250 static long mpi3mr_get_logdata(struct mpi3mr_ioc *mrioc,
1251 struct bsg_job *job)
1252 {
1253 u16 num_entries, sz, entry_sz = mrioc->logdata_entry_sz;
1254
1255 if ((!mrioc->logdata_buf) || (job->request_payload.payload_len < entry_sz))
1256 return -EINVAL;
1257
1258 num_entries = job->request_payload.payload_len / entry_sz;
1259 if (num_entries > MPI3MR_BSG_LOGDATA_MAX_ENTRIES)
1260 num_entries = MPI3MR_BSG_LOGDATA_MAX_ENTRIES;
1261 sz = num_entries * entry_sz;
1262
1263 if (job->request_payload.payload_len >= sz) {
1264 sg_copy_from_buffer(job->request_payload.sg_list,
1265 job->request_payload.sg_cnt,
1266 mrioc->logdata_buf, sz);
1267 return 0;
1268 }
1269 return -EINVAL;
1270 }
1271
1272 /**
1273 * mpi3mr_bsg_pel_enable - Handler for PEL enable driver
1274 * @mrioc: Adapter instance reference
1275 * @job: BSG job pointer
1276 *
1277 * This function is the handler for PEL enable driver.
1278 * Validates the application given class and locale and if
1279 * requires aborts the existing PEL wait request and/or issues
1280 * new PEL wait request to the firmware and returns.
1281 *
1282 * Return: 0 on success and proper error codes on failure.
1283 */
mpi3mr_bsg_pel_enable(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1284 static long mpi3mr_bsg_pel_enable(struct mpi3mr_ioc *mrioc,
1285 struct bsg_job *job)
1286 {
1287 long rval = -EINVAL;
1288 struct mpi3mr_bsg_out_pel_enable pel_enable;
1289 u8 issue_pel_wait;
1290 u8 tmp_class;
1291 u16 tmp_locale;
1292
1293 if (job->request_payload.payload_len != sizeof(pel_enable)) {
1294 dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1295 __func__);
1296 return rval;
1297 }
1298
1299 if (mrioc->unrecoverable) {
1300 dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
1301 __func__);
1302 return -EFAULT;
1303 }
1304
1305 if (mrioc->reset_in_progress) {
1306 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
1307 return -EAGAIN;
1308 }
1309
1310 if (mrioc->stop_bsgs) {
1311 dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
1312 return -EAGAIN;
1313 }
1314
1315 sg_copy_to_buffer(job->request_payload.sg_list,
1316 job->request_payload.sg_cnt,
1317 &pel_enable, sizeof(pel_enable));
1318
1319 if (pel_enable.pel_class > MPI3_PEL_CLASS_FAULT) {
1320 dprint_bsg_err(mrioc, "%s: out of range class %d sent\n",
1321 __func__, pel_enable.pel_class);
1322 rval = 0;
1323 goto out;
1324 }
1325 if (!mrioc->pel_enabled)
1326 issue_pel_wait = 1;
1327 else {
1328 if ((mrioc->pel_class <= pel_enable.pel_class) &&
1329 !((mrioc->pel_locale & pel_enable.pel_locale) ^
1330 pel_enable.pel_locale)) {
1331 issue_pel_wait = 0;
1332 rval = 0;
1333 } else {
1334 pel_enable.pel_locale |= mrioc->pel_locale;
1335
1336 if (mrioc->pel_class < pel_enable.pel_class)
1337 pel_enable.pel_class = mrioc->pel_class;
1338
1339 rval = mpi3mr_bsg_pel_abort(mrioc);
1340 if (rval) {
1341 dprint_bsg_err(mrioc,
1342 "%s: pel_abort failed, status(%ld)\n",
1343 __func__, rval);
1344 goto out;
1345 }
1346 issue_pel_wait = 1;
1347 }
1348 }
1349 if (issue_pel_wait) {
1350 tmp_class = mrioc->pel_class;
1351 tmp_locale = mrioc->pel_locale;
1352 mrioc->pel_class = pel_enable.pel_class;
1353 mrioc->pel_locale = pel_enable.pel_locale;
1354 mrioc->pel_enabled = 1;
1355 rval = mpi3mr_pel_get_seqnum_post(mrioc, NULL);
1356 if (rval) {
1357 mrioc->pel_class = tmp_class;
1358 mrioc->pel_locale = tmp_locale;
1359 mrioc->pel_enabled = 0;
1360 dprint_bsg_err(mrioc,
1361 "%s: pel get sequence number failed, status(%ld)\n",
1362 __func__, rval);
1363 }
1364 }
1365
1366 out:
1367 return rval;
1368 }
1369 /**
1370 * mpi3mr_get_all_tgt_info - Get all target information
1371 * @mrioc: Adapter instance reference
1372 * @job: BSG job reference
1373 *
1374 * This function copies the driver managed target devices device
1375 * handle, persistent ID, bus ID and taret ID to the user
1376 * provided buffer for the specific controller. This function
1377 * also provides the number of devices managed by the driver for
1378 * the specific controller.
1379 *
1380 * Return: 0 on success and proper error codes on failure
1381 */
mpi3mr_get_all_tgt_info(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1382 static long mpi3mr_get_all_tgt_info(struct mpi3mr_ioc *mrioc,
1383 struct bsg_job *job)
1384 {
1385 u16 num_devices = 0, i = 0, size;
1386 unsigned long flags;
1387 struct mpi3mr_tgt_dev *tgtdev;
1388 struct mpi3mr_device_map_info *devmap_info = NULL;
1389 struct mpi3mr_all_tgt_info *alltgt_info = NULL;
1390 uint32_t min_entrylen = 0, kern_entrylen = 0, usr_entrylen = 0;
1391
1392 if (job->request_payload.payload_len < sizeof(u32)) {
1393 dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1394 __func__);
1395 return -EINVAL;
1396 }
1397
1398 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
1399 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list)
1400 num_devices++;
1401 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
1402
1403 if ((job->request_payload.payload_len <= sizeof(u64)) ||
1404 list_empty(&mrioc->tgtdev_list)) {
1405 sg_copy_from_buffer(job->request_payload.sg_list,
1406 job->request_payload.sg_cnt,
1407 &num_devices, sizeof(num_devices));
1408 return 0;
1409 }
1410
1411 kern_entrylen = num_devices * sizeof(*devmap_info);
1412 size = sizeof(u64) + kern_entrylen;
1413 alltgt_info = kzalloc(size, GFP_KERNEL);
1414 if (!alltgt_info)
1415 return -ENOMEM;
1416
1417 devmap_info = alltgt_info->dmi;
1418 memset((u8 *)devmap_info, 0xFF, kern_entrylen);
1419 spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
1420 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) {
1421 if (i < num_devices) {
1422 devmap_info[i].handle = tgtdev->dev_handle;
1423 devmap_info[i].perst_id = tgtdev->perst_id;
1424 if (tgtdev->host_exposed && tgtdev->starget) {
1425 devmap_info[i].target_id = tgtdev->starget->id;
1426 devmap_info[i].bus_id =
1427 tgtdev->starget->channel;
1428 }
1429 i++;
1430 }
1431 }
1432 num_devices = i;
1433 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
1434
1435 alltgt_info->num_devices = num_devices;
1436
1437 usr_entrylen = (job->request_payload.payload_len - sizeof(u64)) /
1438 sizeof(*devmap_info);
1439 usr_entrylen *= sizeof(*devmap_info);
1440 min_entrylen = min(usr_entrylen, kern_entrylen);
1441
1442 sg_copy_from_buffer(job->request_payload.sg_list,
1443 job->request_payload.sg_cnt,
1444 alltgt_info, (min_entrylen + sizeof(u64)));
1445 kfree(alltgt_info);
1446 return 0;
1447 }
1448 /**
1449 * mpi3mr_get_change_count - Get topology change count
1450 * @mrioc: Adapter instance reference
1451 * @job: BSG job reference
1452 *
1453 * This function copies the toplogy change count provided by the
1454 * driver in events and cached in the driver to the user
1455 * provided buffer for the specific controller.
1456 *
1457 * Return: 0 on success and proper error codes on failure
1458 */
mpi3mr_get_change_count(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1459 static long mpi3mr_get_change_count(struct mpi3mr_ioc *mrioc,
1460 struct bsg_job *job)
1461 {
1462 struct mpi3mr_change_count chgcnt;
1463
1464 memset(&chgcnt, 0, sizeof(chgcnt));
1465 chgcnt.change_count = mrioc->change_count;
1466 if (job->request_payload.payload_len >= sizeof(chgcnt)) {
1467 sg_copy_from_buffer(job->request_payload.sg_list,
1468 job->request_payload.sg_cnt,
1469 &chgcnt, sizeof(chgcnt));
1470 return 0;
1471 }
1472 return -EINVAL;
1473 }
1474
1475 /**
1476 * mpi3mr_bsg_adp_reset - Issue controller reset
1477 * @mrioc: Adapter instance reference
1478 * @job: BSG job reference
1479 *
1480 * This function identifies the user provided reset type and
1481 * issues approporiate reset to the controller and wait for that
1482 * to complete and reinitialize the controller and then returns
1483 *
1484 * Return: 0 on success and proper error codes on failure
1485 */
mpi3mr_bsg_adp_reset(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1486 static long mpi3mr_bsg_adp_reset(struct mpi3mr_ioc *mrioc,
1487 struct bsg_job *job)
1488 {
1489 long rval = -EINVAL;
1490 u8 save_snapdump;
1491 struct mpi3mr_bsg_adp_reset adpreset;
1492
1493 if (job->request_payload.payload_len !=
1494 sizeof(adpreset)) {
1495 dprint_bsg_err(mrioc, "%s: invalid size argument\n",
1496 __func__);
1497 goto out;
1498 }
1499
1500 if (mrioc->unrecoverable || mrioc->block_on_pci_err)
1501 return -EINVAL;
1502
1503 sg_copy_to_buffer(job->request_payload.sg_list,
1504 job->request_payload.sg_cnt,
1505 &adpreset, sizeof(adpreset));
1506
1507 switch (adpreset.reset_type) {
1508 case MPI3MR_BSG_ADPRESET_SOFT:
1509 save_snapdump = 0;
1510 break;
1511 case MPI3MR_BSG_ADPRESET_DIAG_FAULT:
1512 save_snapdump = 1;
1513 break;
1514 default:
1515 dprint_bsg_err(mrioc, "%s: unknown reset_type(%d)\n",
1516 __func__, adpreset.reset_type);
1517 goto out;
1518 }
1519
1520 rval = mpi3mr_soft_reset_handler(mrioc, MPI3MR_RESET_FROM_APP,
1521 save_snapdump);
1522
1523 if (rval)
1524 dprint_bsg_err(mrioc,
1525 "%s: reset handler returned error(%ld) for reset type %d\n",
1526 __func__, rval, adpreset.reset_type);
1527 out:
1528 return rval;
1529 }
1530
1531 /**
1532 * mpi3mr_bsg_populate_adpinfo - Get adapter info command handler
1533 * @mrioc: Adapter instance reference
1534 * @job: BSG job reference
1535 *
1536 * This function provides adapter information for the given
1537 * controller
1538 *
1539 * Return: 0 on success and proper error codes on failure
1540 */
mpi3mr_bsg_populate_adpinfo(struct mpi3mr_ioc * mrioc,struct bsg_job * job)1541 static long mpi3mr_bsg_populate_adpinfo(struct mpi3mr_ioc *mrioc,
1542 struct bsg_job *job)
1543 {
1544 enum mpi3mr_iocstate ioc_state;
1545 struct mpi3mr_bsg_in_adpinfo adpinfo;
1546
1547 memset(&adpinfo, 0, sizeof(adpinfo));
1548 adpinfo.adp_type = MPI3MR_BSG_ADPTYPE_AVGFAMILY;
1549 adpinfo.pci_dev_id = mrioc->pdev->device;
1550 adpinfo.pci_dev_hw_rev = mrioc->pdev->revision;
1551 adpinfo.pci_subsys_dev_id = mrioc->pdev->subsystem_device;
1552 adpinfo.pci_subsys_ven_id = mrioc->pdev->subsystem_vendor;
1553 adpinfo.pci_bus = mrioc->pdev->bus->number;
1554 adpinfo.pci_dev = PCI_SLOT(mrioc->pdev->devfn);
1555 adpinfo.pci_func = PCI_FUNC(mrioc->pdev->devfn);
1556 adpinfo.pci_seg_id = pci_domain_nr(mrioc->pdev->bus);
1557 adpinfo.app_intfc_ver = MPI3MR_IOCTL_VERSION;
1558
1559 ioc_state = mpi3mr_get_iocstate(mrioc);
1560 if (ioc_state == MRIOC_STATE_UNRECOVERABLE)
1561 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE;
1562 else if ((mrioc->reset_in_progress) || (mrioc->stop_bsgs))
1563 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET;
1564 else if (ioc_state == MRIOC_STATE_FAULT)
1565 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_FAULT;
1566 else
1567 adpinfo.adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL;
1568
1569 memcpy((u8 *)&adpinfo.driver_info, (u8 *)&mrioc->driver_info,
1570 sizeof(adpinfo.driver_info));
1571
1572 if (job->request_payload.payload_len >= sizeof(adpinfo)) {
1573 sg_copy_from_buffer(job->request_payload.sg_list,
1574 job->request_payload.sg_cnt,
1575 &adpinfo, sizeof(adpinfo));
1576 return 0;
1577 }
1578 return -EINVAL;
1579 }
1580
1581 /**
1582 * mpi3mr_bsg_process_drv_cmds - Driver Command handler
1583 * @job: BSG job reference
1584 *
1585 * This function is the top level handler for driver commands,
1586 * this does basic validation of the buffer and identifies the
1587 * opcode and switches to correct sub handler.
1588 *
1589 * Return: 0 on success and proper error codes on failure
1590 */
mpi3mr_bsg_process_drv_cmds(struct bsg_job * job)1591 static long mpi3mr_bsg_process_drv_cmds(struct bsg_job *job)
1592 {
1593 long rval = -EINVAL;
1594 struct mpi3mr_ioc *mrioc = NULL;
1595 struct mpi3mr_bsg_packet *bsg_req = NULL;
1596 struct mpi3mr_bsg_drv_cmd *drvrcmd = NULL;
1597
1598 bsg_req = job->request;
1599 drvrcmd = &bsg_req->cmd.drvrcmd;
1600
1601 mrioc = mpi3mr_bsg_verify_adapter(drvrcmd->mrioc_id);
1602 if (!mrioc)
1603 return -ENODEV;
1604
1605 if (drvrcmd->opcode == MPI3MR_DRVBSG_OPCODE_ADPINFO) {
1606 rval = mpi3mr_bsg_populate_adpinfo(mrioc, job);
1607 return rval;
1608 }
1609
1610 if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex))
1611 return -ERESTARTSYS;
1612
1613 switch (drvrcmd->opcode) {
1614 case MPI3MR_DRVBSG_OPCODE_ADPRESET:
1615 rval = mpi3mr_bsg_adp_reset(mrioc, job);
1616 break;
1617 case MPI3MR_DRVBSG_OPCODE_ALLTGTDEVINFO:
1618 rval = mpi3mr_get_all_tgt_info(mrioc, job);
1619 break;
1620 case MPI3MR_DRVBSG_OPCODE_GETCHGCNT:
1621 rval = mpi3mr_get_change_count(mrioc, job);
1622 break;
1623 case MPI3MR_DRVBSG_OPCODE_LOGDATAENABLE:
1624 rval = mpi3mr_enable_logdata(mrioc, job);
1625 break;
1626 case MPI3MR_DRVBSG_OPCODE_GETLOGDATA:
1627 rval = mpi3mr_get_logdata(mrioc, job);
1628 break;
1629 case MPI3MR_DRVBSG_OPCODE_PELENABLE:
1630 rval = mpi3mr_bsg_pel_enable(mrioc, job);
1631 break;
1632 case MPI3MR_DRVBSG_OPCODE_QUERY_HDB:
1633 rval = mpi3mr_bsg_query_hdb(mrioc, job);
1634 break;
1635 case MPI3MR_DRVBSG_OPCODE_REPOST_HDB:
1636 rval = mpi3mr_bsg_repost_hdb(mrioc, job);
1637 break;
1638 case MPI3MR_DRVBSG_OPCODE_UPLOAD_HDB:
1639 rval = mpi3mr_bsg_upload_hdb(mrioc, job);
1640 break;
1641 case MPI3MR_DRVBSG_OPCODE_REFRESH_HDB_TRIGGERS:
1642 rval = mpi3mr_bsg_refresh_hdb_triggers(mrioc, job);
1643 break;
1644 case MPI3MR_DRVBSG_OPCODE_UNKNOWN:
1645 default:
1646 pr_err("%s: unsupported driver command opcode %d\n",
1647 MPI3MR_DRIVER_NAME, drvrcmd->opcode);
1648 break;
1649 }
1650 mutex_unlock(&mrioc->bsg_cmds.mutex);
1651 return rval;
1652 }
1653
1654 /**
1655 * mpi3mr_total_num_ioctl_sges - Count number of SGEs required
1656 * @drv_bufs: DMA address of the buffers to be placed in sgl
1657 * @bufcnt: Number of DMA buffers
1658 *
1659 * This function returns total number of data SGEs required
1660 * including zero length SGEs and excluding management request
1661 * and response buffer for the given list of data buffer
1662 * descriptors
1663 *
1664 * Return: Number of SGE elements needed
1665 */
mpi3mr_total_num_ioctl_sges(struct mpi3mr_buf_map * drv_bufs,u8 bufcnt)1666 static inline u16 mpi3mr_total_num_ioctl_sges(struct mpi3mr_buf_map *drv_bufs,
1667 u8 bufcnt)
1668 {
1669 u16 i, sge_count = 0;
1670
1671 for (i = 0; i < bufcnt; i++, drv_bufs++) {
1672 if (drv_bufs->data_dir == DMA_NONE ||
1673 drv_bufs->kern_buf)
1674 continue;
1675 sge_count += drv_bufs->num_dma_desc;
1676 if (!drv_bufs->num_dma_desc)
1677 sge_count++;
1678 }
1679 return sge_count;
1680 }
1681
1682 /**
1683 * mpi3mr_bsg_build_sgl - SGL construction for MPI commands
1684 * @mrioc: Adapter instance reference
1685 * @mpi_req: MPI request
1686 * @sgl_offset: offset to start sgl in the MPI request
1687 * @drv_bufs: DMA address of the buffers to be placed in sgl
1688 * @bufcnt: Number of DMA buffers
1689 * @is_rmc: Does the buffer list has management command buffer
1690 * @is_rmr: Does the buffer list has management response buffer
1691 * @num_datasges: Number of data buffers in the list
1692 *
1693 * This function places the DMA address of the given buffers in
1694 * proper format as SGEs in the given MPI request.
1695 *
1696 * Return: 0 on success,-1 on failure
1697 */
mpi3mr_bsg_build_sgl(struct mpi3mr_ioc * mrioc,u8 * mpi_req,u32 sgl_offset,struct mpi3mr_buf_map * drv_bufs,u8 bufcnt,u8 is_rmc,u8 is_rmr,u8 num_datasges)1698 static int mpi3mr_bsg_build_sgl(struct mpi3mr_ioc *mrioc, u8 *mpi_req,
1699 u32 sgl_offset, struct mpi3mr_buf_map *drv_bufs,
1700 u8 bufcnt, u8 is_rmc, u8 is_rmr, u8 num_datasges)
1701 {
1702 struct mpi3_request_header *mpi_header =
1703 (struct mpi3_request_header *)mpi_req;
1704 u8 *sgl = (mpi_req + sgl_offset), count = 0;
1705 struct mpi3_mgmt_passthrough_request *rmgmt_req =
1706 (struct mpi3_mgmt_passthrough_request *)mpi_req;
1707 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
1708 u8 flag, sgl_flags, sgl_flag_eob, sgl_flags_last, last_chain_sgl_flag;
1709 u16 available_sges, i, sges_needed;
1710 u32 sge_element_size = sizeof(struct mpi3_sge_common);
1711 bool chain_used = false;
1712
1713 sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE |
1714 MPI3_SGE_FLAGS_DLAS_SYSTEM;
1715 sgl_flag_eob = sgl_flags | MPI3_SGE_FLAGS_END_OF_BUFFER;
1716 sgl_flags_last = sgl_flag_eob | MPI3_SGE_FLAGS_END_OF_LIST;
1717 last_chain_sgl_flag = MPI3_SGE_FLAGS_ELEMENT_TYPE_LAST_CHAIN |
1718 MPI3_SGE_FLAGS_DLAS_SYSTEM;
1719
1720 sges_needed = mpi3mr_total_num_ioctl_sges(drv_bufs, bufcnt);
1721
1722 if (is_rmc) {
1723 mpi3mr_add_sg_single(&rmgmt_req->command_sgl,
1724 sgl_flags_last, drv_buf_iter->kern_buf_len,
1725 drv_buf_iter->kern_buf_dma);
1726 sgl = (u8 *)drv_buf_iter->kern_buf +
1727 drv_buf_iter->bsg_buf_len;
1728 available_sges = (drv_buf_iter->kern_buf_len -
1729 drv_buf_iter->bsg_buf_len) / sge_element_size;
1730
1731 if (sges_needed > available_sges)
1732 return -1;
1733
1734 chain_used = true;
1735 drv_buf_iter++;
1736 count++;
1737 if (is_rmr) {
1738 mpi3mr_add_sg_single(&rmgmt_req->response_sgl,
1739 sgl_flags_last, drv_buf_iter->kern_buf_len,
1740 drv_buf_iter->kern_buf_dma);
1741 drv_buf_iter++;
1742 count++;
1743 } else
1744 mpi3mr_build_zero_len_sge(
1745 &rmgmt_req->response_sgl);
1746 if (num_datasges) {
1747 i = 0;
1748 goto build_sges;
1749 }
1750 } else {
1751 if (sgl_offset >= MPI3MR_ADMIN_REQ_FRAME_SZ)
1752 return -1;
1753 available_sges = (MPI3MR_ADMIN_REQ_FRAME_SZ - sgl_offset) /
1754 sge_element_size;
1755 if (!available_sges)
1756 return -1;
1757 }
1758 if (!num_datasges) {
1759 mpi3mr_build_zero_len_sge(sgl);
1760 return 0;
1761 }
1762 if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) {
1763 if ((sges_needed > 2) || (sges_needed > available_sges))
1764 return -1;
1765 for (; count < bufcnt; count++, drv_buf_iter++) {
1766 if (drv_buf_iter->data_dir == DMA_NONE ||
1767 !drv_buf_iter->num_dma_desc)
1768 continue;
1769 mpi3mr_add_sg_single(sgl, sgl_flags_last,
1770 drv_buf_iter->dma_desc[0].size,
1771 drv_buf_iter->dma_desc[0].dma_addr);
1772 sgl += sge_element_size;
1773 }
1774 return 0;
1775 }
1776 i = 0;
1777
1778 build_sges:
1779 for (; count < bufcnt; count++, drv_buf_iter++) {
1780 if (drv_buf_iter->data_dir == DMA_NONE)
1781 continue;
1782 if (!drv_buf_iter->num_dma_desc) {
1783 if (chain_used && !available_sges)
1784 return -1;
1785 if (!chain_used && (available_sges == 1) &&
1786 (sges_needed > 1))
1787 goto setup_chain;
1788 flag = sgl_flag_eob;
1789 if (num_datasges == 1)
1790 flag = sgl_flags_last;
1791 mpi3mr_add_sg_single(sgl, flag, 0, 0);
1792 sgl += sge_element_size;
1793 sges_needed--;
1794 available_sges--;
1795 num_datasges--;
1796 continue;
1797 }
1798 for (; i < drv_buf_iter->num_dma_desc; i++) {
1799 if (chain_used && !available_sges)
1800 return -1;
1801 if (!chain_used && (available_sges == 1) &&
1802 (sges_needed > 1))
1803 goto setup_chain;
1804 flag = sgl_flags;
1805 if (i == (drv_buf_iter->num_dma_desc - 1)) {
1806 if (num_datasges == 1)
1807 flag = sgl_flags_last;
1808 else
1809 flag = sgl_flag_eob;
1810 }
1811
1812 mpi3mr_add_sg_single(sgl, flag,
1813 drv_buf_iter->dma_desc[i].size,
1814 drv_buf_iter->dma_desc[i].dma_addr);
1815 sgl += sge_element_size;
1816 available_sges--;
1817 sges_needed--;
1818 }
1819 num_datasges--;
1820 i = 0;
1821 }
1822 return 0;
1823
1824 setup_chain:
1825 available_sges = mrioc->ioctl_chain_sge.size / sge_element_size;
1826 if (sges_needed > available_sges)
1827 return -1;
1828 mpi3mr_add_sg_single(sgl, last_chain_sgl_flag,
1829 (sges_needed * sge_element_size),
1830 mrioc->ioctl_chain_sge.dma_addr);
1831 memset(mrioc->ioctl_chain_sge.addr, 0, mrioc->ioctl_chain_sge.size);
1832 sgl = (u8 *)mrioc->ioctl_chain_sge.addr;
1833 chain_used = true;
1834 goto build_sges;
1835 }
1836
1837 /**
1838 * mpi3mr_get_nvme_data_fmt - returns the NVMe data format
1839 * @nvme_encap_request: NVMe encapsulated MPI request
1840 *
1841 * This function returns the type of the data format specified
1842 * in user provided NVMe command in NVMe encapsulated request.
1843 *
1844 * Return: Data format of the NVMe command (PRP/SGL etc)
1845 */
mpi3mr_get_nvme_data_fmt(struct mpi3_nvme_encapsulated_request * nvme_encap_request)1846 static unsigned int mpi3mr_get_nvme_data_fmt(
1847 struct mpi3_nvme_encapsulated_request *nvme_encap_request)
1848 {
1849 u8 format = 0;
1850
1851 format = ((nvme_encap_request->command[0] & 0xc000) >> 14);
1852 return format;
1853
1854 }
1855
1856 /**
1857 * mpi3mr_build_nvme_sgl - SGL constructor for NVME
1858 * encapsulated request
1859 * @mrioc: Adapter instance reference
1860 * @nvme_encap_request: NVMe encapsulated MPI request
1861 * @drv_bufs: DMA address of the buffers to be placed in sgl
1862 * @bufcnt: Number of DMA buffers
1863 *
1864 * This function places the DMA address of the given buffers in
1865 * proper format as SGEs in the given NVMe encapsulated request.
1866 *
1867 * Return: 0 on success, -1 on failure
1868 */
mpi3mr_build_nvme_sgl(struct mpi3mr_ioc * mrioc,struct mpi3_nvme_encapsulated_request * nvme_encap_request,struct mpi3mr_buf_map * drv_bufs,u8 bufcnt)1869 static int mpi3mr_build_nvme_sgl(struct mpi3mr_ioc *mrioc,
1870 struct mpi3_nvme_encapsulated_request *nvme_encap_request,
1871 struct mpi3mr_buf_map *drv_bufs, u8 bufcnt)
1872 {
1873 struct mpi3mr_nvme_pt_sge *nvme_sgl;
1874 __le64 sgl_dma;
1875 u8 count;
1876 size_t length = 0;
1877 u16 available_sges = 0, i;
1878 u32 sge_element_size = sizeof(struct mpi3mr_nvme_pt_sge);
1879 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
1880 u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) <<
1881 mrioc->facts.sge_mod_shift) << 32);
1882 u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) <<
1883 mrioc->facts.sge_mod_shift) << 32;
1884 u32 size;
1885
1886 nvme_sgl = (struct mpi3mr_nvme_pt_sge *)
1887 ((u8 *)(nvme_encap_request->command) + MPI3MR_NVME_CMD_SGL_OFFSET);
1888
1889 /*
1890 * Not all commands require a data transfer. If no data, just return
1891 * without constructing any sgl.
1892 */
1893 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
1894 if (drv_buf_iter->data_dir == DMA_NONE)
1895 continue;
1896 length = drv_buf_iter->kern_buf_len;
1897 break;
1898 }
1899 if (!length || !drv_buf_iter->num_dma_desc)
1900 return 0;
1901
1902 if (drv_buf_iter->num_dma_desc == 1) {
1903 available_sges = 1;
1904 goto build_sges;
1905 }
1906
1907 sgl_dma = cpu_to_le64(mrioc->ioctl_chain_sge.dma_addr);
1908 if (sgl_dma & sgemod_mask) {
1909 dprint_bsg_err(mrioc,
1910 "%s: SGL chain address collides with SGE modifier\n",
1911 __func__);
1912 return -1;
1913 }
1914
1915 sgl_dma &= ~sgemod_mask;
1916 sgl_dma |= sgemod_val;
1917
1918 memset(mrioc->ioctl_chain_sge.addr, 0, mrioc->ioctl_chain_sge.size);
1919 available_sges = mrioc->ioctl_chain_sge.size / sge_element_size;
1920 if (available_sges < drv_buf_iter->num_dma_desc)
1921 return -1;
1922 memset(nvme_sgl, 0, sizeof(struct mpi3mr_nvme_pt_sge));
1923 nvme_sgl->base_addr = sgl_dma;
1924 size = drv_buf_iter->num_dma_desc * sizeof(struct mpi3mr_nvme_pt_sge);
1925 nvme_sgl->length = cpu_to_le32(size);
1926 nvme_sgl->type = MPI3MR_NVMESGL_LAST_SEGMENT;
1927 nvme_sgl = (struct mpi3mr_nvme_pt_sge *)mrioc->ioctl_chain_sge.addr;
1928
1929 build_sges:
1930 for (i = 0; i < drv_buf_iter->num_dma_desc; i++) {
1931 sgl_dma = cpu_to_le64(drv_buf_iter->dma_desc[i].dma_addr);
1932 if (sgl_dma & sgemod_mask) {
1933 dprint_bsg_err(mrioc,
1934 "%s: SGL address collides with SGE modifier\n",
1935 __func__);
1936 return -1;
1937 }
1938
1939 sgl_dma &= ~sgemod_mask;
1940 sgl_dma |= sgemod_val;
1941
1942 nvme_sgl->base_addr = sgl_dma;
1943 nvme_sgl->length = cpu_to_le32(drv_buf_iter->dma_desc[i].size);
1944 nvme_sgl->type = MPI3MR_NVMESGL_DATA_SEGMENT;
1945 nvme_sgl++;
1946 available_sges--;
1947 }
1948
1949 return 0;
1950 }
1951
1952 /**
1953 * mpi3mr_build_nvme_prp - PRP constructor for NVME
1954 * encapsulated request
1955 * @mrioc: Adapter instance reference
1956 * @nvme_encap_request: NVMe encapsulated MPI request
1957 * @drv_bufs: DMA address of the buffers to be placed in SGL
1958 * @bufcnt: Number of DMA buffers
1959 *
1960 * This function places the DMA address of the given buffers in
1961 * proper format as PRP entries in the given NVMe encapsulated
1962 * request.
1963 *
1964 * Return: 0 on success, -1 on failure
1965 */
mpi3mr_build_nvme_prp(struct mpi3mr_ioc * mrioc,struct mpi3_nvme_encapsulated_request * nvme_encap_request,struct mpi3mr_buf_map * drv_bufs,u8 bufcnt)1966 static int mpi3mr_build_nvme_prp(struct mpi3mr_ioc *mrioc,
1967 struct mpi3_nvme_encapsulated_request *nvme_encap_request,
1968 struct mpi3mr_buf_map *drv_bufs, u8 bufcnt)
1969 {
1970 int prp_size = MPI3MR_NVME_PRP_SIZE;
1971 __le64 *prp_entry, *prp1_entry, *prp2_entry;
1972 __le64 *prp_page;
1973 dma_addr_t prp_entry_dma, prp_page_dma, dma_addr;
1974 u32 offset, entry_len, dev_pgsz;
1975 u32 page_mask_result, page_mask;
1976 size_t length = 0, desc_len;
1977 u8 count;
1978 struct mpi3mr_buf_map *drv_buf_iter = drv_bufs;
1979 u64 sgemod_mask = ((u64)((mrioc->facts.sge_mod_mask) <<
1980 mrioc->facts.sge_mod_shift) << 32);
1981 u64 sgemod_val = ((u64)(mrioc->facts.sge_mod_value) <<
1982 mrioc->facts.sge_mod_shift) << 32;
1983 u16 dev_handle = nvme_encap_request->dev_handle;
1984 struct mpi3mr_tgt_dev *tgtdev;
1985 u16 desc_count = 0;
1986
1987 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
1988 if (!tgtdev) {
1989 dprint_bsg_err(mrioc, "%s: invalid device handle 0x%04x\n",
1990 __func__, dev_handle);
1991 return -1;
1992 }
1993
1994 if (tgtdev->dev_spec.pcie_inf.pgsz == 0) {
1995 dprint_bsg_err(mrioc,
1996 "%s: NVMe device page size is zero for handle 0x%04x\n",
1997 __func__, dev_handle);
1998 mpi3mr_tgtdev_put(tgtdev);
1999 return -1;
2000 }
2001
2002 dev_pgsz = 1 << (tgtdev->dev_spec.pcie_inf.pgsz);
2003 mpi3mr_tgtdev_put(tgtdev);
2004 page_mask = dev_pgsz - 1;
2005
2006 if (dev_pgsz > MPI3MR_IOCTL_SGE_SIZE) {
2007 dprint_bsg_err(mrioc,
2008 "%s: NVMe device page size(%d) is greater than ioctl data sge size(%d) for handle 0x%04x\n",
2009 __func__, dev_pgsz, MPI3MR_IOCTL_SGE_SIZE, dev_handle);
2010 return -1;
2011 }
2012
2013 if (MPI3MR_IOCTL_SGE_SIZE % dev_pgsz) {
2014 dprint_bsg_err(mrioc,
2015 "%s: ioctl data sge size(%d) is not a multiple of NVMe device page size(%d) for handle 0x%04x\n",
2016 __func__, MPI3MR_IOCTL_SGE_SIZE, dev_pgsz, dev_handle);
2017 return -1;
2018 }
2019
2020 /*
2021 * Not all commands require a data transfer. If no data, just return
2022 * without constructing any PRP.
2023 */
2024 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
2025 if (drv_buf_iter->data_dir == DMA_NONE)
2026 continue;
2027 length = drv_buf_iter->kern_buf_len;
2028 break;
2029 }
2030
2031 if (!length || !drv_buf_iter->num_dma_desc)
2032 return 0;
2033
2034 for (count = 0; count < drv_buf_iter->num_dma_desc; count++) {
2035 dma_addr = drv_buf_iter->dma_desc[count].dma_addr;
2036 if (dma_addr & page_mask) {
2037 dprint_bsg_err(mrioc,
2038 "%s:dma_addr %pad is not aligned with page size 0x%x\n",
2039 __func__, &dma_addr, dev_pgsz);
2040 return -1;
2041 }
2042 }
2043
2044 dma_addr = drv_buf_iter->dma_desc[0].dma_addr;
2045 desc_len = drv_buf_iter->dma_desc[0].size;
2046
2047 mrioc->prp_sz = 0;
2048 mrioc->prp_list_virt = dma_alloc_coherent(&mrioc->pdev->dev,
2049 dev_pgsz, &mrioc->prp_list_dma, GFP_KERNEL);
2050
2051 if (!mrioc->prp_list_virt)
2052 return -1;
2053 mrioc->prp_sz = dev_pgsz;
2054
2055 /*
2056 * Set pointers to PRP1 and PRP2, which are in the NVMe command.
2057 * PRP1 is located at a 24 byte offset from the start of the NVMe
2058 * command. Then set the current PRP entry pointer to PRP1.
2059 */
2060 prp1_entry = (__le64 *)((u8 *)(nvme_encap_request->command) +
2061 MPI3MR_NVME_CMD_PRP1_OFFSET);
2062 prp2_entry = (__le64 *)((u8 *)(nvme_encap_request->command) +
2063 MPI3MR_NVME_CMD_PRP2_OFFSET);
2064 prp_entry = prp1_entry;
2065 /*
2066 * For the PRP entries, use the specially allocated buffer of
2067 * contiguous memory.
2068 */
2069 prp_page = (__le64 *)mrioc->prp_list_virt;
2070 prp_page_dma = mrioc->prp_list_dma;
2071
2072 /*
2073 * Check if we are within 1 entry of a page boundary we don't
2074 * want our first entry to be a PRP List entry.
2075 */
2076 page_mask_result = (uintptr_t)((u8 *)prp_page + prp_size) & page_mask;
2077 if (!page_mask_result) {
2078 dprint_bsg_err(mrioc, "%s: PRP page is not page aligned\n",
2079 __func__);
2080 goto err_out;
2081 }
2082
2083 /*
2084 * Set PRP physical pointer, which initially points to the current PRP
2085 * DMA memory page.
2086 */
2087 prp_entry_dma = prp_page_dma;
2088
2089
2090 /* Loop while the length is not zero. */
2091 while (length) {
2092 page_mask_result = (prp_entry_dma + prp_size) & page_mask;
2093 if (!page_mask_result && (length > dev_pgsz)) {
2094 dprint_bsg_err(mrioc,
2095 "%s: single PRP page is not sufficient\n",
2096 __func__);
2097 goto err_out;
2098 }
2099
2100 /* Need to handle if entry will be part of a page. */
2101 offset = dma_addr & page_mask;
2102 entry_len = dev_pgsz - offset;
2103
2104 if (prp_entry == prp1_entry) {
2105 /*
2106 * Must fill in the first PRP pointer (PRP1) before
2107 * moving on.
2108 */
2109 *prp1_entry = cpu_to_le64(dma_addr);
2110 if (*prp1_entry & sgemod_mask) {
2111 dprint_bsg_err(mrioc,
2112 "%s: PRP1 address collides with SGE modifier\n",
2113 __func__);
2114 goto err_out;
2115 }
2116 *prp1_entry &= ~sgemod_mask;
2117 *prp1_entry |= sgemod_val;
2118
2119 /*
2120 * Now point to the second PRP entry within the
2121 * command (PRP2).
2122 */
2123 prp_entry = prp2_entry;
2124 } else if (prp_entry == prp2_entry) {
2125 /*
2126 * Should the PRP2 entry be a PRP List pointer or just
2127 * a regular PRP pointer? If there is more than one
2128 * more page of data, must use a PRP List pointer.
2129 */
2130 if (length > dev_pgsz) {
2131 /*
2132 * PRP2 will contain a PRP List pointer because
2133 * more PRP's are needed with this command. The
2134 * list will start at the beginning of the
2135 * contiguous buffer.
2136 */
2137 *prp2_entry = cpu_to_le64(prp_entry_dma);
2138 if (*prp2_entry & sgemod_mask) {
2139 dprint_bsg_err(mrioc,
2140 "%s: PRP list address collides with SGE modifier\n",
2141 __func__);
2142 goto err_out;
2143 }
2144 *prp2_entry &= ~sgemod_mask;
2145 *prp2_entry |= sgemod_val;
2146
2147 /*
2148 * The next PRP Entry will be the start of the
2149 * first PRP List.
2150 */
2151 prp_entry = prp_page;
2152 continue;
2153 } else {
2154 /*
2155 * After this, the PRP Entries are complete.
2156 * This command uses 2 PRP's and no PRP list.
2157 */
2158 *prp2_entry = cpu_to_le64(dma_addr);
2159 if (*prp2_entry & sgemod_mask) {
2160 dprint_bsg_err(mrioc,
2161 "%s: PRP2 collides with SGE modifier\n",
2162 __func__);
2163 goto err_out;
2164 }
2165 *prp2_entry &= ~sgemod_mask;
2166 *prp2_entry |= sgemod_val;
2167 }
2168 } else {
2169 /*
2170 * Put entry in list and bump the addresses.
2171 *
2172 * After PRP1 and PRP2 are filled in, this will fill in
2173 * all remaining PRP entries in a PRP List, one per
2174 * each time through the loop.
2175 */
2176 *prp_entry = cpu_to_le64(dma_addr);
2177 if (*prp_entry & sgemod_mask) {
2178 dprint_bsg_err(mrioc,
2179 "%s: PRP address collides with SGE modifier\n",
2180 __func__);
2181 goto err_out;
2182 }
2183 *prp_entry &= ~sgemod_mask;
2184 *prp_entry |= sgemod_val;
2185 prp_entry++;
2186 prp_entry_dma += prp_size;
2187 }
2188
2189 /* decrement length accounting for last partial page. */
2190 if (entry_len >= length) {
2191 length = 0;
2192 } else {
2193 if (entry_len <= desc_len) {
2194 dma_addr += entry_len;
2195 desc_len -= entry_len;
2196 }
2197 if (!desc_len) {
2198 if ((++desc_count) >=
2199 drv_buf_iter->num_dma_desc) {
2200 dprint_bsg_err(mrioc,
2201 "%s: Invalid len %zd while building PRP\n",
2202 __func__, length);
2203 goto err_out;
2204 }
2205 dma_addr =
2206 drv_buf_iter->dma_desc[desc_count].dma_addr;
2207 desc_len =
2208 drv_buf_iter->dma_desc[desc_count].size;
2209 }
2210 length -= entry_len;
2211 }
2212 }
2213
2214 return 0;
2215 err_out:
2216 if (mrioc->prp_list_virt) {
2217 dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz,
2218 mrioc->prp_list_virt, mrioc->prp_list_dma);
2219 mrioc->prp_list_virt = NULL;
2220 }
2221 return -1;
2222 }
2223
2224 /**
2225 * mpi3mr_map_data_buffer_dma - build dma descriptors for data
2226 * buffers
2227 * @mrioc: Adapter instance reference
2228 * @drv_buf: buffer map descriptor
2229 * @desc_count: Number of already consumed dma descriptors
2230 *
2231 * This function computes how many pre-allocated DMA descriptors
2232 * are required for the given data buffer and if those number of
2233 * descriptors are free, then setup the mapping of the scattered
2234 * DMA address to the given data buffer, if the data direction
2235 * of the buffer is DMA_TO_DEVICE then the actual data is copied to
2236 * the DMA buffers
2237 *
2238 * Return: 0 on success, -1 on failure
2239 */
mpi3mr_map_data_buffer_dma(struct mpi3mr_ioc * mrioc,struct mpi3mr_buf_map * drv_buf,u16 desc_count)2240 static int mpi3mr_map_data_buffer_dma(struct mpi3mr_ioc *mrioc,
2241 struct mpi3mr_buf_map *drv_buf,
2242 u16 desc_count)
2243 {
2244 u16 i, needed_desc = drv_buf->kern_buf_len / MPI3MR_IOCTL_SGE_SIZE;
2245 u32 buf_len = drv_buf->kern_buf_len, copied_len = 0;
2246
2247 if (drv_buf->kern_buf_len % MPI3MR_IOCTL_SGE_SIZE)
2248 needed_desc++;
2249 if ((needed_desc + desc_count) > MPI3MR_NUM_IOCTL_SGE) {
2250 dprint_bsg_err(mrioc, "%s: DMA descriptor mapping error %d:%d:%d\n",
2251 __func__, needed_desc, desc_count, MPI3MR_NUM_IOCTL_SGE);
2252 return -1;
2253 }
2254 drv_buf->dma_desc = kzalloc(sizeof(*drv_buf->dma_desc) * needed_desc,
2255 GFP_KERNEL);
2256 if (!drv_buf->dma_desc)
2257 return -1;
2258 for (i = 0; i < needed_desc; i++, desc_count++) {
2259 drv_buf->dma_desc[i].addr = mrioc->ioctl_sge[desc_count].addr;
2260 drv_buf->dma_desc[i].dma_addr =
2261 mrioc->ioctl_sge[desc_count].dma_addr;
2262 if (buf_len < mrioc->ioctl_sge[desc_count].size)
2263 drv_buf->dma_desc[i].size = buf_len;
2264 else
2265 drv_buf->dma_desc[i].size =
2266 mrioc->ioctl_sge[desc_count].size;
2267 buf_len -= drv_buf->dma_desc[i].size;
2268 memset(drv_buf->dma_desc[i].addr, 0,
2269 mrioc->ioctl_sge[desc_count].size);
2270 if (drv_buf->data_dir == DMA_TO_DEVICE) {
2271 memcpy(drv_buf->dma_desc[i].addr,
2272 drv_buf->bsg_buf + copied_len,
2273 drv_buf->dma_desc[i].size);
2274 copied_len += drv_buf->dma_desc[i].size;
2275 }
2276 }
2277 drv_buf->num_dma_desc = needed_desc;
2278 return 0;
2279 }
2280 /**
2281 * mpi3mr_bsg_process_mpt_cmds - MPI Pass through BSG handler
2282 * @job: BSG job reference
2283 *
2284 * This function is the top level handler for MPI Pass through
2285 * command, this does basic validation of the input data buffers,
2286 * identifies the given buffer types and MPI command, allocates
2287 * DMAable memory for user given buffers, construstcs SGL
2288 * properly and passes the command to the firmware.
2289 *
2290 * Once the MPI command is completed the driver copies the data
2291 * if any and reply, sense information to user provided buffers.
2292 * If the command is timed out then issues controller reset
2293 * prior to returning.
2294 *
2295 * Return: 0 on success and proper error codes on failure
2296 */
2297
mpi3mr_bsg_process_mpt_cmds(struct bsg_job * job)2298 static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
2299 {
2300 long rval = -EINVAL;
2301 struct mpi3mr_ioc *mrioc = NULL;
2302 u8 *mpi_req = NULL, *sense_buff_k = NULL;
2303 u8 mpi_msg_size = 0;
2304 struct mpi3mr_bsg_packet *bsg_req = NULL;
2305 struct mpi3mr_bsg_mptcmd *karg;
2306 struct mpi3mr_buf_entry *buf_entries = NULL;
2307 struct mpi3mr_buf_map *drv_bufs = NULL, *drv_buf_iter = NULL;
2308 u8 count, bufcnt = 0, is_rmcb = 0, is_rmrb = 0;
2309 u8 din_cnt = 0, dout_cnt = 0;
2310 u8 invalid_be = 0, erb_offset = 0xFF, mpirep_offset = 0xFF;
2311 u8 block_io = 0, nvme_fmt = 0, resp_code = 0;
2312 struct mpi3_request_header *mpi_header = NULL;
2313 struct mpi3_status_reply_descriptor *status_desc;
2314 struct mpi3_scsi_task_mgmt_request *tm_req;
2315 u32 erbsz = MPI3MR_SENSE_BUF_SZ, tmplen;
2316 u16 dev_handle;
2317 struct mpi3mr_tgt_dev *tgtdev;
2318 struct mpi3mr_stgt_priv_data *stgt_priv = NULL;
2319 struct mpi3mr_bsg_in_reply_buf *bsg_reply_buf = NULL;
2320 u32 din_size = 0, dout_size = 0;
2321 u8 *din_buf = NULL, *dout_buf = NULL;
2322 u8 *sgl_iter = NULL, *sgl_din_iter = NULL, *sgl_dout_iter = NULL;
2323 u16 rmc_size = 0, desc_count = 0;
2324
2325 bsg_req = job->request;
2326 karg = (struct mpi3mr_bsg_mptcmd *)&bsg_req->cmd.mptcmd;
2327
2328 mrioc = mpi3mr_bsg_verify_adapter(karg->mrioc_id);
2329 if (!mrioc)
2330 return -ENODEV;
2331
2332 if (!mrioc->ioctl_sges_allocated) {
2333 dprint_bsg_err(mrioc, "%s: DMA memory was not allocated\n",
2334 __func__);
2335 return -ENOMEM;
2336 }
2337
2338 if (karg->timeout < MPI3MR_APP_DEFAULT_TIMEOUT)
2339 karg->timeout = MPI3MR_APP_DEFAULT_TIMEOUT;
2340
2341 mpi_req = kzalloc(MPI3MR_ADMIN_REQ_FRAME_SZ, GFP_KERNEL);
2342 if (!mpi_req)
2343 return -ENOMEM;
2344 mpi_header = (struct mpi3_request_header *)mpi_req;
2345
2346 bufcnt = karg->buf_entry_list.num_of_entries;
2347 drv_bufs = kzalloc((sizeof(*drv_bufs) * bufcnt), GFP_KERNEL);
2348 if (!drv_bufs) {
2349 rval = -ENOMEM;
2350 goto out;
2351 }
2352
2353 dout_buf = kzalloc(job->request_payload.payload_len,
2354 GFP_KERNEL);
2355 if (!dout_buf) {
2356 rval = -ENOMEM;
2357 goto out;
2358 }
2359
2360 din_buf = kzalloc(job->reply_payload.payload_len,
2361 GFP_KERNEL);
2362 if (!din_buf) {
2363 rval = -ENOMEM;
2364 goto out;
2365 }
2366
2367 sg_copy_to_buffer(job->request_payload.sg_list,
2368 job->request_payload.sg_cnt,
2369 dout_buf, job->request_payload.payload_len);
2370
2371 buf_entries = karg->buf_entry_list.buf_entry;
2372 sgl_din_iter = din_buf;
2373 sgl_dout_iter = dout_buf;
2374 drv_buf_iter = drv_bufs;
2375
2376 for (count = 0; count < bufcnt; count++, buf_entries++, drv_buf_iter++) {
2377
2378 switch (buf_entries->buf_type) {
2379 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD:
2380 sgl_iter = sgl_dout_iter;
2381 sgl_dout_iter += buf_entries->buf_len;
2382 drv_buf_iter->data_dir = DMA_TO_DEVICE;
2383 is_rmcb = 1;
2384 if ((count != 0) || !buf_entries->buf_len)
2385 invalid_be = 1;
2386 break;
2387 case MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP:
2388 sgl_iter = sgl_din_iter;
2389 sgl_din_iter += buf_entries->buf_len;
2390 drv_buf_iter->data_dir = DMA_FROM_DEVICE;
2391 is_rmrb = 1;
2392 if (count != 1 || !is_rmcb || !buf_entries->buf_len)
2393 invalid_be = 1;
2394 break;
2395 case MPI3MR_BSG_BUFTYPE_DATA_IN:
2396 sgl_iter = sgl_din_iter;
2397 sgl_din_iter += buf_entries->buf_len;
2398 drv_buf_iter->data_dir = DMA_FROM_DEVICE;
2399 din_cnt++;
2400 din_size += buf_entries->buf_len;
2401 if ((din_cnt > 1) && !is_rmcb)
2402 invalid_be = 1;
2403 break;
2404 case MPI3MR_BSG_BUFTYPE_DATA_OUT:
2405 sgl_iter = sgl_dout_iter;
2406 sgl_dout_iter += buf_entries->buf_len;
2407 drv_buf_iter->data_dir = DMA_TO_DEVICE;
2408 dout_cnt++;
2409 dout_size += buf_entries->buf_len;
2410 if ((dout_cnt > 1) && !is_rmcb)
2411 invalid_be = 1;
2412 break;
2413 case MPI3MR_BSG_BUFTYPE_MPI_REPLY:
2414 sgl_iter = sgl_din_iter;
2415 sgl_din_iter += buf_entries->buf_len;
2416 drv_buf_iter->data_dir = DMA_NONE;
2417 mpirep_offset = count;
2418 if (!buf_entries->buf_len)
2419 invalid_be = 1;
2420 break;
2421 case MPI3MR_BSG_BUFTYPE_ERR_RESPONSE:
2422 sgl_iter = sgl_din_iter;
2423 sgl_din_iter += buf_entries->buf_len;
2424 drv_buf_iter->data_dir = DMA_NONE;
2425 erb_offset = count;
2426 if (!buf_entries->buf_len)
2427 invalid_be = 1;
2428 break;
2429 case MPI3MR_BSG_BUFTYPE_MPI_REQUEST:
2430 sgl_iter = sgl_dout_iter;
2431 sgl_dout_iter += buf_entries->buf_len;
2432 drv_buf_iter->data_dir = DMA_NONE;
2433 mpi_msg_size = buf_entries->buf_len;
2434 if ((!mpi_msg_size || (mpi_msg_size % 4)) ||
2435 (mpi_msg_size > MPI3MR_ADMIN_REQ_FRAME_SZ)) {
2436 dprint_bsg_err(mrioc, "%s: invalid MPI message size\n",
2437 __func__);
2438 rval = -EINVAL;
2439 goto out;
2440 }
2441 memcpy(mpi_req, sgl_iter, buf_entries->buf_len);
2442 break;
2443 default:
2444 invalid_be = 1;
2445 break;
2446 }
2447 if (invalid_be) {
2448 dprint_bsg_err(mrioc, "%s: invalid buffer entries passed\n",
2449 __func__);
2450 rval = -EINVAL;
2451 goto out;
2452 }
2453
2454 if (sgl_dout_iter > (dout_buf + job->request_payload.payload_len)) {
2455 dprint_bsg_err(mrioc, "%s: data_out buffer length mismatch\n",
2456 __func__);
2457 rval = -EINVAL;
2458 goto out;
2459 }
2460 if (sgl_din_iter > (din_buf + job->reply_payload.payload_len)) {
2461 dprint_bsg_err(mrioc, "%s: data_in buffer length mismatch\n",
2462 __func__);
2463 rval = -EINVAL;
2464 goto out;
2465 }
2466
2467 drv_buf_iter->bsg_buf = sgl_iter;
2468 drv_buf_iter->bsg_buf_len = buf_entries->buf_len;
2469 }
2470
2471 if (is_rmcb && ((din_size + dout_size) > MPI3MR_MAX_APP_XFER_SIZE)) {
2472 dprint_bsg_err(mrioc, "%s:%d: invalid data transfer size passed for function 0x%x din_size = %d, dout_size = %d\n",
2473 __func__, __LINE__, mpi_header->function, din_size,
2474 dout_size);
2475 rval = -EINVAL;
2476 goto out;
2477 }
2478
2479 if (din_size > MPI3MR_MAX_APP_XFER_SIZE) {
2480 dprint_bsg_err(mrioc,
2481 "%s:%d: invalid data transfer size passed for function 0x%x din_size=%d\n",
2482 __func__, __LINE__, mpi_header->function, din_size);
2483 rval = -EINVAL;
2484 goto out;
2485 }
2486 if (dout_size > MPI3MR_MAX_APP_XFER_SIZE) {
2487 dprint_bsg_err(mrioc,
2488 "%s:%d: invalid data transfer size passed for function 0x%x dout_size = %d\n",
2489 __func__, __LINE__, mpi_header->function, dout_size);
2490 rval = -EINVAL;
2491 goto out;
2492 }
2493
2494 if (mpi_header->function == MPI3_BSG_FUNCTION_SMP_PASSTHROUGH) {
2495 if (din_size > MPI3MR_IOCTL_SGE_SIZE ||
2496 dout_size > MPI3MR_IOCTL_SGE_SIZE) {
2497 dprint_bsg_err(mrioc, "%s:%d: invalid message size passed:%d:%d:%d:%d\n",
2498 __func__, __LINE__, din_cnt, dout_cnt, din_size,
2499 dout_size);
2500 rval = -EINVAL;
2501 goto out;
2502 }
2503 }
2504
2505 drv_buf_iter = drv_bufs;
2506 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
2507 if (drv_buf_iter->data_dir == DMA_NONE)
2508 continue;
2509
2510 drv_buf_iter->kern_buf_len = drv_buf_iter->bsg_buf_len;
2511 if (is_rmcb && !count) {
2512 drv_buf_iter->kern_buf_len =
2513 mrioc->ioctl_chain_sge.size;
2514 drv_buf_iter->kern_buf =
2515 mrioc->ioctl_chain_sge.addr;
2516 drv_buf_iter->kern_buf_dma =
2517 mrioc->ioctl_chain_sge.dma_addr;
2518 drv_buf_iter->dma_desc = NULL;
2519 drv_buf_iter->num_dma_desc = 0;
2520 memset(drv_buf_iter->kern_buf, 0,
2521 drv_buf_iter->kern_buf_len);
2522 tmplen = min(drv_buf_iter->kern_buf_len,
2523 drv_buf_iter->bsg_buf_len);
2524 rmc_size = tmplen;
2525 memcpy(drv_buf_iter->kern_buf, drv_buf_iter->bsg_buf, tmplen);
2526 } else if (is_rmrb && (count == 1)) {
2527 drv_buf_iter->kern_buf_len =
2528 mrioc->ioctl_resp_sge.size;
2529 drv_buf_iter->kern_buf =
2530 mrioc->ioctl_resp_sge.addr;
2531 drv_buf_iter->kern_buf_dma =
2532 mrioc->ioctl_resp_sge.dma_addr;
2533 drv_buf_iter->dma_desc = NULL;
2534 drv_buf_iter->num_dma_desc = 0;
2535 memset(drv_buf_iter->kern_buf, 0,
2536 drv_buf_iter->kern_buf_len);
2537 tmplen = min(drv_buf_iter->kern_buf_len,
2538 drv_buf_iter->bsg_buf_len);
2539 drv_buf_iter->kern_buf_len = tmplen;
2540 memset(drv_buf_iter->bsg_buf, 0,
2541 drv_buf_iter->bsg_buf_len);
2542 } else {
2543 if (!drv_buf_iter->kern_buf_len)
2544 continue;
2545 if (mpi3mr_map_data_buffer_dma(mrioc, drv_buf_iter, desc_count)) {
2546 rval = -ENOMEM;
2547 dprint_bsg_err(mrioc, "%s:%d: mapping data buffers failed\n",
2548 __func__, __LINE__);
2549 goto out;
2550 }
2551 desc_count += drv_buf_iter->num_dma_desc;
2552 }
2553 }
2554
2555 if (erb_offset != 0xFF) {
2556 sense_buff_k = kzalloc(erbsz, GFP_KERNEL);
2557 if (!sense_buff_k) {
2558 rval = -ENOMEM;
2559 goto out;
2560 }
2561 }
2562
2563 if (mutex_lock_interruptible(&mrioc->bsg_cmds.mutex)) {
2564 rval = -ERESTARTSYS;
2565 goto out;
2566 }
2567 if (mrioc->bsg_cmds.state & MPI3MR_CMD_PENDING) {
2568 rval = -EAGAIN;
2569 dprint_bsg_err(mrioc, "%s: command is in use\n", __func__);
2570 mutex_unlock(&mrioc->bsg_cmds.mutex);
2571 goto out;
2572 }
2573 if (mrioc->unrecoverable) {
2574 dprint_bsg_err(mrioc, "%s: unrecoverable controller\n",
2575 __func__);
2576 rval = -EFAULT;
2577 mutex_unlock(&mrioc->bsg_cmds.mutex);
2578 goto out;
2579 }
2580 if (mrioc->reset_in_progress) {
2581 dprint_bsg_err(mrioc, "%s: reset in progress\n", __func__);
2582 rval = -EAGAIN;
2583 mutex_unlock(&mrioc->bsg_cmds.mutex);
2584 goto out;
2585 }
2586 if (mrioc->stop_bsgs || mrioc->block_on_pci_err) {
2587 dprint_bsg_err(mrioc, "%s: bsgs are blocked\n", __func__);
2588 rval = -EAGAIN;
2589 mutex_unlock(&mrioc->bsg_cmds.mutex);
2590 goto out;
2591 }
2592
2593 if (mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) {
2594 nvme_fmt = mpi3mr_get_nvme_data_fmt(
2595 (struct mpi3_nvme_encapsulated_request *)mpi_req);
2596 if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_PRP) {
2597 if (mpi3mr_build_nvme_prp(mrioc,
2598 (struct mpi3_nvme_encapsulated_request *)mpi_req,
2599 drv_bufs, bufcnt)) {
2600 rval = -ENOMEM;
2601 mutex_unlock(&mrioc->bsg_cmds.mutex);
2602 goto out;
2603 }
2604 } else if (nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL1 ||
2605 nvme_fmt == MPI3MR_NVME_DATA_FORMAT_SGL2) {
2606 if (mpi3mr_build_nvme_sgl(mrioc,
2607 (struct mpi3_nvme_encapsulated_request *)mpi_req,
2608 drv_bufs, bufcnt)) {
2609 rval = -EINVAL;
2610 mutex_unlock(&mrioc->bsg_cmds.mutex);
2611 goto out;
2612 }
2613 } else {
2614 dprint_bsg_err(mrioc,
2615 "%s:invalid NVMe command format\n", __func__);
2616 rval = -EINVAL;
2617 mutex_unlock(&mrioc->bsg_cmds.mutex);
2618 goto out;
2619 }
2620 } else {
2621 if (mpi3mr_bsg_build_sgl(mrioc, mpi_req, mpi_msg_size,
2622 drv_bufs, bufcnt, is_rmcb, is_rmrb,
2623 (dout_cnt + din_cnt))) {
2624 dprint_bsg_err(mrioc, "%s: sgl build failed\n", __func__);
2625 rval = -EAGAIN;
2626 mutex_unlock(&mrioc->bsg_cmds.mutex);
2627 goto out;
2628 }
2629 }
2630
2631 if (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_TASK_MGMT) {
2632 tm_req = (struct mpi3_scsi_task_mgmt_request *)mpi_req;
2633 if (tm_req->task_type !=
2634 MPI3_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
2635 dev_handle = tm_req->dev_handle;
2636 block_io = 1;
2637 }
2638 }
2639 if (block_io) {
2640 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
2641 if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) {
2642 stgt_priv = (struct mpi3mr_stgt_priv_data *)
2643 tgtdev->starget->hostdata;
2644 atomic_inc(&stgt_priv->block_io);
2645 mpi3mr_tgtdev_put(tgtdev);
2646 }
2647 }
2648
2649 mrioc->bsg_cmds.state = MPI3MR_CMD_PENDING;
2650 mrioc->bsg_cmds.is_waiting = 1;
2651 mrioc->bsg_cmds.callback = NULL;
2652 mrioc->bsg_cmds.is_sense = 0;
2653 mrioc->bsg_cmds.sensebuf = sense_buff_k;
2654 memset(mrioc->bsg_cmds.reply, 0, mrioc->reply_sz);
2655 mpi_header->host_tag = cpu_to_le16(MPI3MR_HOSTTAG_BSG_CMDS);
2656 if (mrioc->logging_level & MPI3_DEBUG_BSG_INFO) {
2657 dprint_bsg_info(mrioc,
2658 "%s: posting bsg request to the controller\n", __func__);
2659 dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ,
2660 "bsg_mpi3_req");
2661 if (mpi_header->function == MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH) {
2662 drv_buf_iter = &drv_bufs[0];
2663 dprint_dump(drv_buf_iter->kern_buf,
2664 rmc_size, "mpi3_mgmt_req");
2665 }
2666 }
2667
2668 init_completion(&mrioc->bsg_cmds.done);
2669 rval = mpi3mr_admin_request_post(mrioc, mpi_req,
2670 MPI3MR_ADMIN_REQ_FRAME_SZ, 0);
2671
2672
2673 if (rval) {
2674 mrioc->bsg_cmds.is_waiting = 0;
2675 dprint_bsg_err(mrioc,
2676 "%s: posting bsg request is failed\n", __func__);
2677 rval = -EAGAIN;
2678 goto out_unlock;
2679 }
2680 wait_for_completion_timeout(&mrioc->bsg_cmds.done,
2681 (karg->timeout * HZ));
2682 if (block_io && stgt_priv)
2683 atomic_dec(&stgt_priv->block_io);
2684 if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE)) {
2685 mrioc->bsg_cmds.is_waiting = 0;
2686 rval = -EAGAIN;
2687 if (mrioc->bsg_cmds.state & MPI3MR_CMD_RESET)
2688 goto out_unlock;
2689 if (((mpi_header->function != MPI3_FUNCTION_SCSI_IO) &&
2690 (mpi_header->function != MPI3_FUNCTION_NVME_ENCAPSULATED))
2691 || (mrioc->logging_level & MPI3_DEBUG_BSG_ERROR)) {
2692 ioc_info(mrioc, "%s: bsg request timedout after %d seconds\n",
2693 __func__, karg->timeout);
2694 if (!(mrioc->logging_level & MPI3_DEBUG_BSG_INFO)) {
2695 dprint_dump(mpi_req, MPI3MR_ADMIN_REQ_FRAME_SZ,
2696 "bsg_mpi3_req");
2697 if (mpi_header->function ==
2698 MPI3_FUNCTION_MGMT_PASSTHROUGH) {
2699 drv_buf_iter = &drv_bufs[0];
2700 dprint_dump(drv_buf_iter->kern_buf,
2701 rmc_size, "mpi3_mgmt_req");
2702 }
2703 }
2704 }
2705 if ((mpi_header->function == MPI3_BSG_FUNCTION_NVME_ENCAPSULATED) ||
2706 (mpi_header->function == MPI3_BSG_FUNCTION_SCSI_IO)) {
2707 dprint_bsg_err(mrioc, "%s: bsg request timedout after %d seconds,\n"
2708 "issuing target reset to (0x%04x)\n", __func__,
2709 karg->timeout, mpi_header->function_dependent);
2710 mpi3mr_issue_tm(mrioc,
2711 MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
2712 mpi_header->function_dependent, 0,
2713 MPI3MR_HOSTTAG_BLK_TMS, MPI3MR_RESETTM_TIMEOUT,
2714 &mrioc->host_tm_cmds, &resp_code, NULL);
2715 }
2716 if (!(mrioc->bsg_cmds.state & MPI3MR_CMD_COMPLETE) &&
2717 !(mrioc->bsg_cmds.state & MPI3MR_CMD_RESET))
2718 mpi3mr_soft_reset_handler(mrioc,
2719 MPI3MR_RESET_FROM_APP_TIMEOUT, 1);
2720 goto out_unlock;
2721 }
2722 dprint_bsg_info(mrioc, "%s: bsg request is completed\n", __func__);
2723
2724 if (mrioc->prp_list_virt) {
2725 dma_free_coherent(&mrioc->pdev->dev, mrioc->prp_sz,
2726 mrioc->prp_list_virt, mrioc->prp_list_dma);
2727 mrioc->prp_list_virt = NULL;
2728 }
2729
2730 if ((mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK)
2731 != MPI3_IOCSTATUS_SUCCESS) {
2732 dprint_bsg_info(mrioc,
2733 "%s: command failed, ioc_status(0x%04x) log_info(0x%08x)\n",
2734 __func__,
2735 (mrioc->bsg_cmds.ioc_status & MPI3_IOCSTATUS_STATUS_MASK),
2736 mrioc->bsg_cmds.ioc_loginfo);
2737 }
2738
2739 if ((mpirep_offset != 0xFF) &&
2740 drv_bufs[mpirep_offset].bsg_buf_len) {
2741 drv_buf_iter = &drv_bufs[mpirep_offset];
2742 drv_buf_iter->kern_buf_len = (sizeof(*bsg_reply_buf) +
2743 mrioc->reply_sz);
2744 bsg_reply_buf = kzalloc(drv_buf_iter->kern_buf_len, GFP_KERNEL);
2745
2746 if (!bsg_reply_buf) {
2747 rval = -ENOMEM;
2748 goto out_unlock;
2749 }
2750 if (mrioc->bsg_cmds.state & MPI3MR_CMD_REPLY_VALID) {
2751 bsg_reply_buf->mpi_reply_type =
2752 MPI3MR_BSG_MPI_REPLY_BUFTYPE_ADDRESS;
2753 memcpy(bsg_reply_buf->reply_buf,
2754 mrioc->bsg_cmds.reply, mrioc->reply_sz);
2755 } else {
2756 bsg_reply_buf->mpi_reply_type =
2757 MPI3MR_BSG_MPI_REPLY_BUFTYPE_STATUS;
2758 status_desc = (struct mpi3_status_reply_descriptor *)
2759 bsg_reply_buf->reply_buf;
2760 status_desc->ioc_status = mrioc->bsg_cmds.ioc_status;
2761 status_desc->ioc_log_info = mrioc->bsg_cmds.ioc_loginfo;
2762 }
2763 tmplen = min(drv_buf_iter->kern_buf_len,
2764 drv_buf_iter->bsg_buf_len);
2765 memcpy(drv_buf_iter->bsg_buf, bsg_reply_buf, tmplen);
2766 }
2767
2768 if (erb_offset != 0xFF && mrioc->bsg_cmds.sensebuf &&
2769 mrioc->bsg_cmds.is_sense) {
2770 drv_buf_iter = &drv_bufs[erb_offset];
2771 tmplen = min(erbsz, drv_buf_iter->bsg_buf_len);
2772 memcpy(drv_buf_iter->bsg_buf, sense_buff_k, tmplen);
2773 }
2774
2775 drv_buf_iter = drv_bufs;
2776 for (count = 0; count < bufcnt; count++, drv_buf_iter++) {
2777 if (drv_buf_iter->data_dir == DMA_NONE)
2778 continue;
2779 if ((count == 1) && is_rmrb) {
2780 memcpy(drv_buf_iter->bsg_buf,
2781 drv_buf_iter->kern_buf,
2782 drv_buf_iter->kern_buf_len);
2783 } else if (drv_buf_iter->data_dir == DMA_FROM_DEVICE) {
2784 tmplen = 0;
2785 for (desc_count = 0;
2786 desc_count < drv_buf_iter->num_dma_desc;
2787 desc_count++) {
2788 memcpy(((u8 *)drv_buf_iter->bsg_buf + tmplen),
2789 drv_buf_iter->dma_desc[desc_count].addr,
2790 drv_buf_iter->dma_desc[desc_count].size);
2791 tmplen +=
2792 drv_buf_iter->dma_desc[desc_count].size;
2793 }
2794 }
2795 }
2796
2797 out_unlock:
2798 if (din_buf) {
2799 job->reply_payload_rcv_len =
2800 sg_copy_from_buffer(job->reply_payload.sg_list,
2801 job->reply_payload.sg_cnt,
2802 din_buf, job->reply_payload.payload_len);
2803 }
2804 mrioc->bsg_cmds.is_sense = 0;
2805 mrioc->bsg_cmds.sensebuf = NULL;
2806 mrioc->bsg_cmds.state = MPI3MR_CMD_NOTUSED;
2807 mutex_unlock(&mrioc->bsg_cmds.mutex);
2808 out:
2809 kfree(sense_buff_k);
2810 kfree(dout_buf);
2811 kfree(din_buf);
2812 kfree(mpi_req);
2813 if (drv_bufs) {
2814 drv_buf_iter = drv_bufs;
2815 for (count = 0; count < bufcnt; count++, drv_buf_iter++)
2816 kfree(drv_buf_iter->dma_desc);
2817 kfree(drv_bufs);
2818 }
2819 kfree(bsg_reply_buf);
2820 return rval;
2821 }
2822
2823 /**
2824 * mpi3mr_app_save_logdata - Save Log Data events
2825 * @mrioc: Adapter instance reference
2826 * @event_data: event data associated with log data event
2827 * @event_data_size: event data size to copy
2828 *
2829 * If log data event caching is enabled by the applicatiobns,
2830 * then this function saves the log data in the circular queue
2831 * and Sends async signal SIGIO to indicate there is an async
2832 * event from the firmware to the event monitoring applications.
2833 *
2834 * Return:Nothing
2835 */
mpi3mr_app_save_logdata(struct mpi3mr_ioc * mrioc,char * event_data,u16 event_data_size)2836 void mpi3mr_app_save_logdata(struct mpi3mr_ioc *mrioc, char *event_data,
2837 u16 event_data_size)
2838 {
2839 u32 index = mrioc->logdata_buf_idx, sz;
2840 struct mpi3mr_logdata_entry *entry;
2841
2842 if (!(mrioc->logdata_buf))
2843 return;
2844
2845 entry = (struct mpi3mr_logdata_entry *)
2846 (mrioc->logdata_buf + (index * mrioc->logdata_entry_sz));
2847 entry->valid_entry = 1;
2848 sz = min(mrioc->logdata_entry_sz, event_data_size);
2849 memcpy(entry->data, event_data, sz);
2850 mrioc->logdata_buf_idx =
2851 ((++index) % MPI3MR_BSG_LOGDATA_MAX_ENTRIES);
2852 atomic64_inc(&event_counter);
2853 }
2854
2855 /**
2856 * mpi3mr_bsg_request - bsg request entry point
2857 * @job: BSG job reference
2858 *
2859 * This is driver's entry point for bsg requests
2860 *
2861 * Return: 0 on success and proper error codes on failure
2862 */
mpi3mr_bsg_request(struct bsg_job * job)2863 static int mpi3mr_bsg_request(struct bsg_job *job)
2864 {
2865 long rval = -EINVAL;
2866 unsigned int reply_payload_rcv_len = 0;
2867
2868 struct mpi3mr_bsg_packet *bsg_req = job->request;
2869
2870 switch (bsg_req->cmd_type) {
2871 case MPI3MR_DRV_CMD:
2872 rval = mpi3mr_bsg_process_drv_cmds(job);
2873 break;
2874 case MPI3MR_MPT_CMD:
2875 rval = mpi3mr_bsg_process_mpt_cmds(job);
2876 break;
2877 default:
2878 pr_err("%s: unsupported BSG command(0x%08x)\n",
2879 MPI3MR_DRIVER_NAME, bsg_req->cmd_type);
2880 break;
2881 }
2882
2883 bsg_job_done(job, rval, reply_payload_rcv_len);
2884
2885 return 0;
2886 }
2887
2888 /**
2889 * mpi3mr_bsg_exit - de-registration from bsg layer
2890 * @mrioc: Adapter instance reference
2891 *
2892 * This will be called during driver unload and all
2893 * bsg resources allocated during load will be freed.
2894 *
2895 * Return:Nothing
2896 */
mpi3mr_bsg_exit(struct mpi3mr_ioc * mrioc)2897 void mpi3mr_bsg_exit(struct mpi3mr_ioc *mrioc)
2898 {
2899 struct device *bsg_dev = &mrioc->bsg_dev;
2900 if (!mrioc->bsg_queue)
2901 return;
2902
2903 bsg_remove_queue(mrioc->bsg_queue);
2904 mrioc->bsg_queue = NULL;
2905
2906 device_del(bsg_dev);
2907 put_device(bsg_dev);
2908 }
2909
2910 /**
2911 * mpi3mr_bsg_node_release -release bsg device node
2912 * @dev: bsg device node
2913 *
2914 * decrements bsg dev parent reference count
2915 *
2916 * Return:Nothing
2917 */
mpi3mr_bsg_node_release(struct device * dev)2918 static void mpi3mr_bsg_node_release(struct device *dev)
2919 {
2920 put_device(dev->parent);
2921 }
2922
2923 /**
2924 * mpi3mr_bsg_init - registration with bsg layer
2925 * @mrioc: Adapter instance reference
2926 *
2927 * This will be called during driver load and it will
2928 * register driver with bsg layer
2929 *
2930 * Return:Nothing
2931 */
mpi3mr_bsg_init(struct mpi3mr_ioc * mrioc)2932 void mpi3mr_bsg_init(struct mpi3mr_ioc *mrioc)
2933 {
2934 struct device *bsg_dev = &mrioc->bsg_dev;
2935 struct device *parent = &mrioc->shost->shost_gendev;
2936 struct queue_limits lim = {
2937 .max_hw_sectors = MPI3MR_MAX_APP_XFER_SECTORS,
2938 .max_segments = MPI3MR_MAX_APP_XFER_SEGMENTS,
2939 };
2940
2941 device_initialize(bsg_dev);
2942
2943 bsg_dev->parent = get_device(parent);
2944 bsg_dev->release = mpi3mr_bsg_node_release;
2945
2946 dev_set_name(bsg_dev, "mpi3mrctl%u", mrioc->id);
2947
2948 if (device_add(bsg_dev)) {
2949 ioc_err(mrioc, "%s: bsg device add failed\n",
2950 dev_name(bsg_dev));
2951 put_device(bsg_dev);
2952 return;
2953 }
2954
2955 mrioc->bsg_queue = bsg_setup_queue(bsg_dev, dev_name(bsg_dev), &lim,
2956 mpi3mr_bsg_request, NULL, 0);
2957 if (IS_ERR(mrioc->bsg_queue)) {
2958 ioc_err(mrioc, "%s: bsg registration failed\n",
2959 dev_name(bsg_dev));
2960 device_del(bsg_dev);
2961 put_device(bsg_dev);
2962 }
2963 }
2964
2965 /**
2966 * version_fw_show - SysFS callback for firmware version read
2967 * @dev: class device
2968 * @attr: Device attributes
2969 * @buf: Buffer to copy
2970 *
2971 * Return: sysfs_emit() return after copying firmware version
2972 */
2973 static ssize_t
version_fw_show(struct device * dev,struct device_attribute * attr,char * buf)2974 version_fw_show(struct device *dev, struct device_attribute *attr,
2975 char *buf)
2976 {
2977 struct Scsi_Host *shost = class_to_shost(dev);
2978 struct mpi3mr_ioc *mrioc = shost_priv(shost);
2979 struct mpi3mr_compimg_ver *fwver = &mrioc->facts.fw_ver;
2980
2981 return sysfs_emit(buf, "%d.%d.%d.%d.%05d-%05d\n",
2982 fwver->gen_major, fwver->gen_minor, fwver->ph_major,
2983 fwver->ph_minor, fwver->cust_id, fwver->build_num);
2984 }
2985 static DEVICE_ATTR_RO(version_fw);
2986
2987 /**
2988 * fw_queue_depth_show - SysFS callback for firmware max cmds
2989 * @dev: class device
2990 * @attr: Device attributes
2991 * @buf: Buffer to copy
2992 *
2993 * Return: sysfs_emit() return after copying firmware max commands
2994 */
2995 static ssize_t
fw_queue_depth_show(struct device * dev,struct device_attribute * attr,char * buf)2996 fw_queue_depth_show(struct device *dev, struct device_attribute *attr,
2997 char *buf)
2998 {
2999 struct Scsi_Host *shost = class_to_shost(dev);
3000 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3001
3002 return sysfs_emit(buf, "%d\n", mrioc->facts.max_reqs);
3003 }
3004 static DEVICE_ATTR_RO(fw_queue_depth);
3005
3006 /**
3007 * op_req_q_count_show - SysFS callback for request queue count
3008 * @dev: class device
3009 * @attr: Device attributes
3010 * @buf: Buffer to copy
3011 *
3012 * Return: sysfs_emit() return after copying request queue count
3013 */
3014 static ssize_t
op_req_q_count_show(struct device * dev,struct device_attribute * attr,char * buf)3015 op_req_q_count_show(struct device *dev, struct device_attribute *attr,
3016 char *buf)
3017 {
3018 struct Scsi_Host *shost = class_to_shost(dev);
3019 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3020
3021 return sysfs_emit(buf, "%d\n", mrioc->num_op_req_q);
3022 }
3023 static DEVICE_ATTR_RO(op_req_q_count);
3024
3025 /**
3026 * reply_queue_count_show - SysFS callback for reply queue count
3027 * @dev: class device
3028 * @attr: Device attributes
3029 * @buf: Buffer to copy
3030 *
3031 * Return: sysfs_emit() return after copying reply queue count
3032 */
3033 static ssize_t
reply_queue_count_show(struct device * dev,struct device_attribute * attr,char * buf)3034 reply_queue_count_show(struct device *dev, struct device_attribute *attr,
3035 char *buf)
3036 {
3037 struct Scsi_Host *shost = class_to_shost(dev);
3038 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3039
3040 return sysfs_emit(buf, "%d\n", mrioc->num_op_reply_q);
3041 }
3042
3043 static DEVICE_ATTR_RO(reply_queue_count);
3044
3045 /**
3046 * logging_level_show - Show controller debug level
3047 * @dev: class device
3048 * @attr: Device attributes
3049 * @buf: Buffer to copy
3050 *
3051 * A sysfs 'read/write' shost attribute, to show the current
3052 * debug log level used by the driver for the specific
3053 * controller.
3054 *
3055 * Return: sysfs_emit() return
3056 */
3057 static ssize_t
logging_level_show(struct device * dev,struct device_attribute * attr,char * buf)3058 logging_level_show(struct device *dev,
3059 struct device_attribute *attr, char *buf)
3060
3061 {
3062 struct Scsi_Host *shost = class_to_shost(dev);
3063 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3064
3065 return sysfs_emit(buf, "%08xh\n", mrioc->logging_level);
3066 }
3067
3068 /**
3069 * logging_level_store- Change controller debug level
3070 * @dev: class device
3071 * @attr: Device attributes
3072 * @buf: Buffer to copy
3073 * @count: size of the buffer
3074 *
3075 * A sysfs 'read/write' shost attribute, to change the current
3076 * debug log level used by the driver for the specific
3077 * controller.
3078 *
3079 * Return: strlen() return
3080 */
3081 static ssize_t
logging_level_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3082 logging_level_store(struct device *dev,
3083 struct device_attribute *attr,
3084 const char *buf, size_t count)
3085 {
3086 struct Scsi_Host *shost = class_to_shost(dev);
3087 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3088 int val = 0;
3089
3090 if (kstrtoint(buf, 0, &val) != 0)
3091 return -EINVAL;
3092
3093 mrioc->logging_level = val;
3094 ioc_info(mrioc, "logging_level=%08xh\n", mrioc->logging_level);
3095 return strlen(buf);
3096 }
3097 static DEVICE_ATTR_RW(logging_level);
3098
3099 /**
3100 * adp_state_show() - SysFS callback for adapter state show
3101 * @dev: class device
3102 * @attr: Device attributes
3103 * @buf: Buffer to copy
3104 *
3105 * Return: sysfs_emit() return after copying adapter state
3106 */
3107 static ssize_t
adp_state_show(struct device * dev,struct device_attribute * attr,char * buf)3108 adp_state_show(struct device *dev, struct device_attribute *attr,
3109 char *buf)
3110 {
3111 struct Scsi_Host *shost = class_to_shost(dev);
3112 struct mpi3mr_ioc *mrioc = shost_priv(shost);
3113 enum mpi3mr_iocstate ioc_state;
3114 uint8_t adp_state;
3115
3116 ioc_state = mpi3mr_get_iocstate(mrioc);
3117 if (ioc_state == MRIOC_STATE_UNRECOVERABLE)
3118 adp_state = MPI3MR_BSG_ADPSTATE_UNRECOVERABLE;
3119 else if (mrioc->reset_in_progress || mrioc->stop_bsgs ||
3120 mrioc->block_on_pci_err)
3121 adp_state = MPI3MR_BSG_ADPSTATE_IN_RESET;
3122 else if (ioc_state == MRIOC_STATE_FAULT)
3123 adp_state = MPI3MR_BSG_ADPSTATE_FAULT;
3124 else
3125 adp_state = MPI3MR_BSG_ADPSTATE_OPERATIONAL;
3126
3127 return sysfs_emit(buf, "%u\n", adp_state);
3128 }
3129
3130 static DEVICE_ATTR_RO(adp_state);
3131
3132 static struct attribute *mpi3mr_host_attrs[] = {
3133 &dev_attr_version_fw.attr,
3134 &dev_attr_fw_queue_depth.attr,
3135 &dev_attr_op_req_q_count.attr,
3136 &dev_attr_reply_queue_count.attr,
3137 &dev_attr_logging_level.attr,
3138 &dev_attr_adp_state.attr,
3139 NULL,
3140 };
3141
3142 static const struct attribute_group mpi3mr_host_attr_group = {
3143 .attrs = mpi3mr_host_attrs
3144 };
3145
3146 const struct attribute_group *mpi3mr_host_groups[] = {
3147 &mpi3mr_host_attr_group,
3148 NULL,
3149 };
3150
3151
3152 /*
3153 * SCSI Device attributes under sysfs
3154 */
3155
3156 /**
3157 * sas_address_show - SysFS callback for dev SASaddress display
3158 * @dev: class device
3159 * @attr: Device attributes
3160 * @buf: Buffer to copy
3161 *
3162 * Return: sysfs_emit() return after copying SAS address of the
3163 * specific SAS/SATA end device.
3164 */
3165 static ssize_t
sas_address_show(struct device * dev,struct device_attribute * attr,char * buf)3166 sas_address_show(struct device *dev, struct device_attribute *attr,
3167 char *buf)
3168 {
3169 struct scsi_device *sdev = to_scsi_device(dev);
3170 struct mpi3mr_sdev_priv_data *sdev_priv_data;
3171 struct mpi3mr_stgt_priv_data *tgt_priv_data;
3172 struct mpi3mr_tgt_dev *tgtdev;
3173
3174 sdev_priv_data = sdev->hostdata;
3175 if (!sdev_priv_data)
3176 return 0;
3177
3178 tgt_priv_data = sdev_priv_data->tgt_priv_data;
3179 if (!tgt_priv_data)
3180 return 0;
3181 tgtdev = tgt_priv_data->tgt_dev;
3182 if (!tgtdev || tgtdev->dev_type != MPI3_DEVICE_DEVFORM_SAS_SATA)
3183 return 0;
3184 return sysfs_emit(buf, "0x%016llx\n",
3185 (unsigned long long)tgtdev->dev_spec.sas_sata_inf.sas_address);
3186 }
3187
3188 static DEVICE_ATTR_RO(sas_address);
3189
3190 /**
3191 * device_handle_show - SysFS callback for device handle display
3192 * @dev: class device
3193 * @attr: Device attributes
3194 * @buf: Buffer to copy
3195 *
3196 * Return: sysfs_emit() return after copying firmware internal
3197 * device handle of the specific device.
3198 */
3199 static ssize_t
device_handle_show(struct device * dev,struct device_attribute * attr,char * buf)3200 device_handle_show(struct device *dev, struct device_attribute *attr,
3201 char *buf)
3202 {
3203 struct scsi_device *sdev = to_scsi_device(dev);
3204 struct mpi3mr_sdev_priv_data *sdev_priv_data;
3205 struct mpi3mr_stgt_priv_data *tgt_priv_data;
3206 struct mpi3mr_tgt_dev *tgtdev;
3207
3208 sdev_priv_data = sdev->hostdata;
3209 if (!sdev_priv_data)
3210 return 0;
3211
3212 tgt_priv_data = sdev_priv_data->tgt_priv_data;
3213 if (!tgt_priv_data)
3214 return 0;
3215 tgtdev = tgt_priv_data->tgt_dev;
3216 if (!tgtdev)
3217 return 0;
3218 return sysfs_emit(buf, "0x%04x\n", tgtdev->dev_handle);
3219 }
3220
3221 static DEVICE_ATTR_RO(device_handle);
3222
3223 /**
3224 * persistent_id_show - SysFS callback for persisten ID display
3225 * @dev: class device
3226 * @attr: Device attributes
3227 * @buf: Buffer to copy
3228 *
3229 * Return: sysfs_emit() return after copying persistent ID of the
3230 * of the specific device.
3231 */
3232 static ssize_t
persistent_id_show(struct device * dev,struct device_attribute * attr,char * buf)3233 persistent_id_show(struct device *dev, struct device_attribute *attr,
3234 char *buf)
3235 {
3236 struct scsi_device *sdev = to_scsi_device(dev);
3237 struct mpi3mr_sdev_priv_data *sdev_priv_data;
3238 struct mpi3mr_stgt_priv_data *tgt_priv_data;
3239 struct mpi3mr_tgt_dev *tgtdev;
3240
3241 sdev_priv_data = sdev->hostdata;
3242 if (!sdev_priv_data)
3243 return 0;
3244
3245 tgt_priv_data = sdev_priv_data->tgt_priv_data;
3246 if (!tgt_priv_data)
3247 return 0;
3248 tgtdev = tgt_priv_data->tgt_dev;
3249 if (!tgtdev)
3250 return 0;
3251 return sysfs_emit(buf, "%d\n", tgtdev->perst_id);
3252 }
3253 static DEVICE_ATTR_RO(persistent_id);
3254
3255 /**
3256 * sas_ncq_prio_supported_show - Indicate if device supports NCQ priority
3257 * @dev: pointer to embedded device
3258 * @attr: sas_ncq_prio_supported attribute descriptor
3259 * @buf: the buffer returned
3260 *
3261 * A sysfs 'read-only' sdev attribute, only works with SATA devices
3262 */
3263 static ssize_t
sas_ncq_prio_supported_show(struct device * dev,struct device_attribute * attr,char * buf)3264 sas_ncq_prio_supported_show(struct device *dev,
3265 struct device_attribute *attr, char *buf)
3266 {
3267 struct scsi_device *sdev = to_scsi_device(dev);
3268
3269 return sysfs_emit(buf, "%d\n", sas_ata_ncq_prio_supported(sdev));
3270 }
3271 static DEVICE_ATTR_RO(sas_ncq_prio_supported);
3272
3273 /**
3274 * sas_ncq_prio_enable_show - send prioritized io commands to device
3275 * @dev: pointer to embedded device
3276 * @attr: sas_ncq_prio_enable attribute descriptor
3277 * @buf: the buffer returned
3278 *
3279 * A sysfs 'read/write' sdev attribute, only works with SATA devices
3280 */
3281 static ssize_t
sas_ncq_prio_enable_show(struct device * dev,struct device_attribute * attr,char * buf)3282 sas_ncq_prio_enable_show(struct device *dev,
3283 struct device_attribute *attr, char *buf)
3284 {
3285 struct scsi_device *sdev = to_scsi_device(dev);
3286 struct mpi3mr_sdev_priv_data *sdev_priv_data = sdev->hostdata;
3287
3288 if (!sdev_priv_data)
3289 return 0;
3290
3291 return sysfs_emit(buf, "%d\n", sdev_priv_data->ncq_prio_enable);
3292 }
3293
3294 static ssize_t
sas_ncq_prio_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3295 sas_ncq_prio_enable_store(struct device *dev,
3296 struct device_attribute *attr,
3297 const char *buf, size_t count)
3298 {
3299 struct scsi_device *sdev = to_scsi_device(dev);
3300 struct mpi3mr_sdev_priv_data *sdev_priv_data = sdev->hostdata;
3301 bool ncq_prio_enable = 0;
3302
3303 if (kstrtobool(buf, &ncq_prio_enable))
3304 return -EINVAL;
3305
3306 if (!sas_ata_ncq_prio_supported(sdev))
3307 return -EINVAL;
3308
3309 sdev_priv_data->ncq_prio_enable = ncq_prio_enable;
3310
3311 return strlen(buf);
3312 }
3313 static DEVICE_ATTR_RW(sas_ncq_prio_enable);
3314
3315 static struct attribute *mpi3mr_dev_attrs[] = {
3316 &dev_attr_sas_address.attr,
3317 &dev_attr_device_handle.attr,
3318 &dev_attr_persistent_id.attr,
3319 &dev_attr_sas_ncq_prio_supported.attr,
3320 &dev_attr_sas_ncq_prio_enable.attr,
3321 NULL,
3322 };
3323
3324 static const struct attribute_group mpi3mr_dev_attr_group = {
3325 .attrs = mpi3mr_dev_attrs
3326 };
3327
3328 const struct attribute_group *mpi3mr_dev_groups[] = {
3329 &mpi3mr_dev_attr_group,
3330 NULL,
3331 };
3332