?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mtd/maps: gpio-addr-flash: new driver for GPIO assisted flash addressing
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / mpt2sas / mpt2sas_ctl.c
blob14e473d1fa7b18193e0673d86dec3bfc8737aa84
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-2008 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 * @VF_ID: virtual function id
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 nothing.
229 */
230 void
231 mpt2sas_ctl_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 VF_ID, u32 reply)
232 {
233 MPI2DefaultReply_t *mpi_reply;
234
235 if (ioc->ctl_cmds.status == MPT2_CMD_NOT_USED)
236 return;
237 if (ioc->ctl_cmds.smid != smid)
238 return;
239 ioc->ctl_cmds.status |= MPT2_CMD_COMPLETE;
240 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
241 if (mpi_reply) {
242 memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
243 ioc->ctl_cmds.status |= MPT2_CMD_REPLY_VALID;
244 }
245 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
246 _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply);
247 #endif
248 ioc->ctl_cmds.status &= ~MPT2_CMD_PENDING;
249 complete(&ioc->ctl_cmds.done);
250 }
251
252 /**
253 * _ctl_check_event_type - determines when an event needs logging
254 * @ioc: per adapter object
255 * @event: firmware event
256 *
257 * The bitmask in ioc->event_type[] indicates which events should be
258 * be saved in the driver event_log. This bitmask is set by application.
259 *
260 * Returns 1 when event should be captured, or zero means no match.
261 */
262 static int
263 _ctl_check_event_type(struct MPT2SAS_ADAPTER *ioc, u16 event)
264 {
265 u16 i;
266 u32 desired_event;
267
268 if (event >= 128 || !event || !ioc->event_log)
269 return 0;
270
271 desired_event = (1 << (event % 32));
272 if (!desired_event)
273 desired_event = 1;
274 i = event / 32;
275 return desired_event & ioc->event_type[i];
276 }
277
278 /**
279 * mpt2sas_ctl_add_to_event_log - add event
280 * @ioc: per adapter object
281 * @mpi_reply: reply message frame
282 *
283 * Return nothing.
284 */
285 void
286 mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER *ioc,
287 Mpi2EventNotificationReply_t *mpi_reply)
288 {
289 struct MPT2_IOCTL_EVENTS *event_log;
290 u16 event;
291 int i;
292 u32 sz, event_data_sz;
293 u8 send_aen = 0;
294
295 if (!ioc->event_log)
296 return;
297
298 event = le16_to_cpu(mpi_reply->Event);
299
300 if (_ctl_check_event_type(ioc, event)) {
301
302 /* insert entry into circular event_log */
303 i = ioc->event_context % MPT2SAS_CTL_EVENT_LOG_SIZE;
304 event_log = ioc->event_log;
305 event_log[i].event = event;
306 event_log[i].context = ioc->event_context++;
307
308 event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4;
309 sz = min_t(u32, event_data_sz, MPT2_EVENT_DATA_SIZE);
310 memset(event_log[i].data, 0, MPT2_EVENT_DATA_SIZE);
311 memcpy(event_log[i].data, mpi_reply->EventData, sz);
312 send_aen = 1;
313 }
314
315 /* This aen_event_read_flag flag is set until the
316 * application has read the event log.
317 * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
318 */
319 if (event == MPI2_EVENT_LOG_ENTRY_ADDED ||
320 (send_aen && !ioc->aen_event_read_flag)) {
321 ioc->aen_event_read_flag = 1;
322 wake_up_interruptible(&ctl_poll_wait);
323 if (async_queue)
324 kill_fasync(&async_queue, SIGIO, POLL_IN);
325 }
326 }
327
328 /**
329 * mpt2sas_ctl_event_callback - firmware event handler (called at ISR time)
330 * @ioc: per adapter object
331 * @VF_ID: virtual function id
332 * @reply: reply message frame(lower 32bit addr)
333 * Context: interrupt.
334 *
335 * This function merely adds a new work task into ioc->firmware_event_thread.
336 * The tasks are worked from _firmware_event_work in user context.
337 *
338 * Return nothing.
339 */
340 void
341 mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, u32 reply)
342 {
343 Mpi2EventNotificationReply_t *mpi_reply;
344
345 mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
346 mpt2sas_ctl_add_to_event_log(ioc, mpi_reply);
347 }
348
349 /**
350 * _ctl_verify_adapter - validates ioc_number passed from application
351 * @ioc: per adapter object
352 * @iocpp: The ioc pointer is returned in this.
353 *
354 * Return (-1) means error, else ioc_number.
355 */
356 static int
357 _ctl_verify_adapter(int ioc_number, struct MPT2SAS_ADAPTER **iocpp)
358 {
359 struct MPT2SAS_ADAPTER *ioc;
360
361 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
362 if (ioc->id != ioc_number)
363 continue;
364 *iocpp = ioc;
365 return ioc_number;
366 }
367 *iocpp = NULL;
368 return -1;
369 }
370
371 /**
372 * mpt2sas_ctl_reset_handler - reset callback handler (for ctl)
373 * @ioc: per adapter object
374 * @reset_phase: phase
375 *
376 * The handler for doing any required cleanup or initialization.
377 *
378 * The reset phase can be MPT2_IOC_PRE_RESET, MPT2_IOC_AFTER_RESET,
379 * MPT2_IOC_DONE_RESET
380 */
381 void
382 mpt2sas_ctl_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
383 {
384 int i;
385 u8 issue_reset;
386
387 switch (reset_phase) {
388 case MPT2_IOC_PRE_RESET:
389 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
390 "MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
391 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
392 if (!(ioc->diag_buffer_status[i] &
393 MPT2_DIAG_BUFFER_IS_REGISTERED))
394 continue;
395 if ((ioc->diag_buffer_status[i] &
396 MPT2_DIAG_BUFFER_IS_RELEASED))
397 continue;
398 _ctl_send_release(ioc, i, &issue_reset);
399 }
400 break;
401 case MPT2_IOC_AFTER_RESET:
402 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
403 "MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
404 if (ioc->ctl_cmds.status & MPT2_CMD_PENDING) {
405 ioc->ctl_cmds.status |= MPT2_CMD_RESET;
406 mpt2sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
407 complete(&ioc->ctl_cmds.done);
408 }
409 break;
410 case MPT2_IOC_DONE_RESET:
411 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
412 "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
413
414 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
415 if (!(ioc->diag_buffer_status[i] &
416 MPT2_DIAG_BUFFER_IS_REGISTERED))
417 continue;
418 if ((ioc->diag_buffer_status[i] &
419 MPT2_DIAG_BUFFER_IS_RELEASED))
420 continue;
421 ioc->diag_buffer_status[i] |=
422 MPT2_DIAG_BUFFER_IS_DIAG_RESET;
423 }
424 break;
425 }
426 }
427
428 /**
429 * _ctl_fasync -
430 * @fd -
431 * @filep -
432 * @mode -
433 *
434 * Called when application request fasyn callback handler.
435 */
436 static int
437 _ctl_fasync(int fd, struct file *filep, int mode)
438 {
439 return fasync_helper(fd, filep, mode, &async_queue);
440 }
441
442 /**
443 * _ctl_release -
444 * @inode -
445 * @filep -
446 *
447 * Called when application releases the fasyn callback handler.
448 */
449 static int
450 _ctl_release(struct inode *inode, struct file *filep)
451 {
452 return fasync_helper(-1, filep, 0, &async_queue);
453 }
454
455 /**
456 * _ctl_poll -
457 * @file -
458 * @wait -
459 *
460 */
461 static unsigned int
462 _ctl_poll(struct file *filep, poll_table *wait)
463 {
464 struct MPT2SAS_ADAPTER *ioc;
465
466 poll_wait(filep, &ctl_poll_wait, wait);
467
468 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
469 if (ioc->aen_event_read_flag)
470 return POLLIN | POLLRDNORM;
471 }
472 return 0;
473 }
474
475 /**
476 * _ctl_set_task_mid - assign an active smid to tm request
477 * @ioc: per adapter object
478 * @karg - (struct mpt2_ioctl_command)
479 * @tm_request - pointer to mf from user space
480 *
481 * Returns 0 when an smid if found, else fail.
482 * during failure, the reply frame is filled.
483 */
484 static int
485 _ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg,
486 Mpi2SCSITaskManagementRequest_t *tm_request)
487 {
488 u8 found = 0;
489 u16 i;
490 u16 handle;
491 struct scsi_cmnd *scmd;
492 struct MPT2SAS_DEVICE *priv_data;
493 unsigned long flags;
494 Mpi2SCSITaskManagementReply_t *tm_reply;
495 u32 sz;
496 u32 lun;
497 char *desc = NULL;
498
499 if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
500 desc = "abort_task";
501 else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK)
502 desc = "query_task";
503 else
504 return 0;
505
506 lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN);
507
508 handle = le16_to_cpu(tm_request->DevHandle);
509 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
510 for (i = ioc->request_depth; i && !found; i--) {
511 scmd = ioc->scsi_lookup[i - 1].scmd;
512 if (scmd == NULL || scmd->device == NULL ||
513 scmd->device->hostdata == NULL)
514 continue;
515 if (lun != scmd->device->lun)
516 continue;
517 priv_data = scmd->device->hostdata;
518 if (priv_data->sas_target == NULL)
519 continue;
520 if (priv_data->sas_target->handle != handle)
521 continue;
522 tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid);
523 found = 1;
524 }
525 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
526
527 if (!found) {
528 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
529 "handle(0x%04x), lun(%d), no active mid!!\n", ioc->name,
530 desc, tm_request->DevHandle, lun));
531 tm_reply = ioc->ctl_cmds.reply;
532 tm_reply->DevHandle = tm_request->DevHandle;
533 tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
534 tm_reply->TaskType = tm_request->TaskType;
535 tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4;
536 tm_reply->VP_ID = tm_request->VP_ID;
537 tm_reply->VF_ID = tm_request->VF_ID;
538 sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz);
539 if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply,
540 sz))
541 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
542 __LINE__, __func__);
543 return 1;
544 }
545
546 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
547 "handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name,
548 desc, tm_request->DevHandle, lun, tm_request->TaskMID));
549 return 0;
550 }
551
552 /**
553 * _ctl_do_mpt_command - main handler for MPT2COMMAND opcode
554 * @ioc: per adapter object
555 * @karg - (struct mpt2_ioctl_command)
556 * @mf - pointer to mf in user space
557 * @state - NON_BLOCKING or BLOCKING
558 */
559 static long
560 _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
561 struct mpt2_ioctl_command karg, void __user *mf, enum block_state state)
562 {
563 MPI2RequestHeader_t *mpi_request;
564 MPI2DefaultReply_t *mpi_reply;
565 u32 ioc_state;
566 u16 ioc_status;
567 u16 smid;
568 unsigned long timeout, timeleft;
569 u8 issue_reset;
570 u32 sz;
571 void *psge;
572 void *priv_sense = NULL;
573 void *data_out = NULL;
574 dma_addr_t data_out_dma;
575 size_t data_out_sz = 0;
576 void *data_in = NULL;
577 dma_addr_t data_in_dma;
578 size_t data_in_sz = 0;
579 u32 sgl_flags;
580 long ret;
581 u16 wait_state_count;
582
583 issue_reset = 0;
584
585 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
586 return -EAGAIN;
587 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
588 return -ERESTARTSYS;
589
590 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
591 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
592 ioc->name, __func__);
593 ret = -EAGAIN;
594 goto out;
595 }
596
597 wait_state_count = 0;
598 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
599 while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
600 if (wait_state_count++ == 10) {
601 printk(MPT2SAS_ERR_FMT
602 "%s: failed due to ioc not operational\n",
603 ioc->name, __func__);
604 ret = -EFAULT;
605 goto out;
606 }
607 ssleep(1);
608 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
609 printk(MPT2SAS_INFO_FMT "%s: waiting for "
610 "operational state(count=%d)\n", ioc->name,
611 __func__, wait_state_count);
612 }
613 if (wait_state_count)
614 printk(MPT2SAS_INFO_FMT "%s: ioc is operational\n",
615 ioc->name, __func__);
616
617 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
618 if (!smid) {
619 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
620 ioc->name, __func__);
621 ret = -EAGAIN;
622 goto out;
623 }
624
625 ret = 0;
626 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
627 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
628 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
629 ioc->ctl_cmds.smid = smid;
630 data_out_sz = karg.data_out_size;
631 data_in_sz = karg.data_in_size;
632
633 /* copy in request message frame from user */
634 if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) {
635 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, __LINE__,
636 __func__);
637 ret = -EFAULT;
638 mpt2sas_base_free_smid(ioc, smid);
639 goto out;
640 }
641
642 if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
643 mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
644 if (!mpi_request->FunctionDependent1 ||
645 mpi_request->FunctionDependent1 >
646 cpu_to_le16(ioc->facts.MaxDevHandle)) {
647 ret = -EINVAL;
648 mpt2sas_base_free_smid(ioc, smid);
649 goto out;
650 }
651 }
652
653 /* obtain dma-able memory for data transfer */
654 if (data_out_sz) /* WRITE */ {
655 data_out = pci_alloc_consistent(ioc->pdev, data_out_sz,
656 &data_out_dma);
657 if (!data_out) {
658 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
659 __LINE__, __func__);
660 ret = -ENOMEM;
661 mpt2sas_base_free_smid(ioc, smid);
662 goto out;
663 }
664 if (copy_from_user(data_out, karg.data_out_buf_ptr,
665 data_out_sz)) {
666 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
667 __LINE__, __func__);
668 ret = -EFAULT;
669 mpt2sas_base_free_smid(ioc, smid);
670 goto out;
671 }
672 }
673
674 if (data_in_sz) /* READ */ {
675 data_in = pci_alloc_consistent(ioc->pdev, data_in_sz,
676 &data_in_dma);
677 if (!data_in) {
678 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
679 __LINE__, __func__);
680 ret = -ENOMEM;
681 mpt2sas_base_free_smid(ioc, smid);
682 goto out;
683 }
684 }
685
686 /* add scatter gather elements */
687 psge = (void *)mpi_request + (karg.data_sge_offset*4);
688
689 if (!data_out_sz && !data_in_sz) {
690 mpt2sas_base_build_zero_len_sge(ioc, psge);
691 } else if (data_out_sz && data_in_sz) {
692 /* WRITE sgel first */
693 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
694 MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
695 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
696 ioc->base_add_sg_single(psge, sgl_flags |
697 data_out_sz, data_out_dma);
698
699 /* incr sgel */
700 psge += ioc->sge_size;
701
702 /* READ sgel last */
703 sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
704 MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
705 MPI2_SGE_FLAGS_END_OF_LIST);
706 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
707 ioc->base_add_sg_single(psge, sgl_flags |
708 data_in_sz, data_in_dma);
709 } else if (data_out_sz) /* WRITE */ {
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 | MPI2_SGE_FLAGS_HOST_TO_IOC);
713 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
714 ioc->base_add_sg_single(psge, sgl_flags |
715 data_out_sz, data_out_dma);
716 } else if (data_in_sz) /* READ */ {
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);
720 sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
721 ioc->base_add_sg_single(psge, sgl_flags |
722 data_in_sz, data_in_dma);
723 }
724
725 /* send command to firmware */
726 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
727 _ctl_display_some_debug(ioc, smid, "ctl_request", NULL);
728 #endif
729
730 switch (mpi_request->Function) {
731 case MPI2_FUNCTION_SCSI_IO_REQUEST:
732 case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
733 {
734 Mpi2SCSIIORequest_t *scsiio_request =
735 (Mpi2SCSIIORequest_t *)mpi_request;
736 scsiio_request->SenseBufferLowAddress =
737 (u32)mpt2sas_base_get_sense_buffer_dma(ioc, smid);
738 priv_sense = mpt2sas_base_get_sense_buffer(ioc, smid);
739 memset(priv_sense, 0, SCSI_SENSE_BUFFERSIZE);
740 mpt2sas_base_put_smid_scsi_io(ioc, smid, 0,
741 le16_to_cpu(mpi_request->FunctionDependent1));
742 break;
743 }
744 case MPI2_FUNCTION_SCSI_TASK_MGMT:
745 {
746 Mpi2SCSITaskManagementRequest_t *tm_request =
747 (Mpi2SCSITaskManagementRequest_t *)mpi_request;
748
749 if (tm_request->TaskType ==
750 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
751 tm_request->TaskType ==
752 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
753 if (_ctl_set_task_mid(ioc, &karg, tm_request)) {
754 mpt2sas_base_free_smid(ioc, smid);
755 goto out;
756 }
757 }
758
759 mutex_lock(&ioc->tm_cmds.mutex);
760 mpt2sas_scsih_set_tm_flag(ioc, le16_to_cpu(
761 tm_request->DevHandle));
762 mpt2sas_base_put_smid_hi_priority(ioc, smid,
763 mpi_request->VF_ID);
764 break;
765 }
766 case MPI2_FUNCTION_SMP_PASSTHROUGH:
767 {
768 Mpi2SmpPassthroughRequest_t *smp_request =
769 (Mpi2SmpPassthroughRequest_t *)mpi_request;
770 u8 *data;
771
772 /* ioc determines which port to use */
773 smp_request->PhysicalPort = 0xFF;
774 if (smp_request->PassthroughFlags &
775 MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
776 data = (u8 *)&smp_request->SGL;
777 else
778 data = data_out;
779
780 if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
781 ioc->ioc_link_reset_in_progress = 1;
782 ioc->ignore_loginfos = 1;
783 }
784 mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
785 break;
786 }
787 case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
788 {
789 Mpi2SasIoUnitControlRequest_t *sasiounit_request =
790 (Mpi2SasIoUnitControlRequest_t *)mpi_request;
791
792 if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET
793 || sasiounit_request->Operation ==
794 MPI2_SAS_OP_PHY_LINK_RESET) {
795 ioc->ioc_link_reset_in_progress = 1;
796 ioc->ignore_loginfos = 1;
797 }
798 mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
799 break;
800 }
801 default:
802 mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
803 break;
804 }
805
806 if (karg.timeout < MPT2_IOCTL_DEFAULT_TIMEOUT)
807 timeout = MPT2_IOCTL_DEFAULT_TIMEOUT;
808 else
809 timeout = karg.timeout;
810 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
811 timeout*HZ);
812 if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
813 Mpi2SCSITaskManagementRequest_t *tm_request =
814 (Mpi2SCSITaskManagementRequest_t *)mpi_request;
815 mutex_unlock(&ioc->tm_cmds.mutex);
816 mpt2sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
817 tm_request->DevHandle));
818 } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH ||
819 mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) &&
820 ioc->ioc_link_reset_in_progress) {
821 ioc->ioc_link_reset_in_progress = 0;
822 ioc->ignore_loginfos = 0;
823 }
824 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
825 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
826 __func__);
827 _debug_dump_mf(mpi_request, karg.data_sge_offset);
828 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
829 issue_reset = 1;
830 goto issue_host_reset;
831 }
832
833 mpi_reply = ioc->ctl_cmds.reply;
834 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
835
836 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
837 if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT &&
838 (ioc->logging_level & MPT_DEBUG_TM)) {
839 Mpi2SCSITaskManagementReply_t *tm_reply =
840 (Mpi2SCSITaskManagementReply_t *)mpi_reply;
841
842 printk(MPT2SAS_DEBUG_FMT "TASK_MGMT: "
843 "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
844 "TerminationCount(0x%08x)\n", ioc->name,
845 tm_reply->IOCStatus, tm_reply->IOCLogInfo,
846 tm_reply->TerminationCount);
847 }
848 #endif
849 /* copy out xdata to user */
850 if (data_in_sz) {
851 if (copy_to_user(karg.data_in_buf_ptr, data_in,
852 data_in_sz)) {
853 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
854 __LINE__, __func__);
855 ret = -ENODATA;
856 goto out;
857 }
858 }
859
860 /* copy out reply message frame to user */
861 if (karg.max_reply_bytes) {
862 sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
863 if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply,
864 sz)) {
865 printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
866 __LINE__, __func__);
867 ret = -ENODATA;
868 goto out;
869 }
870 }
871
872 /* copy out sense to user */
873 if (karg.max_sense_bytes && (mpi_request->Function ==
874 MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
875 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
876 sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE);
877 if (copy_to_user(karg.sense_data_ptr, priv_sense, 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 issue_host_reset:
886 if (issue_reset) {
887 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
888 mpi_request->Function ==
889 MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
890 printk(MPT2SAS_INFO_FMT "issue target reset: handle "
891 "= (0x%04x)\n", ioc->name,
892 mpi_request->FunctionDependent1);
893 mutex_lock(&ioc->tm_cmds.mutex);
894 mpt2sas_scsih_issue_tm(ioc,
895 mpi_request->FunctionDependent1, 0,
896 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 10);
897 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
898 mutex_unlock(&ioc->tm_cmds.mutex);
899 } else
900 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
901 FORCE_BIG_HAMMER);
902 }
903
904 out:
905
906 /* free memory associated with sg buffers */
907 if (data_in)
908 pci_free_consistent(ioc->pdev, data_in_sz, data_in,
909 data_in_dma);
910
911 if (data_out)
912 pci_free_consistent(ioc->pdev, data_out_sz, data_out,
913 data_out_dma);
914
915 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
916 mutex_unlock(&ioc->ctl_cmds.mutex);
917 return ret;
918 }
919
920 /**
921 * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
922 * @arg - user space buffer containing ioctl content
923 */
924 static long
925 _ctl_getiocinfo(void __user *arg)
926 {
927 struct mpt2_ioctl_iocinfo karg;
928 struct MPT2SAS_ADAPTER *ioc;
929 u8 revision;
930
931 if (copy_from_user(&karg, arg, sizeof(karg))) {
932 printk(KERN_ERR "failure at %s:%d/%s()!\n",
933 __FILE__, __LINE__, __func__);
934 return -EFAULT;
935 }
936 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
937 return -ENODEV;
938
939 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
940 __func__));
941
942 memset(&karg, 0 , sizeof(karg));
943 karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
944 if (ioc->pfacts)
945 karg.port_number = ioc->pfacts[0].PortNumber;
946 pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision);
947 karg.hw_rev = revision;
948 karg.pci_id = ioc->pdev->device;
949 karg.subsystem_device = ioc->pdev->subsystem_device;
950 karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
951 karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
952 karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
953 karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
954 karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus);
955 karg.firmware_version = ioc->facts.FWVersion.Word;
956 strcpy(karg.driver_version, MPT2SAS_DRIVER_NAME);
957 strcat(karg.driver_version, "-");
958 strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION);
959 karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
960
961 if (copy_to_user(arg, &karg, sizeof(karg))) {
962 printk(KERN_ERR "failure at %s:%d/%s()!\n",
963 __FILE__, __LINE__, __func__);
964 return -EFAULT;
965 }
966 return 0;
967 }
968
969 /**
970 * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
971 * @arg - user space buffer containing ioctl content
972 */
973 static long
974 _ctl_eventquery(void __user *arg)
975 {
976 struct mpt2_ioctl_eventquery karg;
977 struct MPT2SAS_ADAPTER *ioc;
978
979 if (copy_from_user(&karg, arg, sizeof(karg))) {
980 printk(KERN_ERR "failure at %s:%d/%s()!\n",
981 __FILE__, __LINE__, __func__);
982 return -EFAULT;
983 }
984 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
985 return -ENODEV;
986
987 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
988 __func__));
989
990 karg.event_entries = MPT2SAS_CTL_EVENT_LOG_SIZE;
991 memcpy(karg.event_types, ioc->event_type,
992 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
993
994 if (copy_to_user(arg, &karg, sizeof(karg))) {
995 printk(KERN_ERR "failure at %s:%d/%s()!\n",
996 __FILE__, __LINE__, __func__);
997 return -EFAULT;
998 }
999 return 0;
1000 }
1001
1002 /**
1003 * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
1004 * @arg - user space buffer containing ioctl content
1005 */
1006 static long
1007 _ctl_eventenable(void __user *arg)
1008 {
1009 struct mpt2_ioctl_eventenable karg;
1010 struct MPT2SAS_ADAPTER *ioc;
1011
1012 if (copy_from_user(&karg, arg, sizeof(karg))) {
1013 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1014 __FILE__, __LINE__, __func__);
1015 return -EFAULT;
1016 }
1017 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1018 return -ENODEV;
1019
1020 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
1021 __func__));
1022
1023 if (ioc->event_log)
1024 return 0;
1025 memcpy(ioc->event_type, karg.event_types,
1026 MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
1027 mpt2sas_base_validate_event_type(ioc, ioc->event_type);
1028
1029 /* initialize event_log */
1030 ioc->event_context = 0;
1031 ioc->aen_event_read_flag = 0;
1032 ioc->event_log = kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE,
1033 sizeof(struct MPT2_IOCTL_EVENTS), GFP_KERNEL);
1034 if (!ioc->event_log) {
1035 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1036 __FILE__, __LINE__, __func__);
1037 return -ENOMEM;
1038 }
1039 return 0;
1040 }
1041
1042 /**
1043 * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
1044 * @arg - user space buffer containing ioctl content
1045 */
1046 static long
1047 _ctl_eventreport(void __user *arg)
1048 {
1049 struct mpt2_ioctl_eventreport karg;
1050 struct MPT2SAS_ADAPTER *ioc;
1051 u32 number_bytes, max_events, max;
1052 struct mpt2_ioctl_eventreport __user *uarg = arg;
1053
1054 if (copy_from_user(&karg, arg, sizeof(karg))) {
1055 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1056 __FILE__, __LINE__, __func__);
1057 return -EFAULT;
1058 }
1059 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1060 return -ENODEV;
1061
1062 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
1063 __func__));
1064
1065 number_bytes = karg.hdr.max_data_size -
1066 sizeof(struct mpt2_ioctl_header);
1067 max_events = number_bytes/sizeof(struct MPT2_IOCTL_EVENTS);
1068 max = min_t(u32, MPT2SAS_CTL_EVENT_LOG_SIZE, max_events);
1069
1070 /* If fewer than 1 event is requested, there must have
1071 * been some type of error.
1072 */
1073 if (!max || !ioc->event_log)
1074 return -ENODATA;
1075
1076 number_bytes = max * sizeof(struct MPT2_IOCTL_EVENTS);
1077 if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) {
1078 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1079 __FILE__, __LINE__, __func__);
1080 return -EFAULT;
1081 }
1082
1083 /* reset flag so SIGIO can restart */
1084 ioc->aen_event_read_flag = 0;
1085 return 0;
1086 }
1087
1088 /**
1089 * _ctl_do_reset - main handler for MPT2HARDRESET opcode
1090 * @arg - user space buffer containing ioctl content
1091 */
1092 static long
1093 _ctl_do_reset(void __user *arg)
1094 {
1095 struct mpt2_ioctl_diag_reset karg;
1096 struct MPT2SAS_ADAPTER *ioc;
1097 int retval;
1098
1099 if (copy_from_user(&karg, arg, sizeof(karg))) {
1100 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1101 __FILE__, __LINE__, __func__);
1102 return -EFAULT;
1103 }
1104 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1105 return -ENODEV;
1106
1107 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
1108 __func__));
1109
1110 retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1111 FORCE_BIG_HAMMER);
1112 printk(MPT2SAS_INFO_FMT "host reset: %s\n",
1113 ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
1114 return 0;
1115 }
1116
1117 /**
1118 * _ctl_btdh_search_sas_device - searching for sas device
1119 * @ioc: per adapter object
1120 * @btdh: btdh ioctl payload
1121 */
1122 static int
1123 _ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER *ioc,
1124 struct mpt2_ioctl_btdh_mapping *btdh)
1125 {
1126 struct _sas_device *sas_device;
1127 unsigned long flags;
1128 int rc = 0;
1129
1130 if (list_empty(&ioc->sas_device_list))
1131 return rc;
1132
1133 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1134 list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
1135 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1136 btdh->handle == sas_device->handle) {
1137 btdh->bus = sas_device->channel;
1138 btdh->id = sas_device->id;
1139 rc = 1;
1140 goto out;
1141 } else if (btdh->bus == sas_device->channel && btdh->id ==
1142 sas_device->id && btdh->handle == 0xFFFF) {
1143 btdh->handle = sas_device->handle;
1144 rc = 1;
1145 goto out;
1146 }
1147 }
1148 out:
1149 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1150 return rc;
1151 }
1152
1153 /**
1154 * _ctl_btdh_search_raid_device - searching for raid device
1155 * @ioc: per adapter object
1156 * @btdh: btdh ioctl payload
1157 */
1158 static int
1159 _ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
1160 struct mpt2_ioctl_btdh_mapping *btdh)
1161 {
1162 struct _raid_device *raid_device;
1163 unsigned long flags;
1164 int rc = 0;
1165
1166 if (list_empty(&ioc->raid_device_list))
1167 return rc;
1168
1169 spin_lock_irqsave(&ioc->raid_device_lock, flags);
1170 list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
1171 if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
1172 btdh->handle == raid_device->handle) {
1173 btdh->bus = raid_device->channel;
1174 btdh->id = raid_device->id;
1175 rc = 1;
1176 goto out;
1177 } else if (btdh->bus == raid_device->channel && btdh->id ==
1178 raid_device->id && btdh->handle == 0xFFFF) {
1179 btdh->handle = raid_device->handle;
1180 rc = 1;
1181 goto out;
1182 }
1183 }
1184 out:
1185 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
1186 return rc;
1187 }
1188
1189 /**
1190 * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
1191 * @arg - user space buffer containing ioctl content
1192 */
1193 static long
1194 _ctl_btdh_mapping(void __user *arg)
1195 {
1196 struct mpt2_ioctl_btdh_mapping karg;
1197 struct MPT2SAS_ADAPTER *ioc;
1198 int rc;
1199
1200 if (copy_from_user(&karg, arg, sizeof(karg))) {
1201 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1202 __FILE__, __LINE__, __func__);
1203 return -EFAULT;
1204 }
1205 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1206 return -ENODEV;
1207
1208 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1209 __func__));
1210
1211 rc = _ctl_btdh_search_sas_device(ioc, &karg);
1212 if (!rc)
1213 _ctl_btdh_search_raid_device(ioc, &karg);
1214
1215 if (copy_to_user(arg, &karg, sizeof(karg))) {
1216 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1217 __FILE__, __LINE__, __func__);
1218 return -EFAULT;
1219 }
1220 return 0;
1221 }
1222
1223 /**
1224 * _ctl_diag_capability - return diag buffer capability
1225 * @ioc: per adapter object
1226 * @buffer_type: specifies either TRACE or SNAPSHOT
1227 *
1228 * returns 1 when diag buffer support is enabled in firmware
1229 */
1230 static u8
1231 _ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type)
1232 {
1233 u8 rc = 0;
1234
1235 switch (buffer_type) {
1236 case MPI2_DIAG_BUF_TYPE_TRACE:
1237 if (ioc->facts.IOCCapabilities &
1238 MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER)
1239 rc = 1;
1240 break;
1241 case MPI2_DIAG_BUF_TYPE_SNAPSHOT:
1242 if (ioc->facts.IOCCapabilities &
1243 MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
1244 rc = 1;
1245 break;
1246 }
1247
1248 return rc;
1249 }
1250
1251 /**
1252 * _ctl_diag_register - application register with driver
1253 * @arg - user space buffer containing ioctl content
1254 * @state - NON_BLOCKING or BLOCKING
1255 *
1256 * This will allow the driver to setup any required buffers that will be
1257 * needed by firmware to communicate with the driver.
1258 */
1259 static long
1260 _ctl_diag_register(void __user *arg, enum block_state state)
1261 {
1262 struct mpt2_diag_register karg;
1263 struct MPT2SAS_ADAPTER *ioc;
1264 int rc, i;
1265 void *request_data = NULL;
1266 dma_addr_t request_data_dma;
1267 u32 request_data_sz = 0;
1268 Mpi2DiagBufferPostRequest_t *mpi_request;
1269 Mpi2DiagBufferPostReply_t *mpi_reply;
1270 u8 buffer_type;
1271 unsigned long timeleft;
1272 u16 smid;
1273 u16 ioc_status;
1274 u8 issue_reset = 0;
1275
1276 if (copy_from_user(&karg, arg, sizeof(karg))) {
1277 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1278 __FILE__, __LINE__, __func__);
1279 return -EFAULT;
1280 }
1281 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1282 return -ENODEV;
1283
1284 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1285 __func__));
1286
1287 buffer_type = karg.buffer_type;
1288 if (!_ctl_diag_capability(ioc, buffer_type)) {
1289 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1290 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1291 return -EPERM;
1292 }
1293
1294 if (ioc->diag_buffer_status[buffer_type] &
1295 MPT2_DIAG_BUFFER_IS_REGISTERED) {
1296 printk(MPT2SAS_ERR_FMT "%s: already has a registered "
1297 "buffer for buffer_type(0x%02x)\n", ioc->name, __func__,
1298 buffer_type);
1299 return -EINVAL;
1300 }
1301
1302 if (karg.requested_buffer_size % 4) {
1303 printk(MPT2SAS_ERR_FMT "%s: the requested_buffer_size "
1304 "is not 4 byte aligned\n", ioc->name, __func__);
1305 return -EINVAL;
1306 }
1307
1308 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1309 return -EAGAIN;
1310 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1311 return -ERESTARTSYS;
1312
1313 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1314 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1315 ioc->name, __func__);
1316 rc = -EAGAIN;
1317 goto out;
1318 }
1319
1320 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1321 if (!smid) {
1322 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1323 ioc->name, __func__);
1324 rc = -EAGAIN;
1325 goto out;
1326 }
1327
1328 rc = 0;
1329 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1330 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1331 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1332 ioc->ctl_cmds.smid = smid;
1333
1334 request_data = ioc->diag_buffer[buffer_type];
1335 request_data_sz = karg.requested_buffer_size;
1336 ioc->unique_id[buffer_type] = karg.unique_id;
1337 ioc->diag_buffer_status[buffer_type] = 0;
1338 memcpy(ioc->product_specific[buffer_type], karg.product_specific,
1339 MPT2_PRODUCT_SPECIFIC_DWORDS);
1340 ioc->diagnostic_flags[buffer_type] = karg.diagnostic_flags;
1341
1342 if (request_data) {
1343 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1344 if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
1345 pci_free_consistent(ioc->pdev,
1346 ioc->diag_buffer_sz[buffer_type],
1347 request_data, request_data_dma);
1348 request_data = NULL;
1349 }
1350 }
1351
1352 if (request_data == NULL) {
1353 ioc->diag_buffer_sz[buffer_type] = 0;
1354 ioc->diag_buffer_dma[buffer_type] = 0;
1355 request_data = pci_alloc_consistent(
1356 ioc->pdev, request_data_sz, &request_data_dma);
1357 if (request_data == NULL) {
1358 printk(MPT2SAS_ERR_FMT "%s: failed allocating memory"
1359 " for diag buffers, requested size(%d)\n",
1360 ioc->name, __func__, request_data_sz);
1361 mpt2sas_base_free_smid(ioc, smid);
1362 return -ENOMEM;
1363 }
1364 ioc->diag_buffer[buffer_type] = request_data;
1365 ioc->diag_buffer_sz[buffer_type] = request_data_sz;
1366 ioc->diag_buffer_dma[buffer_type] = request_data_dma;
1367 }
1368
1369 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1370 mpi_request->BufferType = karg.buffer_type;
1371 mpi_request->Flags = cpu_to_le32(karg.diagnostic_flags);
1372 mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
1373 mpi_request->BufferLength = cpu_to_le32(request_data_sz);
1374
1375 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: diag_buffer(0x%p), "
1376 "dma(0x%llx), sz(%d)\n", ioc->name, __func__, request_data,
1377 (unsigned long long)request_data_dma, mpi_request->BufferLength));
1378
1379 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1380 mpi_request->ProductSpecific[i] =
1381 cpu_to_le32(ioc->product_specific[buffer_type][i]);
1382
1383 mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
1384 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1385 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1386
1387 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1388 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1389 __func__);
1390 _debug_dump_mf(mpi_request,
1391 sizeof(Mpi2DiagBufferPostRequest_t)/4);
1392 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1393 issue_reset = 1;
1394 goto issue_host_reset;
1395 }
1396
1397 /* process the completed Reply Message Frame */
1398 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1399 printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1400 ioc->name, __func__);
1401 rc = -EFAULT;
1402 goto out;
1403 }
1404
1405 mpi_reply = ioc->ctl_cmds.reply;
1406 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1407
1408 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1409 ioc->diag_buffer_status[buffer_type] |=
1410 MPT2_DIAG_BUFFER_IS_REGISTERED;
1411 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: success\n",
1412 ioc->name, __func__));
1413 } else {
1414 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
1415 "log_info(0x%08x)\n", ioc->name, __func__,
1416 ioc_status, mpi_reply->IOCLogInfo);
1417 rc = -EFAULT;
1418 }
1419
1420 issue_host_reset:
1421 if (issue_reset)
1422 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1423 FORCE_BIG_HAMMER);
1424
1425 out:
1426
1427 if (rc && request_data)
1428 pci_free_consistent(ioc->pdev, request_data_sz,
1429 request_data, request_data_dma);
1430
1431 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1432 mutex_unlock(&ioc->ctl_cmds.mutex);
1433 return rc;
1434 }
1435
1436 /**
1437 * _ctl_diag_unregister - application unregister with driver
1438 * @arg - user space buffer containing ioctl content
1439 *
1440 * This will allow the driver to cleanup any memory allocated for diag
1441 * messages and to free up any resources.
1442 */
1443 static long
1444 _ctl_diag_unregister(void __user *arg)
1445 {
1446 struct mpt2_diag_unregister karg;
1447 struct MPT2SAS_ADAPTER *ioc;
1448 void *request_data;
1449 dma_addr_t request_data_dma;
1450 u32 request_data_sz;
1451 u8 buffer_type;
1452
1453 if (copy_from_user(&karg, arg, sizeof(karg))) {
1454 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1455 __FILE__, __LINE__, __func__);
1456 return -EFAULT;
1457 }
1458 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1459 return -ENODEV;
1460
1461 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1462 __func__));
1463
1464 buffer_type = karg.unique_id & 0x000000ff;
1465 if (!_ctl_diag_capability(ioc, buffer_type)) {
1466 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1467 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1468 return -EPERM;
1469 }
1470
1471 if ((ioc->diag_buffer_status[buffer_type] &
1472 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1473 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1474 "registered\n", ioc->name, __func__, buffer_type);
1475 return -EINVAL;
1476 }
1477 if ((ioc->diag_buffer_status[buffer_type] &
1478 MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
1479 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) has not been "
1480 "released\n", ioc->name, __func__, buffer_type);
1481 return -EINVAL;
1482 }
1483
1484 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1485 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1486 "registered\n", ioc->name, __func__, karg.unique_id);
1487 return -EINVAL;
1488 }
1489
1490 request_data = ioc->diag_buffer[buffer_type];
1491 if (!request_data) {
1492 printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
1493 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1494 return -ENOMEM;
1495 }
1496
1497 request_data_sz = ioc->diag_buffer_sz[buffer_type];
1498 request_data_dma = ioc->diag_buffer_dma[buffer_type];
1499 pci_free_consistent(ioc->pdev, request_data_sz,
1500 request_data, request_data_dma);
1501 ioc->diag_buffer[buffer_type] = NULL;
1502 ioc->diag_buffer_status[buffer_type] = 0;
1503 return 0;
1504 }
1505
1506 /**
1507 * _ctl_diag_query - query relevant info associated with diag buffers
1508 * @arg - user space buffer containing ioctl content
1509 *
1510 * The application will send only buffer_type and unique_id. Driver will
1511 * inspect unique_id first, if valid, fill in all the info. If unique_id is
1512 * 0x00, the driver will return info specified by Buffer Type.
1513 */
1514 static long
1515 _ctl_diag_query(void __user *arg)
1516 {
1517 struct mpt2_diag_query karg;
1518 struct MPT2SAS_ADAPTER *ioc;
1519 void *request_data;
1520 int i;
1521 u8 buffer_type;
1522
1523 if (copy_from_user(&karg, arg, sizeof(karg))) {
1524 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1525 __FILE__, __LINE__, __func__);
1526 return -EFAULT;
1527 }
1528 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1529 return -ENODEV;
1530
1531 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1532 __func__));
1533
1534 karg.application_flags = 0;
1535 buffer_type = karg.buffer_type;
1536
1537 if (!_ctl_diag_capability(ioc, buffer_type)) {
1538 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1539 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1540 return -EPERM;
1541 }
1542
1543 if ((ioc->diag_buffer_status[buffer_type] &
1544 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1545 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1546 "registered\n", ioc->name, __func__, buffer_type);
1547 return -EINVAL;
1548 }
1549
1550 if (karg.unique_id & 0xffffff00) {
1551 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1552 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1553 "registered\n", ioc->name, __func__,
1554 karg.unique_id);
1555 return -EINVAL;
1556 }
1557 }
1558
1559 request_data = ioc->diag_buffer[buffer_type];
1560 if (!request_data) {
1561 printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
1562 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1563 return -ENOMEM;
1564 }
1565
1566 if (ioc->diag_buffer_status[buffer_type] & MPT2_DIAG_BUFFER_IS_RELEASED)
1567 karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
1568 MPT2_APP_FLAGS_BUFFER_VALID);
1569 else
1570 karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
1571 MPT2_APP_FLAGS_BUFFER_VALID |
1572 MPT2_APP_FLAGS_FW_BUFFER_ACCESS);
1573
1574 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1575 karg.product_specific[i] =
1576 ioc->product_specific[buffer_type][i];
1577
1578 karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
1579 karg.driver_added_buffer_size = 0;
1580 karg.unique_id = ioc->unique_id[buffer_type];
1581 karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
1582
1583 if (copy_to_user(arg, &karg, sizeof(struct mpt2_diag_query))) {
1584 printk(MPT2SAS_ERR_FMT "%s: unable to write mpt2_diag_query "
1585 "data @ %p\n", ioc->name, __func__, arg);
1586 return -EFAULT;
1587 }
1588 return 0;
1589 }
1590
1591 /**
1592 * _ctl_send_release - Diag Release Message
1593 * @ioc: per adapter object
1594 * @buffer_type - specifies either TRACE or SNAPSHOT
1595 * @issue_reset - specifies whether host reset is required.
1596 *
1597 */
1598 static int
1599 _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
1600 {
1601 Mpi2DiagReleaseRequest_t *mpi_request;
1602 Mpi2DiagReleaseReply_t *mpi_reply;
1603 u16 smid;
1604 u16 ioc_status;
1605 u32 ioc_state;
1606 int rc;
1607 unsigned long timeleft;
1608
1609 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1610 __func__));
1611
1612 rc = 0;
1613 *issue_reset = 0;
1614
1615 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
1616 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
1617 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
1618 "skipping due to FAULT state\n", ioc->name,
1619 __func__));
1620 rc = -EAGAIN;
1621 goto out;
1622 }
1623
1624 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1625 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1626 ioc->name, __func__);
1627 rc = -EAGAIN;
1628 goto out;
1629 }
1630
1631 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1632 if (!smid) {
1633 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1634 ioc->name, __func__);
1635 rc = -EAGAIN;
1636 goto out;
1637 }
1638
1639 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1640 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1641 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1642 ioc->ctl_cmds.smid = smid;
1643
1644 mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE;
1645 mpi_request->BufferType = buffer_type;
1646
1647 mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
1648 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1649 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1650
1651 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1652 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1653 __func__);
1654 _debug_dump_mf(mpi_request,
1655 sizeof(Mpi2DiagReleaseRequest_t)/4);
1656 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1657 *issue_reset = 1;
1658 rc = -EFAULT;
1659 goto out;
1660 }
1661
1662 /* process the completed Reply Message Frame */
1663 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1664 printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1665 ioc->name, __func__);
1666 rc = -EFAULT;
1667 goto out;
1668 }
1669
1670 mpi_reply = ioc->ctl_cmds.reply;
1671 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1672
1673 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1674 ioc->diag_buffer_status[buffer_type] |=
1675 MPT2_DIAG_BUFFER_IS_RELEASED;
1676 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: success\n",
1677 ioc->name, __func__));
1678 } else {
1679 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
1680 "log_info(0x%08x)\n", ioc->name, __func__,
1681 ioc_status, mpi_reply->IOCLogInfo);
1682 rc = -EFAULT;
1683 }
1684
1685 out:
1686 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1687 return rc;
1688 }
1689
1690 /**
1691 * _ctl_diag_release - request to send Diag Release Message to firmware
1692 * @arg - user space buffer containing ioctl content
1693 * @state - NON_BLOCKING or BLOCKING
1694 *
1695 * This allows ownership of the specified buffer to returned to the driver,
1696 * allowing an application to read the buffer without fear that firmware is
1697 * overwritting information in the buffer.
1698 */
1699 static long
1700 _ctl_diag_release(void __user *arg, enum block_state state)
1701 {
1702 struct mpt2_diag_release karg;
1703 struct MPT2SAS_ADAPTER *ioc;
1704 void *request_data;
1705 int rc;
1706 u8 buffer_type;
1707 u8 issue_reset = 0;
1708
1709 if (copy_from_user(&karg, arg, sizeof(karg))) {
1710 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1711 __FILE__, __LINE__, __func__);
1712 return -EFAULT;
1713 }
1714 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1715 return -ENODEV;
1716
1717 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1718 __func__));
1719
1720 buffer_type = karg.unique_id & 0x000000ff;
1721 if (!_ctl_diag_capability(ioc, buffer_type)) {
1722 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1723 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1724 return -EPERM;
1725 }
1726
1727 if ((ioc->diag_buffer_status[buffer_type] &
1728 MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
1729 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
1730 "registered\n", ioc->name, __func__, buffer_type);
1731 return -EINVAL;
1732 }
1733
1734 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1735 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1736 "registered\n", ioc->name, __func__, karg.unique_id);
1737 return -EINVAL;
1738 }
1739
1740 if (ioc->diag_buffer_status[buffer_type] &
1741 MPT2_DIAG_BUFFER_IS_RELEASED) {
1742 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
1743 "is already released\n", ioc->name, __func__,
1744 buffer_type);
1745 return 0;
1746 }
1747
1748 request_data = ioc->diag_buffer[buffer_type];
1749
1750 if (!request_data) {
1751 printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
1752 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1753 return -ENOMEM;
1754 }
1755
1756 /* buffers were released by due to host reset */
1757 if ((ioc->diag_buffer_status[buffer_type] &
1758 MPT2_DIAG_BUFFER_IS_DIAG_RESET)) {
1759 ioc->diag_buffer_status[buffer_type] |=
1760 MPT2_DIAG_BUFFER_IS_RELEASED;
1761 ioc->diag_buffer_status[buffer_type] &=
1762 ~MPT2_DIAG_BUFFER_IS_DIAG_RESET;
1763 printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
1764 "was released due to host reset\n", ioc->name, __func__,
1765 buffer_type);
1766 return 0;
1767 }
1768
1769 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1770 return -EAGAIN;
1771 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1772 return -ERESTARTSYS;
1773
1774 rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
1775
1776 if (issue_reset)
1777 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1778 FORCE_BIG_HAMMER);
1779
1780 mutex_unlock(&ioc->ctl_cmds.mutex);
1781 return rc;
1782 }
1783
1784 /**
1785 * _ctl_diag_read_buffer - request for copy of the diag buffer
1786 * @arg - user space buffer containing ioctl content
1787 * @state - NON_BLOCKING or BLOCKING
1788 */
1789 static long
1790 _ctl_diag_read_buffer(void __user *arg, enum block_state state)
1791 {
1792 struct mpt2_diag_read_buffer karg;
1793 struct mpt2_diag_read_buffer __user *uarg = arg;
1794 struct MPT2SAS_ADAPTER *ioc;
1795 void *request_data, *diag_data;
1796 Mpi2DiagBufferPostRequest_t *mpi_request;
1797 Mpi2DiagBufferPostReply_t *mpi_reply;
1798 int rc, i;
1799 u8 buffer_type;
1800 unsigned long timeleft;
1801 u16 smid;
1802 u16 ioc_status;
1803 u8 issue_reset = 0;
1804
1805 if (copy_from_user(&karg, arg, sizeof(karg))) {
1806 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1807 __FILE__, __LINE__, __func__);
1808 return -EFAULT;
1809 }
1810 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
1811 return -ENODEV;
1812
1813 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
1814 __func__));
1815
1816 buffer_type = karg.unique_id & 0x000000ff;
1817 if (!_ctl_diag_capability(ioc, buffer_type)) {
1818 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
1819 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1820 return -EPERM;
1821 }
1822
1823 if (karg.unique_id != ioc->unique_id[buffer_type]) {
1824 printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
1825 "registered\n", ioc->name, __func__, karg.unique_id);
1826 return -EINVAL;
1827 }
1828
1829 request_data = ioc->diag_buffer[buffer_type];
1830 if (!request_data) {
1831 printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
1832 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
1833 return -ENOMEM;
1834 }
1835
1836 if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
1837 printk(MPT2SAS_ERR_FMT "%s: either the starting_offset "
1838 "or bytes_to_read are not 4 byte aligned\n", ioc->name,
1839 __func__);
1840 return -EINVAL;
1841 }
1842
1843 diag_data = (void *)(request_data + karg.starting_offset);
1844 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: diag_buffer(%p), "
1845 "offset(%d), sz(%d)\n", ioc->name, __func__,
1846 diag_data, karg.starting_offset, karg.bytes_to_read));
1847
1848 if (copy_to_user((void __user *)uarg->diagnostic_data,
1849 diag_data, karg.bytes_to_read)) {
1850 printk(MPT2SAS_ERR_FMT "%s: Unable to write "
1851 "mpt_diag_read_buffer_t data @ %p\n", ioc->name,
1852 __func__, diag_data);
1853 return -EFAULT;
1854 }
1855
1856 if ((karg.flags & MPT2_FLAGS_REREGISTER) == 0)
1857 return 0;
1858
1859 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: Reregister "
1860 "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type));
1861 if ((ioc->diag_buffer_status[buffer_type] &
1862 MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
1863 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
1864 "buffer_type(0x%02x) is still registered\n", ioc->name,
1865 __func__, buffer_type));
1866 return 0;
1867 }
1868 /* Get a free request frame and save the message context.
1869 */
1870 if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
1871 return -EAGAIN;
1872 else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
1873 return -ERESTARTSYS;
1874
1875 if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
1876 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
1877 ioc->name, __func__);
1878 rc = -EAGAIN;
1879 goto out;
1880 }
1881
1882 smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
1883 if (!smid) {
1884 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
1885 ioc->name, __func__);
1886 rc = -EAGAIN;
1887 goto out;
1888 }
1889
1890 rc = 0;
1891 ioc->ctl_cmds.status = MPT2_CMD_PENDING;
1892 memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
1893 mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
1894 ioc->ctl_cmds.smid = smid;
1895
1896 mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
1897 mpi_request->BufferType = buffer_type;
1898 mpi_request->BufferLength =
1899 cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
1900 mpi_request->BufferAddress =
1901 cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
1902 for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
1903 mpi_request->ProductSpecific[i] =
1904 cpu_to_le32(ioc->product_specific[buffer_type][i]);
1905
1906 mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
1907 timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
1908 MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
1909
1910 if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
1911 printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
1912 __func__);
1913 _debug_dump_mf(mpi_request,
1914 sizeof(Mpi2DiagBufferPostRequest_t)/4);
1915 if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
1916 issue_reset = 1;
1917 goto issue_host_reset;
1918 }
1919
1920 /* process the completed Reply Message Frame */
1921 if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
1922 printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
1923 ioc->name, __func__);
1924 rc = -EFAULT;
1925 goto out;
1926 }
1927
1928 mpi_reply = ioc->ctl_cmds.reply;
1929 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1930
1931 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
1932 ioc->diag_buffer_status[buffer_type] |=
1933 MPT2_DIAG_BUFFER_IS_REGISTERED;
1934 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: success\n",
1935 ioc->name, __func__));
1936 } else {
1937 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
1938 "log_info(0x%08x)\n", ioc->name, __func__,
1939 ioc_status, mpi_reply->IOCLogInfo);
1940 rc = -EFAULT;
1941 }
1942
1943 issue_host_reset:
1944 if (issue_reset)
1945 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
1946 FORCE_BIG_HAMMER);
1947
1948 out:
1949
1950 ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
1951 mutex_unlock(&ioc->ctl_cmds.mutex);
1952 return rc;
1953 }
1954
1955 /**
1956 * _ctl_ioctl_main - main ioctl entry point
1957 * @file - (struct file)
1958 * @cmd - ioctl opcode
1959 * @arg -
1960 */
1961 static long
1962 _ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg)
1963 {
1964 enum block_state state;
1965 long ret = -EINVAL;
1966 unsigned long flags;
1967
1968 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING :
1969 BLOCKING;
1970
1971 switch (cmd) {
1972 case MPT2IOCINFO:
1973 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo))
1974 ret = _ctl_getiocinfo(arg);
1975 break;
1976 case MPT2COMMAND:
1977 {
1978 struct mpt2_ioctl_command karg;
1979 struct mpt2_ioctl_command __user *uarg;
1980 struct MPT2SAS_ADAPTER *ioc;
1981
1982 if (copy_from_user(&karg, arg, sizeof(karg))) {
1983 printk(KERN_ERR "failure at %s:%d/%s()!\n",
1984 __FILE__, __LINE__, __func__);
1985 return -EFAULT;
1986 }
1987
1988 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
1989 !ioc)
1990 return -ENODEV;
1991
1992 spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
1993 if (ioc->shost_recovery) {
1994 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock,
1995 flags);
1996 return -EAGAIN;
1997 }
1998 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
1999
2000 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) {
2001 uarg = arg;
2002 ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2003 }
2004 break;
2005 }
2006 case MPT2EVENTQUERY:
2007 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery))
2008 ret = _ctl_eventquery(arg);
2009 break;
2010 case MPT2EVENTENABLE:
2011 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable))
2012 ret = _ctl_eventenable(arg);
2013 break;
2014 case MPT2EVENTREPORT:
2015 ret = _ctl_eventreport(arg);
2016 break;
2017 case MPT2HARDRESET:
2018 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset))
2019 ret = _ctl_do_reset(arg);
2020 break;
2021 case MPT2BTDHMAPPING:
2022 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping))
2023 ret = _ctl_btdh_mapping(arg);
2024 break;
2025 case MPT2DIAGREGISTER:
2026 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register))
2027 ret = _ctl_diag_register(arg, state);
2028 break;
2029 case MPT2DIAGUNREGISTER:
2030 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister))
2031 ret = _ctl_diag_unregister(arg);
2032 break;
2033 case MPT2DIAGQUERY:
2034 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query))
2035 ret = _ctl_diag_query(arg);
2036 break;
2037 case MPT2DIAGRELEASE:
2038 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release))
2039 ret = _ctl_diag_release(arg, state);
2040 break;
2041 case MPT2DIAGREADBUFFER:
2042 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer))
2043 ret = _ctl_diag_read_buffer(arg, state);
2044 break;
2045 default:
2046 {
2047 struct mpt2_ioctl_command karg;
2048 struct MPT2SAS_ADAPTER *ioc;
2049
2050 if (copy_from_user(&karg, arg, sizeof(karg))) {
2051 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2052 __FILE__, __LINE__, __func__);
2053 return -EFAULT;
2054 }
2055
2056 if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
2057 !ioc)
2058 return -ENODEV;
2059
2060 dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT
2061 "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
2062 break;
2063 }
2064 }
2065 return ret;
2066 }
2067
2068 /**
2069 * _ctl_ioctl - main ioctl entry point (unlocked)
2070 * @file - (struct file)
2071 * @cmd - ioctl opcode
2072 * @arg -
2073 */
2074 static long
2075 _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2076 {
2077 long ret;
2078 lock_kernel();
2079 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2080 unlock_kernel();
2081 return ret;
2082 }
2083
2084 #ifdef CONFIG_COMPAT
2085 /**
2086 * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
2087 * @file - (struct file)
2088 * @cmd - ioctl opcode
2089 * @arg - (struct mpt2_ioctl_command32)
2090 *
2091 * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
2092 */
2093 static long
2094 _ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
2095 {
2096 struct mpt2_ioctl_command32 karg32;
2097 struct mpt2_ioctl_command32 __user *uarg;
2098 struct mpt2_ioctl_command karg;
2099 struct MPT2SAS_ADAPTER *ioc;
2100 enum block_state state;
2101 unsigned long flags;
2102
2103 if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
2104 return -EINVAL;
2105
2106 uarg = (struct mpt2_ioctl_command32 __user *) arg;
2107
2108 if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
2109 printk(KERN_ERR "failure at %s:%d/%s()!\n",
2110 __FILE__, __LINE__, __func__);
2111 return -EFAULT;
2112 }
2113 if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
2114 return -ENODEV;
2115
2116 spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
2117 if (ioc->shost_recovery) {
2118 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock,
2119 flags);
2120 return -EAGAIN;
2121 }
2122 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
2123
2124 memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
2125 karg.hdr.ioc_number = karg32.hdr.ioc_number;
2126 karg.hdr.port_number = karg32.hdr.port_number;
2127 karg.hdr.max_data_size = karg32.hdr.max_data_size;
2128 karg.timeout = karg32.timeout;
2129 karg.max_reply_bytes = karg32.max_reply_bytes;
2130 karg.data_in_size = karg32.data_in_size;
2131 karg.data_out_size = karg32.data_out_size;
2132 karg.max_sense_bytes = karg32.max_sense_bytes;
2133 karg.data_sge_offset = karg32.data_sge_offset;
2134 memcpy(&karg.reply_frame_buf_ptr, &karg32.reply_frame_buf_ptr,
2135 sizeof(uint32_t));
2136 memcpy(&karg.data_in_buf_ptr, &karg32.data_in_buf_ptr,
2137 sizeof(uint32_t));
2138 memcpy(&karg.data_out_buf_ptr, &karg32.data_out_buf_ptr,
2139 sizeof(uint32_t));
2140 memcpy(&karg.sense_data_ptr, &karg32.sense_data_ptr,
2141 sizeof(uint32_t));
2142 state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
2143 return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
2144 }
2145
2146 /**
2147 * _ctl_ioctl_compat - main ioctl entry point (compat)
2148 * @file -
2149 * @cmd -
2150 * @arg -
2151 *
2152 * This routine handles 32 bit applications in 64bit os.
2153 */
2154 static long
2155 _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
2156 {
2157 long ret;
2158 lock_kernel();
2159 if (cmd == MPT2COMMAND32)
2160 ret = _ctl_compat_mpt_command(file, cmd, arg);
2161 else
2162 ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
2163 unlock_kernel();
2164 return ret;
2165 }
2166 #endif
2167
2168 /* scsi host attributes */
2169
2170 /**
2171 * _ctl_version_fw_show - firmware version
2172 * @cdev - pointer to embedded class device
2173 * @buf - the buffer returned
2174 *
2175 * A sysfs 'read-only' shost attribute.
2176 */
2177 static ssize_t
2178 _ctl_version_fw_show(struct device *cdev, struct device_attribute *attr,
2179 char *buf)
2180 {
2181 struct Scsi_Host *shost = class_to_shost(cdev);
2182 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2183
2184 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2185 (ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
2186 (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
2187 (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
2188 ioc->facts.FWVersion.Word & 0x000000FF);
2189 }
2190 static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL);
2191
2192 /**
2193 * _ctl_version_bios_show - bios version
2194 * @cdev - pointer to embedded class device
2195 * @buf - the buffer returned
2196 *
2197 * A sysfs 'read-only' shost attribute.
2198 */
2199 static ssize_t
2200 _ctl_version_bios_show(struct device *cdev, struct device_attribute *attr,
2201 char *buf)
2202 {
2203 struct Scsi_Host *shost = class_to_shost(cdev);
2204 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2205
2206 u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
2207
2208 return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
2209 (version & 0xFF000000) >> 24,
2210 (version & 0x00FF0000) >> 16,
2211 (version & 0x0000FF00) >> 8,
2212 version & 0x000000FF);
2213 }
2214 static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL);
2215
2216 /**
2217 * _ctl_version_mpi_show - MPI (message passing interface) version
2218 * @cdev - pointer to embedded class device
2219 * @buf - the buffer returned
2220 *
2221 * A sysfs 'read-only' shost attribute.
2222 */
2223 static ssize_t
2224 _ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr,
2225 char *buf)
2226 {
2227 struct Scsi_Host *shost = class_to_shost(cdev);
2228 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2229
2230 return snprintf(buf, PAGE_SIZE, "%03x.%02x\n",
2231 ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
2232 }
2233 static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL);
2234
2235 /**
2236 * _ctl_version_product_show - product name
2237 * @cdev - pointer to embedded class device
2238 * @buf - the buffer returned
2239 *
2240 * A sysfs 'read-only' shost attribute.
2241 */
2242 static ssize_t
2243 _ctl_version_product_show(struct device *cdev, struct device_attribute *attr,
2244 char *buf)
2245 {
2246 struct Scsi_Host *shost = class_to_shost(cdev);
2247 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2248
2249 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName);
2250 }
2251 static DEVICE_ATTR(version_product, S_IRUGO,
2252 _ctl_version_product_show, NULL);
2253
2254 /**
2255 * _ctl_version_nvdata_persistent_show - ndvata persistent version
2256 * @cdev - pointer to embedded class device
2257 * @buf - the buffer returned
2258 *
2259 * A sysfs 'read-only' shost attribute.
2260 */
2261 static ssize_t
2262 _ctl_version_nvdata_persistent_show(struct device *cdev,
2263 struct device_attribute *attr, char *buf)
2264 {
2265 struct Scsi_Host *shost = class_to_shost(cdev);
2266 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2267
2268 return snprintf(buf, PAGE_SIZE, "%02xh\n",
2269 le16_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
2270 }
2271 static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
2272 _ctl_version_nvdata_persistent_show, NULL);
2273
2274 /**
2275 * _ctl_version_nvdata_default_show - nvdata default version
2276 * @cdev - pointer to embedded class device
2277 * @buf - the buffer returned
2278 *
2279 * A sysfs 'read-only' shost attribute.
2280 */
2281 static ssize_t
2282 _ctl_version_nvdata_default_show(struct device *cdev,
2283 struct device_attribute *attr, char *buf)
2284 {
2285 struct Scsi_Host *shost = class_to_shost(cdev);
2286 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2287
2288 return snprintf(buf, PAGE_SIZE, "%02xh\n",
2289 le16_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
2290 }
2291 static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
2292 _ctl_version_nvdata_default_show, NULL);
2293
2294 /**
2295 * _ctl_board_name_show - board name
2296 * @cdev - pointer to embedded class device
2297 * @buf - the buffer returned
2298 *
2299 * A sysfs 'read-only' shost attribute.
2300 */
2301 static ssize_t
2302 _ctl_board_name_show(struct device *cdev, struct device_attribute *attr,
2303 char *buf)
2304 {
2305 struct Scsi_Host *shost = class_to_shost(cdev);
2306 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2307
2308 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName);
2309 }
2310 static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL);
2311
2312 /**
2313 * _ctl_board_assembly_show - board assembly name
2314 * @cdev - pointer to embedded class device
2315 * @buf - the buffer returned
2316 *
2317 * A sysfs 'read-only' shost attribute.
2318 */
2319 static ssize_t
2320 _ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr,
2321 char *buf)
2322 {
2323 struct Scsi_Host *shost = class_to_shost(cdev);
2324 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2325
2326 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly);
2327 }
2328 static DEVICE_ATTR(board_assembly, S_IRUGO,
2329 _ctl_board_assembly_show, NULL);
2330
2331 /**
2332 * _ctl_board_tracer_show - board tracer number
2333 * @cdev - pointer to embedded class device
2334 * @buf - the buffer returned
2335 *
2336 * A sysfs 'read-only' shost attribute.
2337 */
2338 static ssize_t
2339 _ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr,
2340 char *buf)
2341 {
2342 struct Scsi_Host *shost = class_to_shost(cdev);
2343 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2344
2345 return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber);
2346 }
2347 static DEVICE_ATTR(board_tracer, S_IRUGO,
2348 _ctl_board_tracer_show, NULL);
2349
2350 /**
2351 * _ctl_io_delay_show - io missing delay
2352 * @cdev - pointer to embedded class device
2353 * @buf - the buffer returned
2354 *
2355 * This is for firmware implemention for deboucing device
2356 * removal events.
2357 *
2358 * A sysfs 'read-only' shost attribute.
2359 */
2360 static ssize_t
2361 _ctl_io_delay_show(struct device *cdev, struct device_attribute *attr,
2362 char *buf)
2363 {
2364 struct Scsi_Host *shost = class_to_shost(cdev);
2365 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2366
2367 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
2368 }
2369 static DEVICE_ATTR(io_delay, S_IRUGO,
2370 _ctl_io_delay_show, NULL);
2371
2372 /**
2373 * _ctl_device_delay_show - device missing delay
2374 * @cdev - pointer to embedded class device
2375 * @buf - the buffer returned
2376 *
2377 * This is for firmware implemention for deboucing device
2378 * removal events.
2379 *
2380 * A sysfs 'read-only' shost attribute.
2381 */
2382 static ssize_t
2383 _ctl_device_delay_show(struct device *cdev, struct device_attribute *attr,
2384 char *buf)
2385 {
2386 struct Scsi_Host *shost = class_to_shost(cdev);
2387 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2388
2389 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
2390 }
2391 static DEVICE_ATTR(device_delay, S_IRUGO,
2392 _ctl_device_delay_show, NULL);
2393
2394 /**
2395 * _ctl_fw_queue_depth_show - global credits
2396 * @cdev - pointer to embedded class device
2397 * @buf - the buffer returned
2398 *
2399 * This is firmware queue depth limit
2400 *
2401 * A sysfs 'read-only' shost attribute.
2402 */
2403 static ssize_t
2404 _ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr,
2405 char *buf)
2406 {
2407 struct Scsi_Host *shost = class_to_shost(cdev);
2408 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2409
2410 return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit);
2411 }
2412 static DEVICE_ATTR(fw_queue_depth, S_IRUGO,
2413 _ctl_fw_queue_depth_show, NULL);
2414
2415 /**
2416 * _ctl_sas_address_show - sas address
2417 * @cdev - pointer to embedded class device
2418 * @buf - the buffer returned
2419 *
2420 * This is the controller sas address
2421 *
2422 * A sysfs 'read-only' shost attribute.
2423 */
2424 static ssize_t
2425 _ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr,
2426 char *buf)
2427 {
2428 struct Scsi_Host *shost = class_to_shost(cdev);
2429 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2430
2431 return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2432 (unsigned long long)ioc->sas_hba.sas_address);
2433 }
2434 static DEVICE_ATTR(host_sas_address, S_IRUGO,
2435 _ctl_host_sas_address_show, NULL);
2436
2437 /**
2438 * _ctl_logging_level_show - logging level
2439 * @cdev - pointer to embedded class device
2440 * @buf - the buffer returned
2441 *
2442 * A sysfs 'read/write' shost attribute.
2443 */
2444 static ssize_t
2445 _ctl_logging_level_show(struct device *cdev, struct device_attribute *attr,
2446 char *buf)
2447 {
2448 struct Scsi_Host *shost = class_to_shost(cdev);
2449 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2450
2451 return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level);
2452 }
2453 static ssize_t
2454 _ctl_logging_level_store(struct device *cdev, struct device_attribute *attr,
2455 const char *buf, size_t count)
2456 {
2457 struct Scsi_Host *shost = class_to_shost(cdev);
2458 struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
2459 int val = 0;
2460
2461 if (sscanf(buf, "%x", &val) != 1)
2462 return -EINVAL;
2463
2464 ioc->logging_level = val;
2465 printk(MPT2SAS_INFO_FMT "logging_level=%08xh\n", ioc->name,
2466 ioc->logging_level);
2467 return strlen(buf);
2468 }
2469 static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR,
2470 _ctl_logging_level_show, _ctl_logging_level_store);
2471
2472 struct device_attribute *mpt2sas_host_attrs[] = {
2473 &dev_attr_version_fw,
2474 &dev_attr_version_bios,
2475 &dev_attr_version_mpi,
2476 &dev_attr_version_product,
2477 &dev_attr_version_nvdata_persistent,
2478 &dev_attr_version_nvdata_default,
2479 &dev_attr_board_name,
2480 &dev_attr_board_assembly,
2481 &dev_attr_board_tracer,
2482 &dev_attr_io_delay,
2483 &dev_attr_device_delay,
2484 &dev_attr_logging_level,
2485 &dev_attr_fw_queue_depth,
2486 &dev_attr_host_sas_address,
2487 NULL,
2488 };
2489
2490 /* device attributes */
2491
2492 /**
2493 * _ctl_device_sas_address_show - sas address
2494 * @cdev - pointer to embedded class device
2495 * @buf - the buffer returned
2496 *
2497 * This is the sas address for the target
2498 *
2499 * A sysfs 'read-only' shost attribute.
2500 */
2501 static ssize_t
2502 _ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr,
2503 char *buf)
2504 {
2505 struct scsi_device *sdev = to_scsi_device(dev);
2506 struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
2507
2508 return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
2509 (unsigned long long)sas_device_priv_data->sas_target->sas_address);
2510 }
2511 static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL);
2512
2513 /**
2514 * _ctl_device_handle_show - device handle
2515 * @cdev - pointer to embedded class device
2516 * @buf - the buffer returned
2517 *
2518 * This is the firmware assigned device handle
2519 *
2520 * A sysfs 'read-only' shost attribute.
2521 */
2522 static ssize_t
2523 _ctl_device_handle_show(struct device *dev, struct device_attribute *attr,
2524 char *buf)
2525 {
2526 struct scsi_device *sdev = to_scsi_device(dev);
2527 struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
2528
2529 return snprintf(buf, PAGE_SIZE, "0x%04x\n",
2530 sas_device_priv_data->sas_target->handle);
2531 }
2532 static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL);
2533
2534 struct device_attribute *mpt2sas_dev_attrs[] = {
2535 &dev_attr_sas_address,
2536 &dev_attr_sas_device_handle,
2537 NULL,
2538 };
2539
2540 static const struct file_operations ctl_fops = {
2541 .owner = THIS_MODULE,
2542 .unlocked_ioctl = _ctl_ioctl,
2543 .release = _ctl_release,
2544 .poll = _ctl_poll,
2545 .fasync = _ctl_fasync,
2546 #ifdef CONFIG_COMPAT
2547 .compat_ioctl = _ctl_ioctl_compat,
2548 #endif
2549 };
2550
2551 static struct miscdevice ctl_dev = {
2552 .minor = MPT2SAS_MINOR,
2553 .name = MPT2SAS_DEV_NAME,
2554 .fops = &ctl_fops,
2555 };
2556
2557 /**
2558 * mpt2sas_ctl_init - main entry point for ctl.
2559 *
2560 */
2561 void
2562 mpt2sas_ctl_init(void)
2563 {
2564 async_queue = NULL;
2565 if (misc_register(&ctl_dev) < 0)
2566 printk(KERN_ERR "%s can't register misc device [minor=%d]\n",
2567 MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR);
2568
2569 init_waitqueue_head(&ctl_poll_wait);
2570 }
2571
2572 /**
2573 * mpt2sas_ctl_exit - exit point for ctl
2574 *
2575 */
2576 void
2577 mpt2sas_ctl_exit(void)
2578 {
2579 struct MPT2SAS_ADAPTER *ioc;
2580 int i;
2581
2582 list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
2583
2584 /* free memory associated to diag buffers */
2585 for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
2586 if (!ioc->diag_buffer[i])
2587 continue;
2588 pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
2589 ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
2590 ioc->diag_buffer[i] = NULL;
2591 ioc->diag_buffer_status[i] = 0;
2592 }
2593
2594 kfree(ioc->event_log);
2595 }
2596 misc_deregister(&ctl_dev);
2597 }
2598
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree