projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


ddaa99cdce81c0314e53a0a0b7e9c730c9371d80
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / scsi / mpt2sas / mpt2sas_ctl.c
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 mpt2sas_base_put_smid_scsi_io(ioc, smid,
748 le16_to_cpu(mpi_request->FunctionDependent1));
749 break;
750 }
751 case MPI2_FUNCTION_SCSI_TASK_MGMT:
752 {
753 Mpi2SCSITaskManagementRequest_t *tm_request =
754 (Mpi2SCSITaskManagementRequest_t *)mpi_request;
755
756 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "TASK_MGMT: "
757 "handle(0x%04x), task_type(0x%02x)\n", ioc->name,
758 le16_to_cpu(tm_request->DevHandle), tm_request->TaskType));
759
760 if (tm_request->TaskType ==
761 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
762 tm_request->TaskType ==
763 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
764 if (_ctl_set_task_mid(ioc, &karg, tm_request)) {
765 mpt2sas_base_free_smid(ioc, smid);
766 goto out;
767 }
768 }
769
770 mpt2sas_scsih_set_tm_flag(ioc, le16_to_cpu(
771 tm_request->DevHandle));
772 mpt2sas_base_put_smid_hi_priority(ioc, smid);
773 break;
774 }
775 case MPI2_FUNCTION_SMP_PASSTHROUGH:
776 {
777 Mpi2SmpPassthroughRequest_t *smp_request =
778 (Mpi2SmpPassthroughRequest_t *)mpi_request;
779 u8 *data;
780
781 /* ioc determines which port to use */
782 smp_request->PhysicalPort = 0xFF;
783 if (smp_request->PassthroughFlags &
784 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
785 data = (u8 *)&smp_request->SGL;
786 else
787 data = data_out;
788
789 if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
790 ioc->ioc_link_reset_in_progress = 1;
791 ioc->ignore_loginfos = 1;
792 }
793 mpt2sas_base_put_smid_default(ioc, smid);
794 break;
795 }
796 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
797 {
798 Mpi2SasIoUnitControlRequest_t *sasiounit_request =
799 (Mpi2SasIoUnitControlRequest_t *)mpi_request;
800
801 if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET
802 || sasiounit_request->Operation ==
803 MPI2_SAS_OP_PHY_LINK_RESET) {
804 ioc->ioc_link_reset_in_progress = 1;
805 ioc->ignore_loginfos = 1;
806 }
807 mpt2sas_base_put_smid_default(ioc, smid);
808 break;
809 }
810 default:
811 mpt2sas_base_put_smid_default(ioc, smid);
812 break;
813 }
814
815 if (karg.timeout < MPT2_IOCTL_DEFAULT_TIMEOUT)
816 timeout = MPT2_IOCTL_DEFAULT_TIMEOUT;
817 else
818 timeout = karg.timeout;
819 init_completion(&ioc->ctl_cmds.done);
820 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
821 timeout*HZ);
822 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
823 Mpi2SCSITaskManagementRequest_t *tm_request =
824 (Mpi2SCSITaskManagementRequest_t *)mpi_request;
825 mpt2sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
826 tm_request->DevHandle));
827 } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH ||
828 mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) &&
829 ioc->ioc_link_reset_in_progress) {
830 ioc->ioc_link_reset_in_progress = 0;
831 ioc->ignore_loginfos = 0;
832 }
833 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
834 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
835 __func__);
836 _debug_dump_mf(mpi_request, karg.data_sge_offset);
837 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
838 issue_reset = 1;
839 goto issue_host_reset;
840 }
841
842 mpi_reply = ioc->ctl_cmds.reply;
843 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
844
845 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
846 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT &&
847 (ioc->logging_level & MPT_DEBUG_TM)) {
848 Mpi2SCSITaskManagementReply_t *tm_reply =
849 (Mpi2SCSITaskManagementReply_t *)mpi_reply;
850
851 printk(MPT2SAS_DEBUG_FMT "TASK_MGMT: "
852 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
853 "TerminationCount(0x%08x)\n", ioc->name,
854 le16_to_cpu(tm_reply->IOCStatus),
855 le32_to_cpu(tm_reply->IOCLogInfo),
856 le32_to_cpu(tm_reply->TerminationCount));
857 }
858 #endif
859 /* copy out xdata to user */
860 if (data_in_sz) {
861 if (copy_to_user(karg.data_in_buf_ptr, data_in,
862 data_in_sz)) {
863 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
864 __LINE__, __func__);
865 ret = -ENODATA;
866 goto out;
867 }
868 }
869
870 /* copy out reply message frame to user */
871 if (karg.max_reply_bytes) {
872 sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
873 if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply,
874 sz)) {
875 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
876 __LINE__, __func__);
877 ret = -ENODATA;
878 goto out;
879 }
880 }
881
882 /* copy out sense to user */
883 if (karg.max_sense_bytes && (mpi_request->Function ==
884 MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
885 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
886 sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE);
887 if (copy_to_user(karg.sense_data_ptr, priv_sense, sz)) {
888 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
889 __LINE__, __func__);
890 ret = -ENODATA;
891 goto out;
892 }
893 }
894
895 issue_host_reset:
896 if (issue_reset) {
897 ret = -ENODATA;
898 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
899 mpi_request->Function ==
900 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
901 printk(MPT2SAS_INFO_FMT "issue target reset: handle "
902 "= (0x%04x)\n", ioc->name,
903 le16_to_cpu(mpi_request->FunctionDependent1));
904 mpt2sas_halt_firmware(ioc);
905 mpt2sas_scsih_issue_tm(ioc,
906 le16_to_cpu(mpi_request->FunctionDependent1), 0, 0,
907 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 10,
908 NULL);
909 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
910 } else
911 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
912 FORCE_BIG_HAMMER);
913 }
914
915 out:
916
917 /* free memory associated with sg buffers */
918 if (data_in)
919 pci_free_consistent(ioc->pdev, data_in_sz, data_in,
920 data_in_dma);
921
922 if (data_out)
923 pci_free_consistent(ioc->pdev, data_out_sz, data_out,
924 data_out_dma);
925
926 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
927 mutex_unlock(&ioc->ctl_cmds.mutex);
928 return ret;
929 }
930
931 /**
932 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
933 * @arg - user space buffer containing ioctl content
934 */
935 static long
936 _ctl_getiocinfo(void __user *arg)
937 {
938 struct mpt2_ioctl_iocinfo karg;
939 struct MPT2SAS_ADAPTER *ioc;
940 u8 revision;
941
942 if (copy_from_user(&karg, arg, sizeof(karg))) {
943 printk(KERN_ERR "failure at %s:%d/%s()!\n",
944 __FILE__, __LINE__, __func__);
945 return -EFAULT;
946 }
947 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
948 return -ENODEV;
949
950 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
951 __func__));
952
953 memset(&karg, 0 , sizeof(karg));
954 karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
955 if (ioc->pfacts)
956 karg.port_number = ioc->pfacts[0].PortNumber;
957 pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision);
958 karg.hw_rev = revision;
959 karg.pci_id = ioc->pdev->device;
960 karg.subsystem_device = ioc->pdev->subsystem_device;
961 karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
962 karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
963 karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
964 karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
965 karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus);
966 karg.firmware_version = ioc->facts.FWVersion.Word;
967 strcpy(karg.driver_version, MPT2SAS_DRIVER_NAME);
968 strcat(karg.driver_version, "-");
969 strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION);
970 karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
971
972 if (copy_to_user(arg, &karg, sizeof(karg))) {
973 printk(KERN_ERR "failure at %s:%d/%s()!\n",
974 __FILE__, __LINE__, __func__);
975 return -EFAULT;
976 }
977 return 0;
978 }
979
980 /**
981 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
982 * @arg - user space buffer containing ioctl content
983 */
984 static long
985 _ctl_eventquery(void __user *arg)
986 {
987 struct mpt2_ioctl_eventquery karg;
988 struct MPT2SAS_ADAPTER *ioc;
989
990 if (copy_from_user(&karg, arg, sizeof(karg))) {
991 printk(KERN_ERR "failure at %s:%d/%s()!\n",
992 __FILE__, __LINE__, __func__);
993 return -EFAULT;
994 }
995 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
996 return -ENODEV;
997
998 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
999 __func__));
1000
1001 karg.event_entries = MPT2SAS_CTL_EVENT_LOG_SIZE;
1002 memcpy(karg.event_types, ioc->event_type,
1003 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1004
1005 if (copy_to_user(arg, &karg, sizeof(karg))) {
1006 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1007 __FILE__, __LINE__, __func__);
1008 return -EFAULT;
1009 }
1010 return 0;
1011 }
1012
1013 /**
1014 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
1015 * @arg - user space buffer containing ioctl content
1016 */
1017 static long
1018 _ctl_eventenable(void __user *arg)
1019 {
1020 struct mpt2_ioctl_eventenable karg;
1021 struct MPT2SAS_ADAPTER *ioc;
1022
1023 if (copy_from_user(&karg, arg, sizeof(karg))) {
1024 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1025 __FILE__, __LINE__, __func__);
1026 return -EFAULT;
1027 }
1028 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1029 return -ENODEV;
1030
1031 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
1032 __func__));
1033
1034 if (ioc->event_log)
1035 return 0;
1036 memcpy(ioc->event_type, karg.event_types,
1037 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1038 mpt2sas_base_validate_event_type(ioc, ioc->event_type);
1039
1040 /* initialize event_log */
1041 ioc->event_context = 0;
1042 ioc->aen_event_read_flag = 0;
1043 ioc->event_log = kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE,
1044 sizeof(struct MPT2_IOCTL_EVENTS), GFP_KERNEL);
1045 if (!ioc->event_log) {
1046 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1047 __FILE__, __LINE__, __func__);
1048 return -ENOMEM;
1049 }
1050 return 0;
1051 }
1052
1053 /**
1054 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
1055 * @arg - user space buffer containing ioctl content
1056 */
1057 static long
1058 _ctl_eventreport(void __user *arg)
1059 {
1060 struct mpt2_ioctl_eventreport karg;
1061 struct MPT2SAS_ADAPTER *ioc;
1062 u32 number_bytes, max_events, max;
1063 struct mpt2_ioctl_eventreport __user *uarg = arg;
1064
1065 if (copy_from_user(&karg, arg, sizeof(karg))) {
1066 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1067 __FILE__, __LINE__, __func__);
1068 return -EFAULT;
1069 }
1070 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1071 return -ENODEV;
1072
1073 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
1074 __func__));
1075
1076 number_bytes = karg.hdr.max_data_size -
1077 sizeof(struct mpt2_ioctl_header);
1078 max_events = number_bytes/sizeof(struct MPT2_IOCTL_EVENTS);
1079 max = min_t(u32, MPT2SAS_CTL_EVENT_LOG_SIZE, max_events);
1080
1081 /* If fewer than 1 event is requested, there must have
1082 * been some type of error.
1083 */
1084 if (!max || !ioc->event_log)
1085 return -ENODATA;
1086
1087 number_bytes = max * sizeof(struct MPT2_IOCTL_EVENTS);
1088 if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) {
1089 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1090 __FILE__, __LINE__, __func__);
1091 return -EFAULT;
1092 }
1093
1094 /* reset flag so SIGIO can restart */
1095 ioc->aen_event_read_flag = 0;
1096 return 0;
1097 }
1098
1099 /**
1100 * _ctl_do_reset - main handler for MPT2HARDRESET opcode
1101 * @arg - user space buffer containing ioctl content
1102 */
1103 static long
1104 _ctl_do_reset(void __user *arg)
1105 {
1106 struct mpt2_ioctl_diag_reset karg;
1107 struct MPT2SAS_ADAPTER *ioc;
1108 int retval;
1109
1110 if (copy_from_user(&karg, arg, sizeof(karg))) {
1111 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1112 __FILE__, __LINE__, __func__);
1113 return -EFAULT;
1114 }
1115 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1116 return -ENODEV;
1117
1118 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
1119 __func__));
1120
1121 retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1122 FORCE_BIG_HAMMER);
1123 printk(MPT2SAS_INFO_FMT "host reset: %s\n",
1124 ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
1125 return 0;
1126 }
1127
1128 /**
1129 * _ctl_btdh_search_sas_device - searching for sas device
1130 * @ioc: per adapter object
1131 * @btdh: btdh ioctl payload
1132 */
1133 static int
1134 _ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER *ioc,
1135 struct mpt2_ioctl_btdh_mapping *btdh)
1136 {
1137 struct _sas_device *sas_device;
1138 unsigned long flags;
1139 int rc = 0;
1140
1141 if (list_empty(&ioc->sas_device_list))
1142 return rc;
1143
1144 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1145 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
1146 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1147 btdh->handle == sas_device->handle) {
1148 btdh->bus = sas_device->channel;
1149 btdh->id = sas_device->id;
1150 rc = 1;
1151 goto out;
1152 } else if (btdh->bus == sas_device->channel && btdh->id ==
1153 sas_device->id && btdh->handle == 0xFFFF) {
1154 btdh->handle = sas_device->handle;
1155 rc = 1;
1156 goto out;
1157 }
1158 }
1159 out:
1160 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1161 return rc;
1162 }
1163
1164 /**
1165 * _ctl_btdh_search_raid_device - searching for raid device
1166 * @ioc: per adapter object
1167 * @btdh: btdh ioctl payload
1168 */
1169 static int
1170 _ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
1171 struct mpt2_ioctl_btdh_mapping *btdh)
1172 {
1173 struct _raid_device *raid_device;
1174 unsigned long flags;
1175 int rc = 0;
1176
1177 if (list_empty(&ioc->raid_device_list))
1178 return rc;
1179
1180 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1181 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1182 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1183 btdh->handle == raid_device->handle) {
1184 btdh->bus = raid_device->channel;
1185 btdh->id = raid_device->id;
1186 rc = 1;
1187 goto out;
1188 } else if (btdh->bus == raid_device->channel && btdh->id ==
1189 raid_device->id && btdh->handle == 0xFFFF) {
1190 btdh->handle = raid_device->handle;
1191 rc = 1;
1192 goto out;
1193 }
1194 }
1195 out:
1196 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1197 return rc;
1198 }
1199
1200 /**
1201 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
1202 * @arg - user space buffer containing ioctl content
1203 */
1204 static long
1205 _ctl_btdh_mapping(void __user *arg)
1206 {
1207 struct mpt2_ioctl_btdh_mapping karg;
1208 struct MPT2SAS_ADAPTER *ioc;
1209 int rc;
1210
1211 if (copy_from_user(&karg, arg, sizeof(karg))) {
1212 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1213 __FILE__, __LINE__, __func__);
1214 return -EFAULT;
1215 }
1216 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1217 return -ENODEV;
1218
1219 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1220 __func__));
1221
1222 rc = _ctl_btdh_search_sas_device(ioc, &karg);
1223 if (!rc)
1224 _ctl_btdh_search_raid_device(ioc, &karg);
1225
1226 if (copy_to_user(arg, &karg, sizeof(karg))) {
1227 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1228 __FILE__, __LINE__, __func__);
1229 return -EFAULT;
1230 }
1231 return 0;
1232 }
1233
1234 /**
1235 * _ctl_diag_capability - return diag buffer capability
1236 * @ioc: per adapter object
1237 * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
1238 *
1239 * returns 1 when diag buffer support is enabled in firmware
1240 */
1241 static u8
1242 _ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type)
1243 {
1244 u8 rc = 0;
1245
1246 switch (buffer_type) {
1247 case MPI2_DIAG_BUF_TYPE_TRACE:
1248 if (ioc->facts.IOCCapabilities &
1249 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER)
1250 rc = 1;
1251 break;
1252 case MPI2_DIAG_BUF_TYPE_SNAPSHOT:
1253 if (ioc->facts.IOCCapabilities &
1254 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
1255 rc = 1;
1256 break;
1257 case MPI2_DIAG_BUF_TYPE_EXTENDED:
1258 if (ioc->facts.IOCCapabilities &
1259 MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER)
1260 rc = 1;
1261 }
1262
1263 return rc;
1264 }
1265
1266 /**
1267 * _ctl_diag_register_2 - wrapper for registering diag buffer support
1268 * @ioc: per adapter object
1269 * @diag_register: the diag_register struct passed in from user space
1270 *
1271 */
1272 static long
1273 _ctl_diag_register_2(struct MPT2SAS_ADAPTER *ioc,
1274 struct mpt2_diag_register *diag_register)
1275 {
1276 int rc, i;
1277 void *request_data = NULL;
1278 dma_addr_t request_data_dma;
1279 u32 request_data_sz = 0;
1280 Mpi2DiagBufferPostRequest_t *mpi_request;
1281 Mpi2DiagBufferPostReply_t *mpi_reply;
1282 u8 buffer_type;
1283 unsigned long timeleft;
1284 u16 smid;
1285 u16 ioc_status;
1286 u8 issue_reset = 0;
1287
1288 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1289 __func__));
1290
1291 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1292 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1293 ioc->name, __func__);
1294 rc = -EAGAIN;
1295 goto out;
1296 }
1297
1298 buffer_type = diag_register->buffer_type;
1299 if (!_ctl_diag_capability(ioc, buffer_type)) {
1300 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1301 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1302 return -EPERM;
1303 }
1304
1305 if (ioc->diag_buffer_status[buffer_type] &
1306 MPT2_DIAG_BUFFER_IS_REGISTERED) {
1307 printk(MPT2SAS_ERR_FMT "%s: already has a registered "
1308 "buffer for buffer_type(0x%02x)\n", ioc->name, __func__,
1309 buffer_type);
1310 return -EINVAL;
1311 }
1312
1313 if (diag_register->requested_buffer_size % 4) {
1314 printk(MPT2SAS_ERR_FMT "%s: the requested_buffer_size "
1315 "is not 4 byte aligned\n", ioc->name, __func__);
1316 return -EINVAL;
1317 }
1318
1319 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1320 if (!smid) {
1321 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1322 ioc->name, __func__);
1323 rc = -EAGAIN;
1324 goto out;
1325 }
1326
1327 rc = 0;
1328 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1329 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1330 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1331 ioc->ctl_cmds.smid = smid;
1332
1333 request_data = ioc->diag_buffer[buffer_type];
1334 request_data_sz = diag_register->requested_buffer_size;
1335 ioc->unique_id[buffer_type] = diag_register->unique_id;
1336 ioc->diag_buffer_status[buffer_type] = 0;
1337 memcpy(ioc->product_specific[buffer_type],
1338 diag_register->product_specific, MPT2_PRODUCT_SPECIFIC_DWORDS);
1339 ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
1340
1341 if (request_data) {
1342 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1343 if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
1344 pci_free_consistent(ioc->pdev,
1345 ioc->diag_buffer_sz[buffer_type],
1346 request_data, request_data_dma);
1347 request_data = NULL;
1348 }
1349 }
1350
1351 if (request_data == NULL) {
1352 ioc->diag_buffer_sz[buffer_type] = 0;
1353 ioc->diag_buffer_dma[buffer_type] = 0;
1354 request_data = pci_alloc_consistent(
1355 ioc->pdev, request_data_sz, &request_data_dma);
1356 if (request_data == NULL) {
1357 printk(MPT2SAS_ERR_FMT "%s: failed allocating memory"
1358 " for diag buffers, requested size(%d)\n",
1359 ioc->name, __func__, request_data_sz);
1360 mpt2sas_base_free_smid(ioc, smid);
1361 return -ENOMEM;
1362 }
1363 ioc->diag_buffer[buffer_type] = request_data;
1364 ioc->diag_buffer_sz[buffer_type] = request_data_sz;
1365 ioc->diag_buffer_dma[buffer_type] = request_data_dma;
1366 }
1367
1368 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1369 mpi_request->BufferType = diag_register->buffer_type;
1370 mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags);
1371 mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
1372 mpi_request->BufferLength = cpu_to_le32(request_data_sz);
1373 mpi_request->VF_ID = 0; /* TODO */
1374 mpi_request->VP_ID = 0;
1375
1376 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: diag_buffer(0x%p), "
1377 "dma(0x%llx), sz(%d)\n", ioc->name, __func__, request_data,
1378 (unsigned long long)request_data_dma,
1379 le32_to_cpu(mpi_request->BufferLength)));
1380
1381 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1382 mpi_request->ProductSpecific[i] =
1383 cpu_to_le32(ioc->product_specific[buffer_type][i]);
1384
1385 mpt2sas_base_put_smid_default(ioc, smid);
1386 init_completion(&ioc->ctl_cmds.done);
1387 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1388 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1389
1390 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1391 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1392 __func__);
1393 _debug_dump_mf(mpi_request,
1394 sizeof(Mpi2DiagBufferPostRequest_t)/4);
1395 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1396 issue_reset = 1;
1397 goto issue_host_reset;
1398 }
1399
1400 /* process the completed Reply Message Frame */
1401 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1402 printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1403 ioc->name, __func__);
1404 rc = -EFAULT;
1405 goto out;
1406 }
1407
1408 mpi_reply = ioc->ctl_cmds.reply;
1409 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1410
1411 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1412 ioc->diag_buffer_status[buffer_type] |=
1413 MPT2_DIAG_BUFFER_IS_REGISTERED;
1414 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: success\n",
1415 ioc->name, __func__));
1416 } else {
1417 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
1418 "log_info(0x%08x)\n", ioc->name, __func__,
1419 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1420 rc = -EFAULT;
1421 }
1422
1423 issue_host_reset:
1424 if (issue_reset)
1425 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1426 FORCE_BIG_HAMMER);
1427
1428 out:
1429
1430 if (rc && request_data)
1431 pci_free_consistent(ioc->pdev, request_data_sz,
1432 request_data, request_data_dma);
1433
1434 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1435 return rc;
1436 }
1437
1438 /**
1439 * mpt2sas_enable_diag_buffer - enabling diag_buffers support driver load time
1440 * @ioc: per adapter object
1441 * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
1442 *
1443 * This is called when command line option diag_buffer_enable is enabled
1444 * at driver load time.
1445 */
1446 void
1447 mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
1448 {
1449 struct mpt2_diag_register diag_register;
1450
1451 memset(&diag_register, 0, sizeof(struct mpt2_diag_register));
1452
1453 if (bits_to_register & 1) {
1454 printk(MPT2SAS_INFO_FMT "registering trace buffer support\n",
1455 ioc->name);
1456 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
1457 /* register for 1MB buffers */
1458 diag_register.requested_buffer_size = (1024 * 1024);
1459 diag_register.unique_id = 0x7075900;
1460 _ctl_diag_register_2(ioc, &diag_register);
1461 }
1462
1463 if (bits_to_register & 2) {
1464 printk(MPT2SAS_INFO_FMT "registering snapshot buffer support\n",
1465 ioc->name);
1466 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
1467 /* register for 2MB buffers */
1468 diag_register.requested_buffer_size = 2 * (1024 * 1024);
1469 diag_register.unique_id = 0x7075901;
1470 _ctl_diag_register_2(ioc, &diag_register);
1471 }
1472
1473 if (bits_to_register & 4) {
1474 printk(MPT2SAS_INFO_FMT "registering extended buffer support\n",
1475 ioc->name);
1476 diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
1477 /* register for 2MB buffers */
1478 diag_register.requested_buffer_size = 2 * (1024 * 1024);
1479 diag_register.unique_id = 0x7075901;
1480 _ctl_diag_register_2(ioc, &diag_register);
1481 }
1482 }
1483
1484 /**
1485 * _ctl_diag_register - application register with driver
1486 * @arg - user space buffer containing ioctl content
1487 * @state - NON_BLOCKING or BLOCKING
1488 *
1489 * This will allow the driver to setup any required buffers that will be
1490 * needed by firmware to communicate with the driver.
1491 */
1492 static long
1493 _ctl_diag_register(void __user *arg, enum block_state state)
1494 {
1495 struct mpt2_diag_register karg;
1496 struct MPT2SAS_ADAPTER *ioc;
1497 long rc;
1498
1499 if (copy_from_user(&karg, arg, sizeof(karg))) {
1500 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1501 __FILE__, __LINE__, __func__);
1502 return -EFAULT;
1503 }
1504 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1505 return -ENODEV;
1506
1507 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1508 return -EAGAIN;
1509 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1510 return -ERESTARTSYS;
1511 rc = _ctl_diag_register_2(ioc, &karg);
1512 mutex_unlock(&ioc->ctl_cmds.mutex);
1513 return rc;
1514 }
1515
1516 /**
1517 * _ctl_diag_unregister - application unregister with driver
1518 * @arg - user space buffer containing ioctl content
1519 *
1520 * This will allow the driver to cleanup any memory allocated for diag
1521 * messages and to free up any resources.
1522 */
1523 static long
1524 _ctl_diag_unregister(void __user *arg)
1525 {
1526 struct mpt2_diag_unregister karg;
1527 struct MPT2SAS_ADAPTER *ioc;
1528 void *request_data;
1529 dma_addr_t request_data_dma;
1530 u32 request_data_sz;
1531 u8 buffer_type;
1532
1533 if (copy_from_user(&karg, arg, sizeof(karg))) {
1534 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1535 __FILE__, __LINE__, __func__);
1536 return -EFAULT;
1537 }
1538 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1539 return -ENODEV;
1540
1541 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1542 __func__));
1543
1544 buffer_type = karg.unique_id & 0x000000ff;
1545 if (!_ctl_diag_capability(ioc, buffer_type)) {
1546 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1547 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1548 return -EPERM;
1549 }
1550
1551 if ((ioc->diag_buffer_status[buffer_type] &
1552 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1553 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1554 "registered\n", ioc->name, __func__, buffer_type);
1555 return -EINVAL;
1556 }
1557 if ((ioc->diag_buffer_status[buffer_type] &
1558 MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
1559 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) has not been "
1560 "released\n", ioc->name, __func__, buffer_type);
1561 return -EINVAL;
1562 }
1563
1564 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1565 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1566 "registered\n", ioc->name, __func__, karg.unique_id);
1567 return -EINVAL;
1568 }
1569
1570 request_data = ioc->diag_buffer[buffer_type];
1571 if (!request_data) {
1572 printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
1573 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1574 return -ENOMEM;
1575 }
1576
1577 request_data_sz = ioc->diag_buffer_sz[buffer_type];
1578 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1579 pci_free_consistent(ioc->pdev, request_data_sz,
1580 request_data, request_data_dma);
1581 ioc->diag_buffer[buffer_type] = NULL;
1582 ioc->diag_buffer_status[buffer_type] = 0;
1583 return 0;
1584 }
1585
1586 /**
1587 * _ctl_diag_query - query relevant info associated with diag buffers
1588 * @arg - user space buffer containing ioctl content
1589 *
1590 * The application will send only buffer_type and unique_id. Driver will
1591 * inspect unique_id first, if valid, fill in all the info. If unique_id is
1592 * 0x00, the driver will return info specified by Buffer Type.
1593 */
1594 static long
1595 _ctl_diag_query(void __user *arg)
1596 {
1597 struct mpt2_diag_query karg;
1598 struct MPT2SAS_ADAPTER *ioc;
1599 void *request_data;
1600 int i;
1601 u8 buffer_type;
1602
1603 if (copy_from_user(&karg, arg, sizeof(karg))) {
1604 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1605 __FILE__, __LINE__, __func__);
1606 return -EFAULT;
1607 }
1608 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1609 return -ENODEV;
1610
1611 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1612 __func__));
1613
1614 karg.application_flags = 0;
1615 buffer_type = karg.buffer_type;
1616
1617 if (!_ctl_diag_capability(ioc, buffer_type)) {
1618 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1619 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1620 return -EPERM;
1621 }
1622
1623 if ((ioc->diag_buffer_status[buffer_type] &
1624 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1625 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1626 "registered\n", ioc->name, __func__, buffer_type);
1627 return -EINVAL;
1628 }
1629
1630 if (karg.unique_id & 0xffffff00) {
1631 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1632 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1633 "registered\n", ioc->name, __func__,
1634 karg.unique_id);
1635 return -EINVAL;
1636 }
1637 }
1638
1639 request_data = ioc->diag_buffer[buffer_type];
1640 if (!request_data) {
1641 printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
1642 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1643 return -ENOMEM;
1644 }
1645
1646 if (ioc->diag_buffer_status[buffer_type] & MPT2_DIAG_BUFFER_IS_RELEASED)
1647 karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
1648 MPT2_APP_FLAGS_BUFFER_VALID);
1649 else
1650 karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
1651 MPT2_APP_FLAGS_BUFFER_VALID |
1652 MPT2_APP_FLAGS_FW_BUFFER_ACCESS);
1653
1654 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1655 karg.product_specific[i] =
1656 ioc->product_specific[buffer_type][i];
1657
1658 karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
1659 karg.driver_added_buffer_size = 0;
1660 karg.unique_id = ioc->unique_id[buffer_type];
1661 karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
1662
1663 if (copy_to_user(arg, &karg, sizeof(struct mpt2_diag_query))) {
1664 printk(MPT2SAS_ERR_FMT "%s: unable to write mpt2_diag_query "
1665 "data @ %p\n", ioc->name, __func__, arg);
1666 return -EFAULT;
1667 }
1668 return 0;
1669 }
1670
1671 /**
1672 * _ctl_send_release - Diag Release Message
1673 * @ioc: per adapter object
1674 * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
1675 * @issue_reset - specifies whether host reset is required.
1676 *
1677 */
1678 static int
1679 _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
1680 {
1681 Mpi2DiagReleaseRequest_t *mpi_request;
1682 Mpi2DiagReleaseReply_t *mpi_reply;
1683 u16 smid;
1684 u16 ioc_status;
1685 u32 ioc_state;
1686 int rc;
1687 unsigned long timeleft;
1688
1689 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1690 __func__));
1691
1692 rc = 0;
1693 *issue_reset = 0;
1694
1695 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
1696 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1697 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
1698 "skipping due to FAULT state\n", ioc->name,
1699 __func__));
1700 rc = -EAGAIN;
1701 goto out;
1702 }
1703
1704 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1705 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1706 ioc->name, __func__);
1707 rc = -EAGAIN;
1708 goto out;
1709 }
1710
1711 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1712 if (!smid) {
1713 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1714 ioc->name, __func__);
1715 rc = -EAGAIN;
1716 goto out;
1717 }
1718
1719 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1720 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1721 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1722 ioc->ctl_cmds.smid = smid;
1723
1724 mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE;
1725 mpi_request->BufferType = buffer_type;
1726 mpi_request->VF_ID = 0; /* TODO */
1727 mpi_request->VP_ID = 0;
1728
1729 mpt2sas_base_put_smid_default(ioc, smid);
1730 init_completion(&ioc->ctl_cmds.done);
1731 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1732 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1733
1734 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1735 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1736 __func__);
1737 _debug_dump_mf(mpi_request,
1738 sizeof(Mpi2DiagReleaseRequest_t)/4);
1739 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1740 *issue_reset = 1;
1741 rc = -EFAULT;
1742 goto out;
1743 }
1744
1745 /* process the completed Reply Message Frame */
1746 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1747 printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1748 ioc->name, __func__);
1749 rc = -EFAULT;
1750 goto out;
1751 }
1752
1753 mpi_reply = ioc->ctl_cmds.reply;
1754 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1755
1756 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1757 ioc->diag_buffer_status[buffer_type] |=
1758 MPT2_DIAG_BUFFER_IS_RELEASED;
1759 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: success\n",
1760 ioc->name, __func__));
1761 } else {
1762 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
1763 "log_info(0x%08x)\n", ioc->name, __func__,
1764 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
1765 rc = -EFAULT;
1766 }
1767
1768 out:
1769 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1770 return rc;
1771 }
1772
1773 /**
1774 * _ctl_diag_release - request to send Diag Release Message to firmware
1775 * @arg - user space buffer containing ioctl content
1776 * @state - NON_BLOCKING or BLOCKING
1777 *
1778 * This allows ownership of the specified buffer to returned to the driver,
1779 * allowing an application to read the buffer without fear that firmware is
1780 * overwritting information in the buffer.
1781 */
1782 static long
1783 _ctl_diag_release(void __user *arg, enum block_state state)
1784 {
1785 struct mpt2_diag_release karg;
1786 struct MPT2SAS_ADAPTER *ioc;
1787 void *request_data;
1788 int rc;
1789 u8 buffer_type;
1790 u8 issue_reset = 0;
1791
1792 if (copy_from_user(&karg, arg, sizeof(karg))) {
1793 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1794 __FILE__, __LINE__, __func__);
1795 return -EFAULT;
1796 }
1797 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1798 return -ENODEV;
1799
1800 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1801 __func__));
1802
1803 buffer_type = karg.unique_id & 0x000000ff;
1804 if (!_ctl_diag_capability(ioc, buffer_type)) {
1805 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1806 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1807 return -EPERM;
1808 }
1809
1810 if ((ioc->diag_buffer_status[buffer_type] &
1811 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1812 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1813 "registered\n", ioc->name, __func__, buffer_type);
1814 return -EINVAL;
1815 }
1816
1817 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1818 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1819 "registered\n", ioc->name, __func__, karg.unique_id);
1820 return -EINVAL;
1821 }
1822
1823 if (ioc->diag_buffer_status[buffer_type] &
1824 MPT2_DIAG_BUFFER_IS_RELEASED) {
1825 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
1826 "is already released\n", ioc->name, __func__,
1827 buffer_type);
1828 return 0;
1829 }
1830
1831 request_data = ioc->diag_buffer[buffer_type];
1832
1833 if (!request_data) {
1834 printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
1835 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1836 return -ENOMEM;
1837 }
1838
1839 /* buffers were released by due to host reset */
1840 if ((ioc->diag_buffer_status[buffer_type] &
1841 MPT2_DIAG_BUFFER_IS_DIAG_RESET)) {
1842 ioc->diag_buffer_status[buffer_type] |=
1843 MPT2_DIAG_BUFFER_IS_RELEASED;
1844 ioc->diag_buffer_status[buffer_type] &=
1845 ~MPT2_DIAG_BUFFER_IS_DIAG_RESET;
1846 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
1847 "was released due to host reset\n", ioc->name, __func__,
1848 buffer_type);
1849 return 0;
1850 }
1851
1852 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1853 return -EAGAIN;
1854 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1855 return -ERESTARTSYS;
1856
1857 rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
1858
1859 if (issue_reset)
1860 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1861 FORCE_BIG_HAMMER);
1862
1863 mutex_unlock(&ioc->ctl_cmds.mutex);
1864 return rc;
1865 }
1866
1867 /**
1868 * _ctl_diag_read_buffer - request for copy of the diag buffer
1869 * @arg - user space buffer containing ioctl content
1870 * @state - NON_BLOCKING or BLOCKING
1871 */
1872 static long
1873 _ctl_diag_read_buffer(void __user *arg, enum block_state state)
1874 {
1875 struct mpt2_diag_read_buffer karg;
1876 struct mpt2_diag_read_buffer __user *uarg = arg;
1877 struct MPT2SAS_ADAPTER *ioc;
1878 void *request_data, *diag_data;
1879 Mpi2DiagBufferPostRequest_t *mpi_request;
1880 Mpi2DiagBufferPostReply_t *mpi_reply;
1881 int rc, i;
1882 u8 buffer_type;
1883 unsigned long timeleft;
1884 u16 smid;
1885 u16 ioc_status;
1886 u8 issue_reset = 0;
1887
1888 if (copy_from_user(&karg, arg, sizeof(karg))) {
1889 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1890 __FILE__, __LINE__, __func__);
1891 return -EFAULT;
1892 }
1893 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1894 return -ENODEV;
1895
1896 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1897 __func__));
1898
1899 buffer_type = karg.unique_id & 0x000000ff;
1900 if (!_ctl_diag_capability(ioc, buffer_type)) {
1901 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1902 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1903 return -EPERM;
1904 }
1905
1906 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1907 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1908 "registered\n", ioc->name, __func__, karg.unique_id);
1909 return -EINVAL;
1910 }
1911
1912 request_data = ioc->diag_buffer[buffer_type];
1913 if (!request_data) {
1914 printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
1915 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1916 return -ENOMEM;
1917 }
1918
1919 if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
1920 printk(MPT2SAS_ERR_FMT "%s: either the starting_offset "
1921 "or bytes_to_read are not 4 byte aligned\n", ioc->name,
1922 __func__);
1923 return -EINVAL;
1924 }
1925
1926 diag_data = (void *)(request_data + karg.starting_offset);
1927 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: diag_buffer(%p), "
1928 "offset(%d), sz(%d)\n", ioc->name, __func__,
1929 diag_data, karg.starting_offset, karg.bytes_to_read));
1930
1931 if (copy_to_user((void __user *)uarg->diagnostic_data,
1932 diag_data, karg.bytes_to_read)) {
1933 printk(MPT2SAS_ERR_FMT "%s: Unable to write "
1934 "mpt_diag_read_buffer_t data @ %p\n", ioc->name,
1935 __func__, diag_data);
1936 return -EFAULT;
1937 }
1938
1939 if ((karg.flags & MPT2_FLAGS_REREGISTER) == 0)
1940 return 0;
1941
1942 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: Reregister "
1943 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type));
1944 if ((ioc->diag_buffer_status[buffer_type] &
1945 MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
1946 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
1947 "buffer_type(0x%02x) is still registered\n", ioc->name,
1948 __func__, buffer_type));
1949 return 0;
1950 }
1951 /* Get a free request frame and save the message context.
1952 */
1953 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1954 return -EAGAIN;
1955 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1956 return -ERESTARTSYS;
1957
1958 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1959 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1960 ioc->name, __func__);
1961 rc = -EAGAIN;
1962 goto out;
1963 }
1964
1965 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1966 if (!smid) {
1967 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1968 ioc->name, __func__);
1969 rc = -EAGAIN;
1970 goto out;
1971 }
1972
1973 rc = 0;
1974 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1975 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1976 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1977 ioc->ctl_cmds.smid = smid;
1978
1979 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1980 mpi_request->BufferType = buffer_type;
1981 mpi_request->BufferLength =
1982 cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
1983 mpi_request->BufferAddress =
1984 cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
1985 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1986 mpi_request->ProductSpecific[i] =
1987 cpu_to_le32(ioc->product_specific[buffer_type][i]);
1988 mpi_request->VF_ID = 0; /* TODO */
1989 mpi_request->VP_ID = 0;
1990
1991 mpt2sas_base_put_smid_default(ioc, smid);
1992 init_completion(&ioc->ctl_cmds.done);
1993 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1994 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1995
1996 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1997 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1998 __func__);
1999 _debug_dump_mf(mpi_request,
2000 sizeof(Mpi2DiagBufferPostRequest_t)/4);
2001 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
2002 issue_reset = 1;
2003 goto issue_host_reset;
2004 }
2005
2006 /* process the completed Reply Message Frame */
2007 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
2008 printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
2009 ioc->name, __func__);
2010 rc = -EFAULT;
2011 goto out;
2012 }
2013
2014 mpi_reply = ioc->ctl_cmds.reply;
2015 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
2016
2017 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
2018 ioc->diag_buffer_status[buffer_type] |=
2019 MPT2_DIAG_BUFFER_IS_REGISTERED;
2020 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: success\n",
2021 ioc->name, __func__));
2022 } else {
2023 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
2024 "log_info(0x%08x)\n", ioc->name, __func__,
2025 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
2026 rc = -EFAULT;
2027 }
2028
2029 issue_host_reset:
2030 if (issue_reset)
2031 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
2032 FORCE_BIG_HAMMER);
2033
2034 out:
2035
2036 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
2037 mutex_unlock(&ioc->ctl_cmds.mutex);
2038 return rc;
2039 }
2040
2041 /**
2042 * _ctl_ioctl_main - main ioctl entry point
2043 * @file - (struct file)
2044 * @cmd - ioctl opcode
2045 * @arg -
2046 */
2047 static long
2048 _ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg)
2049 {
2050 enum block_state state;
2051 long ret = -EINVAL;
2052
2053 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING :
2054 BLOCKING;
2055
2056 switch (cmd) {
2057 case MPT2IOCINFO:
2058 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo))
2059 ret = _ctl_getiocinfo(arg);
2060 break;
2061 case MPT2COMMAND:
2062 {
2063 struct mpt2_ioctl_command karg;
2064 struct mpt2_ioctl_command __user *uarg;
2065 struct MPT2SAS_ADAPTER *ioc;
2066
2067 if (copy_from_user(&karg, arg, sizeof(karg))) {
2068 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2069 __FILE__, __LINE__, __func__);
2070 return -EFAULT;
2071 }
2072
2073 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2074 !ioc)
2075 return -ENODEV;
2076
2077 if (ioc->shost_recovery)
2078 return -EAGAIN;
2079
2080 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) {
2081 uarg = arg;
2082 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2083 }
2084 break;
2085 }
2086 case MPT2EVENTQUERY:
2087 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery))
2088 ret = _ctl_eventquery(arg);
2089 break;
2090 case MPT2EVENTENABLE:
2091 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable))
2092 ret = _ctl_eventenable(arg);
2093 break;
2094 case MPT2EVENTREPORT:
2095 ret = _ctl_eventreport(arg);
2096 break;
2097 case MPT2HARDRESET:
2098 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset))
2099 ret = _ctl_do_reset(arg);
2100 break;
2101 case MPT2BTDHMAPPING:
2102 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping))
2103 ret = _ctl_btdh_mapping(arg);
2104 break;
2105 case MPT2DIAGREGISTER:
2106 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register))
2107 ret = _ctl_diag_register(arg, state);
2108 break;
2109 case MPT2DIAGUNREGISTER:
2110 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister))
2111 ret = _ctl_diag_unregister(arg);
2112 break;
2113 case MPT2DIAGQUERY:
2114 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query))
2115 ret = _ctl_diag_query(arg);
2116 break;
2117 case MPT2DIAGRELEASE:
2118 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release))
2119 ret = _ctl_diag_release(arg, state);
2120 break;
2121 case MPT2DIAGREADBUFFER:
2122 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer))
2123 ret = _ctl_diag_read_buffer(arg, state);
2124 break;
2125 default:
2126 {
2127 struct mpt2_ioctl_command karg;
2128 struct MPT2SAS_ADAPTER *ioc;
2129
2130 if (copy_from_user(&karg, arg, sizeof(karg))) {
2131 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2132 __FILE__, __LINE__, __func__);
2133 return -EFAULT;
2134 }
2135
2136 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2137 !ioc)
2138 return -ENODEV;
2139
2140 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT
2141 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
2142 break;
2143 }
2144 }
2145 return ret;
2146 }
2147
2148 /**
2149 * _ctl_ioctl - main ioctl entry point (unlocked)
2150 * @file - (struct file)
2151 * @cmd - ioctl opcode
2152 * @arg -
2153 */
2154 static long
2155 _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2156 {
2157 long ret;
2158
2159 lock_kernel();
2160 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2161 unlock_kernel();
2162 return ret;
2163 }
2164
2165 #ifdef CONFIG_COMPAT
2166 /**
2167 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2168 * @file - (struct file)
2169 * @cmd - ioctl opcode
2170 * @arg - (struct mpt2_ioctl_command32)
2171 *
2172 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
2173 */
2174 static long
2175 _ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
2176 {
2177 struct mpt2_ioctl_command32 karg32;
2178 struct mpt2_ioctl_command32 __user *uarg;
2179 struct mpt2_ioctl_command karg;
2180 struct MPT2SAS_ADAPTER *ioc;
2181 enum block_state state;
2182
2183 if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
2184 return -EINVAL;
2185
2186 uarg = (struct mpt2_ioctl_command32 __user *) arg;
2187
2188 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
2189 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2190 __FILE__, __LINE__, __func__);
2191 return -EFAULT;
2192 }
2193 if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
2194 return -ENODEV;
2195
2196 if (ioc->shost_recovery)
2197 return -EAGAIN;
2198
2199 memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
2200 karg.hdr.ioc_number = karg32.hdr.ioc_number;
2201 karg.hdr.port_number = karg32.hdr.port_number;
2202 karg.hdr.max_data_size = karg32.hdr.max_data_size;
2203 karg.timeout = karg32.timeout;
2204 karg.max_reply_bytes = karg32.max_reply_bytes;
2205 karg.data_in_size = karg32.data_in_size;
2206 karg.data_out_size = karg32.data_out_size;
2207 karg.max_sense_bytes = karg32.max_sense_bytes;
2208 karg.data_sge_offset = karg32.data_sge_offset;
2209 karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
2210 karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
2211 karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
2212 karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
2213 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2214 return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2215 }
2216
2217 /**
2218 * _ctl_ioctl_compat - main ioctl entry point (compat)
2219 * @file -
2220 * @cmd -
2221 * @arg -
2222 *
2223 * This routine handles 32 bit applications in 64bit os.
2224 */
2225 static long
2226 _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2227 {
2228 long ret;
2229
2230 lock_kernel();
2231 if (cmd == MPT2COMMAND32)
2232 ret = _ctl_compat_mpt_command(file, cmd, arg);
2233 else
2234 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2235 unlock_kernel();
2236 return ret;
2237 }
2238 #endif
2239
2240 /* scsi host attributes */
2241
2242 /**
2243 * _ctl_version_fw_show - firmware version
2244 * @cdev - pointer to embedded class device
2245 * @buf - the buffer returned
2246 *
2247 * A sysfs 'read-only' shost attribute.
2248 */
2249 static ssize_t
2250 _ctl_version_fw_show(struct device *cdev, struct device_attribute *attr,
2251 char *buf)
2252 {
2253 struct Scsi_Host *shost = class_to_shost(cdev);
2254 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2255
2256 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2257 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
2258 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
2259 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
2260 ioc->facts.FWVersion.Word & 0x000000FF);
2261 }
2262 static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL);
2263
2264 /**
2265 * _ctl_version_bios_show - bios version
2266 * @cdev - pointer to embedded class device
2267 * @buf - the buffer returned
2268 *
2269 * A sysfs 'read-only' shost attribute.
2270 */
2271 static ssize_t
2272 _ctl_version_bios_show(struct device *cdev, struct device_attribute *attr,
2273 char *buf)
2274 {
2275 struct Scsi_Host *shost = class_to_shost(cdev);
2276 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2277
2278 u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
2279
2280 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2281 (version & 0xFF000000) >> 24,
2282 (version & 0x00FF0000) >> 16,
2283 (version & 0x0000FF00) >> 8,
2284 version & 0x000000FF);
2285 }
2286 static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL);
2287
2288 /**
2289 * _ctl_version_mpi_show - MPI (message passing interface) version
2290 * @cdev - pointer to embedded class device
2291 * @buf - the buffer returned
2292 *
2293 * A sysfs 'read-only' shost attribute.
2294 */
2295 static ssize_t
2296 _ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr,
2297 char *buf)
2298 {
2299 struct Scsi_Host *shost = class_to_shost(cdev);
2300 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2301
2302 return snprintf(buf, PAGE_SIZE, "%03x.%02x\n",
2303 ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
2304 }
2305 static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL);
2306
2307 /**
2308 * _ctl_version_product_show - product name
2309 * @cdev - pointer to embedded class device
2310 * @buf - the buffer returned
2311 *
2312 * A sysfs 'read-only' shost attribute.
2313 */
2314 static ssize_t
2315 _ctl_version_product_show(struct device *cdev, struct device_attribute *attr,
2316 char *buf)
2317 {
2318 struct Scsi_Host *shost = class_to_shost(cdev);
2319 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2320
2321 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName);
2322 }
2323 static DEVICE_ATTR(version_product, S_IRUGO,
2324 _ctl_version_product_show, NULL);
2325
2326 /**
2327 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2328 * @cdev - pointer to embedded class device
2329 * @buf - the buffer returned
2330 *
2331 * A sysfs 'read-only' shost attribute.
2332 */
2333 static ssize_t
2334 _ctl_version_nvdata_persistent_show(struct device *cdev,
2335 struct device_attribute *attr, char *buf)
2336 {
2337 struct Scsi_Host *shost = class_to_shost(cdev);
2338 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2339
2340 return snprintf(buf, PAGE_SIZE, "%08xh\n",
2341 le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
2342 }
2343 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
2344 _ctl_version_nvdata_persistent_show, NULL);
2345
2346 /**
2347 * _ctl_version_nvdata_default_show - nvdata default version
2348 * @cdev - pointer to embedded class device
2349 * @buf - the buffer returned
2350 *
2351 * A sysfs 'read-only' shost attribute.
2352 */
2353 static ssize_t
2354 _ctl_version_nvdata_default_show(struct device *cdev,
2355 struct device_attribute *attr, char *buf)
2356 {
2357 struct Scsi_Host *shost = class_to_shost(cdev);
2358 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2359
2360 return snprintf(buf, PAGE_SIZE, "%08xh\n",
2361 le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
2362 }
2363 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
2364 _ctl_version_nvdata_default_show, NULL);
2365
2366 /**
2367 * _ctl_board_name_show - board name
2368 * @cdev - pointer to embedded class device
2369 * @buf - the buffer returned
2370 *
2371 * A sysfs 'read-only' shost attribute.
2372 */
2373 static ssize_t
2374 _ctl_board_name_show(struct device *cdev, struct device_attribute *attr,
2375 char *buf)
2376 {
2377 struct Scsi_Host *shost = class_to_shost(cdev);
2378 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2379
2380 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName);
2381 }
2382 static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL);
2383
2384 /**
2385 * _ctl_board_assembly_show - board assembly name
2386 * @cdev - pointer to embedded class device
2387 * @buf - the buffer returned
2388 *
2389 * A sysfs 'read-only' shost attribute.
2390 */
2391 static ssize_t
2392 _ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr,
2393 char *buf)
2394 {
2395 struct Scsi_Host *shost = class_to_shost(cdev);
2396 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2397
2398 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly);
2399 }
2400 static DEVICE_ATTR(board_assembly, S_IRUGO,
2401 _ctl_board_assembly_show, NULL);
2402
2403 /**
2404 * _ctl_board_tracer_show - board tracer number
2405 * @cdev - pointer to embedded class device
2406 * @buf - the buffer returned
2407 *
2408 * A sysfs 'read-only' shost attribute.
2409 */
2410 static ssize_t
2411 _ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr,
2412 char *buf)
2413 {
2414 struct Scsi_Host *shost = class_to_shost(cdev);
2415 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2416
2417 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber);
2418 }
2419 static DEVICE_ATTR(board_tracer, S_IRUGO,
2420 _ctl_board_tracer_show, NULL);
2421
2422 /**
2423 * _ctl_io_delay_show - io missing delay
2424 * @cdev - pointer to embedded class device
2425 * @buf - the buffer returned
2426 *
2427 * This is for firmware implemention for deboucing device
2428 * removal events.
2429 *
2430 * A sysfs 'read-only' shost attribute.
2431 */
2432 static ssize_t
2433 _ctl_io_delay_show(struct device *cdev, struct device_attribute *attr,
2434 char *buf)
2435 {
2436 struct Scsi_Host *shost = class_to_shost(cdev);
2437 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2438
2439 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
2440 }
2441 static DEVICE_ATTR(io_delay, S_IRUGO,
2442 _ctl_io_delay_show, NULL);
2443
2444 /**
2445 * _ctl_device_delay_show - device missing delay
2446 * @cdev - pointer to embedded class device
2447 * @buf - the buffer returned
2448 *
2449 * This is for firmware implemention for deboucing device
2450 * removal events.
2451 *
2452 * A sysfs 'read-only' shost attribute.
2453 */
2454 static ssize_t
2455 _ctl_device_delay_show(struct device *cdev, struct device_attribute *attr,
2456 char *buf)
2457 {
2458 struct Scsi_Host *shost = class_to_shost(cdev);
2459 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2460
2461 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
2462 }
2463 static DEVICE_ATTR(device_delay, S_IRUGO,
2464 _ctl_device_delay_show, NULL);
2465
2466 /**
2467 * _ctl_fw_queue_depth_show - global credits
2468 * @cdev - pointer to embedded class device
2469 * @buf - the buffer returned
2470 *
2471 * This is firmware queue depth limit
2472 *
2473 * A sysfs 'read-only' shost attribute.
2474 */
2475 static ssize_t
2476 _ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr,
2477 char *buf)
2478 {
2479 struct Scsi_Host *shost = class_to_shost(cdev);
2480 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2481
2482 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit);
2483 }
2484 static DEVICE_ATTR(fw_queue_depth, S_IRUGO,
2485 _ctl_fw_queue_depth_show, NULL);
2486
2487 /**
2488 * _ctl_sas_address_show - sas address
2489 * @cdev - pointer to embedded class device
2490 * @buf - the buffer returned
2491 *
2492 * This is the controller sas address
2493 *
2494 * A sysfs 'read-only' shost attribute.
2495 */
2496 static ssize_t
2497 _ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr,
2498 char *buf)
2499 {
2500 struct Scsi_Host *shost = class_to_shost(cdev);
2501 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2502
2503 return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2504 (unsigned long long)ioc->sas_hba.sas_address);
2505 }
2506 static DEVICE_ATTR(host_sas_address, S_IRUGO,
2507 _ctl_host_sas_address_show, NULL);
2508
2509 /**
2510 * _ctl_logging_level_show - logging level
2511 * @cdev - pointer to embedded class device
2512 * @buf - the buffer returned
2513 *
2514 * A sysfs 'read/write' shost attribute.
2515 */
2516 static ssize_t
2517 _ctl_logging_level_show(struct device *cdev, struct device_attribute *attr,
2518 char *buf)
2519 {
2520 struct Scsi_Host *shost = class_to_shost(cdev);
2521 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2522
2523 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level);
2524 }
2525 static ssize_t
2526 _ctl_logging_level_store(struct device *cdev, struct device_attribute *attr,
2527 const char *buf, size_t count)
2528 {
2529 struct Scsi_Host *shost = class_to_shost(cdev);
2530 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2531 int val = 0;
2532
2533 if (sscanf(buf, "%x", &val) != 1)
2534 return -EINVAL;
2535
2536 ioc->logging_level = val;
2537 printk(MPT2SAS_INFO_FMT "logging_level=%08xh\n", ioc->name,
2538 ioc->logging_level);
2539 return strlen(buf);
2540 }
2541 static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR,
2542 _ctl_logging_level_show, _ctl_logging_level_store);
2543
2544 /* device attributes */
2545 /*
2546 * _ctl_fwfault_debug_show - show/store fwfault_debug
2547 * @cdev - pointer to embedded class device
2548 * @buf - the buffer returned
2549 *
2550 * mpt2sas_fwfault_debug is command line option
2551 * A sysfs 'read/write' shost attribute.
2552 */
2553 static ssize_t
2554 _ctl_fwfault_debug_show(struct device *cdev,
2555 struct device_attribute *attr, char *buf)
2556 {
2557 struct Scsi_Host *shost = class_to_shost(cdev);
2558 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2559
2560 return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug);
2561 }
2562 static ssize_t
2563 _ctl_fwfault_debug_store(struct device *cdev,
2564 struct device_attribute *attr, const char *buf, size_t count)
2565 {
2566 struct Scsi_Host *shost = class_to_shost(cdev);
2567 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2568 int val = 0;
2569
2570 if (sscanf(buf, "%d", &val) != 1)
2571 return -EINVAL;
2572
2573 ioc->fwfault_debug = val;
2574 printk(MPT2SAS_INFO_FMT "fwfault_debug=%d\n", ioc->name,
2575 ioc->fwfault_debug);
2576 return strlen(buf);
2577 }
2578 static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR,
2579 _ctl_fwfault_debug_show, _ctl_fwfault_debug_store);
2580
2581 struct device_attribute *mpt2sas_host_attrs[] = {
2582 &dev_attr_version_fw,
2583 &dev_attr_version_bios,
2584 &dev_attr_version_mpi,
2585 &dev_attr_version_product,
2586 &dev_attr_version_nvdata_persistent,
2587 &dev_attr_version_nvdata_default,
2588 &dev_attr_board_name,
2589 &dev_attr_board_assembly,
2590 &dev_attr_board_tracer,
2591 &dev_attr_io_delay,
2592 &dev_attr_device_delay,
2593 &dev_attr_logging_level,
2594 &dev_attr_fwfault_debug,
2595 &dev_attr_fw_queue_depth,
2596 &dev_attr_host_sas_address,
2597 NULL,
2598 };
2599
2600 /**
2601 * _ctl_device_sas_address_show - sas address
2602 * @cdev - pointer to embedded class device
2603 * @buf - the buffer returned
2604 *
2605 * This is the sas address for the target
2606 *
2607 * A sysfs 'read-only' shost attribute.
2608 */
2609 static ssize_t
2610 _ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr,
2611 char *buf)
2612 {
2613 struct scsi_device *sdev = to_scsi_device(dev);
2614 struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
2615
2616 return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2617 (unsigned long long)sas_device_priv_data->sas_target->sas_address);
2618 }
2619 static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL);
2620
2621 /**
2622 * _ctl_device_handle_show - device handle
2623 * @cdev - pointer to embedded class device
2624 * @buf - the buffer returned
2625 *
2626 * This is the firmware assigned device handle
2627 *
2628 * A sysfs 'read-only' shost attribute.
2629 */
2630 static ssize_t
2631 _ctl_device_handle_show(struct device *dev, struct device_attribute *attr,
2632 char *buf)
2633 {
2634 struct scsi_device *sdev = to_scsi_device(dev);
2635 struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
2636
2637 return snprintf(buf, PAGE_SIZE, "0x%04x\n",
2638 sas_device_priv_data->sas_target->handle);
2639 }
2640 static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL);
2641
2642 struct device_attribute *mpt2sas_dev_attrs[] = {
2643 &dev_attr_sas_address,
2644 &dev_attr_sas_device_handle,
2645 NULL,
2646 };
2647
2648 static const struct file_operations ctl_fops = {
2649 .owner = THIS_MODULE,
2650 .unlocked_ioctl = _ctl_ioctl,
2651 .release = _ctl_release,
2652 .poll = _ctl_poll,
2653 .fasync = _ctl_fasync,
2654 #ifdef CONFIG_COMPAT
2655 .compat_ioctl = _ctl_ioctl_compat,
2656 #endif
2657 };
2658
2659 static struct miscdevice ctl_dev = {
2660 .minor = MPT2SAS_MINOR,
2661 .name = MPT2SAS_DEV_NAME,
2662 .fops = &ctl_fops,
2663 };
2664
2665 /**
2666 * mpt2sas_ctl_init - main entry point for ctl.
2667 *
2668 */
2669 void
2670 mpt2sas_ctl_init(void)
2671 {
2672 async_queue = NULL;
2673 if (misc_register(&ctl_dev) < 0)
2674 printk(KERN_ERR "%s can't register misc device [minor=%d]\n",
2675 MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR);
2676
2677 init_waitqueue_head(&ctl_poll_wait);
2678 }
2679
2680 /**
2681 * mpt2sas_ctl_exit - exit point for ctl
2682 *
2683 */
2684 void
2685 mpt2sas_ctl_exit(void)
2686 {
2687 struct MPT2SAS_ADAPTER *ioc;
2688 int i;
2689
2690 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
2691
2692 /* free memory associated to diag buffers */
2693 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
2694 if (!ioc->diag_buffer[i])
2695 continue;
2696 pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
2697 ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
2698 ioc->diag_buffer[i] = NULL;
2699 ioc->diag_buffer_status[i] = 0;
2700 }
2701
2702 kfree(ioc->event_log);
2703 }
2704 misc_deregister(&ctl_dev);
2705 }
2706
kernel source for telekom puls (alcatel/mediatek)