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