tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
12 * more details.
13 */
14
15#ifndef _ASM_TILE_DMA_MAPPING_H
16#define _ASM_TILE_DMA_MAPPING_H
17
18#include <linux/mm.h>
19#include <linux/scatterlist.h>
20#include <linux/cache.h>
21#include <linux/io.h>
22
23extern struct dma_map_ops *tile_dma_map_ops;
24extern struct dma_map_ops *gx_pci_dma_map_ops;
25extern struct dma_map_ops *gx_legacy_pci_dma_map_ops;
26
27static inline struct dma_map_ops *get_dma_ops(struct device *dev)
28{
29 if (dev && dev->archdata.dma_ops)
30 return dev->archdata.dma_ops;
31 else
32 return tile_dma_map_ops;
33}
34
35static inline dma_addr_t get_dma_offset(struct device *dev)
36{
37 return dev->archdata.dma_offset;
38}
39
40static inline void set_dma_offset(struct device *dev, dma_addr_t off)
41{
42 dev->archdata.dma_offset = off;
43}
44
45static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr)
46{
47 return paddr + get_dma_offset(dev);
48}
49
50static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr)
51{
52 return daddr - get_dma_offset(dev);
53}
54
55static inline void dma_mark_clean(void *addr, size_t size) {}
56
57#include <asm-generic/dma-mapping-common.h>
58
59static inline void set_dma_ops(struct device *dev, struct dma_map_ops *ops)
60{
61 dev->archdata.dma_ops = ops;
62}
63
64static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
65{
66 if (!dev->dma_mask)
67 return 0;
68
69 return addr + size - 1 <= *dev->dma_mask;
70}
71
72static inline int
73dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
74{
75 debug_dma_mapping_error(dev, dma_addr);
76 return get_dma_ops(dev)->mapping_error(dev, dma_addr);
77}
78
79static inline int
80dma_supported(struct device *dev, u64 mask)
81{
82 return get_dma_ops(dev)->dma_supported(dev, mask);
83}
84
85static inline int
86dma_set_mask(struct device *dev, u64 mask)
87{
88 struct dma_map_ops *dma_ops = get_dma_ops(dev);
89
90 /* Handle legacy PCI devices with limited memory addressability. */
91 if ((dma_ops == gx_pci_dma_map_ops) && (mask <= DMA_BIT_MASK(32))) {
92 set_dma_ops(dev, gx_legacy_pci_dma_map_ops);
93 set_dma_offset(dev, 0);
94 if (mask > dev->archdata.max_direct_dma_addr)
95 mask = dev->archdata.max_direct_dma_addr;
96 }
97
98 if (!dev->dma_mask || !dma_supported(dev, mask))
99 return -EIO;
100
101 *dev->dma_mask = mask;
102
103 return 0;
104}
105
106static inline void *dma_alloc_attrs(struct device *dev, size_t size,
107 dma_addr_t *dma_handle, gfp_t flag,
108 struct dma_attrs *attrs)
109{
110 struct dma_map_ops *dma_ops = get_dma_ops(dev);
111 void *cpu_addr;
112
113 cpu_addr = dma_ops->alloc(dev, size, dma_handle, flag, attrs);
114
115 debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
116
117 return cpu_addr;
118}
119
120static inline void dma_free_attrs(struct device *dev, size_t size,
121 void *cpu_addr, dma_addr_t dma_handle,
122 struct dma_attrs *attrs)
123{
124 struct dma_map_ops *dma_ops = get_dma_ops(dev);
125
126 debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
127
128 dma_ops->free(dev, size, cpu_addr, dma_handle, attrs);
129}
130
131#define dma_alloc_coherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
132#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
133#define dma_free_coherent(d, s, v, h) dma_free_attrs(d, s, v, h, NULL)
134#define dma_free_noncoherent(d, s, v, h) dma_free_attrs(d, s, v, h, NULL)
135
136/*
137 * dma_alloc_noncoherent() is #defined to return coherent memory,
138 * so there's no need to do any flushing here.
139 */
140static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
141 enum dma_data_direction direction)
142{
143}
144
145#endif /* _ASM_TILE_DMA_MAPPING_H */