target/linux/generic-2.6/files/crypto/ocf/kirkwood/mvHal/mv_hal/cntmr/mvCntmr.c

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12 ********************************************************************************
  13 Marvell Commercial License Option
  14
  15 If you received this File from Marvell and you have entered into a commercial
  16 license agreement (a "Commercial License") with Marvell, the File is licensed
  17 to you under the terms of the applicable Commercial License.
  18
  19 ********************************************************************************
  20 Marvell GPL License Option
  21
  22 If you received this File from Marvell, you may opt to use, redistribute and/or
  23 modify this File in accordance with the terms and conditions of the General
  24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  25 available along with the File in the license.txt file or by writing to the Free
  26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  28
  29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  31 DISCLAIMED.  The GPL License provides additional details about this warranty
  32 disclaimer.
  33 ********************************************************************************
  34 Marvell BSD License Option
  35
  36 If you received this File from Marvell, you may opt to use, redistribute and/or
  37 modify this File under the following licensing terms.
  38 Redistribution and use in source and binary forms, with or without modification,
  39 are permitted provided that the following conditions are met:
  40
  41     *   Redistributions of source code must retain the above copyright notice,
  42             this list of conditions and the following disclaimer.
  43
  44     *   Redistributions in binary form must reproduce the above copyright
  45         notice, this list of conditions and the following disclaimer in the
  46         documentation and/or other materials provided with the distribution.
  47
  48     *   Neither the name of Marvell nor the names of its contributors may be
  49         used to endorse or promote products derived from this software without
  50         specific prior written permission.
  51
  52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62
  63 *******************************************************************************/
  64
  65 #include "mvCntmr.h"
  66 #include "cpu/mvCpu.h"
  67
  68 /* defines  */
  69 #ifdef MV_DEBUG
  70         #define DB(x)   x
  71 #else
  72         #define DB(x)
  73 #endif
  74
  75 extern unsigned int whoAmI(void);
  76
  77 /*******************************************************************************
  78 * mvCntmrLoad -
  79 *
  80 * DESCRIPTION:
  81 *       Load an init Value to a given counter/timer
  82 *
  83 * INPUT:
  84 *       countNum - counter number
  85 *       value - value to be loaded
  86 *
  87 * OUTPUT:
  88 *       None.
  89 *
  90 * RETURN:
  91 *       MV_BAD_PARAM on bad parameters , MV_ERROR on error ,MV_OK on sucess
  92 *******************************************************************************/
  93 MV_STATUS mvCntmrLoad(MV_U32 countNum, MV_U32 value)
  94 {
  95         if (countNum >= MV_CNTMR_MAX_COUNTER )
  96         {
  97
  98                 mvOsPrintf(("mvCntmrLoad: Err. Illigal counter number \n"));
  99                 return MV_BAD_PARAM;;
 100
 101         }
 102
 103         MV_REG_WRITE(CNTMR_RELOAD_REG(countNum),value);
 104         MV_REG_WRITE(CNTMR_VAL_REG(countNum),value);
 105
 106         return MV_OK;
 107 }
 108
 109 /*******************************************************************************
 110 * mvCntmrRead -
 111 *
 112 * DESCRIPTION:
 113 *       Returns the value of the given Counter/Timer
 114 *
 115 * INPUT:
 116 *       countNum - counter number
 117 *
 118 * OUTPUT:
 119 *       None.
 120 *
 121 * RETURN:
 122 *       MV_U32 counter value
 123 *******************************************************************************/
 124 MV_U32 mvCntmrRead(MV_U32 countNum)
 125 {
 126         return MV_REG_READ(CNTMR_VAL_REG(countNum));
 127 }
 128
 129 /*******************************************************************************
 130 * mvCntmrWrite -
 131 *
 132 * DESCRIPTION:
 133 *       Returns the value of the given Counter/Timer
 134 *
 135 * INPUT:
 136 *       countNum - counter number
 137 *               countVal - value to write
 138 *
 139 * OUTPUT:
 140 *       None.
 141 *
 142 * RETURN:
 143 *       None
 144 *******************************************************************************/
 145 void mvCntmrWrite(MV_U32 countNum,MV_U32 countVal)
 146 {
 147         MV_REG_WRITE(CNTMR_VAL_REG(countNum),countVal);
 148 }
 149
 150 /*******************************************************************************
 151 * mvCntmrCtrlSet -
 152 *
 153 * DESCRIPTION:
 154 *       Set the Control to a given counter/timer
 155 *
 156 * INPUT:
 157 *       countNum - counter number
 158 *               pCtrl - pointer to MV_CNTMR_CTRL structure
 159 *
 160 * OUTPUT:
 161 *       None.
 162 *
 163 * RETURN:
 164 *       MV_BAD_PARAM on bad parameters , MV_ERROR on error ,MV_OK on sucess
 165 *******************************************************************************/
 166 MV_STATUS mvCntmrCtrlSet(MV_U32 countNum, MV_CNTMR_CTRL *pCtrl)
 167 {
 168         MV_U32 cntmrCtrl;
 169
 170         if (countNum >= MV_CNTMR_MAX_COUNTER )
 171         {
 172
 173                 DB(mvOsPrintf(("mvCntmrCtrlSet: Err. Illigal counter number \n")));
 174                 return MV_BAD_PARAM;;
 175
 176         }
 177
 178         /* read control register */
 179         cntmrCtrl = MV_REG_READ(CNTMR_CTRL_REG);
 180
 181
 182         if (pCtrl->enable)      /* enable counter\timer */
 183         {
 184                 cntmrCtrl |= CTCR_ARM_TIMER_EN(countNum);
 185         }
 186         else    /* disable counter\timer */
 187         {
 188                 cntmrCtrl &= ~CTCR_ARM_TIMER_EN(countNum);
 189         }
 190
 191         if ( pCtrl->autoEnable ) /* Auto mode */
 192         {
 193                 cntmrCtrl |= CTCR_ARM_TIMER_AUTO_EN(countNum);
 194
 195         }
 196         else    /* no auto mode */
 197         {
 198                 cntmrCtrl &= ~CTCR_ARM_TIMER_AUTO_EN(countNum);
 199         }
 200
 201         MV_REG_WRITE(CNTMR_CTRL_REG,cntmrCtrl);
 202
 203         return MV_OK;
 204
 205 }
 206
 207 /*******************************************************************************
 208 * mvCntmrCtrlGet -
 209 *
 210 * DESCRIPTION:
 211 *       Get the Control value of a given counter/timer
 212 *
 213 * INPUT:
 214 *       countNum - counter number
 215 *               pCtrl - pointer to MV_CNTMR_CTRL structure
 216 *
 217 * OUTPUT:
 218 *       Counter\Timer control value
 219 *
 220 * RETURN:
 221 *       MV_BAD_PARAM on bad parameters , MV_ERROR on error ,MV_OK on sucess
 222 *******************************************************************************/
 223 MV_STATUS mvCntmrCtrlGet(MV_U32 countNum, MV_CNTMR_CTRL *pCtrl)
 224 {
 225         MV_U32 cntmrCtrl;
 226
 227         if (countNum >= MV_CNTMR_MAX_COUNTER )
 228         {
 229                 DB(mvOsPrintf(("mvCntmrCtrlGet: Err. Illigal counter number \n")));
 230                 return MV_BAD_PARAM;;
 231         }
 232
 233         /* read control register */
 234         cntmrCtrl = MV_REG_READ(CNTMR_CTRL_REG);
 235
 236         /* enable counter\timer */
 237         if (cntmrCtrl & CTCR_ARM_TIMER_EN(countNum))
 238         {
 239                 pCtrl->enable = MV_TRUE;
 240         }
 241         else
 242         {
 243                 pCtrl->enable = MV_FALSE;
 244         }
 245
 246         /* counter mode */
 247         if (cntmrCtrl & CTCR_ARM_TIMER_AUTO_EN(countNum))
 248         {
 249                 pCtrl->autoEnable = MV_TRUE;
 250         }
 251         else
 252         {
 253                 pCtrl->autoEnable = MV_FALSE;
 254         }
 255
 256         return MV_OK;
 257 }
 258
 259 /*******************************************************************************
 260 * mvCntmrEnable -
 261 *
 262 * DESCRIPTION:
 263 *       Set the Enable-Bit to logic '1' ==> starting the counter
 264 *
 265 * INPUT:
 266 *       countNum - counter number
 267 *
 268 * OUTPUT:
 269 *       None.
 270 *
 271 * RETURN:
 272 *       MV_BAD_PARAM on bad parameters , MV_ERROR on error ,MV_OK on sucess
 273 *******************************************************************************/
 274 MV_STATUS mvCntmrEnable(MV_U32 countNum)
 275 {
 276         MV_U32 cntmrCtrl;
 277
 278         if (countNum >= MV_CNTMR_MAX_COUNTER )
 279         {
 280
 281                 DB(mvOsPrintf(("mvCntmrEnable: Err. Illigal counter number \n")));
 282                 return MV_BAD_PARAM;;
 283
 284         }
 285
 286         /* read control register */
 287         cntmrCtrl = MV_REG_READ(CNTMR_CTRL_REG);
 288
 289         /* enable counter\timer */
 290         cntmrCtrl |= CTCR_ARM_TIMER_EN(countNum);
 291
 292
 293         MV_REG_WRITE(CNTMR_CTRL_REG,cntmrCtrl);
 294
 295         return MV_OK;
 296 }
 297
 298 /*******************************************************************************
 299 * mvCntmrDisable -
 300 *
 301 * DESCRIPTION:
 302 *       Stop the counter/timer running, and returns its Value
 303 *
 304 * INPUT:
 305 *       countNum - counter number
 306 *
 307 * OUTPUT:
 308 *       None.
 309 *
 310 * RETURN:
 311 *       MV_U32 counter\timer value
 312 *******************************************************************************/
 313 MV_STATUS mvCntmrDisable(MV_U32 countNum)
 314 {
 315         MV_U32 cntmrCtrl;
 316
 317         if (countNum >= MV_CNTMR_MAX_COUNTER )
 318         {
 319
 320                 DB(mvOsPrintf(("mvCntmrDisable: Err. Illigal counter number \n")));
 321                 return MV_BAD_PARAM;;
 322
 323         }
 324
 325         /* read control register */
 326         cntmrCtrl = MV_REG_READ(CNTMR_CTRL_REG);
 327
 328         /* disable counter\timer */
 329         cntmrCtrl &= ~CTCR_ARM_TIMER_EN(countNum);
 330
 331         MV_REG_WRITE(CNTMR_CTRL_REG,cntmrCtrl);
 332
 333         return MV_OK;
 334 }
 335
 336 /*******************************************************************************
 337 * mvCntmrStart -
 338 *
 339 * DESCRIPTION:
 340 *       Combined all the sub-operations above to one function: Load,setMode,Enable
 341 *
 342 * INPUT:
 343 *       countNum - counter number
 344 *               value - value of the counter\timer to be set
 345 *               pCtrl - pointer to MV_CNTMR_CTRL structure
 346 *
 347 * OUTPUT:
 348 *       None.
 349 *
 350 * RETURN:
 351 *       MV_BAD_PARAM on bad parameters , MV_ERROR on error ,MV_OK on sucess
 352 *******************************************************************************/
 353 MV_STATUS mvCntmrStart(MV_U32 countNum, MV_U32 value,
 354                        MV_CNTMR_CTRL *pCtrl)
 355 {
 356
 357         if (countNum >= MV_CNTMR_MAX_COUNTER )
 358         {
 359
 360                 mvOsPrintf(("mvCntmrDisable: Err. Illigal counter number \n"));
 361                 return MV_BAD_PARAM;;
 362
 363         }
 364
 365         /* load value onto counter\timer */
 366         mvCntmrLoad(countNum,value);
 367
 368         /* set the counter to load in the first time */
 369         mvCntmrWrite(countNum,value);
 370
 371         /* set control for timer \ cunter and enable */
 372         mvCntmrCtrlSet(countNum,pCtrl);
 373
 374         return MV_OK;
 375 }
 376