1 /* 2 * Management Module Support for MPT (Message Passing Technology) based 3 * controllers 4 * 5 * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c 6 * Copyright (C) 2012-2014 LSI Corporation 7 * Copyright (C) 2013-2014 Avago Technologies 8 * (mailto: MPT-FusionLinux.pdl@avagotech.com) 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 2 13 * of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * NO WARRANTY 21 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 22 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 23 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 24 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 25 * solely responsible for determining the appropriateness of using and 26 * distributing the Program and assumes all risks associated with its 27 * exercise of rights under this Agreement, including but not limited to 28 * the risks and costs of program errors, damage to or loss of data, 29 * programs or equipment, and unavailability or interruption of operations. 30 31 * DISCLAIMER OF LIABILITY 32 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 33 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 35 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 36 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 37 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 38 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 39 40 * You should have received a copy of the GNU General Public License 41 * along with this program; if not, write to the Free Software 42 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 43 * USA. 44 */ 45 46 #include <linux/kernel.h> 47 #include <linux/module.h> 48 #include <linux/errno.h> 49 #include <linux/init.h> 50 #include <linux/slab.h> 51 #include <linux/types.h> 52 #include <linux/pci.h> 53 #include <linux/delay.h> 54 #include <linux/compat.h> 55 #include <linux/poll.h> 56 57 #include <linux/io.h> 58 #include <linux/uaccess.h> 59 60 #include "mpt3sas_base.h" 61 #include "mpt3sas_ctl.h" 62 63 64 static struct fasync_struct *async_queue; 65 static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait); 66 67 68 /** 69 * enum block_state - blocking state 70 * @NON_BLOCKING: non blocking 71 * @BLOCKING: blocking 72 * 73 * These states are for ioctls that need to wait for a response 74 * from firmware, so they probably require sleep. 75 */ 76 enum block_state { 77 NON_BLOCKING, 78 BLOCKING, 79 }; 80 81 /** 82 * _ctl_display_some_debug - debug routine 83 * @ioc: per adapter object 84 * @smid: system request message index 85 * @calling_function_name: string pass from calling function 86 * @mpi_reply: reply message frame 87 * Context: none. 88 * 89 * Function for displaying debug info helpful when debugging issues 90 * in this module. 91 */ 92 static void 93 _ctl_display_some_debug(struct MPT3SAS_ADAPTER *ioc, u16 smid, 94 char *calling_function_name, MPI2DefaultReply_t *mpi_reply) 95 { 96 Mpi2ConfigRequest_t *mpi_request; 97 char *desc = NULL; 98 99 if (!(ioc->logging_level & MPT_DEBUG_IOCTL)) 100 return; 101 102 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 103 switch (mpi_request->Function) { 104 case MPI2_FUNCTION_SCSI_IO_REQUEST: 105 { 106 Mpi2SCSIIORequest_t *scsi_request = 107 (Mpi2SCSIIORequest_t *)mpi_request; 108 109 snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 110 "scsi_io, cmd(0x%02x), cdb_len(%d)", 111 scsi_request->CDB.CDB32[0], 112 le16_to_cpu(scsi_request->IoFlags) & 0xF); 113 desc = ioc->tmp_string; 114 break; 115 } 116 case MPI2_FUNCTION_SCSI_TASK_MGMT: 117 desc = "task_mgmt"; 118 break; 119 case MPI2_FUNCTION_IOC_INIT: 120 desc = "ioc_init"; 121 break; 122 case MPI2_FUNCTION_IOC_FACTS: 123 desc = "ioc_facts"; 124 break; 125 case MPI2_FUNCTION_CONFIG: 126 { 127 Mpi2ConfigRequest_t *config_request = 128 (Mpi2ConfigRequest_t *)mpi_request; 129 130 snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 131 "config, type(0x%02x), ext_type(0x%02x), number(%d)", 132 (config_request->Header.PageType & 133 MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType, 134 config_request->Header.PageNumber); 135 desc = ioc->tmp_string; 136 break; 137 } 138 case MPI2_FUNCTION_PORT_FACTS: 139 desc = "port_facts"; 140 break; 141 case MPI2_FUNCTION_PORT_ENABLE: 142 desc = "port_enable"; 143 break; 144 case MPI2_FUNCTION_EVENT_NOTIFICATION: 145 desc = "event_notification"; 146 break; 147 case MPI2_FUNCTION_FW_DOWNLOAD: 148 desc = "fw_download"; 149 break; 150 case MPI2_FUNCTION_FW_UPLOAD: 151 desc = "fw_upload"; 152 break; 153 case MPI2_FUNCTION_RAID_ACTION: 154 desc = "raid_action"; 155 break; 156 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 157 { 158 Mpi2SCSIIORequest_t *scsi_request = 159 (Mpi2SCSIIORequest_t *)mpi_request; 160 161 snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 162 "raid_pass, cmd(0x%02x), cdb_len(%d)", 163 scsi_request->CDB.CDB32[0], 164 le16_to_cpu(scsi_request->IoFlags) & 0xF); 165 desc = ioc->tmp_string; 166 break; 167 } 168 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 169 desc = "sas_iounit_cntl"; 170 break; 171 case MPI2_FUNCTION_SATA_PASSTHROUGH: 172 desc = "sata_pass"; 173 break; 174 case MPI2_FUNCTION_DIAG_BUFFER_POST: 175 desc = "diag_buffer_post"; 176 break; 177 case MPI2_FUNCTION_DIAG_RELEASE: 178 desc = "diag_release"; 179 break; 180 case MPI2_FUNCTION_SMP_PASSTHROUGH: 181 desc = "smp_passthrough"; 182 break; 183 case MPI2_FUNCTION_TOOLBOX: 184 desc = "toolbox"; 185 break; 186 case MPI2_FUNCTION_NVME_ENCAPSULATED: 187 desc = "nvme_encapsulated"; 188 break; 189 } 190 191 if (!desc) 192 return; 193 194 ioc_info(ioc, "%s: %s, smid(%d)\n", calling_function_name, desc, smid); 195 196 if (!mpi_reply) 197 return; 198 199 if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo) 200 ioc_info(ioc, "\tiocstatus(0x%04x), loginfo(0x%08x)\n", 201 le16_to_cpu(mpi_reply->IOCStatus), 202 le32_to_cpu(mpi_reply->IOCLogInfo)); 203 204 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 205 mpi_request->Function == 206 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 207 Mpi2SCSIIOReply_t *scsi_reply = 208 (Mpi2SCSIIOReply_t *)mpi_reply; 209 struct _sas_device *sas_device = NULL; 210 struct _pcie_device *pcie_device = NULL; 211 212 sas_device = mpt3sas_get_sdev_by_handle(ioc, 213 le16_to_cpu(scsi_reply->DevHandle)); 214 if (sas_device) { 215 ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n", 216 (u64)sas_device->sas_address, 217 sas_device->phy); 218 ioc_warn(ioc, "\tenclosure_logical_id(0x%016llx), slot(%d)\n", 219 (u64)sas_device->enclosure_logical_id, 220 sas_device->slot); 221 sas_device_put(sas_device); 222 } 223 if (!sas_device) { 224 pcie_device = mpt3sas_get_pdev_by_handle(ioc, 225 le16_to_cpu(scsi_reply->DevHandle)); 226 if (pcie_device) { 227 ioc_warn(ioc, "\tWWID(0x%016llx), port(%d)\n", 228 (unsigned long long)pcie_device->wwid, 229 pcie_device->port_num); 230 if (pcie_device->enclosure_handle != 0) 231 ioc_warn(ioc, "\tenclosure_logical_id(0x%016llx), slot(%d)\n", 232 (u64)pcie_device->enclosure_logical_id, 233 pcie_device->slot); 234 pcie_device_put(pcie_device); 235 } 236 } 237 if (scsi_reply->SCSIState || scsi_reply->SCSIStatus) 238 ioc_info(ioc, "\tscsi_state(0x%02x), scsi_status(0x%02x)\n", 239 scsi_reply->SCSIState, 240 scsi_reply->SCSIStatus); 241 } 242 } 243 244 /** 245 * mpt3sas_ctl_done - ctl module completion routine 246 * @ioc: per adapter object 247 * @smid: system request message index 248 * @msix_index: MSIX table index supplied by the OS 249 * @reply: reply message frame(lower 32bit addr) 250 * Context: none. 251 * 252 * The callback handler when using ioc->ctl_cb_idx. 253 * 254 * Return: 1 meaning mf should be freed from _base_interrupt 255 * 0 means the mf is freed from this function. 256 */ 257 u8 258 mpt3sas_ctl_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, 259 u32 reply) 260 { 261 MPI2DefaultReply_t *mpi_reply; 262 Mpi2SCSIIOReply_t *scsiio_reply; 263 Mpi26NVMeEncapsulatedErrorReply_t *nvme_error_reply; 264 const void *sense_data; 265 u32 sz; 266 267 if (ioc->ctl_cmds.status == MPT3_CMD_NOT_USED) 268 return 1; 269 if (ioc->ctl_cmds.smid != smid) 270 return 1; 271 ioc->ctl_cmds.status |= MPT3_CMD_COMPLETE; 272 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 273 if (mpi_reply) { 274 memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4); 275 ioc->ctl_cmds.status |= MPT3_CMD_REPLY_VALID; 276 /* get sense data */ 277 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 278 mpi_reply->Function == 279 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 280 scsiio_reply = (Mpi2SCSIIOReply_t *)mpi_reply; 281 if (scsiio_reply->SCSIState & 282 MPI2_SCSI_STATE_AUTOSENSE_VALID) { 283 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 284 le32_to_cpu(scsiio_reply->SenseCount)); 285 sense_data = mpt3sas_base_get_sense_buffer(ioc, 286 smid); 287 memcpy(ioc->ctl_cmds.sense, sense_data, sz); 288 } 289 } 290 /* 291 * Get Error Response data for NVMe device. The ctl_cmds.sense 292 * buffer is used to store the Error Response data. 293 */ 294 if (mpi_reply->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) { 295 nvme_error_reply = 296 (Mpi26NVMeEncapsulatedErrorReply_t *)mpi_reply; 297 sz = min_t(u32, NVME_ERROR_RESPONSE_SIZE, 298 le16_to_cpu(nvme_error_reply->ErrorResponseCount)); 299 sense_data = mpt3sas_base_get_sense_buffer(ioc, smid); 300 memcpy(ioc->ctl_cmds.sense, sense_data, sz); 301 } 302 } 303 304 _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply); 305 ioc->ctl_cmds.status &= ~MPT3_CMD_PENDING; 306 complete(&ioc->ctl_cmds.done); 307 return 1; 308 } 309 310 /** 311 * _ctl_check_event_type - determines when an event needs logging 312 * @ioc: per adapter object 313 * @event: firmware event 314 * 315 * The bitmask in ioc->event_type[] indicates which events should be 316 * be saved in the driver event_log. This bitmask is set by application. 317 * 318 * Return: 1 when event should be captured, or zero means no match. 319 */ 320 static int 321 _ctl_check_event_type(struct MPT3SAS_ADAPTER *ioc, u16 event) 322 { 323 u16 i; 324 u32 desired_event; 325 326 if (event >= 128 || !event || !ioc->event_log) 327 return 0; 328 329 desired_event = (1 << (event % 32)); 330 if (!desired_event) 331 desired_event = 1; 332 i = event / 32; 333 return desired_event & ioc->event_type[i]; 334 } 335 336 /** 337 * mpt3sas_ctl_add_to_event_log - add event 338 * @ioc: per adapter object 339 * @mpi_reply: reply message frame 340 */ 341 void 342 mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER *ioc, 343 Mpi2EventNotificationReply_t *mpi_reply) 344 { 345 struct MPT3_IOCTL_EVENTS *event_log; 346 u16 event; 347 int i; 348 u32 sz, event_data_sz; 349 u8 send_aen = 0; 350 351 if (!ioc->event_log) 352 return; 353 354 event = le16_to_cpu(mpi_reply->Event); 355 356 if (_ctl_check_event_type(ioc, event)) { 357 358 /* insert entry into circular event_log */ 359 i = ioc->event_context % MPT3SAS_CTL_EVENT_LOG_SIZE; 360 event_log = ioc->event_log; 361 event_log[i].event = event; 362 event_log[i].context = ioc->event_context++; 363 364 event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4; 365 sz = min_t(u32, event_data_sz, MPT3_EVENT_DATA_SIZE); 366 memset(event_log[i].data, 0, MPT3_EVENT_DATA_SIZE); 367 memcpy(event_log[i].data, mpi_reply->EventData, sz); 368 send_aen = 1; 369 } 370 371 /* This aen_event_read_flag flag is set until the 372 * application has read the event log. 373 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify. 374 */ 375 if (event == MPI2_EVENT_LOG_ENTRY_ADDED || 376 (send_aen && !ioc->aen_event_read_flag)) { 377 ioc->aen_event_read_flag = 1; 378 wake_up_interruptible(&ctl_poll_wait); 379 if (async_queue) 380 kill_fasync(&async_queue, SIGIO, POLL_IN); 381 } 382 } 383 384 /** 385 * mpt3sas_ctl_event_callback - firmware event handler (called at ISR time) 386 * @ioc: per adapter object 387 * @msix_index: MSIX table index supplied by the OS 388 * @reply: reply message frame(lower 32bit addr) 389 * Context: interrupt. 390 * 391 * This function merely adds a new work task into ioc->firmware_event_thread. 392 * The tasks are worked from _firmware_event_work in user context. 393 * 394 * Return: 1 meaning mf should be freed from _base_interrupt 395 * 0 means the mf is freed from this function. 396 */ 397 u8 398 mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, 399 u32 reply) 400 { 401 Mpi2EventNotificationReply_t *mpi_reply; 402 403 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 404 if (mpi_reply) 405 mpt3sas_ctl_add_to_event_log(ioc, mpi_reply); 406 return 1; 407 } 408 409 /** 410 * _ctl_verify_adapter - validates ioc_number passed from application 411 * @ioc_number: ? 412 * @iocpp: The ioc pointer is returned in this. 413 * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device & 414 * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device. 415 * 416 * Return: (-1) means error, else ioc_number. 417 */ 418 static int 419 _ctl_verify_adapter(int ioc_number, struct MPT3SAS_ADAPTER **iocpp, 420 int mpi_version) 421 { 422 struct MPT3SAS_ADAPTER *ioc; 423 int version = 0; 424 /* global ioc lock to protect controller on list operations */ 425 spin_lock(&gioc_lock); 426 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 427 if (ioc->id != ioc_number) 428 continue; 429 /* Check whether this ioctl command is from right 430 * ioctl device or not, if not continue the search. 431 */ 432 version = ioc->hba_mpi_version_belonged; 433 /* MPI25_VERSION and MPI26_VERSION uses same ioctl 434 * device. 435 */ 436 if (mpi_version == (MPI25_VERSION | MPI26_VERSION)) { 437 if ((version == MPI25_VERSION) || 438 (version == MPI26_VERSION)) 439 goto out; 440 else 441 continue; 442 } else { 443 if (version != mpi_version) 444 continue; 445 } 446 out: 447 spin_unlock(&gioc_lock); 448 *iocpp = ioc; 449 return ioc_number; 450 } 451 spin_unlock(&gioc_lock); 452 *iocpp = NULL; 453 return -1; 454 } 455 456 /** 457 * mpt3sas_ctl_reset_handler - reset callback handler (for ctl) 458 * @ioc: per adapter object 459 * 460 * The handler for doing any required cleanup or initialization. 461 */ 462 void mpt3sas_ctl_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc) 463 { 464 int i; 465 u8 issue_reset; 466 467 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__)); 468 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 469 if (!(ioc->diag_buffer_status[i] & 470 MPT3_DIAG_BUFFER_IS_REGISTERED)) 471 continue; 472 if ((ioc->diag_buffer_status[i] & 473 MPT3_DIAG_BUFFER_IS_RELEASED)) 474 continue; 475 476 /* 477 * add a log message to indicate the release 478 */ 479 ioc_info(ioc, 480 "%s: Releasing the trace buffer due to adapter reset.", 481 __func__); 482 mpt3sas_send_diag_release(ioc, i, &issue_reset); 483 } 484 } 485 486 /** 487 * mpt3sas_ctl_reset_handler - clears outstanding ioctl cmd. 488 * @ioc: per adapter object 489 * 490 * The handler for doing any required cleanup or initialization. 491 */ 492 void mpt3sas_ctl_clear_outstanding_ioctls(struct MPT3SAS_ADAPTER *ioc) 493 { 494 dtmprintk(ioc, 495 ioc_info(ioc, "%s: clear outstanding ioctl cmd\n", __func__)); 496 if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) { 497 ioc->ctl_cmds.status |= MPT3_CMD_RESET; 498 mpt3sas_base_free_smid(ioc, ioc->ctl_cmds.smid); 499 complete(&ioc->ctl_cmds.done); 500 } 501 } 502 503 /** 504 * mpt3sas_ctl_reset_handler - reset callback handler (for ctl) 505 * @ioc: per adapter object 506 * 507 * The handler for doing any required cleanup or initialization. 508 */ 509 void mpt3sas_ctl_reset_done_handler(struct MPT3SAS_ADAPTER *ioc) 510 { 511 int i; 512 513 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__)); 514 515 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 516 if (!(ioc->diag_buffer_status[i] & 517 MPT3_DIAG_BUFFER_IS_REGISTERED)) 518 continue; 519 if ((ioc->diag_buffer_status[i] & 520 MPT3_DIAG_BUFFER_IS_RELEASED)) 521 continue; 522 ioc->diag_buffer_status[i] |= 523 MPT3_DIAG_BUFFER_IS_DIAG_RESET; 524 } 525 } 526 527 /** 528 * _ctl_fasync - 529 * @fd: ? 530 * @filep: ? 531 * @mode: ? 532 * 533 * Called when application request fasyn callback handler. 534 */ 535 static int 536 _ctl_fasync(int fd, struct file *filep, int mode) 537 { 538 return fasync_helper(fd, filep, mode, &async_queue); 539 } 540 541 /** 542 * _ctl_poll - 543 * @filep: ? 544 * @wait: ? 545 * 546 */ 547 static __poll_t 548 _ctl_poll(struct file *filep, poll_table *wait) 549 { 550 struct MPT3SAS_ADAPTER *ioc; 551 552 poll_wait(filep, &ctl_poll_wait, wait); 553 554 /* global ioc lock to protect controller on list operations */ 555 spin_lock(&gioc_lock); 556 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 557 if (ioc->aen_event_read_flag) { 558 spin_unlock(&gioc_lock); 559 return EPOLLIN | EPOLLRDNORM; 560 } 561 } 562 spin_unlock(&gioc_lock); 563 return 0; 564 } 565 566 /** 567 * _ctl_set_task_mid - assign an active smid to tm request 568 * @ioc: per adapter object 569 * @karg: (struct mpt3_ioctl_command) 570 * @tm_request: pointer to mf from user space 571 * 572 * Return: 0 when an smid if found, else fail. 573 * during failure, the reply frame is filled. 574 */ 575 static int 576 _ctl_set_task_mid(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command *karg, 577 Mpi2SCSITaskManagementRequest_t *tm_request) 578 { 579 u8 found = 0; 580 u16 smid; 581 u16 handle; 582 struct scsi_cmnd *scmd; 583 struct MPT3SAS_DEVICE *priv_data; 584 Mpi2SCSITaskManagementReply_t *tm_reply; 585 u32 sz; 586 u32 lun; 587 char *desc = NULL; 588 589 if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK) 590 desc = "abort_task"; 591 else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) 592 desc = "query_task"; 593 else 594 return 0; 595 596 lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN); 597 598 handle = le16_to_cpu(tm_request->DevHandle); 599 for (smid = ioc->scsiio_depth; smid && !found; smid--) { 600 struct scsiio_tracker *st; 601 602 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 603 if (!scmd) 604 continue; 605 if (lun != scmd->device->lun) 606 continue; 607 priv_data = scmd->device->hostdata; 608 if (priv_data->sas_target == NULL) 609 continue; 610 if (priv_data->sas_target->handle != handle) 611 continue; 612 st = scsi_cmd_priv(scmd); 613 614 /* 615 * If the given TaskMID from the user space is zero, then the 616 * first outstanding smid will be picked up. Otherwise, 617 * targeted smid will be the one. 618 */ 619 if (!tm_request->TaskMID || tm_request->TaskMID == st->smid) { 620 tm_request->TaskMID = cpu_to_le16(st->smid); 621 found = 1; 622 } 623 } 624 625 if (!found) { 626 dctlprintk(ioc, 627 ioc_info(ioc, "%s: handle(0x%04x), lun(%d), no active mid!!\n", 628 desc, le16_to_cpu(tm_request->DevHandle), 629 lun)); 630 tm_reply = ioc->ctl_cmds.reply; 631 tm_reply->DevHandle = tm_request->DevHandle; 632 tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 633 tm_reply->TaskType = tm_request->TaskType; 634 tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4; 635 tm_reply->VP_ID = tm_request->VP_ID; 636 tm_reply->VF_ID = tm_request->VF_ID; 637 sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz); 638 if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply, 639 sz)) 640 pr_err("failure at %s:%d/%s()!\n", __FILE__, 641 __LINE__, __func__); 642 return 1; 643 } 644 645 dctlprintk(ioc, 646 ioc_info(ioc, "%s: handle(0x%04x), lun(%d), task_mid(%d)\n", 647 desc, le16_to_cpu(tm_request->DevHandle), lun, 648 le16_to_cpu(tm_request->TaskMID))); 649 return 0; 650 } 651 652 /** 653 * _ctl_do_mpt_command - main handler for MPT3COMMAND opcode 654 * @ioc: per adapter object 655 * @karg: (struct mpt3_ioctl_command) 656 * @mf: pointer to mf in user space 657 */ 658 static long 659 _ctl_do_mpt_command(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command karg, 660 void __user *mf) 661 { 662 MPI2RequestHeader_t *mpi_request = NULL, *request; 663 MPI2DefaultReply_t *mpi_reply; 664 Mpi26NVMeEncapsulatedRequest_t *nvme_encap_request = NULL; 665 struct _pcie_device *pcie_device = NULL; 666 u16 smid; 667 unsigned long timeout; 668 u8 issue_reset; 669 u32 sz, sz_arg; 670 void *psge; 671 void *data_out = NULL; 672 dma_addr_t data_out_dma = 0; 673 size_t data_out_sz = 0; 674 void *data_in = NULL; 675 dma_addr_t data_in_dma = 0; 676 size_t data_in_sz = 0; 677 long ret; 678 u16 device_handle = MPT3SAS_INVALID_DEVICE_HANDLE; 679 680 issue_reset = 0; 681 682 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 683 ioc_err(ioc, "%s: ctl_cmd in use\n", __func__); 684 ret = -EAGAIN; 685 goto out; 686 } 687 688 ret = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT); 689 if (ret) 690 goto out; 691 692 mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL); 693 if (!mpi_request) { 694 ioc_err(ioc, "%s: failed obtaining a memory for mpi_request\n", 695 __func__); 696 ret = -ENOMEM; 697 goto out; 698 } 699 700 /* Check for overflow and wraparound */ 701 if (karg.data_sge_offset * 4 > ioc->request_sz || 702 karg.data_sge_offset > (UINT_MAX / 4)) { 703 ret = -EINVAL; 704 goto out; 705 } 706 707 /* copy in request message frame from user */ 708 if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) { 709 pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__, 710 __func__); 711 ret = -EFAULT; 712 goto out; 713 } 714 715 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 716 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx); 717 if (!smid) { 718 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 719 ret = -EAGAIN; 720 goto out; 721 } 722 } else { 723 /* Use first reserved smid for passthrough ioctls */ 724 smid = ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT + 1; 725 } 726 727 ret = 0; 728 ioc->ctl_cmds.status = MPT3_CMD_PENDING; 729 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 730 request = mpt3sas_base_get_msg_frame(ioc, smid); 731 memset(request, 0, ioc->request_sz); 732 memcpy(request, mpi_request, karg.data_sge_offset*4); 733 ioc->ctl_cmds.smid = smid; 734 data_out_sz = karg.data_out_size; 735 data_in_sz = karg.data_in_size; 736 737 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 738 mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || 739 mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT || 740 mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH || 741 mpi_request->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) { 742 743 device_handle = le16_to_cpu(mpi_request->FunctionDependent1); 744 if (!device_handle || (device_handle > 745 ioc->facts.MaxDevHandle)) { 746 ret = -EINVAL; 747 mpt3sas_base_free_smid(ioc, smid); 748 goto out; 749 } 750 } 751 752 /* obtain dma-able memory for data transfer */ 753 if (data_out_sz) /* WRITE */ { 754 data_out = dma_alloc_coherent(&ioc->pdev->dev, data_out_sz, 755 &data_out_dma, GFP_KERNEL); 756 if (!data_out) { 757 pr_err("failure at %s:%d/%s()!\n", __FILE__, 758 __LINE__, __func__); 759 ret = -ENOMEM; 760 mpt3sas_base_free_smid(ioc, smid); 761 goto out; 762 } 763 if (copy_from_user(data_out, karg.data_out_buf_ptr, 764 data_out_sz)) { 765 pr_err("failure at %s:%d/%s()!\n", __FILE__, 766 __LINE__, __func__); 767 ret = -EFAULT; 768 mpt3sas_base_free_smid(ioc, smid); 769 goto out; 770 } 771 } 772 773 if (data_in_sz) /* READ */ { 774 data_in = dma_alloc_coherent(&ioc->pdev->dev, data_in_sz, 775 &data_in_dma, GFP_KERNEL); 776 if (!data_in) { 777 pr_err("failure at %s:%d/%s()!\n", __FILE__, 778 __LINE__, __func__); 779 ret = -ENOMEM; 780 mpt3sas_base_free_smid(ioc, smid); 781 goto out; 782 } 783 } 784 785 psge = (void *)request + (karg.data_sge_offset*4); 786 787 /* send command to firmware */ 788 _ctl_display_some_debug(ioc, smid, "ctl_request", NULL); 789 790 init_completion(&ioc->ctl_cmds.done); 791 switch (mpi_request->Function) { 792 case MPI2_FUNCTION_NVME_ENCAPSULATED: 793 { 794 nvme_encap_request = (Mpi26NVMeEncapsulatedRequest_t *)request; 795 if (!ioc->pcie_sg_lookup) { 796 dtmprintk(ioc, ioc_info(ioc, 797 "HBA doesn't support NVMe. Rejecting NVMe Encapsulated request.\n" 798 )); 799 800 if (ioc->logging_level & MPT_DEBUG_TM) 801 _debug_dump_mf(nvme_encap_request, 802 ioc->request_sz/4); 803 mpt3sas_base_free_smid(ioc, smid); 804 ret = -EINVAL; 805 goto out; 806 } 807 /* 808 * Get the Physical Address of the sense buffer. 809 * Use Error Response buffer address field to hold the sense 810 * buffer address. 811 * Clear the internal sense buffer, which will potentially hold 812 * the Completion Queue Entry on return, or 0 if no Entry. 813 * Build the PRPs and set direction bits. 814 * Send the request. 815 */ 816 nvme_encap_request->ErrorResponseBaseAddress = 817 cpu_to_le64(ioc->sense_dma & 0xFFFFFFFF00000000UL); 818 nvme_encap_request->ErrorResponseBaseAddress |= 819 cpu_to_le64(le32_to_cpu( 820 mpt3sas_base_get_sense_buffer_dma(ioc, smid))); 821 nvme_encap_request->ErrorResponseAllocationLength = 822 cpu_to_le16(NVME_ERROR_RESPONSE_SIZE); 823 memset(ioc->ctl_cmds.sense, 0, NVME_ERROR_RESPONSE_SIZE); 824 ioc->build_nvme_prp(ioc, smid, nvme_encap_request, 825 data_out_dma, data_out_sz, data_in_dma, data_in_sz); 826 if (test_bit(device_handle, ioc->device_remove_in_progress)) { 827 dtmprintk(ioc, 828 ioc_info(ioc, "handle(0x%04x): ioctl failed due to device removal in progress\n", 829 device_handle)); 830 mpt3sas_base_free_smid(ioc, smid); 831 ret = -EINVAL; 832 goto out; 833 } 834 mpt3sas_base_put_smid_nvme_encap(ioc, smid); 835 break; 836 } 837 case MPI2_FUNCTION_SCSI_IO_REQUEST: 838 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 839 { 840 Mpi2SCSIIORequest_t *scsiio_request = 841 (Mpi2SCSIIORequest_t *)request; 842 scsiio_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 843 scsiio_request->SenseBufferLowAddress = 844 mpt3sas_base_get_sense_buffer_dma(ioc, smid); 845 memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE); 846 if (test_bit(device_handle, ioc->device_remove_in_progress)) { 847 dtmprintk(ioc, 848 ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n", 849 device_handle)); 850 mpt3sas_base_free_smid(ioc, smid); 851 ret = -EINVAL; 852 goto out; 853 } 854 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, 855 data_in_dma, data_in_sz); 856 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST) 857 ioc->put_smid_scsi_io(ioc, smid, device_handle); 858 else 859 ioc->put_smid_default(ioc, smid); 860 break; 861 } 862 case MPI2_FUNCTION_SCSI_TASK_MGMT: 863 { 864 Mpi2SCSITaskManagementRequest_t *tm_request = 865 (Mpi2SCSITaskManagementRequest_t *)request; 866 867 dtmprintk(ioc, 868 ioc_info(ioc, "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n", 869 le16_to_cpu(tm_request->DevHandle), 870 tm_request->TaskType)); 871 ioc->got_task_abort_from_ioctl = 1; 872 if (tm_request->TaskType == 873 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK || 874 tm_request->TaskType == 875 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) { 876 if (_ctl_set_task_mid(ioc, &karg, tm_request)) { 877 mpt3sas_base_free_smid(ioc, smid); 878 ioc->got_task_abort_from_ioctl = 0; 879 goto out; 880 } 881 } 882 ioc->got_task_abort_from_ioctl = 0; 883 884 if (test_bit(device_handle, ioc->device_remove_in_progress)) { 885 dtmprintk(ioc, 886 ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n", 887 device_handle)); 888 mpt3sas_base_free_smid(ioc, smid); 889 ret = -EINVAL; 890 goto out; 891 } 892 mpt3sas_scsih_set_tm_flag(ioc, le16_to_cpu( 893 tm_request->DevHandle)); 894 ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 895 data_in_dma, data_in_sz); 896 ioc->put_smid_hi_priority(ioc, smid, 0); 897 break; 898 } 899 case MPI2_FUNCTION_SMP_PASSTHROUGH: 900 { 901 Mpi2SmpPassthroughRequest_t *smp_request = 902 (Mpi2SmpPassthroughRequest_t *)mpi_request; 903 u8 *data; 904 905 if (!ioc->multipath_on_hba) { 906 /* ioc determines which port to use */ 907 smp_request->PhysicalPort = 0xFF; 908 } 909 if (smp_request->PassthroughFlags & 910 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE) 911 data = (u8 *)&smp_request->SGL; 912 else { 913 if (unlikely(data_out == NULL)) { 914 pr_err("failure at %s:%d/%s()!\n", 915 __FILE__, __LINE__, __func__); 916 mpt3sas_base_free_smid(ioc, smid); 917 ret = -EINVAL; 918 goto out; 919 } 920 data = data_out; 921 } 922 923 if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) { 924 ioc->ioc_link_reset_in_progress = 1; 925 ioc->ignore_loginfos = 1; 926 } 927 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 928 data_in_sz); 929 ioc->put_smid_default(ioc, smid); 930 break; 931 } 932 case MPI2_FUNCTION_SATA_PASSTHROUGH: 933 { 934 if (test_bit(device_handle, ioc->device_remove_in_progress)) { 935 dtmprintk(ioc, 936 ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n", 937 device_handle)); 938 mpt3sas_base_free_smid(ioc, smid); 939 ret = -EINVAL; 940 goto out; 941 } 942 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 943 data_in_sz); 944 ioc->put_smid_default(ioc, smid); 945 break; 946 } 947 case MPI2_FUNCTION_FW_DOWNLOAD: 948 case MPI2_FUNCTION_FW_UPLOAD: 949 { 950 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 951 data_in_sz); 952 ioc->put_smid_default(ioc, smid); 953 break; 954 } 955 case MPI2_FUNCTION_TOOLBOX: 956 { 957 Mpi2ToolboxCleanRequest_t *toolbox_request = 958 (Mpi2ToolboxCleanRequest_t *)mpi_request; 959 960 if ((toolbox_request->Tool == MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL) 961 || (toolbox_request->Tool == 962 MPI26_TOOLBOX_BACKEND_PCIE_LANE_MARGIN)) 963 ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, 964 data_in_dma, data_in_sz); 965 else if (toolbox_request->Tool == 966 MPI2_TOOLBOX_MEMORY_MOVE_TOOL) { 967 Mpi2ToolboxMemMoveRequest_t *mem_move_request = 968 (Mpi2ToolboxMemMoveRequest_t *)request; 969 Mpi2SGESimple64_t tmp, *src = NULL, *dst = NULL; 970 971 ioc->build_sg_mpi(ioc, psge, data_out_dma, 972 data_out_sz, data_in_dma, data_in_sz); 973 if (data_out_sz && !data_in_sz) { 974 dst = 975 (Mpi2SGESimple64_t *)&mem_move_request->SGL; 976 src = (void *)dst + ioc->sge_size; 977 978 memcpy(&tmp, src, ioc->sge_size); 979 memcpy(src, dst, ioc->sge_size); 980 memcpy(dst, &tmp, ioc->sge_size); 981 } 982 if (ioc->logging_level & MPT_DEBUG_TM) { 983 ioc_info(ioc, 984 "Mpi2ToolboxMemMoveRequest_t request msg\n"); 985 _debug_dump_mf(mem_move_request, 986 ioc->request_sz/4); 987 } 988 } else 989 ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 990 data_in_dma, data_in_sz); 991 ioc->put_smid_default(ioc, smid); 992 break; 993 } 994 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 995 { 996 Mpi2SasIoUnitControlRequest_t *sasiounit_request = 997 (Mpi2SasIoUnitControlRequest_t *)mpi_request; 998 999 if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET 1000 || sasiounit_request->Operation == 1001 MPI2_SAS_OP_PHY_LINK_RESET) { 1002 ioc->ioc_link_reset_in_progress = 1; 1003 ioc->ignore_loginfos = 1; 1004 } 1005 /* drop to default case for posting the request */ 1006 } 1007 fallthrough; 1008 default: 1009 ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 1010 data_in_dma, data_in_sz); 1011 ioc->put_smid_default(ioc, smid); 1012 break; 1013 } 1014 1015 if (karg.timeout < MPT3_IOCTL_DEFAULT_TIMEOUT) 1016 timeout = MPT3_IOCTL_DEFAULT_TIMEOUT; 1017 else 1018 timeout = karg.timeout; 1019 wait_for_completion_timeout(&ioc->ctl_cmds.done, timeout*HZ); 1020 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 1021 Mpi2SCSITaskManagementRequest_t *tm_request = 1022 (Mpi2SCSITaskManagementRequest_t *)mpi_request; 1023 mpt3sas_scsih_clear_tm_flag(ioc, le16_to_cpu( 1024 tm_request->DevHandle)); 1025 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 1026 } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH || 1027 mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) && 1028 ioc->ioc_link_reset_in_progress) { 1029 ioc->ioc_link_reset_in_progress = 0; 1030 ioc->ignore_loginfos = 0; 1031 } 1032 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1033 mpt3sas_check_cmd_timeout(ioc, 1034 ioc->ctl_cmds.status, mpi_request, 1035 karg.data_sge_offset, issue_reset); 1036 goto issue_host_reset; 1037 } 1038 1039 mpi_reply = ioc->ctl_cmds.reply; 1040 1041 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT && 1042 (ioc->logging_level & MPT_DEBUG_TM)) { 1043 Mpi2SCSITaskManagementReply_t *tm_reply = 1044 (Mpi2SCSITaskManagementReply_t *)mpi_reply; 1045 1046 ioc_info(ioc, "TASK_MGMT: IOCStatus(0x%04x), IOCLogInfo(0x%08x), TerminationCount(0x%08x)\n", 1047 le16_to_cpu(tm_reply->IOCStatus), 1048 le32_to_cpu(tm_reply->IOCLogInfo), 1049 le32_to_cpu(tm_reply->TerminationCount)); 1050 } 1051 1052 /* copy out xdata to user */ 1053 if (data_in_sz) { 1054 if (copy_to_user(karg.data_in_buf_ptr, data_in, 1055 data_in_sz)) { 1056 pr_err("failure at %s:%d/%s()!\n", __FILE__, 1057 __LINE__, __func__); 1058 ret = -ENODATA; 1059 goto out; 1060 } 1061 } 1062 1063 /* copy out reply message frame to user */ 1064 if (karg.max_reply_bytes) { 1065 sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz); 1066 if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply, 1067 sz)) { 1068 pr_err("failure at %s:%d/%s()!\n", __FILE__, 1069 __LINE__, __func__); 1070 ret = -ENODATA; 1071 goto out; 1072 } 1073 } 1074 1075 /* copy out sense/NVMe Error Response to user */ 1076 if (karg.max_sense_bytes && (mpi_request->Function == 1077 MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function == 1078 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || mpi_request->Function == 1079 MPI2_FUNCTION_NVME_ENCAPSULATED)) { 1080 if (karg.sense_data_ptr == NULL) { 1081 ioc_info(ioc, "Response buffer provided by application is NULL; Response data will not be returned\n"); 1082 goto out; 1083 } 1084 sz_arg = (mpi_request->Function == 1085 MPI2_FUNCTION_NVME_ENCAPSULATED) ? NVME_ERROR_RESPONSE_SIZE : 1086 SCSI_SENSE_BUFFERSIZE; 1087 sz = min_t(u32, karg.max_sense_bytes, sz_arg); 1088 if (copy_to_user(karg.sense_data_ptr, ioc->ctl_cmds.sense, 1089 sz)) { 1090 pr_err("failure at %s:%d/%s()!\n", __FILE__, 1091 __LINE__, __func__); 1092 ret = -ENODATA; 1093 goto out; 1094 } 1095 } 1096 1097 issue_host_reset: 1098 if (issue_reset) { 1099 ret = -ENODATA; 1100 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 1101 mpi_request->Function == 1102 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || 1103 mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) { 1104 ioc_info(ioc, "issue target reset: handle = (0x%04x)\n", 1105 le16_to_cpu(mpi_request->FunctionDependent1)); 1106 mpt3sas_halt_firmware(ioc); 1107 pcie_device = mpt3sas_get_pdev_by_handle(ioc, 1108 le16_to_cpu(mpi_request->FunctionDependent1)); 1109 if (pcie_device && (!ioc->tm_custom_handling) && 1110 (!(mpt3sas_scsih_is_pcie_scsi_device( 1111 pcie_device->device_info)))) 1112 mpt3sas_scsih_issue_locked_tm(ioc, 1113 le16_to_cpu(mpi_request->FunctionDependent1), 1114 0, 0, 0, 1115 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 1116 0, pcie_device->reset_timeout, 1117 MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE); 1118 else 1119 mpt3sas_scsih_issue_locked_tm(ioc, 1120 le16_to_cpu(mpi_request->FunctionDependent1), 1121 0, 0, 0, 1122 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 1123 0, 30, MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET); 1124 } else 1125 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 1126 } 1127 1128 out: 1129 if (pcie_device) 1130 pcie_device_put(pcie_device); 1131 1132 /* free memory associated with sg buffers */ 1133 if (data_in) 1134 dma_free_coherent(&ioc->pdev->dev, data_in_sz, data_in, 1135 data_in_dma); 1136 1137 if (data_out) 1138 dma_free_coherent(&ioc->pdev->dev, data_out_sz, data_out, 1139 data_out_dma); 1140 1141 kfree(mpi_request); 1142 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1143 return ret; 1144 } 1145 1146 /** 1147 * _ctl_getiocinfo - main handler for MPT3IOCINFO opcode 1148 * @ioc: per adapter object 1149 * @arg: user space buffer containing ioctl content 1150 */ 1151 static long 1152 _ctl_getiocinfo(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1153 { 1154 struct mpt3_ioctl_iocinfo karg; 1155 1156 dctlprintk(ioc, ioc_info(ioc, "%s: enter\n", 1157 __func__)); 1158 1159 memset(&karg, 0 , sizeof(karg)); 1160 if (ioc->pfacts) 1161 karg.port_number = ioc->pfacts[0].PortNumber; 1162 karg.hw_rev = ioc->pdev->revision; 1163 karg.pci_id = ioc->pdev->device; 1164 karg.subsystem_device = ioc->pdev->subsystem_device; 1165 karg.subsystem_vendor = ioc->pdev->subsystem_vendor; 1166 karg.pci_information.u.bits.bus = ioc->pdev->bus->number; 1167 karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn); 1168 karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn); 1169 karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus); 1170 karg.firmware_version = ioc->facts.FWVersion.Word; 1171 strcpy(karg.driver_version, ioc->driver_name); 1172 strcat(karg.driver_version, "-"); 1173 switch (ioc->hba_mpi_version_belonged) { 1174 case MPI2_VERSION: 1175 if (ioc->is_warpdrive) 1176 karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200; 1177 else 1178 karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2; 1179 strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION); 1180 break; 1181 case MPI25_VERSION: 1182 case MPI26_VERSION: 1183 if (ioc->is_gen35_ioc) 1184 karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS35; 1185 else 1186 karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS3; 1187 strcat(karg.driver_version, MPT3SAS_DRIVER_VERSION); 1188 break; 1189 } 1190 karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 1191 1192 if (copy_to_user(arg, &karg, sizeof(karg))) { 1193 pr_err("failure at %s:%d/%s()!\n", 1194 __FILE__, __LINE__, __func__); 1195 return -EFAULT; 1196 } 1197 return 0; 1198 } 1199 1200 /** 1201 * _ctl_eventquery - main handler for MPT3EVENTQUERY opcode 1202 * @ioc: per adapter object 1203 * @arg: user space buffer containing ioctl content 1204 */ 1205 static long 1206 _ctl_eventquery(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1207 { 1208 struct mpt3_ioctl_eventquery karg; 1209 1210 if (copy_from_user(&karg, arg, sizeof(karg))) { 1211 pr_err("failure at %s:%d/%s()!\n", 1212 __FILE__, __LINE__, __func__); 1213 return -EFAULT; 1214 } 1215 1216 dctlprintk(ioc, ioc_info(ioc, "%s: enter\n", 1217 __func__)); 1218 1219 karg.event_entries = MPT3SAS_CTL_EVENT_LOG_SIZE; 1220 memcpy(karg.event_types, ioc->event_type, 1221 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1222 1223 if (copy_to_user(arg, &karg, sizeof(karg))) { 1224 pr_err("failure at %s:%d/%s()!\n", 1225 __FILE__, __LINE__, __func__); 1226 return -EFAULT; 1227 } 1228 return 0; 1229 } 1230 1231 /** 1232 * _ctl_eventenable - main handler for MPT3EVENTENABLE opcode 1233 * @ioc: per adapter object 1234 * @arg: user space buffer containing ioctl content 1235 */ 1236 static long 1237 _ctl_eventenable(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1238 { 1239 struct mpt3_ioctl_eventenable karg; 1240 1241 if (copy_from_user(&karg, arg, sizeof(karg))) { 1242 pr_err("failure at %s:%d/%s()!\n", 1243 __FILE__, __LINE__, __func__); 1244 return -EFAULT; 1245 } 1246 1247 dctlprintk(ioc, ioc_info(ioc, "%s: enter\n", 1248 __func__)); 1249 1250 memcpy(ioc->event_type, karg.event_types, 1251 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1252 mpt3sas_base_validate_event_type(ioc, ioc->event_type); 1253 1254 if (ioc->event_log) 1255 return 0; 1256 /* initialize event_log */ 1257 ioc->event_context = 0; 1258 ioc->aen_event_read_flag = 0; 1259 ioc->event_log = kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE, 1260 sizeof(struct MPT3_IOCTL_EVENTS), GFP_KERNEL); 1261 if (!ioc->event_log) { 1262 pr_err("failure at %s:%d/%s()!\n", 1263 __FILE__, __LINE__, __func__); 1264 return -ENOMEM; 1265 } 1266 return 0; 1267 } 1268 1269 /** 1270 * _ctl_eventreport - main handler for MPT3EVENTREPORT opcode 1271 * @ioc: per adapter object 1272 * @arg: user space buffer containing ioctl content 1273 */ 1274 static long 1275 _ctl_eventreport(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1276 { 1277 struct mpt3_ioctl_eventreport karg; 1278 u32 number_bytes, max_events, max; 1279 struct mpt3_ioctl_eventreport __user *uarg = arg; 1280 1281 if (copy_from_user(&karg, arg, sizeof(karg))) { 1282 pr_err("failure at %s:%d/%s()!\n", 1283 __FILE__, __LINE__, __func__); 1284 return -EFAULT; 1285 } 1286 1287 dctlprintk(ioc, ioc_info(ioc, "%s: enter\n", 1288 __func__)); 1289 1290 number_bytes = karg.hdr.max_data_size - 1291 sizeof(struct mpt3_ioctl_header); 1292 max_events = number_bytes/sizeof(struct MPT3_IOCTL_EVENTS); 1293 max = min_t(u32, MPT3SAS_CTL_EVENT_LOG_SIZE, max_events); 1294 1295 /* If fewer than 1 event is requested, there must have 1296 * been some type of error. 1297 */ 1298 if (!max || !ioc->event_log) 1299 return -ENODATA; 1300 1301 number_bytes = max * sizeof(struct MPT3_IOCTL_EVENTS); 1302 if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) { 1303 pr_err("failure at %s:%d/%s()!\n", 1304 __FILE__, __LINE__, __func__); 1305 return -EFAULT; 1306 } 1307 1308 /* reset flag so SIGIO can restart */ 1309 ioc->aen_event_read_flag = 0; 1310 return 0; 1311 } 1312 1313 /** 1314 * _ctl_do_reset - main handler for MPT3HARDRESET opcode 1315 * @ioc: per adapter object 1316 * @arg: user space buffer containing ioctl content 1317 */ 1318 static long 1319 _ctl_do_reset(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1320 { 1321 struct mpt3_ioctl_diag_reset karg; 1322 int retval; 1323 1324 if (copy_from_user(&karg, arg, sizeof(karg))) { 1325 pr_err("failure at %s:%d/%s()!\n", 1326 __FILE__, __LINE__, __func__); 1327 return -EFAULT; 1328 } 1329 1330 if (ioc->shost_recovery || ioc->pci_error_recovery || 1331 ioc->is_driver_loading) 1332 return -EAGAIN; 1333 1334 dctlprintk(ioc, ioc_info(ioc, "%s: enter\n", 1335 __func__)); 1336 1337 retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 1338 ioc_info(ioc, 1339 "Ioctl: host reset: %s\n", ((!retval) ? "SUCCESS" : "FAILED")); 1340 return 0; 1341 } 1342 1343 /** 1344 * _ctl_btdh_search_sas_device - searching for sas device 1345 * @ioc: per adapter object 1346 * @btdh: btdh ioctl payload 1347 */ 1348 static int 1349 _ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER *ioc, 1350 struct mpt3_ioctl_btdh_mapping *btdh) 1351 { 1352 struct _sas_device *sas_device; 1353 unsigned long flags; 1354 int rc = 0; 1355 1356 if (list_empty(&ioc->sas_device_list)) 1357 return rc; 1358 1359 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1360 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 1361 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1362 btdh->handle == sas_device->handle) { 1363 btdh->bus = sas_device->channel; 1364 btdh->id = sas_device->id; 1365 rc = 1; 1366 goto out; 1367 } else if (btdh->bus == sas_device->channel && btdh->id == 1368 sas_device->id && btdh->handle == 0xFFFF) { 1369 btdh->handle = sas_device->handle; 1370 rc = 1; 1371 goto out; 1372 } 1373 } 1374 out: 1375 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1376 return rc; 1377 } 1378 1379 /** 1380 * _ctl_btdh_search_pcie_device - searching for pcie device 1381 * @ioc: per adapter object 1382 * @btdh: btdh ioctl payload 1383 */ 1384 static int 1385 _ctl_btdh_search_pcie_device(struct MPT3SAS_ADAPTER *ioc, 1386 struct mpt3_ioctl_btdh_mapping *btdh) 1387 { 1388 struct _pcie_device *pcie_device; 1389 unsigned long flags; 1390 int rc = 0; 1391 1392 if (list_empty(&ioc->pcie_device_list)) 1393 return rc; 1394 1395 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1396 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) { 1397 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1398 btdh->handle == pcie_device->handle) { 1399 btdh->bus = pcie_device->channel; 1400 btdh->id = pcie_device->id; 1401 rc = 1; 1402 goto out; 1403 } else if (btdh->bus == pcie_device->channel && btdh->id == 1404 pcie_device->id && btdh->handle == 0xFFFF) { 1405 btdh->handle = pcie_device->handle; 1406 rc = 1; 1407 goto out; 1408 } 1409 } 1410 out: 1411 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1412 return rc; 1413 } 1414 1415 /** 1416 * _ctl_btdh_search_raid_device - searching for raid device 1417 * @ioc: per adapter object 1418 * @btdh: btdh ioctl payload 1419 */ 1420 static int 1421 _ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER *ioc, 1422 struct mpt3_ioctl_btdh_mapping *btdh) 1423 { 1424 struct _raid_device *raid_device; 1425 unsigned long flags; 1426 int rc = 0; 1427 1428 if (list_empty(&ioc->raid_device_list)) 1429 return rc; 1430 1431 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1432 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1433 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1434 btdh->handle == raid_device->handle) { 1435 btdh->bus = raid_device->channel; 1436 btdh->id = raid_device->id; 1437 rc = 1; 1438 goto out; 1439 } else if (btdh->bus == raid_device->channel && btdh->id == 1440 raid_device->id && btdh->handle == 0xFFFF) { 1441 btdh->handle = raid_device->handle; 1442 rc = 1; 1443 goto out; 1444 } 1445 } 1446 out: 1447 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1448 return rc; 1449 } 1450 1451 /** 1452 * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode 1453 * @ioc: per adapter object 1454 * @arg: user space buffer containing ioctl content 1455 */ 1456 static long 1457 _ctl_btdh_mapping(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1458 { 1459 struct mpt3_ioctl_btdh_mapping karg; 1460 int rc; 1461 1462 if (copy_from_user(&karg, arg, sizeof(karg))) { 1463 pr_err("failure at %s:%d/%s()!\n", 1464 __FILE__, __LINE__, __func__); 1465 return -EFAULT; 1466 } 1467 1468 dctlprintk(ioc, ioc_info(ioc, "%s\n", 1469 __func__)); 1470 1471 rc = _ctl_btdh_search_sas_device(ioc, &karg); 1472 if (!rc) 1473 rc = _ctl_btdh_search_pcie_device(ioc, &karg); 1474 if (!rc) 1475 _ctl_btdh_search_raid_device(ioc, &karg); 1476 1477 if (copy_to_user(arg, &karg, sizeof(karg))) { 1478 pr_err("failure at %s:%d/%s()!\n", 1479 __FILE__, __LINE__, __func__); 1480 return -EFAULT; 1481 } 1482 return 0; 1483 } 1484 1485 /** 1486 * _ctl_diag_capability - return diag buffer capability 1487 * @ioc: per adapter object 1488 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED 1489 * 1490 * returns 1 when diag buffer support is enabled in firmware 1491 */ 1492 static u8 1493 _ctl_diag_capability(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type) 1494 { 1495 u8 rc = 0; 1496 1497 switch (buffer_type) { 1498 case MPI2_DIAG_BUF_TYPE_TRACE: 1499 if (ioc->facts.IOCCapabilities & 1500 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) 1501 rc = 1; 1502 break; 1503 case MPI2_DIAG_BUF_TYPE_SNAPSHOT: 1504 if (ioc->facts.IOCCapabilities & 1505 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) 1506 rc = 1; 1507 break; 1508 case MPI2_DIAG_BUF_TYPE_EXTENDED: 1509 if (ioc->facts.IOCCapabilities & 1510 MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) 1511 rc = 1; 1512 } 1513 1514 return rc; 1515 } 1516 1517 /** 1518 * _ctl_diag_get_bufftype - return diag buffer type 1519 * either TRACE, SNAPSHOT, or EXTENDED 1520 * @ioc: per adapter object 1521 * @unique_id: specifies the unique_id for the buffer 1522 * 1523 * returns MPT3_DIAG_UID_NOT_FOUND if the id not found 1524 */ 1525 static u8 1526 _ctl_diag_get_bufftype(struct MPT3SAS_ADAPTER *ioc, u32 unique_id) 1527 { 1528 u8 index; 1529 1530 for (index = 0; index < MPI2_DIAG_BUF_TYPE_COUNT; index++) { 1531 if (ioc->unique_id[index] == unique_id) 1532 return index; 1533 } 1534 1535 return MPT3_DIAG_UID_NOT_FOUND; 1536 } 1537 1538 /** 1539 * _ctl_diag_register_2 - wrapper for registering diag buffer support 1540 * @ioc: per adapter object 1541 * @diag_register: the diag_register struct passed in from user space 1542 * 1543 */ 1544 static long 1545 _ctl_diag_register_2(struct MPT3SAS_ADAPTER *ioc, 1546 struct mpt3_diag_register *diag_register) 1547 { 1548 int rc, i; 1549 void *request_data = NULL; 1550 dma_addr_t request_data_dma; 1551 u32 request_data_sz = 0; 1552 Mpi2DiagBufferPostRequest_t *mpi_request; 1553 Mpi2DiagBufferPostReply_t *mpi_reply; 1554 u8 buffer_type; 1555 u16 smid; 1556 u16 ioc_status; 1557 u32 ioc_state; 1558 u8 issue_reset = 0; 1559 1560 dctlprintk(ioc, ioc_info(ioc, "%s\n", 1561 __func__)); 1562 1563 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 1564 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 1565 ioc_err(ioc, "%s: failed due to ioc not operational\n", 1566 __func__); 1567 rc = -EAGAIN; 1568 goto out; 1569 } 1570 1571 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 1572 ioc_err(ioc, "%s: ctl_cmd in use\n", __func__); 1573 rc = -EAGAIN; 1574 goto out; 1575 } 1576 1577 buffer_type = diag_register->buffer_type; 1578 if (!_ctl_diag_capability(ioc, buffer_type)) { 1579 ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n", 1580 __func__, buffer_type); 1581 return -EPERM; 1582 } 1583 1584 if (diag_register->unique_id == 0) { 1585 ioc_err(ioc, 1586 "%s: Invalid UID(0x%08x), buffer_type(0x%02x)\n", __func__, 1587 diag_register->unique_id, buffer_type); 1588 return -EINVAL; 1589 } 1590 1591 if ((ioc->diag_buffer_status[buffer_type] & 1592 MPT3_DIAG_BUFFER_IS_APP_OWNED) && 1593 !(ioc->diag_buffer_status[buffer_type] & 1594 MPT3_DIAG_BUFFER_IS_RELEASED)) { 1595 ioc_err(ioc, 1596 "%s: buffer_type(0x%02x) is already registered by application with UID(0x%08x)\n", 1597 __func__, buffer_type, ioc->unique_id[buffer_type]); 1598 return -EINVAL; 1599 } 1600 1601 if (ioc->diag_buffer_status[buffer_type] & 1602 MPT3_DIAG_BUFFER_IS_REGISTERED) { 1603 /* 1604 * If driver posts buffer initially, then an application wants 1605 * to Register that buffer (own it) without Releasing first, 1606 * the application Register command MUST have the same buffer 1607 * type and size in the Register command (obtained from the 1608 * Query command). Otherwise that Register command will be 1609 * failed. If the application has released the buffer but wants 1610 * to re-register it, it should be allowed as long as the 1611 * Unique-Id/Size match. 1612 */ 1613 1614 if (ioc->unique_id[buffer_type] == MPT3DIAGBUFFUNIQUEID && 1615 ioc->diag_buffer_sz[buffer_type] == 1616 diag_register->requested_buffer_size) { 1617 1618 if (!(ioc->diag_buffer_status[buffer_type] & 1619 MPT3_DIAG_BUFFER_IS_RELEASED)) { 1620 dctlprintk(ioc, ioc_info(ioc, 1621 "%s: diag_buffer (%d) ownership changed. old-ID(0x%08x), new-ID(0x%08x)\n", 1622 __func__, buffer_type, 1623 ioc->unique_id[buffer_type], 1624 diag_register->unique_id)); 1625 1626 /* 1627 * Application wants to own the buffer with 1628 * the same size. 1629 */ 1630 ioc->unique_id[buffer_type] = 1631 diag_register->unique_id; 1632 rc = 0; /* success */ 1633 goto out; 1634 } 1635 } else if (ioc->unique_id[buffer_type] != 1636 MPT3DIAGBUFFUNIQUEID) { 1637 if (ioc->unique_id[buffer_type] != 1638 diag_register->unique_id || 1639 ioc->diag_buffer_sz[buffer_type] != 1640 diag_register->requested_buffer_size || 1641 !(ioc->diag_buffer_status[buffer_type] & 1642 MPT3_DIAG_BUFFER_IS_RELEASED)) { 1643 ioc_err(ioc, 1644 "%s: already has a registered buffer for buffer_type(0x%02x)\n", 1645 __func__, buffer_type); 1646 return -EINVAL; 1647 } 1648 } else { 1649 ioc_err(ioc, "%s: already has a registered buffer for buffer_type(0x%02x)\n", 1650 __func__, buffer_type); 1651 return -EINVAL; 1652 } 1653 } else if (ioc->diag_buffer_status[buffer_type] & 1654 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED) { 1655 1656 if (ioc->unique_id[buffer_type] != MPT3DIAGBUFFUNIQUEID || 1657 ioc->diag_buffer_sz[buffer_type] != 1658 diag_register->requested_buffer_size) { 1659 1660 ioc_err(ioc, 1661 "%s: already a buffer is allocated for buffer_type(0x%02x) of size %d bytes, so please try registering again with same size\n", 1662 __func__, buffer_type, 1663 ioc->diag_buffer_sz[buffer_type]); 1664 return -EINVAL; 1665 } 1666 } 1667 1668 if (diag_register->requested_buffer_size % 4) { 1669 ioc_err(ioc, "%s: the requested_buffer_size is not 4 byte aligned\n", 1670 __func__); 1671 return -EINVAL; 1672 } 1673 1674 smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1675 if (!smid) { 1676 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 1677 rc = -EAGAIN; 1678 goto out; 1679 } 1680 1681 rc = 0; 1682 ioc->ctl_cmds.status = MPT3_CMD_PENDING; 1683 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1684 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 1685 ioc->ctl_cmds.smid = smid; 1686 1687 request_data = ioc->diag_buffer[buffer_type]; 1688 request_data_sz = diag_register->requested_buffer_size; 1689 ioc->unique_id[buffer_type] = diag_register->unique_id; 1690 ioc->diag_buffer_status[buffer_type] &= 1691 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED; 1692 memcpy(ioc->product_specific[buffer_type], 1693 diag_register->product_specific, MPT3_PRODUCT_SPECIFIC_DWORDS); 1694 ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags; 1695 1696 if (request_data) { 1697 request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1698 if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) { 1699 dma_free_coherent(&ioc->pdev->dev, 1700 ioc->diag_buffer_sz[buffer_type], 1701 request_data, request_data_dma); 1702 request_data = NULL; 1703 } 1704 } 1705 1706 if (request_data == NULL) { 1707 ioc->diag_buffer_sz[buffer_type] = 0; 1708 ioc->diag_buffer_dma[buffer_type] = 0; 1709 request_data = dma_alloc_coherent(&ioc->pdev->dev, 1710 request_data_sz, &request_data_dma, GFP_KERNEL); 1711 if (request_data == NULL) { 1712 ioc_err(ioc, "%s: failed allocating memory for diag buffers, requested size(%d)\n", 1713 __func__, request_data_sz); 1714 mpt3sas_base_free_smid(ioc, smid); 1715 rc = -ENOMEM; 1716 goto out; 1717 } 1718 ioc->diag_buffer[buffer_type] = request_data; 1719 ioc->diag_buffer_sz[buffer_type] = request_data_sz; 1720 ioc->diag_buffer_dma[buffer_type] = request_data_dma; 1721 } 1722 1723 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 1724 mpi_request->BufferType = diag_register->buffer_type; 1725 mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags); 1726 mpi_request->BufferAddress = cpu_to_le64(request_data_dma); 1727 mpi_request->BufferLength = cpu_to_le32(request_data_sz); 1728 mpi_request->VF_ID = 0; /* TODO */ 1729 mpi_request->VP_ID = 0; 1730 1731 dctlprintk(ioc, 1732 ioc_info(ioc, "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n", 1733 __func__, request_data, 1734 (unsigned long long)request_data_dma, 1735 le32_to_cpu(mpi_request->BufferLength))); 1736 1737 for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 1738 mpi_request->ProductSpecific[i] = 1739 cpu_to_le32(ioc->product_specific[buffer_type][i]); 1740 1741 init_completion(&ioc->ctl_cmds.done); 1742 ioc->put_smid_default(ioc, smid); 1743 wait_for_completion_timeout(&ioc->ctl_cmds.done, 1744 MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 1745 1746 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1747 mpt3sas_check_cmd_timeout(ioc, 1748 ioc->ctl_cmds.status, mpi_request, 1749 sizeof(Mpi2DiagBufferPostRequest_t)/4, issue_reset); 1750 goto issue_host_reset; 1751 } 1752 1753 /* process the completed Reply Message Frame */ 1754 if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 1755 ioc_err(ioc, "%s: no reply message\n", __func__); 1756 rc = -EFAULT; 1757 goto out; 1758 } 1759 1760 mpi_reply = ioc->ctl_cmds.reply; 1761 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1762 1763 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1764 ioc->diag_buffer_status[buffer_type] |= 1765 MPT3_DIAG_BUFFER_IS_REGISTERED; 1766 dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__)); 1767 } else { 1768 ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 1769 __func__, 1770 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1771 rc = -EFAULT; 1772 } 1773 1774 issue_host_reset: 1775 if (issue_reset) 1776 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 1777 1778 out: 1779 1780 if (rc && request_data) { 1781 dma_free_coherent(&ioc->pdev->dev, request_data_sz, 1782 request_data, request_data_dma); 1783 ioc->diag_buffer_status[buffer_type] &= 1784 ~MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED; 1785 } 1786 1787 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1788 return rc; 1789 } 1790 1791 /** 1792 * mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time 1793 * @ioc: per adapter object 1794 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1 1795 * 1796 * This is called when command line option diag_buffer_enable is enabled 1797 * at driver load time. 1798 */ 1799 void 1800 mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER *ioc, u8 bits_to_register) 1801 { 1802 struct mpt3_diag_register diag_register; 1803 u32 ret_val; 1804 u32 trace_buff_size = ioc->manu_pg11.HostTraceBufferMaxSizeKB<<10; 1805 u32 min_trace_buff_size = 0; 1806 u32 decr_trace_buff_size = 0; 1807 1808 memset(&diag_register, 0, sizeof(struct mpt3_diag_register)); 1809 1810 if (bits_to_register & 1) { 1811 ioc_info(ioc, "registering trace buffer support\n"); 1812 ioc->diag_trigger_master.MasterData = 1813 (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET); 1814 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 1815 diag_register.unique_id = 1816 (ioc->hba_mpi_version_belonged == MPI2_VERSION) ? 1817 (MPT2DIAGBUFFUNIQUEID):(MPT3DIAGBUFFUNIQUEID); 1818 1819 if (trace_buff_size != 0) { 1820 diag_register.requested_buffer_size = trace_buff_size; 1821 min_trace_buff_size = 1822 ioc->manu_pg11.HostTraceBufferMinSizeKB<<10; 1823 decr_trace_buff_size = 1824 ioc->manu_pg11.HostTraceBufferDecrementSizeKB<<10; 1825 1826 if (min_trace_buff_size > trace_buff_size) { 1827 /* The buff size is not set correctly */ 1828 ioc_err(ioc, 1829 "Min Trace Buff size (%d KB) greater than Max Trace Buff size (%d KB)\n", 1830 min_trace_buff_size>>10, 1831 trace_buff_size>>10); 1832 ioc_err(ioc, 1833 "Using zero Min Trace Buff Size\n"); 1834 min_trace_buff_size = 0; 1835 } 1836 1837 if (decr_trace_buff_size == 0) { 1838 /* 1839 * retry the min size if decrement 1840 * is not available. 1841 */ 1842 decr_trace_buff_size = 1843 trace_buff_size - min_trace_buff_size; 1844 } 1845 } else { 1846 /* register for 2MB buffers */ 1847 diag_register.requested_buffer_size = 2 * (1024 * 1024); 1848 } 1849 1850 do { 1851 ret_val = _ctl_diag_register_2(ioc, &diag_register); 1852 1853 if (ret_val == -ENOMEM && min_trace_buff_size && 1854 (trace_buff_size - decr_trace_buff_size) >= 1855 min_trace_buff_size) { 1856 /* adjust the buffer size */ 1857 trace_buff_size -= decr_trace_buff_size; 1858 diag_register.requested_buffer_size = 1859 trace_buff_size; 1860 } else 1861 break; 1862 } while (true); 1863 1864 if (ret_val == -ENOMEM) 1865 ioc_err(ioc, 1866 "Cannot allocate trace buffer memory. Last memory tried = %d KB\n", 1867 diag_register.requested_buffer_size>>10); 1868 else if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] 1869 & MPT3_DIAG_BUFFER_IS_REGISTERED) { 1870 ioc_err(ioc, "Trace buffer memory %d KB allocated\n", 1871 diag_register.requested_buffer_size>>10); 1872 if (ioc->hba_mpi_version_belonged != MPI2_VERSION) 1873 ioc->diag_buffer_status[ 1874 MPI2_DIAG_BUF_TYPE_TRACE] |= 1875 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED; 1876 } 1877 } 1878 1879 if (bits_to_register & 2) { 1880 ioc_info(ioc, "registering snapshot buffer support\n"); 1881 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT; 1882 /* register for 2MB buffers */ 1883 diag_register.requested_buffer_size = 2 * (1024 * 1024); 1884 diag_register.unique_id = 0x7075901; 1885 _ctl_diag_register_2(ioc, &diag_register); 1886 } 1887 1888 if (bits_to_register & 4) { 1889 ioc_info(ioc, "registering extended buffer support\n"); 1890 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED; 1891 /* register for 2MB buffers */ 1892 diag_register.requested_buffer_size = 2 * (1024 * 1024); 1893 diag_register.unique_id = 0x7075901; 1894 _ctl_diag_register_2(ioc, &diag_register); 1895 } 1896 } 1897 1898 /** 1899 * _ctl_diag_register - application register with driver 1900 * @ioc: per adapter object 1901 * @arg: user space buffer containing ioctl content 1902 * 1903 * This will allow the driver to setup any required buffers that will be 1904 * needed by firmware to communicate with the driver. 1905 */ 1906 static long 1907 _ctl_diag_register(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1908 { 1909 struct mpt3_diag_register karg; 1910 long rc; 1911 1912 if (copy_from_user(&karg, arg, sizeof(karg))) { 1913 pr_err("failure at %s:%d/%s()!\n", 1914 __FILE__, __LINE__, __func__); 1915 return -EFAULT; 1916 } 1917 1918 rc = _ctl_diag_register_2(ioc, &karg); 1919 1920 if (!rc && (ioc->diag_buffer_status[karg.buffer_type] & 1921 MPT3_DIAG_BUFFER_IS_REGISTERED)) 1922 ioc->diag_buffer_status[karg.buffer_type] |= 1923 MPT3_DIAG_BUFFER_IS_APP_OWNED; 1924 1925 return rc; 1926 } 1927 1928 /** 1929 * _ctl_diag_unregister - application unregister with driver 1930 * @ioc: per adapter object 1931 * @arg: user space buffer containing ioctl content 1932 * 1933 * This will allow the driver to cleanup any memory allocated for diag 1934 * messages and to free up any resources. 1935 */ 1936 static long 1937 _ctl_diag_unregister(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1938 { 1939 struct mpt3_diag_unregister karg; 1940 void *request_data; 1941 dma_addr_t request_data_dma; 1942 u32 request_data_sz; 1943 u8 buffer_type; 1944 1945 if (copy_from_user(&karg, arg, sizeof(karg))) { 1946 pr_err("failure at %s:%d/%s()!\n", 1947 __FILE__, __LINE__, __func__); 1948 return -EFAULT; 1949 } 1950 1951 dctlprintk(ioc, ioc_info(ioc, "%s\n", 1952 __func__)); 1953 1954 buffer_type = _ctl_diag_get_bufftype(ioc, karg.unique_id); 1955 if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) { 1956 ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n", 1957 __func__, karg.unique_id); 1958 return -EINVAL; 1959 } 1960 1961 if (!_ctl_diag_capability(ioc, buffer_type)) { 1962 ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n", 1963 __func__, buffer_type); 1964 return -EPERM; 1965 } 1966 1967 if ((ioc->diag_buffer_status[buffer_type] & 1968 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 1969 ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n", 1970 __func__, buffer_type); 1971 return -EINVAL; 1972 } 1973 if ((ioc->diag_buffer_status[buffer_type] & 1974 MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { 1975 ioc_err(ioc, "%s: buffer_type(0x%02x) has not been released\n", 1976 __func__, buffer_type); 1977 return -EINVAL; 1978 } 1979 1980 if (karg.unique_id != ioc->unique_id[buffer_type]) { 1981 ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n", 1982 __func__, karg.unique_id); 1983 return -EINVAL; 1984 } 1985 1986 request_data = ioc->diag_buffer[buffer_type]; 1987 if (!request_data) { 1988 ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n", 1989 __func__, buffer_type); 1990 return -ENOMEM; 1991 } 1992 1993 if (ioc->diag_buffer_status[buffer_type] & 1994 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED) { 1995 ioc->unique_id[buffer_type] = MPT3DIAGBUFFUNIQUEID; 1996 ioc->diag_buffer_status[buffer_type] &= 1997 ~MPT3_DIAG_BUFFER_IS_APP_OWNED; 1998 ioc->diag_buffer_status[buffer_type] &= 1999 ~MPT3_DIAG_BUFFER_IS_REGISTERED; 2000 } else { 2001 request_data_sz = ioc->diag_buffer_sz[buffer_type]; 2002 request_data_dma = ioc->diag_buffer_dma[buffer_type]; 2003 dma_free_coherent(&ioc->pdev->dev, request_data_sz, 2004 request_data, request_data_dma); 2005 ioc->diag_buffer[buffer_type] = NULL; 2006 ioc->diag_buffer_status[buffer_type] = 0; 2007 } 2008 return 0; 2009 } 2010 2011 /** 2012 * _ctl_diag_query - query relevant info associated with diag buffers 2013 * @ioc: per adapter object 2014 * @arg: user space buffer containing ioctl content 2015 * 2016 * The application will send only buffer_type and unique_id. Driver will 2017 * inspect unique_id first, if valid, fill in all the info. If unique_id is 2018 * 0x00, the driver will return info specified by Buffer Type. 2019 */ 2020 static long 2021 _ctl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 2022 { 2023 struct mpt3_diag_query karg; 2024 void *request_data; 2025 int i; 2026 u8 buffer_type; 2027 2028 if (copy_from_user(&karg, arg, sizeof(karg))) { 2029 pr_err("failure at %s:%d/%s()!\n", 2030 __FILE__, __LINE__, __func__); 2031 return -EFAULT; 2032 } 2033 2034 dctlprintk(ioc, ioc_info(ioc, "%s\n", 2035 __func__)); 2036 2037 karg.application_flags = 0; 2038 buffer_type = karg.buffer_type; 2039 2040 if (!_ctl_diag_capability(ioc, buffer_type)) { 2041 ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n", 2042 __func__, buffer_type); 2043 return -EPERM; 2044 } 2045 2046 if (!(ioc->diag_buffer_status[buffer_type] & 2047 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED)) { 2048 if ((ioc->diag_buffer_status[buffer_type] & 2049 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 2050 ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n", 2051 __func__, buffer_type); 2052 return -EINVAL; 2053 } 2054 } 2055 2056 if (karg.unique_id) { 2057 if (karg.unique_id != ioc->unique_id[buffer_type]) { 2058 ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n", 2059 __func__, karg.unique_id); 2060 return -EINVAL; 2061 } 2062 } 2063 2064 request_data = ioc->diag_buffer[buffer_type]; 2065 if (!request_data) { 2066 ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n", 2067 __func__, buffer_type); 2068 return -ENOMEM; 2069 } 2070 2071 if ((ioc->diag_buffer_status[buffer_type] & 2072 MPT3_DIAG_BUFFER_IS_REGISTERED)) 2073 karg.application_flags |= MPT3_APP_FLAGS_BUFFER_VALID; 2074 2075 if (!(ioc->diag_buffer_status[buffer_type] & 2076 MPT3_DIAG_BUFFER_IS_RELEASED)) 2077 karg.application_flags |= MPT3_APP_FLAGS_FW_BUFFER_ACCESS; 2078 2079 if (!(ioc->diag_buffer_status[buffer_type] & 2080 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED)) 2081 karg.application_flags |= MPT3_APP_FLAGS_DYNAMIC_BUFFER_ALLOC; 2082 2083 if ((ioc->diag_buffer_status[buffer_type] & 2084 MPT3_DIAG_BUFFER_IS_APP_OWNED)) 2085 karg.application_flags |= MPT3_APP_FLAGS_APP_OWNED; 2086 2087 for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 2088 karg.product_specific[i] = 2089 ioc->product_specific[buffer_type][i]; 2090 2091 karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type]; 2092 karg.driver_added_buffer_size = 0; 2093 karg.unique_id = ioc->unique_id[buffer_type]; 2094 karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type]; 2095 2096 if (copy_to_user(arg, &karg, sizeof(struct mpt3_diag_query))) { 2097 ioc_err(ioc, "%s: unable to write mpt3_diag_query data @ %p\n", 2098 __func__, arg); 2099 return -EFAULT; 2100 } 2101 return 0; 2102 } 2103 2104 /** 2105 * mpt3sas_send_diag_release - Diag Release Message 2106 * @ioc: per adapter object 2107 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED 2108 * @issue_reset: specifies whether host reset is required. 2109 * 2110 */ 2111 int 2112 mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type, 2113 u8 *issue_reset) 2114 { 2115 Mpi2DiagReleaseRequest_t *mpi_request; 2116 Mpi2DiagReleaseReply_t *mpi_reply; 2117 u16 smid; 2118 u16 ioc_status; 2119 u32 ioc_state; 2120 int rc; 2121 u8 reset_needed = 0; 2122 2123 dctlprintk(ioc, ioc_info(ioc, "%s\n", 2124 __func__)); 2125 2126 rc = 0; 2127 *issue_reset = 0; 2128 2129 2130 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 2131 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 2132 if (ioc->diag_buffer_status[buffer_type] & 2133 MPT3_DIAG_BUFFER_IS_REGISTERED) 2134 ioc->diag_buffer_status[buffer_type] |= 2135 MPT3_DIAG_BUFFER_IS_RELEASED; 2136 dctlprintk(ioc, 2137 ioc_info(ioc, "%s: skipping due to FAULT state\n", 2138 __func__)); 2139 rc = -EAGAIN; 2140 goto out; 2141 } 2142 2143 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 2144 ioc_err(ioc, "%s: ctl_cmd in use\n", __func__); 2145 rc = -EAGAIN; 2146 goto out; 2147 } 2148 2149 smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 2150 if (!smid) { 2151 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 2152 rc = -EAGAIN; 2153 goto out; 2154 } 2155 2156 ioc->ctl_cmds.status = MPT3_CMD_PENDING; 2157 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 2158 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 2159 ioc->ctl_cmds.smid = smid; 2160 2161 mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE; 2162 mpi_request->BufferType = buffer_type; 2163 mpi_request->VF_ID = 0; /* TODO */ 2164 mpi_request->VP_ID = 0; 2165 2166 init_completion(&ioc->ctl_cmds.done); 2167 ioc->put_smid_default(ioc, smid); 2168 wait_for_completion_timeout(&ioc->ctl_cmds.done, 2169 MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 2170 2171 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 2172 mpt3sas_check_cmd_timeout(ioc, 2173 ioc->ctl_cmds.status, mpi_request, 2174 sizeof(Mpi2DiagReleaseRequest_t)/4, reset_needed); 2175 *issue_reset = reset_needed; 2176 rc = -EFAULT; 2177 goto out; 2178 } 2179 2180 /* process the completed Reply Message Frame */ 2181 if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 2182 ioc_err(ioc, "%s: no reply message\n", __func__); 2183 rc = -EFAULT; 2184 goto out; 2185 } 2186 2187 mpi_reply = ioc->ctl_cmds.reply; 2188 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 2189 2190 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 2191 ioc->diag_buffer_status[buffer_type] |= 2192 MPT3_DIAG_BUFFER_IS_RELEASED; 2193 dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__)); 2194 } else { 2195 ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 2196 __func__, 2197 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 2198 rc = -EFAULT; 2199 } 2200 2201 out: 2202 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 2203 return rc; 2204 } 2205 2206 /** 2207 * _ctl_diag_release - request to send Diag Release Message to firmware 2208 * @ioc: ? 2209 * @arg: user space buffer containing ioctl content 2210 * 2211 * This allows ownership of the specified buffer to returned to the driver, 2212 * allowing an application to read the buffer without fear that firmware is 2213 * overwriting information in the buffer. 2214 */ 2215 static long 2216 _ctl_diag_release(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 2217 { 2218 struct mpt3_diag_release karg; 2219 void *request_data; 2220 int rc; 2221 u8 buffer_type; 2222 u8 issue_reset = 0; 2223 2224 if (copy_from_user(&karg, arg, sizeof(karg))) { 2225 pr_err("failure at %s:%d/%s()!\n", 2226 __FILE__, __LINE__, __func__); 2227 return -EFAULT; 2228 } 2229 2230 dctlprintk(ioc, ioc_info(ioc, "%s\n", 2231 __func__)); 2232 2233 buffer_type = _ctl_diag_get_bufftype(ioc, karg.unique_id); 2234 if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) { 2235 ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n", 2236 __func__, karg.unique_id); 2237 return -EINVAL; 2238 } 2239 2240 if (!_ctl_diag_capability(ioc, buffer_type)) { 2241 ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n", 2242 __func__, buffer_type); 2243 return -EPERM; 2244 } 2245 2246 if ((ioc->diag_buffer_status[buffer_type] & 2247 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 2248 ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n", 2249 __func__, buffer_type); 2250 return -EINVAL; 2251 } 2252 2253 if (karg.unique_id != ioc->unique_id[buffer_type]) { 2254 ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n", 2255 __func__, karg.unique_id); 2256 return -EINVAL; 2257 } 2258 2259 if (ioc->diag_buffer_status[buffer_type] & 2260 MPT3_DIAG_BUFFER_IS_RELEASED) { 2261 ioc_err(ioc, "%s: buffer_type(0x%02x) is already released\n", 2262 __func__, buffer_type); 2263 return -EINVAL; 2264 } 2265 2266 request_data = ioc->diag_buffer[buffer_type]; 2267 2268 if (!request_data) { 2269 ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n", 2270 __func__, buffer_type); 2271 return -ENOMEM; 2272 } 2273 2274 /* buffers were released by due to host reset */ 2275 if ((ioc->diag_buffer_status[buffer_type] & 2276 MPT3_DIAG_BUFFER_IS_DIAG_RESET)) { 2277 ioc->diag_buffer_status[buffer_type] |= 2278 MPT3_DIAG_BUFFER_IS_RELEASED; 2279 ioc->diag_buffer_status[buffer_type] &= 2280 ~MPT3_DIAG_BUFFER_IS_DIAG_RESET; 2281 ioc_err(ioc, "%s: buffer_type(0x%02x) was released due to host reset\n", 2282 __func__, buffer_type); 2283 return 0; 2284 } 2285 2286 rc = mpt3sas_send_diag_release(ioc, buffer_type, &issue_reset); 2287 2288 if (issue_reset) 2289 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 2290 2291 return rc; 2292 } 2293 2294 /** 2295 * _ctl_diag_read_buffer - request for copy of the diag buffer 2296 * @ioc: per adapter object 2297 * @arg: user space buffer containing ioctl content 2298 */ 2299 static long 2300 _ctl_diag_read_buffer(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 2301 { 2302 struct mpt3_diag_read_buffer karg; 2303 struct mpt3_diag_read_buffer __user *uarg = arg; 2304 void *request_data, *diag_data; 2305 Mpi2DiagBufferPostRequest_t *mpi_request; 2306 Mpi2DiagBufferPostReply_t *mpi_reply; 2307 int rc, i; 2308 u8 buffer_type; 2309 unsigned long request_size, copy_size; 2310 u16 smid; 2311 u16 ioc_status; 2312 u8 issue_reset = 0; 2313 2314 if (copy_from_user(&karg, arg, sizeof(karg))) { 2315 pr_err("failure at %s:%d/%s()!\n", 2316 __FILE__, __LINE__, __func__); 2317 return -EFAULT; 2318 } 2319 2320 dctlprintk(ioc, ioc_info(ioc, "%s\n", 2321 __func__)); 2322 2323 buffer_type = _ctl_diag_get_bufftype(ioc, karg.unique_id); 2324 if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) { 2325 ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n", 2326 __func__, karg.unique_id); 2327 return -EINVAL; 2328 } 2329 2330 if (!_ctl_diag_capability(ioc, buffer_type)) { 2331 ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n", 2332 __func__, buffer_type); 2333 return -EPERM; 2334 } 2335 2336 if (karg.unique_id != ioc->unique_id[buffer_type]) { 2337 ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n", 2338 __func__, karg.unique_id); 2339 return -EINVAL; 2340 } 2341 2342 request_data = ioc->diag_buffer[buffer_type]; 2343 if (!request_data) { 2344 ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n", 2345 __func__, buffer_type); 2346 return -ENOMEM; 2347 } 2348 2349 request_size = ioc->diag_buffer_sz[buffer_type]; 2350 2351 if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) { 2352 ioc_err(ioc, "%s: either the starting_offset or bytes_to_read are not 4 byte aligned\n", 2353 __func__); 2354 return -EINVAL; 2355 } 2356 2357 if (karg.starting_offset > request_size) 2358 return -EINVAL; 2359 2360 diag_data = (void *)(request_data + karg.starting_offset); 2361 dctlprintk(ioc, 2362 ioc_info(ioc, "%s: diag_buffer(%p), offset(%d), sz(%d)\n", 2363 __func__, diag_data, karg.starting_offset, 2364 karg.bytes_to_read)); 2365 2366 /* Truncate data on requests that are too large */ 2367 if ((diag_data + karg.bytes_to_read < diag_data) || 2368 (diag_data + karg.bytes_to_read > request_data + request_size)) 2369 copy_size = request_size - karg.starting_offset; 2370 else 2371 copy_size = karg.bytes_to_read; 2372 2373 if (copy_to_user((void __user *)uarg->diagnostic_data, 2374 diag_data, copy_size)) { 2375 ioc_err(ioc, "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n", 2376 __func__, diag_data); 2377 return -EFAULT; 2378 } 2379 2380 if ((karg.flags & MPT3_FLAGS_REREGISTER) == 0) 2381 return 0; 2382 2383 dctlprintk(ioc, 2384 ioc_info(ioc, "%s: Reregister buffer_type(0x%02x)\n", 2385 __func__, buffer_type)); 2386 if ((ioc->diag_buffer_status[buffer_type] & 2387 MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { 2388 dctlprintk(ioc, 2389 ioc_info(ioc, "%s: buffer_type(0x%02x) is still registered\n", 2390 __func__, buffer_type)); 2391 return 0; 2392 } 2393 /* Get a free request frame and save the message context. 2394 */ 2395 2396 if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 2397 ioc_err(ioc, "%s: ctl_cmd in use\n", __func__); 2398 rc = -EAGAIN; 2399 goto out; 2400 } 2401 2402 smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 2403 if (!smid) { 2404 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 2405 rc = -EAGAIN; 2406 goto out; 2407 } 2408 2409 rc = 0; 2410 ioc->ctl_cmds.status = MPT3_CMD_PENDING; 2411 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 2412 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 2413 ioc->ctl_cmds.smid = smid; 2414 2415 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 2416 mpi_request->BufferType = buffer_type; 2417 mpi_request->BufferLength = 2418 cpu_to_le32(ioc->diag_buffer_sz[buffer_type]); 2419 mpi_request->BufferAddress = 2420 cpu_to_le64(ioc->diag_buffer_dma[buffer_type]); 2421 for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 2422 mpi_request->ProductSpecific[i] = 2423 cpu_to_le32(ioc->product_specific[buffer_type][i]); 2424 mpi_request->VF_ID = 0; /* TODO */ 2425 mpi_request->VP_ID = 0; 2426 2427 init_completion(&ioc->ctl_cmds.done); 2428 ioc->put_smid_default(ioc, smid); 2429 wait_for_completion_timeout(&ioc->ctl_cmds.done, 2430 MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 2431 2432 if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 2433 mpt3sas_check_cmd_timeout(ioc, 2434 ioc->ctl_cmds.status, mpi_request, 2435 sizeof(Mpi2DiagBufferPostRequest_t)/4, issue_reset); 2436 goto issue_host_reset; 2437 } 2438 2439 /* process the completed Reply Message Frame */ 2440 if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 2441 ioc_err(ioc, "%s: no reply message\n", __func__); 2442 rc = -EFAULT; 2443 goto out; 2444 } 2445 2446 mpi_reply = ioc->ctl_cmds.reply; 2447 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 2448 2449 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 2450 ioc->diag_buffer_status[buffer_type] |= 2451 MPT3_DIAG_BUFFER_IS_REGISTERED; 2452 ioc->diag_buffer_status[buffer_type] &= 2453 ~MPT3_DIAG_BUFFER_IS_RELEASED; 2454 dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__)); 2455 } else { 2456 ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 2457 __func__, ioc_status, 2458 le32_to_cpu(mpi_reply->IOCLogInfo)); 2459 rc = -EFAULT; 2460 } 2461 2462 issue_host_reset: 2463 if (issue_reset) 2464 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 2465 2466 out: 2467 2468 ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 2469 return rc; 2470 } 2471 2472 2473 2474 #ifdef CONFIG_COMPAT 2475 /** 2476 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit. 2477 * @ioc: per adapter object 2478 * @cmd: ioctl opcode 2479 * @arg: (struct mpt3_ioctl_command32) 2480 * 2481 * MPT3COMMAND32 - Handle 32bit applications running on 64bit os. 2482 */ 2483 static long 2484 _ctl_compat_mpt_command(struct MPT3SAS_ADAPTER *ioc, unsigned cmd, 2485 void __user *arg) 2486 { 2487 struct mpt3_ioctl_command32 karg32; 2488 struct mpt3_ioctl_command32 __user *uarg; 2489 struct mpt3_ioctl_command karg; 2490 2491 if (_IOC_SIZE(cmd) != sizeof(struct mpt3_ioctl_command32)) 2492 return -EINVAL; 2493 2494 uarg = (struct mpt3_ioctl_command32 __user *) arg; 2495 2496 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) { 2497 pr_err("failure at %s:%d/%s()!\n", 2498 __FILE__, __LINE__, __func__); 2499 return -EFAULT; 2500 } 2501 2502 memset(&karg, 0, sizeof(struct mpt3_ioctl_command)); 2503 karg.hdr.ioc_number = karg32.hdr.ioc_number; 2504 karg.hdr.port_number = karg32.hdr.port_number; 2505 karg.hdr.max_data_size = karg32.hdr.max_data_size; 2506 karg.timeout = karg32.timeout; 2507 karg.max_reply_bytes = karg32.max_reply_bytes; 2508 karg.data_in_size = karg32.data_in_size; 2509 karg.data_out_size = karg32.data_out_size; 2510 karg.max_sense_bytes = karg32.max_sense_bytes; 2511 karg.data_sge_offset = karg32.data_sge_offset; 2512 karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr); 2513 karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr); 2514 karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr); 2515 karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr); 2516 return _ctl_do_mpt_command(ioc, karg, &uarg->mf); 2517 } 2518 #endif 2519 2520 /** 2521 * _ctl_ioctl_main - main ioctl entry point 2522 * @file: (struct file) 2523 * @cmd: ioctl opcode 2524 * @arg: user space data buffer 2525 * @compat: handles 32 bit applications in 64bit os 2526 * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device & 2527 * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device. 2528 */ 2529 static long 2530 _ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg, 2531 u8 compat, u16 mpi_version) 2532 { 2533 struct MPT3SAS_ADAPTER *ioc; 2534 struct mpt3_ioctl_header ioctl_header; 2535 enum block_state state; 2536 long ret = -EINVAL; 2537 2538 /* get IOCTL header */ 2539 if (copy_from_user(&ioctl_header, (char __user *)arg, 2540 sizeof(struct mpt3_ioctl_header))) { 2541 pr_err("failure at %s:%d/%s()!\n", 2542 __FILE__, __LINE__, __func__); 2543 return -EFAULT; 2544 } 2545 2546 if (_ctl_verify_adapter(ioctl_header.ioc_number, 2547 &ioc, mpi_version) == -1 || !ioc) 2548 return -ENODEV; 2549 2550 /* pci_access_mutex lock acquired by ioctl path */ 2551 mutex_lock(&ioc->pci_access_mutex); 2552 2553 if (ioc->shost_recovery || ioc->pci_error_recovery || 2554 ioc->is_driver_loading || ioc->remove_host) { 2555 ret = -EAGAIN; 2556 goto out_unlock_pciaccess; 2557 } 2558 2559 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING; 2560 if (state == NON_BLOCKING) { 2561 if (!mutex_trylock(&ioc->ctl_cmds.mutex)) { 2562 ret = -EAGAIN; 2563 goto out_unlock_pciaccess; 2564 } 2565 } else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) { 2566 ret = -ERESTARTSYS; 2567 goto out_unlock_pciaccess; 2568 } 2569 2570 2571 switch (cmd) { 2572 case MPT3IOCINFO: 2573 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_iocinfo)) 2574 ret = _ctl_getiocinfo(ioc, arg); 2575 break; 2576 #ifdef CONFIG_COMPAT 2577 case MPT3COMMAND32: 2578 #endif 2579 case MPT3COMMAND: 2580 { 2581 struct mpt3_ioctl_command __user *uarg; 2582 struct mpt3_ioctl_command karg; 2583 2584 #ifdef CONFIG_COMPAT 2585 if (compat) { 2586 ret = _ctl_compat_mpt_command(ioc, cmd, arg); 2587 break; 2588 } 2589 #endif 2590 if (copy_from_user(&karg, arg, sizeof(karg))) { 2591 pr_err("failure at %s:%d/%s()!\n", 2592 __FILE__, __LINE__, __func__); 2593 ret = -EFAULT; 2594 break; 2595 } 2596 2597 if (karg.hdr.ioc_number != ioctl_header.ioc_number) { 2598 ret = -EINVAL; 2599 break; 2600 } 2601 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_command)) { 2602 uarg = arg; 2603 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf); 2604 } 2605 break; 2606 } 2607 case MPT3EVENTQUERY: 2608 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventquery)) 2609 ret = _ctl_eventquery(ioc, arg); 2610 break; 2611 case MPT3EVENTENABLE: 2612 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventenable)) 2613 ret = _ctl_eventenable(ioc, arg); 2614 break; 2615 case MPT3EVENTREPORT: 2616 ret = _ctl_eventreport(ioc, arg); 2617 break; 2618 case MPT3HARDRESET: 2619 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_diag_reset)) 2620 ret = _ctl_do_reset(ioc, arg); 2621 break; 2622 case MPT3BTDHMAPPING: 2623 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_btdh_mapping)) 2624 ret = _ctl_btdh_mapping(ioc, arg); 2625 break; 2626 case MPT3DIAGREGISTER: 2627 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_register)) 2628 ret = _ctl_diag_register(ioc, arg); 2629 break; 2630 case MPT3DIAGUNREGISTER: 2631 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_unregister)) 2632 ret = _ctl_diag_unregister(ioc, arg); 2633 break; 2634 case MPT3DIAGQUERY: 2635 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_query)) 2636 ret = _ctl_diag_query(ioc, arg); 2637 break; 2638 case MPT3DIAGRELEASE: 2639 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_release)) 2640 ret = _ctl_diag_release(ioc, arg); 2641 break; 2642 case MPT3DIAGREADBUFFER: 2643 if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_read_buffer)) 2644 ret = _ctl_diag_read_buffer(ioc, arg); 2645 break; 2646 default: 2647 dctlprintk(ioc, 2648 ioc_info(ioc, "unsupported ioctl opcode(0x%08x)\n", 2649 cmd)); 2650 break; 2651 } 2652 2653 mutex_unlock(&ioc->ctl_cmds.mutex); 2654 out_unlock_pciaccess: 2655 mutex_unlock(&ioc->pci_access_mutex); 2656 return ret; 2657 } 2658 2659 /** 2660 * _ctl_ioctl - mpt3ctl main ioctl entry point (unlocked) 2661 * @file: (struct file) 2662 * @cmd: ioctl opcode 2663 * @arg: ? 2664 */ 2665 static long 2666 _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2667 { 2668 long ret; 2669 2670 /* pass MPI25_VERSION | MPI26_VERSION value, 2671 * to indicate that this ioctl cmd 2672 * came from mpt3ctl ioctl device. 2673 */ 2674 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0, 2675 MPI25_VERSION | MPI26_VERSION); 2676 return ret; 2677 } 2678 2679 /** 2680 * _ctl_mpt2_ioctl - mpt2ctl main ioctl entry point (unlocked) 2681 * @file: (struct file) 2682 * @cmd: ioctl opcode 2683 * @arg: ? 2684 */ 2685 static long 2686 _ctl_mpt2_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2687 { 2688 long ret; 2689 2690 /* pass MPI2_VERSION value, to indicate that this ioctl cmd 2691 * came from mpt2ctl ioctl device. 2692 */ 2693 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0, MPI2_VERSION); 2694 return ret; 2695 } 2696 #ifdef CONFIG_COMPAT 2697 /** 2698 *_ ctl_ioctl_compat - main ioctl entry point (compat) 2699 * @file: ? 2700 * @cmd: ? 2701 * @arg: ? 2702 * 2703 * This routine handles 32 bit applications in 64bit os. 2704 */ 2705 static long 2706 _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg) 2707 { 2708 long ret; 2709 2710 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1, 2711 MPI25_VERSION | MPI26_VERSION); 2712 return ret; 2713 } 2714 2715 /** 2716 *_ ctl_mpt2_ioctl_compat - main ioctl entry point (compat) 2717 * @file: ? 2718 * @cmd: ? 2719 * @arg: ? 2720 * 2721 * This routine handles 32 bit applications in 64bit os. 2722 */ 2723 static long 2724 _ctl_mpt2_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg) 2725 { 2726 long ret; 2727 2728 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1, MPI2_VERSION); 2729 return ret; 2730 } 2731 #endif 2732 2733 /* scsi host attributes */ 2734 /** 2735 * version_fw_show - firmware version 2736 * @cdev: pointer to embedded class device 2737 * @attr: ? 2738 * @buf: the buffer returned 2739 * 2740 * A sysfs 'read-only' shost attribute. 2741 */ 2742 static ssize_t 2743 version_fw_show(struct device *cdev, struct device_attribute *attr, 2744 char *buf) 2745 { 2746 struct Scsi_Host *shost = class_to_shost(cdev); 2747 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2748 2749 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2750 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24, 2751 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16, 2752 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8, 2753 ioc->facts.FWVersion.Word & 0x000000FF); 2754 } 2755 static DEVICE_ATTR_RO(version_fw); 2756 2757 /** 2758 * version_bios_show - bios version 2759 * @cdev: pointer to embedded class device 2760 * @attr: ? 2761 * @buf: the buffer returned 2762 * 2763 * A sysfs 'read-only' shost attribute. 2764 */ 2765 static ssize_t 2766 version_bios_show(struct device *cdev, struct device_attribute *attr, 2767 char *buf) 2768 { 2769 struct Scsi_Host *shost = class_to_shost(cdev); 2770 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2771 2772 u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 2773 2774 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2775 (version & 0xFF000000) >> 24, 2776 (version & 0x00FF0000) >> 16, 2777 (version & 0x0000FF00) >> 8, 2778 version & 0x000000FF); 2779 } 2780 static DEVICE_ATTR_RO(version_bios); 2781 2782 /** 2783 * version_mpi_show - MPI (message passing interface) version 2784 * @cdev: pointer to embedded class device 2785 * @attr: ? 2786 * @buf: the buffer returned 2787 * 2788 * A sysfs 'read-only' shost attribute. 2789 */ 2790 static ssize_t 2791 version_mpi_show(struct device *cdev, struct device_attribute *attr, 2792 char *buf) 2793 { 2794 struct Scsi_Host *shost = class_to_shost(cdev); 2795 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2796 2797 return snprintf(buf, PAGE_SIZE, "%03x.%02x\n", 2798 ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8); 2799 } 2800 static DEVICE_ATTR_RO(version_mpi); 2801 2802 /** 2803 * version_product_show - product name 2804 * @cdev: pointer to embedded class device 2805 * @attr: ? 2806 * @buf: the buffer returned 2807 * 2808 * A sysfs 'read-only' shost attribute. 2809 */ 2810 static ssize_t 2811 version_product_show(struct device *cdev, struct device_attribute *attr, 2812 char *buf) 2813 { 2814 struct Scsi_Host *shost = class_to_shost(cdev); 2815 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2816 2817 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName); 2818 } 2819 static DEVICE_ATTR_RO(version_product); 2820 2821 /** 2822 * version_nvdata_persistent_show - ndvata persistent version 2823 * @cdev: pointer to embedded class device 2824 * @attr: ? 2825 * @buf: the buffer returned 2826 * 2827 * A sysfs 'read-only' shost attribute. 2828 */ 2829 static ssize_t 2830 version_nvdata_persistent_show(struct device *cdev, 2831 struct device_attribute *attr, char *buf) 2832 { 2833 struct Scsi_Host *shost = class_to_shost(cdev); 2834 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2835 2836 return snprintf(buf, PAGE_SIZE, "%08xh\n", 2837 le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word)); 2838 } 2839 static DEVICE_ATTR_RO(version_nvdata_persistent); 2840 2841 /** 2842 * version_nvdata_default_show - nvdata default version 2843 * @cdev: pointer to embedded class device 2844 * @attr: ? 2845 * @buf: the buffer returned 2846 * 2847 * A sysfs 'read-only' shost attribute. 2848 */ 2849 static ssize_t 2850 version_nvdata_default_show(struct device *cdev, struct device_attribute 2851 *attr, char *buf) 2852 { 2853 struct Scsi_Host *shost = class_to_shost(cdev); 2854 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2855 2856 return snprintf(buf, PAGE_SIZE, "%08xh\n", 2857 le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word)); 2858 } 2859 static DEVICE_ATTR_RO(version_nvdata_default); 2860 2861 /** 2862 * board_name_show - board name 2863 * @cdev: pointer to embedded class device 2864 * @attr: ? 2865 * @buf: the buffer returned 2866 * 2867 * A sysfs 'read-only' shost attribute. 2868 */ 2869 static ssize_t 2870 board_name_show(struct device *cdev, struct device_attribute *attr, 2871 char *buf) 2872 { 2873 struct Scsi_Host *shost = class_to_shost(cdev); 2874 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2875 2876 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName); 2877 } 2878 static DEVICE_ATTR_RO(board_name); 2879 2880 /** 2881 * board_assembly_show - board assembly name 2882 * @cdev: pointer to embedded class device 2883 * @attr: ? 2884 * @buf: the buffer returned 2885 * 2886 * A sysfs 'read-only' shost attribute. 2887 */ 2888 static ssize_t 2889 board_assembly_show(struct device *cdev, struct device_attribute *attr, 2890 char *buf) 2891 { 2892 struct Scsi_Host *shost = class_to_shost(cdev); 2893 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2894 2895 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly); 2896 } 2897 static DEVICE_ATTR_RO(board_assembly); 2898 2899 /** 2900 * board_tracer_show - board tracer number 2901 * @cdev: pointer to embedded class device 2902 * @attr: ? 2903 * @buf: the buffer returned 2904 * 2905 * A sysfs 'read-only' shost attribute. 2906 */ 2907 static ssize_t 2908 board_tracer_show(struct device *cdev, struct device_attribute *attr, 2909 char *buf) 2910 { 2911 struct Scsi_Host *shost = class_to_shost(cdev); 2912 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2913 2914 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber); 2915 } 2916 static DEVICE_ATTR_RO(board_tracer); 2917 2918 /** 2919 * io_delay_show - io missing delay 2920 * @cdev: pointer to embedded class device 2921 * @attr: ? 2922 * @buf: the buffer returned 2923 * 2924 * This is for firmware implemention for deboucing device 2925 * removal events. 2926 * 2927 * A sysfs 'read-only' shost attribute. 2928 */ 2929 static ssize_t 2930 io_delay_show(struct device *cdev, struct device_attribute *attr, 2931 char *buf) 2932 { 2933 struct Scsi_Host *shost = class_to_shost(cdev); 2934 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2935 2936 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay); 2937 } 2938 static DEVICE_ATTR_RO(io_delay); 2939 2940 /** 2941 * device_delay_show - device missing delay 2942 * @cdev: pointer to embedded class device 2943 * @attr: ? 2944 * @buf: the buffer returned 2945 * 2946 * This is for firmware implemention for deboucing device 2947 * removal events. 2948 * 2949 * A sysfs 'read-only' shost attribute. 2950 */ 2951 static ssize_t 2952 device_delay_show(struct device *cdev, struct device_attribute *attr, 2953 char *buf) 2954 { 2955 struct Scsi_Host *shost = class_to_shost(cdev); 2956 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2957 2958 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay); 2959 } 2960 static DEVICE_ATTR_RO(device_delay); 2961 2962 /** 2963 * fw_queue_depth_show - global credits 2964 * @cdev: pointer to embedded class device 2965 * @attr: ? 2966 * @buf: the buffer returned 2967 * 2968 * This is firmware queue depth limit 2969 * 2970 * A sysfs 'read-only' shost attribute. 2971 */ 2972 static ssize_t 2973 fw_queue_depth_show(struct device *cdev, struct device_attribute *attr, 2974 char *buf) 2975 { 2976 struct Scsi_Host *shost = class_to_shost(cdev); 2977 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2978 2979 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit); 2980 } 2981 static DEVICE_ATTR_RO(fw_queue_depth); 2982 2983 /** 2984 * sas_address_show - sas address 2985 * @cdev: pointer to embedded class device 2986 * @attr: ? 2987 * @buf: the buffer returned 2988 * 2989 * This is the controller sas address 2990 * 2991 * A sysfs 'read-only' shost attribute. 2992 */ 2993 static ssize_t 2994 host_sas_address_show(struct device *cdev, struct device_attribute *attr, 2995 char *buf) 2996 2997 { 2998 struct Scsi_Host *shost = class_to_shost(cdev); 2999 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3000 3001 return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 3002 (unsigned long long)ioc->sas_hba.sas_address); 3003 } 3004 static DEVICE_ATTR_RO(host_sas_address); 3005 3006 /** 3007 * logging_level_show - logging level 3008 * @cdev: pointer to embedded class device 3009 * @attr: ? 3010 * @buf: the buffer returned 3011 * 3012 * A sysfs 'read/write' shost attribute. 3013 */ 3014 static ssize_t 3015 logging_level_show(struct device *cdev, struct device_attribute *attr, 3016 char *buf) 3017 { 3018 struct Scsi_Host *shost = class_to_shost(cdev); 3019 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3020 3021 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level); 3022 } 3023 static ssize_t 3024 logging_level_store(struct device *cdev, struct device_attribute *attr, 3025 const char *buf, size_t count) 3026 { 3027 struct Scsi_Host *shost = class_to_shost(cdev); 3028 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3029 int val = 0; 3030 3031 if (sscanf(buf, "%x", &val) != 1) 3032 return -EINVAL; 3033 3034 ioc->logging_level = val; 3035 ioc_info(ioc, "logging_level=%08xh\n", 3036 ioc->logging_level); 3037 return strlen(buf); 3038 } 3039 static DEVICE_ATTR_RW(logging_level); 3040 3041 /** 3042 * fwfault_debug_show - show/store fwfault_debug 3043 * @cdev: pointer to embedded class device 3044 * @attr: ? 3045 * @buf: the buffer returned 3046 * 3047 * mpt3sas_fwfault_debug is command line option 3048 * A sysfs 'read/write' shost attribute. 3049 */ 3050 static ssize_t 3051 fwfault_debug_show(struct device *cdev, struct device_attribute *attr, 3052 char *buf) 3053 { 3054 struct Scsi_Host *shost = class_to_shost(cdev); 3055 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3056 3057 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug); 3058 } 3059 static ssize_t 3060 fwfault_debug_store(struct device *cdev, struct device_attribute *attr, 3061 const char *buf, size_t count) 3062 { 3063 struct Scsi_Host *shost = class_to_shost(cdev); 3064 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3065 int val = 0; 3066 3067 if (sscanf(buf, "%d", &val) != 1) 3068 return -EINVAL; 3069 3070 ioc->fwfault_debug = val; 3071 ioc_info(ioc, "fwfault_debug=%d\n", 3072 ioc->fwfault_debug); 3073 return strlen(buf); 3074 } 3075 static DEVICE_ATTR_RW(fwfault_debug); 3076 3077 /** 3078 * ioc_reset_count_show - ioc reset count 3079 * @cdev: pointer to embedded class device 3080 * @attr: ? 3081 * @buf: the buffer returned 3082 * 3083 * This is firmware queue depth limit 3084 * 3085 * A sysfs 'read-only' shost attribute. 3086 */ 3087 static ssize_t 3088 ioc_reset_count_show(struct device *cdev, struct device_attribute *attr, 3089 char *buf) 3090 { 3091 struct Scsi_Host *shost = class_to_shost(cdev); 3092 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3093 3094 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->ioc_reset_count); 3095 } 3096 static DEVICE_ATTR_RO(ioc_reset_count); 3097 3098 /** 3099 * reply_queue_count_show - number of reply queues 3100 * @cdev: pointer to embedded class device 3101 * @attr: ? 3102 * @buf: the buffer returned 3103 * 3104 * This is number of reply queues 3105 * 3106 * A sysfs 'read-only' shost attribute. 3107 */ 3108 static ssize_t 3109 reply_queue_count_show(struct device *cdev, 3110 struct device_attribute *attr, char *buf) 3111 { 3112 u8 reply_queue_count; 3113 struct Scsi_Host *shost = class_to_shost(cdev); 3114 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3115 3116 if ((ioc->facts.IOCCapabilities & 3117 MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX) && ioc->msix_enable) 3118 reply_queue_count = ioc->reply_queue_count; 3119 else 3120 reply_queue_count = 1; 3121 3122 return snprintf(buf, PAGE_SIZE, "%d\n", reply_queue_count); 3123 } 3124 static DEVICE_ATTR_RO(reply_queue_count); 3125 3126 /** 3127 * BRM_status_show - Backup Rail Monitor Status 3128 * @cdev: pointer to embedded class device 3129 * @attr: ? 3130 * @buf: the buffer returned 3131 * 3132 * This is number of reply queues 3133 * 3134 * A sysfs 'read-only' shost attribute. 3135 */ 3136 static ssize_t 3137 BRM_status_show(struct device *cdev, struct device_attribute *attr, 3138 char *buf) 3139 { 3140 struct Scsi_Host *shost = class_to_shost(cdev); 3141 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3142 Mpi2IOUnitPage3_t *io_unit_pg3 = NULL; 3143 Mpi2ConfigReply_t mpi_reply; 3144 u16 backup_rail_monitor_status = 0; 3145 u16 ioc_status; 3146 int sz; 3147 ssize_t rc = 0; 3148 3149 if (!ioc->is_warpdrive) { 3150 ioc_err(ioc, "%s: BRM attribute is only for warpdrive\n", 3151 __func__); 3152 return 0; 3153 } 3154 /* pci_access_mutex lock acquired by sysfs show path */ 3155 mutex_lock(&ioc->pci_access_mutex); 3156 if (ioc->pci_error_recovery || ioc->remove_host) 3157 goto out; 3158 3159 /* allocate upto GPIOVal 36 entries */ 3160 sz = offsetof(Mpi2IOUnitPage3_t, GPIOVal) + (sizeof(u16) * 36); 3161 io_unit_pg3 = kzalloc(sz, GFP_KERNEL); 3162 if (!io_unit_pg3) { 3163 rc = -ENOMEM; 3164 ioc_err(ioc, "%s: failed allocating memory for iounit_pg3: (%d) bytes\n", 3165 __func__, sz); 3166 goto out; 3167 } 3168 3169 if (mpt3sas_config_get_iounit_pg3(ioc, &mpi_reply, io_unit_pg3, sz) != 3170 0) { 3171 ioc_err(ioc, "%s: failed reading iounit_pg3\n", 3172 __func__); 3173 rc = -EINVAL; 3174 goto out; 3175 } 3176 3177 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 3178 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 3179 ioc_err(ioc, "%s: iounit_pg3 failed with ioc_status(0x%04x)\n", 3180 __func__, ioc_status); 3181 rc = -EINVAL; 3182 goto out; 3183 } 3184 3185 if (io_unit_pg3->GPIOCount < 25) { 3186 ioc_err(ioc, "%s: iounit_pg3->GPIOCount less than 25 entries, detected (%d) entries\n", 3187 __func__, io_unit_pg3->GPIOCount); 3188 rc = -EINVAL; 3189 goto out; 3190 } 3191 3192 /* BRM status is in bit zero of GPIOVal[24] */ 3193 backup_rail_monitor_status = le16_to_cpu(io_unit_pg3->GPIOVal[24]); 3194 rc = snprintf(buf, PAGE_SIZE, "%d\n", (backup_rail_monitor_status & 1)); 3195 3196 out: 3197 kfree(io_unit_pg3); 3198 mutex_unlock(&ioc->pci_access_mutex); 3199 return rc; 3200 } 3201 static DEVICE_ATTR_RO(BRM_status); 3202 3203 struct DIAG_BUFFER_START { 3204 __le32 Size; 3205 __le32 DiagVersion; 3206 u8 BufferType; 3207 u8 Reserved[3]; 3208 __le32 Reserved1; 3209 __le32 Reserved2; 3210 __le32 Reserved3; 3211 }; 3212 3213 /** 3214 * host_trace_buffer_size_show - host buffer size (trace only) 3215 * @cdev: pointer to embedded class device 3216 * @attr: ? 3217 * @buf: the buffer returned 3218 * 3219 * A sysfs 'read-only' shost attribute. 3220 */ 3221 static ssize_t 3222 host_trace_buffer_size_show(struct device *cdev, 3223 struct device_attribute *attr, char *buf) 3224 { 3225 struct Scsi_Host *shost = class_to_shost(cdev); 3226 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3227 u32 size = 0; 3228 struct DIAG_BUFFER_START *request_data; 3229 3230 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 3231 ioc_err(ioc, "%s: host_trace_buffer is not registered\n", 3232 __func__); 3233 return 0; 3234 } 3235 3236 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3237 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 3238 ioc_err(ioc, "%s: host_trace_buffer is not registered\n", 3239 __func__); 3240 return 0; 3241 } 3242 3243 request_data = (struct DIAG_BUFFER_START *) 3244 ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]; 3245 if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 || 3246 le32_to_cpu(request_data->DiagVersion) == 0x01000000 || 3247 le32_to_cpu(request_data->DiagVersion) == 0x01010000) && 3248 le32_to_cpu(request_data->Reserved3) == 0x4742444c) 3249 size = le32_to_cpu(request_data->Size); 3250 3251 ioc->ring_buffer_sz = size; 3252 return snprintf(buf, PAGE_SIZE, "%d\n", size); 3253 } 3254 static DEVICE_ATTR_RO(host_trace_buffer_size); 3255 3256 /** 3257 * host_trace_buffer_show - firmware ring buffer (trace only) 3258 * @cdev: pointer to embedded class device 3259 * @attr: ? 3260 * @buf: the buffer returned 3261 * 3262 * A sysfs 'read/write' shost attribute. 3263 * 3264 * You will only be able to read 4k bytes of ring buffer at a time. 3265 * In order to read beyond 4k bytes, you will have to write out the 3266 * offset to the same attribute, it will move the pointer. 3267 */ 3268 static ssize_t 3269 host_trace_buffer_show(struct device *cdev, struct device_attribute *attr, 3270 char *buf) 3271 { 3272 struct Scsi_Host *shost = class_to_shost(cdev); 3273 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3274 void *request_data; 3275 u32 size; 3276 3277 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 3278 ioc_err(ioc, "%s: host_trace_buffer is not registered\n", 3279 __func__); 3280 return 0; 3281 } 3282 3283 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3284 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 3285 ioc_err(ioc, "%s: host_trace_buffer is not registered\n", 3286 __func__); 3287 return 0; 3288 } 3289 3290 if (ioc->ring_buffer_offset > ioc->ring_buffer_sz) 3291 return 0; 3292 3293 size = ioc->ring_buffer_sz - ioc->ring_buffer_offset; 3294 size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size; 3295 request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset; 3296 memcpy(buf, request_data, size); 3297 return size; 3298 } 3299 3300 static ssize_t 3301 host_trace_buffer_store(struct device *cdev, struct device_attribute *attr, 3302 const char *buf, size_t count) 3303 { 3304 struct Scsi_Host *shost = class_to_shost(cdev); 3305 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3306 int val = 0; 3307 3308 if (sscanf(buf, "%d", &val) != 1) 3309 return -EINVAL; 3310 3311 ioc->ring_buffer_offset = val; 3312 return strlen(buf); 3313 } 3314 static DEVICE_ATTR_RW(host_trace_buffer); 3315 3316 3317 /*****************************************/ 3318 3319 /** 3320 * host_trace_buffer_enable_show - firmware ring buffer (trace only) 3321 * @cdev: pointer to embedded class device 3322 * @attr: ? 3323 * @buf: the buffer returned 3324 * 3325 * A sysfs 'read/write' shost attribute. 3326 * 3327 * This is a mechnism to post/release host_trace_buffers 3328 */ 3329 static ssize_t 3330 host_trace_buffer_enable_show(struct device *cdev, 3331 struct device_attribute *attr, char *buf) 3332 { 3333 struct Scsi_Host *shost = class_to_shost(cdev); 3334 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3335 3336 if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) || 3337 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3338 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0)) 3339 return snprintf(buf, PAGE_SIZE, "off\n"); 3340 else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3341 MPT3_DIAG_BUFFER_IS_RELEASED)) 3342 return snprintf(buf, PAGE_SIZE, "release\n"); 3343 else 3344 return snprintf(buf, PAGE_SIZE, "post\n"); 3345 } 3346 3347 static ssize_t 3348 host_trace_buffer_enable_store(struct device *cdev, 3349 struct device_attribute *attr, const char *buf, size_t count) 3350 { 3351 struct Scsi_Host *shost = class_to_shost(cdev); 3352 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3353 char str[10] = ""; 3354 struct mpt3_diag_register diag_register; 3355 u8 issue_reset = 0; 3356 3357 /* don't allow post/release occurr while recovery is active */ 3358 if (ioc->shost_recovery || ioc->remove_host || 3359 ioc->pci_error_recovery || ioc->is_driver_loading) 3360 return -EBUSY; 3361 3362 if (sscanf(buf, "%9s", str) != 1) 3363 return -EINVAL; 3364 3365 if (!strcmp(str, "post")) { 3366 /* exit out if host buffers are already posted */ 3367 if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) && 3368 (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3369 MPT3_DIAG_BUFFER_IS_REGISTERED) && 3370 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3371 MPT3_DIAG_BUFFER_IS_RELEASED) == 0)) 3372 goto out; 3373 memset(&diag_register, 0, sizeof(struct mpt3_diag_register)); 3374 ioc_info(ioc, "posting host trace buffers\n"); 3375 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 3376 3377 if (ioc->manu_pg11.HostTraceBufferMaxSizeKB != 0 && 3378 ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE] != 0) { 3379 /* post the same buffer allocated previously */ 3380 diag_register.requested_buffer_size = 3381 ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE]; 3382 } else { 3383 /* 3384 * Free the diag buffer memory which was previously 3385 * allocated by an application. 3386 */ 3387 if ((ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE] != 0) 3388 && 3389 (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3390 MPT3_DIAG_BUFFER_IS_APP_OWNED)) { 3391 dma_free_coherent(&ioc->pdev->dev, 3392 ioc->diag_buffer_sz[MPI2_DIAG_BUF_TYPE_TRACE], 3393 ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE], 3394 ioc->diag_buffer_dma[MPI2_DIAG_BUF_TYPE_TRACE]); 3395 ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE] = 3396 NULL; 3397 } 3398 3399 diag_register.requested_buffer_size = (1024 * 1024); 3400 } 3401 3402 diag_register.unique_id = 3403 (ioc->hba_mpi_version_belonged == MPI2_VERSION) ? 3404 (MPT2DIAGBUFFUNIQUEID):(MPT3DIAGBUFFUNIQUEID); 3405 ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0; 3406 _ctl_diag_register_2(ioc, &diag_register); 3407 if (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3408 MPT3_DIAG_BUFFER_IS_REGISTERED) { 3409 ioc_info(ioc, 3410 "Trace buffer %d KB allocated through sysfs\n", 3411 diag_register.requested_buffer_size>>10); 3412 if (ioc->hba_mpi_version_belonged != MPI2_VERSION) 3413 ioc->diag_buffer_status[ 3414 MPI2_DIAG_BUF_TYPE_TRACE] |= 3415 MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED; 3416 } 3417 } else if (!strcmp(str, "release")) { 3418 /* exit out if host buffers are already released */ 3419 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) 3420 goto out; 3421 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3422 MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) 3423 goto out; 3424 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3425 MPT3_DIAG_BUFFER_IS_RELEASED)) 3426 goto out; 3427 ioc_info(ioc, "releasing host trace buffer\n"); 3428 mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, 3429 &issue_reset); 3430 } 3431 3432 out: 3433 return strlen(buf); 3434 } 3435 static DEVICE_ATTR_RW(host_trace_buffer_enable); 3436 3437 /*********** diagnostic trigger suppport *********************************/ 3438 3439 /** 3440 * diag_trigger_master_show - show the diag_trigger_master attribute 3441 * @cdev: pointer to embedded class device 3442 * @attr: ? 3443 * @buf: the buffer returned 3444 * 3445 * A sysfs 'read/write' shost attribute. 3446 */ 3447 static ssize_t 3448 diag_trigger_master_show(struct device *cdev, 3449 struct device_attribute *attr, char *buf) 3450 3451 { 3452 struct Scsi_Host *shost = class_to_shost(cdev); 3453 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3454 unsigned long flags; 3455 ssize_t rc; 3456 3457 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3458 rc = sizeof(struct SL_WH_MASTER_TRIGGER_T); 3459 memcpy(buf, &ioc->diag_trigger_master, rc); 3460 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3461 return rc; 3462 } 3463 3464 /** 3465 * diag_trigger_master_store - store the diag_trigger_master attribute 3466 * @cdev: pointer to embedded class device 3467 * @attr: ? 3468 * @buf: the buffer returned 3469 * @count: ? 3470 * 3471 * A sysfs 'read/write' shost attribute. 3472 */ 3473 static ssize_t 3474 diag_trigger_master_store(struct device *cdev, 3475 struct device_attribute *attr, const char *buf, size_t count) 3476 3477 { 3478 struct Scsi_Host *shost = class_to_shost(cdev); 3479 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3480 unsigned long flags; 3481 ssize_t rc; 3482 3483 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3484 rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count); 3485 memset(&ioc->diag_trigger_master, 0, 3486 sizeof(struct SL_WH_MASTER_TRIGGER_T)); 3487 memcpy(&ioc->diag_trigger_master, buf, rc); 3488 ioc->diag_trigger_master.MasterData |= 3489 (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET); 3490 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3491 return rc; 3492 } 3493 static DEVICE_ATTR_RW(diag_trigger_master); 3494 3495 3496 /** 3497 * diag_trigger_event_show - show the diag_trigger_event attribute 3498 * @cdev: pointer to embedded class device 3499 * @attr: ? 3500 * @buf: the buffer returned 3501 * 3502 * A sysfs 'read/write' shost attribute. 3503 */ 3504 static ssize_t 3505 diag_trigger_event_show(struct device *cdev, 3506 struct device_attribute *attr, char *buf) 3507 { 3508 struct Scsi_Host *shost = class_to_shost(cdev); 3509 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3510 unsigned long flags; 3511 ssize_t rc; 3512 3513 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3514 rc = sizeof(struct SL_WH_EVENT_TRIGGERS_T); 3515 memcpy(buf, &ioc->diag_trigger_event, rc); 3516 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3517 return rc; 3518 } 3519 3520 /** 3521 * diag_trigger_event_store - store the diag_trigger_event attribute 3522 * @cdev: pointer to embedded class device 3523 * @attr: ? 3524 * @buf: the buffer returned 3525 * @count: ? 3526 * 3527 * A sysfs 'read/write' shost attribute. 3528 */ 3529 static ssize_t 3530 diag_trigger_event_store(struct device *cdev, 3531 struct device_attribute *attr, const char *buf, size_t count) 3532 3533 { 3534 struct Scsi_Host *shost = class_to_shost(cdev); 3535 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3536 unsigned long flags; 3537 ssize_t sz; 3538 3539 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3540 sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count); 3541 memset(&ioc->diag_trigger_event, 0, 3542 sizeof(struct SL_WH_EVENT_TRIGGERS_T)); 3543 memcpy(&ioc->diag_trigger_event, buf, sz); 3544 if (ioc->diag_trigger_event.ValidEntries > NUM_VALID_ENTRIES) 3545 ioc->diag_trigger_event.ValidEntries = NUM_VALID_ENTRIES; 3546 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3547 return sz; 3548 } 3549 static DEVICE_ATTR_RW(diag_trigger_event); 3550 3551 3552 /** 3553 * diag_trigger_scsi_show - show the diag_trigger_scsi attribute 3554 * @cdev: pointer to embedded class device 3555 * @attr: ? 3556 * @buf: the buffer returned 3557 * 3558 * A sysfs 'read/write' shost attribute. 3559 */ 3560 static ssize_t 3561 diag_trigger_scsi_show(struct device *cdev, 3562 struct device_attribute *attr, char *buf) 3563 { 3564 struct Scsi_Host *shost = class_to_shost(cdev); 3565 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3566 unsigned long flags; 3567 ssize_t rc; 3568 3569 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3570 rc = sizeof(struct SL_WH_SCSI_TRIGGERS_T); 3571 memcpy(buf, &ioc->diag_trigger_scsi, rc); 3572 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3573 return rc; 3574 } 3575 3576 /** 3577 * diag_trigger_scsi_store - store the diag_trigger_scsi attribute 3578 * @cdev: pointer to embedded class device 3579 * @attr: ? 3580 * @buf: the buffer returned 3581 * @count: ? 3582 * 3583 * A sysfs 'read/write' shost attribute. 3584 */ 3585 static ssize_t 3586 diag_trigger_scsi_store(struct device *cdev, 3587 struct device_attribute *attr, const char *buf, size_t count) 3588 { 3589 struct Scsi_Host *shost = class_to_shost(cdev); 3590 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3591 unsigned long flags; 3592 ssize_t sz; 3593 3594 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3595 sz = min(sizeof(ioc->diag_trigger_scsi), count); 3596 memset(&ioc->diag_trigger_scsi, 0, sizeof(ioc->diag_trigger_scsi)); 3597 memcpy(&ioc->diag_trigger_scsi, buf, sz); 3598 if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES) 3599 ioc->diag_trigger_scsi.ValidEntries = NUM_VALID_ENTRIES; 3600 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3601 return sz; 3602 } 3603 static DEVICE_ATTR_RW(diag_trigger_scsi); 3604 3605 3606 /** 3607 * diag_trigger_scsi_show - show the diag_trigger_mpi attribute 3608 * @cdev: pointer to embedded class device 3609 * @attr: ? 3610 * @buf: the buffer returned 3611 * 3612 * A sysfs 'read/write' shost attribute. 3613 */ 3614 static ssize_t 3615 diag_trigger_mpi_show(struct device *cdev, 3616 struct device_attribute *attr, char *buf) 3617 { 3618 struct Scsi_Host *shost = class_to_shost(cdev); 3619 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3620 unsigned long flags; 3621 ssize_t rc; 3622 3623 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3624 rc = sizeof(struct SL_WH_MPI_TRIGGERS_T); 3625 memcpy(buf, &ioc->diag_trigger_mpi, rc); 3626 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3627 return rc; 3628 } 3629 3630 /** 3631 * diag_trigger_mpi_store - store the diag_trigger_mpi attribute 3632 * @cdev: pointer to embedded class device 3633 * @attr: ? 3634 * @buf: the buffer returned 3635 * @count: ? 3636 * 3637 * A sysfs 'read/write' shost attribute. 3638 */ 3639 static ssize_t 3640 diag_trigger_mpi_store(struct device *cdev, 3641 struct device_attribute *attr, const char *buf, size_t count) 3642 { 3643 struct Scsi_Host *shost = class_to_shost(cdev); 3644 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3645 unsigned long flags; 3646 ssize_t sz; 3647 3648 spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3649 sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count); 3650 memset(&ioc->diag_trigger_mpi, 0, 3651 sizeof(ioc->diag_trigger_mpi)); 3652 memcpy(&ioc->diag_trigger_mpi, buf, sz); 3653 if (ioc->diag_trigger_mpi.ValidEntries > NUM_VALID_ENTRIES) 3654 ioc->diag_trigger_mpi.ValidEntries = NUM_VALID_ENTRIES; 3655 spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3656 return sz; 3657 } 3658 3659 static DEVICE_ATTR_RW(diag_trigger_mpi); 3660 3661 /*********** diagnostic trigger suppport *** END ****************************/ 3662 3663 /*****************************************/ 3664 3665 /** 3666 * drv_support_bitmap_show - driver supported feature bitmap 3667 * @cdev: pointer to embedded class device 3668 * @attr: unused 3669 * @buf: the buffer returned 3670 * 3671 * A sysfs 'read-only' shost attribute. 3672 */ 3673 static ssize_t 3674 drv_support_bitmap_show(struct device *cdev, 3675 struct device_attribute *attr, char *buf) 3676 { 3677 struct Scsi_Host *shost = class_to_shost(cdev); 3678 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3679 3680 return snprintf(buf, PAGE_SIZE, "0x%08x\n", ioc->drv_support_bitmap); 3681 } 3682 static DEVICE_ATTR_RO(drv_support_bitmap); 3683 3684 /** 3685 * enable_sdev_max_qd_show - display whether sdev max qd is enabled/disabled 3686 * @cdev: pointer to embedded class device 3687 * @attr: unused 3688 * @buf: the buffer returned 3689 * 3690 * A sysfs read/write shost attribute. This attribute is used to set the 3691 * targets queue depth to HBA IO queue depth if this attribute is enabled. 3692 */ 3693 static ssize_t 3694 enable_sdev_max_qd_show(struct device *cdev, 3695 struct device_attribute *attr, char *buf) 3696 { 3697 struct Scsi_Host *shost = class_to_shost(cdev); 3698 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3699 3700 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->enable_sdev_max_qd); 3701 } 3702 3703 /** 3704 * enable_sdev_max_qd_store - Enable/disable sdev max qd 3705 * @cdev: pointer to embedded class device 3706 * @attr: unused 3707 * @buf: the buffer returned 3708 * @count: unused 3709 * 3710 * A sysfs read/write shost attribute. This attribute is used to set the 3711 * targets queue depth to HBA IO queue depth if this attribute is enabled. 3712 * If this attribute is disabled then targets will have corresponding default 3713 * queue depth. 3714 */ 3715 static ssize_t 3716 enable_sdev_max_qd_store(struct device *cdev, 3717 struct device_attribute *attr, const char *buf, size_t count) 3718 { 3719 struct Scsi_Host *shost = class_to_shost(cdev); 3720 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3721 struct MPT3SAS_DEVICE *sas_device_priv_data; 3722 struct MPT3SAS_TARGET *sas_target_priv_data; 3723 int val = 0; 3724 struct scsi_device *sdev; 3725 struct _raid_device *raid_device; 3726 int qdepth; 3727 3728 if (kstrtoint(buf, 0, &val) != 0) 3729 return -EINVAL; 3730 3731 switch (val) { 3732 case 0: 3733 ioc->enable_sdev_max_qd = 0; 3734 shost_for_each_device(sdev, ioc->shost) { 3735 sas_device_priv_data = sdev->hostdata; 3736 if (!sas_device_priv_data) 3737 continue; 3738 sas_target_priv_data = sas_device_priv_data->sas_target; 3739 if (!sas_target_priv_data) 3740 continue; 3741 3742 if (sas_target_priv_data->flags & 3743 MPT_TARGET_FLAGS_VOLUME) { 3744 raid_device = 3745 mpt3sas_raid_device_find_by_handle(ioc, 3746 sas_target_priv_data->handle); 3747 3748 switch (raid_device->volume_type) { 3749 case MPI2_RAID_VOL_TYPE_RAID0: 3750 if (raid_device->device_info & 3751 MPI2_SAS_DEVICE_INFO_SSP_TARGET) 3752 qdepth = 3753 MPT3SAS_SAS_QUEUE_DEPTH; 3754 else 3755 qdepth = 3756 MPT3SAS_SATA_QUEUE_DEPTH; 3757 break; 3758 case MPI2_RAID_VOL_TYPE_RAID1E: 3759 case MPI2_RAID_VOL_TYPE_RAID1: 3760 case MPI2_RAID_VOL_TYPE_RAID10: 3761 case MPI2_RAID_VOL_TYPE_UNKNOWN: 3762 default: 3763 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 3764 } 3765 } else if (sas_target_priv_data->flags & 3766 MPT_TARGET_FLAGS_PCIE_DEVICE) 3767 qdepth = MPT3SAS_NVME_QUEUE_DEPTH; 3768 else 3769 qdepth = MPT3SAS_SAS_QUEUE_DEPTH; 3770 3771 mpt3sas_scsih_change_queue_depth(sdev, qdepth); 3772 } 3773 break; 3774 case 1: 3775 ioc->enable_sdev_max_qd = 1; 3776 shost_for_each_device(sdev, ioc->shost) 3777 mpt3sas_scsih_change_queue_depth(sdev, 3778 shost->can_queue); 3779 break; 3780 default: 3781 return -EINVAL; 3782 } 3783 3784 return strlen(buf); 3785 } 3786 static DEVICE_ATTR_RW(enable_sdev_max_qd); 3787 3788 struct device_attribute *mpt3sas_host_attrs[] = { 3789 &dev_attr_version_fw, 3790 &dev_attr_version_bios, 3791 &dev_attr_version_mpi, 3792 &dev_attr_version_product, 3793 &dev_attr_version_nvdata_persistent, 3794 &dev_attr_version_nvdata_default, 3795 &dev_attr_board_name, 3796 &dev_attr_board_assembly, 3797 &dev_attr_board_tracer, 3798 &dev_attr_io_delay, 3799 &dev_attr_device_delay, 3800 &dev_attr_logging_level, 3801 &dev_attr_fwfault_debug, 3802 &dev_attr_fw_queue_depth, 3803 &dev_attr_host_sas_address, 3804 &dev_attr_ioc_reset_count, 3805 &dev_attr_host_trace_buffer_size, 3806 &dev_attr_host_trace_buffer, 3807 &dev_attr_host_trace_buffer_enable, 3808 &dev_attr_reply_queue_count, 3809 &dev_attr_diag_trigger_master, 3810 &dev_attr_diag_trigger_event, 3811 &dev_attr_diag_trigger_scsi, 3812 &dev_attr_diag_trigger_mpi, 3813 &dev_attr_drv_support_bitmap, 3814 &dev_attr_BRM_status, 3815 &dev_attr_enable_sdev_max_qd, 3816 NULL, 3817 }; 3818 3819 /* device attributes */ 3820 3821 /** 3822 * sas_address_show - sas address 3823 * @dev: pointer to embedded class device 3824 * @attr: ? 3825 * @buf: the buffer returned 3826 * 3827 * This is the sas address for the target 3828 * 3829 * A sysfs 'read-only' shost attribute. 3830 */ 3831 static ssize_t 3832 sas_address_show(struct device *dev, struct device_attribute *attr, 3833 char *buf) 3834 { 3835 struct scsi_device *sdev = to_scsi_device(dev); 3836 struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3837 3838 return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 3839 (unsigned long long)sas_device_priv_data->sas_target->sas_address); 3840 } 3841 static DEVICE_ATTR_RO(sas_address); 3842 3843 /** 3844 * sas_device_handle_show - device handle 3845 * @dev: pointer to embedded class device 3846 * @attr: ? 3847 * @buf: the buffer returned 3848 * 3849 * This is the firmware assigned device handle 3850 * 3851 * A sysfs 'read-only' shost attribute. 3852 */ 3853 static ssize_t 3854 sas_device_handle_show(struct device *dev, struct device_attribute *attr, 3855 char *buf) 3856 { 3857 struct scsi_device *sdev = to_scsi_device(dev); 3858 struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3859 3860 return snprintf(buf, PAGE_SIZE, "0x%04x\n", 3861 sas_device_priv_data->sas_target->handle); 3862 } 3863 static DEVICE_ATTR_RO(sas_device_handle); 3864 3865 /** 3866 * sas_ncq_io_prio_show - send prioritized io commands to device 3867 * @dev: pointer to embedded device 3868 * @attr: ? 3869 * @buf: the buffer returned 3870 * 3871 * A sysfs 'read/write' sdev attribute, only works with SATA 3872 */ 3873 static ssize_t 3874 sas_ncq_prio_enable_show(struct device *dev, 3875 struct device_attribute *attr, char *buf) 3876 { 3877 struct scsi_device *sdev = to_scsi_device(dev); 3878 struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3879 3880 return snprintf(buf, PAGE_SIZE, "%d\n", 3881 sas_device_priv_data->ncq_prio_enable); 3882 } 3883 3884 static ssize_t 3885 sas_ncq_prio_enable_store(struct device *dev, 3886 struct device_attribute *attr, 3887 const char *buf, size_t count) 3888 { 3889 struct scsi_device *sdev = to_scsi_device(dev); 3890 struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3891 bool ncq_prio_enable = 0; 3892 3893 if (kstrtobool(buf, &ncq_prio_enable)) 3894 return -EINVAL; 3895 3896 if (!scsih_ncq_prio_supp(sdev)) 3897 return -EINVAL; 3898 3899 sas_device_priv_data->ncq_prio_enable = ncq_prio_enable; 3900 return strlen(buf); 3901 } 3902 static DEVICE_ATTR_RW(sas_ncq_prio_enable); 3903 3904 struct device_attribute *mpt3sas_dev_attrs[] = { 3905 &dev_attr_sas_address, 3906 &dev_attr_sas_device_handle, 3907 &dev_attr_sas_ncq_prio_enable, 3908 NULL, 3909 }; 3910 3911 /* file operations table for mpt3ctl device */ 3912 static const struct file_operations ctl_fops = { 3913 .owner = THIS_MODULE, 3914 .unlocked_ioctl = _ctl_ioctl, 3915 .poll = _ctl_poll, 3916 .fasync = _ctl_fasync, 3917 #ifdef CONFIG_COMPAT 3918 .compat_ioctl = _ctl_ioctl_compat, 3919 #endif 3920 }; 3921 3922 /* file operations table for mpt2ctl device */ 3923 static const struct file_operations ctl_gen2_fops = { 3924 .owner = THIS_MODULE, 3925 .unlocked_ioctl = _ctl_mpt2_ioctl, 3926 .poll = _ctl_poll, 3927 .fasync = _ctl_fasync, 3928 #ifdef CONFIG_COMPAT 3929 .compat_ioctl = _ctl_mpt2_ioctl_compat, 3930 #endif 3931 }; 3932 3933 static struct miscdevice ctl_dev = { 3934 .minor = MPT3SAS_MINOR, 3935 .name = MPT3SAS_DEV_NAME, 3936 .fops = &ctl_fops, 3937 }; 3938 3939 static struct miscdevice gen2_ctl_dev = { 3940 .minor = MPT2SAS_MINOR, 3941 .name = MPT2SAS_DEV_NAME, 3942 .fops = &ctl_gen2_fops, 3943 }; 3944 3945 /** 3946 * mpt3sas_ctl_init - main entry point for ctl. 3947 * @hbas_to_enumerate: ? 3948 */ 3949 void 3950 mpt3sas_ctl_init(ushort hbas_to_enumerate) 3951 { 3952 async_queue = NULL; 3953 3954 /* Don't register mpt3ctl ioctl device if 3955 * hbas_to_enumarate is one. 3956 */ 3957 if (hbas_to_enumerate != 1) 3958 if (misc_register(&ctl_dev) < 0) 3959 pr_err("%s can't register misc device [minor=%d]\n", 3960 MPT3SAS_DRIVER_NAME, MPT3SAS_MINOR); 3961 3962 /* Don't register mpt3ctl ioctl device if 3963 * hbas_to_enumarate is two. 3964 */ 3965 if (hbas_to_enumerate != 2) 3966 if (misc_register(&gen2_ctl_dev) < 0) 3967 pr_err("%s can't register misc device [minor=%d]\n", 3968 MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR); 3969 3970 init_waitqueue_head(&ctl_poll_wait); 3971 } 3972 3973 /** 3974 * mpt3sas_ctl_exit - exit point for ctl 3975 * @hbas_to_enumerate: ? 3976 */ 3977 void 3978 mpt3sas_ctl_exit(ushort hbas_to_enumerate) 3979 { 3980 struct MPT3SAS_ADAPTER *ioc; 3981 int i; 3982 3983 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 3984 3985 /* free memory associated to diag buffers */ 3986 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 3987 if (!ioc->diag_buffer[i]) 3988 continue; 3989 dma_free_coherent(&ioc->pdev->dev, 3990 ioc->diag_buffer_sz[i], 3991 ioc->diag_buffer[i], 3992 ioc->diag_buffer_dma[i]); 3993 ioc->diag_buffer[i] = NULL; 3994 ioc->diag_buffer_status[i] = 0; 3995 } 3996 3997 kfree(ioc->event_log); 3998 } 3999 if (hbas_to_enumerate != 1) 4000 misc_deregister(&ctl_dev); 4001 if (hbas_to_enumerate != 2) 4002 misc_deregister(&gen2_ctl_dev); 4003 } 4004