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 NULL on error. 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 156 if (!np || !name) { 157 pr_err("%s: not enough information provided\n", __func__); 158 return NULL; 159 } 160 161 count = of_property_count_strings(np, "dma-names"); 162 if (count < 0) { 163 pr_err("%s: dma-names property of node '%s' missing or empty\n", 164 __func__, np->full_name); 165 return NULL; 166 } 167 168 for (i = 0; i < count; i++) { 169 if (of_dma_match_channel(np, name, i, &dma_spec)) 170 continue; 171 172 mutex_lock(&of_dma_lock); 173 ofdma = of_dma_find_controller(&dma_spec); 174 175 if (ofdma) 176 chan = ofdma->of_dma_xlate(&dma_spec, ofdma); 177 else 178 chan = NULL; 179 180 mutex_unlock(&of_dma_lock); 181 182 of_node_put(dma_spec.np); 183 184 if (chan) 185 return chan; 186 } 187 188 return NULL; 189 } 190 191 /** 192 * of_dma_simple_xlate - Simple DMA engine translation function 193 * @dma_spec: pointer to DMA specifier as found in the device tree 194 * @of_dma: pointer to DMA controller data 195 * 196 * A simple translation function for devices that use a 32-bit value for the 197 * filter_param when calling the DMA engine dma_request_channel() function. 198 * Note that this translation function requires that #dma-cells is equal to 1 199 * and the argument of the dma specifier is the 32-bit filter_param. Returns 200 * pointer to appropriate dma channel on success or NULL on error. 201 */ 202 struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec, 203 struct of_dma *ofdma) 204 { 205 int count = dma_spec->args_count; 206 struct of_dma_filter_info *info = ofdma->of_dma_data; 207 208 if (!info || !info->filter_fn) 209 return NULL; 210 211 if (count != 1) 212 return NULL; 213 214 return dma_request_channel(info->dma_cap, info->filter_fn, 215 &dma_spec->args[0]); 216 } 217 EXPORT_SYMBOL_GPL(of_dma_simple_xlate); 218