target/linux/ifxmips/files-2.6.33/drivers/crypto/ifxmips/ifxmips_deu_dma.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; either version 2 of the License, or
   5  *   (at your option) any later version.
   6  *
   7  *   This program is distributed in the hope that it will be useful,
   8  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *   GNU General Public License for more details.
  11  *
  12  *   You should have received a copy of the GNU General Public License
  13  *   along with this program; if not, write to the Free Software
  14  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  15  *
  16  *   Copyright (C) 2010 Ralph Hempel <ralph.hempel@lantiq.com>
  17  *   Copyright (C) 2009 Mohammad Firdaus
  18  */
  19
  20 /*!
  21   \defgroup IFX_DEU IFX_DEU_DRIVERS
  22   \ingroup  IFX_API
  23   \brief ifx deu driver module
  24 */
  25
  26 /*!
  27   \file ifxmips_deu_dma.c
  28   \ingroup IFX_DEU
  29   \brief DMA deu driver file
  30 */
  31
  32 /*!
  33  \defgroup IFX_DMA_FUNCTIONS IFX_DMA_FUNCTIONS
  34  \ingroup IFX_DEU
  35  \brief deu-dma driver functions
  36 */
  37
  38 /* Project header files */
  39 #include <linux/module.h>
  40 #include <linux/init.h>
  41 #include <linux/types.h>
  42 #include <linux/errno.h>
  43 #include <linux/delay.h>
  44 #include <asm/io.h>
  45 #include "ifxmips_deu.h"
  46
  47 extern _ifx_deu_device ifx_deu[1];
  48 extern spinlock_t ifx_deu_lock;
  49
  50 //extern deu_drv_priv_t deu_dma_priv;
  51
  52 /*! \fn int deu_dma_intr_handler (struct dma_device_info *dma_dev, int status)
  53  *  \ingroup IFX_DMA_FUNCTIONS
  54  *  \brief callback function for deu dma interrupt
  55  *  \param dma_dev dma device
  56  *  \param status not used
  57 */
  58 int deu_dma_intr_handler (struct dma_device_info *dma_dev, int status)
  59 {
  60 #if 0
  61     int len = 0;
  62     while (len <= 20000) { len++; }
  63     u8 *buf;
  64     int len = 0;
  65
  66
  67     deu_drv_priv_t *deu_priv = (deu_drv_priv_t *)dma_dev->priv;
  68     //printk("status:%d \n",status);
  69     switch(status) {
  70         case RCV_INT:
  71             len = dma_device_read(dma_dev, (u8 **)&buf, NULL);
  72             if ( len != deu_priv->deu_rx_len) {
  73                 printk(KERN_ERR "%s packet length %d is not equal to expect %d\n",
  74                     __func__, len, deu_priv->deu_rx_len);
  75                 return -1;
  76             }
  77             memcpy(deu_priv->deu_rx_buf, buf, deu_priv->deu_rx_len);
  78             /* Reset for next usage */
  79             deu_priv->deu_rx_buf = NULL;
  80             deu_priv->deu_rx_len = 0;
  81             DEU_WAKEUP_EVENT(deu_priv->deu_thread_wait, DEU_EVENT, deu_priv->deu_event_flags);
  82             break;
  83         case TX_BUF_FULL_INT:
  84              // delay for buffer to be cleared
  85              while (len <= 20000) { len++; }
  86              break;
  87
  88         case TRANSMIT_CPT_INT:
  89             break;
  90         default:
  91             break;
  92     }
  93 #endif
  94     return 0;
  95 }
  96
  97 extern u8 *g_dma_block;
  98 extern u8 *g_dma_block2;
  99
 100 /*! \fn u8 *deu_dma_buffer_alloc (int len, int *byte_offset, void **opt)
 101  *  \ingroup IFX_DMA_FUNCTIONS
 102  *  \brief callback function for allocating buffers for dma receive descriptors
 103  *  \param len not used
 104  *  \param byte_offset dma byte offset
 105  *  \param *opt not used
 106  *
 107 */
 108 u8 *deu_dma_buffer_alloc (int len, int *byte_offset, void **opt)
 109 {
 110     u8 *swap = NULL;
 111
 112     // dma-core needs at least 2 blocks of memory
 113     swap = g_dma_block;
 114     g_dma_block = g_dma_block2;
 115     g_dma_block2 = swap;
 116
 117     //dma_cache_wback_inv((unsigned long) g_dma_block, (PAGE_SIZE >> 1));
 118     *byte_offset = 0;
 119
 120     return g_dma_block;
 121 }
 122
 123 /*! \fn int deu_dma_buffer_free (u8 * dataptr, void *opt)
 124  *  \ingroup IFX_DMA_FUNCTIONS
 125  *  \brief callback function for freeing dma transmit descriptors
 126  *  \param dataptr data pointer to be freed
 127  *  \param opt not used
 128 */
 129 int deu_dma_buffer_free (u8 *dataptr, void *opt)
 130 {
 131 #if 0
 132     printk("Trying to free memory buffer\n");
 133     if (dataptr == NULL && opt == NULL)
 134         return 0;
 135     else if (opt == NULL) {
 136         kfree(dataptr);
 137         return 1;
 138     }
 139     else if (dataptr == NULL) {
 140        kfree(opt);
 141        return 1;
 142     }
 143     else {
 144        kfree(opt);
 145        kfree(dataptr);
 146     }
 147 #endif
 148     return 0;
 149 }
 150