Merge branch 'smsc47b397-new-id' into release
[linux-2.6] / drivers / scsi / megaraid / megaraid_mm.c
1 /*
2  *
3  *                      Linux MegaRAID device driver
4  *
5  * Copyright (c) 2003-2004  LSI Logic Corporation.
6  *
7  *         This program is free software; you can redistribute it and/or
8  *         modify it under the terms of the GNU General Public License
9  *         as published by the Free Software Foundation; either version
10  *         2 of the License, or (at your option) any later version.
11  *
12  * FILE         : megaraid_mm.c
13  * Version      : v2.20.2.7 (Jul 16 2006)
14  *
15  * Common management module
16  */
17 #include <linux/sched.h>
18 #include "megaraid_mm.h"
19
20
21 // Entry points for char node driver
22 static int mraid_mm_open(struct inode *, struct file *);
23 static int mraid_mm_ioctl(struct inode *, struct file *, uint, unsigned long);
24
25
26 // routines to convert to and from the old the format
27 static int mimd_to_kioc(mimd_t __user *, mraid_mmadp_t *, uioc_t *);
28 static int kioc_to_mimd(uioc_t *, mimd_t __user *);
29
30
31 // Helper functions
32 static int handle_drvrcmd(void __user *, uint8_t, int *);
33 static int lld_ioctl(mraid_mmadp_t *, uioc_t *);
34 static void ioctl_done(uioc_t *);
35 static void lld_timedout(unsigned long);
36 static void hinfo_to_cinfo(mraid_hba_info_t *, mcontroller_t *);
37 static mraid_mmadp_t *mraid_mm_get_adapter(mimd_t __user *, int *);
38 static uioc_t *mraid_mm_alloc_kioc(mraid_mmadp_t *);
39 static void mraid_mm_dealloc_kioc(mraid_mmadp_t *, uioc_t *);
40 static int mraid_mm_attach_buf(mraid_mmadp_t *, uioc_t *, int);
41 static int mraid_mm_setup_dma_pools(mraid_mmadp_t *);
42 static void mraid_mm_free_adp_resources(mraid_mmadp_t *);
43 static void mraid_mm_teardown_dma_pools(mraid_mmadp_t *);
44
45 #ifdef CONFIG_COMPAT
46 static long mraid_mm_compat_ioctl(struct file *, unsigned int, unsigned long);
47 #endif
48
49 MODULE_AUTHOR("LSI Logic Corporation");
50 MODULE_DESCRIPTION("LSI Logic Management Module");
51 MODULE_LICENSE("GPL");
52 MODULE_VERSION(LSI_COMMON_MOD_VERSION);
53
54 static int dbglevel = CL_ANN;
55 module_param_named(dlevel, dbglevel, int, 0);
56 MODULE_PARM_DESC(dlevel, "Debug level (default=0)");
57
58 EXPORT_SYMBOL(mraid_mm_register_adp);
59 EXPORT_SYMBOL(mraid_mm_unregister_adp);
60 EXPORT_SYMBOL(mraid_mm_adapter_app_handle);
61
62 static uint32_t drvr_ver        = 0x02200207;
63
64 static int adapters_count_g;
65 static struct list_head adapters_list_g;
66
67 static wait_queue_head_t wait_q;
68
69 static const struct file_operations lsi_fops = {
70         .open   = mraid_mm_open,
71         .ioctl  = mraid_mm_ioctl,
72 #ifdef CONFIG_COMPAT
73         .compat_ioctl = mraid_mm_compat_ioctl,
74 #endif
75         .owner  = THIS_MODULE,
76 };
77
78 static struct miscdevice megaraid_mm_dev = {
79         .minor  = MISC_DYNAMIC_MINOR,
80         .name   = "megadev0",
81         .fops   = &lsi_fops,
82 };
83
84 /**
85  * mraid_mm_open - open routine for char node interface
86  * @inode       : unused
87  * @filep       : unused
88  *
89  * Allow ioctl operations by apps only if they have superuser privilege.
90  */
91 static int
92 mraid_mm_open(struct inode *inode, struct file *filep)
93 {
94         /*
95          * Only allow superuser to access private ioctl interface
96          */
97         if (!capable(CAP_SYS_ADMIN)) return (-EACCES);
98
99         return 0;
100 }
101
102 /**
103  * mraid_mm_ioctl - module entry-point for ioctls
104  * @inode       : inode (ignored)
105  * @filep       : file operations pointer (ignored)
106  * @cmd         : ioctl command
107  * @arg         : user ioctl packet
108  */
109 static int
110 mraid_mm_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
111                                                         unsigned long arg)
112 {
113         uioc_t          *kioc;
114         char            signature[EXT_IOCTL_SIGN_SZ]    = {0};
115         int             rval;
116         mraid_mmadp_t   *adp;
117         uint8_t         old_ioctl;
118         int             drvrcmd_rval;
119         void __user *argp = (void __user *)arg;
120
121         /*
122          * Make sure only USCSICMD are issued through this interface.
123          * MIMD application would still fire different command.
124          */
125
126         if ((_IOC_TYPE(cmd) != MEGAIOC_MAGIC) && (cmd != USCSICMD)) {
127                 return (-EINVAL);
128         }
129
130         /*
131          * Look for signature to see if this is the new or old ioctl format.
132          */
133         if (copy_from_user(signature, argp, EXT_IOCTL_SIGN_SZ)) {
134                 con_log(CL_ANN, (KERN_WARNING
135                         "megaraid cmm: copy from usr addr failed\n"));
136                 return (-EFAULT);
137         }
138
139         if (memcmp(signature, EXT_IOCTL_SIGN, EXT_IOCTL_SIGN_SZ) == 0)
140                 old_ioctl = 0;
141         else
142                 old_ioctl = 1;
143
144         /*
145          * At present, we don't support the new ioctl packet
146          */
147         if (!old_ioctl )
148                 return (-EINVAL);
149
150         /*
151          * If it is a driver ioctl (as opposed to fw ioctls), then we can
152          * handle the command locally. rval > 0 means it is not a drvr cmd
153          */
154         rval = handle_drvrcmd(argp, old_ioctl, &drvrcmd_rval);
155
156         if (rval < 0)
157                 return rval;
158         else if (rval == 0)
159                 return drvrcmd_rval;
160
161         rval = 0;
162         if ((adp = mraid_mm_get_adapter(argp, &rval)) == NULL) {
163                 return rval;
164         }
165
166         /*
167          * Check if adapter can accept ioctl. We may have marked it offline
168          * if any previous kioc had timedout on this controller.
169          */
170         if (!adp->quiescent) {
171                 con_log(CL_ANN, (KERN_WARNING
172                         "megaraid cmm: controller cannot accept cmds due to "
173                         "earlier errors\n" ));
174                 return -EFAULT;
175         }
176
177         /*
178          * The following call will block till a kioc is available
179          */
180         kioc = mraid_mm_alloc_kioc(adp);
181
182         /*
183          * User sent the old mimd_t ioctl packet. Convert it to uioc_t.
184          */
185         if ((rval = mimd_to_kioc(argp, adp, kioc))) {
186                 mraid_mm_dealloc_kioc(adp, kioc);
187                 return rval;
188         }
189
190         kioc->done = ioctl_done;
191
192         /*
193          * Issue the IOCTL to the low level driver. After the IOCTL completes
194          * release the kioc if and only if it was _not_ timedout. If it was
195          * timedout, that means that resources are still with low level driver.
196          */
197         if ((rval = lld_ioctl(adp, kioc))) {
198
199                 if (!kioc->timedout)
200                         mraid_mm_dealloc_kioc(adp, kioc);
201
202                 return rval;
203         }
204
205         /*
206          * Convert the kioc back to user space
207          */
208         rval = kioc_to_mimd(kioc, argp);
209
210         /*
211          * Return the kioc to free pool
212          */
213         mraid_mm_dealloc_kioc(adp, kioc);
214
215         return rval;
216 }
217
218
219 /**
220  * mraid_mm_get_adapter - Returns corresponding adapters for the mimd packet
221  * @umimd       : User space mimd_t ioctl packet
222  * @rval        : returned success/error status
223  *
224  * The function return value is a pointer to the located @adapter.
225  */
226 static mraid_mmadp_t *
227 mraid_mm_get_adapter(mimd_t __user *umimd, int *rval)
228 {
229         mraid_mmadp_t   *adapter;
230         mimd_t          mimd;
231         uint32_t        adapno;
232         int             iterator;
233
234
235         if (copy_from_user(&mimd, umimd, sizeof(mimd_t))) {
236                 *rval = -EFAULT;
237                 return NULL;
238         }
239
240         adapno = GETADAP(mimd.ui.fcs.adapno);
241
242         if (adapno >= adapters_count_g) {
243                 *rval = -ENODEV;
244                 return NULL;
245         }
246
247         adapter = NULL;
248         iterator = 0;
249
250         list_for_each_entry(adapter, &adapters_list_g, list) {
251                 if (iterator++ == adapno) break;
252         }
253
254         if (!adapter) {
255                 *rval = -ENODEV;
256                 return NULL;
257         }
258
259         return adapter;
260 }
261
262 /**
263  * handle_drvrcmd - Checks if the opcode is a driver cmd and if it is, handles it.
264  * @arg         : packet sent by the user app
265  * @old_ioctl   : mimd if 1; uioc otherwise
266  * @rval        : pointer for command's returned value (not function status)
267  */
268 static int
269 handle_drvrcmd(void __user *arg, uint8_t old_ioctl, int *rval)
270 {
271         mimd_t          __user *umimd;
272         mimd_t          kmimd;
273         uint8_t         opcode;
274         uint8_t         subopcode;
275
276         if (old_ioctl)
277                 goto old_packet;
278         else
279                 goto new_packet;
280
281 new_packet:
282         return (-ENOTSUPP);
283
284 old_packet:
285         *rval = 0;
286         umimd = arg;
287
288         if (copy_from_user(&kmimd, umimd, sizeof(mimd_t)))
289                 return (-EFAULT);
290
291         opcode          = kmimd.ui.fcs.opcode;
292         subopcode       = kmimd.ui.fcs.subopcode;
293
294         /*
295          * If the opcode is 0x82 and the subopcode is either GET_DRVRVER or
296          * GET_NUMADP, then we can handle. Otherwise we should return 1 to
297          * indicate that we cannot handle this.
298          */
299         if (opcode != 0x82)
300                 return 1;
301
302         switch (subopcode) {
303
304         case MEGAIOC_QDRVRVER:
305
306                 if (copy_to_user(kmimd.data, &drvr_ver, sizeof(uint32_t)))
307                         return (-EFAULT);
308
309                 return 0;
310
311         case MEGAIOC_QNADAP:
312
313                 *rval = adapters_count_g;
314
315                 if (copy_to_user(kmimd.data, &adapters_count_g,
316                                 sizeof(uint32_t)))
317                         return (-EFAULT);
318
319                 return 0;
320
321         default:
322                 /* cannot handle */
323                 return 1;
324         }
325
326         return 0;
327 }
328
329
330 /**
331  * mimd_to_kioc - Converter from old to new ioctl format
332  * @umimd       : user space old MIMD IOCTL
333  * @adp         : adapter softstate
334  * @kioc        : kernel space new format IOCTL
335  *
336  * Routine to convert MIMD interface IOCTL to new interface IOCTL packet. The
337  * new packet is in kernel space so that driver can perform operations on it
338  * freely.
339  */
340
341 static int
342 mimd_to_kioc(mimd_t __user *umimd, mraid_mmadp_t *adp, uioc_t *kioc)
343 {
344         mbox64_t                *mbox64;
345         mbox_t                  *mbox;
346         mraid_passthru_t        *pthru32;
347         uint32_t                adapno;
348         uint8_t                 opcode;
349         uint8_t                 subopcode;
350         mimd_t                  mimd;
351
352         if (copy_from_user(&mimd, umimd, sizeof(mimd_t)))
353                 return (-EFAULT);
354
355         /*
356          * Applications are not allowed to send extd pthru
357          */
358         if ((mimd.mbox[0] == MBOXCMD_PASSTHRU64) ||
359                         (mimd.mbox[0] == MBOXCMD_EXTPTHRU))
360                 return (-EINVAL);
361
362         opcode          = mimd.ui.fcs.opcode;
363         subopcode       = mimd.ui.fcs.subopcode;
364         adapno          = GETADAP(mimd.ui.fcs.adapno);
365
366         if (adapno >= adapters_count_g)
367                 return (-ENODEV);
368
369         kioc->adapno    = adapno;
370         kioc->mb_type   = MBOX_LEGACY;
371         kioc->app_type  = APPTYPE_MIMD;
372
373         switch (opcode) {
374
375         case 0x82:
376
377                 if (subopcode == MEGAIOC_QADAPINFO) {
378
379                         kioc->opcode    = GET_ADAP_INFO;
380                         kioc->data_dir  = UIOC_RD;
381                         kioc->xferlen   = sizeof(mraid_hba_info_t);
382
383                         if (mraid_mm_attach_buf(adp, kioc, kioc->xferlen))
384                                 return (-ENOMEM);
385                 }
386                 else {
387                         con_log(CL_ANN, (KERN_WARNING
388                                         "megaraid cmm: Invalid subop\n"));
389                         return (-EINVAL);
390                 }
391
392                 break;
393
394         case 0x81:
395
396                 kioc->opcode            = MBOX_CMD;
397                 kioc->xferlen           = mimd.ui.fcs.length;
398                 kioc->user_data_len     = kioc->xferlen;
399                 kioc->user_data         = mimd.ui.fcs.buffer;
400
401                 if (mraid_mm_attach_buf(adp, kioc, kioc->xferlen))
402                         return (-ENOMEM);
403
404                 if (mimd.outlen) kioc->data_dir  = UIOC_RD;
405                 if (mimd.inlen) kioc->data_dir |= UIOC_WR;
406
407                 break;
408
409         case 0x80:
410
411                 kioc->opcode            = MBOX_CMD;
412                 kioc->xferlen           = (mimd.outlen > mimd.inlen) ?
413                                                 mimd.outlen : mimd.inlen;
414                 kioc->user_data_len     = kioc->xferlen;
415                 kioc->user_data         = mimd.data;
416
417                 if (mraid_mm_attach_buf(adp, kioc, kioc->xferlen))
418                         return (-ENOMEM);
419
420                 if (mimd.outlen) kioc->data_dir  = UIOC_RD;
421                 if (mimd.inlen) kioc->data_dir |= UIOC_WR;
422
423                 break;
424
425         default:
426                 return (-EINVAL);
427         }
428
429         /*
430          * If driver command, nothing else to do
431          */
432         if (opcode == 0x82)
433                 return 0;
434
435         /*
436          * This is a mailbox cmd; copy the mailbox from mimd
437          */
438         mbox64  = (mbox64_t *)((unsigned long)kioc->cmdbuf);
439         mbox    = &mbox64->mbox32;
440         memcpy(mbox, mimd.mbox, 14);
441
442         if (mbox->cmd != MBOXCMD_PASSTHRU) {    // regular DCMD
443
444                 mbox->xferaddr  = (uint32_t)kioc->buf_paddr;
445
446                 if (kioc->data_dir & UIOC_WR) {
447                         if (copy_from_user(kioc->buf_vaddr, kioc->user_data,
448                                                         kioc->xferlen)) {
449                                 return (-EFAULT);
450                         }
451                 }
452
453                 return 0;
454         }
455
456         /*
457          * This is a regular 32-bit pthru cmd; mbox points to pthru struct.
458          * Just like in above case, the beginning for memblk is treated as
459          * a mailbox. The passthru will begin at next 1K boundary. And the
460          * data will start 1K after that.
461          */
462         pthru32                 = kioc->pthru32;
463         kioc->user_pthru        = &umimd->pthru;
464         mbox->xferaddr          = (uint32_t)kioc->pthru32_h;
465
466         if (copy_from_user(pthru32, kioc->user_pthru,
467                         sizeof(mraid_passthru_t))) {
468                 return (-EFAULT);
469         }
470
471         pthru32->dataxferaddr   = kioc->buf_paddr;
472         if (kioc->data_dir & UIOC_WR) {
473                 if (copy_from_user(kioc->buf_vaddr, kioc->user_data,
474                                                 pthru32->dataxferlen)) {
475                         return (-EFAULT);
476                 }
477         }
478
479         return 0;
480 }
481
482 /**
483  * mraid_mm_attch_buf - Attach a free dma buffer for required size
484  * @adp         : Adapter softstate
485  * @kioc        : kioc that the buffer needs to be attached to
486  * @xferlen     : required length for buffer
487  *
488  * First we search for a pool with smallest buffer that is >= @xferlen. If
489  * that pool has no free buffer, we will try for the next bigger size. If none
490  * is available, we will try to allocate the smallest buffer that is >=
491  * @xferlen and attach it the pool.
492  */
493 static int
494 mraid_mm_attach_buf(mraid_mmadp_t *adp, uioc_t *kioc, int xferlen)
495 {
496         mm_dmapool_t    *pool;
497         int             right_pool = -1;
498         unsigned long   flags;
499         int             i;
500
501         kioc->pool_index        = -1;
502         kioc->buf_vaddr         = NULL;
503         kioc->buf_paddr         = 0;
504         kioc->free_buf          = 0;
505
506         /*
507          * We need xferlen amount of memory. See if we can get it from our
508          * dma pools. If we don't get exact size, we will try bigger buffer
509          */
510
511         for (i = 0; i < MAX_DMA_POOLS; i++) {
512
513                 pool = &adp->dma_pool_list[i];
514
515                 if (xferlen > pool->buf_size)
516                         continue;
517
518                 if (right_pool == -1)
519                         right_pool = i;
520
521                 spin_lock_irqsave(&pool->lock, flags);
522
523                 if (!pool->in_use) {
524
525                         pool->in_use            = 1;
526                         kioc->pool_index        = i;
527                         kioc->buf_vaddr         = pool->vaddr;
528                         kioc->buf_paddr         = pool->paddr;
529
530                         spin_unlock_irqrestore(&pool->lock, flags);
531                         return 0;
532                 }
533                 else {
534                         spin_unlock_irqrestore(&pool->lock, flags);
535                         continue;
536                 }
537         }
538
539         /*
540          * If xferlen doesn't match any of our pools, return error
541          */
542         if (right_pool == -1)
543                 return -EINVAL;
544
545         /*
546          * We did not get any buffer from the preallocated pool. Let us try
547          * to allocate one new buffer. NOTE: This is a blocking call.
548          */
549         pool = &adp->dma_pool_list[right_pool];
550
551         spin_lock_irqsave(&pool->lock, flags);
552
553         kioc->pool_index        = right_pool;
554         kioc->free_buf          = 1;
555         kioc->buf_vaddr         = pci_pool_alloc(pool->handle, GFP_KERNEL,
556                                                         &kioc->buf_paddr);
557         spin_unlock_irqrestore(&pool->lock, flags);
558
559         if (!kioc->buf_vaddr)
560                 return -ENOMEM;
561
562         return 0;
563 }
564
565 /**
566  * mraid_mm_alloc_kioc - Returns a uioc_t from free list
567  * @adp : Adapter softstate for this module
568  *
569  * The kioc_semaphore is initialized with number of kioc nodes in the
570  * free kioc pool. If the kioc pool is empty, this function blocks till
571  * a kioc becomes free.
572  */
573 static uioc_t *
574 mraid_mm_alloc_kioc(mraid_mmadp_t *adp)
575 {
576         uioc_t                  *kioc;
577         struct list_head*       head;
578         unsigned long           flags;
579
580         down(&adp->kioc_semaphore);
581
582         spin_lock_irqsave(&adp->kioc_pool_lock, flags);
583
584         head = &adp->kioc_pool;
585
586         if (list_empty(head)) {
587                 up(&adp->kioc_semaphore);
588                 spin_unlock_irqrestore(&adp->kioc_pool_lock, flags);
589
590                 con_log(CL_ANN, ("megaraid cmm: kioc list empty!\n"));
591                 return NULL;
592         }
593
594         kioc = list_entry(head->next, uioc_t, list);
595         list_del_init(&kioc->list);
596
597         spin_unlock_irqrestore(&adp->kioc_pool_lock, flags);
598
599         memset((caddr_t)(unsigned long)kioc->cmdbuf, 0, sizeof(mbox64_t));
600         memset((caddr_t) kioc->pthru32, 0, sizeof(mraid_passthru_t));
601
602         kioc->buf_vaddr         = NULL;
603         kioc->buf_paddr         = 0;
604         kioc->pool_index        =-1;
605         kioc->free_buf          = 0;
606         kioc->user_data         = NULL;
607         kioc->user_data_len     = 0;
608         kioc->user_pthru        = NULL;
609         kioc->timedout          = 0;
610
611         return kioc;
612 }
613
614 /**
615  * mraid_mm_dealloc_kioc - Return kioc to free pool
616  * @adp         : Adapter softstate
617  * @kioc        : uioc_t node to be returned to free pool
618  */
619 static void
620 mraid_mm_dealloc_kioc(mraid_mmadp_t *adp, uioc_t *kioc)
621 {
622         mm_dmapool_t    *pool;
623         unsigned long   flags;
624
625         if (kioc->pool_index != -1) {
626                 pool = &adp->dma_pool_list[kioc->pool_index];
627
628                 /* This routine may be called in non-isr context also */
629                 spin_lock_irqsave(&pool->lock, flags);
630
631                 /*
632                  * While attaching the dma buffer, if we didn't get the 
633                  * required buffer from the pool, we would have allocated 
634                  * it at the run time and set the free_buf flag. We must 
635                  * free that buffer. Otherwise, just mark that the buffer is 
636                  * not in use
637                  */
638                 if (kioc->free_buf == 1)
639                         pci_pool_free(pool->handle, kioc->buf_vaddr, 
640                                                         kioc->buf_paddr);
641                 else
642                         pool->in_use = 0;
643
644                 spin_unlock_irqrestore(&pool->lock, flags);
645         }
646
647         /* Return the kioc to the free pool */
648         spin_lock_irqsave(&adp->kioc_pool_lock, flags);
649         list_add(&kioc->list, &adp->kioc_pool);
650         spin_unlock_irqrestore(&adp->kioc_pool_lock, flags);
651
652         /* increment the free kioc count */
653         up(&adp->kioc_semaphore);
654
655         return;
656 }
657
658 /**
659  * lld_ioctl - Routine to issue ioctl to low level drvr
660  * @adp         : The adapter handle
661  * @kioc        : The ioctl packet with kernel addresses
662  */
663 static int
664 lld_ioctl(mraid_mmadp_t *adp, uioc_t *kioc)
665 {
666         int                     rval;
667         struct timer_list       timer;
668         struct timer_list       *tp = NULL;
669
670         kioc->status    = -ENODATA;
671         rval            = adp->issue_uioc(adp->drvr_data, kioc, IOCTL_ISSUE);
672
673         if (rval) return rval;
674
675         /*
676          * Start the timer
677          */
678         if (adp->timeout > 0) {
679                 tp              = &timer;
680                 init_timer(tp);
681
682                 tp->function    = lld_timedout;
683                 tp->data        = (unsigned long)kioc;
684                 tp->expires     = jiffies + adp->timeout * HZ;
685
686                 add_timer(tp);
687         }
688
689         /*
690          * Wait till the low level driver completes the ioctl. After this
691          * call, the ioctl either completed successfully or timedout.
692          */
693         wait_event(wait_q, (kioc->status != -ENODATA));
694         if (tp) {
695                 del_timer_sync(tp);
696         }
697
698         /*
699          * If the command had timedout, we mark the controller offline
700          * before returning
701          */
702         if (kioc->timedout) {
703                 adp->quiescent = 0;
704         }
705
706         return kioc->status;
707 }
708
709
710 /**
711  * ioctl_done - callback from the low level driver
712  * @kioc        : completed ioctl packet
713  */
714 static void
715 ioctl_done(uioc_t *kioc)
716 {
717         uint32_t        adapno;
718         int             iterator;
719         mraid_mmadp_t*  adapter;
720
721         /*
722          * When the kioc returns from driver, make sure it still doesn't
723          * have ENODATA in status. Otherwise, driver will hang on wait_event
724          * forever
725          */
726         if (kioc->status == -ENODATA) {
727                 con_log(CL_ANN, (KERN_WARNING
728                         "megaraid cmm: lld didn't change status!\n"));
729
730                 kioc->status = -EINVAL;
731         }
732
733         /*
734          * Check if this kioc was timedout before. If so, nobody is waiting
735          * on this kioc. We don't have to wake up anybody. Instead, we just
736          * have to free the kioc
737          */
738         if (kioc->timedout) {
739                 iterator        = 0;
740                 adapter         = NULL;
741                 adapno          = kioc->adapno;
742
743                 con_log(CL_ANN, ( KERN_WARNING "megaraid cmm: completed "
744                                         "ioctl that was timedout before\n"));
745
746                 list_for_each_entry(adapter, &adapters_list_g, list) {
747                         if (iterator++ == adapno) break;
748                 }
749
750                 kioc->timedout = 0;
751
752                 if (adapter) {
753                         mraid_mm_dealloc_kioc( adapter, kioc );
754                 }
755         }
756         else {
757                 wake_up(&wait_q);
758         }
759 }
760
761
762 /**
763  * lld_timedout - callback from the expired timer
764  * @ptr         : ioctl packet that timed out
765  */
766 static void
767 lld_timedout(unsigned long ptr)
768 {
769         uioc_t *kioc    = (uioc_t *)ptr;
770
771         kioc->status    = -ETIME;
772         kioc->timedout  = 1;
773
774         con_log(CL_ANN, (KERN_WARNING "megaraid cmm: ioctl timed out\n"));
775
776         wake_up(&wait_q);
777 }
778
779
780 /**
781  * kioc_to_mimd - Converter from new back to old format
782  * @kioc        : Kernel space IOCTL packet (successfully issued)
783  * @mimd        : User space MIMD packet
784  */
785 static int
786 kioc_to_mimd(uioc_t *kioc, mimd_t __user *mimd)
787 {
788         mimd_t                  kmimd;
789         uint8_t                 opcode;
790         uint8_t                 subopcode;
791
792         mbox64_t                *mbox64;
793         mraid_passthru_t        __user *upthru32;
794         mraid_passthru_t        *kpthru32;
795         mcontroller_t           cinfo;
796         mraid_hba_info_t        *hinfo;
797
798
799         if (copy_from_user(&kmimd, mimd, sizeof(mimd_t)))
800                 return (-EFAULT);
801
802         opcode          = kmimd.ui.fcs.opcode;
803         subopcode       = kmimd.ui.fcs.subopcode;
804
805         if (opcode == 0x82) {
806                 switch (subopcode) {
807
808                 case MEGAIOC_QADAPINFO:
809
810                         hinfo = (mraid_hba_info_t *)(unsigned long)
811                                         kioc->buf_vaddr;
812
813                         hinfo_to_cinfo(hinfo, &cinfo);
814
815                         if (copy_to_user(kmimd.data, &cinfo, sizeof(cinfo)))
816                                 return (-EFAULT);
817
818                         return 0;
819
820                 default:
821                         return (-EINVAL);
822                 }
823
824                 return 0;
825         }
826
827         mbox64 = (mbox64_t *)(unsigned long)kioc->cmdbuf;
828
829         if (kioc->user_pthru) {
830
831                 upthru32 = kioc->user_pthru;
832                 kpthru32 = kioc->pthru32;
833
834                 if (copy_to_user(&upthru32->scsistatus,
835                                         &kpthru32->scsistatus,
836                                         sizeof(uint8_t))) {
837                         return (-EFAULT);
838                 }
839         }
840
841         if (kioc->user_data) {
842                 if (copy_to_user(kioc->user_data, kioc->buf_vaddr,
843                                         kioc->user_data_len)) {
844                         return (-EFAULT);
845                 }
846         }
847
848         if (copy_to_user(&mimd->mbox[17],
849                         &mbox64->mbox32.status, sizeof(uint8_t))) {
850                 return (-EFAULT);
851         }
852
853         return 0;
854 }
855
856
857 /**
858  * hinfo_to_cinfo - Convert new format hba info into old format
859  * @hinfo       : New format, more comprehensive adapter info
860  * @cinfo       : Old format adapter info to support mimd_t apps
861  */
862 static void
863 hinfo_to_cinfo(mraid_hba_info_t *hinfo, mcontroller_t *cinfo)
864 {
865         if (!hinfo || !cinfo)
866                 return;
867
868         cinfo->base             = hinfo->baseport;
869         cinfo->irq              = hinfo->irq;
870         cinfo->numldrv          = hinfo->num_ldrv;
871         cinfo->pcibus           = hinfo->pci_bus;
872         cinfo->pcidev           = hinfo->pci_slot;
873         cinfo->pcifun           = PCI_FUNC(hinfo->pci_dev_fn);
874         cinfo->pciid            = hinfo->pci_device_id;
875         cinfo->pcivendor        = hinfo->pci_vendor_id;
876         cinfo->pcislot          = hinfo->pci_slot;
877         cinfo->uid              = hinfo->unique_id;
878 }
879
880
881 /**
882  * mraid_mm_register_adp - Registration routine for low level drivers
883  * @lld_adp     : Adapter objejct
884  */
885 int
886 mraid_mm_register_adp(mraid_mmadp_t *lld_adp)
887 {
888         mraid_mmadp_t   *adapter;
889         mbox64_t        *mbox_list;
890         uioc_t          *kioc;
891         uint32_t        rval;
892         int             i;
893
894
895         if (lld_adp->drvr_type != DRVRTYPE_MBOX)
896                 return (-EINVAL);
897
898         adapter = kzalloc(sizeof(mraid_mmadp_t), GFP_KERNEL);
899
900         if (!adapter)
901                 return -ENOMEM;
902
903
904         adapter->unique_id      = lld_adp->unique_id;
905         adapter->drvr_type      = lld_adp->drvr_type;
906         adapter->drvr_data      = lld_adp->drvr_data;
907         adapter->pdev           = lld_adp->pdev;
908         adapter->issue_uioc     = lld_adp->issue_uioc;
909         adapter->timeout        = lld_adp->timeout;
910         adapter->max_kioc       = lld_adp->max_kioc;
911         adapter->quiescent      = 1;
912
913         /*
914          * Allocate single blocks of memory for all required kiocs,
915          * mailboxes and passthru structures.
916          */
917         adapter->kioc_list      = kmalloc(sizeof(uioc_t) * lld_adp->max_kioc,
918                                                 GFP_KERNEL);
919         adapter->mbox_list      = kmalloc(sizeof(mbox64_t) * lld_adp->max_kioc,
920                                                 GFP_KERNEL);
921         adapter->pthru_dma_pool = pci_pool_create("megaraid mm pthru pool",
922                                                 adapter->pdev,
923                                                 sizeof(mraid_passthru_t),
924                                                 16, 0);
925
926         if (!adapter->kioc_list || !adapter->mbox_list ||
927                         !adapter->pthru_dma_pool) {
928
929                 con_log(CL_ANN, (KERN_WARNING
930                         "megaraid cmm: out of memory, %s %d\n", __FUNCTION__,
931                         __LINE__));
932
933                 rval = (-ENOMEM);
934
935                 goto memalloc_error;
936         }
937
938         /*
939          * Slice kioc_list and make a kioc_pool with the individiual kiocs
940          */
941         INIT_LIST_HEAD(&adapter->kioc_pool);
942         spin_lock_init(&adapter->kioc_pool_lock);
943         sema_init(&adapter->kioc_semaphore, lld_adp->max_kioc);
944
945         mbox_list       = (mbox64_t *)adapter->mbox_list;
946
947         for (i = 0; i < lld_adp->max_kioc; i++) {
948
949                 kioc            = adapter->kioc_list + i;
950                 kioc->cmdbuf    = (uint64_t)(unsigned long)(mbox_list + i);
951                 kioc->pthru32   = pci_pool_alloc(adapter->pthru_dma_pool,
952                                                 GFP_KERNEL, &kioc->pthru32_h);
953
954                 if (!kioc->pthru32) {
955
956                         con_log(CL_ANN, (KERN_WARNING
957                                 "megaraid cmm: out of memory, %s %d\n",
958                                         __FUNCTION__, __LINE__));
959
960                         rval = (-ENOMEM);
961
962                         goto pthru_dma_pool_error;
963                 }
964
965                 list_add_tail(&kioc->list, &adapter->kioc_pool);
966         }
967
968         // Setup the dma pools for data buffers
969         if ((rval = mraid_mm_setup_dma_pools(adapter)) != 0) {
970                 goto dma_pool_error;
971         }
972
973         list_add_tail(&adapter->list, &adapters_list_g);
974
975         adapters_count_g++;
976
977         return 0;
978
979 dma_pool_error:
980         /* Do nothing */
981
982 pthru_dma_pool_error:
983
984         for (i = 0; i < lld_adp->max_kioc; i++) {
985                 kioc = adapter->kioc_list + i;
986                 if (kioc->pthru32) {
987                         pci_pool_free(adapter->pthru_dma_pool, kioc->pthru32,
988                                 kioc->pthru32_h);
989                 }
990         }
991
992 memalloc_error:
993
994         kfree(adapter->kioc_list);
995         kfree(adapter->mbox_list);
996
997         if (adapter->pthru_dma_pool)
998                 pci_pool_destroy(adapter->pthru_dma_pool);
999
1000         kfree(adapter);
1001
1002         return rval;
1003 }
1004
1005
1006 /**
1007  * mraid_mm_adapter_app_handle - return the application handle for this adapter
1008  * @unique_id   : adapter unique identifier
1009  *
1010  * For the given driver data, locate the adapter in our global list and
1011  * return the corresponding handle, which is also used by applications to
1012  * uniquely identify an adapter.
1013  *
1014  * Return adapter handle if found in the list.
1015  * Return 0 if adapter could not be located, should never happen though.
1016  */
1017 uint32_t
1018 mraid_mm_adapter_app_handle(uint32_t unique_id)
1019 {
1020         mraid_mmadp_t   *adapter;
1021         mraid_mmadp_t   *tmp;
1022         int             index = 0;
1023
1024         list_for_each_entry_safe(adapter, tmp, &adapters_list_g, list) {
1025
1026                 if (adapter->unique_id == unique_id) {
1027
1028                         return MKADAP(index);
1029                 }
1030
1031                 index++;
1032         }
1033
1034         return 0;
1035 }
1036
1037
1038 /**
1039  * mraid_mm_setup_dma_pools - Set up dma buffer pools per adapter
1040  * @adp : Adapter softstate
1041  *
1042  * We maintain a pool of dma buffers per each adapter. Each pool has one
1043  * buffer. E.g, we may have 5 dma pools - one each for 4k, 8k ... 64k buffers.
1044  * We have just one 4k buffer in 4k pool, one 8k buffer in 8k pool etc. We
1045  * dont' want to waste too much memory by allocating more buffers per each
1046  * pool.
1047  */
1048 static int
1049 mraid_mm_setup_dma_pools(mraid_mmadp_t *adp)
1050 {
1051         mm_dmapool_t    *pool;
1052         int             bufsize;
1053         int             i;
1054
1055         /*
1056          * Create MAX_DMA_POOLS number of pools
1057          */
1058         bufsize = MRAID_MM_INIT_BUFF_SIZE;
1059
1060         for (i = 0; i < MAX_DMA_POOLS; i++){
1061
1062                 pool = &adp->dma_pool_list[i];
1063
1064                 pool->buf_size = bufsize;
1065                 spin_lock_init(&pool->lock);
1066
1067                 pool->handle = pci_pool_create("megaraid mm data buffer",
1068                                                 adp->pdev, bufsize, 16, 0);
1069
1070                 if (!pool->handle) {
1071                         goto dma_pool_setup_error;
1072                 }
1073
1074                 pool->vaddr = pci_pool_alloc(pool->handle, GFP_KERNEL,
1075                                                         &pool->paddr);
1076
1077                 if (!pool->vaddr)
1078                         goto dma_pool_setup_error;
1079
1080                 bufsize = bufsize * 2;
1081         }
1082
1083         return 0;
1084
1085 dma_pool_setup_error:
1086
1087         mraid_mm_teardown_dma_pools(adp);
1088         return (-ENOMEM);
1089 }
1090
1091
1092 /**
1093  * mraid_mm_unregister_adp - Unregister routine for low level drivers
1094  * @unique_id   : UID of the adpater
1095  *
1096  * Assumes no outstanding ioctls to llds.
1097  */
1098 int
1099 mraid_mm_unregister_adp(uint32_t unique_id)
1100 {
1101         mraid_mmadp_t   *adapter;
1102         mraid_mmadp_t   *tmp;
1103
1104         list_for_each_entry_safe(adapter, tmp, &adapters_list_g, list) {
1105
1106
1107                 if (adapter->unique_id == unique_id) {
1108
1109                         adapters_count_g--;
1110
1111                         list_del_init(&adapter->list);
1112
1113                         mraid_mm_free_adp_resources(adapter);
1114
1115                         kfree(adapter);
1116
1117                         con_log(CL_ANN, (
1118                                 "megaraid cmm: Unregistered one adapter:%#x\n",
1119                                 unique_id));
1120
1121                         return 0;
1122                 }
1123         }
1124
1125         return (-ENODEV);
1126 }
1127
1128 /**
1129  * mraid_mm_free_adp_resources - Free adapter softstate
1130  * @adp : Adapter softstate
1131  */
1132 static void
1133 mraid_mm_free_adp_resources(mraid_mmadp_t *adp)
1134 {
1135         uioc_t  *kioc;
1136         int     i;
1137
1138         mraid_mm_teardown_dma_pools(adp);
1139
1140         for (i = 0; i < adp->max_kioc; i++) {
1141
1142                 kioc = adp->kioc_list + i;
1143
1144                 pci_pool_free(adp->pthru_dma_pool, kioc->pthru32,
1145                                 kioc->pthru32_h);
1146         }
1147
1148         kfree(adp->kioc_list);
1149         kfree(adp->mbox_list);
1150
1151         pci_pool_destroy(adp->pthru_dma_pool);
1152
1153
1154         return;
1155 }
1156
1157
1158 /**
1159  * mraid_mm_teardown_dma_pools - Free all per adapter dma buffers
1160  * @adp : Adapter softstate
1161  */
1162 static void
1163 mraid_mm_teardown_dma_pools(mraid_mmadp_t *adp)
1164 {
1165         int             i;
1166         mm_dmapool_t    *pool;
1167
1168         for (i = 0; i < MAX_DMA_POOLS; i++) {
1169
1170                 pool = &adp->dma_pool_list[i];
1171
1172                 if (pool->handle) {
1173
1174                         if (pool->vaddr)
1175                                 pci_pool_free(pool->handle, pool->vaddr,
1176                                                         pool->paddr);
1177
1178                         pci_pool_destroy(pool->handle);
1179                         pool->handle = NULL;
1180                 }
1181         }
1182
1183         return;
1184 }
1185
1186 /**
1187  * mraid_mm_init        - Module entry point
1188  */
1189 static int __init
1190 mraid_mm_init(void)
1191 {
1192         int err;
1193
1194         // Announce the driver version
1195         con_log(CL_ANN, (KERN_INFO "megaraid cmm: %s %s\n",
1196                 LSI_COMMON_MOD_VERSION, LSI_COMMON_MOD_EXT_VERSION));
1197
1198         err = misc_register(&megaraid_mm_dev);
1199         if (err < 0) {
1200                 con_log(CL_ANN, ("megaraid cmm: cannot register misc device\n"));
1201                 return err;
1202         }
1203
1204         init_waitqueue_head(&wait_q);
1205
1206         INIT_LIST_HEAD(&adapters_list_g);
1207
1208         return 0;
1209 }
1210
1211
1212 #ifdef CONFIG_COMPAT
1213 /**
1214  * mraid_mm_compat_ioctl        - 32bit to 64bit ioctl conversion routine
1215  * @filep       : file operations pointer (ignored)
1216  * @cmd         : ioctl command
1217  * @arg         : user ioctl packet
1218  */
1219 static long
1220 mraid_mm_compat_ioctl(struct file *filep, unsigned int cmd,
1221                       unsigned long arg)
1222 {
1223         int err;
1224
1225         err = mraid_mm_ioctl(NULL, filep, cmd, arg);
1226
1227         return err;
1228 }
1229 #endif
1230
1231 /**
1232  * mraid_mm_exit        - Module exit point
1233  */
1234 static void __exit
1235 mraid_mm_exit(void)
1236 {
1237         con_log(CL_DLEVEL1 , ("exiting common mod\n"));
1238
1239         misc_deregister(&megaraid_mm_dev);
1240 }
1241
1242 module_init(mraid_mm_init);
1243 module_exit(mraid_mm_exit);
1244
1245 /* vi: set ts=8 sw=8 tw=78: */