Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Adaptec AAC series RAID controller driver
4 * (c) Copyright 2001 Red Hat Inc.
5 *
6 * based on the old aacraid driver that is..
7 * Adaptec aacraid device driver for Linux.
8 *
9 * Copyright (c) 2000-2010 Adaptec, Inc.
10 * 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
11 * 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
12 *
13 * Module Name:
14 * commctrl.c
15 *
16 * Abstract: Contains all routines for control of the AFA comm layer
17 */
18
19#include <linux/kernel.h>
20#include <linux/init.h>
21#include <linux/types.h>
22#include <linux/pci.h>
23#include <linux/spinlock.h>
24#include <linux/slab.h>
25#include <linux/completion.h>
26#include <linux/dma-mapping.h>
27#include <linux/blkdev.h>
28#include <linux/delay.h> /* ssleep prototype */
29#include <linux/kthread.h>
30#include <linux/uaccess.h>
31#include <scsi/scsi_host.h>
32
33#include "aacraid.h"
34
35/**
36 * ioctl_send_fib - send a FIB from userspace
37 * @dev: adapter is being processed
38 * @arg: arguments to the ioctl call
39 *
40 * This routine sends a fib to the adapter on behalf of a user level
41 * program.
42 */
43# define AAC_DEBUG_PREAMBLE KERN_INFO
44# define AAC_DEBUG_POSTAMBLE
45
46static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
47{
48 struct hw_fib * kfib;
49 struct fib *fibptr;
50 struct hw_fib * hw_fib = (struct hw_fib *)0;
51 dma_addr_t hw_fib_pa = (dma_addr_t)0LL;
52 unsigned int size, osize;
53 int retval;
54
55 if (dev->in_reset) {
56 return -EBUSY;
57 }
58 fibptr = aac_fib_alloc(dev);
59 if(fibptr == NULL) {
60 return -ENOMEM;
61 }
62
63 kfib = fibptr->hw_fib_va;
64 /*
65 * First copy in the header so that we can check the size field.
66 */
67 if (copy_from_user((void *)kfib, arg, sizeof(struct aac_fibhdr))) {
68 aac_fib_free(fibptr);
69 return -EFAULT;
70 }
71 /*
72 * Since we copy based on the fib header size, make sure that we
73 * will not overrun the buffer when we copy the memory. Return
74 * an error if we would.
75 */
76 osize = size = le16_to_cpu(kfib->header.Size) +
77 sizeof(struct aac_fibhdr);
78 if (size < le16_to_cpu(kfib->header.SenderSize))
79 size = le16_to_cpu(kfib->header.SenderSize);
80 if (size > dev->max_fib_size) {
81 dma_addr_t daddr;
82
83 if (size > 2048) {
84 retval = -EINVAL;
85 goto cleanup;
86 }
87
88 kfib = dma_alloc_coherent(&dev->pdev->dev, size, &daddr,
89 GFP_KERNEL);
90 if (!kfib) {
91 retval = -ENOMEM;
92 goto cleanup;
93 }
94
95 /* Highjack the hw_fib */
96 hw_fib = fibptr->hw_fib_va;
97 hw_fib_pa = fibptr->hw_fib_pa;
98 fibptr->hw_fib_va = kfib;
99 fibptr->hw_fib_pa = daddr;
100 memset(((char *)kfib) + dev->max_fib_size, 0, size - dev->max_fib_size);
101 memcpy(kfib, hw_fib, dev->max_fib_size);
102 }
103
104 if (copy_from_user(kfib, arg, size)) {
105 retval = -EFAULT;
106 goto cleanup;
107 }
108
109 /* Sanity check the second copy */
110 if ((osize != le16_to_cpu(kfib->header.Size) +
111 sizeof(struct aac_fibhdr))
112 || (size < le16_to_cpu(kfib->header.SenderSize))) {
113 retval = -EINVAL;
114 goto cleanup;
115 }
116
117 if (kfib->header.Command == cpu_to_le16(TakeABreakPt)) {
118 aac_adapter_interrupt(dev);
119 /*
120 * Since we didn't really send a fib, zero out the state to allow
121 * cleanup code not to assert.
122 */
123 kfib->header.XferState = 0;
124 } else {
125 retval = aac_fib_send(le16_to_cpu(kfib->header.Command), fibptr,
126 le16_to_cpu(kfib->header.Size) , FsaNormal,
127 1, 1, NULL, NULL);
128 if (retval) {
129 goto cleanup;
130 }
131 if (aac_fib_complete(fibptr) != 0) {
132 retval = -EINVAL;
133 goto cleanup;
134 }
135 }
136 /*
137 * Make sure that the size returned by the adapter (which includes
138 * the header) is less than or equal to the size of a fib, so we
139 * don't corrupt application data. Then copy that size to the user
140 * buffer. (Don't try to add the header information again, since it
141 * was already included by the adapter.)
142 */
143
144 retval = 0;
145 if (copy_to_user(arg, (void *)kfib, size))
146 retval = -EFAULT;
147cleanup:
148 if (hw_fib) {
149 dma_free_coherent(&dev->pdev->dev, size, kfib,
150 fibptr->hw_fib_pa);
151 fibptr->hw_fib_pa = hw_fib_pa;
152 fibptr->hw_fib_va = hw_fib;
153 }
154 if (retval != -ERESTARTSYS)
155 aac_fib_free(fibptr);
156 return retval;
157}
158
159/**
160 * open_getadapter_fib - Get the next fib
161 *
162 * This routine will get the next Fib, if available, from the AdapterFibContext
163 * passed in from the user.
164 */
165
166static int open_getadapter_fib(struct aac_dev * dev, void __user *arg)
167{
168 struct aac_fib_context * fibctx;
169 int status;
170
171 fibctx = kmalloc(sizeof(struct aac_fib_context), GFP_KERNEL);
172 if (fibctx == NULL) {
173 status = -ENOMEM;
174 } else {
175 unsigned long flags;
176 struct list_head * entry;
177 struct aac_fib_context * context;
178
179 fibctx->type = FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT;
180 fibctx->size = sizeof(struct aac_fib_context);
181 /*
182 * Yes yes, I know this could be an index, but we have a
183 * better guarantee of uniqueness for the locked loop below.
184 * Without the aid of a persistent history, this also helps
185 * reduce the chance that the opaque context would be reused.
186 */
187 fibctx->unique = (u32)((ulong)fibctx & 0xFFFFFFFF);
188 /*
189 * Initialize the mutex used to wait for the next AIF.
190 */
191 init_completion(&fibctx->completion);
192 fibctx->wait = 0;
193 /*
194 * Initialize the fibs and set the count of fibs on
195 * the list to 0.
196 */
197 fibctx->count = 0;
198 INIT_LIST_HEAD(&fibctx->fib_list);
199 fibctx->jiffies = jiffies/HZ;
200 /*
201 * Now add this context onto the adapter's
202 * AdapterFibContext list.
203 */
204 spin_lock_irqsave(&dev->fib_lock, flags);
205 /* Ensure that we have a unique identifier */
206 entry = dev->fib_list.next;
207 while (entry != &dev->fib_list) {
208 context = list_entry(entry, struct aac_fib_context, next);
209 if (context->unique == fibctx->unique) {
210 /* Not unique (32 bits) */
211 fibctx->unique++;
212 entry = dev->fib_list.next;
213 } else {
214 entry = entry->next;
215 }
216 }
217 list_add_tail(&fibctx->next, &dev->fib_list);
218 spin_unlock_irqrestore(&dev->fib_lock, flags);
219 if (copy_to_user(arg, &fibctx->unique,
220 sizeof(fibctx->unique))) {
221 status = -EFAULT;
222 } else {
223 status = 0;
224 }
225 }
226 return status;
227}
228
229/**
230 * next_getadapter_fib - get the next fib
231 * @dev: adapter to use
232 * @arg: ioctl argument
233 *
234 * This routine will get the next Fib, if available, from the AdapterFibContext
235 * passed in from the user.
236 */
237
238static int next_getadapter_fib(struct aac_dev * dev, void __user *arg)
239{
240 struct fib_ioctl f;
241 struct fib *fib;
242 struct aac_fib_context *fibctx;
243 int status;
244 struct list_head * entry;
245 unsigned long flags;
246
247 if(copy_from_user((void *)&f, arg, sizeof(struct fib_ioctl)))
248 return -EFAULT;
249 /*
250 * Verify that the HANDLE passed in was a valid AdapterFibContext
251 *
252 * Search the list of AdapterFibContext addresses on the adapter
253 * to be sure this is a valid address
254 */
255 spin_lock_irqsave(&dev->fib_lock, flags);
256 entry = dev->fib_list.next;
257 fibctx = NULL;
258
259 while (entry != &dev->fib_list) {
260 fibctx = list_entry(entry, struct aac_fib_context, next);
261 /*
262 * Extract the AdapterFibContext from the Input parameters.
263 */
264 if (fibctx->unique == f.fibctx) { /* We found a winner */
265 break;
266 }
267 entry = entry->next;
268 fibctx = NULL;
269 }
270 if (!fibctx) {
271 spin_unlock_irqrestore(&dev->fib_lock, flags);
272 dprintk ((KERN_INFO "Fib Context not found\n"));
273 return -EINVAL;
274 }
275
276 if((fibctx->type != FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT) ||
277 (fibctx->size != sizeof(struct aac_fib_context))) {
278 spin_unlock_irqrestore(&dev->fib_lock, flags);
279 dprintk ((KERN_INFO "Fib Context corrupt?\n"));
280 return -EINVAL;
281 }
282 status = 0;
283 /*
284 * If there are no fibs to send back, then either wait or return
285 * -EAGAIN
286 */
287return_fib:
288 if (!list_empty(&fibctx->fib_list)) {
289 /*
290 * Pull the next fib from the fibs
291 */
292 entry = fibctx->fib_list.next;
293 list_del(entry);
294
295 fib = list_entry(entry, struct fib, fiblink);
296 fibctx->count--;
297 spin_unlock_irqrestore(&dev->fib_lock, flags);
298 if (copy_to_user(f.fib, fib->hw_fib_va, sizeof(struct hw_fib))) {
299 kfree(fib->hw_fib_va);
300 kfree(fib);
301 return -EFAULT;
302 }
303 /*
304 * Free the space occupied by this copy of the fib.
305 */
306 kfree(fib->hw_fib_va);
307 kfree(fib);
308 status = 0;
309 } else {
310 spin_unlock_irqrestore(&dev->fib_lock, flags);
311 /* If someone killed the AIF aacraid thread, restart it */
312 status = !dev->aif_thread;
313 if (status && !dev->in_reset && dev->queues && dev->fsa_dev) {
314 /* Be paranoid, be very paranoid! */
315 kthread_stop(dev->thread);
316 ssleep(1);
317 dev->aif_thread = 0;
318 dev->thread = kthread_run(aac_command_thread, dev,
319 "%s", dev->name);
320 ssleep(1);
321 }
322 if (f.wait) {
323 if (wait_for_completion_interruptible(&fibctx->completion) < 0) {
324 status = -ERESTARTSYS;
325 } else {
326 /* Lock again and retry */
327 spin_lock_irqsave(&dev->fib_lock, flags);
328 goto return_fib;
329 }
330 } else {
331 status = -EAGAIN;
332 }
333 }
334 fibctx->jiffies = jiffies/HZ;
335 return status;
336}
337
338int aac_close_fib_context(struct aac_dev * dev, struct aac_fib_context * fibctx)
339{
340 struct fib *fib;
341
342 /*
343 * First free any FIBs that have not been consumed.
344 */
345 while (!list_empty(&fibctx->fib_list)) {
346 struct list_head * entry;
347 /*
348 * Pull the next fib from the fibs
349 */
350 entry = fibctx->fib_list.next;
351 list_del(entry);
352 fib = list_entry(entry, struct fib, fiblink);
353 fibctx->count--;
354 /*
355 * Free the space occupied by this copy of the fib.
356 */
357 kfree(fib->hw_fib_va);
358 kfree(fib);
359 }
360 /*
361 * Remove the Context from the AdapterFibContext List
362 */
363 list_del(&fibctx->next);
364 /*
365 * Invalidate context
366 */
367 fibctx->type = 0;
368 /*
369 * Free the space occupied by the Context
370 */
371 kfree(fibctx);
372 return 0;
373}
374
375/**
376 * close_getadapter_fib - close down user fib context
377 * @dev: adapter
378 * @arg: ioctl arguments
379 *
380 * This routine will close down the fibctx passed in from the user.
381 */
382
383static int close_getadapter_fib(struct aac_dev * dev, void __user *arg)
384{
385 struct aac_fib_context *fibctx;
386 int status;
387 unsigned long flags;
388 struct list_head * entry;
389
390 /*
391 * Verify that the HANDLE passed in was a valid AdapterFibContext
392 *
393 * Search the list of AdapterFibContext addresses on the adapter
394 * to be sure this is a valid address
395 */
396
397 entry = dev->fib_list.next;
398 fibctx = NULL;
399
400 while(entry != &dev->fib_list) {
401 fibctx = list_entry(entry, struct aac_fib_context, next);
402 /*
403 * Extract the fibctx from the input parameters
404 */
405 if (fibctx->unique == (u32)(uintptr_t)arg) /* We found a winner */
406 break;
407 entry = entry->next;
408 fibctx = NULL;
409 }
410
411 if (!fibctx)
412 return 0; /* Already gone */
413
414 if((fibctx->type != FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT) ||
415 (fibctx->size != sizeof(struct aac_fib_context)))
416 return -EINVAL;
417 spin_lock_irqsave(&dev->fib_lock, flags);
418 status = aac_close_fib_context(dev, fibctx);
419 spin_unlock_irqrestore(&dev->fib_lock, flags);
420 return status;
421}
422
423/**
424 * check_revision - close down user fib context
425 * @dev: adapter
426 * @arg: ioctl arguments
427 *
428 * This routine returns the driver version.
429 * Under Linux, there have been no version incompatibilities, so this is
430 * simple!
431 */
432
433static int check_revision(struct aac_dev *dev, void __user *arg)
434{
435 struct revision response;
436 char *driver_version = aac_driver_version;
437 u32 version;
438
439 response.compat = 1;
440 version = (simple_strtol(driver_version,
441 &driver_version, 10) << 24) | 0x00000400;
442 version += simple_strtol(driver_version + 1, &driver_version, 10) << 16;
443 version += simple_strtol(driver_version + 1, NULL, 10);
444 response.version = cpu_to_le32(version);
445# ifdef AAC_DRIVER_BUILD
446 response.build = cpu_to_le32(AAC_DRIVER_BUILD);
447# else
448 response.build = cpu_to_le32(9999);
449# endif
450
451 if (copy_to_user(arg, &response, sizeof(response)))
452 return -EFAULT;
453 return 0;
454}
455
456
457/**
458 *
459 * aac_send_raw_scb
460 *
461 */
462
463static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
464{
465 struct fib* srbfib;
466 int status;
467 struct aac_srb *srbcmd = NULL;
468 struct aac_hba_cmd_req *hbacmd = NULL;
469 struct user_aac_srb *user_srbcmd = NULL;
470 struct user_aac_srb __user *user_srb = arg;
471 struct aac_srb_reply __user *user_reply;
472 u32 chn;
473 u32 fibsize = 0;
474 u32 flags = 0;
475 s32 rcode = 0;
476 u32 data_dir;
477 void __user *sg_user[HBA_MAX_SG_EMBEDDED];
478 void *sg_list[HBA_MAX_SG_EMBEDDED];
479 u32 sg_count[HBA_MAX_SG_EMBEDDED];
480 u32 sg_indx = 0;
481 u32 byte_count = 0;
482 u32 actual_fibsize64, actual_fibsize = 0;
483 int i;
484 int is_native_device;
485 u64 address;
486
487
488 if (dev->in_reset) {
489 dprintk((KERN_DEBUG"aacraid: send raw srb -EBUSY\n"));
490 return -EBUSY;
491 }
492 if (!capable(CAP_SYS_ADMIN)){
493 dprintk((KERN_DEBUG"aacraid: No permission to send raw srb\n"));
494 return -EPERM;
495 }
496 /*
497 * Allocate and initialize a Fib then setup a SRB command
498 */
499 if (!(srbfib = aac_fib_alloc(dev))) {
500 return -ENOMEM;
501 }
502
503 memset(sg_list, 0, sizeof(sg_list)); /* cleanup may take issue */
504 if(copy_from_user(&fibsize, &user_srb->count,sizeof(u32))){
505 dprintk((KERN_DEBUG"aacraid: Could not copy data size from user\n"));
506 rcode = -EFAULT;
507 goto cleanup;
508 }
509
510 if ((fibsize < (sizeof(struct user_aac_srb) - sizeof(struct user_sgentry))) ||
511 (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)))) {
512 rcode = -EINVAL;
513 goto cleanup;
514 }
515
516 user_srbcmd = memdup_user(user_srb, fibsize);
517 if (IS_ERR(user_srbcmd)) {
518 rcode = PTR_ERR(user_srbcmd);
519 user_srbcmd = NULL;
520 goto cleanup;
521 }
522
523 flags = user_srbcmd->flags; /* from user in cpu order */
524 switch (flags & (SRB_DataIn | SRB_DataOut)) {
525 case SRB_DataOut:
526 data_dir = DMA_TO_DEVICE;
527 break;
528 case (SRB_DataIn | SRB_DataOut):
529 data_dir = DMA_BIDIRECTIONAL;
530 break;
531 case SRB_DataIn:
532 data_dir = DMA_FROM_DEVICE;
533 break;
534 default:
535 data_dir = DMA_NONE;
536 }
537 if (user_srbcmd->sg.count > ARRAY_SIZE(sg_list)) {
538 dprintk((KERN_DEBUG"aacraid: too many sg entries %d\n",
539 user_srbcmd->sg.count));
540 rcode = -EINVAL;
541 goto cleanup;
542 }
543 if ((data_dir == DMA_NONE) && user_srbcmd->sg.count) {
544 dprintk((KERN_DEBUG"aacraid:SG with no direction specified\n"));
545 rcode = -EINVAL;
546 goto cleanup;
547 }
548 actual_fibsize = sizeof(struct aac_srb) - sizeof(struct sgentry) +
549 ((user_srbcmd->sg.count & 0xff) * sizeof(struct sgentry));
550 actual_fibsize64 = actual_fibsize + (user_srbcmd->sg.count & 0xff) *
551 (sizeof(struct sgentry64) - sizeof(struct sgentry));
552 /* User made a mistake - should not continue */
553 if ((actual_fibsize != fibsize) && (actual_fibsize64 != fibsize)) {
554 dprintk((KERN_DEBUG"aacraid: Bad Size specified in "
555 "Raw SRB command calculated fibsize=%lu;%lu "
556 "user_srbcmd->sg.count=%d aac_srb=%lu sgentry=%lu;%lu "
557 "issued fibsize=%d\n",
558 actual_fibsize, actual_fibsize64, user_srbcmd->sg.count,
559 sizeof(struct aac_srb), sizeof(struct sgentry),
560 sizeof(struct sgentry64), fibsize));
561 rcode = -EINVAL;
562 goto cleanup;
563 }
564
565 chn = user_srbcmd->channel;
566 if (chn < AAC_MAX_BUSES && user_srbcmd->id < AAC_MAX_TARGETS &&
567 dev->hba_map[chn][user_srbcmd->id].devtype ==
568 AAC_DEVTYPE_NATIVE_RAW) {
569 is_native_device = 1;
570 hbacmd = (struct aac_hba_cmd_req *)srbfib->hw_fib_va;
571 memset(hbacmd, 0, 96); /* sizeof(*hbacmd) is not necessary */
572
573 /* iu_type is a parameter of aac_hba_send */
574 switch (data_dir) {
575 case DMA_TO_DEVICE:
576 hbacmd->byte1 = 2;
577 break;
578 case DMA_FROM_DEVICE:
579 case DMA_BIDIRECTIONAL:
580 hbacmd->byte1 = 1;
581 break;
582 case DMA_NONE:
583 default:
584 break;
585 }
586 hbacmd->lun[1] = cpu_to_le32(user_srbcmd->lun);
587 hbacmd->it_nexus = dev->hba_map[chn][user_srbcmd->id].rmw_nexus;
588
589 /*
590 * we fill in reply_qid later in aac_src_deliver_message
591 * we fill in iu_type, request_id later in aac_hba_send
592 * we fill in emb_data_desc_count, data_length later
593 * in sg list build
594 */
595
596 memcpy(hbacmd->cdb, user_srbcmd->cdb, sizeof(hbacmd->cdb));
597
598 address = (u64)srbfib->hw_error_pa;
599 hbacmd->error_ptr_hi = cpu_to_le32((u32)(address >> 32));
600 hbacmd->error_ptr_lo = cpu_to_le32((u32)(address & 0xffffffff));
601 hbacmd->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE);
602 hbacmd->emb_data_desc_count =
603 cpu_to_le32(user_srbcmd->sg.count);
604 srbfib->hbacmd_size = 64 +
605 user_srbcmd->sg.count * sizeof(struct aac_hba_sgl);
606
607 } else {
608 is_native_device = 0;
609 aac_fib_init(srbfib);
610
611 /* raw_srb FIB is not FastResponseCapable */
612 srbfib->hw_fib_va->header.XferState &=
613 ~cpu_to_le32(FastResponseCapable);
614
615 srbcmd = (struct aac_srb *) fib_data(srbfib);
616
617 // Fix up srb for endian and force some values
618
619 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); // Force this
620 srbcmd->channel = cpu_to_le32(user_srbcmd->channel);
621 srbcmd->id = cpu_to_le32(user_srbcmd->id);
622 srbcmd->lun = cpu_to_le32(user_srbcmd->lun);
623 srbcmd->timeout = cpu_to_le32(user_srbcmd->timeout);
624 srbcmd->flags = cpu_to_le32(flags);
625 srbcmd->retry_limit = 0; // Obsolete parameter
626 srbcmd->cdb_size = cpu_to_le32(user_srbcmd->cdb_size);
627 memcpy(srbcmd->cdb, user_srbcmd->cdb, sizeof(srbcmd->cdb));
628 }
629
630 byte_count = 0;
631 if (is_native_device) {
632 struct user_sgmap *usg32 = &user_srbcmd->sg;
633 struct user_sgmap64 *usg64 =
634 (struct user_sgmap64 *)&user_srbcmd->sg;
635
636 for (i = 0; i < usg32->count; i++) {
637 void *p;
638 u64 addr;
639
640 sg_count[i] = (actual_fibsize64 == fibsize) ?
641 usg64->sg[i].count : usg32->sg[i].count;
642 if (sg_count[i] >
643 (dev->scsi_host_ptr->max_sectors << 9)) {
644 pr_err("aacraid: upsg->sg[%d].count=%u>%u\n",
645 i, sg_count[i],
646 dev->scsi_host_ptr->max_sectors << 9);
647 rcode = -EINVAL;
648 goto cleanup;
649 }
650
651 p = kmalloc(sg_count[i], GFP_KERNEL);
652 if (!p) {
653 rcode = -ENOMEM;
654 goto cleanup;
655 }
656
657 if (actual_fibsize64 == fibsize) {
658 addr = (u64)usg64->sg[i].addr[0];
659 addr += ((u64)usg64->sg[i].addr[1]) << 32;
660 } else {
661 addr = (u64)usg32->sg[i].addr;
662 }
663
664 sg_user[i] = (void __user *)(uintptr_t)addr;
665 sg_list[i] = p; // save so we can clean up later
666 sg_indx = i;
667
668 if (flags & SRB_DataOut) {
669 if (copy_from_user(p, sg_user[i],
670 sg_count[i])) {
671 rcode = -EFAULT;
672 goto cleanup;
673 }
674 }
675 addr = pci_map_single(dev->pdev, p, sg_count[i],
676 data_dir);
677 hbacmd->sge[i].addr_hi = cpu_to_le32((u32)(addr>>32));
678 hbacmd->sge[i].addr_lo = cpu_to_le32(
679 (u32)(addr & 0xffffffff));
680 hbacmd->sge[i].len = cpu_to_le32(sg_count[i]);
681 hbacmd->sge[i].flags = 0;
682 byte_count += sg_count[i];
683 }
684
685 if (usg32->count > 0) /* embedded sglist */
686 hbacmd->sge[usg32->count-1].flags =
687 cpu_to_le32(0x40000000);
688 hbacmd->data_length = cpu_to_le32(byte_count);
689
690 status = aac_hba_send(HBA_IU_TYPE_SCSI_CMD_REQ, srbfib,
691 NULL, NULL);
692
693 } else if (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64) {
694 struct user_sgmap64* upsg = (struct user_sgmap64*)&user_srbcmd->sg;
695 struct sgmap64* psg = (struct sgmap64*)&srbcmd->sg;
696
697 /*
698 * This should also catch if user used the 32 bit sgmap
699 */
700 if (actual_fibsize64 == fibsize) {
701 actual_fibsize = actual_fibsize64;
702 for (i = 0; i < upsg->count; i++) {
703 u64 addr;
704 void* p;
705
706 sg_count[i] = upsg->sg[i].count;
707 if (sg_count[i] >
708 ((dev->adapter_info.options &
709 AAC_OPT_NEW_COMM) ?
710 (dev->scsi_host_ptr->max_sectors << 9) :
711 65536)) {
712 rcode = -EINVAL;
713 goto cleanup;
714 }
715
716 p = kmalloc(sg_count[i], GFP_KERNEL);
717 if(!p) {
718 dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
719 sg_count[i], i, upsg->count));
720 rcode = -ENOMEM;
721 goto cleanup;
722 }
723 addr = (u64)upsg->sg[i].addr[0];
724 addr += ((u64)upsg->sg[i].addr[1]) << 32;
725 sg_user[i] = (void __user *)(uintptr_t)addr;
726 sg_list[i] = p; // save so we can clean up later
727 sg_indx = i;
728
729 if (flags & SRB_DataOut) {
730 if (copy_from_user(p, sg_user[i],
731 sg_count[i])){
732 dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
733 rcode = -EFAULT;
734 goto cleanup;
735 }
736 }
737 addr = pci_map_single(dev->pdev, p,
738 sg_count[i], data_dir);
739
740 psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
741 psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
742 byte_count += sg_count[i];
743 psg->sg[i].count = cpu_to_le32(sg_count[i]);
744 }
745 } else {
746 struct user_sgmap* usg;
747 usg = kmemdup(upsg,
748 actual_fibsize - sizeof(struct aac_srb)
749 + sizeof(struct sgmap), GFP_KERNEL);
750 if (!usg) {
751 dprintk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
752 rcode = -ENOMEM;
753 goto cleanup;
754 }
755 actual_fibsize = actual_fibsize64;
756
757 for (i = 0; i < usg->count; i++) {
758 u64 addr;
759 void* p;
760
761 sg_count[i] = usg->sg[i].count;
762 if (sg_count[i] >
763 ((dev->adapter_info.options &
764 AAC_OPT_NEW_COMM) ?
765 (dev->scsi_host_ptr->max_sectors << 9) :
766 65536)) {
767 kfree(usg);
768 rcode = -EINVAL;
769 goto cleanup;
770 }
771
772 p = kmalloc(sg_count[i], GFP_KERNEL);
773 if(!p) {
774 dprintk((KERN_DEBUG "aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
775 sg_count[i], i, usg->count));
776 kfree(usg);
777 rcode = -ENOMEM;
778 goto cleanup;
779 }
780 sg_user[i] = (void __user *)(uintptr_t)usg->sg[i].addr;
781 sg_list[i] = p; // save so we can clean up later
782 sg_indx = i;
783
784 if (flags & SRB_DataOut) {
785 if (copy_from_user(p, sg_user[i],
786 sg_count[i])) {
787 kfree (usg);
788 dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
789 rcode = -EFAULT;
790 goto cleanup;
791 }
792 }
793 addr = pci_map_single(dev->pdev, p,
794 sg_count[i], data_dir);
795
796 psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
797 psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
798 byte_count += sg_count[i];
799 psg->sg[i].count = cpu_to_le32(sg_count[i]);
800 }
801 kfree (usg);
802 }
803 srbcmd->count = cpu_to_le32(byte_count);
804 if (user_srbcmd->sg.count)
805 psg->count = cpu_to_le32(sg_indx+1);
806 else
807 psg->count = 0;
808 status = aac_fib_send(ScsiPortCommand64, srbfib, actual_fibsize, FsaNormal, 1, 1,NULL,NULL);
809 } else {
810 struct user_sgmap* upsg = &user_srbcmd->sg;
811 struct sgmap* psg = &srbcmd->sg;
812
813 if (actual_fibsize64 == fibsize) {
814 struct user_sgmap64* usg = (struct user_sgmap64 *)upsg;
815 for (i = 0; i < upsg->count; i++) {
816 uintptr_t addr;
817 void* p;
818
819 sg_count[i] = usg->sg[i].count;
820 if (sg_count[i] >
821 ((dev->adapter_info.options &
822 AAC_OPT_NEW_COMM) ?
823 (dev->scsi_host_ptr->max_sectors << 9) :
824 65536)) {
825 rcode = -EINVAL;
826 goto cleanup;
827 }
828 p = kmalloc(sg_count[i], GFP_KERNEL);
829 if (!p) {
830 dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
831 sg_count[i], i, usg->count));
832 rcode = -ENOMEM;
833 goto cleanup;
834 }
835 addr = (u64)usg->sg[i].addr[0];
836 addr += ((u64)usg->sg[i].addr[1]) << 32;
837 sg_user[i] = (void __user *)addr;
838 sg_list[i] = p; // save so we can clean up later
839 sg_indx = i;
840
841 if (flags & SRB_DataOut) {
842 if (copy_from_user(p, sg_user[i],
843 sg_count[i])){
844 dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
845 rcode = -EFAULT;
846 goto cleanup;
847 }
848 }
849 addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
850
851 psg->sg[i].addr = cpu_to_le32(addr & 0xffffffff);
852 byte_count += usg->sg[i].count;
853 psg->sg[i].count = cpu_to_le32(sg_count[i]);
854 }
855 } else {
856 for (i = 0; i < upsg->count; i++) {
857 dma_addr_t addr;
858 void* p;
859
860 sg_count[i] = upsg->sg[i].count;
861 if (sg_count[i] >
862 ((dev->adapter_info.options &
863 AAC_OPT_NEW_COMM) ?
864 (dev->scsi_host_ptr->max_sectors << 9) :
865 65536)) {
866 rcode = -EINVAL;
867 goto cleanup;
868 }
869 p = kmalloc(sg_count[i], GFP_KERNEL);
870 if (!p) {
871 dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
872 sg_count[i], i, upsg->count));
873 rcode = -ENOMEM;
874 goto cleanup;
875 }
876 sg_user[i] = (void __user *)(uintptr_t)upsg->sg[i].addr;
877 sg_list[i] = p; // save so we can clean up later
878 sg_indx = i;
879
880 if (flags & SRB_DataOut) {
881 if (copy_from_user(p, sg_user[i],
882 sg_count[i])) {
883 dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
884 rcode = -EFAULT;
885 goto cleanup;
886 }
887 }
888 addr = pci_map_single(dev->pdev, p,
889 sg_count[i], data_dir);
890
891 psg->sg[i].addr = cpu_to_le32(addr);
892 byte_count += sg_count[i];
893 psg->sg[i].count = cpu_to_le32(sg_count[i]);
894 }
895 }
896 srbcmd->count = cpu_to_le32(byte_count);
897 if (user_srbcmd->sg.count)
898 psg->count = cpu_to_le32(sg_indx+1);
899 else
900 psg->count = 0;
901 status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
902 }
903
904 if (status == -ERESTARTSYS) {
905 rcode = -ERESTARTSYS;
906 goto cleanup;
907 }
908
909 if (status != 0) {
910 dprintk((KERN_DEBUG"aacraid: Could not send raw srb fib to hba\n"));
911 rcode = -ENXIO;
912 goto cleanup;
913 }
914
915 if (flags & SRB_DataIn) {
916 for(i = 0 ; i <= sg_indx; i++){
917 if (copy_to_user(sg_user[i], sg_list[i], sg_count[i])) {
918 dprintk((KERN_DEBUG"aacraid: Could not copy sg data to user\n"));
919 rcode = -EFAULT;
920 goto cleanup;
921
922 }
923 }
924 }
925
926 user_reply = arg + fibsize;
927 if (is_native_device) {
928 struct aac_hba_resp *err =
929 &((struct aac_native_hba *)srbfib->hw_fib_va)->resp.err;
930 struct aac_srb_reply reply;
931
932 memset(&reply, 0, sizeof(reply));
933 reply.status = ST_OK;
934 if (srbfib->flags & FIB_CONTEXT_FLAG_FASTRESP) {
935 /* fast response */
936 reply.srb_status = SRB_STATUS_SUCCESS;
937 reply.scsi_status = 0;
938 reply.data_xfer_length = byte_count;
939 reply.sense_data_size = 0;
940 memset(reply.sense_data, 0, AAC_SENSE_BUFFERSIZE);
941 } else {
942 reply.srb_status = err->service_response;
943 reply.scsi_status = err->status;
944 reply.data_xfer_length = byte_count -
945 le32_to_cpu(err->residual_count);
946 reply.sense_data_size = err->sense_response_data_len;
947 memcpy(reply.sense_data, err->sense_response_buf,
948 AAC_SENSE_BUFFERSIZE);
949 }
950 if (copy_to_user(user_reply, &reply,
951 sizeof(struct aac_srb_reply))) {
952 dprintk((KERN_DEBUG"aacraid: Copy to user failed\n"));
953 rcode = -EFAULT;
954 goto cleanup;
955 }
956 } else {
957 struct aac_srb_reply *reply;
958
959 reply = (struct aac_srb_reply *) fib_data(srbfib);
960 if (copy_to_user(user_reply, reply,
961 sizeof(struct aac_srb_reply))) {
962 dprintk((KERN_DEBUG"aacraid: Copy to user failed\n"));
963 rcode = -EFAULT;
964 goto cleanup;
965 }
966 }
967
968cleanup:
969 kfree(user_srbcmd);
970 if (rcode != -ERESTARTSYS) {
971 for (i = 0; i <= sg_indx; i++)
972 kfree(sg_list[i]);
973 aac_fib_complete(srbfib);
974 aac_fib_free(srbfib);
975 }
976
977 return rcode;
978}
979
980struct aac_pci_info {
981 u32 bus;
982 u32 slot;
983};
984
985
986static int aac_get_pci_info(struct aac_dev* dev, void __user *arg)
987{
988 struct aac_pci_info pci_info;
989
990 pci_info.bus = dev->pdev->bus->number;
991 pci_info.slot = PCI_SLOT(dev->pdev->devfn);
992
993 if (copy_to_user(arg, &pci_info, sizeof(struct aac_pci_info))) {
994 dprintk((KERN_DEBUG "aacraid: Could not copy pci info\n"));
995 return -EFAULT;
996 }
997 return 0;
998}
999
1000static int aac_get_hba_info(struct aac_dev *dev, void __user *arg)
1001{
1002 struct aac_hba_info hbainfo;
1003
1004 memset(&hbainfo, 0, sizeof(hbainfo));
1005 hbainfo.adapter_number = (u8) dev->id;
1006 hbainfo.system_io_bus_number = dev->pdev->bus->number;
1007 hbainfo.device_number = (dev->pdev->devfn >> 3);
1008 hbainfo.function_number = (dev->pdev->devfn & 0x0007);
1009
1010 hbainfo.vendor_id = dev->pdev->vendor;
1011 hbainfo.device_id = dev->pdev->device;
1012 hbainfo.sub_vendor_id = dev->pdev->subsystem_vendor;
1013 hbainfo.sub_system_id = dev->pdev->subsystem_device;
1014
1015 if (copy_to_user(arg, &hbainfo, sizeof(struct aac_hba_info))) {
1016 dprintk((KERN_DEBUG "aacraid: Could not copy hba info\n"));
1017 return -EFAULT;
1018 }
1019
1020 return 0;
1021}
1022
1023struct aac_reset_iop {
1024 u8 reset_type;
1025};
1026
1027static int aac_send_reset_adapter(struct aac_dev *dev, void __user *arg)
1028{
1029 struct aac_reset_iop reset;
1030 int retval;
1031
1032 if (copy_from_user((void *)&reset, arg, sizeof(struct aac_reset_iop)))
1033 return -EFAULT;
1034
1035 dev->adapter_shutdown = 1;
1036
1037 mutex_unlock(&dev->ioctl_mutex);
1038 retval = aac_reset_adapter(dev, 0, reset.reset_type);
1039 mutex_lock(&dev->ioctl_mutex);
1040
1041 return retval;
1042}
1043
1044int aac_do_ioctl(struct aac_dev *dev, unsigned int cmd, void __user *arg)
1045{
1046 int status;
1047
1048 mutex_lock(&dev->ioctl_mutex);
1049
1050 if (dev->adapter_shutdown) {
1051 status = -EACCES;
1052 goto cleanup;
1053 }
1054
1055 /*
1056 * HBA gets first crack
1057 */
1058
1059 status = aac_dev_ioctl(dev, cmd, arg);
1060 if (status != -ENOTTY)
1061 goto cleanup;
1062
1063 switch (cmd) {
1064 case FSACTL_MINIPORT_REV_CHECK:
1065 status = check_revision(dev, arg);
1066 break;
1067 case FSACTL_SEND_LARGE_FIB:
1068 case FSACTL_SENDFIB:
1069 status = ioctl_send_fib(dev, arg);
1070 break;
1071 case FSACTL_OPEN_GET_ADAPTER_FIB:
1072 status = open_getadapter_fib(dev, arg);
1073 break;
1074 case FSACTL_GET_NEXT_ADAPTER_FIB:
1075 status = next_getadapter_fib(dev, arg);
1076 break;
1077 case FSACTL_CLOSE_GET_ADAPTER_FIB:
1078 status = close_getadapter_fib(dev, arg);
1079 break;
1080 case FSACTL_SEND_RAW_SRB:
1081 status = aac_send_raw_srb(dev,arg);
1082 break;
1083 case FSACTL_GET_PCI_INFO:
1084 status = aac_get_pci_info(dev,arg);
1085 break;
1086 case FSACTL_GET_HBA_INFO:
1087 status = aac_get_hba_info(dev, arg);
1088 break;
1089 case FSACTL_RESET_IOP:
1090 status = aac_send_reset_adapter(dev, arg);
1091 break;
1092
1093 default:
1094 status = -ENOTTY;
1095 break;
1096 }
1097
1098cleanup:
1099 mutex_unlock(&dev->ioctl_mutex);
1100
1101 return status;
1102}
1103