drivers/hid/intel-ish-hid/ishtp/dma-if.c

   1 /*
   2  * ISHTP DMA I/F functions
   3  *
   4  * Copyright (c) 2003-2016, Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16
  17 #include <linux/slab.h>
  18 #include <linux/sched.h>
  19 #include <linux/wait.h>
  20 #include <linux/delay.h>
  21 #include <linux/dma-mapping.h>
  22 #include "ishtp-dev.h"
  23 #include "client.h"
  24
  25 /**
  26  * ishtp_cl_alloc_dma_buf() - Allocate DMA RX and TX buffer
  27  * @dev: ishtp device
  28  *
  29  * Allocate RX and TX DMA buffer once during bus setup.
  30  * It allocates 1MB, RX and TX DMA buffer, which are divided
  31  * into slots.
  32  */
  33 void    ishtp_cl_alloc_dma_buf(struct ishtp_device *dev)
  34 {
  35         dma_addr_t      h;
  36
  37         if (dev->ishtp_host_dma_tx_buf)
  38                 return;
  39
  40         dev->ishtp_host_dma_tx_buf_size = 1024*1024;
  41         dev->ishtp_host_dma_rx_buf_size = 1024*1024;
  42
  43         /* Allocate Tx buffer and init usage bitmap */
  44         dev->ishtp_host_dma_tx_buf = dma_alloc_coherent(dev->devc,
  45                                         dev->ishtp_host_dma_tx_buf_size,
  46                                         &h, GFP_KERNEL);
  47         if (dev->ishtp_host_dma_tx_buf)
  48                 dev->ishtp_host_dma_tx_buf_phys = h;
  49
  50         dev->ishtp_dma_num_slots = dev->ishtp_host_dma_tx_buf_size /
  51                                                 DMA_SLOT_SIZE;
  52
  53         dev->ishtp_dma_tx_map = kcalloc(dev->ishtp_dma_num_slots,
  54                                         sizeof(uint8_t),
  55                                         GFP_KERNEL);
  56         spin_lock_init(&dev->ishtp_dma_tx_lock);
  57
  58         /* Allocate Rx buffer */
  59         dev->ishtp_host_dma_rx_buf = dma_alloc_coherent(dev->devc,
  60                                         dev->ishtp_host_dma_rx_buf_size,
  61                                          &h, GFP_KERNEL);
  62
  63         if (dev->ishtp_host_dma_rx_buf)
  64                 dev->ishtp_host_dma_rx_buf_phys = h;
  65 }
  66
  67 /**
  68  * ishtp_cl_free_dma_buf() - Free DMA RX and TX buffer
  69  * @dev: ishtp device
  70  *
  71  * Free DMA buffer when all clients are released. This is
  72  * only happens during error path in ISH built in driver
  73  * model
  74  */
  75 void    ishtp_cl_free_dma_buf(struct ishtp_device *dev)
  76 {
  77         dma_addr_t      h;
  78
  79         if (dev->ishtp_host_dma_tx_buf) {
  80                 h = dev->ishtp_host_dma_tx_buf_phys;
  81                 dma_free_coherent(dev->devc, dev->ishtp_host_dma_tx_buf_size,
  82                                   dev->ishtp_host_dma_tx_buf, h);
  83         }
  84
  85         if (dev->ishtp_host_dma_rx_buf) {
  86                 h = dev->ishtp_host_dma_rx_buf_phys;
  87                 dma_free_coherent(dev->devc, dev->ishtp_host_dma_rx_buf_size,
  88                                   dev->ishtp_host_dma_rx_buf, h);
  89         }
  90
  91         kfree(dev->ishtp_dma_tx_map);
  92         dev->ishtp_host_dma_tx_buf = NULL;
  93         dev->ishtp_host_dma_rx_buf = NULL;
  94         dev->ishtp_dma_tx_map = NULL;
  95 }
  96
  97 /*
  98  * ishtp_cl_get_dma_send_buf() - Get a DMA memory slot
  99  * @dev:        ishtp device
 100  * @size:       Size of memory to get
 101  *
 102  * Find and return free address of "size" bytes in dma tx buffer.
 103  * the function will mark this address as "in-used" memory.
 104  *
 105  * Return: NULL when no free buffer else a buffer to copy
 106  */
 107 void *ishtp_cl_get_dma_send_buf(struct ishtp_device *dev,
 108                                 uint32_t size)
 109 {
 110         unsigned long   flags;
 111         int i, j, free;
 112         /* additional slot is needed if there is rem */
 113         int required_slots = (size / DMA_SLOT_SIZE)
 114                 + 1 * (size % DMA_SLOT_SIZE != 0);
 115
 116         spin_lock_irqsave(&dev->ishtp_dma_tx_lock, flags);
 117         for (i = 0; i <= (dev->ishtp_dma_num_slots - required_slots); i++) {
 118                 free = 1;
 119                 for (j = 0; j < required_slots; j++)
 120                         if (dev->ishtp_dma_tx_map[i+j]) {
 121                                 free = 0;
 122                                 i += j;
 123                                 break;
 124                         }
 125                 if (free) {
 126                         /* mark memory as "caught" */
 127                         for (j = 0; j < required_slots; j++)
 128                                 dev->ishtp_dma_tx_map[i+j] = 1;
 129                         spin_unlock_irqrestore(&dev->ishtp_dma_tx_lock, flags);
 130                         return (i * DMA_SLOT_SIZE) +
 131                                 (unsigned char *)dev->ishtp_host_dma_tx_buf;
 132                 }
 133         }
 134         spin_unlock_irqrestore(&dev->ishtp_dma_tx_lock, flags);
 135         dev_err(dev->devc, "No free DMA buffer to send msg\n");
 136         return NULL;
 137 }
 138
 139 /*
 140  * ishtp_cl_release_dma_acked_mem() - Release DMA memory slot
 141  * @dev:        ishtp device
 142  * @msg_addr:   message address of slot
 143  * @size:       Size of memory to get
 144  *
 145  * Release_dma_acked_mem - returnes the acked memory to free list.
 146  * (from msg_addr, size bytes long)
 147  */
 148 void ishtp_cl_release_dma_acked_mem(struct ishtp_device *dev,
 149                                     void *msg_addr,
 150                                     uint8_t size)
 151 {
 152         unsigned long   flags;
 153         int acked_slots = (size / DMA_SLOT_SIZE)
 154                 + 1 * (size % DMA_SLOT_SIZE != 0);
 155         int i, j;
 156
 157         if ((msg_addr - dev->ishtp_host_dma_tx_buf) % DMA_SLOT_SIZE) {
 158                 dev_err(dev->devc, "Bad DMA Tx ack address\n");
 159                 return;
 160         }
 161
 162         i = (msg_addr - dev->ishtp_host_dma_tx_buf) / DMA_SLOT_SIZE;
 163         spin_lock_irqsave(&dev->ishtp_dma_tx_lock, flags);
 164         for (j = 0; j < acked_slots; j++) {
 165                 if ((i + j) >= dev->ishtp_dma_num_slots ||
 166                                         !dev->ishtp_dma_tx_map[i+j]) {
 167                         /* no such slot, or memory is already free */
 168                         spin_unlock_irqrestore(&dev->ishtp_dma_tx_lock, flags);
 169                         dev_err(dev->devc, "Bad DMA Tx ack address\n");
 170                         return;
 171                 }
 172                 dev->ishtp_dma_tx_map[i+j] = 0;
 173         }
 174         spin_unlock_irqrestore(&dev->ishtp_dma_tx_lock, flags);
 175 }