1 /*
2 * This module provides common API for accessing firmware configuration pages
3 *
4 * This code is based on drivers/scsi/mpt3sas/mpt3sas_base.c
5 * Copyright (C) 2012-2014 LSI Corporation
6 * Copyright (C) 2013-2014 Avago Technologies
7 * (mailto: MPT-FusionLinux.pdl@avagotech.com)
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * NO WARRANTY
20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 * solely responsible for determining the appropriateness of using and
25 * distributing the Program and assumes all risks associated with its
26 * exercise of rights under this Agreement, including but not limited to
27 * the risks and costs of program errors, damage to or loss of data,
28 * programs or equipment, and unavailability or interruption of operations.
29
30 * DISCLAIMER OF LIABILITY
31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
42 * USA.
43 */
44
45 #include <linux/module.h>
46 #include <linux/kernel.h>
47 #include <linux/init.h>
48 #include <linux/errno.h>
49 #include <linux/blkdev.h>
50 #include <linux/sched.h>
51 #include <linux/workqueue.h>
52 #include <linux/delay.h>
53 #include <linux/pci.h>
54
55 #include "mpt3sas_base.h"
56
57 /* local definitions */
58
59 /* Timeout for config page request (in seconds) */
60 #define MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT 15
61
62 /* Common sgl flags for READING a config page. */
63 #define MPT3_CONFIG_COMMON_SGLFLAGS ((MPI2_SGE_FLAGS_SIMPLE_ELEMENT | \
64 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER \
65 | MPI2_SGE_FLAGS_END_OF_LIST) << MPI2_SGE_FLAGS_SHIFT)
66
67 /* Common sgl flags for WRITING a config page. */
68 #define MPT3_CONFIG_COMMON_WRITE_SGLFLAGS ((MPI2_SGE_FLAGS_SIMPLE_ELEMENT | \
69 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER \
70 | MPI2_SGE_FLAGS_END_OF_LIST | MPI2_SGE_FLAGS_HOST_TO_IOC) \
71 << MPI2_SGE_FLAGS_SHIFT)
72
73 /**
74 * struct config_request - obtain dma memory via routine
75 * @sz: size
76 * @page: virt pointer
77 * @page_dma: phys pointer
78 *
79 */
80 struct config_request {
81 u16 sz;
82 void *page;
83 dma_addr_t page_dma;
84 };
85
86 /**
87 * _config_display_some_debug - debug routine
88 * @ioc: per adapter object
89 * @smid: system request message index
90 * @calling_function_name: string pass from calling function
91 * @mpi_reply: reply message frame
92 * Context: none.
93 *
94 * Function for displaying debug info helpful when debugging issues
95 * in this module.
96 */
97 static void
_config_display_some_debug(struct MPT3SAS_ADAPTER * ioc,u16 smid,char * calling_function_name,MPI2DefaultReply_t * mpi_reply)98 _config_display_some_debug(struct MPT3SAS_ADAPTER *ioc, u16 smid,
99 char *calling_function_name, MPI2DefaultReply_t *mpi_reply)
100 {
101 Mpi2ConfigRequest_t *mpi_request;
102 char *desc = NULL;
103
104 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
105 switch (mpi_request->Header.PageType & MPI2_CONFIG_PAGETYPE_MASK) {
106 case MPI2_CONFIG_PAGETYPE_IO_UNIT:
107 desc = "io_unit";
108 break;
109 case MPI2_CONFIG_PAGETYPE_IOC:
110 desc = "ioc";
111 break;
112 case MPI2_CONFIG_PAGETYPE_BIOS:
113 desc = "bios";
114 break;
115 case MPI2_CONFIG_PAGETYPE_RAID_VOLUME:
116 desc = "raid_volume";
117 break;
118 case MPI2_CONFIG_PAGETYPE_MANUFACTURING:
119 desc = "manufacturing";
120 break;
121 case MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK:
122 desc = "physdisk";
123 break;
124 case MPI2_CONFIG_PAGETYPE_EXTENDED:
125 switch (mpi_request->ExtPageType) {
126 case MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT:
127 desc = "sas_io_unit";
128 break;
129 case MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER:
130 desc = "sas_expander";
131 break;
132 case MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE:
133 desc = "sas_device";
134 break;
135 case MPI2_CONFIG_EXTPAGETYPE_SAS_PHY:
136 desc = "sas_phy";
137 break;
138 case MPI2_CONFIG_EXTPAGETYPE_LOG:
139 desc = "log";
140 break;
141 case MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE:
142 desc = "enclosure";
143 break;
144 case MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG:
145 desc = "raid_config";
146 break;
147 case MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING:
148 desc = "driver_mapping";
149 break;
150 case MPI2_CONFIG_EXTPAGETYPE_SAS_PORT:
151 desc = "sas_port";
152 break;
153 case MPI2_CONFIG_EXTPAGETYPE_EXT_MANUFACTURING:
154 desc = "ext_manufacturing";
155 break;
156 case MPI2_CONFIG_EXTPAGETYPE_PCIE_IO_UNIT:
157 desc = "pcie_io_unit";
158 break;
159 case MPI2_CONFIG_EXTPAGETYPE_PCIE_SWITCH:
160 desc = "pcie_switch";
161 break;
162 case MPI2_CONFIG_EXTPAGETYPE_PCIE_DEVICE:
163 desc = "pcie_device";
164 break;
165 case MPI2_CONFIG_EXTPAGETYPE_PCIE_LINK:
166 desc = "pcie_link";
167 break;
168 }
169 break;
170 }
171
172 if (!desc)
173 return;
174
175 ioc_info(ioc, "%s: %s(%d), action(%d), form(0x%08x), smid(%d)\n",
176 calling_function_name, desc,
177 mpi_request->Header.PageNumber, mpi_request->Action,
178 le32_to_cpu(mpi_request->PageAddress), smid);
179
180 if (!mpi_reply)
181 return;
182
183 if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
184 ioc_info(ioc, "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
185 le16_to_cpu(mpi_reply->IOCStatus),
186 le32_to_cpu(mpi_reply->IOCLogInfo));
187 }
188
189 /**
190 * _config_alloc_config_dma_memory - obtain physical memory
191 * @ioc: per adapter object
192 * @mem: struct config_request
193 *
194 * A wrapper for obtaining dma-able memory for config page request.
195 *
196 * Return: 0 for success, non-zero for failure.
197 */
198 static int
_config_alloc_config_dma_memory(struct MPT3SAS_ADAPTER * ioc,struct config_request * mem)199 _config_alloc_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
200 struct config_request *mem)
201 {
202 int r = 0;
203
204 if (mem->sz > ioc->config_page_sz) {
205 mem->page = dma_alloc_coherent(&ioc->pdev->dev, mem->sz,
206 &mem->page_dma, GFP_KERNEL);
207 if (!mem->page) {
208 ioc_err(ioc, "%s: dma_alloc_coherent failed asking for (%d) bytes!!\n",
209 __func__, mem->sz);
210 r = -ENOMEM;
211 }
212 } else { /* use tmp buffer if less than 512 bytes */
213 mem->page = ioc->config_page;
214 mem->page_dma = ioc->config_page_dma;
215 }
216 ioc->config_vaddr = mem->page;
217 return r;
218 }
219
220 /**
221 * _config_free_config_dma_memory - wrapper to free the memory
222 * @ioc: per adapter object
223 * @mem: struct config_request
224 *
225 * A wrapper to free dma-able memory when using _config_alloc_config_dma_memory.
226 *
227 * Return: 0 for success, non-zero for failure.
228 */
229 static void
_config_free_config_dma_memory(struct MPT3SAS_ADAPTER * ioc,struct config_request * mem)230 _config_free_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
231 struct config_request *mem)
232 {
233 if (mem->sz > ioc->config_page_sz)
234 dma_free_coherent(&ioc->pdev->dev, mem->sz, mem->page,
235 mem->page_dma);
236 }
237
238 /**
239 * mpt3sas_config_done - config page completion routine
240 * @ioc: per adapter object
241 * @smid: system request message index
242 * @msix_index: MSIX table index supplied by the OS
243 * @reply: reply message frame(lower 32bit addr)
244 * Context: none.
245 *
246 * The callback handler when using _config_request.
247 *
248 * Return: 1 meaning mf should be freed from _base_interrupt
249 * 0 means the mf is freed from this function.
250 */
251 u8
mpt3sas_config_done(struct MPT3SAS_ADAPTER * ioc,u16 smid,u8 msix_index,u32 reply)252 mpt3sas_config_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
253 u32 reply)
254 {
255 MPI2DefaultReply_t *mpi_reply;
256
257 if (ioc->config_cmds.status == MPT3_CMD_NOT_USED)
258 return 1;
259 if (ioc->config_cmds.smid != smid)
260 return 1;
261 ioc->config_cmds.status |= MPT3_CMD_COMPLETE;
262 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
263 if (mpi_reply) {
264 ioc->config_cmds.status |= MPT3_CMD_REPLY_VALID;
265 memcpy(ioc->config_cmds.reply, mpi_reply,
266 mpi_reply->MsgLength*4);
267 }
268 ioc->config_cmds.status &= ~MPT3_CMD_PENDING;
269 if (ioc->logging_level & MPT_DEBUG_CONFIG)
270 _config_display_some_debug(ioc, smid, "config_done", mpi_reply);
271 ioc->config_cmds.smid = USHRT_MAX;
272 complete(&ioc->config_cmds.done);
273 return 1;
274 }
275
276 /**
277 * _config_request - main routine for sending config page requests
278 * @ioc: per adapter object
279 * @mpi_request: request message frame
280 * @mpi_reply: reply mf payload returned from firmware
281 * @timeout: timeout in seconds
282 * @config_page: contents of the config page
283 * @config_page_sz: size of config page
284 * Context: sleep
285 *
286 * A generic API for config page requests to firmware.
287 *
288 * The ioc->config_cmds.status flag should be MPT3_CMD_NOT_USED before calling
289 * this API.
290 *
291 * The callback index is set inside `ioc->config_cb_idx.
292 *
293 * Return: 0 for success, non-zero for failure.
294 */
295 static int
_config_request(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigRequest_t * mpi_request,Mpi2ConfigReply_t * mpi_reply,int timeout,void * config_page,u16 config_page_sz)296 _config_request(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
297 *mpi_request, Mpi2ConfigReply_t *mpi_reply, int timeout,
298 void *config_page, u16 config_page_sz)
299 {
300 u16 smid;
301 Mpi2ConfigRequest_t *config_request;
302 int r;
303 u8 retry_count, issue_host_reset = 0;
304 struct config_request mem;
305 u32 ioc_status = UINT_MAX;
306
307 mutex_lock(&ioc->config_cmds.mutex);
308 if (ioc->config_cmds.status != MPT3_CMD_NOT_USED) {
309 ioc_err(ioc, "%s: config_cmd in use\n", __func__);
310 mutex_unlock(&ioc->config_cmds.mutex);
311 return -EAGAIN;
312 }
313
314 retry_count = 0;
315 memset(&mem, 0, sizeof(struct config_request));
316
317 mpi_request->VF_ID = 0; /* TODO */
318 mpi_request->VP_ID = 0;
319
320 if (config_page) {
321 mpi_request->Header.PageVersion = mpi_reply->Header.PageVersion;
322 mpi_request->Header.PageNumber = mpi_reply->Header.PageNumber;
323 mpi_request->Header.PageType = mpi_reply->Header.PageType;
324 mpi_request->Header.PageLength = mpi_reply->Header.PageLength;
325 mpi_request->ExtPageLength = mpi_reply->ExtPageLength;
326 mpi_request->ExtPageType = mpi_reply->ExtPageType;
327 if (mpi_request->Header.PageLength)
328 mem.sz = mpi_request->Header.PageLength * 4;
329 else
330 mem.sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
331 r = _config_alloc_config_dma_memory(ioc, &mem);
332 if (r != 0)
333 goto out;
334 if (mpi_request->Action ==
335 MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
336 mpi_request->Action ==
337 MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
338 ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
339 MPT3_CONFIG_COMMON_WRITE_SGLFLAGS | mem.sz,
340 mem.page_dma);
341 memcpy(mem.page, config_page, min_t(u16, mem.sz,
342 config_page_sz));
343 } else {
344 memset(config_page, 0, config_page_sz);
345 ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
346 MPT3_CONFIG_COMMON_SGLFLAGS | mem.sz, mem.page_dma);
347 memset(mem.page, 0, min_t(u16, mem.sz, config_page_sz));
348 }
349 }
350
351 retry_config:
352 if (retry_count) {
353 if (retry_count > 2) { /* attempt only 2 retries */
354 r = -EFAULT;
355 goto free_mem;
356 }
357 ioc_info(ioc, "%s: attempting retry (%d)\n",
358 __func__, retry_count);
359 }
360
361 r = mpt3sas_wait_for_ioc(ioc, MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT);
362 if (r)
363 goto free_mem;
364
365 smid = mpt3sas_base_get_smid(ioc, ioc->config_cb_idx);
366 if (!smid) {
367 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
368 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
369 r = -EAGAIN;
370 goto free_mem;
371 }
372
373 r = 0;
374 memset(ioc->config_cmds.reply, 0, sizeof(Mpi2ConfigReply_t));
375 ioc->config_cmds.status = MPT3_CMD_PENDING;
376 config_request = mpt3sas_base_get_msg_frame(ioc, smid);
377 ioc->config_cmds.smid = smid;
378 memcpy(config_request, mpi_request, sizeof(Mpi2ConfigRequest_t));
379 if (ioc->logging_level & MPT_DEBUG_CONFIG)
380 _config_display_some_debug(ioc, smid, "config_request", NULL);
381 init_completion(&ioc->config_cmds.done);
382 ioc->put_smid_default(ioc, smid);
383 wait_for_completion_timeout(&ioc->config_cmds.done, timeout*HZ);
384 if (!(ioc->config_cmds.status & MPT3_CMD_COMPLETE)) {
385 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
386 _config_display_some_debug(ioc,
387 smid, "config_request", NULL);
388 ioc_err(ioc, "%s: command timeout\n", __func__);
389 mpt3sas_base_check_cmd_timeout(ioc, ioc->config_cmds.status,
390 mpi_request, sizeof(Mpi2ConfigRequest_t) / 4);
391 retry_count++;
392 if (ioc->config_cmds.smid == smid)
393 mpt3sas_base_free_smid(ioc, smid);
394 if ((ioc->shost_recovery) || (ioc->config_cmds.status &
395 MPT3_CMD_RESET) || ioc->pci_error_recovery)
396 goto retry_config;
397 issue_host_reset = 1;
398 r = -EFAULT;
399 goto free_mem;
400 }
401
402 if (ioc->config_cmds.status & MPT3_CMD_REPLY_VALID) {
403 memcpy(mpi_reply, ioc->config_cmds.reply,
404 sizeof(Mpi2ConfigReply_t));
405
406 /* Reply Frame Sanity Checks to workaround FW issues */
407 if ((mpi_request->Header.PageType & 0xF) !=
408 (mpi_reply->Header.PageType & 0xF)) {
409 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
410 _config_display_some_debug(ioc,
411 smid, "config_request", NULL);
412 _debug_dump_mf(mpi_request, ioc->request_sz/4);
413 _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
414 panic("%s: %s: Firmware BUG: mpi_reply mismatch: Requested PageType(0x%02x) Reply PageType(0x%02x)\n",
415 ioc->name, __func__,
416 mpi_request->Header.PageType & 0xF,
417 mpi_reply->Header.PageType & 0xF);
418 }
419
420 if (((mpi_request->Header.PageType & 0xF) ==
421 MPI2_CONFIG_PAGETYPE_EXTENDED) &&
422 mpi_request->ExtPageType != mpi_reply->ExtPageType) {
423 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
424 _config_display_some_debug(ioc,
425 smid, "config_request", NULL);
426 _debug_dump_mf(mpi_request, ioc->request_sz/4);
427 _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
428 panic("%s: %s: Firmware BUG: mpi_reply mismatch: Requested ExtPageType(0x%02x) Reply ExtPageType(0x%02x)\n",
429 ioc->name, __func__,
430 mpi_request->ExtPageType,
431 mpi_reply->ExtPageType);
432 }
433 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
434 & MPI2_IOCSTATUS_MASK;
435 }
436
437 if (retry_count)
438 ioc_info(ioc, "%s: retry (%d) completed!!\n",
439 __func__, retry_count);
440
441 if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
442 config_page && mpi_request->Action ==
443 MPI2_CONFIG_ACTION_PAGE_READ_CURRENT) {
444 u8 *p = (u8 *)mem.page;
445
446 /* Config Page Sanity Checks to workaround FW issues */
447 if (p) {
448 if ((mpi_request->Header.PageType & 0xF) !=
449 (p[3] & 0xF)) {
450 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
451 _config_display_some_debug(ioc,
452 smid, "config_request", NULL);
453 _debug_dump_mf(mpi_request, ioc->request_sz/4);
454 _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
455 _debug_dump_config(p, min_t(u16, mem.sz,
456 config_page_sz)/4);
457 panic("%s: %s: Firmware BUG: config page mismatch: Requested PageType(0x%02x) Reply PageType(0x%02x)\n",
458 ioc->name, __func__,
459 mpi_request->Header.PageType & 0xF,
460 p[3] & 0xF);
461 }
462
463 if (((mpi_request->Header.PageType & 0xF) ==
464 MPI2_CONFIG_PAGETYPE_EXTENDED) &&
465 (mpi_request->ExtPageType != p[6])) {
466 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
467 _config_display_some_debug(ioc,
468 smid, "config_request", NULL);
469 _debug_dump_mf(mpi_request, ioc->request_sz/4);
470 _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
471 _debug_dump_config(p, min_t(u16, mem.sz,
472 config_page_sz)/4);
473 panic("%s: %s: Firmware BUG: config page mismatch: Requested ExtPageType(0x%02x) Reply ExtPageType(0x%02x)\n",
474 ioc->name, __func__,
475 mpi_request->ExtPageType, p[6]);
476 }
477 }
478 memcpy(config_page, mem.page, min_t(u16, mem.sz,
479 config_page_sz));
480 }
481
482 free_mem:
483 if (config_page)
484 _config_free_config_dma_memory(ioc, &mem);
485 out:
486 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
487 mutex_unlock(&ioc->config_cmds.mutex);
488
489 if (issue_host_reset)
490 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
491 return r;
492 }
493
494 /**
495 * mpt3sas_config_get_manufacturing_pg0 - obtain manufacturing page 0
496 * @ioc: per adapter object
497 * @mpi_reply: reply mf payload returned from firmware
498 * @config_page: contents of the config page
499 * Context: sleep.
500 *
501 * Return: 0 for success, non-zero for failure.
502 */
503 int
mpt3sas_config_get_manufacturing_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2ManufacturingPage0_t * config_page)504 mpt3sas_config_get_manufacturing_pg0(struct MPT3SAS_ADAPTER *ioc,
505 Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage0_t *config_page)
506 {
507 Mpi2ConfigRequest_t mpi_request;
508 int r;
509
510 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
511 mpi_request.Function = MPI2_FUNCTION_CONFIG;
512 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
513 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
514 mpi_request.Header.PageNumber = 0;
515 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
516 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
517 r = _config_request(ioc, &mpi_request, mpi_reply,
518 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
519 if (r)
520 goto out;
521
522 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
523 r = _config_request(ioc, &mpi_request, mpi_reply,
524 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
525 sizeof(*config_page));
526 out:
527 return r;
528 }
529
530 /**
531 * mpt3sas_config_get_manufacturing_pg7 - obtain manufacturing page 7
532 * @ioc: per adapter object
533 * @mpi_reply: reply mf payload returned from firmware
534 * @config_page: contents of the config page
535 * @sz: size of buffer passed in config_page
536 * Context: sleep.
537 *
538 * Return: 0 for success, non-zero for failure.
539 */
540 int
mpt3sas_config_get_manufacturing_pg7(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2ManufacturingPage7_t * config_page,u16 sz)541 mpt3sas_config_get_manufacturing_pg7(struct MPT3SAS_ADAPTER *ioc,
542 Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage7_t *config_page,
543 u16 sz)
544 {
545 Mpi2ConfigRequest_t mpi_request;
546 int r;
547
548 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
549 mpi_request.Function = MPI2_FUNCTION_CONFIG;
550 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
551 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
552 mpi_request.Header.PageNumber = 7;
553 mpi_request.Header.PageVersion = MPI2_MANUFACTURING7_PAGEVERSION;
554 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
555 r = _config_request(ioc, &mpi_request, mpi_reply,
556 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
557 if (r)
558 goto out;
559
560 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
561 r = _config_request(ioc, &mpi_request, mpi_reply,
562 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
563 sz);
564 out:
565 return r;
566 }
567
568 /**
569 * mpt3sas_config_get_manufacturing_pg10 - obtain manufacturing page 10
570 * @ioc: per adapter object
571 * @mpi_reply: reply mf payload returned from firmware
572 * @config_page: contents of the config page
573 * Context: sleep.
574 *
575 * Return: 0 for success, non-zero for failure.
576 */
577 int
mpt3sas_config_get_manufacturing_pg10(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,struct Mpi2ManufacturingPage10_t * config_page)578 mpt3sas_config_get_manufacturing_pg10(struct MPT3SAS_ADAPTER *ioc,
579 Mpi2ConfigReply_t *mpi_reply,
580 struct Mpi2ManufacturingPage10_t *config_page)
581 {
582 Mpi2ConfigRequest_t mpi_request;
583 int r;
584
585 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
586 mpi_request.Function = MPI2_FUNCTION_CONFIG;
587 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
588 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
589 mpi_request.Header.PageNumber = 10;
590 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
591 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
592 r = _config_request(ioc, &mpi_request, mpi_reply,
593 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
594 if (r)
595 goto out;
596
597 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
598 r = _config_request(ioc, &mpi_request, mpi_reply,
599 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
600 sizeof(*config_page));
601 out:
602 return r;
603 }
604
605 /**
606 * mpt3sas_config_get_manufacturing_pg11 - obtain manufacturing page 11
607 * @ioc: per adapter object
608 * @mpi_reply: reply mf payload returned from firmware
609 * @config_page: contents of the config page
610 * Context: sleep.
611 *
612 * Return: 0 for success, non-zero for failure.
613 */
614 int
mpt3sas_config_get_manufacturing_pg11(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,struct Mpi2ManufacturingPage11_t * config_page)615 mpt3sas_config_get_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
616 Mpi2ConfigReply_t *mpi_reply,
617 struct Mpi2ManufacturingPage11_t *config_page)
618 {
619 Mpi2ConfigRequest_t mpi_request;
620 int r;
621
622 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
623 mpi_request.Function = MPI2_FUNCTION_CONFIG;
624 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
625 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
626 mpi_request.Header.PageNumber = 11;
627 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
628 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
629 r = _config_request(ioc, &mpi_request, mpi_reply,
630 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
631 if (r)
632 goto out;
633
634 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
635 r = _config_request(ioc, &mpi_request, mpi_reply,
636 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
637 sizeof(*config_page));
638 out:
639 return r;
640 }
641
642 /**
643 * mpt3sas_config_set_manufacturing_pg11 - set manufacturing page 11
644 * @ioc: per adapter object
645 * @mpi_reply: reply mf payload returned from firmware
646 * @config_page: contents of the config page
647 * Context: sleep.
648 *
649 * Return: 0 for success, non-zero for failure.
650 */
651 int
mpt3sas_config_set_manufacturing_pg11(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,struct Mpi2ManufacturingPage11_t * config_page)652 mpt3sas_config_set_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
653 Mpi2ConfigReply_t *mpi_reply,
654 struct Mpi2ManufacturingPage11_t *config_page)
655 {
656 Mpi2ConfigRequest_t mpi_request;
657 int r;
658
659 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
660 mpi_request.Function = MPI2_FUNCTION_CONFIG;
661 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
662 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
663 mpi_request.Header.PageNumber = 11;
664 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
665 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
666 r = _config_request(ioc, &mpi_request, mpi_reply,
667 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
668 if (r)
669 goto out;
670
671 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
672 r = _config_request(ioc, &mpi_request, mpi_reply,
673 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
674 sizeof(*config_page));
675 out:
676 return r;
677 }
678
679 /**
680 * mpt3sas_config_get_bios_pg2 - obtain bios page 2
681 * @ioc: per adapter object
682 * @mpi_reply: reply mf payload returned from firmware
683 * @config_page: contents of the config page
684 * Context: sleep.
685 *
686 * Return: 0 for success, non-zero for failure.
687 */
688 int
mpt3sas_config_get_bios_pg2(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2BiosPage2_t * config_page)689 mpt3sas_config_get_bios_pg2(struct MPT3SAS_ADAPTER *ioc,
690 Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage2_t *config_page)
691 {
692 Mpi2ConfigRequest_t mpi_request;
693 int r;
694
695 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
696 mpi_request.Function = MPI2_FUNCTION_CONFIG;
697 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
698 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
699 mpi_request.Header.PageNumber = 2;
700 mpi_request.Header.PageVersion = MPI2_BIOSPAGE2_PAGEVERSION;
701 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
702 r = _config_request(ioc, &mpi_request, mpi_reply,
703 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
704 if (r)
705 goto out;
706
707 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
708 r = _config_request(ioc, &mpi_request, mpi_reply,
709 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
710 sizeof(*config_page));
711 out:
712 return r;
713 }
714
715 /**
716 * mpt3sas_config_get_bios_pg3 - obtain bios page 3
717 * @ioc: per adapter object
718 * @mpi_reply: reply mf payload returned from firmware
719 * @config_page: contents of the config page
720 * Context: sleep.
721 *
722 * Return: 0 for success, non-zero for failure.
723 */
724 int
mpt3sas_config_get_bios_pg3(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2BiosPage3_t * config_page)725 mpt3sas_config_get_bios_pg3(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
726 *mpi_reply, Mpi2BiosPage3_t *config_page)
727 {
728 Mpi2ConfigRequest_t mpi_request;
729 int r;
730
731 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
732 mpi_request.Function = MPI2_FUNCTION_CONFIG;
733 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
734 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
735 mpi_request.Header.PageNumber = 3;
736 mpi_request.Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
737 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
738 r = _config_request(ioc, &mpi_request, mpi_reply,
739 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
740 if (r)
741 goto out;
742
743 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
744 r = _config_request(ioc, &mpi_request, mpi_reply,
745 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
746 sizeof(*config_page));
747 out:
748 return r;
749 }
750
751 /**
752 * mpt3sas_config_get_iounit_pg0 - obtain iounit page 0
753 * @ioc: per adapter object
754 * @mpi_reply: reply mf payload returned from firmware
755 * @config_page: contents of the config page
756 * Context: sleep.
757 *
758 * Return: 0 for success, non-zero for failure.
759 */
760 int
mpt3sas_config_get_iounit_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOUnitPage0_t * config_page)761 mpt3sas_config_get_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
762 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage0_t *config_page)
763 {
764 Mpi2ConfigRequest_t mpi_request;
765 int r;
766
767 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
768 mpi_request.Function = MPI2_FUNCTION_CONFIG;
769 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
770 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
771 mpi_request.Header.PageNumber = 0;
772 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE0_PAGEVERSION;
773 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
774 r = _config_request(ioc, &mpi_request, mpi_reply,
775 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
776 if (r)
777 goto out;
778
779 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
780 r = _config_request(ioc, &mpi_request, mpi_reply,
781 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
782 sizeof(*config_page));
783 out:
784 return r;
785 }
786
787 /**
788 * mpt3sas_config_get_iounit_pg1 - obtain iounit page 1
789 * @ioc: per adapter object
790 * @mpi_reply: reply mf payload returned from firmware
791 * @config_page: contents of the config page
792 * Context: sleep.
793 *
794 * Return: 0 for success, non-zero for failure.
795 */
796 int
mpt3sas_config_get_iounit_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOUnitPage1_t * config_page)797 mpt3sas_config_get_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
798 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
799 {
800 Mpi2ConfigRequest_t mpi_request;
801 int r;
802
803 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
804 mpi_request.Function = MPI2_FUNCTION_CONFIG;
805 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
806 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
807 mpi_request.Header.PageNumber = 1;
808 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
809 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
810 r = _config_request(ioc, &mpi_request, mpi_reply,
811 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
812 if (r)
813 goto out;
814
815 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
816 r = _config_request(ioc, &mpi_request, mpi_reply,
817 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
818 sizeof(*config_page));
819 out:
820 return r;
821 }
822
823 /**
824 * mpt3sas_config_set_iounit_pg1 - set iounit page 1
825 * @ioc: per adapter object
826 * @mpi_reply: reply mf payload returned from firmware
827 * @config_page: contents of the config page
828 * Context: sleep.
829 *
830 * Return: 0 for success, non-zero for failure.
831 */
832 int
mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOUnitPage1_t * config_page)833 mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
834 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
835 {
836 Mpi2ConfigRequest_t mpi_request;
837 int r;
838
839 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
840 mpi_request.Function = MPI2_FUNCTION_CONFIG;
841 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
842 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
843 mpi_request.Header.PageNumber = 1;
844 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
845 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
846 r = _config_request(ioc, &mpi_request, mpi_reply,
847 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
848 if (r)
849 goto out;
850
851 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
852 r = _config_request(ioc, &mpi_request, mpi_reply,
853 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
854 sizeof(*config_page));
855 out:
856 return r;
857 }
858
859 /**
860 * mpt3sas_config_get_iounit_pg3 - obtain iounit page 3
861 * @ioc: per adapter object
862 * @mpi_reply: reply mf payload returned from firmware
863 * @config_page: contents of the config page
864 * @sz: size of buffer passed in config_page
865 * Context: sleep.
866 *
867 * Return: 0 for success, non-zero for failure.
868 */
869 int
mpt3sas_config_get_iounit_pg3(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOUnitPage3_t * config_page,u16 sz)870 mpt3sas_config_get_iounit_pg3(struct MPT3SAS_ADAPTER *ioc,
871 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage3_t *config_page, u16 sz)
872 {
873 Mpi2ConfigRequest_t mpi_request;
874 int r;
875
876 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
877 mpi_request.Function = MPI2_FUNCTION_CONFIG;
878 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
879 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
880 mpi_request.Header.PageNumber = 3;
881 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE3_PAGEVERSION;
882 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
883 r = _config_request(ioc, &mpi_request, mpi_reply,
884 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
885 if (r)
886 goto out;
887
888 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
889 r = _config_request(ioc, &mpi_request, mpi_reply,
890 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
891 out:
892 return r;
893 }
894
895 /**
896 * mpt3sas_config_get_iounit_pg8 - obtain iounit page 8
897 * @ioc: per adapter object
898 * @mpi_reply: reply mf payload returned from firmware
899 * @config_page: contents of the config page
900 * Context: sleep.
901 *
902 * Return: 0 for success, non-zero for failure.
903 */
904 int
mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOUnitPage8_t * config_page)905 mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER *ioc,
906 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page)
907 {
908 Mpi2ConfigRequest_t mpi_request;
909 int r;
910
911 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
912 mpi_request.Function = MPI2_FUNCTION_CONFIG;
913 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
914 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
915 mpi_request.Header.PageNumber = 8;
916 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE8_PAGEVERSION;
917 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
918 r = _config_request(ioc, &mpi_request, mpi_reply,
919 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
920 if (r)
921 goto out;
922
923 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
924 r = _config_request(ioc, &mpi_request, mpi_reply,
925 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
926 sizeof(*config_page));
927 out:
928 return r;
929 }
930
931 /**
932 * mpt3sas_config_get_ioc_pg8 - obtain ioc page 8
933 * @ioc: per adapter object
934 * @mpi_reply: reply mf payload returned from firmware
935 * @config_page: contents of the config page
936 * Context: sleep.
937 *
938 * Return: 0 for success, non-zero for failure.
939 */
940 int
mpt3sas_config_get_ioc_pg8(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOCPage8_t * config_page)941 mpt3sas_config_get_ioc_pg8(struct MPT3SAS_ADAPTER *ioc,
942 Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage8_t *config_page)
943 {
944 Mpi2ConfigRequest_t mpi_request;
945 int r;
946
947 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
948 mpi_request.Function = MPI2_FUNCTION_CONFIG;
949 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
950 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
951 mpi_request.Header.PageNumber = 8;
952 mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
953 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
954 r = _config_request(ioc, &mpi_request, mpi_reply,
955 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
956 if (r)
957 goto out;
958
959 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
960 r = _config_request(ioc, &mpi_request, mpi_reply,
961 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
962 sizeof(*config_page));
963 out:
964 return r;
965 }
966 /**
967 * mpt3sas_config_get_ioc_pg1 - obtain ioc page 1
968 * @ioc: per adapter object
969 * @mpi_reply: reply mf payload returned from firmware
970 * @config_page: contents of the config page
971 * Context: sleep.
972 *
973 * Return: 0 for success, non-zero for failure.
974 */
975 int
mpt3sas_config_get_ioc_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOCPage1_t * config_page)976 mpt3sas_config_get_ioc_pg1(struct MPT3SAS_ADAPTER *ioc,
977 Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage1_t *config_page)
978 {
979 Mpi2ConfigRequest_t mpi_request;
980 int r;
981
982 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
983 mpi_request.Function = MPI2_FUNCTION_CONFIG;
984 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
985 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
986 mpi_request.Header.PageNumber = 1;
987 mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
988 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
989 r = _config_request(ioc, &mpi_request, mpi_reply,
990 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
991 if (r)
992 goto out;
993
994 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
995 r = _config_request(ioc, &mpi_request, mpi_reply,
996 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
997 sizeof(*config_page));
998 out:
999 return r;
1000 }
1001
1002 /**
1003 * mpt3sas_config_set_ioc_pg1 - modify ioc page 1
1004 * @ioc: per adapter object
1005 * @mpi_reply: reply mf payload returned from firmware
1006 * @config_page: contents of the config page
1007 * Context: sleep.
1008 *
1009 * Return: 0 for success, non-zero for failure.
1010 */
1011 int
mpt3sas_config_set_ioc_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2IOCPage1_t * config_page)1012 mpt3sas_config_set_ioc_pg1(struct MPT3SAS_ADAPTER *ioc,
1013 Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage1_t *config_page)
1014 {
1015 Mpi2ConfigRequest_t mpi_request;
1016 int r;
1017
1018 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1019 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1020 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1021 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
1022 mpi_request.Header.PageNumber = 1;
1023 mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
1024 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1025 r = _config_request(ioc, &mpi_request, mpi_reply,
1026 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1027 if (r)
1028 goto out;
1029
1030 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1031 r = _config_request(ioc, &mpi_request, mpi_reply,
1032 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1033 sizeof(*config_page));
1034 out:
1035 return r;
1036 }
1037
1038 /**
1039 * mpt3sas_config_get_sas_device_pg0 - obtain sas device page 0
1040 * @ioc: per adapter object
1041 * @mpi_reply: reply mf payload returned from firmware
1042 * @config_page: contents of the config page
1043 * @form: GET_NEXT_HANDLE or HANDLE
1044 * @handle: device handle
1045 * Context: sleep.
1046 *
1047 * Return: 0 for success, non-zero for failure.
1048 */
1049 int
mpt3sas_config_get_sas_device_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasDevicePage0_t * config_page,u32 form,u32 handle)1050 mpt3sas_config_get_sas_device_pg0(struct MPT3SAS_ADAPTER *ioc,
1051 Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage0_t *config_page,
1052 u32 form, u32 handle)
1053 {
1054 Mpi2ConfigRequest_t mpi_request;
1055 int r;
1056
1057 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1058 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1059 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1060 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1061 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1062 mpi_request.Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
1063 mpi_request.Header.PageNumber = 0;
1064 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1065 r = _config_request(ioc, &mpi_request, mpi_reply,
1066 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1067 if (r)
1068 goto out;
1069
1070 mpi_request.PageAddress = cpu_to_le32(form | handle);
1071 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1072 r = _config_request(ioc, &mpi_request, mpi_reply,
1073 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1074 sizeof(*config_page));
1075 out:
1076 return r;
1077 }
1078
1079 /**
1080 * mpt3sas_config_get_sas_device_pg1 - obtain sas device page 1
1081 * @ioc: per adapter object
1082 * @mpi_reply: reply mf payload returned from firmware
1083 * @config_page: contents of the config page
1084 * @form: GET_NEXT_HANDLE or HANDLE
1085 * @handle: device handle
1086 * Context: sleep.
1087 *
1088 * Return: 0 for success, non-zero for failure.
1089 */
1090 int
mpt3sas_config_get_sas_device_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasDevicePage1_t * config_page,u32 form,u32 handle)1091 mpt3sas_config_get_sas_device_pg1(struct MPT3SAS_ADAPTER *ioc,
1092 Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage1_t *config_page,
1093 u32 form, u32 handle)
1094 {
1095 Mpi2ConfigRequest_t mpi_request;
1096 int r;
1097
1098 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1099 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1100 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1101 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1102 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1103 mpi_request.Header.PageVersion = MPI2_SASDEVICE1_PAGEVERSION;
1104 mpi_request.Header.PageNumber = 1;
1105 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1106 r = _config_request(ioc, &mpi_request, mpi_reply,
1107 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1108 if (r)
1109 goto out;
1110
1111 mpi_request.PageAddress = cpu_to_le32(form | handle);
1112 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1113 r = _config_request(ioc, &mpi_request, mpi_reply,
1114 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1115 sizeof(*config_page));
1116 out:
1117 return r;
1118 }
1119
1120 /**
1121 * mpt3sas_config_get_pcie_device_pg0 - obtain pcie device page 0
1122 * @ioc: per adapter object
1123 * @mpi_reply: reply mf payload returned from firmware
1124 * @config_page: contents of the config page
1125 * @form: GET_NEXT_HANDLE or HANDLE
1126 * @handle: device handle
1127 * Context: sleep.
1128 *
1129 * Return: 0 for success, non-zero for failure.
1130 */
1131 int
mpt3sas_config_get_pcie_device_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi26PCIeDevicePage0_t * config_page,u32 form,u32 handle)1132 mpt3sas_config_get_pcie_device_pg0(struct MPT3SAS_ADAPTER *ioc,
1133 Mpi2ConfigReply_t *mpi_reply, Mpi26PCIeDevicePage0_t *config_page,
1134 u32 form, u32 handle)
1135 {
1136 Mpi2ConfigRequest_t mpi_request;
1137 int r;
1138
1139 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1140 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1141 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1142 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1143 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_PCIE_DEVICE;
1144 mpi_request.Header.PageVersion = MPI26_PCIEDEVICE0_PAGEVERSION;
1145 mpi_request.Header.PageNumber = 0;
1146 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1147 r = _config_request(ioc, &mpi_request, mpi_reply,
1148 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1149 if (r)
1150 goto out;
1151
1152 mpi_request.PageAddress = cpu_to_le32(form | handle);
1153 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1154 r = _config_request(ioc, &mpi_request, mpi_reply,
1155 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1156 sizeof(*config_page));
1157 out:
1158 return r;
1159 }
1160
1161 /**
1162 * mpt3sas_config_get_pcie_device_pg2 - obtain pcie device page 2
1163 * @ioc: per adapter object
1164 * @mpi_reply: reply mf payload returned from firmware
1165 * @config_page: contents of the config page
1166 * @form: GET_NEXT_HANDLE or HANDLE
1167 * @handle: device handle
1168 * Context: sleep.
1169 *
1170 * Return: 0 for success, non-zero for failure.
1171 */
1172 int
mpt3sas_config_get_pcie_device_pg2(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi26PCIeDevicePage2_t * config_page,u32 form,u32 handle)1173 mpt3sas_config_get_pcie_device_pg2(struct MPT3SAS_ADAPTER *ioc,
1174 Mpi2ConfigReply_t *mpi_reply, Mpi26PCIeDevicePage2_t *config_page,
1175 u32 form, u32 handle)
1176 {
1177 Mpi2ConfigRequest_t mpi_request;
1178 int r;
1179
1180 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1181 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1182 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1183 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1184 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_PCIE_DEVICE;
1185 mpi_request.Header.PageVersion = MPI26_PCIEDEVICE2_PAGEVERSION;
1186 mpi_request.Header.PageNumber = 2;
1187 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1188 r = _config_request(ioc, &mpi_request, mpi_reply,
1189 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1190 if (r)
1191 goto out;
1192
1193 mpi_request.PageAddress = cpu_to_le32(form | handle);
1194 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1195 r = _config_request(ioc, &mpi_request, mpi_reply,
1196 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1197 sizeof(*config_page));
1198 out:
1199 return r;
1200 }
1201
1202 /**
1203 * mpt3sas_config_get_number_hba_phys - obtain number of phys on the host
1204 * @ioc: per adapter object
1205 * @num_phys: pointer returned with the number of phys
1206 * Context: sleep.
1207 *
1208 * Return: 0 for success, non-zero for failure.
1209 */
1210 int
mpt3sas_config_get_number_hba_phys(struct MPT3SAS_ADAPTER * ioc,u8 * num_phys)1211 mpt3sas_config_get_number_hba_phys(struct MPT3SAS_ADAPTER *ioc, u8 *num_phys)
1212 {
1213 Mpi2ConfigRequest_t mpi_request;
1214 int r;
1215 u16 ioc_status;
1216 Mpi2ConfigReply_t mpi_reply;
1217 Mpi2SasIOUnitPage0_t config_page;
1218
1219 *num_phys = 0;
1220 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1221 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1222 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1223 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1224 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1225 mpi_request.Header.PageNumber = 0;
1226 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1227 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1228 r = _config_request(ioc, &mpi_request, &mpi_reply,
1229 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1230 if (r)
1231 goto out;
1232
1233 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1234 r = _config_request(ioc, &mpi_request, &mpi_reply,
1235 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1236 sizeof(Mpi2SasIOUnitPage0_t));
1237 if (!r) {
1238 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1239 MPI2_IOCSTATUS_MASK;
1240 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1241 *num_phys = config_page.NumPhys;
1242 }
1243 out:
1244 return r;
1245 }
1246
1247 /**
1248 * mpt3sas_config_get_sas_iounit_pg0 - obtain sas iounit page 0
1249 * @ioc: per adapter object
1250 * @mpi_reply: reply mf payload returned from firmware
1251 * @config_page: contents of the config page
1252 * @sz: size of buffer passed in config_page
1253 * Context: sleep.
1254 *
1255 * Calling function should call config_get_number_hba_phys prior to
1256 * this function, so enough memory is allocated for config_page.
1257 *
1258 * Return: 0 for success, non-zero for failure.
1259 */
1260 int
mpt3sas_config_get_sas_iounit_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasIOUnitPage0_t * config_page,u16 sz)1261 mpt3sas_config_get_sas_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
1262 Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage0_t *config_page,
1263 u16 sz)
1264 {
1265 Mpi2ConfigRequest_t mpi_request;
1266 int r;
1267
1268 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1269 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1270 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1271 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1272 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1273 mpi_request.Header.PageNumber = 0;
1274 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1275 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1276 r = _config_request(ioc, &mpi_request, mpi_reply,
1277 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1278 if (r)
1279 goto out;
1280
1281 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1282 r = _config_request(ioc, &mpi_request, mpi_reply,
1283 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1284 out:
1285 return r;
1286 }
1287
1288 /**
1289 * mpt3sas_config_get_sas_iounit_pg1 - obtain sas iounit page 1
1290 * @ioc: per adapter object
1291 * @mpi_reply: reply mf payload returned from firmware
1292 * @config_page: contents of the config page
1293 * @sz: size of buffer passed in config_page
1294 * Context: sleep.
1295 *
1296 * Calling function should call config_get_number_hba_phys prior to
1297 * this function, so enough memory is allocated for config_page.
1298 *
1299 * Return: 0 for success, non-zero for failure.
1300 */
1301 int
mpt3sas_config_get_sas_iounit_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasIOUnitPage1_t * config_page,u16 sz)1302 mpt3sas_config_get_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1303 Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1304 u16 sz)
1305 {
1306 Mpi2ConfigRequest_t mpi_request;
1307 int r;
1308
1309 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1310 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1311 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1312 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1313 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1314 mpi_request.Header.PageNumber = 1;
1315 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1316 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1317 r = _config_request(ioc, &mpi_request, mpi_reply,
1318 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1319 if (r)
1320 goto out;
1321
1322 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1323 r = _config_request(ioc, &mpi_request, mpi_reply,
1324 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1325 out:
1326 return r;
1327 }
1328
1329 /**
1330 * mpt3sas_config_set_sas_iounit_pg1 - send sas iounit page 1
1331 * @ioc: per adapter object
1332 * @mpi_reply: reply mf payload returned from firmware
1333 * @config_page: contents of the config page
1334 * @sz: size of buffer passed in config_page
1335 * Context: sleep.
1336 *
1337 * Calling function should call config_get_number_hba_phys prior to
1338 * this function, so enough memory is allocated for config_page.
1339 *
1340 * Return: 0 for success, non-zero for failure.
1341 */
1342 int
mpt3sas_config_set_sas_iounit_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasIOUnitPage1_t * config_page,u16 sz)1343 mpt3sas_config_set_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1344 Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1345 u16 sz)
1346 {
1347 Mpi2ConfigRequest_t mpi_request;
1348 int r;
1349
1350 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1351 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1352 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1353 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1354 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1355 mpi_request.Header.PageNumber = 1;
1356 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1357 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1358 r = _config_request(ioc, &mpi_request, mpi_reply,
1359 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1360 if (r)
1361 goto out;
1362
1363 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1364 _config_request(ioc, &mpi_request, mpi_reply,
1365 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1366 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
1367 r = _config_request(ioc, &mpi_request, mpi_reply,
1368 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1369 out:
1370 return r;
1371 }
1372
1373 /**
1374 * mpt3sas_config_get_expander_pg0 - obtain expander page 0
1375 * @ioc: per adapter object
1376 * @mpi_reply: reply mf payload returned from firmware
1377 * @config_page: contents of the config page
1378 * @form: GET_NEXT_HANDLE or HANDLE
1379 * @handle: expander handle
1380 * Context: sleep.
1381 *
1382 * Return: 0 for success, non-zero for failure.
1383 */
1384 int
mpt3sas_config_get_expander_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2ExpanderPage0_t * config_page,u32 form,u32 handle)1385 mpt3sas_config_get_expander_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1386 *mpi_reply, Mpi2ExpanderPage0_t *config_page, u32 form, u32 handle)
1387 {
1388 Mpi2ConfigRequest_t mpi_request;
1389 int r;
1390
1391 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1392 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1393 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1394 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1395 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1396 mpi_request.Header.PageNumber = 0;
1397 mpi_request.Header.PageVersion = MPI2_SASEXPANDER0_PAGEVERSION;
1398 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1399 r = _config_request(ioc, &mpi_request, mpi_reply,
1400 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1401 if (r)
1402 goto out;
1403
1404 mpi_request.PageAddress = cpu_to_le32(form | handle);
1405 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1406 r = _config_request(ioc, &mpi_request, mpi_reply,
1407 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1408 sizeof(*config_page));
1409 out:
1410 return r;
1411 }
1412
1413 /**
1414 * mpt3sas_config_get_expander_pg1 - obtain expander page 1
1415 * @ioc: per adapter object
1416 * @mpi_reply: reply mf payload returned from firmware
1417 * @config_page: contents of the config page
1418 * @phy_number: phy number
1419 * @handle: expander handle
1420 * Context: sleep.
1421 *
1422 * Return: 0 for success, non-zero for failure.
1423 */
1424 int
mpt3sas_config_get_expander_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2ExpanderPage1_t * config_page,u32 phy_number,u16 handle)1425 mpt3sas_config_get_expander_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1426 *mpi_reply, Mpi2ExpanderPage1_t *config_page, u32 phy_number,
1427 u16 handle)
1428 {
1429 Mpi2ConfigRequest_t mpi_request;
1430 int r;
1431
1432 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1433 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1434 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1435 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1436 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1437 mpi_request.Header.PageNumber = 1;
1438 mpi_request.Header.PageVersion = MPI2_SASEXPANDER1_PAGEVERSION;
1439 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1440 r = _config_request(ioc, &mpi_request, mpi_reply,
1441 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1442 if (r)
1443 goto out;
1444
1445 mpi_request.PageAddress =
1446 cpu_to_le32(MPI2_SAS_EXPAND_PGAD_FORM_HNDL_PHY_NUM |
1447 (phy_number << MPI2_SAS_EXPAND_PGAD_PHYNUM_SHIFT) | handle);
1448 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1449 r = _config_request(ioc, &mpi_request, mpi_reply,
1450 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1451 sizeof(*config_page));
1452 out:
1453 return r;
1454 }
1455
1456 /**
1457 * mpt3sas_config_get_enclosure_pg0 - obtain enclosure page 0
1458 * @ioc: per adapter object
1459 * @mpi_reply: reply mf payload returned from firmware
1460 * @config_page: contents of the config page
1461 * @form: GET_NEXT_HANDLE or HANDLE
1462 * @handle: expander handle
1463 * Context: sleep.
1464 *
1465 * Return: 0 for success, non-zero for failure.
1466 */
1467 int
mpt3sas_config_get_enclosure_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasEnclosurePage0_t * config_page,u32 form,u32 handle)1468 mpt3sas_config_get_enclosure_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1469 *mpi_reply, Mpi2SasEnclosurePage0_t *config_page, u32 form, u32 handle)
1470 {
1471 Mpi2ConfigRequest_t mpi_request;
1472 int r;
1473
1474 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1475 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1476 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1477 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1478 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE;
1479 mpi_request.Header.PageNumber = 0;
1480 mpi_request.Header.PageVersion = MPI2_SASENCLOSURE0_PAGEVERSION;
1481 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1482 r = _config_request(ioc, &mpi_request, mpi_reply,
1483 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1484 if (r)
1485 goto out;
1486
1487 mpi_request.PageAddress = cpu_to_le32(form | handle);
1488 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1489 r = _config_request(ioc, &mpi_request, mpi_reply,
1490 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1491 sizeof(*config_page));
1492 out:
1493 return r;
1494 }
1495
1496 /**
1497 * mpt3sas_config_get_phy_pg0 - obtain phy page 0
1498 * @ioc: per adapter object
1499 * @mpi_reply: reply mf payload returned from firmware
1500 * @config_page: contents of the config page
1501 * @phy_number: phy number
1502 * Context: sleep.
1503 *
1504 * Return: 0 for success, non-zero for failure.
1505 */
1506 int
mpt3sas_config_get_phy_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasPhyPage0_t * config_page,u32 phy_number)1507 mpt3sas_config_get_phy_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1508 *mpi_reply, Mpi2SasPhyPage0_t *config_page, u32 phy_number)
1509 {
1510 Mpi2ConfigRequest_t mpi_request;
1511 int r;
1512
1513 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1514 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1515 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1516 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1517 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1518 mpi_request.Header.PageNumber = 0;
1519 mpi_request.Header.PageVersion = MPI2_SASPHY0_PAGEVERSION;
1520 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1521 r = _config_request(ioc, &mpi_request, mpi_reply,
1522 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1523 if (r)
1524 goto out;
1525
1526 mpi_request.PageAddress =
1527 cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1528 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1529 r = _config_request(ioc, &mpi_request, mpi_reply,
1530 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1531 sizeof(*config_page));
1532 out:
1533 return r;
1534 }
1535
1536 /**
1537 * mpt3sas_config_get_phy_pg1 - obtain phy page 1
1538 * @ioc: per adapter object
1539 * @mpi_reply: reply mf payload returned from firmware
1540 * @config_page: contents of the config page
1541 * @phy_number: phy number
1542 * Context: sleep.
1543 *
1544 * Return: 0 for success, non-zero for failure.
1545 */
1546 int
mpt3sas_config_get_phy_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2SasPhyPage1_t * config_page,u32 phy_number)1547 mpt3sas_config_get_phy_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1548 *mpi_reply, Mpi2SasPhyPage1_t *config_page, u32 phy_number)
1549 {
1550 Mpi2ConfigRequest_t mpi_request;
1551 int r;
1552
1553 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1554 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1555 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1556 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1557 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1558 mpi_request.Header.PageNumber = 1;
1559 mpi_request.Header.PageVersion = MPI2_SASPHY1_PAGEVERSION;
1560 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1561 r = _config_request(ioc, &mpi_request, mpi_reply,
1562 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1563 if (r)
1564 goto out;
1565
1566 mpi_request.PageAddress =
1567 cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1568 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1569 r = _config_request(ioc, &mpi_request, mpi_reply,
1570 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1571 sizeof(*config_page));
1572 out:
1573 return r;
1574 }
1575
1576 /**
1577 * mpt3sas_config_get_raid_volume_pg1 - obtain raid volume page 1
1578 * @ioc: per adapter object
1579 * @mpi_reply: reply mf payload returned from firmware
1580 * @config_page: contents of the config page
1581 * @form: GET_NEXT_HANDLE or HANDLE
1582 * @handle: volume handle
1583 * Context: sleep.
1584 *
1585 * Return: 0 for success, non-zero for failure.
1586 */
1587 int
mpt3sas_config_get_raid_volume_pg1(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2RaidVolPage1_t * config_page,u32 form,u32 handle)1588 mpt3sas_config_get_raid_volume_pg1(struct MPT3SAS_ADAPTER *ioc,
1589 Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form,
1590 u32 handle)
1591 {
1592 Mpi2ConfigRequest_t mpi_request;
1593 int r;
1594
1595 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1596 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1597 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1598 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1599 mpi_request.Header.PageNumber = 1;
1600 mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION;
1601 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1602 r = _config_request(ioc, &mpi_request, mpi_reply,
1603 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1604 if (r)
1605 goto out;
1606
1607 mpi_request.PageAddress = cpu_to_le32(form | handle);
1608 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1609 r = _config_request(ioc, &mpi_request, mpi_reply,
1610 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1611 sizeof(*config_page));
1612 out:
1613 return r;
1614 }
1615
1616 /**
1617 * mpt3sas_config_get_number_pds - obtain number of phys disk assigned to volume
1618 * @ioc: per adapter object
1619 * @handle: volume handle
1620 * @num_pds: returns pds count
1621 * Context: sleep.
1622 *
1623 * Return: 0 for success, non-zero for failure.
1624 */
1625 int
mpt3sas_config_get_number_pds(struct MPT3SAS_ADAPTER * ioc,u16 handle,u8 * num_pds)1626 mpt3sas_config_get_number_pds(struct MPT3SAS_ADAPTER *ioc, u16 handle,
1627 u8 *num_pds)
1628 {
1629 Mpi2ConfigRequest_t mpi_request;
1630 Mpi2RaidVolPage0_t config_page;
1631 Mpi2ConfigReply_t mpi_reply;
1632 int r;
1633 u16 ioc_status;
1634
1635 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1636 *num_pds = 0;
1637 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1638 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1639 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1640 mpi_request.Header.PageNumber = 0;
1641 mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1642 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1643 r = _config_request(ioc, &mpi_request, &mpi_reply,
1644 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1645 if (r)
1646 goto out;
1647
1648 mpi_request.PageAddress =
1649 cpu_to_le32(MPI2_RAID_VOLUME_PGAD_FORM_HANDLE | handle);
1650 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1651 r = _config_request(ioc, &mpi_request, &mpi_reply,
1652 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1653 sizeof(Mpi2RaidVolPage0_t));
1654 if (!r) {
1655 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1656 MPI2_IOCSTATUS_MASK;
1657 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1658 *num_pds = config_page.NumPhysDisks;
1659 }
1660
1661 out:
1662 return r;
1663 }
1664
1665 /**
1666 * mpt3sas_config_get_raid_volume_pg0 - obtain raid volume page 0
1667 * @ioc: per adapter object
1668 * @mpi_reply: reply mf payload returned from firmware
1669 * @config_page: contents of the config page
1670 * @form: GET_NEXT_HANDLE or HANDLE
1671 * @handle: volume handle
1672 * @sz: size of buffer passed in config_page
1673 * Context: sleep.
1674 *
1675 * Return: 0 for success, non-zero for failure.
1676 */
1677 int
mpt3sas_config_get_raid_volume_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2RaidVolPage0_t * config_page,u32 form,u32 handle,u16 sz)1678 mpt3sas_config_get_raid_volume_pg0(struct MPT3SAS_ADAPTER *ioc,
1679 Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 form,
1680 u32 handle, u16 sz)
1681 {
1682 Mpi2ConfigRequest_t mpi_request;
1683 int r;
1684
1685 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1686 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1687 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1688 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1689 mpi_request.Header.PageNumber = 0;
1690 mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1691 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1692 r = _config_request(ioc, &mpi_request, mpi_reply,
1693 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1694 if (r)
1695 goto out;
1696
1697 mpi_request.PageAddress = cpu_to_le32(form | handle);
1698 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1699 r = _config_request(ioc, &mpi_request, mpi_reply,
1700 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1701 out:
1702 return r;
1703 }
1704
1705 /**
1706 * mpt3sas_config_get_phys_disk_pg0 - obtain phys disk page 0
1707 * @ioc: per adapter object
1708 * @mpi_reply: reply mf payload returned from firmware
1709 * @config_page: contents of the config page
1710 * @form: GET_NEXT_PHYSDISKNUM, PHYSDISKNUM, DEVHANDLE
1711 * @form_specific: specific to the form
1712 * Context: sleep.
1713 *
1714 * Return: 0 for success, non-zero for failure.
1715 */
1716 int
mpt3sas_config_get_phys_disk_pg0(struct MPT3SAS_ADAPTER * ioc,Mpi2ConfigReply_t * mpi_reply,Mpi2RaidPhysDiskPage0_t * config_page,u32 form,u32 form_specific)1717 mpt3sas_config_get_phys_disk_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1718 *mpi_reply, Mpi2RaidPhysDiskPage0_t *config_page, u32 form,
1719 u32 form_specific)
1720 {
1721 Mpi2ConfigRequest_t mpi_request;
1722 int r;
1723
1724 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1725 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1726 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1727 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
1728 mpi_request.Header.PageNumber = 0;
1729 mpi_request.Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION;
1730 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1731 r = _config_request(ioc, &mpi_request, mpi_reply,
1732 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1733 if (r)
1734 goto out;
1735
1736 mpi_request.PageAddress = cpu_to_le32(form | form_specific);
1737 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1738 r = _config_request(ioc, &mpi_request, mpi_reply,
1739 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1740 sizeof(*config_page));
1741 out:
1742 return r;
1743 }
1744
1745 /**
1746 * mpt3sas_config_get_volume_handle - returns volume handle for give hidden
1747 * raid components
1748 * @ioc: per adapter object
1749 * @pd_handle: phys disk handle
1750 * @volume_handle: volume handle
1751 * Context: sleep.
1752 *
1753 * Return: 0 for success, non-zero for failure.
1754 */
1755 int
mpt3sas_config_get_volume_handle(struct MPT3SAS_ADAPTER * ioc,u16 pd_handle,u16 * volume_handle)1756 mpt3sas_config_get_volume_handle(struct MPT3SAS_ADAPTER *ioc, u16 pd_handle,
1757 u16 *volume_handle)
1758 {
1759 Mpi2RaidConfigurationPage0_t *config_page = NULL;
1760 Mpi2ConfigRequest_t mpi_request;
1761 Mpi2ConfigReply_t mpi_reply;
1762 int r, i, config_page_sz;
1763 u16 ioc_status;
1764 int config_num;
1765 u16 element_type;
1766 u16 phys_disk_dev_handle;
1767
1768 *volume_handle = 0;
1769 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1770 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1771 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1772 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1773 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG;
1774 mpi_request.Header.PageVersion = MPI2_RAIDCONFIG0_PAGEVERSION;
1775 mpi_request.Header.PageNumber = 0;
1776 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1777 r = _config_request(ioc, &mpi_request, &mpi_reply,
1778 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1779 if (r)
1780 goto out;
1781
1782 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1783 config_page_sz = (le16_to_cpu(mpi_reply.ExtPageLength) * 4);
1784 config_page = kmalloc(config_page_sz, GFP_KERNEL);
1785 if (!config_page) {
1786 r = -1;
1787 goto out;
1788 }
1789
1790 config_num = 0xff;
1791 while (1) {
1792 mpi_request.PageAddress = cpu_to_le32(config_num +
1793 MPI2_RAID_PGAD_FORM_GET_NEXT_CONFIGNUM);
1794 r = _config_request(ioc, &mpi_request, &mpi_reply,
1795 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1796 config_page_sz);
1797 if (r)
1798 goto out;
1799 r = -1;
1800 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1801 MPI2_IOCSTATUS_MASK;
1802 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
1803 goto out;
1804 for (i = 0; i < config_page->NumElements; i++) {
1805 element_type = le16_to_cpu(config_page->
1806 ConfigElement[i].ElementFlags) &
1807 MPI2_RAIDCONFIG0_EFLAGS_MASK_ELEMENT_TYPE;
1808 if (element_type ==
1809 MPI2_RAIDCONFIG0_EFLAGS_VOL_PHYS_DISK_ELEMENT ||
1810 element_type ==
1811 MPI2_RAIDCONFIG0_EFLAGS_OCE_ELEMENT) {
1812 phys_disk_dev_handle =
1813 le16_to_cpu(config_page->ConfigElement[i].
1814 PhysDiskDevHandle);
1815 if (phys_disk_dev_handle == pd_handle) {
1816 *volume_handle =
1817 le16_to_cpu(config_page->
1818 ConfigElement[i].VolDevHandle);
1819 r = 0;
1820 goto out;
1821 }
1822 } else if (element_type ==
1823 MPI2_RAIDCONFIG0_EFLAGS_HOT_SPARE_ELEMENT) {
1824 *volume_handle = 0;
1825 r = 0;
1826 goto out;
1827 }
1828 }
1829 config_num = config_page->ConfigNum;
1830 }
1831 out:
1832 kfree(config_page);
1833 return r;
1834 }
1835
1836 /**
1837 * mpt3sas_config_get_volume_wwid - returns wwid given the volume handle
1838 * @ioc: per adapter object
1839 * @volume_handle: volume handle
1840 * @wwid: volume wwid
1841 * Context: sleep.
1842 *
1843 * Return: 0 for success, non-zero for failure.
1844 */
1845 int
mpt3sas_config_get_volume_wwid(struct MPT3SAS_ADAPTER * ioc,u16 volume_handle,u64 * wwid)1846 mpt3sas_config_get_volume_wwid(struct MPT3SAS_ADAPTER *ioc, u16 volume_handle,
1847 u64 *wwid)
1848 {
1849 Mpi2ConfigReply_t mpi_reply;
1850 Mpi2RaidVolPage1_t raid_vol_pg1;
1851
1852 *wwid = 0;
1853 if (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1854 &raid_vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE,
1855 volume_handle))) {
1856 *wwid = le64_to_cpu(raid_vol_pg1.WWID);
1857 return 0;
1858 } else
1859 return -1;
1860 }
1861