1c82ee6d3SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * Adaptec AAC series RAID controller driver
4fa195afeSAlan Cox * (c) Copyright 2001 Red Hat Inc.
51da177e4SLinus Torvalds *
61da177e4SLinus Torvalds * based on the old aacraid driver that is..
71da177e4SLinus Torvalds * Adaptec aacraid device driver for Linux.
81da177e4SLinus Torvalds *
9e8b12f0fSMahesh Rajashekhara * Copyright (c) 2000-2010 Adaptec, Inc.
10f4babba0SRaghava Aditya Renukunta * 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
11f4babba0SRaghava Aditya Renukunta * 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
121da177e4SLinus Torvalds *
131da177e4SLinus Torvalds * Module Name:
141da177e4SLinus Torvalds * commctrl.c
151da177e4SLinus Torvalds *
161da177e4SLinus Torvalds * Abstract: Contains all routines for control of the AFA comm layer
171da177e4SLinus Torvalds */
181da177e4SLinus Torvalds
191da177e4SLinus Torvalds #include <linux/kernel.h>
201da177e4SLinus Torvalds #include <linux/init.h>
211da177e4SLinus Torvalds #include <linux/types.h>
221da177e4SLinus Torvalds #include <linux/pci.h>
231da177e4SLinus Torvalds #include <linux/spinlock.h>
241da177e4SLinus Torvalds #include <linux/slab.h>
251da177e4SLinus Torvalds #include <linux/completion.h>
261da177e4SLinus Torvalds #include <linux/dma-mapping.h>
271da177e4SLinus Torvalds #include <linux/blkdev.h>
2807705421SArnd Bergmann #include <linux/compat.h>
29c8f7b073SMark Haverkamp #include <linux/delay.h> /* ssleep prototype */
30dc4adbf4SMark Haverkamp #include <linux/kthread.h>
317c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
3209050715SMark Salyzyn #include <scsi/scsi_host.h>
331da177e4SLinus Torvalds
341da177e4SLinus Torvalds #include "aacraid.h"
351da177e4SLinus Torvalds
36cf93fffaSLee Jones # define AAC_DEBUG_PREAMBLE KERN_INFO
37cf93fffaSLee Jones # define AAC_DEBUG_POSTAMBLE
381da177e4SLinus Torvalds /**
391da177e4SLinus Torvalds * ioctl_send_fib - send a FIB from userspace
401da177e4SLinus Torvalds * @dev: adapter is being processed
411da177e4SLinus Torvalds * @arg: arguments to the ioctl call
421da177e4SLinus Torvalds *
431da177e4SLinus Torvalds * This routine sends a fib to the adapter on behalf of a user level
441da177e4SLinus Torvalds * program.
451da177e4SLinus Torvalds */
ioctl_send_fib(struct aac_dev * dev,void __user * arg)461da177e4SLinus Torvalds static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
471da177e4SLinus Torvalds {
481da177e4SLinus Torvalds struct hw_fib * kfib;
491da177e4SLinus Torvalds struct fib *fibptr;
507c00ffa3SMark Haverkamp struct hw_fib * hw_fib = (struct hw_fib *)0;
517c00ffa3SMark Haverkamp dma_addr_t hw_fib_pa = (dma_addr_t)0LL;
52fa00c437SDave Carroll unsigned int size, osize;
537c00ffa3SMark Haverkamp int retval;
541da177e4SLinus Torvalds
5533bb3b29SMark Haverkamp if (dev->in_reset) {
5633bb3b29SMark Haverkamp return -EBUSY;
5733bb3b29SMark Haverkamp }
58bfb35aa8SMark Haverkamp fibptr = aac_fib_alloc(dev);
597c00ffa3SMark Haverkamp if(fibptr == NULL) {
601da177e4SLinus Torvalds return -ENOMEM;
617c00ffa3SMark Haverkamp }
621da177e4SLinus Torvalds
63a8166a52SMark Haverkamp kfib = fibptr->hw_fib_va;
641da177e4SLinus Torvalds /*
651da177e4SLinus Torvalds * First copy in the header so that we can check the size field.
661da177e4SLinus Torvalds */
671da177e4SLinus Torvalds if (copy_from_user((void *)kfib, arg, sizeof(struct aac_fibhdr))) {
68bfb35aa8SMark Haverkamp aac_fib_free(fibptr);
691da177e4SLinus Torvalds return -EFAULT;
701da177e4SLinus Torvalds }
711da177e4SLinus Torvalds /*
721da177e4SLinus Torvalds * Since we copy based on the fib header size, make sure that we
731da177e4SLinus Torvalds * will not overrun the buffer when we copy the memory. Return
741da177e4SLinus Torvalds * an error if we would.
751da177e4SLinus Torvalds */
76fa00c437SDave Carroll osize = size = le16_to_cpu(kfib->header.Size) +
77fa00c437SDave Carroll sizeof(struct aac_fibhdr);
787c00ffa3SMark Haverkamp if (size < le16_to_cpu(kfib->header.SenderSize))
797c00ffa3SMark Haverkamp size = le16_to_cpu(kfib->header.SenderSize);
807c00ffa3SMark Haverkamp if (size > dev->max_fib_size) {
81e9899113SFUJITA Tomonori dma_addr_t daddr;
82e9899113SFUJITA Tomonori
836e289a90SMark Haverkamp if (size > 2048) {
846e289a90SMark Haverkamp retval = -EINVAL;
856e289a90SMark Haverkamp goto cleanup;
866e289a90SMark Haverkamp }
87e9899113SFUJITA Tomonori
88f481973dSMahesh Rajashekhara kfib = dma_alloc_coherent(&dev->pdev->dev, size, &daddr,
89f481973dSMahesh Rajashekhara GFP_KERNEL);
90e9899113SFUJITA Tomonori if (!kfib) {
91e9899113SFUJITA Tomonori retval = -ENOMEM;
92e9899113SFUJITA Tomonori goto cleanup;
93e9899113SFUJITA Tomonori }
94e9899113SFUJITA Tomonori
957c00ffa3SMark Haverkamp /* Highjack the hw_fib */
96a8166a52SMark Haverkamp hw_fib = fibptr->hw_fib_va;
977c00ffa3SMark Haverkamp hw_fib_pa = fibptr->hw_fib_pa;
98e9899113SFUJITA Tomonori fibptr->hw_fib_va = kfib;
99e9899113SFUJITA Tomonori fibptr->hw_fib_pa = daddr;
1007c00ffa3SMark Haverkamp memset(((char *)kfib) + dev->max_fib_size, 0, size - dev->max_fib_size);
1017c00ffa3SMark Haverkamp memcpy(kfib, hw_fib, dev->max_fib_size);
1021da177e4SLinus Torvalds }
1031da177e4SLinus Torvalds
1047c00ffa3SMark Haverkamp if (copy_from_user(kfib, arg, size)) {
1057c00ffa3SMark Haverkamp retval = -EFAULT;
1067c00ffa3SMark Haverkamp goto cleanup;
1071da177e4SLinus Torvalds }
1081da177e4SLinus Torvalds
109fa00c437SDave Carroll /* Sanity check the second copy */
110fa00c437SDave Carroll if ((osize != le16_to_cpu(kfib->header.Size) +
111fa00c437SDave Carroll sizeof(struct aac_fibhdr))
112fa00c437SDave Carroll || (size < le16_to_cpu(kfib->header.SenderSize))) {
113fa00c437SDave Carroll retval = -EINVAL;
114fa00c437SDave Carroll goto cleanup;
115fa00c437SDave Carroll }
116fa00c437SDave Carroll
11756b58712SMark Haverkamp if (kfib->header.Command == cpu_to_le16(TakeABreakPt)) {
1181da177e4SLinus Torvalds aac_adapter_interrupt(dev);
1191da177e4SLinus Torvalds /*
1201da177e4SLinus Torvalds * Since we didn't really send a fib, zero out the state to allow
1211da177e4SLinus Torvalds * cleanup code not to assert.
1221da177e4SLinus Torvalds */
1231da177e4SLinus Torvalds kfib->header.XferState = 0;
1241da177e4SLinus Torvalds } else {
125bfb35aa8SMark Haverkamp retval = aac_fib_send(le16_to_cpu(kfib->header.Command), fibptr,
1261da177e4SLinus Torvalds le16_to_cpu(kfib->header.Size) , FsaNormal,
1271da177e4SLinus Torvalds 1, 1, NULL, NULL);
1281da177e4SLinus Torvalds if (retval) {
1297c00ffa3SMark Haverkamp goto cleanup;
1301da177e4SLinus Torvalds }
131bfb35aa8SMark Haverkamp if (aac_fib_complete(fibptr) != 0) {
1327c00ffa3SMark Haverkamp retval = -EINVAL;
1337c00ffa3SMark Haverkamp goto cleanup;
1341da177e4SLinus Torvalds }
1351da177e4SLinus Torvalds }
1361da177e4SLinus Torvalds /*
1371da177e4SLinus Torvalds * Make sure that the size returned by the adapter (which includes
1381da177e4SLinus Torvalds * the header) is less than or equal to the size of a fib, so we
1391da177e4SLinus Torvalds * don't corrupt application data. Then copy that size to the user
1401da177e4SLinus Torvalds * buffer. (Don't try to add the header information again, since it
1411da177e4SLinus Torvalds * was already included by the adapter.)
1421da177e4SLinus Torvalds */
1431da177e4SLinus Torvalds
1447c00ffa3SMark Haverkamp retval = 0;
1457c00ffa3SMark Haverkamp if (copy_to_user(arg, (void *)kfib, size))
1467c00ffa3SMark Haverkamp retval = -EFAULT;
1477c00ffa3SMark Haverkamp cleanup:
1487c00ffa3SMark Haverkamp if (hw_fib) {
149f481973dSMahesh Rajashekhara dma_free_coherent(&dev->pdev->dev, size, kfib,
150f481973dSMahesh Rajashekhara fibptr->hw_fib_pa);
1517c00ffa3SMark Haverkamp fibptr->hw_fib_pa = hw_fib_pa;
152a8166a52SMark Haverkamp fibptr->hw_fib_va = hw_fib;
1531da177e4SLinus Torvalds }
154cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (retval != -ERESTARTSYS)
155bfb35aa8SMark Haverkamp aac_fib_free(fibptr);
1567c00ffa3SMark Haverkamp return retval;
1571da177e4SLinus Torvalds }
1581da177e4SLinus Torvalds
1591da177e4SLinus Torvalds /**
1601da177e4SLinus Torvalds * open_getadapter_fib - Get the next fib
161cf93fffaSLee Jones * @dev: adapter is being processed
162cf93fffaSLee Jones * @arg: arguments to the open call
1631da177e4SLinus Torvalds *
1641da177e4SLinus Torvalds * This routine will get the next Fib, if available, from the AdapterFibContext
1651da177e4SLinus Torvalds * passed in from the user.
1661da177e4SLinus Torvalds */
open_getadapter_fib(struct aac_dev * dev,void __user * arg)1671da177e4SLinus Torvalds static int open_getadapter_fib(struct aac_dev * dev, void __user *arg)
1681da177e4SLinus Torvalds {
1691da177e4SLinus Torvalds struct aac_fib_context * fibctx;
1701da177e4SLinus Torvalds int status;
1711da177e4SLinus Torvalds
1721da177e4SLinus Torvalds fibctx = kmalloc(sizeof(struct aac_fib_context), GFP_KERNEL);
1731da177e4SLinus Torvalds if (fibctx == NULL) {
1741da177e4SLinus Torvalds status = -ENOMEM;
1751da177e4SLinus Torvalds } else {
1761da177e4SLinus Torvalds unsigned long flags;
1771da177e4SLinus Torvalds struct list_head * entry;
1781da177e4SLinus Torvalds struct aac_fib_context * context;
1791da177e4SLinus Torvalds
1801da177e4SLinus Torvalds fibctx->type = FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT;
1811da177e4SLinus Torvalds fibctx->size = sizeof(struct aac_fib_context);
1821da177e4SLinus Torvalds /*
1831da177e4SLinus Torvalds * Yes yes, I know this could be an index, but we have a
1841da177e4SLinus Torvalds * better guarantee of uniqueness for the locked loop below.
1851da177e4SLinus Torvalds * Without the aid of a persistent history, this also helps
1861da177e4SLinus Torvalds * reduce the chance that the opaque context would be reused.
1871da177e4SLinus Torvalds */
1881da177e4SLinus Torvalds fibctx->unique = (u32)((ulong)fibctx & 0xFFFFFFFF);
1891da177e4SLinus Torvalds /*
1901da177e4SLinus Torvalds * Initialize the mutex used to wait for the next AIF.
1911da177e4SLinus Torvalds */
192dc71ecccSArnd Bergmann init_completion(&fibctx->completion);
1931da177e4SLinus Torvalds fibctx->wait = 0;
1941da177e4SLinus Torvalds /*
1951da177e4SLinus Torvalds * Initialize the fibs and set the count of fibs on
1961da177e4SLinus Torvalds * the list to 0.
1971da177e4SLinus Torvalds */
1981da177e4SLinus Torvalds fibctx->count = 0;
1991da177e4SLinus Torvalds INIT_LIST_HEAD(&fibctx->fib_list);
2001da177e4SLinus Torvalds fibctx->jiffies = jiffies/HZ;
2011da177e4SLinus Torvalds /*
2021da177e4SLinus Torvalds * Now add this context onto the adapter's
2031da177e4SLinus Torvalds * AdapterFibContext list.
2041da177e4SLinus Torvalds */
2051da177e4SLinus Torvalds spin_lock_irqsave(&dev->fib_lock, flags);
2061da177e4SLinus Torvalds /* Ensure that we have a unique identifier */
2071da177e4SLinus Torvalds entry = dev->fib_list.next;
2081da177e4SLinus Torvalds while (entry != &dev->fib_list) {
2091da177e4SLinus Torvalds context = list_entry(entry, struct aac_fib_context, next);
2101da177e4SLinus Torvalds if (context->unique == fibctx->unique) {
2111da177e4SLinus Torvalds /* Not unique (32 bits) */
2121da177e4SLinus Torvalds fibctx->unique++;
2131da177e4SLinus Torvalds entry = dev->fib_list.next;
2141da177e4SLinus Torvalds } else {
2151da177e4SLinus Torvalds entry = entry->next;
2161da177e4SLinus Torvalds }
2171da177e4SLinus Torvalds }
2181da177e4SLinus Torvalds list_add_tail(&fibctx->next, &dev->fib_list);
2191da177e4SLinus Torvalds spin_unlock_irqrestore(&dev->fib_lock, flags);
2201da177e4SLinus Torvalds if (copy_to_user(arg, &fibctx->unique,
2211da177e4SLinus Torvalds sizeof(fibctx->unique))) {
2221da177e4SLinus Torvalds status = -EFAULT;
2231da177e4SLinus Torvalds } else {
2241da177e4SLinus Torvalds status = 0;
2251da177e4SLinus Torvalds }
2261da177e4SLinus Torvalds }
2271da177e4SLinus Torvalds return status;
2281da177e4SLinus Torvalds }
2291da177e4SLinus Torvalds
23007705421SArnd Bergmann struct compat_fib_ioctl {
23107705421SArnd Bergmann u32 fibctx;
23207705421SArnd Bergmann s32 wait;
23307705421SArnd Bergmann compat_uptr_t fib;
23407705421SArnd Bergmann };
23507705421SArnd Bergmann
2361da177e4SLinus Torvalds /**
2371da177e4SLinus Torvalds * next_getadapter_fib - get the next fib
2381da177e4SLinus Torvalds * @dev: adapter to use
2391da177e4SLinus Torvalds * @arg: ioctl argument
2401da177e4SLinus Torvalds *
2411da177e4SLinus Torvalds * This routine will get the next Fib, if available, from the AdapterFibContext
2421da177e4SLinus Torvalds * passed in from the user.
2431da177e4SLinus Torvalds */
next_getadapter_fib(struct aac_dev * dev,void __user * arg)2441da177e4SLinus Torvalds static int next_getadapter_fib(struct aac_dev * dev, void __user *arg)
2451da177e4SLinus Torvalds {
2461da177e4SLinus Torvalds struct fib_ioctl f;
2471da177e4SLinus Torvalds struct fib *fib;
2481da177e4SLinus Torvalds struct aac_fib_context *fibctx;
2491da177e4SLinus Torvalds int status;
2501da177e4SLinus Torvalds struct list_head * entry;
2511da177e4SLinus Torvalds unsigned long flags;
2521da177e4SLinus Torvalds
25307705421SArnd Bergmann if (in_compat_syscall()) {
25407705421SArnd Bergmann struct compat_fib_ioctl cf;
25507705421SArnd Bergmann
25607705421SArnd Bergmann if (copy_from_user(&cf, arg, sizeof(struct compat_fib_ioctl)))
2571da177e4SLinus Torvalds return -EFAULT;
25807705421SArnd Bergmann
25907705421SArnd Bergmann f.fibctx = cf.fibctx;
26007705421SArnd Bergmann f.wait = cf.wait;
26107705421SArnd Bergmann f.fib = compat_ptr(cf.fib);
26207705421SArnd Bergmann } else {
26307705421SArnd Bergmann if (copy_from_user(&f, arg, sizeof(struct fib_ioctl)))
26407705421SArnd Bergmann return -EFAULT;
26507705421SArnd Bergmann }
2661da177e4SLinus Torvalds /*
2671da177e4SLinus Torvalds * Verify that the HANDLE passed in was a valid AdapterFibContext
2681da177e4SLinus Torvalds *
2691da177e4SLinus Torvalds * Search the list of AdapterFibContext addresses on the adapter
2701da177e4SLinus Torvalds * to be sure this is a valid address
2711da177e4SLinus Torvalds */
2725234e25cSSalyzyn, Mark spin_lock_irqsave(&dev->fib_lock, flags);
2731da177e4SLinus Torvalds entry = dev->fib_list.next;
2741da177e4SLinus Torvalds fibctx = NULL;
2751da177e4SLinus Torvalds
2761da177e4SLinus Torvalds while (entry != &dev->fib_list) {
2771da177e4SLinus Torvalds fibctx = list_entry(entry, struct aac_fib_context, next);
2781da177e4SLinus Torvalds /*
2791da177e4SLinus Torvalds * Extract the AdapterFibContext from the Input parameters.
2801da177e4SLinus Torvalds */
2811da177e4SLinus Torvalds if (fibctx->unique == f.fibctx) { /* We found a winner */
2821da177e4SLinus Torvalds break;
2831da177e4SLinus Torvalds }
2841da177e4SLinus Torvalds entry = entry->next;
2851da177e4SLinus Torvalds fibctx = NULL;
2861da177e4SLinus Torvalds }
2871da177e4SLinus Torvalds if (!fibctx) {
2885234e25cSSalyzyn, Mark spin_unlock_irqrestore(&dev->fib_lock, flags);
2891da177e4SLinus Torvalds dprintk ((KERN_INFO "Fib Context not found\n"));
2901da177e4SLinus Torvalds return -EINVAL;
2911da177e4SLinus Torvalds }
2921da177e4SLinus Torvalds
2931da177e4SLinus Torvalds if((fibctx->type != FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT) ||
2941da177e4SLinus Torvalds (fibctx->size != sizeof(struct aac_fib_context))) {
2955234e25cSSalyzyn, Mark spin_unlock_irqrestore(&dev->fib_lock, flags);
2961da177e4SLinus Torvalds dprintk ((KERN_INFO "Fib Context corrupt?\n"));
2971da177e4SLinus Torvalds return -EINVAL;
2981da177e4SLinus Torvalds }
2991da177e4SLinus Torvalds status = 0;
3001da177e4SLinus Torvalds /*
3011da177e4SLinus Torvalds * If there are no fibs to send back, then either wait or return
3021da177e4SLinus Torvalds * -EAGAIN
3031da177e4SLinus Torvalds */
3041da177e4SLinus Torvalds return_fib:
3051da177e4SLinus Torvalds if (!list_empty(&fibctx->fib_list)) {
3061da177e4SLinus Torvalds /*
3071da177e4SLinus Torvalds * Pull the next fib from the fibs
3081da177e4SLinus Torvalds */
3091da177e4SLinus Torvalds entry = fibctx->fib_list.next;
3101da177e4SLinus Torvalds list_del(entry);
3111da177e4SLinus Torvalds
3121da177e4SLinus Torvalds fib = list_entry(entry, struct fib, fiblink);
3131da177e4SLinus Torvalds fibctx->count--;
3141da177e4SLinus Torvalds spin_unlock_irqrestore(&dev->fib_lock, flags);
315a8166a52SMark Haverkamp if (copy_to_user(f.fib, fib->hw_fib_va, sizeof(struct hw_fib))) {
316a8166a52SMark Haverkamp kfree(fib->hw_fib_va);
3171da177e4SLinus Torvalds kfree(fib);
3181da177e4SLinus Torvalds return -EFAULT;
3191da177e4SLinus Torvalds }
3201da177e4SLinus Torvalds /*
3211da177e4SLinus Torvalds * Free the space occupied by this copy of the fib.
3221da177e4SLinus Torvalds */
323a8166a52SMark Haverkamp kfree(fib->hw_fib_va);
3241da177e4SLinus Torvalds kfree(fib);
3251da177e4SLinus Torvalds status = 0;
3261da177e4SLinus Torvalds } else {
3271da177e4SLinus Torvalds spin_unlock_irqrestore(&dev->fib_lock, flags);
328dc4adbf4SMark Haverkamp /* If someone killed the AIF aacraid thread, restart it */
329dc4adbf4SMark Haverkamp status = !dev->aif_thread;
3308c867b25SMark Haverkamp if (status && !dev->in_reset && dev->queues && dev->fsa_dev) {
331dc4adbf4SMark Haverkamp /* Be paranoid, be very paranoid! */
332dc4adbf4SMark Haverkamp kthread_stop(dev->thread);
333dc4adbf4SMark Haverkamp ssleep(1);
334dc4adbf4SMark Haverkamp dev->aif_thread = 0;
335f170168bSKees Cook dev->thread = kthread_run(aac_command_thread, dev,
336f170168bSKees Cook "%s", dev->name);
337dc4adbf4SMark Haverkamp ssleep(1);
338dc4adbf4SMark Haverkamp }
3391da177e4SLinus Torvalds if (f.wait) {
340dc71ecccSArnd Bergmann if (wait_for_completion_interruptible(&fibctx->completion) < 0) {
341cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech status = -ERESTARTSYS;
3421da177e4SLinus Torvalds } else {
3431da177e4SLinus Torvalds /* Lock again and retry */
3441da177e4SLinus Torvalds spin_lock_irqsave(&dev->fib_lock, flags);
3451da177e4SLinus Torvalds goto return_fib;
3461da177e4SLinus Torvalds }
3471da177e4SLinus Torvalds } else {
3481da177e4SLinus Torvalds status = -EAGAIN;
3491da177e4SLinus Torvalds }
3501da177e4SLinus Torvalds }
35112a26d08SMark Haverkamp fibctx->jiffies = jiffies/HZ;
3521da177e4SLinus Torvalds return status;
3531da177e4SLinus Torvalds }
3541da177e4SLinus Torvalds
aac_close_fib_context(struct aac_dev * dev,struct aac_fib_context * fibctx)3551da177e4SLinus Torvalds int aac_close_fib_context(struct aac_dev * dev, struct aac_fib_context * fibctx)
3561da177e4SLinus Torvalds {
3571da177e4SLinus Torvalds struct fib *fib;
3581da177e4SLinus Torvalds
3591da177e4SLinus Torvalds /*
3601da177e4SLinus Torvalds * First free any FIBs that have not been consumed.
3611da177e4SLinus Torvalds */
3621da177e4SLinus Torvalds while (!list_empty(&fibctx->fib_list)) {
3631da177e4SLinus Torvalds struct list_head * entry;
3641da177e4SLinus Torvalds /*
3651da177e4SLinus Torvalds * Pull the next fib from the fibs
3661da177e4SLinus Torvalds */
3671da177e4SLinus Torvalds entry = fibctx->fib_list.next;
3681da177e4SLinus Torvalds list_del(entry);
3691da177e4SLinus Torvalds fib = list_entry(entry, struct fib, fiblink);
3701da177e4SLinus Torvalds fibctx->count--;
3711da177e4SLinus Torvalds /*
3721da177e4SLinus Torvalds * Free the space occupied by this copy of the fib.
3731da177e4SLinus Torvalds */
374a8166a52SMark Haverkamp kfree(fib->hw_fib_va);
3751da177e4SLinus Torvalds kfree(fib);
3761da177e4SLinus Torvalds }
3771da177e4SLinus Torvalds /*
3781da177e4SLinus Torvalds * Remove the Context from the AdapterFibContext List
3791da177e4SLinus Torvalds */
3801da177e4SLinus Torvalds list_del(&fibctx->next);
3811da177e4SLinus Torvalds /*
3821da177e4SLinus Torvalds * Invalidate context
3831da177e4SLinus Torvalds */
3841da177e4SLinus Torvalds fibctx->type = 0;
3851da177e4SLinus Torvalds /*
3861da177e4SLinus Torvalds * Free the space occupied by the Context
3871da177e4SLinus Torvalds */
3881da177e4SLinus Torvalds kfree(fibctx);
3891da177e4SLinus Torvalds return 0;
3901da177e4SLinus Torvalds }
3911da177e4SLinus Torvalds
3921da177e4SLinus Torvalds /**
3931da177e4SLinus Torvalds * close_getadapter_fib - close down user fib context
3941da177e4SLinus Torvalds * @dev: adapter
3951da177e4SLinus Torvalds * @arg: ioctl arguments
3961da177e4SLinus Torvalds *
3971da177e4SLinus Torvalds * This routine will close down the fibctx passed in from the user.
3981da177e4SLinus Torvalds */
3991da177e4SLinus Torvalds
close_getadapter_fib(struct aac_dev * dev,void __user * arg)4001da177e4SLinus Torvalds static int close_getadapter_fib(struct aac_dev * dev, void __user *arg)
4011da177e4SLinus Torvalds {
4021da177e4SLinus Torvalds struct aac_fib_context *fibctx;
4031da177e4SLinus Torvalds int status;
4041da177e4SLinus Torvalds unsigned long flags;
4051da177e4SLinus Torvalds struct list_head * entry;
4061da177e4SLinus Torvalds
4071da177e4SLinus Torvalds /*
4081da177e4SLinus Torvalds * Verify that the HANDLE passed in was a valid AdapterFibContext
4091da177e4SLinus Torvalds *
4101da177e4SLinus Torvalds * Search the list of AdapterFibContext addresses on the adapter
4111da177e4SLinus Torvalds * to be sure this is a valid address
4121da177e4SLinus Torvalds */
4131da177e4SLinus Torvalds
4141da177e4SLinus Torvalds entry = dev->fib_list.next;
4151da177e4SLinus Torvalds fibctx = NULL;
4161da177e4SLinus Torvalds
4171da177e4SLinus Torvalds while(entry != &dev->fib_list) {
4181da177e4SLinus Torvalds fibctx = list_entry(entry, struct aac_fib_context, next);
4191da177e4SLinus Torvalds /*
4201da177e4SLinus Torvalds * Extract the fibctx from the input parameters
4211da177e4SLinus Torvalds */
422142956afSAl Viro if (fibctx->unique == (u32)(uintptr_t)arg) /* We found a winner */
4231da177e4SLinus Torvalds break;
4241da177e4SLinus Torvalds entry = entry->next;
4251da177e4SLinus Torvalds fibctx = NULL;
4261da177e4SLinus Torvalds }
4271da177e4SLinus Torvalds
4281da177e4SLinus Torvalds if (!fibctx)
4291da177e4SLinus Torvalds return 0; /* Already gone */
4301da177e4SLinus Torvalds
4311da177e4SLinus Torvalds if((fibctx->type != FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT) ||
4321da177e4SLinus Torvalds (fibctx->size != sizeof(struct aac_fib_context)))
4331da177e4SLinus Torvalds return -EINVAL;
4341da177e4SLinus Torvalds spin_lock_irqsave(&dev->fib_lock, flags);
4351da177e4SLinus Torvalds status = aac_close_fib_context(dev, fibctx);
4361da177e4SLinus Torvalds spin_unlock_irqrestore(&dev->fib_lock, flags);
4371da177e4SLinus Torvalds return status;
4381da177e4SLinus Torvalds }
4391da177e4SLinus Torvalds
4401da177e4SLinus Torvalds /**
4411da177e4SLinus Torvalds * check_revision - close down user fib context
4421da177e4SLinus Torvalds * @dev: adapter
4431da177e4SLinus Torvalds * @arg: ioctl arguments
4441da177e4SLinus Torvalds *
4451da177e4SLinus Torvalds * This routine returns the driver version.
4461da177e4SLinus Torvalds * Under Linux, there have been no version incompatibilities, so this is
4471da177e4SLinus Torvalds * simple!
4481da177e4SLinus Torvalds */
4491da177e4SLinus Torvalds
check_revision(struct aac_dev * dev,void __user * arg)4501da177e4SLinus Torvalds static int check_revision(struct aac_dev *dev, void __user *arg)
4511da177e4SLinus Torvalds {
4521da177e4SLinus Torvalds struct revision response;
453c7f47602SMark Haverkamp char *driver_version = aac_driver_version;
454c7f47602SMark Haverkamp u32 version;
4551da177e4SLinus Torvalds
4569f30a323SMark Haverkamp response.compat = 1;
457c7f47602SMark Haverkamp version = (simple_strtol(driver_version,
458c7f47602SMark Haverkamp &driver_version, 10) << 24) | 0x00000400;
459c7f47602SMark Haverkamp version += simple_strtol(driver_version + 1, &driver_version, 10) << 16;
460c7f47602SMark Haverkamp version += simple_strtol(driver_version + 1, NULL, 10);
461c7f47602SMark Haverkamp response.version = cpu_to_le32(version);
4628ce3eca4SSalyzyn, Mark # ifdef AAC_DRIVER_BUILD
463c7f47602SMark Haverkamp response.build = cpu_to_le32(AAC_DRIVER_BUILD);
464c7f47602SMark Haverkamp # else
465c7f47602SMark Haverkamp response.build = cpu_to_le32(9999);
466c7f47602SMark Haverkamp # endif
4671da177e4SLinus Torvalds
4681da177e4SLinus Torvalds if (copy_to_user(arg, &response, sizeof(response)))
4691da177e4SLinus Torvalds return -EFAULT;
4701da177e4SLinus Torvalds return 0;
4711da177e4SLinus Torvalds }
4721da177e4SLinus Torvalds
4737c00ffa3SMark Haverkamp
4741da177e4SLinus Torvalds /**
475*4c4b8cf5SLee Jones * aac_send_raw_srb()
476cf93fffaSLee Jones * @dev: adapter is being processed
477cf93fffaSLee Jones * @arg: arguments to the send call
4781da177e4SLinus Torvalds */
aac_send_raw_srb(struct aac_dev * dev,void __user * arg)4794833869eSAdrian Bunk static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
4801da177e4SLinus Torvalds {
4811da177e4SLinus Torvalds struct fib* srbfib;
4821da177e4SLinus Torvalds int status;
48356b58712SMark Haverkamp struct aac_srb *srbcmd = NULL;
484423400e6SRaghava Aditya Renukunta struct aac_hba_cmd_req *hbacmd = NULL;
48556b58712SMark Haverkamp struct user_aac_srb *user_srbcmd = NULL;
48656b58712SMark Haverkamp struct user_aac_srb __user *user_srb = arg;
4871da177e4SLinus Torvalds struct aac_srb_reply __user *user_reply;
488423400e6SRaghava Aditya Renukunta u32 chn;
4891da177e4SLinus Torvalds u32 fibsize = 0;
4901da177e4SLinus Torvalds u32 flags = 0;
4911da177e4SLinus Torvalds s32 rcode = 0;
4921da177e4SLinus Torvalds u32 data_dir;
493423400e6SRaghava Aditya Renukunta void __user *sg_user[HBA_MAX_SG_EMBEDDED];
494423400e6SRaghava Aditya Renukunta void *sg_list[HBA_MAX_SG_EMBEDDED];
495423400e6SRaghava Aditya Renukunta u32 sg_count[HBA_MAX_SG_EMBEDDED];
4961da177e4SLinus Torvalds u32 sg_indx = 0;
4971da177e4SLinus Torvalds u32 byte_count = 0;
498f2b1a06aSMark Haverkamp u32 actual_fibsize64, actual_fibsize = 0;
4991da177e4SLinus Torvalds int i;
500423400e6SRaghava Aditya Renukunta int is_native_device;
501423400e6SRaghava Aditya Renukunta u64 address;
5021da177e4SLinus Torvalds
5031da177e4SLinus Torvalds
50433bb3b29SMark Haverkamp if (dev->in_reset) {
50533bb3b29SMark Haverkamp dprintk((KERN_DEBUG"aacraid: send raw srb -EBUSY\n"));
50633bb3b29SMark Haverkamp return -EBUSY;
50733bb3b29SMark Haverkamp }
5081da177e4SLinus Torvalds if (!capable(CAP_SYS_ADMIN)){
5097c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: No permission to send raw srb\n"));
5101da177e4SLinus Torvalds return -EPERM;
5111da177e4SLinus Torvalds }
5121da177e4SLinus Torvalds /*
513f2b1a06aSMark Haverkamp * Allocate and initialize a Fib then setup a SRB command
5141da177e4SLinus Torvalds */
515bfb35aa8SMark Haverkamp if (!(srbfib = aac_fib_alloc(dev))) {
5165d497cecSMark Haverkamp return -ENOMEM;
5171da177e4SLinus Torvalds }
5181da177e4SLinus Torvalds
5197c00ffa3SMark Haverkamp memset(sg_list, 0, sizeof(sg_list)); /* cleanup may take issue */
5201da177e4SLinus Torvalds if(copy_from_user(&fibsize, &user_srb->count,sizeof(u32))){
5217c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not copy data size from user\n"));
5221da177e4SLinus Torvalds rcode = -EFAULT;
5231da177e4SLinus Torvalds goto cleanup;
5241da177e4SLinus Torvalds }
5251da177e4SLinus Torvalds
526b4789b8eSMahesh Rajashekhara if ((fibsize < (sizeof(struct user_aac_srb) - sizeof(struct user_sgentry))) ||
527b4789b8eSMahesh Rajashekhara (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)))) {
5281da177e4SLinus Torvalds rcode = -EINVAL;
5291da177e4SLinus Torvalds goto cleanup;
5301da177e4SLinus Torvalds }
5311da177e4SLinus Torvalds
5328d925b1fSZou Wei user_srbcmd = memdup_user(user_srb, fibsize);
5338d925b1fSZou Wei if (IS_ERR(user_srbcmd)) {
5348d925b1fSZou Wei rcode = PTR_ERR(user_srbcmd);
53525c21d20SDan Carpenter user_srbcmd = NULL;
5361da177e4SLinus Torvalds goto cleanup;
5371da177e4SLinus Torvalds }
5381da177e4SLinus Torvalds
53956b58712SMark Haverkamp flags = user_srbcmd->flags; /* from user in cpu order */
54056b58712SMark Haverkamp switch (flags & (SRB_DataIn | SRB_DataOut)) {
5411da177e4SLinus Torvalds case SRB_DataOut:
5421da177e4SLinus Torvalds data_dir = DMA_TO_DEVICE;
5431da177e4SLinus Torvalds break;
5441da177e4SLinus Torvalds case (SRB_DataIn | SRB_DataOut):
5451da177e4SLinus Torvalds data_dir = DMA_BIDIRECTIONAL;
5461da177e4SLinus Torvalds break;
5471da177e4SLinus Torvalds case SRB_DataIn:
5481da177e4SLinus Torvalds data_dir = DMA_FROM_DEVICE;
5491da177e4SLinus Torvalds break;
5501da177e4SLinus Torvalds default:
5511da177e4SLinus Torvalds data_dir = DMA_NONE;
5521da177e4SLinus Torvalds }
5536391a113STobias Klauser if (user_srbcmd->sg.count > ARRAY_SIZE(sg_list)) {
5547c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: too many sg entries %d\n",
555423400e6SRaghava Aditya Renukunta user_srbcmd->sg.count));
556423400e6SRaghava Aditya Renukunta rcode = -EINVAL;
557423400e6SRaghava Aditya Renukunta goto cleanup;
558423400e6SRaghava Aditya Renukunta }
559423400e6SRaghava Aditya Renukunta if ((data_dir == DMA_NONE) && user_srbcmd->sg.count) {
560423400e6SRaghava Aditya Renukunta dprintk((KERN_DEBUG"aacraid:SG with no direction specified\n"));
5617c00ffa3SMark Haverkamp rcode = -EINVAL;
5627c00ffa3SMark Haverkamp goto cleanup;
5637c00ffa3SMark Haverkamp }
564f2b1a06aSMark Haverkamp actual_fibsize = sizeof(struct aac_srb) - sizeof(struct sgentry) +
565f2b1a06aSMark Haverkamp ((user_srbcmd->sg.count & 0xff) * sizeof(struct sgentry));
566f2b1a06aSMark Haverkamp actual_fibsize64 = actual_fibsize + (user_srbcmd->sg.count & 0xff) *
567f2b1a06aSMark Haverkamp (sizeof(struct sgentry64) - sizeof(struct sgentry));
568f2b1a06aSMark Haverkamp /* User made a mistake - should not continue */
569f2b1a06aSMark Haverkamp if ((actual_fibsize != fibsize) && (actual_fibsize64 != fibsize)) {
570f2b1a06aSMark Haverkamp dprintk((KERN_DEBUG"aacraid: Bad Size specified in "
571f2b1a06aSMark Haverkamp "Raw SRB command calculated fibsize=%lu;%lu "
572f2b1a06aSMark Haverkamp "user_srbcmd->sg.count=%d aac_srb=%lu sgentry=%lu;%lu "
573f2b1a06aSMark Haverkamp "issued fibsize=%d\n",
574f2b1a06aSMark Haverkamp actual_fibsize, actual_fibsize64, user_srbcmd->sg.count,
575f2b1a06aSMark Haverkamp sizeof(struct aac_srb), sizeof(struct sgentry),
576f2b1a06aSMark Haverkamp sizeof(struct sgentry64), fibsize));
577f2b1a06aSMark Haverkamp rcode = -EINVAL;
578f2b1a06aSMark Haverkamp goto cleanup;
579f2b1a06aSMark Haverkamp }
580423400e6SRaghava Aditya Renukunta
581f3ef4a74SRaghava Aditya Renukunta chn = user_srbcmd->channel;
582423400e6SRaghava Aditya Renukunta if (chn < AAC_MAX_BUSES && user_srbcmd->id < AAC_MAX_TARGETS &&
583423400e6SRaghava Aditya Renukunta dev->hba_map[chn][user_srbcmd->id].devtype ==
584423400e6SRaghava Aditya Renukunta AAC_DEVTYPE_NATIVE_RAW) {
585423400e6SRaghava Aditya Renukunta is_native_device = 1;
586423400e6SRaghava Aditya Renukunta hbacmd = (struct aac_hba_cmd_req *)srbfib->hw_fib_va;
587423400e6SRaghava Aditya Renukunta memset(hbacmd, 0, 96); /* sizeof(*hbacmd) is not necessary */
588423400e6SRaghava Aditya Renukunta
589423400e6SRaghava Aditya Renukunta /* iu_type is a parameter of aac_hba_send */
590423400e6SRaghava Aditya Renukunta switch (data_dir) {
591423400e6SRaghava Aditya Renukunta case DMA_TO_DEVICE:
592423400e6SRaghava Aditya Renukunta hbacmd->byte1 = 2;
593423400e6SRaghava Aditya Renukunta break;
594423400e6SRaghava Aditya Renukunta case DMA_FROM_DEVICE:
595423400e6SRaghava Aditya Renukunta case DMA_BIDIRECTIONAL:
596423400e6SRaghava Aditya Renukunta hbacmd->byte1 = 1;
597423400e6SRaghava Aditya Renukunta break;
598423400e6SRaghava Aditya Renukunta case DMA_NONE:
599423400e6SRaghava Aditya Renukunta default:
600423400e6SRaghava Aditya Renukunta break;
601423400e6SRaghava Aditya Renukunta }
602423400e6SRaghava Aditya Renukunta hbacmd->lun[1] = cpu_to_le32(user_srbcmd->lun);
603423400e6SRaghava Aditya Renukunta hbacmd->it_nexus = dev->hba_map[chn][user_srbcmd->id].rmw_nexus;
604423400e6SRaghava Aditya Renukunta
605423400e6SRaghava Aditya Renukunta /*
606423400e6SRaghava Aditya Renukunta * we fill in reply_qid later in aac_src_deliver_message
607423400e6SRaghava Aditya Renukunta * we fill in iu_type, request_id later in aac_hba_send
608423400e6SRaghava Aditya Renukunta * we fill in emb_data_desc_count, data_length later
609423400e6SRaghava Aditya Renukunta * in sg list build
610423400e6SRaghava Aditya Renukunta */
611423400e6SRaghava Aditya Renukunta
612423400e6SRaghava Aditya Renukunta memcpy(hbacmd->cdb, user_srbcmd->cdb, sizeof(hbacmd->cdb));
613423400e6SRaghava Aditya Renukunta
614423400e6SRaghava Aditya Renukunta address = (u64)srbfib->hw_error_pa;
615423400e6SRaghava Aditya Renukunta hbacmd->error_ptr_hi = cpu_to_le32((u32)(address >> 32));
616423400e6SRaghava Aditya Renukunta hbacmd->error_ptr_lo = cpu_to_le32((u32)(address & 0xffffffff));
617423400e6SRaghava Aditya Renukunta hbacmd->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE);
618423400e6SRaghava Aditya Renukunta hbacmd->emb_data_desc_count =
619423400e6SRaghava Aditya Renukunta cpu_to_le32(user_srbcmd->sg.count);
620423400e6SRaghava Aditya Renukunta srbfib->hbacmd_size = 64 +
621423400e6SRaghava Aditya Renukunta user_srbcmd->sg.count * sizeof(struct aac_hba_sgl);
622423400e6SRaghava Aditya Renukunta
623423400e6SRaghava Aditya Renukunta } else {
624423400e6SRaghava Aditya Renukunta is_native_device = 0;
625423400e6SRaghava Aditya Renukunta aac_fib_init(srbfib);
626423400e6SRaghava Aditya Renukunta
627423400e6SRaghava Aditya Renukunta /* raw_srb FIB is not FastResponseCapable */
628423400e6SRaghava Aditya Renukunta srbfib->hw_fib_va->header.XferState &=
629423400e6SRaghava Aditya Renukunta ~cpu_to_le32(FastResponseCapable);
630423400e6SRaghava Aditya Renukunta
631423400e6SRaghava Aditya Renukunta srbcmd = (struct aac_srb *) fib_data(srbfib);
632423400e6SRaghava Aditya Renukunta
633423400e6SRaghava Aditya Renukunta // Fix up srb for endian and force some values
634423400e6SRaghava Aditya Renukunta
635423400e6SRaghava Aditya Renukunta srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); // Force this
636423400e6SRaghava Aditya Renukunta srbcmd->channel = cpu_to_le32(user_srbcmd->channel);
637423400e6SRaghava Aditya Renukunta srbcmd->id = cpu_to_le32(user_srbcmd->id);
638423400e6SRaghava Aditya Renukunta srbcmd->lun = cpu_to_le32(user_srbcmd->lun);
639423400e6SRaghava Aditya Renukunta srbcmd->timeout = cpu_to_le32(user_srbcmd->timeout);
640423400e6SRaghava Aditya Renukunta srbcmd->flags = cpu_to_le32(flags);
641423400e6SRaghava Aditya Renukunta srbcmd->retry_limit = 0; // Obsolete parameter
642423400e6SRaghava Aditya Renukunta srbcmd->cdb_size = cpu_to_le32(user_srbcmd->cdb_size);
643423400e6SRaghava Aditya Renukunta memcpy(srbcmd->cdb, user_srbcmd->cdb, sizeof(srbcmd->cdb));
644423400e6SRaghava Aditya Renukunta }
645423400e6SRaghava Aditya Renukunta
646423400e6SRaghava Aditya Renukunta byte_count = 0;
647423400e6SRaghava Aditya Renukunta if (is_native_device) {
648423400e6SRaghava Aditya Renukunta struct user_sgmap *usg32 = &user_srbcmd->sg;
649423400e6SRaghava Aditya Renukunta struct user_sgmap64 *usg64 =
650423400e6SRaghava Aditya Renukunta (struct user_sgmap64 *)&user_srbcmd->sg;
651423400e6SRaghava Aditya Renukunta
652423400e6SRaghava Aditya Renukunta for (i = 0; i < usg32->count; i++) {
653423400e6SRaghava Aditya Renukunta void *p;
654423400e6SRaghava Aditya Renukunta u64 addr;
655423400e6SRaghava Aditya Renukunta
656423400e6SRaghava Aditya Renukunta sg_count[i] = (actual_fibsize64 == fibsize) ?
657423400e6SRaghava Aditya Renukunta usg64->sg[i].count : usg32->sg[i].count;
658423400e6SRaghava Aditya Renukunta if (sg_count[i] >
659423400e6SRaghava Aditya Renukunta (dev->scsi_host_ptr->max_sectors << 9)) {
660423400e6SRaghava Aditya Renukunta pr_err("aacraid: upsg->sg[%d].count=%u>%u\n",
661423400e6SRaghava Aditya Renukunta i, sg_count[i],
662423400e6SRaghava Aditya Renukunta dev->scsi_host_ptr->max_sectors << 9);
663f2b1a06aSMark Haverkamp rcode = -EINVAL;
664f2b1a06aSMark Haverkamp goto cleanup;
665f2b1a06aSMark Haverkamp }
666423400e6SRaghava Aditya Renukunta
667c831a4a0SRaghava Aditya Renukunta p = kmalloc(sg_count[i], GFP_KERNEL);
668423400e6SRaghava Aditya Renukunta if (!p) {
669423400e6SRaghava Aditya Renukunta rcode = -ENOMEM;
670423400e6SRaghava Aditya Renukunta goto cleanup;
671423400e6SRaghava Aditya Renukunta }
672423400e6SRaghava Aditya Renukunta
673423400e6SRaghava Aditya Renukunta if (actual_fibsize64 == fibsize) {
674423400e6SRaghava Aditya Renukunta addr = (u64)usg64->sg[i].addr[0];
675423400e6SRaghava Aditya Renukunta addr += ((u64)usg64->sg[i].addr[1]) << 32;
676423400e6SRaghava Aditya Renukunta } else {
677423400e6SRaghava Aditya Renukunta addr = (u64)usg32->sg[i].addr;
678423400e6SRaghava Aditya Renukunta }
679423400e6SRaghava Aditya Renukunta
680423400e6SRaghava Aditya Renukunta sg_user[i] = (void __user *)(uintptr_t)addr;
681423400e6SRaghava Aditya Renukunta sg_list[i] = p; // save so we can clean up later
682423400e6SRaghava Aditya Renukunta sg_indx = i;
683423400e6SRaghava Aditya Renukunta
684423400e6SRaghava Aditya Renukunta if (flags & SRB_DataOut) {
685423400e6SRaghava Aditya Renukunta if (copy_from_user(p, sg_user[i],
686423400e6SRaghava Aditya Renukunta sg_count[i])) {
687423400e6SRaghava Aditya Renukunta rcode = -EFAULT;
688423400e6SRaghava Aditya Renukunta goto cleanup;
689423400e6SRaghava Aditya Renukunta }
690423400e6SRaghava Aditya Renukunta }
691e555cd5fSSuraj Upadhyay addr = dma_map_single(&dev->pdev->dev, p, sg_count[i],
692423400e6SRaghava Aditya Renukunta data_dir);
693423400e6SRaghava Aditya Renukunta hbacmd->sge[i].addr_hi = cpu_to_le32((u32)(addr>>32));
694423400e6SRaghava Aditya Renukunta hbacmd->sge[i].addr_lo = cpu_to_le32(
695423400e6SRaghava Aditya Renukunta (u32)(addr & 0xffffffff));
696423400e6SRaghava Aditya Renukunta hbacmd->sge[i].len = cpu_to_le32(sg_count[i]);
697423400e6SRaghava Aditya Renukunta hbacmd->sge[i].flags = 0;
698423400e6SRaghava Aditya Renukunta byte_count += sg_count[i];
699423400e6SRaghava Aditya Renukunta }
700423400e6SRaghava Aditya Renukunta
701423400e6SRaghava Aditya Renukunta if (usg32->count > 0) /* embedded sglist */
702423400e6SRaghava Aditya Renukunta hbacmd->sge[usg32->count-1].flags =
703423400e6SRaghava Aditya Renukunta cpu_to_le32(0x40000000);
704423400e6SRaghava Aditya Renukunta hbacmd->data_length = cpu_to_le32(byte_count);
705423400e6SRaghava Aditya Renukunta
706423400e6SRaghava Aditya Renukunta status = aac_hba_send(HBA_IU_TYPE_SCSI_CMD_REQ, srbfib,
707423400e6SRaghava Aditya Renukunta NULL, NULL);
708423400e6SRaghava Aditya Renukunta
709423400e6SRaghava Aditya Renukunta } else if (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64) {
71056b58712SMark Haverkamp struct user_sgmap64* upsg = (struct user_sgmap64*)&user_srbcmd->sg;
71184e29308SMark Haverkamp struct sgmap64* psg = (struct sgmap64*)&srbcmd->sg;
7121da177e4SLinus Torvalds
7131da177e4SLinus Torvalds /*
7141da177e4SLinus Torvalds * This should also catch if user used the 32 bit sgmap
7151da177e4SLinus Torvalds */
716f2b1a06aSMark Haverkamp if (actual_fibsize64 == fibsize) {
717f2b1a06aSMark Haverkamp actual_fibsize = actual_fibsize64;
718f2b1a06aSMark Haverkamp for (i = 0; i < upsg->count; i++) {
719f2b1a06aSMark Haverkamp u64 addr;
720f2b1a06aSMark Haverkamp void* p;
721423400e6SRaghava Aditya Renukunta
722423400e6SRaghava Aditya Renukunta sg_count[i] = upsg->sg[i].count;
723423400e6SRaghava Aditya Renukunta if (sg_count[i] >
724cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech ((dev->adapter_info.options &
72509050715SMark Salyzyn AAC_OPT_NEW_COMM) ?
72609050715SMark Salyzyn (dev->scsi_host_ptr->max_sectors << 9) :
727cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 65536)) {
72809050715SMark Salyzyn rcode = -EINVAL;
72909050715SMark Salyzyn goto cleanup;
73009050715SMark Salyzyn }
731c831a4a0SRaghava Aditya Renukunta
732c831a4a0SRaghava Aditya Renukunta p = kmalloc(sg_count[i], GFP_KERNEL);
7336dcd4a7fSSalyzyn, Mark if(!p) {
734f2b1a06aSMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
735423400e6SRaghava Aditya Renukunta sg_count[i], i, upsg->count));
736f2b1a06aSMark Haverkamp rcode = -ENOMEM;
7371da177e4SLinus Torvalds goto cleanup;
7381da177e4SLinus Torvalds }
739f2b1a06aSMark Haverkamp addr = (u64)upsg->sg[i].addr[0];
740f2b1a06aSMark Haverkamp addr += ((u64)upsg->sg[i].addr[1]) << 32;
741142956afSAl Viro sg_user[i] = (void __user *)(uintptr_t)addr;
742f2b1a06aSMark Haverkamp sg_list[i] = p; // save so we can clean up later
743f2b1a06aSMark Haverkamp sg_indx = i;
744f2b1a06aSMark Haverkamp
745f2b1a06aSMark Haverkamp if (flags & SRB_DataOut) {
746423400e6SRaghava Aditya Renukunta if (copy_from_user(p, sg_user[i],
747423400e6SRaghava Aditya Renukunta sg_count[i])){
748f2b1a06aSMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
749f2b1a06aSMark Haverkamp rcode = -EFAULT;
750f2b1a06aSMark Haverkamp goto cleanup;
751f2b1a06aSMark Haverkamp }
752f2b1a06aSMark Haverkamp }
753e555cd5fSSuraj Upadhyay addr = dma_map_single(&dev->pdev->dev, p,
754423400e6SRaghava Aditya Renukunta sg_count[i], data_dir);
755f2b1a06aSMark Haverkamp
756f2b1a06aSMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
757f2b1a06aSMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
758423400e6SRaghava Aditya Renukunta byte_count += sg_count[i];
759423400e6SRaghava Aditya Renukunta psg->sg[i].count = cpu_to_le32(sg_count[i]);
760f2b1a06aSMark Haverkamp }
761f2b1a06aSMark Haverkamp } else {
762f2b1a06aSMark Haverkamp struct user_sgmap* usg;
76322e9f5a6SMuhammad Falak R Wani usg = kmemdup(upsg,
76422e9f5a6SMuhammad Falak R Wani actual_fibsize - sizeof(struct aac_srb)
7657c00ffa3SMark Haverkamp + sizeof(struct sgmap), GFP_KERNEL);
7667c00ffa3SMark Haverkamp if (!usg) {
7677c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
7687c00ffa3SMark Haverkamp rcode = -ENOMEM;
7697c00ffa3SMark Haverkamp goto cleanup;
7707c00ffa3SMark Haverkamp }
771f2b1a06aSMark Haverkamp actual_fibsize = actual_fibsize64;
7721da177e4SLinus Torvalds
7737c00ffa3SMark Haverkamp for (i = 0; i < usg->count; i++) {
77456b58712SMark Haverkamp u64 addr;
7751da177e4SLinus Torvalds void* p;
776423400e6SRaghava Aditya Renukunta
777423400e6SRaghava Aditya Renukunta sg_count[i] = usg->sg[i].count;
778423400e6SRaghava Aditya Renukunta if (sg_count[i] >
779cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech ((dev->adapter_info.options &
78009050715SMark Salyzyn AAC_OPT_NEW_COMM) ?
78109050715SMark Salyzyn (dev->scsi_host_ptr->max_sectors << 9) :
782cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 65536)) {
7837dd72f51SJesper Juhl kfree(usg);
78409050715SMark Salyzyn rcode = -EINVAL;
78509050715SMark Salyzyn goto cleanup;
78609050715SMark Salyzyn }
787c831a4a0SRaghava Aditya Renukunta
788c831a4a0SRaghava Aditya Renukunta p = kmalloc(sg_count[i], GFP_KERNEL);
7896dcd4a7fSSalyzyn, Mark if(!p) {
7907c00ffa3SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
791423400e6SRaghava Aditya Renukunta sg_count[i], i, usg->count));
7928a52da63SJulia Lawall kfree(usg);
7931da177e4SLinus Torvalds rcode = -ENOMEM;
7941da177e4SLinus Torvalds goto cleanup;
7951da177e4SLinus Torvalds }
796142956afSAl Viro sg_user[i] = (void __user *)(uintptr_t)usg->sg[i].addr;
7971da177e4SLinus Torvalds sg_list[i] = p; // save so we can clean up later
7981da177e4SLinus Torvalds sg_indx = i;
7991da177e4SLinus Torvalds
8001da177e4SLinus Torvalds if (flags & SRB_DataOut) {
801423400e6SRaghava Aditya Renukunta if (copy_from_user(p, sg_user[i],
802423400e6SRaghava Aditya Renukunta sg_count[i])) {
8037c00ffa3SMark Haverkamp kfree (usg);
8047c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
8051da177e4SLinus Torvalds rcode = -EFAULT;
8061da177e4SLinus Torvalds goto cleanup;
8071da177e4SLinus Torvalds }
8081da177e4SLinus Torvalds }
809e555cd5fSSuraj Upadhyay addr = dma_map_single(&dev->pdev->dev, p,
810423400e6SRaghava Aditya Renukunta sg_count[i], data_dir);
8111da177e4SLinus Torvalds
81256b58712SMark Haverkamp psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
81356b58712SMark Haverkamp psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
814423400e6SRaghava Aditya Renukunta byte_count += sg_count[i];
815423400e6SRaghava Aditya Renukunta psg->sg[i].count = cpu_to_le32(sg_count[i]);
8161da177e4SLinus Torvalds }
8177c00ffa3SMark Haverkamp kfree (usg);
818f2b1a06aSMark Haverkamp }
8191da177e4SLinus Torvalds srbcmd->count = cpu_to_le32(byte_count);
8202f5d1f79SMahesh Rajashekhara if (user_srbcmd->sg.count)
8217c00ffa3SMark Haverkamp psg->count = cpu_to_le32(sg_indx+1);
8222f5d1f79SMahesh Rajashekhara else
8232f5d1f79SMahesh Rajashekhara psg->count = 0;
824bfb35aa8SMark Haverkamp status = aac_fib_send(ScsiPortCommand64, srbfib, actual_fibsize, FsaNormal, 1, 1,NULL,NULL);
8251da177e4SLinus Torvalds } else {
82656b58712SMark Haverkamp struct user_sgmap* upsg = &user_srbcmd->sg;
8271da177e4SLinus Torvalds struct sgmap* psg = &srbcmd->sg;
8281da177e4SLinus Torvalds
829f2b1a06aSMark Haverkamp if (actual_fibsize64 == fibsize) {
830f2b1a06aSMark Haverkamp struct user_sgmap64* usg = (struct user_sgmap64 *)upsg;
831f2b1a06aSMark Haverkamp for (i = 0; i < upsg->count; i++) {
832142956afSAl Viro uintptr_t addr;
833f2b1a06aSMark Haverkamp void* p;
834423400e6SRaghava Aditya Renukunta
835423400e6SRaghava Aditya Renukunta sg_count[i] = usg->sg[i].count;
836423400e6SRaghava Aditya Renukunta if (sg_count[i] >
837cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech ((dev->adapter_info.options &
83809050715SMark Salyzyn AAC_OPT_NEW_COMM) ?
83909050715SMark Salyzyn (dev->scsi_host_ptr->max_sectors << 9) :
840cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 65536)) {
84109050715SMark Salyzyn rcode = -EINVAL;
84209050715SMark Salyzyn goto cleanup;
84309050715SMark Salyzyn }
844a0c1c185SChristoph Hellwig p = kmalloc(sg_count[i], GFP_KERNEL);
8456dcd4a7fSSalyzyn, Mark if (!p) {
846f2b1a06aSMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
847423400e6SRaghava Aditya Renukunta sg_count[i], i, usg->count));
848f2b1a06aSMark Haverkamp rcode = -ENOMEM;
8491da177e4SLinus Torvalds goto cleanup;
8501da177e4SLinus Torvalds }
851f2b1a06aSMark Haverkamp addr = (u64)usg->sg[i].addr[0];
852f2b1a06aSMark Haverkamp addr += ((u64)usg->sg[i].addr[1]) << 32;
853142956afSAl Viro sg_user[i] = (void __user *)addr;
854f2b1a06aSMark Haverkamp sg_list[i] = p; // save so we can clean up later
855f2b1a06aSMark Haverkamp sg_indx = i;
856f2b1a06aSMark Haverkamp
857f2b1a06aSMark Haverkamp if (flags & SRB_DataOut) {
858423400e6SRaghava Aditya Renukunta if (copy_from_user(p, sg_user[i],
859423400e6SRaghava Aditya Renukunta sg_count[i])){
860f2b1a06aSMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
861f2b1a06aSMark Haverkamp rcode = -EFAULT;
8621da177e4SLinus Torvalds goto cleanup;
8631da177e4SLinus Torvalds }
864f2b1a06aSMark Haverkamp }
865e555cd5fSSuraj Upadhyay addr = dma_map_single(&dev->pdev->dev, p,
866e555cd5fSSuraj Upadhyay usg->sg[i].count,
867e555cd5fSSuraj Upadhyay data_dir);
868f2b1a06aSMark Haverkamp
869f2b1a06aSMark Haverkamp psg->sg[i].addr = cpu_to_le32(addr & 0xffffffff);
870f2b1a06aSMark Haverkamp byte_count += usg->sg[i].count;
871423400e6SRaghava Aditya Renukunta psg->sg[i].count = cpu_to_le32(sg_count[i]);
872f2b1a06aSMark Haverkamp }
873f2b1a06aSMark Haverkamp } else {
87456b58712SMark Haverkamp for (i = 0; i < upsg->count; i++) {
8751da177e4SLinus Torvalds dma_addr_t addr;
8761da177e4SLinus Torvalds void* p;
877423400e6SRaghava Aditya Renukunta
878423400e6SRaghava Aditya Renukunta sg_count[i] = upsg->sg[i].count;
879423400e6SRaghava Aditya Renukunta if (sg_count[i] >
880cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech ((dev->adapter_info.options &
88109050715SMark Salyzyn AAC_OPT_NEW_COMM) ?
88209050715SMark Salyzyn (dev->scsi_host_ptr->max_sectors << 9) :
883cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech 65536)) {
88409050715SMark Salyzyn rcode = -EINVAL;
88509050715SMark Salyzyn goto cleanup;
88609050715SMark Salyzyn }
887a0c1c185SChristoph Hellwig p = kmalloc(sg_count[i], GFP_KERNEL);
8886dcd4a7fSSalyzyn, Mark if (!p) {
8897c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
890423400e6SRaghava Aditya Renukunta sg_count[i], i, upsg->count));
8911da177e4SLinus Torvalds rcode = -ENOMEM;
8921da177e4SLinus Torvalds goto cleanup;
8931da177e4SLinus Torvalds }
894142956afSAl Viro sg_user[i] = (void __user *)(uintptr_t)upsg->sg[i].addr;
8951da177e4SLinus Torvalds sg_list[i] = p; // save so we can clean up later
8961da177e4SLinus Torvalds sg_indx = i;
8971da177e4SLinus Torvalds
8981da177e4SLinus Torvalds if (flags & SRB_DataOut) {
89956b58712SMark Haverkamp if (copy_from_user(p, sg_user[i],
900423400e6SRaghava Aditya Renukunta sg_count[i])) {
9017c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
9021da177e4SLinus Torvalds rcode = -EFAULT;
9031da177e4SLinus Torvalds goto cleanup;
9041da177e4SLinus Torvalds }
9051da177e4SLinus Torvalds }
906e555cd5fSSuraj Upadhyay addr = dma_map_single(&dev->pdev->dev, p,
907423400e6SRaghava Aditya Renukunta sg_count[i], data_dir);
9081da177e4SLinus Torvalds
9091da177e4SLinus Torvalds psg->sg[i].addr = cpu_to_le32(addr);
910423400e6SRaghava Aditya Renukunta byte_count += sg_count[i];
911423400e6SRaghava Aditya Renukunta psg->sg[i].count = cpu_to_le32(sg_count[i]);
912f2b1a06aSMark Haverkamp }
9131da177e4SLinus Torvalds }
9141da177e4SLinus Torvalds srbcmd->count = cpu_to_le32(byte_count);
9152f5d1f79SMahesh Rajashekhara if (user_srbcmd->sg.count)
9167c00ffa3SMark Haverkamp psg->count = cpu_to_le32(sg_indx+1);
9172f5d1f79SMahesh Rajashekhara else
9182f5d1f79SMahesh Rajashekhara psg->count = 0;
919bfb35aa8SMark Haverkamp status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
9201da177e4SLinus Torvalds }
921423400e6SRaghava Aditya Renukunta
922cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (status == -ERESTARTSYS) {
923cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech rcode = -ERESTARTSYS;
924c8f7b073SMark Haverkamp goto cleanup;
925c8f7b073SMark Haverkamp }
9261da177e4SLinus Torvalds
9271da177e4SLinus Torvalds if (status != 0) {
9287c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not send raw srb fib to hba\n"));
9295d497cecSMark Haverkamp rcode = -ENXIO;
9301da177e4SLinus Torvalds goto cleanup;
9311da177e4SLinus Torvalds }
9321da177e4SLinus Torvalds
9331da177e4SLinus Torvalds if (flags & SRB_DataIn) {
9341da177e4SLinus Torvalds for(i = 0 ; i <= sg_indx; i++){
935423400e6SRaghava Aditya Renukunta if (copy_to_user(sg_user[i], sg_list[i], sg_count[i])) {
9367c00ffa3SMark Haverkamp dprintk((KERN_DEBUG"aacraid: Could not copy sg data to user\n"));
9371da177e4SLinus Torvalds rcode = -EFAULT;
9381da177e4SLinus Torvalds goto cleanup;
9391da177e4SLinus Torvalds
9401da177e4SLinus Torvalds }
9411da177e4SLinus Torvalds }
9421da177e4SLinus Torvalds }
9431da177e4SLinus Torvalds
944423400e6SRaghava Aditya Renukunta user_reply = arg + fibsize;
945423400e6SRaghava Aditya Renukunta if (is_native_device) {
946423400e6SRaghava Aditya Renukunta struct aac_hba_resp *err =
947423400e6SRaghava Aditya Renukunta &((struct aac_native_hba *)srbfib->hw_fib_va)->resp.err;
948423400e6SRaghava Aditya Renukunta struct aac_srb_reply reply;
949423400e6SRaghava Aditya Renukunta
950342ffc26SSeth Forshee memset(&reply, 0, sizeof(reply));
951423400e6SRaghava Aditya Renukunta reply.status = ST_OK;
952423400e6SRaghava Aditya Renukunta if (srbfib->flags & FIB_CONTEXT_FLAG_FASTRESP) {
953423400e6SRaghava Aditya Renukunta /* fast response */
954423400e6SRaghava Aditya Renukunta reply.srb_status = SRB_STATUS_SUCCESS;
955423400e6SRaghava Aditya Renukunta reply.scsi_status = 0;
956423400e6SRaghava Aditya Renukunta reply.data_xfer_length = byte_count;
9575cc973f0SColin Ian King reply.sense_data_size = 0;
9585cc973f0SColin Ian King memset(reply.sense_data, 0, AAC_SENSE_BUFFERSIZE);
959423400e6SRaghava Aditya Renukunta } else {
960423400e6SRaghava Aditya Renukunta reply.srb_status = err->service_response;
961423400e6SRaghava Aditya Renukunta reply.scsi_status = err->status;
962423400e6SRaghava Aditya Renukunta reply.data_xfer_length = byte_count -
963423400e6SRaghava Aditya Renukunta le32_to_cpu(err->residual_count);
964423400e6SRaghava Aditya Renukunta reply.sense_data_size = err->sense_response_data_len;
965423400e6SRaghava Aditya Renukunta memcpy(reply.sense_data, err->sense_response_buf,
966423400e6SRaghava Aditya Renukunta AAC_SENSE_BUFFERSIZE);
967423400e6SRaghava Aditya Renukunta }
968423400e6SRaghava Aditya Renukunta if (copy_to_user(user_reply, &reply,
969423400e6SRaghava Aditya Renukunta sizeof(struct aac_srb_reply))) {
970423400e6SRaghava Aditya Renukunta dprintk((KERN_DEBUG"aacraid: Copy to user failed\n"));
9711da177e4SLinus Torvalds rcode = -EFAULT;
9721da177e4SLinus Torvalds goto cleanup;
9731da177e4SLinus Torvalds }
974423400e6SRaghava Aditya Renukunta } else {
975423400e6SRaghava Aditya Renukunta struct aac_srb_reply *reply;
976423400e6SRaghava Aditya Renukunta
977423400e6SRaghava Aditya Renukunta reply = (struct aac_srb_reply *) fib_data(srbfib);
978423400e6SRaghava Aditya Renukunta if (copy_to_user(user_reply, reply,
979423400e6SRaghava Aditya Renukunta sizeof(struct aac_srb_reply))) {
980423400e6SRaghava Aditya Renukunta dprintk((KERN_DEBUG"aacraid: Copy to user failed\n"));
981423400e6SRaghava Aditya Renukunta rcode = -EFAULT;
982423400e6SRaghava Aditya Renukunta goto cleanup;
983423400e6SRaghava Aditya Renukunta }
984423400e6SRaghava Aditya Renukunta }
9851da177e4SLinus Torvalds
9861da177e4SLinus Torvalds cleanup:
98756b58712SMark Haverkamp kfree(user_srbcmd);
988cacb6dc3SPenchala Narasimha Reddy Chilakala, ERS-HCLTech if (rcode != -ERESTARTSYS) {
989423400e6SRaghava Aditya Renukunta for (i = 0; i <= sg_indx; i++)
990423400e6SRaghava Aditya Renukunta kfree(sg_list[i]);
991bfb35aa8SMark Haverkamp aac_fib_complete(srbfib);
992bfb35aa8SMark Haverkamp aac_fib_free(srbfib);
993c8f7b073SMark Haverkamp }
9941da177e4SLinus Torvalds
9951da177e4SLinus Torvalds return rcode;
9961da177e4SLinus Torvalds }
9971da177e4SLinus Torvalds
9981da177e4SLinus Torvalds struct aac_pci_info {
9991da177e4SLinus Torvalds u32 bus;
10001da177e4SLinus Torvalds u32 slot;
10011da177e4SLinus Torvalds };
10021da177e4SLinus Torvalds
10031da177e4SLinus Torvalds
aac_get_pci_info(struct aac_dev * dev,void __user * arg)10044833869eSAdrian Bunk static int aac_get_pci_info(struct aac_dev* dev, void __user *arg)
10051da177e4SLinus Torvalds {
10061da177e4SLinus Torvalds struct aac_pci_info pci_info;
10071da177e4SLinus Torvalds
10081da177e4SLinus Torvalds pci_info.bus = dev->pdev->bus->number;
10091da177e4SLinus Torvalds pci_info.slot = PCI_SLOT(dev->pdev->devfn);
10101da177e4SLinus Torvalds
10111da177e4SLinus Torvalds if (copy_to_user(arg, &pci_info, sizeof(struct aac_pci_info))) {
10127c00ffa3SMark Haverkamp dprintk((KERN_DEBUG "aacraid: Could not copy pci info\n"));
10131da177e4SLinus Torvalds return -EFAULT;
10141da177e4SLinus Torvalds }
10151da177e4SLinus Torvalds return 0;
10161da177e4SLinus Torvalds }
1017c799d519SRaghava Aditya Renukunta
aac_get_hba_info(struct aac_dev * dev,void __user * arg)1018c799d519SRaghava Aditya Renukunta static int aac_get_hba_info(struct aac_dev *dev, void __user *arg)
1019c799d519SRaghava Aditya Renukunta {
1020c799d519SRaghava Aditya Renukunta struct aac_hba_info hbainfo;
1021c799d519SRaghava Aditya Renukunta
1022342ffc26SSeth Forshee memset(&hbainfo, 0, sizeof(hbainfo));
1023c799d519SRaghava Aditya Renukunta hbainfo.adapter_number = (u8) dev->id;
1024c799d519SRaghava Aditya Renukunta hbainfo.system_io_bus_number = dev->pdev->bus->number;
1025c799d519SRaghava Aditya Renukunta hbainfo.device_number = (dev->pdev->devfn >> 3);
1026c799d519SRaghava Aditya Renukunta hbainfo.function_number = (dev->pdev->devfn & 0x0007);
1027c799d519SRaghava Aditya Renukunta
1028c799d519SRaghava Aditya Renukunta hbainfo.vendor_id = dev->pdev->vendor;
1029c799d519SRaghava Aditya Renukunta hbainfo.device_id = dev->pdev->device;
1030c799d519SRaghava Aditya Renukunta hbainfo.sub_vendor_id = dev->pdev->subsystem_vendor;
1031c799d519SRaghava Aditya Renukunta hbainfo.sub_system_id = dev->pdev->subsystem_device;
1032c799d519SRaghava Aditya Renukunta
1033c799d519SRaghava Aditya Renukunta if (copy_to_user(arg, &hbainfo, sizeof(struct aac_hba_info))) {
1034c799d519SRaghava Aditya Renukunta dprintk((KERN_DEBUG "aacraid: Could not copy hba info\n"));
1035c799d519SRaghava Aditya Renukunta return -EFAULT;
1036c799d519SRaghava Aditya Renukunta }
1037c799d519SRaghava Aditya Renukunta
1038c799d519SRaghava Aditya Renukunta return 0;
1039c799d519SRaghava Aditya Renukunta }
1040c799d519SRaghava Aditya Renukunta
104109867a0eSRaghava Aditya Renukunta struct aac_reset_iop {
104209867a0eSRaghava Aditya Renukunta u8 reset_type;
104309867a0eSRaghava Aditya Renukunta };
10441da177e4SLinus Torvalds
aac_send_reset_adapter(struct aac_dev * dev,void __user * arg)104509867a0eSRaghava Aditya Renukunta static int aac_send_reset_adapter(struct aac_dev *dev, void __user *arg)
104609867a0eSRaghava Aditya Renukunta {
104709867a0eSRaghava Aditya Renukunta struct aac_reset_iop reset;
104809867a0eSRaghava Aditya Renukunta int retval;
104909867a0eSRaghava Aditya Renukunta
105009867a0eSRaghava Aditya Renukunta if (copy_from_user((void *)&reset, arg, sizeof(struct aac_reset_iop)))
105109867a0eSRaghava Aditya Renukunta return -EFAULT;
105209867a0eSRaghava Aditya Renukunta
1053f3a23277SRaghava Aditya Renukunta dev->adapter_shutdown = 1;
105409867a0eSRaghava Aditya Renukunta
1055f3a23277SRaghava Aditya Renukunta mutex_unlock(&dev->ioctl_mutex);
1056f3a23277SRaghava Aditya Renukunta retval = aac_reset_adapter(dev, 0, reset.reset_type);
1057f3a23277SRaghava Aditya Renukunta mutex_lock(&dev->ioctl_mutex);
1058f3a23277SRaghava Aditya Renukunta
1059f3a23277SRaghava Aditya Renukunta return retval;
106009867a0eSRaghava Aditya Renukunta }
10611da177e4SLinus Torvalds
aac_do_ioctl(struct aac_dev * dev,unsigned int cmd,void __user * arg)10626f4e626fSNathan Chancellor int aac_do_ioctl(struct aac_dev *dev, unsigned int cmd, void __user *arg)
10631da177e4SLinus Torvalds {
10641da177e4SLinus Torvalds int status;
10651da177e4SLinus Torvalds
1066222a9fb3SRaghava Aditya Renukunta mutex_lock(&dev->ioctl_mutex);
1067222a9fb3SRaghava Aditya Renukunta
1068fbd18598SRaghava Aditya Renukunta if (dev->adapter_shutdown) {
1069fbd18598SRaghava Aditya Renukunta status = -EACCES;
1070fbd18598SRaghava Aditya Renukunta goto cleanup;
1071fbd18598SRaghava Aditya Renukunta }
1072fbd18598SRaghava Aditya Renukunta
10731da177e4SLinus Torvalds /*
10741da177e4SLinus Torvalds * HBA gets first crack
10751da177e4SLinus Torvalds */
10761da177e4SLinus Torvalds
10771da177e4SLinus Torvalds status = aac_dev_ioctl(dev, cmd, arg);
10781da177e4SLinus Torvalds if (status != -ENOTTY)
1079222a9fb3SRaghava Aditya Renukunta goto cleanup;
10801da177e4SLinus Torvalds
10811da177e4SLinus Torvalds switch (cmd) {
10821da177e4SLinus Torvalds case FSACTL_MINIPORT_REV_CHECK:
10831da177e4SLinus Torvalds status = check_revision(dev, arg);
10841da177e4SLinus Torvalds break;
10857c00ffa3SMark Haverkamp case FSACTL_SEND_LARGE_FIB:
10861da177e4SLinus Torvalds case FSACTL_SENDFIB:
10871da177e4SLinus Torvalds status = ioctl_send_fib(dev, arg);
10881da177e4SLinus Torvalds break;
10891da177e4SLinus Torvalds case FSACTL_OPEN_GET_ADAPTER_FIB:
10901da177e4SLinus Torvalds status = open_getadapter_fib(dev, arg);
10911da177e4SLinus Torvalds break;
10921da177e4SLinus Torvalds case FSACTL_GET_NEXT_ADAPTER_FIB:
10931da177e4SLinus Torvalds status = next_getadapter_fib(dev, arg);
10941da177e4SLinus Torvalds break;
10951da177e4SLinus Torvalds case FSACTL_CLOSE_GET_ADAPTER_FIB:
10961da177e4SLinus Torvalds status = close_getadapter_fib(dev, arg);
10971da177e4SLinus Torvalds break;
10981da177e4SLinus Torvalds case FSACTL_SEND_RAW_SRB:
10991da177e4SLinus Torvalds status = aac_send_raw_srb(dev,arg);
11001da177e4SLinus Torvalds break;
11011da177e4SLinus Torvalds case FSACTL_GET_PCI_INFO:
11021da177e4SLinus Torvalds status = aac_get_pci_info(dev,arg);
11031da177e4SLinus Torvalds break;
1104c799d519SRaghava Aditya Renukunta case FSACTL_GET_HBA_INFO:
1105c799d519SRaghava Aditya Renukunta status = aac_get_hba_info(dev, arg);
1106c799d519SRaghava Aditya Renukunta break;
110709867a0eSRaghava Aditya Renukunta case FSACTL_RESET_IOP:
110809867a0eSRaghava Aditya Renukunta status = aac_send_reset_adapter(dev, arg);
110909867a0eSRaghava Aditya Renukunta break;
111009867a0eSRaghava Aditya Renukunta
11111da177e4SLinus Torvalds default:
11121da177e4SLinus Torvalds status = -ENOTTY;
11131da177e4SLinus Torvalds break;
11141da177e4SLinus Torvalds }
1115222a9fb3SRaghava Aditya Renukunta
1116222a9fb3SRaghava Aditya Renukunta cleanup:
1117222a9fb3SRaghava Aditya Renukunta mutex_unlock(&dev->ioctl_mutex);
1118222a9fb3SRaghava Aditya Renukunta
11191da177e4SLinus Torvalds return status;
11201da177e4SLinus Torvalds }
11211da177e4SLinus Torvalds
1122