1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Linux MegaRAID device driver
6 * Copyright (c) 2003-2004 LSI Logic Corporation.
9 * Version : v2.20.2.7 (Jul 16 2006)
11 * Common management module
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/mutex.h>
16 #include "megaraid_mm.h"
19 // Entry points for char node driver
20 static DEFINE_MUTEX(mraid_mm_mutex);
21 static int mraid_mm_open(struct inode *, struct file *);
22 static long mraid_mm_unlocked_ioctl(struct file *, uint, unsigned long);
25 // routines to convert to and from the old the format
26 static int mimd_to_kioc(mimd_t __user *, mraid_mmadp_t *, uioc_t *);
27 static int kioc_to_mimd(uioc_t *, mimd_t __user *);
31 static int handle_drvrcmd(void __user *, uint8_t, int *);
32 static int lld_ioctl(mraid_mmadp_t *, uioc_t *);
33 static void ioctl_done(uioc_t *);
34 static void lld_timedout(struct timer_list *);
35 static void hinfo_to_cinfo(mraid_hba_info_t *, mcontroller_t *);
36 static mraid_mmadp_t *mraid_mm_get_adapter(mimd_t __user *, int *);
37 static uioc_t *mraid_mm_alloc_kioc(mraid_mmadp_t *);
38 static void mraid_mm_dealloc_kioc(mraid_mmadp_t *, uioc_t *);
39 static int mraid_mm_attach_buf(mraid_mmadp_t *, uioc_t *, int);
40 static int mraid_mm_setup_dma_pools(mraid_mmadp_t *);
41 static void mraid_mm_free_adp_resources(mraid_mmadp_t *);
42 static void mraid_mm_teardown_dma_pools(mraid_mmadp_t *);
44 MODULE_AUTHOR("LSI Logic Corporation");
45 MODULE_DESCRIPTION("LSI Logic Management Module");
46 MODULE_LICENSE("GPL");
47 MODULE_VERSION(LSI_COMMON_MOD_VERSION);
49 static int dbglevel = CL_ANN;
50 module_param_named(dlevel, dbglevel, int, 0);
51 MODULE_PARM_DESC(dlevel, "Debug level (default=0)");
53 EXPORT_SYMBOL(mraid_mm_register_adp);
54 EXPORT_SYMBOL(mraid_mm_unregister_adp);
55 EXPORT_SYMBOL(mraid_mm_adapter_app_handle);
57 static uint32_t drvr_ver = 0x02200207;
59 static int adapters_count_g;
60 static struct list_head adapters_list_g;
62 static wait_queue_head_t wait_q;
64 static const struct file_operations lsi_fops = {
65 .open = mraid_mm_open,
66 .unlocked_ioctl = mraid_mm_unlocked_ioctl,
67 .compat_ioctl = compat_ptr_ioctl,
69 .llseek = noop_llseek,
72 static struct miscdevice megaraid_mm_dev = {
73 .minor = MISC_DYNAMIC_MINOR,
79 * mraid_mm_open - open routine for char node interface
83 * Allow ioctl operations by apps only if they have superuser privilege.
86 mraid_mm_open(struct inode *inode, struct file *filep)
89 * Only allow superuser to access private ioctl interface
91 if (!capable(CAP_SYS_ADMIN)) return (-EACCES);
97 * mraid_mm_ioctl - module entry-point for ioctls
98 * @filep : file operations pointer (ignored)
99 * @cmd : ioctl command
100 * @arg : user ioctl packet
103 mraid_mm_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
106 char signature[EXT_IOCTL_SIGN_SZ] = {0};
111 void __user *argp = (void __user *)arg;
114 * Make sure only USCSICMD are issued through this interface.
115 * MIMD application would still fire different command.
118 if ((_IOC_TYPE(cmd) != MEGAIOC_MAGIC) && (cmd != USCSICMD)) {
123 * Look for signature to see if this is the new or old ioctl format.
125 if (copy_from_user(signature, argp, EXT_IOCTL_SIGN_SZ)) {
126 con_log(CL_ANN, (KERN_WARNING
127 "megaraid cmm: copy from usr addr failed\n"));
131 if (memcmp(signature, EXT_IOCTL_SIGN, EXT_IOCTL_SIGN_SZ) == 0)
137 * At present, we don't support the new ioctl packet
143 * If it is a driver ioctl (as opposed to fw ioctls), then we can
144 * handle the command locally. rval > 0 means it is not a drvr cmd
146 rval = handle_drvrcmd(argp, old_ioctl, &drvrcmd_rval);
154 if ((adp = mraid_mm_get_adapter(argp, &rval)) == NULL) {
159 * Check if adapter can accept ioctl. We may have marked it offline
160 * if any previous kioc had timedout on this controller.
162 if (!adp->quiescent) {
163 con_log(CL_ANN, (KERN_WARNING
164 "megaraid cmm: controller cannot accept cmds due to "
165 "earlier errors\n" ));
170 * The following call will block till a kioc is available
171 * or return NULL if the list head is empty for the pointer
172 * of type mraid_mmapt passed to mraid_mm_alloc_kioc
174 kioc = mraid_mm_alloc_kioc(adp);
179 * User sent the old mimd_t ioctl packet. Convert it to uioc_t.
181 if ((rval = mimd_to_kioc(argp, adp, kioc))) {
182 mraid_mm_dealloc_kioc(adp, kioc);
186 kioc->done = ioctl_done;
189 * Issue the IOCTL to the low level driver. After the IOCTL completes
190 * release the kioc if and only if it was _not_ timedout. If it was
191 * timedout, that means that resources are still with low level driver.
193 if ((rval = lld_ioctl(adp, kioc))) {
196 mraid_mm_dealloc_kioc(adp, kioc);
202 * Convert the kioc back to user space
204 rval = kioc_to_mimd(kioc, argp);
207 * Return the kioc to free pool
209 mraid_mm_dealloc_kioc(adp, kioc);
215 mraid_mm_unlocked_ioctl(struct file *filep, unsigned int cmd,
220 mutex_lock(&mraid_mm_mutex);
221 err = mraid_mm_ioctl(filep, cmd, arg);
222 mutex_unlock(&mraid_mm_mutex);
228 * mraid_mm_get_adapter - Returns corresponding adapters for the mimd packet
229 * @umimd : User space mimd_t ioctl packet
230 * @rval : returned success/error status
232 * The function return value is a pointer to the located @adapter.
234 static mraid_mmadp_t *
235 mraid_mm_get_adapter(mimd_t __user *umimd, int *rval)
237 mraid_mmadp_t *adapter;
243 if (copy_from_user(&mimd, umimd, sizeof(mimd_t))) {
248 adapno = GETADAP(mimd.ui.fcs.adapno);
250 if (adapno >= adapters_count_g) {
258 list_for_each_entry(adapter, &adapters_list_g, list) {
259 if (iterator++ == adapno) break;
271 * handle_drvrcmd - Checks if the opcode is a driver cmd and if it is, handles it.
272 * @arg : packet sent by the user app
273 * @old_ioctl : mimd if 1; uioc otherwise
274 * @rval : pointer for command's returned value (not function status)
277 handle_drvrcmd(void __user *arg, uint8_t old_ioctl, int *rval)
279 mimd_t __user *umimd;
296 if (copy_from_user(&kmimd, umimd, sizeof(mimd_t)))
299 opcode = kmimd.ui.fcs.opcode;
300 subopcode = kmimd.ui.fcs.subopcode;
303 * If the opcode is 0x82 and the subopcode is either GET_DRVRVER or
304 * GET_NUMADP, then we can handle. Otherwise we should return 1 to
305 * indicate that we cannot handle this.
312 case MEGAIOC_QDRVRVER:
314 if (copy_to_user(kmimd.data, &drvr_ver, sizeof(uint32_t)))
321 *rval = adapters_count_g;
323 if (copy_to_user(kmimd.data, &adapters_count_g,
339 * mimd_to_kioc - Converter from old to new ioctl format
340 * @umimd : user space old MIMD IOCTL
341 * @adp : adapter softstate
342 * @kioc : kernel space new format IOCTL
344 * Routine to convert MIMD interface IOCTL to new interface IOCTL packet. The
345 * new packet is in kernel space so that driver can perform operations on it
350 mimd_to_kioc(mimd_t __user *umimd, mraid_mmadp_t *adp, uioc_t *kioc)
354 mraid_passthru_t *pthru32;
360 if (copy_from_user(&mimd, umimd, sizeof(mimd_t)))
364 * Applications are not allowed to send extd pthru
366 if ((mimd.mbox[0] == MBOXCMD_PASSTHRU64) ||
367 (mimd.mbox[0] == MBOXCMD_EXTPTHRU))
370 opcode = mimd.ui.fcs.opcode;
371 subopcode = mimd.ui.fcs.subopcode;
372 adapno = GETADAP(mimd.ui.fcs.adapno);
374 if (adapno >= adapters_count_g)
377 kioc->adapno = adapno;
378 kioc->mb_type = MBOX_LEGACY;
379 kioc->app_type = APPTYPE_MIMD;
385 if (subopcode == MEGAIOC_QADAPINFO) {
387 kioc->opcode = GET_ADAP_INFO;
388 kioc->data_dir = UIOC_RD;
389 kioc->xferlen = sizeof(mraid_hba_info_t);
391 if (mraid_mm_attach_buf(adp, kioc, kioc->xferlen))
395 con_log(CL_ANN, (KERN_WARNING
396 "megaraid cmm: Invalid subop\n"));
404 kioc->opcode = MBOX_CMD;
405 kioc->xferlen = mimd.ui.fcs.length;
406 kioc->user_data_len = kioc->xferlen;
407 kioc->user_data = mimd.ui.fcs.buffer;
409 if (mraid_mm_attach_buf(adp, kioc, kioc->xferlen))
412 if (mimd.outlen) kioc->data_dir = UIOC_RD;
413 if (mimd.inlen) kioc->data_dir |= UIOC_WR;
419 kioc->opcode = MBOX_CMD;
420 kioc->xferlen = (mimd.outlen > mimd.inlen) ?
421 mimd.outlen : mimd.inlen;
422 kioc->user_data_len = kioc->xferlen;
423 kioc->user_data = mimd.data;
425 if (mraid_mm_attach_buf(adp, kioc, kioc->xferlen))
428 if (mimd.outlen) kioc->data_dir = UIOC_RD;
429 if (mimd.inlen) kioc->data_dir |= UIOC_WR;
438 * If driver command, nothing else to do
444 * This is a mailbox cmd; copy the mailbox from mimd
446 mbox64 = (mbox64_t *)((unsigned long)kioc->cmdbuf);
447 mbox = &mbox64->mbox32;
448 memcpy(mbox, mimd.mbox, 14);
450 if (mbox->cmd != MBOXCMD_PASSTHRU) { // regular DCMD
452 mbox->xferaddr = (uint32_t)kioc->buf_paddr;
454 if (kioc->data_dir & UIOC_WR) {
455 if (copy_from_user(kioc->buf_vaddr, kioc->user_data,
465 * This is a regular 32-bit pthru cmd; mbox points to pthru struct.
466 * Just like in above case, the beginning for memblk is treated as
467 * a mailbox. The passthru will begin at next 1K boundary. And the
468 * data will start 1K after that.
470 pthru32 = kioc->pthru32;
471 kioc->user_pthru = &umimd->pthru;
472 mbox->xferaddr = (uint32_t)kioc->pthru32_h;
474 if (copy_from_user(pthru32, kioc->user_pthru,
475 sizeof(mraid_passthru_t))) {
479 pthru32->dataxferaddr = kioc->buf_paddr;
480 if (kioc->data_dir & UIOC_WR) {
481 if (pthru32->dataxferlen > kioc->xferlen)
483 if (copy_from_user(kioc->buf_vaddr, kioc->user_data,
484 pthru32->dataxferlen)) {
493 * mraid_mm_attch_buf - Attach a free dma buffer for required size
494 * @adp : Adapter softstate
495 * @kioc : kioc that the buffer needs to be attached to
496 * @xferlen : required length for buffer
498 * First we search for a pool with smallest buffer that is >= @xferlen. If
499 * that pool has no free buffer, we will try for the next bigger size. If none
500 * is available, we will try to allocate the smallest buffer that is >=
501 * @xferlen and attach it the pool.
504 mraid_mm_attach_buf(mraid_mmadp_t *adp, uioc_t *kioc, int xferlen)
511 kioc->pool_index = -1;
512 kioc->buf_vaddr = NULL;
517 * We need xferlen amount of memory. See if we can get it from our
518 * dma pools. If we don't get exact size, we will try bigger buffer
521 for (i = 0; i < MAX_DMA_POOLS; i++) {
523 pool = &adp->dma_pool_list[i];
525 if (xferlen > pool->buf_size)
528 if (right_pool == -1)
531 spin_lock_irqsave(&pool->lock, flags);
536 kioc->pool_index = i;
537 kioc->buf_vaddr = pool->vaddr;
538 kioc->buf_paddr = pool->paddr;
540 spin_unlock_irqrestore(&pool->lock, flags);
544 spin_unlock_irqrestore(&pool->lock, flags);
550 * If xferlen doesn't match any of our pools, return error
552 if (right_pool == -1)
556 * We did not get any buffer from the preallocated pool. Let us try
557 * to allocate one new buffer. NOTE: This is a blocking call.
559 pool = &adp->dma_pool_list[right_pool];
561 spin_lock_irqsave(&pool->lock, flags);
563 kioc->pool_index = right_pool;
565 kioc->buf_vaddr = dma_pool_alloc(pool->handle, GFP_ATOMIC,
567 spin_unlock_irqrestore(&pool->lock, flags);
569 if (!kioc->buf_vaddr)
576 * mraid_mm_alloc_kioc - Returns a uioc_t from free list
577 * @adp : Adapter softstate for this module
579 * The kioc_semaphore is initialized with number of kioc nodes in the
580 * free kioc pool. If the kioc pool is empty, this function blocks till
581 * a kioc becomes free.
584 mraid_mm_alloc_kioc(mraid_mmadp_t *adp)
587 struct list_head* head;
590 down(&adp->kioc_semaphore);
592 spin_lock_irqsave(&adp->kioc_pool_lock, flags);
594 head = &adp->kioc_pool;
596 if (list_empty(head)) {
597 up(&adp->kioc_semaphore);
598 spin_unlock_irqrestore(&adp->kioc_pool_lock, flags);
600 con_log(CL_ANN, ("megaraid cmm: kioc list empty!\n"));
604 kioc = list_entry(head->next, uioc_t, list);
605 list_del_init(&kioc->list);
607 spin_unlock_irqrestore(&adp->kioc_pool_lock, flags);
609 memset((caddr_t)(unsigned long)kioc->cmdbuf, 0, sizeof(mbox64_t));
610 memset((caddr_t) kioc->pthru32, 0, sizeof(mraid_passthru_t));
612 kioc->buf_vaddr = NULL;
614 kioc->pool_index =-1;
616 kioc->user_data = NULL;
617 kioc->user_data_len = 0;
618 kioc->user_pthru = NULL;
625 * mraid_mm_dealloc_kioc - Return kioc to free pool
626 * @adp : Adapter softstate
627 * @kioc : uioc_t node to be returned to free pool
630 mraid_mm_dealloc_kioc(mraid_mmadp_t *adp, uioc_t *kioc)
635 if (kioc->pool_index != -1) {
636 pool = &adp->dma_pool_list[kioc->pool_index];
638 /* This routine may be called in non-isr context also */
639 spin_lock_irqsave(&pool->lock, flags);
642 * While attaching the dma buffer, if we didn't get the
643 * required buffer from the pool, we would have allocated
644 * it at the run time and set the free_buf flag. We must
645 * free that buffer. Otherwise, just mark that the buffer is
648 if (kioc->free_buf == 1)
649 dma_pool_free(pool->handle, kioc->buf_vaddr,
654 spin_unlock_irqrestore(&pool->lock, flags);
657 /* Return the kioc to the free pool */
658 spin_lock_irqsave(&adp->kioc_pool_lock, flags);
659 list_add(&kioc->list, &adp->kioc_pool);
660 spin_unlock_irqrestore(&adp->kioc_pool_lock, flags);
662 /* increment the free kioc count */
663 up(&adp->kioc_semaphore);
669 * lld_ioctl - Routine to issue ioctl to low level drvr
670 * @adp : The adapter handle
671 * @kioc : The ioctl packet with kernel addresses
674 lld_ioctl(mraid_mmadp_t *adp, uioc_t *kioc)
677 struct uioc_timeout timeout = { };
679 kioc->status = -ENODATA;
680 rval = adp->issue_uioc(adp->drvr_data, kioc, IOCTL_ISSUE);
682 if (rval) return rval;
687 if (adp->timeout > 0) {
689 timer_setup_on_stack(&timeout.timer, lld_timedout, 0);
691 timeout.timer.expires = jiffies + adp->timeout * HZ;
693 add_timer(&timeout.timer);
697 * Wait till the low level driver completes the ioctl. After this
698 * call, the ioctl either completed successfully or timedout.
700 wait_event(wait_q, (kioc->status != -ENODATA));
701 if (timeout.timer.function) {
702 del_timer_sync(&timeout.timer);
703 destroy_timer_on_stack(&timeout.timer);
707 * If the command had timedout, we mark the controller offline
710 if (kioc->timedout) {
719 * ioctl_done - callback from the low level driver
720 * @kioc : completed ioctl packet
723 ioctl_done(uioc_t *kioc)
727 mraid_mmadp_t* adapter;
730 * When the kioc returns from driver, make sure it still doesn't
731 * have ENODATA in status. Otherwise, driver will hang on wait_event
734 if (kioc->status == -ENODATA) {
735 con_log(CL_ANN, (KERN_WARNING
736 "megaraid cmm: lld didn't change status!\n"));
738 kioc->status = -EINVAL;
742 * Check if this kioc was timedout before. If so, nobody is waiting
743 * on this kioc. We don't have to wake up anybody. Instead, we just
744 * have to free the kioc
746 if (kioc->timedout) {
749 adapno = kioc->adapno;
751 con_log(CL_ANN, ( KERN_WARNING "megaraid cmm: completed "
752 "ioctl that was timedout before\n"));
754 list_for_each_entry(adapter, &adapters_list_g, list) {
755 if (iterator++ == adapno) break;
761 mraid_mm_dealloc_kioc( adapter, kioc );
771 * lld_timedout - callback from the expired timer
772 * @t : timer that timed out
775 lld_timedout(struct timer_list *t)
777 struct uioc_timeout *timeout = from_timer(timeout, t, timer);
778 uioc_t *kioc = timeout->uioc;
780 kioc->status = -ETIME;
783 con_log(CL_ANN, (KERN_WARNING "megaraid cmm: ioctl timed out\n"));
790 * kioc_to_mimd - Converter from new back to old format
791 * @kioc : Kernel space IOCTL packet (successfully issued)
792 * @mimd : User space MIMD packet
795 kioc_to_mimd(uioc_t *kioc, mimd_t __user *mimd)
802 mraid_passthru_t __user *upthru32;
803 mraid_passthru_t *kpthru32;
805 mraid_hba_info_t *hinfo;
808 if (copy_from_user(&kmimd, mimd, sizeof(mimd_t)))
811 opcode = kmimd.ui.fcs.opcode;
812 subopcode = kmimd.ui.fcs.subopcode;
814 if (opcode == 0x82) {
817 case MEGAIOC_QADAPINFO:
819 hinfo = (mraid_hba_info_t *)(unsigned long)
822 hinfo_to_cinfo(hinfo, &cinfo);
824 if (copy_to_user(kmimd.data, &cinfo, sizeof(cinfo)))
836 mbox64 = (mbox64_t *)(unsigned long)kioc->cmdbuf;
838 if (kioc->user_pthru) {
840 upthru32 = kioc->user_pthru;
841 kpthru32 = kioc->pthru32;
843 if (copy_to_user(&upthru32->scsistatus,
844 &kpthru32->scsistatus,
850 if (kioc->user_data) {
851 if (copy_to_user(kioc->user_data, kioc->buf_vaddr,
852 kioc->user_data_len)) {
857 if (copy_to_user(&mimd->mbox[17],
858 &mbox64->mbox32.status, sizeof(uint8_t))) {
867 * hinfo_to_cinfo - Convert new format hba info into old format
868 * @hinfo : New format, more comprehensive adapter info
869 * @cinfo : Old format adapter info to support mimd_t apps
872 hinfo_to_cinfo(mraid_hba_info_t *hinfo, mcontroller_t *cinfo)
874 if (!hinfo || !cinfo)
877 cinfo->base = hinfo->baseport;
878 cinfo->irq = hinfo->irq;
879 cinfo->numldrv = hinfo->num_ldrv;
880 cinfo->pcibus = hinfo->pci_bus;
881 cinfo->pcidev = hinfo->pci_slot;
882 cinfo->pcifun = PCI_FUNC(hinfo->pci_dev_fn);
883 cinfo->pciid = hinfo->pci_device_id;
884 cinfo->pcivendor = hinfo->pci_vendor_id;
885 cinfo->pcislot = hinfo->pci_slot;
886 cinfo->uid = hinfo->unique_id;
891 * mraid_mm_register_adp - Registration routine for low level drivers
892 * @lld_adp : Adapter object
895 mraid_mm_register_adp(mraid_mmadp_t *lld_adp)
897 mraid_mmadp_t *adapter;
904 if (lld_adp->drvr_type != DRVRTYPE_MBOX)
907 adapter = kzalloc(sizeof(mraid_mmadp_t), GFP_KERNEL);
913 adapter->unique_id = lld_adp->unique_id;
914 adapter->drvr_type = lld_adp->drvr_type;
915 adapter->drvr_data = lld_adp->drvr_data;
916 adapter->pdev = lld_adp->pdev;
917 adapter->issue_uioc = lld_adp->issue_uioc;
918 adapter->timeout = lld_adp->timeout;
919 adapter->max_kioc = lld_adp->max_kioc;
920 adapter->quiescent = 1;
923 * Allocate single blocks of memory for all required kiocs,
924 * mailboxes and passthru structures.
926 adapter->kioc_list = kmalloc_array(lld_adp->max_kioc,
929 adapter->mbox_list = kmalloc_array(lld_adp->max_kioc,
932 adapter->pthru_dma_pool = dma_pool_create("megaraid mm pthru pool",
934 sizeof(mraid_passthru_t),
937 if (!adapter->kioc_list || !adapter->mbox_list ||
938 !adapter->pthru_dma_pool) {
940 con_log(CL_ANN, (KERN_WARNING
941 "megaraid cmm: out of memory, %s %d\n", __func__,
950 * Slice kioc_list and make a kioc_pool with the individiual kiocs
952 INIT_LIST_HEAD(&adapter->kioc_pool);
953 spin_lock_init(&adapter->kioc_pool_lock);
954 sema_init(&adapter->kioc_semaphore, lld_adp->max_kioc);
956 mbox_list = (mbox64_t *)adapter->mbox_list;
958 for (i = 0; i < lld_adp->max_kioc; i++) {
960 kioc = adapter->kioc_list + i;
961 kioc->cmdbuf = (uint64_t)(unsigned long)(mbox_list + i);
962 kioc->pthru32 = dma_pool_alloc(adapter->pthru_dma_pool,
963 GFP_KERNEL, &kioc->pthru32_h);
965 if (!kioc->pthru32) {
967 con_log(CL_ANN, (KERN_WARNING
968 "megaraid cmm: out of memory, %s %d\n",
969 __func__, __LINE__));
973 goto pthru_dma_pool_error;
976 list_add_tail(&kioc->list, &adapter->kioc_pool);
979 // Setup the dma pools for data buffers
980 if ((rval = mraid_mm_setup_dma_pools(adapter)) != 0) {
984 list_add_tail(&adapter->list, &adapters_list_g);
993 pthru_dma_pool_error:
995 for (i = 0; i < lld_adp->max_kioc; i++) {
996 kioc = adapter->kioc_list + i;
998 dma_pool_free(adapter->pthru_dma_pool, kioc->pthru32,
1005 kfree(adapter->kioc_list);
1006 kfree(adapter->mbox_list);
1008 dma_pool_destroy(adapter->pthru_dma_pool);
1017 * mraid_mm_adapter_app_handle - return the application handle for this adapter
1018 * @unique_id : adapter unique identifier
1020 * For the given driver data, locate the adapter in our global list and
1021 * return the corresponding handle, which is also used by applications to
1022 * uniquely identify an adapter.
1024 * Return adapter handle if found in the list.
1025 * Return 0 if adapter could not be located, should never happen though.
1028 mraid_mm_adapter_app_handle(uint32_t unique_id)
1030 mraid_mmadp_t *adapter;
1034 list_for_each_entry_safe(adapter, tmp, &adapters_list_g, list) {
1036 if (adapter->unique_id == unique_id) {
1038 return MKADAP(index);
1049 * mraid_mm_setup_dma_pools - Set up dma buffer pools per adapter
1050 * @adp : Adapter softstate
1052 * We maintain a pool of dma buffers per each adapter. Each pool has one
1053 * buffer. E.g, we may have 5 dma pools - one each for 4k, 8k ... 64k buffers.
1054 * We have just one 4k buffer in 4k pool, one 8k buffer in 8k pool etc. We
1055 * dont' want to waste too much memory by allocating more buffers per each
1059 mraid_mm_setup_dma_pools(mraid_mmadp_t *adp)
1066 * Create MAX_DMA_POOLS number of pools
1068 bufsize = MRAID_MM_INIT_BUFF_SIZE;
1070 for (i = 0; i < MAX_DMA_POOLS; i++){
1072 pool = &adp->dma_pool_list[i];
1074 pool->buf_size = bufsize;
1075 spin_lock_init(&pool->lock);
1077 pool->handle = dma_pool_create("megaraid mm data buffer",
1078 &adp->pdev->dev, bufsize,
1081 if (!pool->handle) {
1082 goto dma_pool_setup_error;
1085 pool->vaddr = dma_pool_alloc(pool->handle, GFP_KERNEL,
1089 goto dma_pool_setup_error;
1091 bufsize = bufsize * 2;
1096 dma_pool_setup_error:
1098 mraid_mm_teardown_dma_pools(adp);
1104 * mraid_mm_unregister_adp - Unregister routine for low level drivers
1105 * @unique_id : UID of the adpater
1107 * Assumes no outstanding ioctls to llds.
1110 mraid_mm_unregister_adp(uint32_t unique_id)
1112 mraid_mmadp_t *adapter;
1115 list_for_each_entry_safe(adapter, tmp, &adapters_list_g, list) {
1118 if (adapter->unique_id == unique_id) {
1122 list_del_init(&adapter->list);
1124 mraid_mm_free_adp_resources(adapter);
1129 "megaraid cmm: Unregistered one adapter:%#x\n",
1140 * mraid_mm_free_adp_resources - Free adapter softstate
1141 * @adp : Adapter softstate
1144 mraid_mm_free_adp_resources(mraid_mmadp_t *adp)
1149 mraid_mm_teardown_dma_pools(adp);
1151 for (i = 0; i < adp->max_kioc; i++) {
1153 kioc = adp->kioc_list + i;
1155 dma_pool_free(adp->pthru_dma_pool, kioc->pthru32,
1159 kfree(adp->kioc_list);
1160 kfree(adp->mbox_list);
1162 dma_pool_destroy(adp->pthru_dma_pool);
1170 * mraid_mm_teardown_dma_pools - Free all per adapter dma buffers
1171 * @adp : Adapter softstate
1174 mraid_mm_teardown_dma_pools(mraid_mmadp_t *adp)
1179 for (i = 0; i < MAX_DMA_POOLS; i++) {
1181 pool = &adp->dma_pool_list[i];
1186 dma_pool_free(pool->handle, pool->vaddr,
1189 dma_pool_destroy(pool->handle);
1190 pool->handle = NULL;
1198 * mraid_mm_init - Module entry point
1205 // Announce the driver version
1206 con_log(CL_ANN, (KERN_INFO "megaraid cmm: %s %s\n",
1207 LSI_COMMON_MOD_VERSION, LSI_COMMON_MOD_EXT_VERSION));
1209 err = misc_register(&megaraid_mm_dev);
1211 con_log(CL_ANN, ("megaraid cmm: cannot register misc device\n"));
1215 init_waitqueue_head(&wait_q);
1217 INIT_LIST_HEAD(&adapters_list_g);
1224 * mraid_mm_exit - Module exit point
1229 con_log(CL_DLEVEL1 , ("exiting common mod\n"));
1231 misc_deregister(&megaraid_mm_dev);
1234 module_init(mraid_mm_init);
1235 module_exit(mraid_mm_exit);
1237 /* vi: set ts=8 sw=8 tw=78: */