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 count = of_property_count_strings(np, "dma-names"); 163 if (count < 0) { 164 pr_err("%s: dma-names property of node '%s' missing or empty\n", 165 __func__, np->full_name); 166 return ERR_PTR(-ENODEV); 167 } 168 169 for (i = 0; i < count; i++) { 170 if (of_dma_match_channel(np, name, i, &dma_spec)) 171 continue; 172 173 mutex_lock(&of_dma_lock); 174 ofdma = of_dma_find_controller(&dma_spec); 175 176 if (ofdma) { 177 chan = ofdma->of_dma_xlate(&dma_spec, ofdma); 178 } else { 179 ret_no_channel = -EPROBE_DEFER; 180 chan = NULL; 181 } 182 183 mutex_unlock(&of_dma_lock); 184 185 of_node_put(dma_spec.np); 186 187 if (chan) 188 return chan; 189 } 190 191 return ERR_PTR(ret_no_channel); 192 } 193 194 /** 195 * of_dma_simple_xlate - Simple DMA engine translation function 196 * @dma_spec: pointer to DMA specifier as found in the device tree 197 * @of_dma: pointer to DMA controller data 198 * 199 * A simple translation function for devices that use a 32-bit value for the 200 * filter_param when calling the DMA engine dma_request_channel() function. 201 * Note that this translation function requires that #dma-cells is equal to 1 202 * and the argument of the dma specifier is the 32-bit filter_param. Returns 203 * pointer to appropriate dma channel on success or NULL on error. 204 */ 205 struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec, 206 struct of_dma *ofdma) 207 { 208 int count = dma_spec->args_count; 209 struct of_dma_filter_info *info = ofdma->of_dma_data; 210 211 if (!info || !info->filter_fn) 212 return NULL; 213 214 if (count != 1) 215 return NULL; 216 217 return dma_request_channel(info->dma_cap, info->filter_fn, 218 &dma_spec->args[0]); 219 } 220 EXPORT_SYMBOL_GPL(of_dma_simple_xlate); 221 222 /** 223 * of_dma_xlate_by_chan_id - Translate dt property to DMA channel by channel id 224 * @dma_spec: pointer to DMA specifier as found in the device tree 225 * @of_dma: pointer to DMA controller data 226 * 227 * This function can be used as the of xlate callback for DMA driver which wants 228 * to match the channel based on the channel id. When using this xlate function 229 * the #dma-cells propety of the DMA controller dt node needs to be set to 1. 230 * The data parameter of of_dma_controller_register must be a pointer to the 231 * dma_device struct the function should match upon. 232 * 233 * Returns pointer to appropriate dma channel on success or NULL on error. 234 */ 235 struct dma_chan *of_dma_xlate_by_chan_id(struct of_phandle_args *dma_spec, 236 struct of_dma *ofdma) 237 { 238 struct dma_device *dev = ofdma->of_dma_data; 239 struct dma_chan *chan, *candidate = NULL; 240 241 if (!dev || dma_spec->args_count != 1) 242 return NULL; 243 244 list_for_each_entry(chan, &dev->channels, device_node) 245 if (chan->chan_id == dma_spec->args[0]) { 246 candidate = chan; 247 break; 248 } 249 250 if (!candidate) 251 return NULL; 252 253 return dma_get_slave_channel(candidate); 254 } 255 EXPORT_SYMBOL_GPL(of_dma_xlate_by_chan_id); 256