mpt2sas_ctl.c revision eabb08ad2d3b0257cd2c9aed4f106fb39d14604a
1/* 2 * Management Module Support for MPT (Message Passing Technology) based 3 * controllers 4 * 5 * This code is based on drivers/scsi/mpt2sas/mpt2_ctl.c 6 * Copyright (C) 2007-2010 LSI Corporation 7 * (mailto:DL-MPTFusionLinux@lsi.com) 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * as published by the Free Software Foundation; either version 2 12 * of the License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * NO WARRANTY 20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 24 * solely responsible for determining the appropriateness of using and 25 * distributing the Program and assumes all risks associated with its 26 * exercise of rights under this Agreement, including but not limited to 27 * the risks and costs of program errors, damage to or loss of data, 28 * programs or equipment, and unavailability or interruption of operations. 29 30 * DISCLAIMER OF LIABILITY 31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 38 39 * You should have received a copy of the GNU General Public License 40 * along with this program; if not, write to the Free Software 41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 42 * USA. 43 */ 44 45#include <linux/version.h> 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/smp_lock.h> 55#include <linux/compat.h> 56#include <linux/poll.h> 57 58#include <linux/io.h> 59#include <linux/uaccess.h> 60 61#include "mpt2sas_base.h" 62#include "mpt2sas_ctl.h" 63 64static struct fasync_struct *async_queue; 65static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait); 66 67static int _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, 68 u8 *issue_reset); 69 70/** 71 * enum block_state - blocking state 72 * @NON_BLOCKING: non blocking 73 * @BLOCKING: blocking 74 * 75 * These states are for ioctls that need to wait for a response 76 * from firmware, so they probably require sleep. 77 */ 78enum block_state { 79 NON_BLOCKING, 80 BLOCKING, 81}; 82 83#ifdef CONFIG_SCSI_MPT2SAS_LOGGING 84/** 85 * _ctl_display_some_debug - debug routine 86 * @ioc: per adapter object 87 * @smid: system request message index 88 * @calling_function_name: string pass from calling function 89 * @mpi_reply: reply message frame 90 * Context: none. 91 * 92 * Function for displaying debug info helpfull when debugging issues 93 * in this module. 94 */ 95static void 96_ctl_display_some_debug(struct MPT2SAS_ADAPTER *ioc, u16 smid, 97 char *calling_function_name, MPI2DefaultReply_t *mpi_reply) 98{ 99 Mpi2ConfigRequest_t *mpi_request; 100 char *desc = NULL; 101 102 if (!(ioc->logging_level & MPT_DEBUG_IOCTL)) 103 return; 104 105 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid); 106 switch (mpi_request->Function) { 107 case MPI2_FUNCTION_SCSI_IO_REQUEST: 108 { 109 Mpi2SCSIIORequest_t *scsi_request = 110 (Mpi2SCSIIORequest_t *)mpi_request; 111 112 snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 113 "scsi_io, cmd(0x%02x), cdb_len(%d)", 114 scsi_request->CDB.CDB32[0], 115 le16_to_cpu(scsi_request->IoFlags) & 0xF); 116 desc = ioc->tmp_string; 117 break; 118 } 119 case MPI2_FUNCTION_SCSI_TASK_MGMT: 120 desc = "task_mgmt"; 121 break; 122 case MPI2_FUNCTION_IOC_INIT: 123 desc = "ioc_init"; 124 break; 125 case MPI2_FUNCTION_IOC_FACTS: 126 desc = "ioc_facts"; 127 break; 128 case MPI2_FUNCTION_CONFIG: 129 { 130 Mpi2ConfigRequest_t *config_request = 131 (Mpi2ConfigRequest_t *)mpi_request; 132 133 snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 134 "config, type(0x%02x), ext_type(0x%02x), number(%d)", 135 (config_request->Header.PageType & 136 MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType, 137 config_request->Header.PageNumber); 138 desc = ioc->tmp_string; 139 break; 140 } 141 case MPI2_FUNCTION_PORT_FACTS: 142 desc = "port_facts"; 143 break; 144 case MPI2_FUNCTION_PORT_ENABLE: 145 desc = "port_enable"; 146 break; 147 case MPI2_FUNCTION_EVENT_NOTIFICATION: 148 desc = "event_notification"; 149 break; 150 case MPI2_FUNCTION_FW_DOWNLOAD: 151 desc = "fw_download"; 152 break; 153 case MPI2_FUNCTION_FW_UPLOAD: 154 desc = "fw_upload"; 155 break; 156 case MPI2_FUNCTION_RAID_ACTION: 157 desc = "raid_action"; 158 break; 159 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 160 { 161 Mpi2SCSIIORequest_t *scsi_request = 162 (Mpi2SCSIIORequest_t *)mpi_request; 163 164 snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 165 "raid_pass, cmd(0x%02x), cdb_len(%d)", 166 scsi_request->CDB.CDB32[0], 167 le16_to_cpu(scsi_request->IoFlags) & 0xF); 168 desc = ioc->tmp_string; 169 break; 170 } 171 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 172 desc = "sas_iounit_cntl"; 173 break; 174 case MPI2_FUNCTION_SATA_PASSTHROUGH: 175 desc = "sata_pass"; 176 break; 177 case MPI2_FUNCTION_DIAG_BUFFER_POST: 178 desc = "diag_buffer_post"; 179 break; 180 case MPI2_FUNCTION_DIAG_RELEASE: 181 desc = "diag_release"; 182 break; 183 case MPI2_FUNCTION_SMP_PASSTHROUGH: 184 desc = "smp_passthrough"; 185 break; 186 } 187 188 if (!desc) 189 return; 190 191 printk(MPT2SAS_INFO_FMT "%s: %s, smid(%d)\n", 192 ioc->name, calling_function_name, desc, smid); 193 194 if (!mpi_reply) 195 return; 196 197 if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo) 198 printk(MPT2SAS_INFO_FMT 199 "\tiocstatus(0x%04x), loginfo(0x%08x)\n", 200 ioc->name, le16_to_cpu(mpi_reply->IOCStatus), 201 le32_to_cpu(mpi_reply->IOCLogInfo)); 202 203 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 204 mpi_request->Function == 205 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 206 Mpi2SCSIIOReply_t *scsi_reply = 207 (Mpi2SCSIIOReply_t *)mpi_reply; 208 if (scsi_reply->SCSIState || scsi_reply->SCSIStatus) 209 printk(MPT2SAS_INFO_FMT 210 "\tscsi_state(0x%02x), scsi_status" 211 "(0x%02x)\n", ioc->name, 212 scsi_reply->SCSIState, 213 scsi_reply->SCSIStatus); 214 } 215} 216#endif 217 218/** 219 * mpt2sas_ctl_done - ctl module completion routine 220 * @ioc: per adapter object 221 * @smid: system request message index 222 * @msix_index: MSIX table index supplied by the OS 223 * @reply: reply message frame(lower 32bit addr) 224 * Context: none. 225 * 226 * The callback handler when using ioc->ctl_cb_idx. 227 * 228 * Return 1 meaning mf should be freed from _base_interrupt 229 * 0 means the mf is freed from this function. 230 */ 231u8 232mpt2sas_ctl_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, 233 u32 reply) 234{ 235 MPI2DefaultReply_t *mpi_reply; 236 237 if (ioc->ctl_cmds.status == MPT2_CMD_NOT_USED) 238 return 1; 239 if (ioc->ctl_cmds.smid != smid) 240 return 1; 241 ioc->ctl_cmds.status |= MPT2_CMD_COMPLETE; 242 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply); 243 if (mpi_reply) { 244 memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4); 245 ioc->ctl_cmds.status |= MPT2_CMD_REPLY_VALID; 246 } 247#ifdef CONFIG_SCSI_MPT2SAS_LOGGING 248 _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply); 249#endif 250 ioc->ctl_cmds.status &= ~MPT2_CMD_PENDING; 251 complete(&ioc->ctl_cmds.done); 252 return 1; 253} 254 255/** 256 * _ctl_check_event_type - determines when an event needs logging 257 * @ioc: per adapter object 258 * @event: firmware event 259 * 260 * The bitmask in ioc->event_type[] indicates which events should be 261 * be saved in the driver event_log. This bitmask is set by application. 262 * 263 * Returns 1 when event should be captured, or zero means no match. 264 */ 265static int 266_ctl_check_event_type(struct MPT2SAS_ADAPTER *ioc, u16 event) 267{ 268 u16 i; 269 u32 desired_event; 270 271 if (event >= 128 || !event || !ioc->event_log) 272 return 0; 273 274 desired_event = (1 << (event % 32)); 275 if (!desired_event) 276 desired_event = 1; 277 i = event / 32; 278 return desired_event & ioc->event_type[i]; 279} 280 281/** 282 * mpt2sas_ctl_add_to_event_log - add event 283 * @ioc: per adapter object 284 * @mpi_reply: reply message frame 285 * 286 * Return nothing. 287 */ 288void 289mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER *ioc, 290 Mpi2EventNotificationReply_t *mpi_reply) 291{ 292 struct MPT2_IOCTL_EVENTS *event_log; 293 u16 event; 294 int i; 295 u32 sz, event_data_sz; 296 u8 send_aen = 0; 297 298 if (!ioc->event_log) 299 return; 300 301 event = le16_to_cpu(mpi_reply->Event); 302 303 if (_ctl_check_event_type(ioc, event)) { 304 305 /* insert entry into circular event_log */ 306 i = ioc->event_context % MPT2SAS_CTL_EVENT_LOG_SIZE; 307 event_log = ioc->event_log; 308 event_log[i].event = event; 309 event_log[i].context = ioc->event_context++; 310 311 event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4; 312 sz = min_t(u32, event_data_sz, MPT2_EVENT_DATA_SIZE); 313 memset(event_log[i].data, 0, MPT2_EVENT_DATA_SIZE); 314 memcpy(event_log[i].data, mpi_reply->EventData, sz); 315 send_aen = 1; 316 } 317 318 /* This aen_event_read_flag flag is set until the 319 * application has read the event log. 320 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify. 321 */ 322 if (event == MPI2_EVENT_LOG_ENTRY_ADDED || 323 (send_aen && !ioc->aen_event_read_flag)) { 324 ioc->aen_event_read_flag = 1; 325 wake_up_interruptible(&ctl_poll_wait); 326 if (async_queue) 327 kill_fasync(&async_queue, SIGIO, POLL_IN); 328 } 329} 330 331/** 332 * mpt2sas_ctl_event_callback - firmware event handler (called at ISR time) 333 * @ioc: per adapter object 334 * @msix_index: MSIX table index supplied by the OS 335 * @reply: reply message frame(lower 32bit addr) 336 * Context: interrupt. 337 * 338 * This function merely adds a new work task into ioc->firmware_event_thread. 339 * The tasks are worked from _firmware_event_work in user context. 340 * 341 * Return 1 meaning mf should be freed from _base_interrupt 342 * 0 means the mf is freed from this function. 343 */ 344u8 345mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index, 346 u32 reply) 347{ 348 Mpi2EventNotificationReply_t *mpi_reply; 349 350 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply); 351 mpt2sas_ctl_add_to_event_log(ioc, mpi_reply); 352 return 1; 353} 354 355/** 356 * _ctl_verify_adapter - validates ioc_number passed from application 357 * @ioc: per adapter object 358 * @iocpp: The ioc pointer is returned in this. 359 * 360 * Return (-1) means error, else ioc_number. 361 */ 362static int 363_ctl_verify_adapter(int ioc_number, struct MPT2SAS_ADAPTER **iocpp) 364{ 365 struct MPT2SAS_ADAPTER *ioc; 366 367 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) { 368 if (ioc->id != ioc_number) 369 continue; 370 *iocpp = ioc; 371 return ioc_number; 372 } 373 *iocpp = NULL; 374 return -1; 375} 376 377/** 378 * mpt2sas_ctl_reset_handler - reset callback handler (for ctl) 379 * @ioc: per adapter object 380 * @reset_phase: phase 381 * 382 * The handler for doing any required cleanup or initialization. 383 * 384 * The reset phase can be MPT2_IOC_PRE_RESET, MPT2_IOC_AFTER_RESET, 385 * MPT2_IOC_DONE_RESET 386 */ 387void 388mpt2sas_ctl_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase) 389{ 390 int i; 391 u8 issue_reset; 392 393 switch (reset_phase) { 394 case MPT2_IOC_PRE_RESET: 395 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 396 "MPT2_IOC_PRE_RESET\n", ioc->name, __func__)); 397 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 398 if (!(ioc->diag_buffer_status[i] & 399 MPT2_DIAG_BUFFER_IS_REGISTERED)) 400 continue; 401 if ((ioc->diag_buffer_status[i] & 402 MPT2_DIAG_BUFFER_IS_RELEASED)) 403 continue; 404 _ctl_send_release(ioc, i, &issue_reset); 405 } 406 break; 407 case MPT2_IOC_AFTER_RESET: 408 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 409 "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__)); 410 if (ioc->ctl_cmds.status & MPT2_CMD_PENDING) { 411 ioc->ctl_cmds.status |= MPT2_CMD_RESET; 412 mpt2sas_base_free_smid(ioc, ioc->ctl_cmds.smid); 413 complete(&ioc->ctl_cmds.done); 414 } 415 break; 416 case MPT2_IOC_DONE_RESET: 417 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 418 "MPT2_IOC_DONE_RESET\n", ioc->name, __func__)); 419 420 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 421 if (!(ioc->diag_buffer_status[i] & 422 MPT2_DIAG_BUFFER_IS_REGISTERED)) 423 continue; 424 if ((ioc->diag_buffer_status[i] & 425 MPT2_DIAG_BUFFER_IS_RELEASED)) 426 continue; 427 ioc->diag_buffer_status[i] |= 428 MPT2_DIAG_BUFFER_IS_DIAG_RESET; 429 } 430 break; 431 } 432} 433 434/** 435 * _ctl_fasync - 436 * @fd - 437 * @filep - 438 * @mode - 439 * 440 * Called when application request fasyn callback handler. 441 */ 442static int 443_ctl_fasync(int fd, struct file *filep, int mode) 444{ 445 return fasync_helper(fd, filep, mode, &async_queue); 446} 447 448/** 449 * _ctl_release - 450 * @inode - 451 * @filep - 452 * 453 * Called when application releases the fasyn callback handler. 454 */ 455static int 456_ctl_release(struct inode *inode, struct file *filep) 457{ 458 return fasync_helper(-1, filep, 0, &async_queue); 459} 460 461/** 462 * _ctl_poll - 463 * @file - 464 * @wait - 465 * 466 */ 467static unsigned int 468_ctl_poll(struct file *filep, poll_table *wait) 469{ 470 struct MPT2SAS_ADAPTER *ioc; 471 472 poll_wait(filep, &ctl_poll_wait, wait); 473 474 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) { 475 if (ioc->aen_event_read_flag) 476 return POLLIN | POLLRDNORM; 477 } 478 return 0; 479} 480 481/** 482 * _ctl_set_task_mid - assign an active smid to tm request 483 * @ioc: per adapter object 484 * @karg - (struct mpt2_ioctl_command) 485 * @tm_request - pointer to mf from user space 486 * 487 * Returns 0 when an smid if found, else fail. 488 * during failure, the reply frame is filled. 489 */ 490static int 491_ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg, 492 Mpi2SCSITaskManagementRequest_t *tm_request) 493{ 494 u8 found = 0; 495 u16 i; 496 u16 handle; 497 struct scsi_cmnd *scmd; 498 struct MPT2SAS_DEVICE *priv_data; 499 unsigned long flags; 500 Mpi2SCSITaskManagementReply_t *tm_reply; 501 u32 sz; 502 u32 lun; 503 char *desc = NULL; 504 505 if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK) 506 desc = "abort_task"; 507 else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) 508 desc = "query_task"; 509 else 510 return 0; 511 512 lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN); 513 514 handle = le16_to_cpu(tm_request->DevHandle); 515 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 516 for (i = ioc->scsiio_depth; i && !found; i--) { 517 scmd = ioc->scsi_lookup[i - 1].scmd; 518 if (scmd == NULL || scmd->device == NULL || 519 scmd->device->hostdata == NULL) 520 continue; 521 if (lun != scmd->device->lun) 522 continue; 523 priv_data = scmd->device->hostdata; 524 if (priv_data->sas_target == NULL) 525 continue; 526 if (priv_data->sas_target->handle != handle) 527 continue; 528 tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid); 529 found = 1; 530 } 531 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 532 533 if (!found) { 534 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 535 "handle(0x%04x), lun(%d), no active mid!!\n", ioc->name, 536 desc, le16_to_cpu(tm_request->DevHandle), lun)); 537 tm_reply = ioc->ctl_cmds.reply; 538 tm_reply->DevHandle = tm_request->DevHandle; 539 tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 540 tm_reply->TaskType = tm_request->TaskType; 541 tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4; 542 tm_reply->VP_ID = tm_request->VP_ID; 543 tm_reply->VF_ID = tm_request->VF_ID; 544 sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz); 545 if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply, 546 sz)) 547 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 548 __LINE__, __func__); 549 return 1; 550 } 551 552 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 553 "handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name, 554 desc, le16_to_cpu(tm_request->DevHandle), lun, 555 le16_to_cpu(tm_request->TaskMID))); 556 return 0; 557} 558 559/** 560 * _ctl_do_mpt_command - main handler for MPT2COMMAND opcode 561 * @ioc: per adapter object 562 * @karg - (struct mpt2_ioctl_command) 563 * @mf - pointer to mf in user space 564 * @state - NON_BLOCKING or BLOCKING 565 */ 566static long 567_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc, 568 struct mpt2_ioctl_command karg, void __user *mf, enum block_state state) 569{ 570 MPI2RequestHeader_t *mpi_request; 571 MPI2DefaultReply_t *mpi_reply; 572 u32 ioc_state; 573 u16 ioc_status; 574 u16 smid; 575 unsigned long timeout, timeleft; 576 u8 issue_reset; 577 u32 sz; 578 void *psge; 579 void *priv_sense = NULL; 580 void *data_out = NULL; 581 dma_addr_t data_out_dma; 582 size_t data_out_sz = 0; 583 void *data_in = NULL; 584 dma_addr_t data_in_dma; 585 size_t data_in_sz = 0; 586 u32 sgl_flags; 587 long ret; 588 u16 wait_state_count; 589 590 issue_reset = 0; 591 592 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex)) 593 return -EAGAIN; 594 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) 595 return -ERESTARTSYS; 596 597 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) { 598 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n", 599 ioc->name, __func__); 600 ret = -EAGAIN; 601 goto out; 602 } 603 604 wait_state_count = 0; 605 ioc_state = mpt2sas_base_get_iocstate(ioc, 1); 606 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 607 if (wait_state_count++ == 10) { 608 printk(MPT2SAS_ERR_FMT 609 "%s: failed due to ioc not operational\n", 610 ioc->name, __func__); 611 ret = -EFAULT; 612 goto out; 613 } 614 ssleep(1); 615 ioc_state = mpt2sas_base_get_iocstate(ioc, 1); 616 printk(MPT2SAS_INFO_FMT "%s: waiting for " 617 "operational state(count=%d)\n", ioc->name, 618 __func__, wait_state_count); 619 } 620 if (wait_state_count) 621 printk(MPT2SAS_INFO_FMT "%s: ioc is operational\n", 622 ioc->name, __func__); 623 624 smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL); 625 if (!smid) { 626 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n", 627 ioc->name, __func__); 628 ret = -EAGAIN; 629 goto out; 630 } 631 632 ret = 0; 633 ioc->ctl_cmds.status = MPT2_CMD_PENDING; 634 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 635 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid); 636 ioc->ctl_cmds.smid = smid; 637 data_out_sz = karg.data_out_size; 638 data_in_sz = karg.data_in_size; 639 640 /* copy in request message frame from user */ 641 if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) { 642 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, __LINE__, 643 __func__); 644 ret = -EFAULT; 645 mpt2sas_base_free_smid(ioc, smid); 646 goto out; 647 } 648 649 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 650 mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 651 if (!le16_to_cpu(mpi_request->FunctionDependent1) || 652 le16_to_cpu(mpi_request->FunctionDependent1) > 653 ioc->facts.MaxDevHandle) { 654 ret = -EINVAL; 655 mpt2sas_base_free_smid(ioc, smid); 656 goto out; 657 } 658 } 659 660 /* obtain dma-able memory for data transfer */ 661 if (data_out_sz) /* WRITE */ { 662 data_out = pci_alloc_consistent(ioc->pdev, data_out_sz, 663 &data_out_dma); 664 if (!data_out) { 665 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 666 __LINE__, __func__); 667 ret = -ENOMEM; 668 mpt2sas_base_free_smid(ioc, smid); 669 goto out; 670 } 671 if (copy_from_user(data_out, karg.data_out_buf_ptr, 672 data_out_sz)) { 673 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 674 __LINE__, __func__); 675 ret = -EFAULT; 676 mpt2sas_base_free_smid(ioc, smid); 677 goto out; 678 } 679 } 680 681 if (data_in_sz) /* READ */ { 682 data_in = pci_alloc_consistent(ioc->pdev, data_in_sz, 683 &data_in_dma); 684 if (!data_in) { 685 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 686 __LINE__, __func__); 687 ret = -ENOMEM; 688 mpt2sas_base_free_smid(ioc, smid); 689 goto out; 690 } 691 } 692 693 /* add scatter gather elements */ 694 psge = (void *)mpi_request + (karg.data_sge_offset*4); 695 696 if (!data_out_sz && !data_in_sz) { 697 mpt2sas_base_build_zero_len_sge(ioc, psge); 698 } else if (data_out_sz && data_in_sz) { 699 /* WRITE sgel first */ 700 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT | 701 MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC); 702 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT; 703 ioc->base_add_sg_single(psge, sgl_flags | 704 data_out_sz, data_out_dma); 705 706 /* incr sgel */ 707 psge += ioc->sge_size; 708 709 /* READ sgel last */ 710 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT | 711 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER | 712 MPI2_SGE_FLAGS_END_OF_LIST); 713 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT; 714 ioc->base_add_sg_single(psge, sgl_flags | 715 data_in_sz, data_in_dma); 716 } else if (data_out_sz) /* WRITE */ { 717 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT | 718 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER | 719 MPI2_SGE_FLAGS_END_OF_LIST | MPI2_SGE_FLAGS_HOST_TO_IOC); 720 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT; 721 ioc->base_add_sg_single(psge, sgl_flags | 722 data_out_sz, data_out_dma); 723 } else if (data_in_sz) /* READ */ { 724 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT | 725 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER | 726 MPI2_SGE_FLAGS_END_OF_LIST); 727 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT; 728 ioc->base_add_sg_single(psge, sgl_flags | 729 data_in_sz, data_in_dma); 730 } 731 732 /* send command to firmware */ 733#ifdef CONFIG_SCSI_MPT2SAS_LOGGING 734 _ctl_display_some_debug(ioc, smid, "ctl_request", NULL); 735#endif 736 737 switch (mpi_request->Function) { 738 case MPI2_FUNCTION_SCSI_IO_REQUEST: 739 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 740 { 741 Mpi2SCSIIORequest_t *scsiio_request = 742 (Mpi2SCSIIORequest_t *)mpi_request; 743 scsiio_request->SenseBufferLowAddress = 744 mpt2sas_base_get_sense_buffer_dma(ioc, smid); 745 priv_sense = mpt2sas_base_get_sense_buffer(ioc, smid); 746 memset(priv_sense, 0, SCSI_SENSE_BUFFERSIZE); 747 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST) 748 mpt2sas_base_put_smid_scsi_io(ioc, smid, 749 le16_to_cpu(mpi_request->FunctionDependent1)); 750 else 751 mpt2sas_base_put_smid_default(ioc, smid); 752 break; 753 } 754 case MPI2_FUNCTION_SCSI_TASK_MGMT: 755 { 756 Mpi2SCSITaskManagementRequest_t *tm_request = 757 (Mpi2SCSITaskManagementRequest_t *)mpi_request; 758 759 dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "TASK_MGMT: " 760 "handle(0x%04x), task_type(0x%02x)\n", ioc->name, 761 le16_to_cpu(tm_request->DevHandle), tm_request->TaskType)); 762 763 if (tm_request->TaskType == 764 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK || 765 tm_request->TaskType == 766 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) { 767 if (_ctl_set_task_mid(ioc, &karg, tm_request)) { 768 mpt2sas_base_free_smid(ioc, smid); 769 goto out; 770 } 771 } 772 773 mpt2sas_scsih_set_tm_flag(ioc, le16_to_cpu( 774 tm_request->DevHandle)); 775 mpt2sas_base_put_smid_hi_priority(ioc, smid); 776 break; 777 } 778 case MPI2_FUNCTION_SMP_PASSTHROUGH: 779 { 780 Mpi2SmpPassthroughRequest_t *smp_request = 781 (Mpi2SmpPassthroughRequest_t *)mpi_request; 782 u8 *data; 783 784 /* ioc determines which port to use */ 785 smp_request->PhysicalPort = 0xFF; 786 if (smp_request->PassthroughFlags & 787 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE) 788 data = (u8 *)&smp_request->SGL; 789 else 790 data = data_out; 791 792 if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) { 793 ioc->ioc_link_reset_in_progress = 1; 794 ioc->ignore_loginfos = 1; 795 } 796 mpt2sas_base_put_smid_default(ioc, smid); 797 break; 798 } 799 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 800 { 801 Mpi2SasIoUnitControlRequest_t *sasiounit_request = 802 (Mpi2SasIoUnitControlRequest_t *)mpi_request; 803 804 if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET 805 || sasiounit_request->Operation == 806 MPI2_SAS_OP_PHY_LINK_RESET) { 807 ioc->ioc_link_reset_in_progress = 1; 808 ioc->ignore_loginfos = 1; 809 } 810 mpt2sas_base_put_smid_default(ioc, smid); 811 break; 812 } 813 default: 814 mpt2sas_base_put_smid_default(ioc, smid); 815 break; 816 } 817 818 if (karg.timeout < MPT2_IOCTL_DEFAULT_TIMEOUT) 819 timeout = MPT2_IOCTL_DEFAULT_TIMEOUT; 820 else 821 timeout = karg.timeout; 822 init_completion(&ioc->ctl_cmds.done); 823 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 824 timeout*HZ); 825 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 826 Mpi2SCSITaskManagementRequest_t *tm_request = 827 (Mpi2SCSITaskManagementRequest_t *)mpi_request; 828 mpt2sas_scsih_clear_tm_flag(ioc, le16_to_cpu( 829 tm_request->DevHandle)); 830 } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH || 831 mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) && 832 ioc->ioc_link_reset_in_progress) { 833 ioc->ioc_link_reset_in_progress = 0; 834 ioc->ignore_loginfos = 0; 835 } 836 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) { 837 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name, 838 __func__); 839 _debug_dump_mf(mpi_request, karg.data_sge_offset); 840 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET)) 841 issue_reset = 1; 842 goto issue_host_reset; 843 } 844 845 mpi_reply = ioc->ctl_cmds.reply; 846 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 847 848#ifdef CONFIG_SCSI_MPT2SAS_LOGGING 849 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT && 850 (ioc->logging_level & MPT_DEBUG_TM)) { 851 Mpi2SCSITaskManagementReply_t *tm_reply = 852 (Mpi2SCSITaskManagementReply_t *)mpi_reply; 853 854 printk(MPT2SAS_INFO_FMT "TASK_MGMT: " 855 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), " 856 "TerminationCount(0x%08x)\n", ioc->name, 857 le16_to_cpu(tm_reply->IOCStatus), 858 le32_to_cpu(tm_reply->IOCLogInfo), 859 le32_to_cpu(tm_reply->TerminationCount)); 860 } 861#endif 862 /* copy out xdata to user */ 863 if (data_in_sz) { 864 if (copy_to_user(karg.data_in_buf_ptr, data_in, 865 data_in_sz)) { 866 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 867 __LINE__, __func__); 868 ret = -ENODATA; 869 goto out; 870 } 871 } 872 873 /* copy out reply message frame to user */ 874 if (karg.max_reply_bytes) { 875 sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz); 876 if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply, 877 sz)) { 878 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 879 __LINE__, __func__); 880 ret = -ENODATA; 881 goto out; 882 } 883 } 884 885 /* copy out sense to user */ 886 if (karg.max_sense_bytes && (mpi_request->Function == 887 MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function == 888 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) { 889 sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE); 890 if (copy_to_user(karg.sense_data_ptr, priv_sense, sz)) { 891 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, 892 __LINE__, __func__); 893 ret = -ENODATA; 894 goto out; 895 } 896 } 897 898 issue_host_reset: 899 if (issue_reset) { 900 ret = -ENODATA; 901 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 902 mpi_request->Function == 903 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) { 904 printk(MPT2SAS_INFO_FMT "issue target reset: handle " 905 "= (0x%04x)\n", ioc->name, 906 le16_to_cpu(mpi_request->FunctionDependent1)); 907 mpt2sas_halt_firmware(ioc); 908 mpt2sas_scsih_issue_tm(ioc, 909 le16_to_cpu(mpi_request->FunctionDependent1), 0, 0, 910 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 10, 911 NULL); 912 ioc->tm_cmds.status = MPT2_CMD_NOT_USED; 913 } else 914 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, 915 FORCE_BIG_HAMMER); 916 } 917 918 out: 919 920 /* free memory associated with sg buffers */ 921 if (data_in) 922 pci_free_consistent(ioc->pdev, data_in_sz, data_in, 923 data_in_dma); 924 925 if (data_out) 926 pci_free_consistent(ioc->pdev, data_out_sz, data_out, 927 data_out_dma); 928 929 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED; 930 mutex_unlock(&ioc->ctl_cmds.mutex); 931 return ret; 932} 933 934/** 935 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode 936 * @arg - user space buffer containing ioctl content 937 */ 938static long 939_ctl_getiocinfo(void __user *arg) 940{ 941 struct mpt2_ioctl_iocinfo karg; 942 struct MPT2SAS_ADAPTER *ioc; 943 u8 revision; 944 945 if (copy_from_user(&karg, arg, sizeof(karg))) { 946 printk(KERN_ERR "failure at %s:%d/%s()!\n", 947 __FILE__, __LINE__, __func__); 948 return -EFAULT; 949 } 950 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 951 return -ENODEV; 952 953 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 954 __func__)); 955 956 memset(&karg, 0 , sizeof(karg)); 957 karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2; 958 if (ioc->pfacts) 959 karg.port_number = ioc->pfacts[0].PortNumber; 960 pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision); 961 karg.hw_rev = revision; 962 karg.pci_id = ioc->pdev->device; 963 karg.subsystem_device = ioc->pdev->subsystem_device; 964 karg.subsystem_vendor = ioc->pdev->subsystem_vendor; 965 karg.pci_information.u.bits.bus = ioc->pdev->bus->number; 966 karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn); 967 karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn); 968 karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus); 969 karg.firmware_version = ioc->facts.FWVersion.Word; 970 strcpy(karg.driver_version, MPT2SAS_DRIVER_NAME); 971 strcat(karg.driver_version, "-"); 972 strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION); 973 karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 974 975 if (copy_to_user(arg, &karg, sizeof(karg))) { 976 printk(KERN_ERR "failure at %s:%d/%s()!\n", 977 __FILE__, __LINE__, __func__); 978 return -EFAULT; 979 } 980 return 0; 981} 982 983/** 984 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode 985 * @arg - user space buffer containing ioctl content 986 */ 987static long 988_ctl_eventquery(void __user *arg) 989{ 990 struct mpt2_ioctl_eventquery karg; 991 struct MPT2SAS_ADAPTER *ioc; 992 993 if (copy_from_user(&karg, arg, sizeof(karg))) { 994 printk(KERN_ERR "failure at %s:%d/%s()!\n", 995 __FILE__, __LINE__, __func__); 996 return -EFAULT; 997 } 998 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 999 return -ENODEV; 1000 1001 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1002 __func__)); 1003 1004 karg.event_entries = MPT2SAS_CTL_EVENT_LOG_SIZE; 1005 memcpy(karg.event_types, ioc->event_type, 1006 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1007 1008 if (copy_to_user(arg, &karg, sizeof(karg))) { 1009 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1010 __FILE__, __LINE__, __func__); 1011 return -EFAULT; 1012 } 1013 return 0; 1014} 1015 1016/** 1017 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode 1018 * @arg - user space buffer containing ioctl content 1019 */ 1020static long 1021_ctl_eventenable(void __user *arg) 1022{ 1023 struct mpt2_ioctl_eventenable karg; 1024 struct MPT2SAS_ADAPTER *ioc; 1025 1026 if (copy_from_user(&karg, arg, sizeof(karg))) { 1027 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1028 __FILE__, __LINE__, __func__); 1029 return -EFAULT; 1030 } 1031 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1032 return -ENODEV; 1033 1034 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1035 __func__)); 1036 1037 if (ioc->event_log) 1038 return 0; 1039 memcpy(ioc->event_type, karg.event_types, 1040 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1041 mpt2sas_base_validate_event_type(ioc, ioc->event_type); 1042 1043 /* initialize event_log */ 1044 ioc->event_context = 0; 1045 ioc->aen_event_read_flag = 0; 1046 ioc->event_log = kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE, 1047 sizeof(struct MPT2_IOCTL_EVENTS), GFP_KERNEL); 1048 if (!ioc->event_log) { 1049 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1050 __FILE__, __LINE__, __func__); 1051 return -ENOMEM; 1052 } 1053 return 0; 1054} 1055 1056/** 1057 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode 1058 * @arg - user space buffer containing ioctl content 1059 */ 1060static long 1061_ctl_eventreport(void __user *arg) 1062{ 1063 struct mpt2_ioctl_eventreport karg; 1064 struct MPT2SAS_ADAPTER *ioc; 1065 u32 number_bytes, max_events, max; 1066 struct mpt2_ioctl_eventreport __user *uarg = arg; 1067 1068 if (copy_from_user(&karg, arg, sizeof(karg))) { 1069 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1070 __FILE__, __LINE__, __func__); 1071 return -EFAULT; 1072 } 1073 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1074 return -ENODEV; 1075 1076 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1077 __func__)); 1078 1079 number_bytes = karg.hdr.max_data_size - 1080 sizeof(struct mpt2_ioctl_header); 1081 max_events = number_bytes/sizeof(struct MPT2_IOCTL_EVENTS); 1082 max = min_t(u32, MPT2SAS_CTL_EVENT_LOG_SIZE, max_events); 1083 1084 /* If fewer than 1 event is requested, there must have 1085 * been some type of error. 1086 */ 1087 if (!max || !ioc->event_log) 1088 return -ENODATA; 1089 1090 number_bytes = max * sizeof(struct MPT2_IOCTL_EVENTS); 1091 if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) { 1092 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1093 __FILE__, __LINE__, __func__); 1094 return -EFAULT; 1095 } 1096 1097 /* reset flag so SIGIO can restart */ 1098 ioc->aen_event_read_flag = 0; 1099 return 0; 1100} 1101 1102/** 1103 * _ctl_do_reset - main handler for MPT2HARDRESET opcode 1104 * @arg - user space buffer containing ioctl content 1105 */ 1106static long 1107_ctl_do_reset(void __user *arg) 1108{ 1109 struct mpt2_ioctl_diag_reset karg; 1110 struct MPT2SAS_ADAPTER *ioc; 1111 int retval; 1112 1113 if (copy_from_user(&karg, arg, sizeof(karg))) { 1114 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1115 __FILE__, __LINE__, __func__); 1116 return -EFAULT; 1117 } 1118 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1119 return -ENODEV; 1120 1121 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name, 1122 __func__)); 1123 1124 retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1125 FORCE_BIG_HAMMER); 1126 printk(MPT2SAS_INFO_FMT "host reset: %s\n", 1127 ioc->name, ((!retval) ? "SUCCESS" : "FAILED")); 1128 return 0; 1129} 1130 1131/** 1132 * _ctl_btdh_search_sas_device - searching for sas device 1133 * @ioc: per adapter object 1134 * @btdh: btdh ioctl payload 1135 */ 1136static int 1137_ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER *ioc, 1138 struct mpt2_ioctl_btdh_mapping *btdh) 1139{ 1140 struct _sas_device *sas_device; 1141 unsigned long flags; 1142 int rc = 0; 1143 1144 if (list_empty(&ioc->sas_device_list)) 1145 return rc; 1146 1147 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1148 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 1149 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1150 btdh->handle == sas_device->handle) { 1151 btdh->bus = sas_device->channel; 1152 btdh->id = sas_device->id; 1153 rc = 1; 1154 goto out; 1155 } else if (btdh->bus == sas_device->channel && btdh->id == 1156 sas_device->id && btdh->handle == 0xFFFF) { 1157 btdh->handle = sas_device->handle; 1158 rc = 1; 1159 goto out; 1160 } 1161 } 1162 out: 1163 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1164 return rc; 1165} 1166 1167/** 1168 * _ctl_btdh_search_raid_device - searching for raid device 1169 * @ioc: per adapter object 1170 * @btdh: btdh ioctl payload 1171 */ 1172static int 1173_ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc, 1174 struct mpt2_ioctl_btdh_mapping *btdh) 1175{ 1176 struct _raid_device *raid_device; 1177 unsigned long flags; 1178 int rc = 0; 1179 1180 if (list_empty(&ioc->raid_device_list)) 1181 return rc; 1182 1183 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1184 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1185 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1186 btdh->handle == raid_device->handle) { 1187 btdh->bus = raid_device->channel; 1188 btdh->id = raid_device->id; 1189 rc = 1; 1190 goto out; 1191 } else if (btdh->bus == raid_device->channel && btdh->id == 1192 raid_device->id && btdh->handle == 0xFFFF) { 1193 btdh->handle = raid_device->handle; 1194 rc = 1; 1195 goto out; 1196 } 1197 } 1198 out: 1199 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1200 return rc; 1201} 1202 1203/** 1204 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode 1205 * @arg - user space buffer containing ioctl content 1206 */ 1207static long 1208_ctl_btdh_mapping(void __user *arg) 1209{ 1210 struct mpt2_ioctl_btdh_mapping karg; 1211 struct MPT2SAS_ADAPTER *ioc; 1212 int rc; 1213 1214 if (copy_from_user(&karg, arg, sizeof(karg))) { 1215 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1216 __FILE__, __LINE__, __func__); 1217 return -EFAULT; 1218 } 1219 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1220 return -ENODEV; 1221 1222 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1223 __func__)); 1224 1225 rc = _ctl_btdh_search_sas_device(ioc, &karg); 1226 if (!rc) 1227 _ctl_btdh_search_raid_device(ioc, &karg); 1228 1229 if (copy_to_user(arg, &karg, sizeof(karg))) { 1230 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1231 __FILE__, __LINE__, __func__); 1232 return -EFAULT; 1233 } 1234 return 0; 1235} 1236 1237/** 1238 * _ctl_diag_capability - return diag buffer capability 1239 * @ioc: per adapter object 1240 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED 1241 * 1242 * returns 1 when diag buffer support is enabled in firmware 1243 */ 1244static u8 1245_ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type) 1246{ 1247 u8 rc = 0; 1248 1249 switch (buffer_type) { 1250 case MPI2_DIAG_BUF_TYPE_TRACE: 1251 if (ioc->facts.IOCCapabilities & 1252 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) 1253 rc = 1; 1254 break; 1255 case MPI2_DIAG_BUF_TYPE_SNAPSHOT: 1256 if (ioc->facts.IOCCapabilities & 1257 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) 1258 rc = 1; 1259 break; 1260 case MPI2_DIAG_BUF_TYPE_EXTENDED: 1261 if (ioc->facts.IOCCapabilities & 1262 MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) 1263 rc = 1; 1264 } 1265 1266 return rc; 1267} 1268 1269/** 1270 * _ctl_diag_register_2 - wrapper for registering diag buffer support 1271 * @ioc: per adapter object 1272 * @diag_register: the diag_register struct passed in from user space 1273 * 1274 */ 1275static long 1276_ctl_diag_register_2(struct MPT2SAS_ADAPTER *ioc, 1277 struct mpt2_diag_register *diag_register) 1278{ 1279 int rc, i; 1280 void *request_data = NULL; 1281 dma_addr_t request_data_dma; 1282 u32 request_data_sz = 0; 1283 Mpi2DiagBufferPostRequest_t *mpi_request; 1284 Mpi2DiagBufferPostReply_t *mpi_reply; 1285 u8 buffer_type; 1286 unsigned long timeleft; 1287 u16 smid; 1288 u16 ioc_status; 1289 u8 issue_reset = 0; 1290 1291 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1292 __func__)); 1293 1294 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) { 1295 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n", 1296 ioc->name, __func__); 1297 rc = -EAGAIN; 1298 goto out; 1299 } 1300 1301 buffer_type = diag_register->buffer_type; 1302 if (!_ctl_diag_capability(ioc, buffer_type)) { 1303 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for " 1304 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1305 return -EPERM; 1306 } 1307 1308 if (ioc->diag_buffer_status[buffer_type] & 1309 MPT2_DIAG_BUFFER_IS_REGISTERED) { 1310 printk(MPT2SAS_ERR_FMT "%s: already has a registered " 1311 "buffer for buffer_type(0x%02x)\n", ioc->name, __func__, 1312 buffer_type); 1313 return -EINVAL; 1314 } 1315 1316 if (diag_register->requested_buffer_size % 4) { 1317 printk(MPT2SAS_ERR_FMT "%s: the requested_buffer_size " 1318 "is not 4 byte aligned\n", ioc->name, __func__); 1319 return -EINVAL; 1320 } 1321 1322 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1323 if (!smid) { 1324 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n", 1325 ioc->name, __func__); 1326 rc = -EAGAIN; 1327 goto out; 1328 } 1329 1330 rc = 0; 1331 ioc->ctl_cmds.status = MPT2_CMD_PENDING; 1332 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1333 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid); 1334 ioc->ctl_cmds.smid = smid; 1335 1336 request_data = ioc->diag_buffer[buffer_type]; 1337 request_data_sz = diag_register->requested_buffer_size; 1338 ioc->unique_id[buffer_type] = diag_register->unique_id; 1339 ioc->diag_buffer_status[buffer_type] = 0; 1340 memcpy(ioc->product_specific[buffer_type], 1341 diag_register->product_specific, MPT2_PRODUCT_SPECIFIC_DWORDS); 1342 ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags; 1343 1344 if (request_data) { 1345 request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1346 if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) { 1347 pci_free_consistent(ioc->pdev, 1348 ioc->diag_buffer_sz[buffer_type], 1349 request_data, request_data_dma); 1350 request_data = NULL; 1351 } 1352 } 1353 1354 if (request_data == NULL) { 1355 ioc->diag_buffer_sz[buffer_type] = 0; 1356 ioc->diag_buffer_dma[buffer_type] = 0; 1357 request_data = pci_alloc_consistent( 1358 ioc->pdev, request_data_sz, &request_data_dma); 1359 if (request_data == NULL) { 1360 printk(MPT2SAS_ERR_FMT "%s: failed allocating memory" 1361 " for diag buffers, requested size(%d)\n", 1362 ioc->name, __func__, request_data_sz); 1363 mpt2sas_base_free_smid(ioc, smid); 1364 return -ENOMEM; 1365 } 1366 ioc->diag_buffer[buffer_type] = request_data; 1367 ioc->diag_buffer_sz[buffer_type] = request_data_sz; 1368 ioc->diag_buffer_dma[buffer_type] = request_data_dma; 1369 } 1370 1371 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 1372 mpi_request->BufferType = diag_register->buffer_type; 1373 mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags); 1374 mpi_request->BufferAddress = cpu_to_le64(request_data_dma); 1375 mpi_request->BufferLength = cpu_to_le32(request_data_sz); 1376 mpi_request->VF_ID = 0; /* TODO */ 1377 mpi_request->VP_ID = 0; 1378 1379 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(0x%p), " 1380 "dma(0x%llx), sz(%d)\n", ioc->name, __func__, request_data, 1381 (unsigned long long)request_data_dma, 1382 le32_to_cpu(mpi_request->BufferLength))); 1383 1384 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++) 1385 mpi_request->ProductSpecific[i] = 1386 cpu_to_le32(ioc->product_specific[buffer_type][i]); 1387 1388 mpt2sas_base_put_smid_default(ioc, smid); 1389 init_completion(&ioc->ctl_cmds.done); 1390 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 1391 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ); 1392 1393 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) { 1394 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name, 1395 __func__); 1396 _debug_dump_mf(mpi_request, 1397 sizeof(Mpi2DiagBufferPostRequest_t)/4); 1398 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET)) 1399 issue_reset = 1; 1400 goto issue_host_reset; 1401 } 1402 1403 /* process the completed Reply Message Frame */ 1404 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) { 1405 printk(MPT2SAS_ERR_FMT "%s: no reply message\n", 1406 ioc->name, __func__); 1407 rc = -EFAULT; 1408 goto out; 1409 } 1410 1411 mpi_reply = ioc->ctl_cmds.reply; 1412 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1413 1414 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1415 ioc->diag_buffer_status[buffer_type] |= 1416 MPT2_DIAG_BUFFER_IS_REGISTERED; 1417 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n", 1418 ioc->name, __func__)); 1419 } else { 1420 printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) " 1421 "log_info(0x%08x)\n", ioc->name, __func__, 1422 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1423 rc = -EFAULT; 1424 } 1425 1426 issue_host_reset: 1427 if (issue_reset) 1428 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1429 FORCE_BIG_HAMMER); 1430 1431 out: 1432 1433 if (rc && request_data) 1434 pci_free_consistent(ioc->pdev, request_data_sz, 1435 request_data, request_data_dma); 1436 1437 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED; 1438 return rc; 1439} 1440 1441/** 1442 * mpt2sas_enable_diag_buffer - enabling diag_buffers support driver load time 1443 * @ioc: per adapter object 1444 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1 1445 * 1446 * This is called when command line option diag_buffer_enable is enabled 1447 * at driver load time. 1448 */ 1449void 1450mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register) 1451{ 1452 struct mpt2_diag_register diag_register; 1453 1454 memset(&diag_register, 0, sizeof(struct mpt2_diag_register)); 1455 1456 if (bits_to_register & 1) { 1457 printk(MPT2SAS_INFO_FMT "registering trace buffer support\n", 1458 ioc->name); 1459 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 1460 /* register for 1MB buffers */ 1461 diag_register.requested_buffer_size = (1024 * 1024); 1462 diag_register.unique_id = 0x7075900; 1463 _ctl_diag_register_2(ioc, &diag_register); 1464 } 1465 1466 if (bits_to_register & 2) { 1467 printk(MPT2SAS_INFO_FMT "registering snapshot buffer support\n", 1468 ioc->name); 1469 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT; 1470 /* register for 2MB buffers */ 1471 diag_register.requested_buffer_size = 2 * (1024 * 1024); 1472 diag_register.unique_id = 0x7075901; 1473 _ctl_diag_register_2(ioc, &diag_register); 1474 } 1475 1476 if (bits_to_register & 4) { 1477 printk(MPT2SAS_INFO_FMT "registering extended buffer support\n", 1478 ioc->name); 1479 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED; 1480 /* register for 2MB buffers */ 1481 diag_register.requested_buffer_size = 2 * (1024 * 1024); 1482 diag_register.unique_id = 0x7075901; 1483 _ctl_diag_register_2(ioc, &diag_register); 1484 } 1485} 1486 1487/** 1488 * _ctl_diag_register - application register with driver 1489 * @arg - user space buffer containing ioctl content 1490 * @state - NON_BLOCKING or BLOCKING 1491 * 1492 * This will allow the driver to setup any required buffers that will be 1493 * needed by firmware to communicate with the driver. 1494 */ 1495static long 1496_ctl_diag_register(void __user *arg, enum block_state state) 1497{ 1498 struct mpt2_diag_register karg; 1499 struct MPT2SAS_ADAPTER *ioc; 1500 long rc; 1501 1502 if (copy_from_user(&karg, arg, sizeof(karg))) { 1503 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1504 __FILE__, __LINE__, __func__); 1505 return -EFAULT; 1506 } 1507 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1508 return -ENODEV; 1509 1510 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex)) 1511 return -EAGAIN; 1512 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) 1513 return -ERESTARTSYS; 1514 rc = _ctl_diag_register_2(ioc, &karg); 1515 mutex_unlock(&ioc->ctl_cmds.mutex); 1516 return rc; 1517} 1518 1519/** 1520 * _ctl_diag_unregister - application unregister with driver 1521 * @arg - user space buffer containing ioctl content 1522 * 1523 * This will allow the driver to cleanup any memory allocated for diag 1524 * messages and to free up any resources. 1525 */ 1526static long 1527_ctl_diag_unregister(void __user *arg) 1528{ 1529 struct mpt2_diag_unregister karg; 1530 struct MPT2SAS_ADAPTER *ioc; 1531 void *request_data; 1532 dma_addr_t request_data_dma; 1533 u32 request_data_sz; 1534 u8 buffer_type; 1535 1536 if (copy_from_user(&karg, arg, sizeof(karg))) { 1537 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1538 __FILE__, __LINE__, __func__); 1539 return -EFAULT; 1540 } 1541 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1542 return -ENODEV; 1543 1544 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1545 __func__)); 1546 1547 buffer_type = karg.unique_id & 0x000000ff; 1548 if (!_ctl_diag_capability(ioc, buffer_type)) { 1549 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for " 1550 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1551 return -EPERM; 1552 } 1553 1554 if ((ioc->diag_buffer_status[buffer_type] & 1555 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) { 1556 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not " 1557 "registered\n", ioc->name, __func__, buffer_type); 1558 return -EINVAL; 1559 } 1560 if ((ioc->diag_buffer_status[buffer_type] & 1561 MPT2_DIAG_BUFFER_IS_RELEASED) == 0) { 1562 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) has not been " 1563 "released\n", ioc->name, __func__, buffer_type); 1564 return -EINVAL; 1565 } 1566 1567 if (karg.unique_id != ioc->unique_id[buffer_type]) { 1568 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not " 1569 "registered\n", ioc->name, __func__, karg.unique_id); 1570 return -EINVAL; 1571 } 1572 1573 request_data = ioc->diag_buffer[buffer_type]; 1574 if (!request_data) { 1575 printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for " 1576 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1577 return -ENOMEM; 1578 } 1579 1580 request_data_sz = ioc->diag_buffer_sz[buffer_type]; 1581 request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1582 pci_free_consistent(ioc->pdev, request_data_sz, 1583 request_data, request_data_dma); 1584 ioc->diag_buffer[buffer_type] = NULL; 1585 ioc->diag_buffer_status[buffer_type] = 0; 1586 return 0; 1587} 1588 1589/** 1590 * _ctl_diag_query - query relevant info associated with diag buffers 1591 * @arg - user space buffer containing ioctl content 1592 * 1593 * The application will send only buffer_type and unique_id. Driver will 1594 * inspect unique_id first, if valid, fill in all the info. If unique_id is 1595 * 0x00, the driver will return info specified by Buffer Type. 1596 */ 1597static long 1598_ctl_diag_query(void __user *arg) 1599{ 1600 struct mpt2_diag_query karg; 1601 struct MPT2SAS_ADAPTER *ioc; 1602 void *request_data; 1603 int i; 1604 u8 buffer_type; 1605 1606 if (copy_from_user(&karg, arg, sizeof(karg))) { 1607 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1608 __FILE__, __LINE__, __func__); 1609 return -EFAULT; 1610 } 1611 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1612 return -ENODEV; 1613 1614 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1615 __func__)); 1616 1617 karg.application_flags = 0; 1618 buffer_type = karg.buffer_type; 1619 1620 if (!_ctl_diag_capability(ioc, buffer_type)) { 1621 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for " 1622 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1623 return -EPERM; 1624 } 1625 1626 if ((ioc->diag_buffer_status[buffer_type] & 1627 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) { 1628 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not " 1629 "registered\n", ioc->name, __func__, buffer_type); 1630 return -EINVAL; 1631 } 1632 1633 if (karg.unique_id & 0xffffff00) { 1634 if (karg.unique_id != ioc->unique_id[buffer_type]) { 1635 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not " 1636 "registered\n", ioc->name, __func__, 1637 karg.unique_id); 1638 return -EINVAL; 1639 } 1640 } 1641 1642 request_data = ioc->diag_buffer[buffer_type]; 1643 if (!request_data) { 1644 printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for " 1645 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1646 return -ENOMEM; 1647 } 1648 1649 if (ioc->diag_buffer_status[buffer_type] & MPT2_DIAG_BUFFER_IS_RELEASED) 1650 karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED | 1651 MPT2_APP_FLAGS_BUFFER_VALID); 1652 else 1653 karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED | 1654 MPT2_APP_FLAGS_BUFFER_VALID | 1655 MPT2_APP_FLAGS_FW_BUFFER_ACCESS); 1656 1657 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++) 1658 karg.product_specific[i] = 1659 ioc->product_specific[buffer_type][i]; 1660 1661 karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type]; 1662 karg.driver_added_buffer_size = 0; 1663 karg.unique_id = ioc->unique_id[buffer_type]; 1664 karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type]; 1665 1666 if (copy_to_user(arg, &karg, sizeof(struct mpt2_diag_query))) { 1667 printk(MPT2SAS_ERR_FMT "%s: unable to write mpt2_diag_query " 1668 "data @ %p\n", ioc->name, __func__, arg); 1669 return -EFAULT; 1670 } 1671 return 0; 1672} 1673 1674/** 1675 * _ctl_send_release - Diag Release Message 1676 * @ioc: per adapter object 1677 * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED 1678 * @issue_reset - specifies whether host reset is required. 1679 * 1680 */ 1681static int 1682_ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset) 1683{ 1684 Mpi2DiagReleaseRequest_t *mpi_request; 1685 Mpi2DiagReleaseReply_t *mpi_reply; 1686 u16 smid; 1687 u16 ioc_status; 1688 u32 ioc_state; 1689 int rc; 1690 unsigned long timeleft; 1691 1692 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1693 __func__)); 1694 1695 rc = 0; 1696 *issue_reset = 0; 1697 1698 ioc_state = mpt2sas_base_get_iocstate(ioc, 1); 1699 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 1700 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 1701 "skipping due to FAULT state\n", ioc->name, 1702 __func__)); 1703 rc = -EAGAIN; 1704 goto out; 1705 } 1706 1707 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) { 1708 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n", 1709 ioc->name, __func__); 1710 rc = -EAGAIN; 1711 goto out; 1712 } 1713 1714 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1715 if (!smid) { 1716 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n", 1717 ioc->name, __func__); 1718 rc = -EAGAIN; 1719 goto out; 1720 } 1721 1722 ioc->ctl_cmds.status = MPT2_CMD_PENDING; 1723 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1724 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid); 1725 ioc->ctl_cmds.smid = smid; 1726 1727 mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE; 1728 mpi_request->BufferType = buffer_type; 1729 mpi_request->VF_ID = 0; /* TODO */ 1730 mpi_request->VP_ID = 0; 1731 1732 mpt2sas_base_put_smid_default(ioc, smid); 1733 init_completion(&ioc->ctl_cmds.done); 1734 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 1735 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ); 1736 1737 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) { 1738 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name, 1739 __func__); 1740 _debug_dump_mf(mpi_request, 1741 sizeof(Mpi2DiagReleaseRequest_t)/4); 1742 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET)) 1743 *issue_reset = 1; 1744 rc = -EFAULT; 1745 goto out; 1746 } 1747 1748 /* process the completed Reply Message Frame */ 1749 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) { 1750 printk(MPT2SAS_ERR_FMT "%s: no reply message\n", 1751 ioc->name, __func__); 1752 rc = -EFAULT; 1753 goto out; 1754 } 1755 1756 mpi_reply = ioc->ctl_cmds.reply; 1757 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1758 1759 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1760 ioc->diag_buffer_status[buffer_type] |= 1761 MPT2_DIAG_BUFFER_IS_RELEASED; 1762 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n", 1763 ioc->name, __func__)); 1764 } else { 1765 printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) " 1766 "log_info(0x%08x)\n", ioc->name, __func__, 1767 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1768 rc = -EFAULT; 1769 } 1770 1771 out: 1772 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED; 1773 return rc; 1774} 1775 1776/** 1777 * _ctl_diag_release - request to send Diag Release Message to firmware 1778 * @arg - user space buffer containing ioctl content 1779 * @state - NON_BLOCKING or BLOCKING 1780 * 1781 * This allows ownership of the specified buffer to returned to the driver, 1782 * allowing an application to read the buffer without fear that firmware is 1783 * overwritting information in the buffer. 1784 */ 1785static long 1786_ctl_diag_release(void __user *arg, enum block_state state) 1787{ 1788 struct mpt2_diag_release karg; 1789 struct MPT2SAS_ADAPTER *ioc; 1790 void *request_data; 1791 int rc; 1792 u8 buffer_type; 1793 u8 issue_reset = 0; 1794 1795 if (copy_from_user(&karg, arg, sizeof(karg))) { 1796 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1797 __FILE__, __LINE__, __func__); 1798 return -EFAULT; 1799 } 1800 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1801 return -ENODEV; 1802 1803 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1804 __func__)); 1805 1806 buffer_type = karg.unique_id & 0x000000ff; 1807 if (!_ctl_diag_capability(ioc, buffer_type)) { 1808 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for " 1809 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1810 return -EPERM; 1811 } 1812 1813 if ((ioc->diag_buffer_status[buffer_type] & 1814 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) { 1815 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not " 1816 "registered\n", ioc->name, __func__, buffer_type); 1817 return -EINVAL; 1818 } 1819 1820 if (karg.unique_id != ioc->unique_id[buffer_type]) { 1821 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not " 1822 "registered\n", ioc->name, __func__, karg.unique_id); 1823 return -EINVAL; 1824 } 1825 1826 if (ioc->diag_buffer_status[buffer_type] & 1827 MPT2_DIAG_BUFFER_IS_RELEASED) { 1828 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) " 1829 "is already released\n", ioc->name, __func__, 1830 buffer_type); 1831 return 0; 1832 } 1833 1834 request_data = ioc->diag_buffer[buffer_type]; 1835 1836 if (!request_data) { 1837 printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for " 1838 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1839 return -ENOMEM; 1840 } 1841 1842 /* buffers were released by due to host reset */ 1843 if ((ioc->diag_buffer_status[buffer_type] & 1844 MPT2_DIAG_BUFFER_IS_DIAG_RESET)) { 1845 ioc->diag_buffer_status[buffer_type] |= 1846 MPT2_DIAG_BUFFER_IS_RELEASED; 1847 ioc->diag_buffer_status[buffer_type] &= 1848 ~MPT2_DIAG_BUFFER_IS_DIAG_RESET; 1849 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) " 1850 "was released due to host reset\n", ioc->name, __func__, 1851 buffer_type); 1852 return 0; 1853 } 1854 1855 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex)) 1856 return -EAGAIN; 1857 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) 1858 return -ERESTARTSYS; 1859 1860 rc = _ctl_send_release(ioc, buffer_type, &issue_reset); 1861 1862 if (issue_reset) 1863 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1864 FORCE_BIG_HAMMER); 1865 1866 mutex_unlock(&ioc->ctl_cmds.mutex); 1867 return rc; 1868} 1869 1870/** 1871 * _ctl_diag_read_buffer - request for copy of the diag buffer 1872 * @arg - user space buffer containing ioctl content 1873 * @state - NON_BLOCKING or BLOCKING 1874 */ 1875static long 1876_ctl_diag_read_buffer(void __user *arg, enum block_state state) 1877{ 1878 struct mpt2_diag_read_buffer karg; 1879 struct mpt2_diag_read_buffer __user *uarg = arg; 1880 struct MPT2SAS_ADAPTER *ioc; 1881 void *request_data, *diag_data; 1882 Mpi2DiagBufferPostRequest_t *mpi_request; 1883 Mpi2DiagBufferPostReply_t *mpi_reply; 1884 int rc, i; 1885 u8 buffer_type; 1886 unsigned long timeleft; 1887 u16 smid; 1888 u16 ioc_status; 1889 u8 issue_reset = 0; 1890 1891 if (copy_from_user(&karg, arg, sizeof(karg))) { 1892 printk(KERN_ERR "failure at %s:%d/%s()!\n", 1893 __FILE__, __LINE__, __func__); 1894 return -EFAULT; 1895 } 1896 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc) 1897 return -ENODEV; 1898 1899 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name, 1900 __func__)); 1901 1902 buffer_type = karg.unique_id & 0x000000ff; 1903 if (!_ctl_diag_capability(ioc, buffer_type)) { 1904 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for " 1905 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1906 return -EPERM; 1907 } 1908 1909 if (karg.unique_id != ioc->unique_id[buffer_type]) { 1910 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not " 1911 "registered\n", ioc->name, __func__, karg.unique_id); 1912 return -EINVAL; 1913 } 1914 1915 request_data = ioc->diag_buffer[buffer_type]; 1916 if (!request_data) { 1917 printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for " 1918 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type); 1919 return -ENOMEM; 1920 } 1921 1922 if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) { 1923 printk(MPT2SAS_ERR_FMT "%s: either the starting_offset " 1924 "or bytes_to_read are not 4 byte aligned\n", ioc->name, 1925 __func__); 1926 return -EINVAL; 1927 } 1928 1929 diag_data = (void *)(request_data + karg.starting_offset); 1930 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(%p), " 1931 "offset(%d), sz(%d)\n", ioc->name, __func__, 1932 diag_data, karg.starting_offset, karg.bytes_to_read)); 1933 1934 if (copy_to_user((void __user *)uarg->diagnostic_data, 1935 diag_data, karg.bytes_to_read)) { 1936 printk(MPT2SAS_ERR_FMT "%s: Unable to write " 1937 "mpt_diag_read_buffer_t data @ %p\n", ioc->name, 1938 __func__, diag_data); 1939 return -EFAULT; 1940 } 1941 1942 if ((karg.flags & MPT2_FLAGS_REREGISTER) == 0) 1943 return 0; 1944 1945 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: Reregister " 1946 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type)); 1947 if ((ioc->diag_buffer_status[buffer_type] & 1948 MPT2_DIAG_BUFFER_IS_RELEASED) == 0) { 1949 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: " 1950 "buffer_type(0x%02x) is still registered\n", ioc->name, 1951 __func__, buffer_type)); 1952 return 0; 1953 } 1954 /* Get a free request frame and save the message context. 1955 */ 1956 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex)) 1957 return -EAGAIN; 1958 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) 1959 return -ERESTARTSYS; 1960 1961 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) { 1962 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n", 1963 ioc->name, __func__); 1964 rc = -EAGAIN; 1965 goto out; 1966 } 1967 1968 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1969 if (!smid) { 1970 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n", 1971 ioc->name, __func__); 1972 rc = -EAGAIN; 1973 goto out; 1974 } 1975 1976 rc = 0; 1977 ioc->ctl_cmds.status = MPT2_CMD_PENDING; 1978 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1979 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid); 1980 ioc->ctl_cmds.smid = smid; 1981 1982 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 1983 mpi_request->BufferType = buffer_type; 1984 mpi_request->BufferLength = 1985 cpu_to_le32(ioc->diag_buffer_sz[buffer_type]); 1986 mpi_request->BufferAddress = 1987 cpu_to_le64(ioc->diag_buffer_dma[buffer_type]); 1988 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++) 1989 mpi_request->ProductSpecific[i] = 1990 cpu_to_le32(ioc->product_specific[buffer_type][i]); 1991 mpi_request->VF_ID = 0; /* TODO */ 1992 mpi_request->VP_ID = 0; 1993 1994 mpt2sas_base_put_smid_default(ioc, smid); 1995 init_completion(&ioc->ctl_cmds.done); 1996 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 1997 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ); 1998 1999 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) { 2000 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name, 2001 __func__); 2002 _debug_dump_mf(mpi_request, 2003 sizeof(Mpi2DiagBufferPostRequest_t)/4); 2004 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET)) 2005 issue_reset = 1; 2006 goto issue_host_reset; 2007 } 2008 2009 /* process the completed Reply Message Frame */ 2010 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) { 2011 printk(MPT2SAS_ERR_FMT "%s: no reply message\n", 2012 ioc->name, __func__); 2013 rc = -EFAULT; 2014 goto out; 2015 } 2016 2017 mpi_reply = ioc->ctl_cmds.reply; 2018 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 2019 2020 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 2021 ioc->diag_buffer_status[buffer_type] |= 2022 MPT2_DIAG_BUFFER_IS_REGISTERED; 2023 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n", 2024 ioc->name, __func__)); 2025 } else { 2026 printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) " 2027 "log_info(0x%08x)\n", ioc->name, __func__, 2028 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 2029 rc = -EFAULT; 2030 } 2031 2032 issue_host_reset: 2033 if (issue_reset) 2034 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP, 2035 FORCE_BIG_HAMMER); 2036 2037 out: 2038 2039 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED; 2040 mutex_unlock(&ioc->ctl_cmds.mutex); 2041 return rc; 2042} 2043 2044/** 2045 * _ctl_ioctl_main - main ioctl entry point 2046 * @file - (struct file) 2047 * @cmd - ioctl opcode 2048 * @arg - 2049 */ 2050static long 2051_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg) 2052{ 2053 enum block_state state; 2054 long ret = -EINVAL; 2055 2056 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : 2057 BLOCKING; 2058 2059 switch (cmd) { 2060 case MPT2IOCINFO: 2061 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo)) 2062 ret = _ctl_getiocinfo(arg); 2063 break; 2064 case MPT2COMMAND: 2065 { 2066 struct mpt2_ioctl_command karg; 2067 struct mpt2_ioctl_command __user *uarg; 2068 struct MPT2SAS_ADAPTER *ioc; 2069 2070 if (copy_from_user(&karg, arg, sizeof(karg))) { 2071 printk(KERN_ERR "failure at %s:%d/%s()!\n", 2072 __FILE__, __LINE__, __func__); 2073 return -EFAULT; 2074 } 2075 2076 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || 2077 !ioc) 2078 return -ENODEV; 2079 2080 if (ioc->shost_recovery) 2081 return -EAGAIN; 2082 2083 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) { 2084 uarg = arg; 2085 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state); 2086 } 2087 break; 2088 } 2089 case MPT2EVENTQUERY: 2090 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery)) 2091 ret = _ctl_eventquery(arg); 2092 break; 2093 case MPT2EVENTENABLE: 2094 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable)) 2095 ret = _ctl_eventenable(arg); 2096 break; 2097 case MPT2EVENTREPORT: 2098 ret = _ctl_eventreport(arg); 2099 break; 2100 case MPT2HARDRESET: 2101 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset)) 2102 ret = _ctl_do_reset(arg); 2103 break; 2104 case MPT2BTDHMAPPING: 2105 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping)) 2106 ret = _ctl_btdh_mapping(arg); 2107 break; 2108 case MPT2DIAGREGISTER: 2109 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register)) 2110 ret = _ctl_diag_register(arg, state); 2111 break; 2112 case MPT2DIAGUNREGISTER: 2113 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister)) 2114 ret = _ctl_diag_unregister(arg); 2115 break; 2116 case MPT2DIAGQUERY: 2117 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query)) 2118 ret = _ctl_diag_query(arg); 2119 break; 2120 case MPT2DIAGRELEASE: 2121 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release)) 2122 ret = _ctl_diag_release(arg, state); 2123 break; 2124 case MPT2DIAGREADBUFFER: 2125 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer)) 2126 ret = _ctl_diag_read_buffer(arg, state); 2127 break; 2128 default: 2129 { 2130 struct mpt2_ioctl_command karg; 2131 struct MPT2SAS_ADAPTER *ioc; 2132 2133 if (copy_from_user(&karg, arg, sizeof(karg))) { 2134 printk(KERN_ERR "failure at %s:%d/%s()!\n", 2135 __FILE__, __LINE__, __func__); 2136 return -EFAULT; 2137 } 2138 2139 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || 2140 !ioc) 2141 return -ENODEV; 2142 2143 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT 2144 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd)); 2145 break; 2146 } 2147 } 2148 return ret; 2149} 2150 2151/** 2152 * _ctl_ioctl - main ioctl entry point (unlocked) 2153 * @file - (struct file) 2154 * @cmd - ioctl opcode 2155 * @arg - 2156 */ 2157static long 2158_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2159{ 2160 long ret; 2161 2162 lock_kernel(); 2163 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg); 2164 unlock_kernel(); 2165 return ret; 2166} 2167 2168#ifdef CONFIG_COMPAT 2169/** 2170 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit. 2171 * @file - (struct file) 2172 * @cmd - ioctl opcode 2173 * @arg - (struct mpt2_ioctl_command32) 2174 * 2175 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os. 2176 */ 2177static long 2178_ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg) 2179{ 2180 struct mpt2_ioctl_command32 karg32; 2181 struct mpt2_ioctl_command32 __user *uarg; 2182 struct mpt2_ioctl_command karg; 2183 struct MPT2SAS_ADAPTER *ioc; 2184 enum block_state state; 2185 2186 if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32)) 2187 return -EINVAL; 2188 2189 uarg = (struct mpt2_ioctl_command32 __user *) arg; 2190 2191 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) { 2192 printk(KERN_ERR "failure at %s:%d/%s()!\n", 2193 __FILE__, __LINE__, __func__); 2194 return -EFAULT; 2195 } 2196 if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc) 2197 return -ENODEV; 2198 2199 if (ioc->shost_recovery) 2200 return -EAGAIN; 2201 2202 memset(&karg, 0, sizeof(struct mpt2_ioctl_command)); 2203 karg.hdr.ioc_number = karg32.hdr.ioc_number; 2204 karg.hdr.port_number = karg32.hdr.port_number; 2205 karg.hdr.max_data_size = karg32.hdr.max_data_size; 2206 karg.timeout = karg32.timeout; 2207 karg.max_reply_bytes = karg32.max_reply_bytes; 2208 karg.data_in_size = karg32.data_in_size; 2209 karg.data_out_size = karg32.data_out_size; 2210 karg.max_sense_bytes = karg32.max_sense_bytes; 2211 karg.data_sge_offset = karg32.data_sge_offset; 2212 karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr); 2213 karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr); 2214 karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr); 2215 karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr); 2216 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING; 2217 return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state); 2218} 2219 2220/** 2221 * _ctl_ioctl_compat - main ioctl entry point (compat) 2222 * @file - 2223 * @cmd - 2224 * @arg - 2225 * 2226 * This routine handles 32 bit applications in 64bit os. 2227 */ 2228static long 2229_ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg) 2230{ 2231 long ret; 2232 2233 lock_kernel(); 2234 if (cmd == MPT2COMMAND32) 2235 ret = _ctl_compat_mpt_command(file, cmd, arg); 2236 else 2237 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg); 2238 unlock_kernel(); 2239 return ret; 2240} 2241#endif 2242 2243/* scsi host attributes */ 2244 2245/** 2246 * _ctl_version_fw_show - firmware version 2247 * @cdev - pointer to embedded class device 2248 * @buf - the buffer returned 2249 * 2250 * A sysfs 'read-only' shost attribute. 2251 */ 2252static ssize_t 2253_ctl_version_fw_show(struct device *cdev, struct device_attribute *attr, 2254 char *buf) 2255{ 2256 struct Scsi_Host *shost = class_to_shost(cdev); 2257 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2258 2259 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2260 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24, 2261 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16, 2262 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8, 2263 ioc->facts.FWVersion.Word & 0x000000FF); 2264} 2265static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL); 2266 2267/** 2268 * _ctl_version_bios_show - bios version 2269 * @cdev - pointer to embedded class device 2270 * @buf - the buffer returned 2271 * 2272 * A sysfs 'read-only' shost attribute. 2273 */ 2274static ssize_t 2275_ctl_version_bios_show(struct device *cdev, struct device_attribute *attr, 2276 char *buf) 2277{ 2278 struct Scsi_Host *shost = class_to_shost(cdev); 2279 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2280 2281 u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 2282 2283 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2284 (version & 0xFF000000) >> 24, 2285 (version & 0x00FF0000) >> 16, 2286 (version & 0x0000FF00) >> 8, 2287 version & 0x000000FF); 2288} 2289static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL); 2290 2291/** 2292 * _ctl_version_mpi_show - MPI (message passing interface) version 2293 * @cdev - pointer to embedded class device 2294 * @buf - the buffer returned 2295 * 2296 * A sysfs 'read-only' shost attribute. 2297 */ 2298static ssize_t 2299_ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr, 2300 char *buf) 2301{ 2302 struct Scsi_Host *shost = class_to_shost(cdev); 2303 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2304 2305 return snprintf(buf, PAGE_SIZE, "%03x.%02x\n", 2306 ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8); 2307} 2308static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL); 2309 2310/** 2311 * _ctl_version_product_show - product name 2312 * @cdev - pointer to embedded class device 2313 * @buf - the buffer returned 2314 * 2315 * A sysfs 'read-only' shost attribute. 2316 */ 2317static ssize_t 2318_ctl_version_product_show(struct device *cdev, struct device_attribute *attr, 2319 char *buf) 2320{ 2321 struct Scsi_Host *shost = class_to_shost(cdev); 2322 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2323 2324 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName); 2325} 2326static DEVICE_ATTR(version_product, S_IRUGO, 2327 _ctl_version_product_show, NULL); 2328 2329/** 2330 * _ctl_version_nvdata_persistent_show - ndvata persistent version 2331 * @cdev - pointer to embedded class device 2332 * @buf - the buffer returned 2333 * 2334 * A sysfs 'read-only' shost attribute. 2335 */ 2336static ssize_t 2337_ctl_version_nvdata_persistent_show(struct device *cdev, 2338 struct device_attribute *attr, char *buf) 2339{ 2340 struct Scsi_Host *shost = class_to_shost(cdev); 2341 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2342 2343 return snprintf(buf, PAGE_SIZE, "%08xh\n", 2344 le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word)); 2345} 2346static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO, 2347 _ctl_version_nvdata_persistent_show, NULL); 2348 2349/** 2350 * _ctl_version_nvdata_default_show - nvdata default version 2351 * @cdev - pointer to embedded class device 2352 * @buf - the buffer returned 2353 * 2354 * A sysfs 'read-only' shost attribute. 2355 */ 2356static ssize_t 2357_ctl_version_nvdata_default_show(struct device *cdev, 2358 struct device_attribute *attr, char *buf) 2359{ 2360 struct Scsi_Host *shost = class_to_shost(cdev); 2361 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2362 2363 return snprintf(buf, PAGE_SIZE, "%08xh\n", 2364 le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word)); 2365} 2366static DEVICE_ATTR(version_nvdata_default, S_IRUGO, 2367 _ctl_version_nvdata_default_show, NULL); 2368 2369/** 2370 * _ctl_board_name_show - board name 2371 * @cdev - pointer to embedded class device 2372 * @buf - the buffer returned 2373 * 2374 * A sysfs 'read-only' shost attribute. 2375 */ 2376static ssize_t 2377_ctl_board_name_show(struct device *cdev, struct device_attribute *attr, 2378 char *buf) 2379{ 2380 struct Scsi_Host *shost = class_to_shost(cdev); 2381 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2382 2383 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName); 2384} 2385static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL); 2386 2387/** 2388 * _ctl_board_assembly_show - board assembly name 2389 * @cdev - pointer to embedded class device 2390 * @buf - the buffer returned 2391 * 2392 * A sysfs 'read-only' shost attribute. 2393 */ 2394static ssize_t 2395_ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr, 2396 char *buf) 2397{ 2398 struct Scsi_Host *shost = class_to_shost(cdev); 2399 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2400 2401 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly); 2402} 2403static DEVICE_ATTR(board_assembly, S_IRUGO, 2404 _ctl_board_assembly_show, NULL); 2405 2406/** 2407 * _ctl_board_tracer_show - board tracer number 2408 * @cdev - pointer to embedded class device 2409 * @buf - the buffer returned 2410 * 2411 * A sysfs 'read-only' shost attribute. 2412 */ 2413static ssize_t 2414_ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr, 2415 char *buf) 2416{ 2417 struct Scsi_Host *shost = class_to_shost(cdev); 2418 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2419 2420 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber); 2421} 2422static DEVICE_ATTR(board_tracer, S_IRUGO, 2423 _ctl_board_tracer_show, NULL); 2424 2425/** 2426 * _ctl_io_delay_show - io missing delay 2427 * @cdev - pointer to embedded class device 2428 * @buf - the buffer returned 2429 * 2430 * This is for firmware implemention for deboucing device 2431 * removal events. 2432 * 2433 * A sysfs 'read-only' shost attribute. 2434 */ 2435static ssize_t 2436_ctl_io_delay_show(struct device *cdev, struct device_attribute *attr, 2437 char *buf) 2438{ 2439 struct Scsi_Host *shost = class_to_shost(cdev); 2440 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2441 2442 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay); 2443} 2444static DEVICE_ATTR(io_delay, S_IRUGO, 2445 _ctl_io_delay_show, NULL); 2446 2447/** 2448 * _ctl_device_delay_show - device missing delay 2449 * @cdev - pointer to embedded class device 2450 * @buf - the buffer returned 2451 * 2452 * This is for firmware implemention for deboucing device 2453 * removal events. 2454 * 2455 * A sysfs 'read-only' shost attribute. 2456 */ 2457static ssize_t 2458_ctl_device_delay_show(struct device *cdev, struct device_attribute *attr, 2459 char *buf) 2460{ 2461 struct Scsi_Host *shost = class_to_shost(cdev); 2462 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2463 2464 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay); 2465} 2466static DEVICE_ATTR(device_delay, S_IRUGO, 2467 _ctl_device_delay_show, NULL); 2468 2469/** 2470 * _ctl_fw_queue_depth_show - global credits 2471 * @cdev - pointer to embedded class device 2472 * @buf - the buffer returned 2473 * 2474 * This is firmware queue depth limit 2475 * 2476 * A sysfs 'read-only' shost attribute. 2477 */ 2478static ssize_t 2479_ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr, 2480 char *buf) 2481{ 2482 struct Scsi_Host *shost = class_to_shost(cdev); 2483 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2484 2485 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit); 2486} 2487static DEVICE_ATTR(fw_queue_depth, S_IRUGO, 2488 _ctl_fw_queue_depth_show, NULL); 2489 2490/** 2491 * _ctl_sas_address_show - sas address 2492 * @cdev - pointer to embedded class device 2493 * @buf - the buffer returned 2494 * 2495 * This is the controller sas address 2496 * 2497 * A sysfs 'read-only' shost attribute. 2498 */ 2499static ssize_t 2500_ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr, 2501 char *buf) 2502{ 2503 struct Scsi_Host *shost = class_to_shost(cdev); 2504 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2505 2506 return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 2507 (unsigned long long)ioc->sas_hba.sas_address); 2508} 2509static DEVICE_ATTR(host_sas_address, S_IRUGO, 2510 _ctl_host_sas_address_show, NULL); 2511 2512/** 2513 * _ctl_logging_level_show - logging level 2514 * @cdev - pointer to embedded class device 2515 * @buf - the buffer returned 2516 * 2517 * A sysfs 'read/write' shost attribute. 2518 */ 2519static ssize_t 2520_ctl_logging_level_show(struct device *cdev, struct device_attribute *attr, 2521 char *buf) 2522{ 2523 struct Scsi_Host *shost = class_to_shost(cdev); 2524 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2525 2526 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level); 2527} 2528static ssize_t 2529_ctl_logging_level_store(struct device *cdev, struct device_attribute *attr, 2530 const char *buf, size_t count) 2531{ 2532 struct Scsi_Host *shost = class_to_shost(cdev); 2533 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2534 int val = 0; 2535 2536 if (sscanf(buf, "%x", &val) != 1) 2537 return -EINVAL; 2538 2539 ioc->logging_level = val; 2540 printk(MPT2SAS_INFO_FMT "logging_level=%08xh\n", ioc->name, 2541 ioc->logging_level); 2542 return strlen(buf); 2543} 2544static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR, 2545 _ctl_logging_level_show, _ctl_logging_level_store); 2546 2547/* device attributes */ 2548/* 2549 * _ctl_fwfault_debug_show - show/store fwfault_debug 2550 * @cdev - pointer to embedded class device 2551 * @buf - the buffer returned 2552 * 2553 * mpt2sas_fwfault_debug is command line option 2554 * A sysfs 'read/write' shost attribute. 2555 */ 2556static ssize_t 2557_ctl_fwfault_debug_show(struct device *cdev, 2558 struct device_attribute *attr, char *buf) 2559{ 2560 struct Scsi_Host *shost = class_to_shost(cdev); 2561 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2562 2563 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug); 2564} 2565static ssize_t 2566_ctl_fwfault_debug_store(struct device *cdev, 2567 struct device_attribute *attr, const char *buf, size_t count) 2568{ 2569 struct Scsi_Host *shost = class_to_shost(cdev); 2570 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2571 int val = 0; 2572 2573 if (sscanf(buf, "%d", &val) != 1) 2574 return -EINVAL; 2575 2576 ioc->fwfault_debug = val; 2577 printk(MPT2SAS_INFO_FMT "fwfault_debug=%d\n", ioc->name, 2578 ioc->fwfault_debug); 2579 return strlen(buf); 2580} 2581static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR, 2582 _ctl_fwfault_debug_show, _ctl_fwfault_debug_store); 2583 2584 2585/** 2586 * _ctl_ioc_reset_count_show - ioc reset count 2587 * @cdev - pointer to embedded class device 2588 * @buf - the buffer returned 2589 * 2590 * This is firmware queue depth limit 2591 * 2592 * A sysfs 'read-only' shost attribute. 2593 */ 2594static ssize_t 2595_ctl_ioc_reset_count_show(struct device *cdev, struct device_attribute *attr, 2596 char *buf) 2597{ 2598 struct Scsi_Host *shost = class_to_shost(cdev); 2599 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2600 2601 return snprintf(buf, PAGE_SIZE, "%08d\n", ioc->ioc_reset_count); 2602} 2603static DEVICE_ATTR(ioc_reset_count, S_IRUGO, 2604 _ctl_ioc_reset_count_show, NULL); 2605 2606struct DIAG_BUFFER_START { 2607 u32 Size; 2608 u32 DiagVersion; 2609 u8 BufferType; 2610 u8 Reserved[3]; 2611 u32 Reserved1; 2612 u32 Reserved2; 2613 u32 Reserved3; 2614}; 2615/** 2616 * _ctl_host_trace_buffer_size_show - host buffer size (trace only) 2617 * @cdev - pointer to embedded class device 2618 * @buf - the buffer returned 2619 * 2620 * A sysfs 'read-only' shost attribute. 2621 */ 2622static ssize_t 2623_ctl_host_trace_buffer_size_show(struct device *cdev, 2624 struct device_attribute *attr, char *buf) 2625{ 2626 struct Scsi_Host *shost = class_to_shost(cdev); 2627 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2628 u32 size = 0; 2629 struct DIAG_BUFFER_START *request_data; 2630 2631 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 2632 printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not " 2633 "registered\n", ioc->name, __func__); 2634 return 0; 2635 } 2636 2637 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2638 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) { 2639 printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not " 2640 "registered\n", ioc->name, __func__); 2641 return 0; 2642 } 2643 2644 request_data = (struct DIAG_BUFFER_START *) 2645 ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]; 2646 if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 || 2647 le32_to_cpu(request_data->DiagVersion) == 0x01000000) && 2648 le32_to_cpu(request_data->Reserved3) == 0x4742444c) 2649 size = le32_to_cpu(request_data->Size); 2650 2651 ioc->ring_buffer_sz = size; 2652 return snprintf(buf, PAGE_SIZE, "%d\n", size); 2653} 2654static DEVICE_ATTR(host_trace_buffer_size, S_IRUGO, 2655 _ctl_host_trace_buffer_size_show, NULL); 2656 2657/** 2658 * _ctl_host_trace_buffer_show - firmware ring buffer (trace only) 2659 * @cdev - pointer to embedded class device 2660 * @buf - the buffer returned 2661 * 2662 * A sysfs 'read/write' shost attribute. 2663 * 2664 * You will only be able to read 4k bytes of ring buffer at a time. 2665 * In order to read beyond 4k bytes, you will have to write out the 2666 * offset to the same attribute, it will move the pointer. 2667 */ 2668static ssize_t 2669_ctl_host_trace_buffer_show(struct device *cdev, struct device_attribute *attr, 2670 char *buf) 2671{ 2672 struct Scsi_Host *shost = class_to_shost(cdev); 2673 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2674 void *request_data; 2675 u32 size; 2676 2677 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 2678 printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not " 2679 "registered\n", ioc->name, __func__); 2680 return 0; 2681 } 2682 2683 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2684 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) { 2685 printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not " 2686 "registered\n", ioc->name, __func__); 2687 return 0; 2688 } 2689 2690 if (ioc->ring_buffer_offset > ioc->ring_buffer_sz) 2691 return 0; 2692 2693 size = ioc->ring_buffer_sz - ioc->ring_buffer_offset; 2694 size = (size > PAGE_SIZE) ? PAGE_SIZE : size; 2695 request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset; 2696 memcpy(buf, request_data, size); 2697 return size; 2698} 2699 2700static ssize_t 2701_ctl_host_trace_buffer_store(struct device *cdev, struct device_attribute *attr, 2702 const char *buf, size_t count) 2703{ 2704 struct Scsi_Host *shost = class_to_shost(cdev); 2705 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2706 int val = 0; 2707 2708 if (sscanf(buf, "%d", &val) != 1) 2709 return -EINVAL; 2710 2711 ioc->ring_buffer_offset = val; 2712 return strlen(buf); 2713} 2714static DEVICE_ATTR(host_trace_buffer, S_IRUGO | S_IWUSR, 2715 _ctl_host_trace_buffer_show, _ctl_host_trace_buffer_store); 2716 2717/*****************************************/ 2718 2719/** 2720 * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only) 2721 * @cdev - pointer to embedded class device 2722 * @buf - the buffer returned 2723 * 2724 * A sysfs 'read/write' shost attribute. 2725 * 2726 * This is a mechnism to post/release host_trace_buffers 2727 */ 2728static ssize_t 2729_ctl_host_trace_buffer_enable_show(struct device *cdev, 2730 struct device_attribute *attr, char *buf) 2731{ 2732 struct Scsi_Host *shost = class_to_shost(cdev); 2733 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2734 2735 if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) || 2736 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2737 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0)) 2738 return snprintf(buf, PAGE_SIZE, "off\n"); 2739 else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2740 MPT2_DIAG_BUFFER_IS_RELEASED)) 2741 return snprintf(buf, PAGE_SIZE, "release\n"); 2742 else 2743 return snprintf(buf, PAGE_SIZE, "post\n"); 2744} 2745 2746static ssize_t 2747_ctl_host_trace_buffer_enable_store(struct device *cdev, 2748 struct device_attribute *attr, const char *buf, size_t count) 2749{ 2750 struct Scsi_Host *shost = class_to_shost(cdev); 2751 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost); 2752 char str[10] = ""; 2753 struct mpt2_diag_register diag_register; 2754 u8 issue_reset = 0; 2755 2756 if (sscanf(buf, "%s", str) != 1) 2757 return -EINVAL; 2758 2759 if (!strcmp(str, "post")) { 2760 /* exit out if host buffers are already posted */ 2761 if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) && 2762 (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2763 MPT2_DIAG_BUFFER_IS_REGISTERED) && 2764 ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2765 MPT2_DIAG_BUFFER_IS_RELEASED) == 0)) 2766 goto out; 2767 memset(&diag_register, 0, sizeof(struct mpt2_diag_register)); 2768 printk(MPT2SAS_INFO_FMT "posting host trace buffers\n", 2769 ioc->name); 2770 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 2771 diag_register.requested_buffer_size = (1024 * 1024); 2772 diag_register.unique_id = 0x7075900; 2773 ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0; 2774 _ctl_diag_register_2(ioc, &diag_register); 2775 } else if (!strcmp(str, "release")) { 2776 /* exit out if host buffers are already released */ 2777 if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) 2778 goto out; 2779 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2780 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) 2781 goto out; 2782 if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2783 MPT2_DIAG_BUFFER_IS_RELEASED)) 2784 goto out; 2785 printk(MPT2SAS_INFO_FMT "releasing host trace buffer\n", 2786 ioc->name); 2787 _ctl_send_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, &issue_reset); 2788 } 2789 2790 out: 2791 return strlen(buf); 2792} 2793static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR, 2794 _ctl_host_trace_buffer_enable_show, _ctl_host_trace_buffer_enable_store); 2795 2796struct device_attribute *mpt2sas_host_attrs[] = { 2797 &dev_attr_version_fw, 2798 &dev_attr_version_bios, 2799 &dev_attr_version_mpi, 2800 &dev_attr_version_product, 2801 &dev_attr_version_nvdata_persistent, 2802 &dev_attr_version_nvdata_default, 2803 &dev_attr_board_name, 2804 &dev_attr_board_assembly, 2805 &dev_attr_board_tracer, 2806 &dev_attr_io_delay, 2807 &dev_attr_device_delay, 2808 &dev_attr_logging_level, 2809 &dev_attr_fwfault_debug, 2810 &dev_attr_fw_queue_depth, 2811 &dev_attr_host_sas_address, 2812 &dev_attr_ioc_reset_count, 2813 &dev_attr_host_trace_buffer_size, 2814 &dev_attr_host_trace_buffer, 2815 &dev_attr_host_trace_buffer_enable, 2816 NULL, 2817}; 2818 2819/** 2820 * _ctl_device_sas_address_show - sas address 2821 * @cdev - pointer to embedded class device 2822 * @buf - the buffer returned 2823 * 2824 * This is the sas address for the target 2825 * 2826 * A sysfs 'read-only' shost attribute. 2827 */ 2828static ssize_t 2829_ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr, 2830 char *buf) 2831{ 2832 struct scsi_device *sdev = to_scsi_device(dev); 2833 struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 2834 2835 return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 2836 (unsigned long long)sas_device_priv_data->sas_target->sas_address); 2837} 2838static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL); 2839 2840/** 2841 * _ctl_device_handle_show - device handle 2842 * @cdev - pointer to embedded class device 2843 * @buf - the buffer returned 2844 * 2845 * This is the firmware assigned device handle 2846 * 2847 * A sysfs 'read-only' shost attribute. 2848 */ 2849static ssize_t 2850_ctl_device_handle_show(struct device *dev, struct device_attribute *attr, 2851 char *buf) 2852{ 2853 struct scsi_device *sdev = to_scsi_device(dev); 2854 struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 2855 2856 return snprintf(buf, PAGE_SIZE, "0x%04x\n", 2857 sas_device_priv_data->sas_target->handle); 2858} 2859static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL); 2860 2861struct device_attribute *mpt2sas_dev_attrs[] = { 2862 &dev_attr_sas_address, 2863 &dev_attr_sas_device_handle, 2864 NULL, 2865}; 2866 2867static const struct file_operations ctl_fops = { 2868 .owner = THIS_MODULE, 2869 .unlocked_ioctl = _ctl_ioctl, 2870 .release = _ctl_release, 2871 .poll = _ctl_poll, 2872 .fasync = _ctl_fasync, 2873#ifdef CONFIG_COMPAT 2874 .compat_ioctl = _ctl_ioctl_compat, 2875#endif 2876}; 2877 2878static struct miscdevice ctl_dev = { 2879 .minor = MPT2SAS_MINOR, 2880 .name = MPT2SAS_DEV_NAME, 2881 .fops = &ctl_fops, 2882}; 2883 2884/** 2885 * mpt2sas_ctl_init - main entry point for ctl. 2886 * 2887 */ 2888void 2889mpt2sas_ctl_init(void) 2890{ 2891 async_queue = NULL; 2892 if (misc_register(&ctl_dev) < 0) 2893 printk(KERN_ERR "%s can't register misc device [minor=%d]\n", 2894 MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR); 2895 2896 init_waitqueue_head(&ctl_poll_wait); 2897} 2898 2899/** 2900 * mpt2sas_ctl_exit - exit point for ctl 2901 * 2902 */ 2903void 2904mpt2sas_ctl_exit(void) 2905{ 2906 struct MPT2SAS_ADAPTER *ioc; 2907 int i; 2908 2909 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) { 2910 2911 /* free memory associated to diag buffers */ 2912 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 2913 if (!ioc->diag_buffer[i]) 2914 continue; 2915 pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i], 2916 ioc->diag_buffer[i], ioc->diag_buffer_dma[i]); 2917 ioc->diag_buffer[i] = NULL; 2918 ioc->diag_buffer_status[i] = 0; 2919 } 2920 2921 kfree(ioc->event_log); 2922 } 2923 misc_deregister(&ctl_dev); 2924} 2925 2926