?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] mpt2sas: Added sysfs support for trace buffer
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / mpt2sas / mpt2sas_ctl.c
blob371f063a926c1278171500d461a29ca9e2a1d053
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
64 static struct fasync_struct *async_queue;
65 static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait);
66
67 static 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 */
78 enum 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 */
95 static 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_DEBUG_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_DEBUG_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_DEBUG_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 */
231 u8
232 mpt2sas_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 */
265 static 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 */
288 void
289 mpt2sas_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 */
344 u8
345 mpt2sas_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 */
362 static 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 */
387 void
388 mpt2sas_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_DEBUG_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_DEBUG_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_DEBUG_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 */
442 static 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 */
455 static 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 */
467 static 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 */
490 static 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_DEBUG_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_DEBUG_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 */
566 static 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_DEBUG_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_DEBUG_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 */
938 static 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_DEBUG_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 */
987 static 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_DEBUG_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 */
1020 static 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_DEBUG_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 */
1060 static 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_DEBUG_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 */
1106 static 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_DEBUG_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 */
1136 static 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 */
1172 static 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 */
1207 static 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_DEBUG_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 */
1244 static 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 */
1275 static 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_DEBUG_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_DEBUG_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_DEBUG_FMT "%s: success\n",
1418 ioc->name, __func__));
1419 } else {
1420 printk(MPT2SAS_DEBUG_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 */
1449 void
1450 mpt2sas_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 */
1495 static 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 */
1526 static 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_DEBUG_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 */
1597 static 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_DEBUG_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 */
1681 static 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_DEBUG_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_DEBUG_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_DEBUG_FMT "%s: success\n",
1763 ioc->name, __func__));
1764 } else {
1765 printk(MPT2SAS_DEBUG_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 */
1785 static 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_DEBUG_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 */
1875 static 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_DEBUG_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_DEBUG_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_DEBUG_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_DEBUG_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_DEBUG_FMT "%s: success\n",
2024 ioc->name, __func__));
2025 } else {
2026 printk(MPT2SAS_DEBUG_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 */
2050 static 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_DEBUG_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 */
2157 static 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 */
2177 static 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 */
2228 static 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 */
2252 static 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 }
2265 static 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 */
2274 static 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 }
2289 static 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 */
2298 static 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 }
2308 static 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 */
2317 static 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 }
2326 static 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 */
2336 static 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 }
2346 static 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 */
2356 static 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 }
2366 static 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 */
2376 static 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 }
2385 static 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 */
2394 static 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 }
2403 static 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 */
2413 static 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 }
2422 static 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 */
2435 static 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 }
2444 static 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 */
2457 static 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 }
2466 static 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 */
2478 static 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 }
2487 static 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 */
2499 static 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 }
2509 static 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 */
2519 static 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 }
2528 static 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 }
2544 static 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 */
2556 static 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 }
2565 static 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 }
2581 static 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 */
2594 static 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 }
2603 static DEVICE_ATTR(ioc_reset_count, S_IRUGO,
2604 _ctl_ioc_reset_count_show, NULL);
2605
2606 struct 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 */
2622 static 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 }
2654 static 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 */
2668 static 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
2700 static 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 }
2714 static 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 */
2728 static 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
2746 static 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 }
2793 static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR,
2794 _ctl_host_trace_buffer_enable_show, _ctl_host_trace_buffer_enable_store);
2795
2796 struct 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 */
2828 static 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 }
2838 static 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 */
2849 static 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 }
2859 static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL);
2860
2861 struct device_attribute *mpt2sas_dev_attrs[] = {
2862 &dev_attr_sas_address,
2863 &dev_attr_sas_device_handle,
2864 NULL,
2865 };
2866
2867 static 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
2878 static 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 */
2888 void
2889 mpt2sas_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 */
2903 void
2904 mpt2sas_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
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree