drivers/scsi/megaraid/megaraid_mm.c

   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: */