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