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