projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mpt2sas, mpt3sas: Remove SCSI_MPTXSAS_LOGGING entry from Kconfig
[linux-2.6-block.git] / drivers / scsi / mpt3sas / mpt3sas_config.c
CommitLineData
f92363d1
SR		 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
a4ffce0d 5 * Copyright (C) 2012-2014 LSI Corporation
a03bd153
SR		 6 * Copyright (C) 2013-2014 Avago Technologies
7 * (mailto: MPT-FusionLinux.pdl@avagotech.com)
f92363d1
SR		 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
f92363d1
SR		 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 */
80struct config_request {
81 u16 sz;
82 void *page;
83 dma_addr_t page_dma;
84};
85
f92363d1
SR		 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 */
97static void
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 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
105 return;
106
107 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
108 switch (mpi_request->Header.PageType & MPI2_CONFIG_PAGETYPE_MASK) {
109 case MPI2_CONFIG_PAGETYPE_IO_UNIT:
110 desc = "io_unit";
111 break;
112 case MPI2_CONFIG_PAGETYPE_IOC:
113 desc = "ioc";
114 break;
115 case MPI2_CONFIG_PAGETYPE_BIOS:
116 desc = "bios";
117 break;
118 case MPI2_CONFIG_PAGETYPE_RAID_VOLUME:
119 desc = "raid_volume";
120 break;
121 case MPI2_CONFIG_PAGETYPE_MANUFACTURING:
122 desc = "manufaucturing";
123 break;
124 case MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK:
125 desc = "physdisk";
126 break;
127 case MPI2_CONFIG_PAGETYPE_EXTENDED:
128 switch (mpi_request->ExtPageType) {
129 case MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT:
130 desc = "sas_io_unit";
131 break;
132 case MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER:
133 desc = "sas_expander";
134 break;
135 case MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE:
136 desc = "sas_device";
137 break;
138 case MPI2_CONFIG_EXTPAGETYPE_SAS_PHY:
139 desc = "sas_phy";
140 break;
141 case MPI2_CONFIG_EXTPAGETYPE_LOG:
142 desc = "log";
143 break;
144 case MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE:
145 desc = "enclosure";
146 break;
147 case MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG:
148 desc = "raid_config";
149 break;
150 case MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING:
07f42258 151 desc = "driver_mapping";
f92363d1
SR		 152 break;
153 }
154 break;
155 }
156
157 if (!desc)
158 return;
159
160 pr_info(MPT3SAS_FMT
161 "%s: %s(%d), action(%d), form(0x%08x), smid(%d)\n",
162 ioc->name, calling_function_name, desc,
163 mpi_request->Header.PageNumber, mpi_request->Action,
164 le32_to_cpu(mpi_request->PageAddress), smid);
165
166 if (!mpi_reply)
167 return;
168
169 if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
170 pr_info(MPT3SAS_FMT
171 "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
172 ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
173 le32_to_cpu(mpi_reply->IOCLogInfo));
174}
f92363d1
SR		 175
176/**
177 * _config_alloc_config_dma_memory - obtain physical memory
178 * @ioc: per adapter object
179 * @mem: struct config_request
180 *
181 * A wrapper for obtaining dma-able memory for config page request.
182 *
183 * Returns 0 for success, non-zero for failure.
184 */
185static int
186_config_alloc_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
187 struct config_request *mem)
188{
189 int r = 0;
190
191 if (mem->sz > ioc->config_page_sz) {
192 mem->page = dma_alloc_coherent(&ioc->pdev->dev, mem->sz,
193 &mem->page_dma, GFP_KERNEL);
194 if (!mem->page) {
195 pr_err(MPT3SAS_FMT
196 "%s: dma_alloc_coherent failed asking for (%d) bytes!!\n",
197 ioc->name, __func__, mem->sz);
198 r = -ENOMEM;
199 }
200 } else { /* use tmp buffer if less than 512 bytes */
201 mem->page = ioc->config_page;
202 mem->page_dma = ioc->config_page_dma;
203 }
204 return r;
205}
206
207/**
208 * _config_free_config_dma_memory - wrapper to free the memory
209 * @ioc: per adapter object
210 * @mem: struct config_request
211 *
212 * A wrapper to free dma-able memory when using _config_alloc_config_dma_memory.
213 *
214 * Returns 0 for success, non-zero for failure.
215 */
216static void
217_config_free_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
218 struct config_request *mem)
219{
220 if (mem->sz > ioc->config_page_sz)
221 dma_free_coherent(&ioc->pdev->dev, mem->sz, mem->page,
222 mem->page_dma);
223}
224
225/**
226 * mpt3sas_config_done - config page completion routine
227 * @ioc: per adapter object
228 * @smid: system request message index
229 * @msix_index: MSIX table index supplied by the OS
230 * @reply: reply message frame(lower 32bit addr)
231 * Context: none.
232 *
233 * The callback handler when using _config_request.
234 *
235 * Return 1 meaning mf should be freed from _base_interrupt
236 * 0 means the mf is freed from this function.
237 */
238u8
239mpt3sas_config_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
240 u32 reply)
241{
242 MPI2DefaultReply_t *mpi_reply;
243
244 if (ioc->config_cmds.status == MPT3_CMD_NOT_USED)
245 return 1;
246 if (ioc->config_cmds.smid != smid)
247 return 1;
248 ioc->config_cmds.status |= MPT3_CMD_COMPLETE;
249 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
250 if (mpi_reply) {
251 ioc->config_cmds.status |= MPT3_CMD_REPLY_VALID;
252 memcpy(ioc->config_cmds.reply, mpi_reply,
253 mpi_reply->MsgLength*4);
254 }
255 ioc->config_cmds.status &= ~MPT3_CMD_PENDING;
f92363d1 256 _config_display_some_debug(ioc, smid, "config_done", mpi_reply);
f92363d1
SR		 257 ioc->config_cmds.smid = USHRT_MAX;
258 complete(&ioc->config_cmds.done);
259 return 1;
260}
261
262/**
263 * _config_request - main routine for sending config page requests
264 * @ioc: per adapter object
265 * @mpi_request: request message frame
266 * @mpi_reply: reply mf payload returned from firmware
267 * @timeout: timeout in seconds
268 * @config_page: contents of the config page
269 * @config_page_sz: size of config page
270 * Context: sleep
271 *
272 * A generic API for config page requests to firmware.
273 *
274 * The ioc->config_cmds.status flag should be MPT3_CMD_NOT_USED before calling
275 * this API.
276 *
277 * The callback index is set inside `ioc->config_cb_idx.
278 *
279 * Returns 0 for success, non-zero for failure.
280 */
281static int
282_config_request(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
283 *mpi_request, Mpi2ConfigReply_t *mpi_reply, int timeout,
284 void *config_page, u16 config_page_sz)
285{
286 u16 smid;
287 u32 ioc_state;
288 unsigned long timeleft;
289 Mpi2ConfigRequest_t *config_request;
290 int r;
291 u8 retry_count, issue_host_reset = 0;
292 u16 wait_state_count;
293 struct config_request mem;
294 u32 ioc_status = UINT_MAX;
295
296 mutex_lock(&ioc->config_cmds.mutex);
297 if (ioc->config_cmds.status != MPT3_CMD_NOT_USED) {
298 pr_err(MPT3SAS_FMT "%s: config_cmd in use\n",
299 ioc->name, __func__);
300 mutex_unlock(&ioc->config_cmds.mutex);
301 return -EAGAIN;
302 }
303
304 retry_count = 0;
305 memset(&mem, 0, sizeof(struct config_request));
306
307 mpi_request->VF_ID = 0; /* TODO */
308 mpi_request->VP_ID = 0;
309
310 if (config_page) {
311 mpi_request->Header.PageVersion = mpi_reply->Header.PageVersion;
312 mpi_request->Header.PageNumber = mpi_reply->Header.PageNumber;
313 mpi_request->Header.PageType = mpi_reply->Header.PageType;
314 mpi_request->Header.PageLength = mpi_reply->Header.PageLength;
315 mpi_request->ExtPageLength = mpi_reply->ExtPageLength;
316 mpi_request->ExtPageType = mpi_reply->ExtPageType;
317 if (mpi_request->Header.PageLength)
318 mem.sz = mpi_request->Header.PageLength * 4;
319 else
320 mem.sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
321 r = _config_alloc_config_dma_memory(ioc, &mem);
322 if (r != 0)
323 goto out;
324 if (mpi_request->Action ==
325 MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
326 mpi_request->Action ==
327 MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
328 ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
329 MPT3_CONFIG_COMMON_WRITE_SGLFLAGS | mem.sz,
330 mem.page_dma);
331 memcpy(mem.page, config_page, min_t(u16, mem.sz,
332 config_page_sz));
333 } else {
334 memset(config_page, 0, config_page_sz);
335 ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
336 MPT3_CONFIG_COMMON_SGLFLAGS | mem.sz, mem.page_dma);
337 memset(mem.page, 0, min_t(u16, mem.sz, config_page_sz));
338 }
339 }
340
341 retry_config:
342 if (retry_count) {
343 if (retry_count > 2) { /* attempt only 2 retries */
344 r = -EFAULT;
345 goto free_mem;
346 }
347 pr_info(MPT3SAS_FMT "%s: attempting retry (%d)\n",
348 ioc->name, __func__, retry_count);
349 }
350 wait_state_count = 0;
351 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
352 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
353 if (wait_state_count++ == MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT) {
354 pr_err(MPT3SAS_FMT
355 "%s: failed due to ioc not operational\n",
356 ioc->name, __func__);
357 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
358 r = -EFAULT;
359 goto free_mem;
360 }
361 ssleep(1);
362 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
363 pr_info(MPT3SAS_FMT
364 "%s: waiting for operational state(count=%d)\n",
365 ioc->name, __func__, wait_state_count);
366 }
367 if (wait_state_count)
368 pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
369 ioc->name, __func__);
370
371 smid = mpt3sas_base_get_smid(ioc, ioc->config_cb_idx);
372 if (!smid) {
373 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
374 ioc->name, __func__);
375 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
376 r = -EAGAIN;
377 goto free_mem;
378 }
379
380 r = 0;
381 memset(mpi_reply, 0, sizeof(Mpi2ConfigReply_t));
382 ioc->config_cmds.status = MPT3_CMD_PENDING;
383 config_request = mpt3sas_base_get_msg_frame(ioc, smid);
384 ioc->config_cmds.smid = smid;
385 memcpy(config_request, mpi_request, sizeof(Mpi2ConfigRequest_t));
f92363d1 386 _config_display_some_debug(ioc, smid, "config_request", NULL);
f92363d1
SR		 387 init_completion(&ioc->config_cmds.done);
388 mpt3sas_base_put_smid_default(ioc, smid);
389 timeleft = wait_for_completion_timeout(&ioc->config_cmds.done,
390 timeout*HZ);
391 if (!(ioc->config_cmds.status & MPT3_CMD_COMPLETE)) {
392 pr_err(MPT3SAS_FMT "%s: timeout\n",
393 ioc->name, __func__);
394 _debug_dump_mf(mpi_request,
395 sizeof(Mpi2ConfigRequest_t)/4);
396 retry_count++;
397 if (ioc->config_cmds.smid == smid)
398 mpt3sas_base_free_smid(ioc, smid);
399 if ((ioc->shost_recovery) || (ioc->config_cmds.status &
400 MPT3_CMD_RESET) || ioc->pci_error_recovery)
401 goto retry_config;
402 issue_host_reset = 1;
403 r = -EFAULT;
404 goto free_mem;
405 }
406
407 if (ioc->config_cmds.status & MPT3_CMD_REPLY_VALID) {
408 memcpy(mpi_reply, ioc->config_cmds.reply,
409 sizeof(Mpi2ConfigReply_t));
410
411 /* Reply Frame Sanity Checks to workaround FW issues */
412 if ((mpi_request->Header.PageType & 0xF) !=
413 (mpi_reply->Header.PageType & 0xF)) {
414 _debug_dump_mf(mpi_request, ioc->request_sz/4);
415 _debug_dump_reply(mpi_reply, ioc->request_sz/4);
416 panic(KERN_WARNING MPT3SAS_FMT "%s: Firmware BUG:" \
417 " mpi_reply mismatch: Requested PageType(0x%02x)" \
418 " Reply PageType(0x%02x)\n", \
419 ioc->name, __func__,
420 (mpi_request->Header.PageType & 0xF),
421 (mpi_reply->Header.PageType & 0xF));
422 }
423
424 if (((mpi_request->Header.PageType & 0xF) ==
425 MPI2_CONFIG_PAGETYPE_EXTENDED) &&
426 mpi_request->ExtPageType != mpi_reply->ExtPageType) {
427 _debug_dump_mf(mpi_request, ioc->request_sz/4);
428 _debug_dump_reply(mpi_reply, ioc->request_sz/4);
429 panic(KERN_WARNING MPT3SAS_FMT "%s: Firmware BUG:" \
430 " mpi_reply mismatch: Requested ExtPageType(0x%02x)"
431 " Reply ExtPageType(0x%02x)\n",
432 ioc->name, __func__, mpi_request->ExtPageType,
433 mpi_reply->ExtPageType);
434 }
435 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
436 & MPI2_IOCSTATUS_MASK;
437 }
438
439 if (retry_count)
440 pr_info(MPT3SAS_FMT "%s: retry (%d) completed!!\n", \
441 ioc->name, __func__, retry_count);
442
443 if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
444 config_page && mpi_request->Action ==
445 MPI2_CONFIG_ACTION_PAGE_READ_CURRENT) {
446 u8 *p = (u8 *)mem.page;
447
448 /* Config Page Sanity Checks to workaround FW issues */
449 if (p) {
450 if ((mpi_request->Header.PageType & 0xF) !=
451 (p[3] & 0xF)) {
452 _debug_dump_mf(mpi_request, ioc->request_sz/4);
453 _debug_dump_reply(mpi_reply, ioc->request_sz/4);
454 _debug_dump_config(p, min_t(u16, mem.sz,
455 config_page_sz)/4);
456 panic(KERN_WARNING MPT3SAS_FMT
457 "%s: Firmware BUG:" \
458 " config page mismatch:"
459 " Requested PageType(0x%02x)"
460 " Reply PageType(0x%02x)\n",
461 ioc->name, __func__,
462 (mpi_request->Header.PageType & 0xF),
463 (p[3] & 0xF));
464 }
465
466 if (((mpi_request->Header.PageType & 0xF) ==
467 MPI2_CONFIG_PAGETYPE_EXTENDED) &&
468 (mpi_request->ExtPageType != p[6])) {
469 _debug_dump_mf(mpi_request, ioc->request_sz/4);
470 _debug_dump_reply(mpi_reply, ioc->request_sz/4);
471 _debug_dump_config(p, min_t(u16, mem.sz,
472 config_page_sz)/4);
473 panic(KERN_WARNING MPT3SAS_FMT
474 "%s: Firmware BUG:" \
475 " config page mismatch:"
476 " Requested ExtPageType(0x%02x)"
477 " Reply ExtPageType(0x%02x)\n",
478 ioc->name, __func__,
479 mpi_request->ExtPageType, p[6]);
480 }
481 }
482 memcpy(config_page, mem.page, min_t(u16, mem.sz,
483 config_page_sz));
484 }
485
486 free_mem:
487 if (config_page)
488 _config_free_config_dma_memory(ioc, &mem);
489 out:
490 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
491 mutex_unlock(&ioc->config_cmds.mutex);
492
493 if (issue_host_reset)
494 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
495 FORCE_BIG_HAMMER);
496 return r;
497}
498
499/**
500 * mpt3sas_config_get_manufacturing_pg0 - obtain manufacturing page 0
501 * @ioc: per adapter object
502 * @mpi_reply: reply mf payload returned from firmware
503 * @config_page: contents of the config page
504 * Context: sleep.
505 *
506 * Returns 0 for success, non-zero for failure.
507 */
508int
509mpt3sas_config_get_manufacturing_pg0(struct MPT3SAS_ADAPTER *ioc,
510 Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage0_t *config_page)
511{
512 Mpi2ConfigRequest_t mpi_request;
513 int r;
514
515 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
516 mpi_request.Function = MPI2_FUNCTION_CONFIG;
517 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
518 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
519 mpi_request.Header.PageNumber = 0;
520 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
521 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
522 r = _config_request(ioc, &mpi_request, mpi_reply,
523 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
524 if (r)
525 goto out;
526
527 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
528 r = _config_request(ioc, &mpi_request, mpi_reply,
529 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
530 sizeof(*config_page));
531 out:
532 return r;
533}
534
535/**
536 * mpt3sas_config_get_manufacturing_pg7 - obtain manufacturing page 7
537 * @ioc: per adapter object
538 * @mpi_reply: reply mf payload returned from firmware
539 * @config_page: contents of the config page
540 * @sz: size of buffer passed in config_page
541 * Context: sleep.
542 *
543 * Returns 0 for success, non-zero for failure.
544 */
545int
546mpt3sas_config_get_manufacturing_pg7(struct MPT3SAS_ADAPTER *ioc,
547 Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage7_t *config_page,
548 u16 sz)
549{
550 Mpi2ConfigRequest_t mpi_request;
551 int r;
552
553 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
554 mpi_request.Function = MPI2_FUNCTION_CONFIG;
555 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
556 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
557 mpi_request.Header.PageNumber = 7;
558 mpi_request.Header.PageVersion = MPI2_MANUFACTURING7_PAGEVERSION;
559 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
560 r = _config_request(ioc, &mpi_request, mpi_reply,
561 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
562 if (r)
563 goto out;
564
565 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
566 r = _config_request(ioc, &mpi_request, mpi_reply,
567 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
568 sz);
569 out:
570 return r;
571}
572
573/**
574 * mpt3sas_config_get_manufacturing_pg10 - obtain manufacturing page 10
575 * @ioc: per adapter object
576 * @mpi_reply: reply mf payload returned from firmware
577 * @config_page: contents of the config page
578 * Context: sleep.
579 *
580 * Returns 0 for success, non-zero for failure.
581 */
582int
583mpt3sas_config_get_manufacturing_pg10(struct MPT3SAS_ADAPTER *ioc,
584 Mpi2ConfigReply_t *mpi_reply,
585 struct Mpi2ManufacturingPage10_t *config_page)
586{
587 Mpi2ConfigRequest_t mpi_request;
588 int r;
589
590 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
591 mpi_request.Function = MPI2_FUNCTION_CONFIG;
592 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
593 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
594 mpi_request.Header.PageNumber = 10;
595 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
596 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
597 r = _config_request(ioc, &mpi_request, mpi_reply,
598 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
599 if (r)
600 goto out;
601
602 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
603 r = _config_request(ioc, &mpi_request, mpi_reply,
604 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
605 sizeof(*config_page));
606 out:
607 return r;
608}
609
610/**
611 * mpt3sas_config_get_manufacturing_pg11 - obtain manufacturing page 11
612 * @ioc: per adapter object
613 * @mpi_reply: reply mf payload returned from firmware
614 * @config_page: contents of the config page
615 * Context: sleep.
616 *
617 * Returns 0 for success, non-zero for failure.
618 */
619int
620mpt3sas_config_get_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
621 Mpi2ConfigReply_t *mpi_reply,
622 struct Mpi2ManufacturingPage11_t *config_page)
623{
624 Mpi2ConfigRequest_t mpi_request;
625 int r;
626
627 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
628 mpi_request.Function = MPI2_FUNCTION_CONFIG;
629 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
630 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
631 mpi_request.Header.PageNumber = 11;
632 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
633 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
634 r = _config_request(ioc, &mpi_request, mpi_reply,
635 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
636 if (r)
637 goto out;
638
639 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
640 r = _config_request(ioc, &mpi_request, mpi_reply,
641 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
642 sizeof(*config_page));
643 out:
644 return r;
645}
646
647/**
648 * mpt3sas_config_set_manufacturing_pg11 - set manufacturing page 11
649 * @ioc: per adapter object
650 * @mpi_reply: reply mf payload returned from firmware
651 * @config_page: contents of the config page
652 * Context: sleep.
653 *
654 * Returns 0 for success, non-zero for failure.
655 */
656int
657mpt3sas_config_set_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
658 Mpi2ConfigReply_t *mpi_reply,
659 struct Mpi2ManufacturingPage11_t *config_page)
660{
661 Mpi2ConfigRequest_t mpi_request;
662 int r;
663
664 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
665 mpi_request.Function = MPI2_FUNCTION_CONFIG;
666 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
667 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
668 mpi_request.Header.PageNumber = 11;
669 mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
670 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
671 r = _config_request(ioc, &mpi_request, mpi_reply,
672 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
673 if (r)
674 goto out;
675
676 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
677 r = _config_request(ioc, &mpi_request, mpi_reply,
678 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
679 sizeof(*config_page));
680 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
681 r = _config_request(ioc, &mpi_request, mpi_reply,
682 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
683 sizeof(*config_page));
684 out:
685 return r;
686}
687
688/**
689 * mpt3sas_config_get_bios_pg2 - obtain bios page 2
690 * @ioc: per adapter object
691 * @mpi_reply: reply mf payload returned from firmware
692 * @config_page: contents of the config page
693 * Context: sleep.
694 *
695 * Returns 0 for success, non-zero for failure.
696 */
697int
698mpt3sas_config_get_bios_pg2(struct MPT3SAS_ADAPTER *ioc,
699 Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage2_t *config_page)
700{
701 Mpi2ConfigRequest_t mpi_request;
702 int r;
703
704 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
705 mpi_request.Function = MPI2_FUNCTION_CONFIG;
706 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
707 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
708 mpi_request.Header.PageNumber = 2;
709 mpi_request.Header.PageVersion = MPI2_BIOSPAGE2_PAGEVERSION;
710 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
711 r = _config_request(ioc, &mpi_request, mpi_reply,
712 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
713 if (r)
714 goto out;
715
716 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
717 r = _config_request(ioc, &mpi_request, mpi_reply,
718 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
719 sizeof(*config_page));
720 out:
721 return r;
722}
723
724/**
725 * mpt3sas_config_get_bios_pg3 - obtain bios page 3
726 * @ioc: per adapter object
727 * @mpi_reply: reply mf payload returned from firmware
728 * @config_page: contents of the config page
729 * Context: sleep.
730 *
731 * Returns 0 for success, non-zero for failure.
732 */
733int
734mpt3sas_config_get_bios_pg3(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
735 *mpi_reply, Mpi2BiosPage3_t *config_page)
736{
737 Mpi2ConfigRequest_t mpi_request;
738 int r;
739
740 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
741 mpi_request.Function = MPI2_FUNCTION_CONFIG;
742 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
743 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
744 mpi_request.Header.PageNumber = 3;
745 mpi_request.Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
746 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
747 r = _config_request(ioc, &mpi_request, mpi_reply,
748 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
749 if (r)
750 goto out;
751
752 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
753 r = _config_request(ioc, &mpi_request, mpi_reply,
754 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
755 sizeof(*config_page));
756 out:
757 return r;
758}
759
760/**
761 * mpt3sas_config_get_iounit_pg0 - obtain iounit page 0
762 * @ioc: per adapter object
763 * @mpi_reply: reply mf payload returned from firmware
764 * @config_page: contents of the config page
765 * Context: sleep.
766 *
767 * Returns 0 for success, non-zero for failure.
768 */
769int
770mpt3sas_config_get_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
771 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage0_t *config_page)
772{
773 Mpi2ConfigRequest_t mpi_request;
774 int r;
775
776 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
777 mpi_request.Function = MPI2_FUNCTION_CONFIG;
778 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
779 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
780 mpi_request.Header.PageNumber = 0;
781 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE0_PAGEVERSION;
782 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
783 r = _config_request(ioc, &mpi_request, mpi_reply,
784 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
785 if (r)
786 goto out;
787
788 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
789 r = _config_request(ioc, &mpi_request, mpi_reply,
790 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
791 sizeof(*config_page));
792 out:
793 return r;
794}
795
796/**
797 * mpt3sas_config_get_iounit_pg1 - obtain iounit page 1
798 * @ioc: per adapter object
799 * @mpi_reply: reply mf payload returned from firmware
800 * @config_page: contents of the config page
801 * Context: sleep.
802 *
803 * Returns 0 for success, non-zero for failure.
804 */
805int
806mpt3sas_config_get_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
807 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
808{
809 Mpi2ConfigRequest_t mpi_request;
810 int r;
811
812 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
813 mpi_request.Function = MPI2_FUNCTION_CONFIG;
814 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
815 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
816 mpi_request.Header.PageNumber = 1;
817 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
818 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
819 r = _config_request(ioc, &mpi_request, mpi_reply,
820 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
821 if (r)
822 goto out;
823
824 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
825 r = _config_request(ioc, &mpi_request, mpi_reply,
826 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
827 sizeof(*config_page));
828 out:
829 return r;
830}
831
832/**
833 * mpt3sas_config_set_iounit_pg1 - set iounit page 1
834 * @ioc: per adapter object
835 * @mpi_reply: reply mf payload returned from firmware
836 * @config_page: contents of the config page
837 * Context: sleep.
838 *
839 * Returns 0 for success, non-zero for failure.
840 */
841int
842mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
843 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
844{
845 Mpi2ConfigRequest_t mpi_request;
846 int r;
847
848 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
849 mpi_request.Function = MPI2_FUNCTION_CONFIG;
850 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
851 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
852 mpi_request.Header.PageNumber = 1;
853 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
854 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
855 r = _config_request(ioc, &mpi_request, mpi_reply,
856 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
857 if (r)
858 goto out;
859
860 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
861 r = _config_request(ioc, &mpi_request, mpi_reply,
862 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
863 sizeof(*config_page));
864 out:
865 return r;
866}
867
2d8ce8c9
SR		 868/**
869 * mpt3sas_config_get_iounit_pg8 - obtain iounit page 8
870 * @ioc: per adapter object
871 * @mpi_reply: reply mf payload returned from firmware
872 * @config_page: contents of the config page
873 * Context: sleep.
874 *
875 * Returns 0 for success, non-zero for failure.
876 */
877int
878mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER *ioc,
879 Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page)
880{
881 Mpi2ConfigRequest_t mpi_request;
882 int r;
883
884 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
885 mpi_request.Function = MPI2_FUNCTION_CONFIG;
886 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
887 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
888 mpi_request.Header.PageNumber = 8;
889 mpi_request.Header.PageVersion = MPI2_IOUNITPAGE8_PAGEVERSION;
890 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
891 r = _config_request(ioc, &mpi_request, mpi_reply,
892 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
893 if (r)
894 goto out;
895
896 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
897 r = _config_request(ioc, &mpi_request, mpi_reply,
898 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
899 sizeof(*config_page));
900 out:
901 return r;
902}
903
f92363d1
SR		 904/**
905 * mpt3sas_config_get_ioc_pg8 - obtain ioc page 8
906 * @ioc: per adapter object
907 * @mpi_reply: reply mf payload returned from firmware
908 * @config_page: contents of the config page
909 * Context: sleep.
910 *
911 * Returns 0 for success, non-zero for failure.
912 */
913int
914mpt3sas_config_get_ioc_pg8(struct MPT3SAS_ADAPTER *ioc,
915 Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage8_t *config_page)
916{
917 Mpi2ConfigRequest_t mpi_request;
918 int r;
919
920 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
921 mpi_request.Function = MPI2_FUNCTION_CONFIG;
922 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
923 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
924 mpi_request.Header.PageNumber = 8;
925 mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
926 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
927 r = _config_request(ioc, &mpi_request, mpi_reply,
928 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
929 if (r)
930 goto out;
931
932 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
933 r = _config_request(ioc, &mpi_request, mpi_reply,
934 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
935 sizeof(*config_page));
936 out:
937 return r;
938}
939
940/**
941 * mpt3sas_config_get_sas_device_pg0 - obtain sas device page 0
942 * @ioc: per adapter object
943 * @mpi_reply: reply mf payload returned from firmware
944 * @config_page: contents of the config page
945 * @form: GET_NEXT_HANDLE or HANDLE
946 * @handle: device handle
947 * Context: sleep.
948 *
949 * Returns 0 for success, non-zero for failure.
950 */
951int
952mpt3sas_config_get_sas_device_pg0(struct MPT3SAS_ADAPTER *ioc,
953 Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage0_t *config_page,
954 u32 form, u32 handle)
955{
956 Mpi2ConfigRequest_t mpi_request;
957 int r;
958
959 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
960 mpi_request.Function = MPI2_FUNCTION_CONFIG;
961 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
962 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
963 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
964 mpi_request.Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
965 mpi_request.Header.PageNumber = 0;
966 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
967 r = _config_request(ioc, &mpi_request, mpi_reply,
968 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
969 if (r)
970 goto out;
971
972 mpi_request.PageAddress = cpu_to_le32(form | handle);
973 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
974 r = _config_request(ioc, &mpi_request, mpi_reply,
975 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
976 sizeof(*config_page));
977 out:
978 return r;
979}
980
981/**
982 * mpt3sas_config_get_sas_device_pg1 - obtain sas device page 1
983 * @ioc: per adapter object
984 * @mpi_reply: reply mf payload returned from firmware
985 * @config_page: contents of the config page
986 * @form: GET_NEXT_HANDLE or HANDLE
987 * @handle: device handle
988 * Context: sleep.
989 *
990 * Returns 0 for success, non-zero for failure.
991 */
992int
993mpt3sas_config_get_sas_device_pg1(struct MPT3SAS_ADAPTER *ioc,
994 Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage1_t *config_page,
995 u32 form, u32 handle)
996{
997 Mpi2ConfigRequest_t mpi_request;
998 int r;
999
1000 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1001 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1002 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1003 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1004 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1005 mpi_request.Header.PageVersion = MPI2_SASDEVICE1_PAGEVERSION;
1006 mpi_request.Header.PageNumber = 1;
1007 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1008 r = _config_request(ioc, &mpi_request, mpi_reply,
1009 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1010 if (r)
1011 goto out;
1012
1013 mpi_request.PageAddress = cpu_to_le32(form | handle);
1014 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1015 r = _config_request(ioc, &mpi_request, mpi_reply,
1016 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1017 sizeof(*config_page));
1018 out:
1019 return r;
1020}
1021
1022/**
1023 * mpt3sas_config_get_number_hba_phys - obtain number of phys on the host
1024 * @ioc: per adapter object
1025 * @num_phys: pointer returned with the number of phys
1026 * Context: sleep.
1027 *
1028 * Returns 0 for success, non-zero for failure.
1029 */
1030int
1031mpt3sas_config_get_number_hba_phys(struct MPT3SAS_ADAPTER *ioc, u8 *num_phys)
1032{
1033 Mpi2ConfigRequest_t mpi_request;
1034 int r;
1035 u16 ioc_status;
1036 Mpi2ConfigReply_t mpi_reply;
1037 Mpi2SasIOUnitPage0_t config_page;
1038
1039 *num_phys = 0;
1040 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1041 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1042 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1043 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1044 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1045 mpi_request.Header.PageNumber = 0;
1046 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1047 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1048 r = _config_request(ioc, &mpi_request, &mpi_reply,
1049 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1050 if (r)
1051 goto out;
1052
1053 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1054 r = _config_request(ioc, &mpi_request, &mpi_reply,
1055 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1056 sizeof(Mpi2SasIOUnitPage0_t));
1057 if (!r) {
1058 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1059 MPI2_IOCSTATUS_MASK;
1060 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1061 *num_phys = config_page.NumPhys;
1062 }
1063 out:
1064 return r;
1065}
1066
1067/**
1068 * mpt3sas_config_get_sas_iounit_pg0 - obtain sas iounit page 0
1069 * @ioc: per adapter object
1070 * @mpi_reply: reply mf payload returned from firmware
1071 * @config_page: contents of the config page
1072 * @sz: size of buffer passed in config_page
1073 * Context: sleep.
1074 *
1075 * Calling function should call config_get_number_hba_phys prior to
1076 * this function, so enough memory is allocated for config_page.
1077 *
1078 * Returns 0 for success, non-zero for failure.
1079 */
1080int
1081mpt3sas_config_get_sas_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
1082 Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage0_t *config_page,
1083 u16 sz)
1084{
1085 Mpi2ConfigRequest_t mpi_request;
1086 int r;
1087
1088 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1089 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1090 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1091 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1092 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1093 mpi_request.Header.PageNumber = 0;
1094 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1095 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1096 r = _config_request(ioc, &mpi_request, mpi_reply,
1097 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1098 if (r)
1099 goto out;
1100
1101 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1102 r = _config_request(ioc, &mpi_request, mpi_reply,
1103 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1104 out:
1105 return r;
1106}
1107
1108/**
1109 * mpt3sas_config_get_sas_iounit_pg1 - obtain sas iounit page 1
1110 * @ioc: per adapter object
1111 * @mpi_reply: reply mf payload returned from firmware
1112 * @config_page: contents of the config page
1113 * @sz: size of buffer passed in config_page
1114 * Context: sleep.
1115 *
1116 * Calling function should call config_get_number_hba_phys prior to
1117 * this function, so enough memory is allocated for config_page.
1118 *
1119 * Returns 0 for success, non-zero for failure.
1120 */
1121int
1122mpt3sas_config_get_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1123 Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1124 u16 sz)
1125{
1126 Mpi2ConfigRequest_t mpi_request;
1127 int r;
1128
1129 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1130 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1131 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1132 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1133 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1134 mpi_request.Header.PageNumber = 1;
1135 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1136 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1137 r = _config_request(ioc, &mpi_request, mpi_reply,
1138 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1139 if (r)
1140 goto out;
1141
1142 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1143 r = _config_request(ioc, &mpi_request, mpi_reply,
1144 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1145 out:
1146 return r;
1147}
1148
1149/**
1150 * mpt3sas_config_set_sas_iounit_pg1 - send sas iounit page 1
1151 * @ioc: per adapter object
1152 * @mpi_reply: reply mf payload returned from firmware
1153 * @config_page: contents of the config page
1154 * @sz: size of buffer passed in config_page
1155 * Context: sleep.
1156 *
1157 * Calling function should call config_get_number_hba_phys prior to
1158 * this function, so enough memory is allocated for config_page.
1159 *
1160 * Returns 0 for success, non-zero for failure.
1161 */
1162int
1163mpt3sas_config_set_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1164 Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1165 u16 sz)
1166{
1167 Mpi2ConfigRequest_t mpi_request;
1168 int r;
1169
1170 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1171 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1172 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1173 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1174 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1175 mpi_request.Header.PageNumber = 1;
1176 mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1177 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1178 r = _config_request(ioc, &mpi_request, mpi_reply,
1179 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1180 if (r)
1181 goto out;
1182
1183 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1184 _config_request(ioc, &mpi_request, mpi_reply,
1185 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1186 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
1187 r = _config_request(ioc, &mpi_request, mpi_reply,
1188 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1189 out:
1190 return r;
1191}
1192
1193/**
1194 * mpt3sas_config_get_expander_pg0 - obtain expander page 0
1195 * @ioc: per adapter object
1196 * @mpi_reply: reply mf payload returned from firmware
1197 * @config_page: contents of the config page
1198 * @form: GET_NEXT_HANDLE or HANDLE
1199 * @handle: expander handle
1200 * Context: sleep.
1201 *
1202 * Returns 0 for success, non-zero for failure.
1203 */
1204int
1205mpt3sas_config_get_expander_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1206 *mpi_reply, Mpi2ExpanderPage0_t *config_page, u32 form, u32 handle)
1207{
1208 Mpi2ConfigRequest_t mpi_request;
1209 int r;
1210
1211 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1212 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1213 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1214 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1215 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1216 mpi_request.Header.PageNumber = 0;
1217 mpi_request.Header.PageVersion = MPI2_SASEXPANDER0_PAGEVERSION;
1218 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1219 r = _config_request(ioc, &mpi_request, mpi_reply,
1220 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1221 if (r)
1222 goto out;
1223
1224 mpi_request.PageAddress = cpu_to_le32(form | handle);
1225 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1226 r = _config_request(ioc, &mpi_request, mpi_reply,
1227 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1228 sizeof(*config_page));
1229 out:
1230 return r;
1231}
1232
1233/**
1234 * mpt3sas_config_get_expander_pg1 - obtain expander page 1
1235 * @ioc: per adapter object
1236 * @mpi_reply: reply mf payload returned from firmware
1237 * @config_page: contents of the config page
1238 * @phy_number: phy number
1239 * @handle: expander handle
1240 * Context: sleep.
1241 *
1242 * Returns 0 for success, non-zero for failure.
1243 */
1244int
1245mpt3sas_config_get_expander_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1246 *mpi_reply, Mpi2ExpanderPage1_t *config_page, u32 phy_number,
1247 u16 handle)
1248{
1249 Mpi2ConfigRequest_t mpi_request;
1250 int r;
1251
1252 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1253 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1254 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1255 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1256 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1257 mpi_request.Header.PageNumber = 1;
1258 mpi_request.Header.PageVersion = MPI2_SASEXPANDER1_PAGEVERSION;
1259 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1260 r = _config_request(ioc, &mpi_request, mpi_reply,
1261 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1262 if (r)
1263 goto out;
1264
1265 mpi_request.PageAddress =
1266 cpu_to_le32(MPI2_SAS_EXPAND_PGAD_FORM_HNDL_PHY_NUM |
1267 (phy_number << MPI2_SAS_EXPAND_PGAD_PHYNUM_SHIFT) | handle);
1268 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1269 r = _config_request(ioc, &mpi_request, mpi_reply,
1270 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1271 sizeof(*config_page));
1272 out:
1273 return r;
1274}
1275
1276/**
1277 * mpt3sas_config_get_enclosure_pg0 - obtain enclosure page 0
1278 * @ioc: per adapter object
1279 * @mpi_reply: reply mf payload returned from firmware
1280 * @config_page: contents of the config page
1281 * @form: GET_NEXT_HANDLE or HANDLE
1282 * @handle: expander handle
1283 * Context: sleep.
1284 *
1285 * Returns 0 for success, non-zero for failure.
1286 */
1287int
1288mpt3sas_config_get_enclosure_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1289 *mpi_reply, Mpi2SasEnclosurePage0_t *config_page, u32 form, u32 handle)
1290{
1291 Mpi2ConfigRequest_t mpi_request;
1292 int r;
1293
1294 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1295 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1296 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1297 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1298 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE;
1299 mpi_request.Header.PageNumber = 0;
1300 mpi_request.Header.PageVersion = MPI2_SASENCLOSURE0_PAGEVERSION;
1301 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1302 r = _config_request(ioc, &mpi_request, mpi_reply,
1303 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1304 if (r)
1305 goto out;
1306
1307 mpi_request.PageAddress = cpu_to_le32(form | handle);
1308 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1309 r = _config_request(ioc, &mpi_request, mpi_reply,
1310 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1311 sizeof(*config_page));
1312 out:
1313 return r;
1314}
1315
1316/**
1317 * mpt3sas_config_get_phy_pg0 - obtain phy page 0
1318 * @ioc: per adapter object
1319 * @mpi_reply: reply mf payload returned from firmware
1320 * @config_page: contents of the config page
1321 * @phy_number: phy number
1322 * Context: sleep.
1323 *
1324 * Returns 0 for success, non-zero for failure.
1325 */
1326int
1327mpt3sas_config_get_phy_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1328 *mpi_reply, Mpi2SasPhyPage0_t *config_page, u32 phy_number)
1329{
1330 Mpi2ConfigRequest_t mpi_request;
1331 int r;
1332
1333 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1334 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1335 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1336 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1337 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1338 mpi_request.Header.PageNumber = 0;
1339 mpi_request.Header.PageVersion = MPI2_SASPHY0_PAGEVERSION;
1340 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1341 r = _config_request(ioc, &mpi_request, mpi_reply,
1342 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1343 if (r)
1344 goto out;
1345
1346 mpi_request.PageAddress =
1347 cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1348 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1349 r = _config_request(ioc, &mpi_request, mpi_reply,
1350 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1351 sizeof(*config_page));
1352 out:
1353 return r;
1354}
1355
1356/**
1357 * mpt3sas_config_get_phy_pg1 - obtain phy page 1
1358 * @ioc: per adapter object
1359 * @mpi_reply: reply mf payload returned from firmware
1360 * @config_page: contents of the config page
1361 * @phy_number: phy number
1362 * Context: sleep.
1363 *
1364 * Returns 0 for success, non-zero for failure.
1365 */
1366int
1367mpt3sas_config_get_phy_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1368 *mpi_reply, Mpi2SasPhyPage1_t *config_page, u32 phy_number)
1369{
1370 Mpi2ConfigRequest_t mpi_request;
1371 int r;
1372
1373 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1374 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1375 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1376 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1377 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1378 mpi_request.Header.PageNumber = 1;
1379 mpi_request.Header.PageVersion = MPI2_SASPHY1_PAGEVERSION;
1380 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1381 r = _config_request(ioc, &mpi_request, mpi_reply,
1382 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1383 if (r)
1384 goto out;
1385
1386 mpi_request.PageAddress =
1387 cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1388 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1389 r = _config_request(ioc, &mpi_request, mpi_reply,
1390 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1391 sizeof(*config_page));
1392 out:
1393 return r;
1394}
1395
1396/**
1397 * mpt3sas_config_get_raid_volume_pg1 - obtain raid volume page 1
1398 * @ioc: per adapter object
1399 * @mpi_reply: reply mf payload returned from firmware
1400 * @config_page: contents of the config page
1401 * @form: GET_NEXT_HANDLE or HANDLE
1402 * @handle: volume handle
1403 * Context: sleep.
1404 *
1405 * Returns 0 for success, non-zero for failure.
1406 */
1407int
1408mpt3sas_config_get_raid_volume_pg1(struct MPT3SAS_ADAPTER *ioc,
1409 Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form,
1410 u32 handle)
1411{
1412 Mpi2ConfigRequest_t mpi_request;
1413 int r;
1414
1415 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1416 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1417 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1418 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1419 mpi_request.Header.PageNumber = 1;
1420 mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION;
1421 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1422 r = _config_request(ioc, &mpi_request, mpi_reply,
1423 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1424 if (r)
1425 goto out;
1426
1427 mpi_request.PageAddress = cpu_to_le32(form | handle);
1428 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1429 r = _config_request(ioc, &mpi_request, mpi_reply,
1430 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1431 sizeof(*config_page));
1432 out:
1433 return r;
1434}
1435
1436/**
1437 * mpt3sas_config_get_number_pds - obtain number of phys disk assigned to volume
1438 * @ioc: per adapter object
1439 * @handle: volume handle
1440 * @num_pds: returns pds count
1441 * Context: sleep.
1442 *
1443 * Returns 0 for success, non-zero for failure.
1444 */
1445int
1446mpt3sas_config_get_number_pds(struct MPT3SAS_ADAPTER *ioc, u16 handle,
1447 u8 *num_pds)
1448{
1449 Mpi2ConfigRequest_t mpi_request;
1450 Mpi2RaidVolPage0_t config_page;
1451 Mpi2ConfigReply_t mpi_reply;
1452 int r;
1453 u16 ioc_status;
1454
1455 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1456 *num_pds = 0;
1457 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1458 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1459 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1460 mpi_request.Header.PageNumber = 0;
1461 mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1462 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1463 r = _config_request(ioc, &mpi_request, &mpi_reply,
1464 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1465 if (r)
1466 goto out;
1467
1468 mpi_request.PageAddress =
1469 cpu_to_le32(MPI2_RAID_VOLUME_PGAD_FORM_HANDLE | handle);
1470 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1471 r = _config_request(ioc, &mpi_request, &mpi_reply,
1472 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1473 sizeof(Mpi2RaidVolPage0_t));
1474 if (!r) {
1475 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1476 MPI2_IOCSTATUS_MASK;
1477 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1478 *num_pds = config_page.NumPhysDisks;
1479 }
1480
1481 out:
1482 return r;
1483}
1484
1485/**
1486 * mpt3sas_config_get_raid_volume_pg0 - obtain raid volume page 0
1487 * @ioc: per adapter object
1488 * @mpi_reply: reply mf payload returned from firmware
1489 * @config_page: contents of the config page
1490 * @form: GET_NEXT_HANDLE or HANDLE
1491 * @handle: volume handle
1492 * @sz: size of buffer passed in config_page
1493 * Context: sleep.
1494 *
1495 * Returns 0 for success, non-zero for failure.
1496 */
1497int
1498mpt3sas_config_get_raid_volume_pg0(struct MPT3SAS_ADAPTER *ioc,
1499 Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 form,
1500 u32 handle, u16 sz)
1501{
1502 Mpi2ConfigRequest_t mpi_request;
1503 int r;
1504
1505 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1506 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1507 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1508 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1509 mpi_request.Header.PageNumber = 0;
1510 mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1511 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1512 r = _config_request(ioc, &mpi_request, mpi_reply,
1513 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1514 if (r)
1515 goto out;
1516
1517 mpi_request.PageAddress = cpu_to_le32(form | handle);
1518 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1519 r = _config_request(ioc, &mpi_request, mpi_reply,
1520 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1521 out:
1522 return r;
1523}
1524
1525/**
1526 * mpt3sas_config_get_phys_disk_pg0 - obtain phys disk page 0
1527 * @ioc: per adapter object
1528 * @mpi_reply: reply mf payload returned from firmware
1529 * @config_page: contents of the config page
1530 * @form: GET_NEXT_PHYSDISKNUM, PHYSDISKNUM, DEVHANDLE
1531 * @form_specific: specific to the form
1532 * Context: sleep.
1533 *
1534 * Returns 0 for success, non-zero for failure.
1535 */
1536int
1537mpt3sas_config_get_phys_disk_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1538 *mpi_reply, Mpi2RaidPhysDiskPage0_t *config_page, u32 form,
1539 u32 form_specific)
1540{
1541 Mpi2ConfigRequest_t mpi_request;
1542 int r;
1543
1544 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1545 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1546 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1547 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
1548 mpi_request.Header.PageNumber = 0;
1549 mpi_request.Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION;
1550 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1551 r = _config_request(ioc, &mpi_request, mpi_reply,
1552 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1553 if (r)
1554 goto out;
1555
1556 mpi_request.PageAddress = cpu_to_le32(form | form_specific);
1557 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1558 r = _config_request(ioc, &mpi_request, mpi_reply,
1559 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1560 sizeof(*config_page));
1561 out:
1562 return r;
1563}
1564
1565/**
1566 * mpt3sas_config_get_volume_handle - returns volume handle for give hidden
1567 * raid components
1568 * @ioc: per adapter object
1569 * @pd_handle: phys disk handle
1570 * @volume_handle: volume handle
1571 * Context: sleep.
1572 *
1573 * Returns 0 for success, non-zero for failure.
1574 */
1575int
1576mpt3sas_config_get_volume_handle(struct MPT3SAS_ADAPTER *ioc, u16 pd_handle,
1577 u16 *volume_handle)
1578{
1579 Mpi2RaidConfigurationPage0_t *config_page = NULL;
1580 Mpi2ConfigRequest_t mpi_request;
1581 Mpi2ConfigReply_t mpi_reply;
1582 int r, i, config_page_sz;
1583 u16 ioc_status;
1584 int config_num;
1585 u16 element_type;
1586 u16 phys_disk_dev_handle;
1587
1588 *volume_handle = 0;
1589 memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1590 mpi_request.Function = MPI2_FUNCTION_CONFIG;
1591 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1592 mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1593 mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG;
1594 mpi_request.Header.PageVersion = MPI2_RAIDCONFIG0_PAGEVERSION;
1595 mpi_request.Header.PageNumber = 0;
1596 ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1597 r = _config_request(ioc, &mpi_request, &mpi_reply,
1598 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1599 if (r)
1600 goto out;
1601
1602 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1603 config_page_sz = (le16_to_cpu(mpi_reply.ExtPageLength) * 4);
1604 config_page = kmalloc(config_page_sz, GFP_KERNEL);
1605 if (!config_page) {
1606 r = -1;
1607 goto out;
1608 }
1609
1610 config_num = 0xff;
1611 while (1) {
1612 mpi_request.PageAddress = cpu_to_le32(config_num +
1613 MPI2_RAID_PGAD_FORM_GET_NEXT_CONFIGNUM);
1614 r = _config_request(ioc, &mpi_request, &mpi_reply,
1615 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1616 config_page_sz);
1617 if (r)
1618 goto out;
1619 r = -1;
1620 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1621 MPI2_IOCSTATUS_MASK;
1622 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
1623 goto out;
1624 for (i = 0; i < config_page->NumElements; i++) {
1625 element_type = le16_to_cpu(config_page->
1626 ConfigElement[i].ElementFlags) &
1627 MPI2_RAIDCONFIG0_EFLAGS_MASK_ELEMENT_TYPE;
1628 if (element_type ==
1629 MPI2_RAIDCONFIG0_EFLAGS_VOL_PHYS_DISK_ELEMENT ||
1630 element_type ==
1631 MPI2_RAIDCONFIG0_EFLAGS_OCE_ELEMENT) {
1632 phys_disk_dev_handle =
1633 le16_to_cpu(config_page->ConfigElement[i].
1634 PhysDiskDevHandle);
1635 if (phys_disk_dev_handle == pd_handle) {
1636 *volume_handle =
1637 le16_to_cpu(config_page->
1638 ConfigElement[i].VolDevHandle);
1639 r = 0;
1640 goto out;
1641 }
1642 } else if (element_type ==
1643 MPI2_RAIDCONFIG0_EFLAGS_HOT_SPARE_ELEMENT) {
1644 *volume_handle = 0;
1645 r = 0;
1646 goto out;
1647 }
1648 }
1649 config_num = config_page->ConfigNum;
1650 }
1651 out:
1652 kfree(config_page);
1653 return r;
1654}
1655
1656/**
1657 * mpt3sas_config_get_volume_wwid - returns wwid given the volume handle
1658 * @ioc: per adapter object
1659 * @volume_handle: volume handle
1660 * @wwid: volume wwid
1661 * Context: sleep.
1662 *
1663 * Returns 0 for success, non-zero for failure.
1664 */
1665int
1666mpt3sas_config_get_volume_wwid(struct MPT3SAS_ADAPTER *ioc, u16 volume_handle,
1667 u64 *wwid)
1668{
1669 Mpi2ConfigReply_t mpi_reply;
1670 Mpi2RaidVolPage1_t raid_vol_pg1;
1671
1672 *wwid = 0;
1673 if (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1674 &raid_vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE,
1675 volume_handle))) {
1676 *wwid = le64_to_cpu(raid_vol_pg1.WWID);
1677 return 0;
1678 } else
1679 return -1;
1680}
Linux 6.x block layer and io_uring tree(s)