LCOV - code coverage report
Current view: top level - include/linux - dma-debug.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2017-01-25 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2008 Advanced Micro Devices, Inc.
       3             :  *
       4             :  * Author: Joerg Roedel <joerg.roedel@amd.com>
       5             :  *
       6             :  * This program is free software; you can redistribute it and/or modify it
       7             :  * under the terms of the GNU General Public License version 2 as published
       8             :  * by the Free Software Foundation.
       9             :  *
      10             :  * This program is distributed in the hope that it will be useful,
      11             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13             :  * GNU General Public License for more details.
      14             :  *
      15             :  * You should have received a copy of the GNU General Public License
      16             :  * along with this program; if not, write to the Free Software
      17             :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
      18             :  */
      19             : 
      20             : #ifndef __DMA_DEBUG_H
      21             : #define __DMA_DEBUG_H
      22             : 
      23             : #include <linux/types.h>
      24             : 
      25             : struct device;
      26             : struct scatterlist;
      27             : struct bus_type;
      28             : 
      29             : #ifdef CONFIG_DMA_API_DEBUG
      30             : 
      31             : extern void dma_debug_add_bus(struct bus_type *bus);
      32             : 
      33             : extern void dma_debug_init(u32 num_entries);
      34             : 
      35             : extern int dma_debug_resize_entries(u32 num_entries);
      36             : 
      37             : extern void debug_dma_map_page(struct device *dev, struct page *page,
      38             :                                size_t offset, size_t size,
      39             :                                int direction, dma_addr_t dma_addr,
      40             :                                bool map_single);
      41             : 
      42             : extern void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
      43             :                                  size_t size, int direction, bool map_single);
      44             : 
      45             : extern void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
      46             :                              int nents, int mapped_ents, int direction);
      47             : 
      48             : extern void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
      49             :                                int nelems, int dir);
      50             : 
      51             : extern void debug_dma_alloc_coherent(struct device *dev, size_t size,
      52             :                                      dma_addr_t dma_addr, void *virt);
      53             : 
      54             : extern void debug_dma_free_coherent(struct device *dev, size_t size,
      55             :                                     void *virt, dma_addr_t addr);
      56             : 
      57             : extern void debug_dma_sync_single_for_cpu(struct device *dev,
      58             :                                           dma_addr_t dma_handle, size_t size,
      59             :                                           int direction);
      60             : 
      61             : extern void debug_dma_sync_single_for_device(struct device *dev,
      62             :                                              dma_addr_t dma_handle,
      63             :                                              size_t size, int direction);
      64             : 
      65             : extern void debug_dma_sync_single_range_for_cpu(struct device *dev,
      66             :                                                 dma_addr_t dma_handle,
      67             :                                                 unsigned long offset,
      68             :                                                 size_t size,
      69             :                                                 int direction);
      70             : 
      71             : extern void debug_dma_sync_single_range_for_device(struct device *dev,
      72             :                                                    dma_addr_t dma_handle,
      73             :                                                    unsigned long offset,
      74             :                                                    size_t size, int direction);
      75             : 
      76             : extern void debug_dma_sync_sg_for_cpu(struct device *dev,
      77             :                                       struct scatterlist *sg,
      78             :                                       int nelems, int direction);
      79             : 
      80             : extern void debug_dma_sync_sg_for_device(struct device *dev,
      81             :                                          struct scatterlist *sg,
      82             :                                          int nelems, int direction);
      83             : 
      84             : extern void debug_dma_dump_mappings(struct device *dev);
      85             : 
      86             : #else /* CONFIG_DMA_API_DEBUG */
      87             : 
      88             : static inline void dma_debug_add_bus(struct bus_type *bus)
      89             : {
      90             : }
      91             : 
      92             : static inline void dma_debug_init(u32 num_entries)
      93             : {
      94             : }
      95             : 
      96             : static inline int dma_debug_resize_entries(u32 num_entries)
      97             : {
      98             :         return 0;
      99             : }
     100             : 
     101             : static inline void debug_dma_map_page(struct device *dev, struct page *page,
     102             :                                       size_t offset, size_t size,
     103             :                                       int direction, dma_addr_t dma_addr,
     104             :                                       bool map_single)
     105             : {
     106             : }
     107             : 
     108             : static inline void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
     109             :                                         size_t size, int direction,
     110             :                                         bool map_single)
     111             : {
     112             : }
     113             : 
     114             : static inline void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
     115             :                                     int nents, int mapped_ents, int direction)
     116             : {
     117             : }
     118             : 
     119             : static inline void debug_dma_unmap_sg(struct device *dev,
     120             :                                       struct scatterlist *sglist,
     121             :                                       int nelems, int dir)
     122             : {
     123             : }
     124             : 
     125             : static inline void debug_dma_alloc_coherent(struct device *dev, size_t size,
     126             :                                             dma_addr_t dma_addr, void *virt)
     127           1 : {
     128             : }
     129             : 
     130             : static inline void debug_dma_free_coherent(struct device *dev, size_t size,
     131             :                                            void *virt, dma_addr_t addr)
     132           9 : {
     133             : }
     134             : 
     135             : static inline void debug_dma_sync_single_for_cpu(struct device *dev,
     136             :                                                  dma_addr_t dma_handle,
     137             :                                                  size_t size, int direction)
     138             : {
     139             : }
     140             : 
     141             : static inline void debug_dma_sync_single_for_device(struct device *dev,
     142             :                                                     dma_addr_t dma_handle,
     143             :                                                     size_t size, int direction)
     144             : {
     145             : }
     146             : 
     147             : static inline void debug_dma_sync_single_range_for_cpu(struct device *dev,
     148             :                                                        dma_addr_t dma_handle,
     149             :                                                        unsigned long offset,
     150             :                                                        size_t size,
     151             :                                                        int direction)
     152             : {
     153             : }
     154             : 
     155             : static inline void debug_dma_sync_single_range_for_device(struct device *dev,
     156             :                                                           dma_addr_t dma_handle,
     157             :                                                           unsigned long offset,
     158             :                                                           size_t size,
     159             :                                                           int direction)
     160             : {
     161             : }
     162             : 
     163             : static inline void debug_dma_sync_sg_for_cpu(struct device *dev,
     164             :                                              struct scatterlist *sg,
     165             :                                              int nelems, int direction)
     166             : {
     167             : }
     168             : 
     169             : static inline void debug_dma_sync_sg_for_device(struct device *dev,
     170             :                                                 struct scatterlist *sg,
     171             :                                                 int nelems, int direction)
     172             : {
     173             : }
     174             : 
     175             : static inline void debug_dma_dump_mappings(struct device *dev)
     176             : {
     177             : }
     178             : 
     179             : #endif /* CONFIG_DMA_API_DEBUG */
     180             : 
     181             : #endif /* __DMA_DEBUG_H */

Generated by: LCOV version 1.10