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 return ofdma; 40 41 pr_debug("%s: can't find DMA controller %s\n", __func__, 42 dma_spec->np->full_name); 43 44 return NULL; 45 } 46 47 /** 48 * of_dma_controller_register - Register a DMA controller to DT DMA helpers 49 * @np: device node of DMA controller 50 * @of_dma_xlate: translation function which converts a phandle 51 * arguments list into a dma_chan structure 52 * @data pointer to controller specific data to be used by 53 * translation function 54 * 55 * Returns 0 on success or appropriate errno value on error. 56 * 57 * Allocated memory should be freed with appropriate of_dma_controller_free() 58 * call. 59 */ 60 int of_dma_controller_register(struct device_node *np, 61 struct dma_chan *(*of_dma_xlate) 62 (struct of_phandle_args *, struct of_dma *), 63 void *data) 64 { 65 struct of_dma *ofdma; 66 67 if (!np || !of_dma_xlate) { 68 pr_err("%s: not enough information provided\n", __func__); 69 return -EINVAL; 70 } 71 72 ofdma = kzalloc(sizeof(*ofdma), GFP_KERNEL); 73 if (!ofdma) 74 return -ENOMEM; 75 76 ofdma->of_node = np; 77 ofdma->of_dma_xlate = of_dma_xlate; 78 ofdma->of_dma_data = data; 79 80 /* Now queue of_dma controller structure in list */ 81 mutex_lock(&of_dma_lock); 82 list_add_tail(&ofdma->of_dma_controllers, &of_dma_list); 83 mutex_unlock(&of_dma_lock); 84 85 return 0; 86 } 87 EXPORT_SYMBOL_GPL(of_dma_controller_register); 88 89 /** 90 * of_dma_controller_free - Remove a DMA controller from DT DMA helpers list 91 * @np: device node of DMA controller 92 * 93 * Memory allocated by of_dma_controller_register() is freed here. 94 */ 95 void of_dma_controller_free(struct device_node *np) 96 { 97 struct of_dma *ofdma; 98 99 mutex_lock(&of_dma_lock); 100 101 list_for_each_entry(ofdma, &of_dma_list, of_dma_controllers) 102 if (ofdma->of_node == np) { 103 list_del(&ofdma->of_dma_controllers); 104 kfree(ofdma); 105 break; 106 } 107 108 mutex_unlock(&of_dma_lock); 109 } 110 EXPORT_SYMBOL_GPL(of_dma_controller_free); 111 112 /** 113 * of_dma_match_channel - Check if a DMA specifier matches name 114 * @np: device node to look for DMA channels 115 * @name: channel name to be matched 116 * @index: index of DMA specifier in list of DMA specifiers 117 * @dma_spec: pointer to DMA specifier as found in the device tree 118 * 119 * Check if the DMA specifier pointed to by the index in a list of DMA 120 * specifiers, matches the name provided. Returns 0 if the name matches and 121 * a valid pointer to the DMA specifier is found. Otherwise returns -ENODEV. 122 */ 123 static int of_dma_match_channel(struct device_node *np, const char *name, 124 int index, struct of_phandle_args *dma_spec) 125 { 126 const char *s; 127 128 if (of_property_read_string_index(np, "dma-names", index, &s)) 129 return -ENODEV; 130 131 if (strcmp(name, s)) 132 return -ENODEV; 133 134 if (of_parse_phandle_with_args(np, "dmas", "#dma-cells", index, 135 dma_spec)) 136 return -ENODEV; 137 138 return 0; 139 } 140 141 /** 142 * of_dma_request_slave_channel - Get the DMA slave channel 143 * @np: device node to get DMA request from 144 * @name: name of desired channel 145 * 146 * Returns pointer to appropriate DMA channel on success or an error pointer. 147 */ 148 struct dma_chan *of_dma_request_slave_channel(struct device_node *np, 149 const char *name) 150 { 151 struct of_phandle_args dma_spec; 152 struct of_dma *ofdma; 153 struct dma_chan *chan; 154 int count, i; 155 int ret_no_channel = -ENODEV; 156 157 if (!np || !name) { 158 pr_err("%s: not enough information provided\n", __func__); 159 return ERR_PTR(-ENODEV); 160 } 161 162 /* Silently fail if there is not even the "dmas" property */ 163 if (!of_find_property(np, "dmas", NULL)) 164 return ERR_PTR(-ENODEV); 165 166 count = of_property_count_strings(np, "dma-names"); 167 if (count < 0) { 168 pr_err("%s: dma-names property of node '%s' missing or empty\n", 169 __func__, np->full_name); 170 return ERR_PTR(-ENODEV); 171 } 172 173 for (i = 0; i < count; i++) { 174 if (of_dma_match_channel(np, name, i, &dma_spec)) 175 continue; 176 177 mutex_lock(&of_dma_lock); 178 ofdma = of_dma_find_controller(&dma_spec); 179 180 if (ofdma) { 181 chan = ofdma->of_dma_xlate(&dma_spec, ofdma); 182 } else { 183 ret_no_channel = -EPROBE_DEFER; 184 chan = NULL; 185 } 186 187 mutex_unlock(&of_dma_lock); 188 189 of_node_put(dma_spec.np); 190 191 if (chan) 192 return chan; 193 } 194 195 return ERR_PTR(ret_no_channel); 196 } 197 198 /** 199 * of_dma_simple_xlate - Simple DMA engine translation function 200 * @dma_spec: pointer to DMA specifier as found in the device tree 201 * @of_dma: pointer to DMA controller data 202 * 203 * A simple translation function for devices that use a 32-bit value for the 204 * filter_param when calling the DMA engine dma_request_channel() function. 205 * Note that this translation function requires that #dma-cells is equal to 1 206 * and the argument of the dma specifier is the 32-bit filter_param. Returns 207 * pointer to appropriate dma channel on success or NULL on error. 208 */ 209 struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec, 210 struct of_dma *ofdma) 211 { 212 int count = dma_spec->args_count; 213 struct of_dma_filter_info *info = ofdma->of_dma_data; 214 215 if (!info || !info->filter_fn) 216 return NULL; 217 218 if (count != 1) 219 return NULL; 220 221 return dma_request_channel(info->dma_cap, info->filter_fn, 222 &dma_spec->args[0]); 223 } 224 EXPORT_SYMBOL_GPL(of_dma_simple_xlate); 225 226 /** 227 * of_dma_xlate_by_chan_id - Translate dt property to DMA channel by channel id 228 * @dma_spec: pointer to DMA specifier as found in the device tree 229 * @of_dma: pointer to DMA controller data 230 * 231 * This function can be used as the of xlate callback for DMA driver which wants 232 * to match the channel based on the channel id. When using this xlate function 233 * the #dma-cells propety of the DMA controller dt node needs to be set to 1. 234 * The data parameter of of_dma_controller_register must be a pointer to the 235 * dma_device struct the function should match upon. 236 * 237 * Returns pointer to appropriate dma channel on success or NULL on error. 238 */ 239 struct dma_chan *of_dma_xlate_by_chan_id(struct of_phandle_args *dma_spec, 240 struct of_dma *ofdma) 241 { 242 struct dma_device *dev = ofdma->of_dma_data; 243 struct dma_chan *chan, *candidate = NULL; 244 245 if (!dev || dma_spec->args_count != 1) 246 return NULL; 247 248 list_for_each_entry(chan, &dev->channels, device_node) 249 if (chan->chan_id == dma_spec->args[0]) { 250 candidate = chan; 251 break; 252 } 253 254 if (!candidate) 255 return NULL; 256 257 return dma_get_slave_channel(candidate); 258 } 259 EXPORT_SYMBOL_GPL(of_dma_xlate_by_chan_id); 260