sys/dev/pci/n8/common/userPool.c

   1 /*-
   2  * Copyright (C) 2001-2003 by NBMK Encryption Technologies.
   3  * All rights reserved.
   4  *
   5  * NBMK Encryption Technologies provides no support of any kind for
   6  * this software.  Questions or concerns about it may be addressed to
   7  * the members of the relevant open-source community at
   8  * <tech-crypto@netbsd.org>.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are
  12  * met:
  13  *
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * 2. Redistributions in binary form must reproduce the above
  18  *    copyright notice, this list of conditions and the following
  19  *    disclaimer in the documentation and/or other materials provided
  20  *    with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 /*****************************************************************************
  36  * @(#) userPool.c 1.10@(#)
  37  *****************************************************************************/
  38
  39 /*****************************************************************************/
  40 /** @file userPool.c                                                         *
  41  *  @brief Memory Services - Cross-Platform                                  *
  42  *                                                                           *
  43  * This file implements the kernel onlu portions of the user pool allocation *
  44  * and management service for the NSP2000 devices.                           *
  45  *                                                                           *
  46  *                                                                           *
  47  * userPoolInit -                                                            *
  48  *      Obtains the large allocated space. It allocates the large pool       *
  49  *      with n8_GetLargeAllocation (platform-specific).                      *
  50  * userPoolRelease -                                                       *
  51  *      Purges the allocation map and deallocates the large allocation space.*
  52  *                                                                           *
  53  *****************************************************************************/
  54
  55 /*****************************************************************************
  56  * Revision history:
  57  * 05/07/03 brr   Modified user pools to take advantage of the support for
  58  *                multiple memory banks.
  59  * 04/23/03 brr   Removed redundant parameter from n8_FreeLargeAllocation.
  60  * 04/21/03 brr   Added support for multiple memory banks.
  61  * 07/15/02 brr   Do not take userPoolSem in userPoolAlloc if not initialzed.
  62  * 07/11/02 brr   Do not fail userPoolInit if banks is 0.
  63  * 07/02/02 brr   Added userPoolStats.
  64  * 06/26/02 brr   Remove bank parameter from calls to N8_PhysToVirt.
  65  * 06/24/02 brr   Original version.
  66  ****************************************************************************/
  67 /** @defgroup NSP2000Driver Memory Allocation Services - Cross-Platform.
  68  */
  69
  70
  71 #include "n8_OS_intf.h"
  72 #include "helper.h"
  73 #include "n8_driver_parms.h"
  74 #include "n8_malloc_common.h"
  75 #include "n8_memory.h"
  76 #include "userPool.h"
  77
  78 static int                userPoolBanks = 0;
  79 static ATOMICLOCK_t       userPoolSem;
  80
  81 static unsigned long      userPoolBase[DEF_USER_POOL_BANKS];
  82 static n8_UserPoolState_t userPoolState[DEF_USER_POOL_BANKS];
  83 static int                userPoolID[DEF_USER_POOL_BANKS];
  84
  85 /*****************************************************************************
  86  * userPoolDisplay
  87  *****************************************************************************/
  88 /** @ingroup NSP2000Driver
  89  * @brief Displays the current state of the user pool.
  90  *
  91  * This function displays the current state of the user pool.
  92  *
  93  * @par Externals:
  94  *
  95  * @return
  96  *
  97  * @par Errors:
  98  *    See return section for error information.
  99  *****************************************************************************/
 100
 101 void userPoolDisplay(void)
 102 {
 103      int ctr;
 104
 105      if (userPoolBanks == 0)
 106      {
 107         N8_PRINT( "userPool: <************* USER POOL UNINITIALIZED ***********>\n");
 108         return;
 109      }
 110
 111      N8_PRINT( "userPool: <***************** USER POOL MAP *****************>\n");
 112
 113      N8_PRINT( "userPool: banks = %d \n", userPoolBanks);
 114
 115      for (ctr = 0; ctr < userPoolBanks; ctr++)
 116      {
 117         N8_PRINT( "userPool: <*************** USER POOL BANK #%d ***************>\n", ctr);
 118
 119         N8_PRINT( "userPool: base address = %x, bank state =  %d, session ID = %d, \n",
 120                    (int)(userPoolBase[ctr]),
 121                    userPoolState[ctr], userPoolID[ctr]);
 122
 123         if (userPoolState[ctr] != POOL_FREE)
 124         {
 125            n8_memoryDisplay(N8_MEMBANK_USERPOOL + ctr);
 126         }
 127      }
 128
 129      N8_PRINT( "userPool: <********* USER POOL ALLOCATION MAP END **********>\n");
 130
 131 }
 132
 133 /*****************************************************************************
 134  * userPoolCount
 135  *****************************************************************************/
 136 /** @ingroup NSP2000Driver
 137  * @brief Returns the number of allocated user pools.
 138  *
 139  * This function returns the number of allocated user pools.
 140  *
 141  * @par Externals:
 142  *
 143  * @return
 144  *
 145  * @par Errors:
 146  *    See return section for error information.
 147  *****************************************************************************/
 148
 149 int userPoolCount(void)
 150 {
 151    return(userPoolBanks);
 152 }
 153
 154 /*****************************************************************************
 155  * userPoolInit
 156  *****************************************************************************/
 157 /** @ingroup NSP2000Driver
 158  * @brief Allocate and setup management for user pool allocations.
 159  *
 160  * This routine should be called when a driver is loaded and initialized.
 161  *
 162  * @param bank          RO:  The number of user pool banks to allocate
 163  * @param size          RO:  Specifies the desired allocation size(MB) per bank
 164  * @param granularity   RO:  The size of the smallest allocation.
 165  *
 166  * @par Externals:
 167  *
 168  * @return
 169  *    N/A
 170  *
 171  * @par Errors:
 172  *    See return section for error information.
 173  *****************************************************************************/
 174
 175 void userPoolInit(unsigned int  banks,
 176                   unsigned long size,
 177                   unsigned long granularity)
 178 {
 179    int ctr;
 180
 181    /* Initialize each bank */
 182    for (ctr = 0; ctr < banks; ctr++)
 183    {
 184       userPoolBase[ctr] = (unsigned long)n8_memoryInit(N8_MEMBANK_USERPOOL + ctr,
 185                                                        size * N8_ONE_MEGABYTE,
 186                                                        granularity);
 187       if (!userPoolBase[ctr])
 188       {
 189          break;
 190       }
 191    }
 192
 193    /* Setup user pool globals */
 194    userPoolBanks = ctr;
 195    N8_AtomicLockInit(userPoolSem);
 196
 197 }
 198
 199
 200 /*****************************************************************************
 201  * userPoolRelease
 202  *****************************************************************************/
 203 /** @ingroup NSP2000Driver
 204  * @brief Release memory resources allocated for user pools.
 205  *
 206  * This routine deallocates and releases the large space allocated for the
 207  * user request pool.
 208  *
 209  *
 210  * @par Externals:
 211  *    N/A
 212  *
 213  * @return
 214  *    N/A
 215  *
 216  * @par Errors:
 217  *    See return section for error information.
 218  *****************************************************************************/
 219
 220 void userPoolRelease(void)
 221 {
 222    int ctr;
 223
 224    N8_AtomicLockDel(userPoolSem);
 225    for (ctr = 0; ctr < userPoolBanks; ctr++)
 226    {
 227       n8_memoryRelease(N8_MEMBANK_USERPOOL+ctr);
 228       userPoolBase[ctr] = 0;
 229    }
 230    userPoolBanks = 0;
 231
 232    return;
 233 }
 234
 235 /*****************************************************************************
 236  * userPoolAlloc
 237  *****************************************************************************/
 238 /** @ingroup NSP2000Driver
 239  * @brief Allocate a user pool for a process.
 240  *
 241  * This routine should be called when a process opens the device
 242  *
 243  * @par Externals:
 244  *
 245  * @return
 246  *    NULL       pointer if process failed
 247  *    non-NULL   void physical pointer to the base of the user pool
 248  *
 249  * @par Errors:
 250  *    See return section for error information.
 251  *****************************************************************************/
 252
 253 unsigned long userPoolAlloc(int sessID)
 254 {
 255    int   ctr;
 256    unsigned long addr = 0;
 257    MemBankCtl_t *memBankCtl_p;
 258
 259    N8_AtomicLock(userPoolSem);
 260
 261    for (ctr = 0; ctr < userPoolBanks; ctr++)
 262    {
 263       if (userPoolState[ctr] == POOL_FREE)
 264       {
 265          userPoolState[ctr] = POOL_ALLOCATED;
 266          userPoolID[ctr] = sessID;
 267          addr = userPoolBase[ctr];
 268
 269          /* Reset memory control variables for new allocation */
 270          memBankCtl_p =  memBankCtl_gp[N8_MEMBANK_USERPOOL+ctr];
 271          memBankCtl_p->maxAllocated = 0;
 272          memBankCtl_p->failedAllocs = 0;
 273          break;
 274       }
 275    }
 276    N8_AtomicUnlock(userPoolSem);
 277
 278    return (addr);
 279 }
 280
 281
 282 /*****************************************************************************
 283  * userPoolFree
 284  *****************************************************************************/
 285 /** @ingroup NSP2000Driver
 286  * @brief Deallocate a user pool for a process.
 287  *
 288  * This routine should be called when a process exits
 289  *
 290  * @param sessID        RO:  The session ID of the exiting process.
 291  *
 292  * @par Externals:
 293  *
 294  * @return
 295  *
 296  * @par Errors:
 297  *    See return section for error information.
 298  *
 299  * @par Assumptions:
 300  *   It is assume the caller has disabled interrupts to ensure there is no
 301  *   conflict with the ISR accessing the currAllocated value.
 302  *****************************************************************************/
 303
 304 void userPoolFree(int sessID)
 305 {
 306    int           ctr;
 307    MemBankCtl_t *memBankCtl_p;
 308
 309    for (ctr = 0; ctr < userPoolBanks; ctr++)
 310    {
 311       if (userPoolID[ctr] == sessID)
 312       {
 313
 314          /* If there is memory still allocated, the command blocks on the */
 315          /* queue may still be pointing to memory in this pool. Thus it   */
 316          /* cannot be marked as free until everything has been returned.  */
 317          n8_pfreeSessID(N8_MEMBANK_USERPOOL+ctr, sessID);
 318
 319          memBankCtl_p =  memBankCtl_gp[N8_MEMBANK_USERPOOL+ctr];
 320          if (n8_atomic_read(memBankCtl_p->curAllocated))
 321          {
 322             userPoolState[ctr] = POOL_DELETED;
 323          }
 324          else
 325          {
 326             userPoolState[ctr] = POOL_FREE;
 327          }
 328       }
 329    }
 330
 331 }
 332
 333
 334 /*****************************************************************************
 335  * userPoolFreePool
 336  *****************************************************************************/
 337 /** @ingroup NSP2000Driver
 338  * @brief Mark a user pool as free
 339  *
 340  * This routine should be called after the last buffer has been
 341  * freed from a pool
 342  *
 343  * @param addr          RO:  The physical address of the user pool.
 344  *
 345  * @par Externals:
 346  *
 347  * @return
 348  *
 349  * @par Errors:
 350  *    See return section for error information.
 351  *
 352  *****************************************************************************/
 353
 354 void userPoolFreePool(int bankIndex)
 355 {
 356
 357    /* Validate bank index */
 358    if ((bankIndex >= N8_MEMBANK_USERPOOL) &&
 359        (bankIndex <=N8_MEMBANK_USERPOOL+userPoolBanks))
 360    {
 361       /* Only mark the bank as free once all the buffers have been freed */
 362       if (n8_atomic_read(memBankCtl_gp[bankIndex]->curAllocated) == 0)
 363       {
 364          userPoolState[bankIndex - N8_MEMBANK_USERPOOL] = POOL_FREE;
 365       }
 366    }
 367
 368 }
 369
 370 /*****************************************************************************
 371  * userPoolStats
 372  *****************************************************************************/
 373 /** @ingroup NSP2000Driver
 374  * @brief Returns the current state of the user pool.
 375  *
 376  * This function return the current state of the user pool.
 377  *
 378  * @par Externals:
 379  *
 380  * @return
 381  *
 382  * @par Errors:
 383  *    See return section for error information.
 384  *****************************************************************************/
 385
 386 void userPoolStats(MemStats_t *memStatsPtr)
 387 {
 388    int ctr;
 389    MemBankCtl_t *memBankCtl_p;
 390
 391    for (ctr = 0; ctr < userPoolBanks; ctr++)
 392    {
 393
 394       if (userPoolState[ctr] != POOL_FREE)
 395       {
 396          memBankCtl_p =  memBankCtl_gp[N8_MEMBANK_USERPOOL+ctr];
 397          memStatsPtr->sessionID    = userPoolID[ctr];
 398          memStatsPtr->curAllocated = n8_atomic_read(memBankCtl_p->curAllocated);
 399          memStatsPtr->maxAllocated = memBankCtl_p->maxAllocated;
 400          memStatsPtr->maxEntries   = memBankCtl_p->maxEntries;
 401          memStatsPtr->failedAllocs = memBankCtl_p->failedAllocs;
 402
 403       }
 404       else
 405       {
 406          memStatsPtr->sessionID = 0;
 407       }
 408       memStatsPtr++;
 409    }
 410
 411 }
 412
 413