1 /* 2 * Device tree helpers for DMA request / controller 3 * 4 * Based on of_gpio.c 5 * 6 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/ 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/device.h> 14 #include <linux/err.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/slab.h> 18 #include <linux/of.h> 19 #include <linux/of_dma.h> 20 21 static LIST_HEAD(of_dma_list); 22 static DEFINE_MUTEX(of_dma_lock); 23 24 /** 25 * of_dma_find_controller - Get a DMA controller in DT DMA helpers list 26 * @dma_spec: pointer to DMA specifier as found in the device tree 27 * 28 * Finds a DMA controller with matching device node and number for dma cells 29 * in a list of registered DMA controllers. If a match is found a valid pointer 30 * to the DMA data stored is retuned. A NULL pointer is returned if no match is 31 * found. 32 */ 33 static struct of_dma *of_dma_find_controller(struct of_phandle_args *dma_spec) 34 { 35 struct of_dma *ofdma; 36 37 list_for_each_entry(ofdma, &of_dma_list, of_dma_controllers) 38 if ((ofdma->of_node == dma_spec->np) && 39 (ofdma->of_dma_nbcells == dma_spec->args_count)) 40 return ofdma; 41 42 pr_debug("%s: can't find DMA controller %s\n", __func__, 43 dma_spec->np->full_name); 44 45 return NULL; 46 } 47 48 /** 49 * of_dma_controller_register - Register a DMA controller to DT DMA helpers 50 * @np: device node of DMA controller 51 * @of_dma_xlate: translation function which converts a phandle 52 * arguments list into a dma_chan structure 53 * @data pointer to controller specific data to be used by 54 * translation function 55 * 56 * Returns 0 on success or appropriate errno value on error. 57 * 58 * Allocated memory should be freed with appropriate of_dma_controller_free() 59 * call. 60 */ 61 int of_dma_controller_register(struct device_node *np, 62 struct dma_chan *(*of_dma_xlate) 63 (struct of_phandle_args *, struct of_dma *), 64 void *data) 65 { 66 struct of_dma *ofdma; 67 int nbcells; 68 const __be32 *prop; 69 70 if (!np || !of_dma_xlate) { 71 pr_err("%s: not enough information provided\n", __func__); 72 return -EINVAL; 73 } 74 75 ofdma = kzalloc(sizeof(*ofdma), GFP_KERNEL); 76 if (!ofdma) 77 return -ENOMEM; 78 79 prop = of_get_property(np, "#dma-cells", NULL); 80 if (prop) 81 nbcells = be32_to_cpup(prop); 82 83 if (!prop || !nbcells) { 84 pr_err("%s: #dma-cells property is missing or invalid\n", 85 __func__); 86 kfree(ofdma); 87 return -EINVAL; 88 } 89 90 ofdma->of_node = np; 91 ofdma->of_dma_nbcells = nbcells; 92 ofdma->of_dma_xlate = of_dma_xlate; 93 ofdma->of_dma_data = data; 94 95 /* Now queue of_dma controller structure in list */ 96 mutex_lock(&of_dma_lock); 97 list_add_tail(&ofdma->of_dma_controllers, &of_dma_list); 98 mutex_unlock(&of_dma_lock); 99 100 return 0; 101 } 102 EXPORT_SYMBOL_GPL(of_dma_controller_register); 103 104 /** 105 * of_dma_controller_free - Remove a DMA controller from DT DMA helpers list 106 * @np: device node of DMA controller 107 * 108 * Memory allocated by of_dma_controller_register() is freed here. 109 */ 110 void of_dma_controller_free(struct device_node *np) 111 { 112 struct of_dma *ofdma; 113 114 mutex_lock(&of_dma_lock); 115 116 list_for_each_entry(ofdma, &of_dma_list, of_dma_controllers) 117 if (ofdma->of_node == np) { 118 list_del(&ofdma->of_dma_controllers); 119 kfree(ofdma); 120 break; 121 } 122 123 mutex_unlock(&of_dma_lock); 124 } 125 EXPORT_SYMBOL_GPL(of_dma_controller_free); 126 127 /** 128 * of_dma_match_channel - Check if a DMA specifier matches name 129 * @np: device node to look for DMA channels 130 * @name: channel name to be matched 131 * @index: index of DMA specifier in list of DMA specifiers 132 * @dma_spec: pointer to DMA specifier as found in the device tree 133 * 134 * Check if the DMA specifier pointed to by the index in a list of DMA 135 * specifiers, matches the name provided. Returns 0 if the name matches and 136 * a valid pointer to the DMA specifier is found. Otherwise returns -ENODEV. 137 */ 138 static int of_dma_match_channel(struct device_node *np, const char *name, 139 int index, struct of_phandle_args *dma_spec) 140 { 141 const char *s; 142 143 if (of_property_read_string_index(np, "dma-names", index, &s)) 144 return -ENODEV; 145 146 if (strcmp(name, s)) 147 return -ENODEV; 148 149 if (of_parse_phandle_with_args(np, "dmas", "#dma-cells", index, 150 dma_spec)) 151 return -ENODEV; 152 153 return 0; 154 } 155 156 /** 157 * of_dma_request_slave_channel - Get the DMA slave channel 158 * @np: device node to get DMA request from 159 * @name: name of desired channel 160 * 161 * Returns pointer to appropriate dma channel on success or NULL on error. 162 */ 163 struct dma_chan *of_dma_request_slave_channel(struct device_node *np, 164 const char *name) 165 { 166 struct of_phandle_args dma_spec; 167 struct of_dma *ofdma; 168 struct dma_chan *chan; 169 int count, i; 170 171 if (!np || !name) { 172 pr_err("%s: not enough information provided\n", __func__); 173 return NULL; 174 } 175 176 count = of_property_count_strings(np, "dma-names"); 177 if (count < 0) { 178 pr_err("%s: dma-names property missing or empty\n", __func__); 179 return NULL; 180 } 181 182 for (i = 0; i < count; i++) { 183 if (of_dma_match_channel(np, name, i, &dma_spec)) 184 continue; 185 186 mutex_lock(&of_dma_lock); 187 ofdma = of_dma_find_controller(&dma_spec); 188 189 if (ofdma) 190 chan = ofdma->of_dma_xlate(&dma_spec, ofdma); 191 else 192 chan = NULL; 193 194 mutex_unlock(&of_dma_lock); 195 196 of_node_put(dma_spec.np); 197 198 if (chan) 199 return chan; 200 } 201 202 return NULL; 203 } 204 205 /** 206 * of_dma_simple_xlate - Simple DMA engine translation function 207 * @dma_spec: pointer to DMA specifier as found in the device tree 208 * @of_dma: pointer to DMA controller data 209 * 210 * A simple translation function for devices that use a 32-bit value for the 211 * filter_param when calling the DMA engine dma_request_channel() function. 212 * Note that this translation function requires that #dma-cells is equal to 1 213 * and the argument of the dma specifier is the 32-bit filter_param. Returns 214 * pointer to appropriate dma channel on success or NULL on error. 215 */ 216 struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec, 217 struct of_dma *ofdma) 218 { 219 int count = dma_spec->args_count; 220 struct of_dma_filter_info *info = ofdma->of_dma_data; 221 222 if (!info || !info->filter_fn) 223 return NULL; 224 225 if (count != 1) 226 return NULL; 227 228 return dma_request_channel(info->dma_cap, info->filter_fn, 229 &dma_spec->args[0]); 230 } 231 EXPORT_SYMBOL_GPL(of_dma_simple_xlate); 232