blob: 1fef92d55dee1097888c4b2b6f52eacc1611d210 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
4 *
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
7 *
8 * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; see the file COPYING. If not, write to
22 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 * Module Name:
25 * commctrl.c
26 *
27 * Abstract: Contains all routines for control of the AFA comm layer
28 *
29 */
30
31#include <linux/kernel.h>
32#include <linux/init.h>
33#include <linux/types.h>
34#include <linux/sched.h>
35#include <linux/pci.h>
36#include <linux/spinlock.h>
37#include <linux/slab.h>
38#include <linux/completion.h>
39#include <linux/dma-mapping.h>
40#include <linux/blkdev.h>
41#include <asm/semaphore.h>
42#include <asm/uaccess.h>
43
44#include "aacraid.h"
45
46/**
47 * ioctl_send_fib - send a FIB from userspace
48 * @dev: adapter is being processed
49 * @arg: arguments to the ioctl call
50 *
51 * This routine sends a fib to the adapter on behalf of a user level
52 * program.
53 */
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070054# define AAC_DEBUG_PREAMBLE KERN_INFO
55# define AAC_DEBUG_POSTAMBLE
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
58{
59 struct hw_fib * kfib;
60 struct fib *fibptr;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070061 struct hw_fib * hw_fib = (struct hw_fib *)0;
62 dma_addr_t hw_fib_pa = (dma_addr_t)0LL;
63 unsigned size;
64 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66 fibptr = fib_alloc(dev);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070067 if(fibptr == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 return -ENOMEM;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070069 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71 kfib = fibptr->hw_fib;
72 /*
73 * First copy in the header so that we can check the size field.
74 */
75 if (copy_from_user((void *)kfib, arg, sizeof(struct aac_fibhdr))) {
76 fib_free(fibptr);
77 return -EFAULT;
78 }
79 /*
80 * Since we copy based on the fib header size, make sure that we
81 * will not overrun the buffer when we copy the memory. Return
82 * an error if we would.
83 */
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070084 size = le16_to_cpu(kfib->header.Size) + sizeof(struct aac_fibhdr);
85 if (size < le16_to_cpu(kfib->header.SenderSize))
86 size = le16_to_cpu(kfib->header.SenderSize);
87 if (size > dev->max_fib_size) {
88 /* Highjack the hw_fib */
89 hw_fib = fibptr->hw_fib;
90 hw_fib_pa = fibptr->hw_fib_pa;
91 fibptr->hw_fib = kfib = pci_alloc_consistent(dev->pdev, size, &fibptr->hw_fib_pa);
92 memset(((char *)kfib) + dev->max_fib_size, 0, size - dev->max_fib_size);
93 memcpy(kfib, hw_fib, dev->max_fib_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 }
95
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -070096 if (copy_from_user(kfib, arg, size)) {
97 retval = -EFAULT;
98 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 }
100
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700101 if (kfib->header.Command == cpu_to_le16(TakeABreakPt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 aac_adapter_interrupt(dev);
103 /*
104 * Since we didn't really send a fib, zero out the state to allow
105 * cleanup code not to assert.
106 */
107 kfib->header.XferState = 0;
108 } else {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700109 retval = fib_send(le16_to_cpu(kfib->header.Command), fibptr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 le16_to_cpu(kfib->header.Size) , FsaNormal,
111 1, 1, NULL, NULL);
112 if (retval) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700113 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 }
115 if (fib_complete(fibptr) != 0) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700116 retval = -EINVAL;
117 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 }
119 }
120 /*
121 * Make sure that the size returned by the adapter (which includes
122 * the header) is less than or equal to the size of a fib, so we
123 * don't corrupt application data. Then copy that size to the user
124 * buffer. (Don't try to add the header information again, since it
125 * was already included by the adapter.)
126 */
127
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700128 retval = 0;
129 if (copy_to_user(arg, (void *)kfib, size))
130 retval = -EFAULT;
131cleanup:
132 if (hw_fib) {
133 pci_free_consistent(dev->pdev, size, kfib, fibptr->hw_fib_pa);
134 fibptr->hw_fib_pa = hw_fib_pa;
135 fibptr->hw_fib = hw_fib;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137 fib_free(fibptr);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700138 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139}
140
141/**
142 * open_getadapter_fib - Get the next fib
143 *
144 * This routine will get the next Fib, if available, from the AdapterFibContext
145 * passed in from the user.
146 */
147
148static int open_getadapter_fib(struct aac_dev * dev, void __user *arg)
149{
150 struct aac_fib_context * fibctx;
151 int status;
152
153 fibctx = kmalloc(sizeof(struct aac_fib_context), GFP_KERNEL);
154 if (fibctx == NULL) {
155 status = -ENOMEM;
156 } else {
157 unsigned long flags;
158 struct list_head * entry;
159 struct aac_fib_context * context;
160
161 fibctx->type = FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT;
162 fibctx->size = sizeof(struct aac_fib_context);
163 /*
164 * Yes yes, I know this could be an index, but we have a
165 * better guarantee of uniqueness for the locked loop below.
166 * Without the aid of a persistent history, this also helps
167 * reduce the chance that the opaque context would be reused.
168 */
169 fibctx->unique = (u32)((ulong)fibctx & 0xFFFFFFFF);
170 /*
171 * Initialize the mutex used to wait for the next AIF.
172 */
173 init_MUTEX_LOCKED(&fibctx->wait_sem);
174 fibctx->wait = 0;
175 /*
176 * Initialize the fibs and set the count of fibs on
177 * the list to 0.
178 */
179 fibctx->count = 0;
180 INIT_LIST_HEAD(&fibctx->fib_list);
181 fibctx->jiffies = jiffies/HZ;
182 /*
183 * Now add this context onto the adapter's
184 * AdapterFibContext list.
185 */
186 spin_lock_irqsave(&dev->fib_lock, flags);
187 /* Ensure that we have a unique identifier */
188 entry = dev->fib_list.next;
189 while (entry != &dev->fib_list) {
190 context = list_entry(entry, struct aac_fib_context, next);
191 if (context->unique == fibctx->unique) {
192 /* Not unique (32 bits) */
193 fibctx->unique++;
194 entry = dev->fib_list.next;
195 } else {
196 entry = entry->next;
197 }
198 }
199 list_add_tail(&fibctx->next, &dev->fib_list);
200 spin_unlock_irqrestore(&dev->fib_lock, flags);
201 if (copy_to_user(arg, &fibctx->unique,
202 sizeof(fibctx->unique))) {
203 status = -EFAULT;
204 } else {
205 status = 0;
206 }
207 }
208 return status;
209}
210
211/**
212 * next_getadapter_fib - get the next fib
213 * @dev: adapter to use
214 * @arg: ioctl argument
215 *
216 * This routine will get the next Fib, if available, from the AdapterFibContext
217 * passed in from the user.
218 */
219
220static int next_getadapter_fib(struct aac_dev * dev, void __user *arg)
221{
222 struct fib_ioctl f;
223 struct fib *fib;
224 struct aac_fib_context *fibctx;
225 int status;
226 struct list_head * entry;
227 unsigned long flags;
228
229 if(copy_from_user((void *)&f, arg, sizeof(struct fib_ioctl)))
230 return -EFAULT;
231 /*
232 * Verify that the HANDLE passed in was a valid AdapterFibContext
233 *
234 * Search the list of AdapterFibContext addresses on the adapter
235 * to be sure this is a valid address
236 */
237 entry = dev->fib_list.next;
238 fibctx = NULL;
239
240 while (entry != &dev->fib_list) {
241 fibctx = list_entry(entry, struct aac_fib_context, next);
242 /*
243 * Extract the AdapterFibContext from the Input parameters.
244 */
245 if (fibctx->unique == f.fibctx) { /* We found a winner */
246 break;
247 }
248 entry = entry->next;
249 fibctx = NULL;
250 }
251 if (!fibctx) {
252 dprintk ((KERN_INFO "Fib Context not found\n"));
253 return -EINVAL;
254 }
255
256 if((fibctx->type != FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT) ||
257 (fibctx->size != sizeof(struct aac_fib_context))) {
258 dprintk ((KERN_INFO "Fib Context corrupt?\n"));
259 return -EINVAL;
260 }
261 status = 0;
262 spin_lock_irqsave(&dev->fib_lock, flags);
263 /*
264 * If there are no fibs to send back, then either wait or return
265 * -EAGAIN
266 */
267return_fib:
268 if (!list_empty(&fibctx->fib_list)) {
269 struct list_head * entry;
270 /*
271 * Pull the next fib from the fibs
272 */
273 entry = fibctx->fib_list.next;
274 list_del(entry);
275
276 fib = list_entry(entry, struct fib, fiblink);
277 fibctx->count--;
278 spin_unlock_irqrestore(&dev->fib_lock, flags);
279 if (copy_to_user(f.fib, fib->hw_fib, sizeof(struct hw_fib))) {
280 kfree(fib->hw_fib);
281 kfree(fib);
282 return -EFAULT;
283 }
284 /*
285 * Free the space occupied by this copy of the fib.
286 */
287 kfree(fib->hw_fib);
288 kfree(fib);
289 status = 0;
290 fibctx->jiffies = jiffies/HZ;
291 } else {
292 spin_unlock_irqrestore(&dev->fib_lock, flags);
293 if (f.wait) {
294 if(down_interruptible(&fibctx->wait_sem) < 0) {
295 status = -EINTR;
296 } else {
297 /* Lock again and retry */
298 spin_lock_irqsave(&dev->fib_lock, flags);
299 goto return_fib;
300 }
301 } else {
302 status = -EAGAIN;
303 }
304 }
305 return status;
306}
307
308int aac_close_fib_context(struct aac_dev * dev, struct aac_fib_context * fibctx)
309{
310 struct fib *fib;
311
312 /*
313 * First free any FIBs that have not been consumed.
314 */
315 while (!list_empty(&fibctx->fib_list)) {
316 struct list_head * entry;
317 /*
318 * Pull the next fib from the fibs
319 */
320 entry = fibctx->fib_list.next;
321 list_del(entry);
322 fib = list_entry(entry, struct fib, fiblink);
323 fibctx->count--;
324 /*
325 * Free the space occupied by this copy of the fib.
326 */
327 kfree(fib->hw_fib);
328 kfree(fib);
329 }
330 /*
331 * Remove the Context from the AdapterFibContext List
332 */
333 list_del(&fibctx->next);
334 /*
335 * Invalidate context
336 */
337 fibctx->type = 0;
338 /*
339 * Free the space occupied by the Context
340 */
341 kfree(fibctx);
342 return 0;
343}
344
345/**
346 * close_getadapter_fib - close down user fib context
347 * @dev: adapter
348 * @arg: ioctl arguments
349 *
350 * This routine will close down the fibctx passed in from the user.
351 */
352
353static int close_getadapter_fib(struct aac_dev * dev, void __user *arg)
354{
355 struct aac_fib_context *fibctx;
356 int status;
357 unsigned long flags;
358 struct list_head * entry;
359
360 /*
361 * Verify that the HANDLE passed in was a valid AdapterFibContext
362 *
363 * Search the list of AdapterFibContext addresses on the adapter
364 * to be sure this is a valid address
365 */
366
367 entry = dev->fib_list.next;
368 fibctx = NULL;
369
370 while(entry != &dev->fib_list) {
371 fibctx = list_entry(entry, struct aac_fib_context, next);
372 /*
373 * Extract the fibctx from the input parameters
374 */
375 if (fibctx->unique == (u32)(unsigned long)arg) {
376 /* We found a winner */
377 break;
378 }
379 entry = entry->next;
380 fibctx = NULL;
381 }
382
383 if (!fibctx)
384 return 0; /* Already gone */
385
386 if((fibctx->type != FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT) ||
387 (fibctx->size != sizeof(struct aac_fib_context)))
388 return -EINVAL;
389 spin_lock_irqsave(&dev->fib_lock, flags);
390 status = aac_close_fib_context(dev, fibctx);
391 spin_unlock_irqrestore(&dev->fib_lock, flags);
392 return status;
393}
394
395/**
396 * check_revision - close down user fib context
397 * @dev: adapter
398 * @arg: ioctl arguments
399 *
400 * This routine returns the driver version.
401 * Under Linux, there have been no version incompatibilities, so this is
402 * simple!
403 */
404
405static int check_revision(struct aac_dev *dev, void __user *arg)
406{
407 struct revision response;
408
409 response.compat = 1;
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700410 response.version = le32_to_cpu(dev->adapter_info.kernelrev);
411 response.build = le32_to_cpu(dev->adapter_info.kernelbuild);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 if (copy_to_user(arg, &response, sizeof(response)))
414 return -EFAULT;
415 return 0;
416}
417
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419/**
420 *
421 * aac_send_raw_scb
422 *
423 */
424
Adrian Bunk 48338692005-04-25 19:45:58 -0700425static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 struct fib* srbfib;
428 int status;
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700429 struct aac_srb *srbcmd = NULL;
430 struct user_aac_srb *user_srbcmd = NULL;
431 struct user_aac_srb __user *user_srb = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 struct aac_srb_reply __user *user_reply;
433 struct aac_srb_reply* reply;
434 u32 fibsize = 0;
435 u32 flags = 0;
436 s32 rcode = 0;
437 u32 data_dir;
438 void __user *sg_user[32];
439 void *sg_list[32];
440 u32 sg_indx = 0;
441 u32 byte_count = 0;
442 u32 actual_fibsize = 0;
443 int i;
444
445
446 if (!capable(CAP_SYS_ADMIN)){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700447 dprintk((KERN_DEBUG"aacraid: No permission to send raw srb\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return -EPERM;
449 }
450 /*
451 * Allocate and initialize a Fib then setup a BlockWrite command
452 */
453 if (!(srbfib = fib_alloc(dev))) {
Mark Haverkamp5d497ce2005-06-17 13:38:04 -0700454 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 }
456 fib_init(srbfib);
457
458 srbcmd = (struct aac_srb*) fib_data(srbfib);
459
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700460 memset(sg_list, 0, sizeof(sg_list)); /* cleanup may take issue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if(copy_from_user(&fibsize, &user_srb->count,sizeof(u32))){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700462 dprintk((KERN_DEBUG"aacraid: Could not copy data size from user\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 rcode = -EFAULT;
464 goto cleanup;
465 }
466
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700467 if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 rcode = -EINVAL;
469 goto cleanup;
470 }
471
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700472 user_srbcmd = kmalloc(GFP_KERNEL, fibsize);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700473 if (!user_srbcmd) {
474 dprintk((KERN_DEBUG"aacraid: Could not make a copy of the srb\n"));
475 rcode = -ENOMEM;
476 goto cleanup;
477 }
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700478 if(copy_from_user(user_srbcmd, user_srb,fibsize)){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700479 dprintk((KERN_DEBUG"aacraid: Could not copy srb from user\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 rcode = -EFAULT;
481 goto cleanup;
482 }
483
484 user_reply = arg+fibsize;
485
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700486 flags = user_srbcmd->flags; /* from user in cpu order */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 // Fix up srb for endian and force some values
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); // Force this
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700490 srbcmd->channel = cpu_to_le32(user_srbcmd->channel);
491 srbcmd->id = cpu_to_le32(user_srbcmd->id);
492 srbcmd->lun = cpu_to_le32(user_srbcmd->lun);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700493 srbcmd->timeout = cpu_to_le32(user_srbcmd->timeout);
Mark Haverkamp5d497ce2005-06-17 13:38:04 -0700494 srbcmd->flags = cpu_to_le32(flags);
495 srbcmd->retry_limit = 0; // Obsolete parameter
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700496 srbcmd->cdb_size = cpu_to_le32(user_srbcmd->cdb_size);
Mark Haverkamp5d497ce2005-06-17 13:38:04 -0700497 memcpy(srbcmd->cdb, user_srbcmd->cdb, sizeof(srbcmd->cdb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700499 switch (flags & (SRB_DataIn | SRB_DataOut)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 case SRB_DataOut:
501 data_dir = DMA_TO_DEVICE;
502 break;
503 case (SRB_DataIn | SRB_DataOut):
504 data_dir = DMA_BIDIRECTIONAL;
505 break;
506 case SRB_DataIn:
507 data_dir = DMA_FROM_DEVICE;
508 break;
509 default:
510 data_dir = DMA_NONE;
511 }
Mark Haverkamp5d497ce2005-06-17 13:38:04 -0700512 if (user_srbcmd->sg.count > (sizeof(sg_list)/sizeof(sg_list[0]))) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700513 dprintk((KERN_DEBUG"aacraid: too many sg entries %d\n",
514 le32_to_cpu(srbcmd->sg.count)));
515 rcode = -EINVAL;
516 goto cleanup;
517 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (dev->dac_support == 1) {
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700519 struct user_sgmap64* upsg = (struct user_sgmap64*)&user_srbcmd->sg;
520 struct sgmap64* psg = (struct sgmap64*)&user_srbcmd->sg;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700521 struct user_sgmap* usg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 byte_count = 0;
523
524 /*
525 * This should also catch if user used the 32 bit sgmap
526 */
527 actual_fibsize = sizeof(struct aac_srb) -
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700528 sizeof(struct sgentry) +
529 ((upsg->count & 0xff) *
530 sizeof(struct sgentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 if(actual_fibsize != fibsize){ // User made a mistake - should not continue
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700532 dprintk((KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 rcode = -EINVAL;
534 goto cleanup;
535 }
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700536 usg = kmalloc(actual_fibsize - sizeof(struct aac_srb)
537 + sizeof(struct sgmap), GFP_KERNEL);
538 if (!usg) {
539 dprintk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
540 rcode = -ENOMEM;
541 goto cleanup;
542 }
543 memcpy (usg, upsg, actual_fibsize - sizeof(struct aac_srb)
544 + sizeof(struct sgmap));
545 actual_fibsize = sizeof(struct aac_srb) -
546 sizeof(struct sgentry) + ((usg->count & 0xff) *
547 sizeof(struct sgentry64));
548 if ((data_dir == DMA_NONE) && upsg->count) {
549 kfree (usg);
550 dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 rcode = -EINVAL;
552 goto cleanup;
553 }
554
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700555 for (i = 0; i < usg->count; i++) {
556 u64 addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 void* p;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700558 /* Does this really need to be GFP_DMA? */
559 p = kmalloc(usg->sg[i].count,GFP_KERNEL|__GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if(p == 0) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700561 kfree (usg);
562 dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
563 usg->sg[i].count,i,usg->count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 rcode = -ENOMEM;
565 goto cleanup;
566 }
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700567 sg_user[i] = (void __user *)usg->sg[i].addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 sg_list[i] = p; // save so we can clean up later
569 sg_indx = i;
570
571 if( flags & SRB_DataOut ){
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700572 if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700573 kfree (usg);
574 dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 rcode = -EFAULT;
576 goto cleanup;
577 }
578 }
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700579 addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700581 psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700582 psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
583 psg->sg[i].count = cpu_to_le32(usg->sg[i].count);
584 byte_count += usg->sg[i].count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 }
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700586 kfree (usg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 srbcmd->count = cpu_to_le32(byte_count);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700589 psg->count = cpu_to_le32(sg_indx+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 status = fib_send(ScsiPortCommand64, srbfib, actual_fibsize, FsaNormal, 1, 1,NULL,NULL);
591 } else {
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700592 struct user_sgmap* upsg = &user_srbcmd->sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 struct sgmap* psg = &srbcmd->sg;
594 byte_count = 0;
595
Mark Haverkamp5d497ce2005-06-17 13:38:04 -0700596 actual_fibsize = sizeof (struct aac_srb) + (((user_srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if(actual_fibsize != fibsize){ // User made a mistake - should not continue
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700598 dprintk((KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 rcode = -EINVAL;
600 goto cleanup;
601 }
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700602 if ((data_dir == DMA_NONE) && upsg->count) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700603 dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 rcode = -EINVAL;
605 goto cleanup;
606 }
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700607 for (i = 0; i < upsg->count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 dma_addr_t addr;
609 void* p;
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700610 p = kmalloc(upsg->sg[i].count, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if(p == 0) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700612 dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
613 upsg->sg[i].count, i, upsg->count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 rcode = -ENOMEM;
615 goto cleanup;
616 }
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700617 sg_user[i] = (void __user *)upsg->sg[i].addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 sg_list[i] = p; // save so we can clean up later
619 sg_indx = i;
620
621 if( flags & SRB_DataOut ){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700622 if(copy_from_user(p, sg_user[i],
623 upsg->sg[i].count)) {
624 dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 rcode = -EFAULT;
626 goto cleanup;
627 }
628 }
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700629 addr = pci_map_single(dev->pdev, p,
630 upsg->sg[i].count, data_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
632 psg->sg[i].addr = cpu_to_le32(addr);
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700633 psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);
634 byte_count += upsg->sg[i].count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636 srbcmd->count = cpu_to_le32(byte_count);
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700637 psg->count = cpu_to_le32(sg_indx+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 status = fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
639 }
640
641 if (status != 0){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700642 dprintk((KERN_DEBUG"aacraid: Could not send raw srb fib to hba\n"));
Mark Haverkamp5d497ce2005-06-17 13:38:04 -0700643 rcode = -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 goto cleanup;
645 }
646
647 if( flags & SRB_DataIn ) {
648 for(i = 0 ; i <= sg_indx; i++){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700649 byte_count = le32_to_cpu((dev->dac_support == 1)
650 ? ((struct sgmap64*)&srbcmd->sg)->sg[i].count
651 : srbcmd->sg.sg[i].count);
652 if(copy_to_user(sg_user[i], sg_list[i], byte_count)){
653 dprintk((KERN_DEBUG"aacraid: Could not copy sg data to user\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 rcode = -EFAULT;
655 goto cleanup;
656
657 }
658 }
659 }
660
661 reply = (struct aac_srb_reply *) fib_data(srbfib);
662 if(copy_to_user(user_reply,reply,sizeof(struct aac_srb_reply))){
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700663 dprintk((KERN_DEBUG"aacraid: Could not copy reply to user\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 rcode = -EFAULT;
665 goto cleanup;
666 }
667
668cleanup:
Mark Haverkamp 56b58712005-04-27 06:05:51 -0700669 kfree(user_srbcmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 for(i=0; i <= sg_indx; i++){
671 kfree(sg_list[i]);
672 }
673 fib_complete(srbfib);
674 fib_free(srbfib);
675
676 return rcode;
677}
678
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679struct aac_pci_info {
680 u32 bus;
681 u32 slot;
682};
683
684
Adrian Bunk 48338692005-04-25 19:45:58 -0700685static int aac_get_pci_info(struct aac_dev* dev, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686{
687 struct aac_pci_info pci_info;
688
689 pci_info.bus = dev->pdev->bus->number;
690 pci_info.slot = PCI_SLOT(dev->pdev->devfn);
691
692 if (copy_to_user(arg, &pci_info, sizeof(struct aac_pci_info))) {
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700693 dprintk((KERN_DEBUG "aacraid: Could not copy pci info\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 return -EFAULT;
695 }
696 return 0;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700697}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
699
700int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg)
701{
702 int status;
703
704 /*
705 * HBA gets first crack
706 */
707
708 status = aac_dev_ioctl(dev, cmd, arg);
709 if(status != -ENOTTY)
710 return status;
711
712 switch (cmd) {
713 case FSACTL_MINIPORT_REV_CHECK:
714 status = check_revision(dev, arg);
715 break;
Mark Haverkamp 7c00ffa2005-05-16 18:28:42 -0700716 case FSACTL_SEND_LARGE_FIB:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 case FSACTL_SENDFIB:
718 status = ioctl_send_fib(dev, arg);
719 break;
720 case FSACTL_OPEN_GET_ADAPTER_FIB:
721 status = open_getadapter_fib(dev, arg);
722 break;
723 case FSACTL_GET_NEXT_ADAPTER_FIB:
724 status = next_getadapter_fib(dev, arg);
725 break;
726 case FSACTL_CLOSE_GET_ADAPTER_FIB:
727 status = close_getadapter_fib(dev, arg);
728 break;
729 case FSACTL_SEND_RAW_SRB:
730 status = aac_send_raw_srb(dev,arg);
731 break;
732 case FSACTL_GET_PCI_INFO:
733 status = aac_get_pci_info(dev,arg);
734 break;
735 default:
736 status = -ENOTTY;
737 break;
738 }
739 return status;
740}
741