blob: bdbadaa47ef3ecb481b200785d4bc1aa9981f6e4 [file] [log] [blame]
Martyn Welcha17a75e2009-07-31 09:28:17 +01001/*
2 * VME Bridge Framework
3 *
Martyn Welch66bd8db2010-02-18 15:12:52 +00004 * Author: Martyn Welch <martyn.welch@ge.com>
5 * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
Martyn Welcha17a75e2009-07-31 09:28:17 +01006 *
7 * Based on work by Tom Armistead and Ajit Prem
8 * Copyright 2004 Motorola Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 */
15
Paul Gortmaker050c3d52016-07-03 14:05:56 -040016#include <linux/init.h>
17#include <linux/export.h>
Martyn Welcha17a75e2009-07-31 09:28:17 +010018#include <linux/mm.h>
19#include <linux/types.h>
20#include <linux/kernel.h>
21#include <linux/errno.h>
22#include <linux/pci.h>
23#include <linux/poll.h>
24#include <linux/highmem.h>
25#include <linux/interrupt.h>
26#include <linux/pagemap.h>
27#include <linux/device.h>
28#include <linux/dma-mapping.h>
29#include <linux/syscalls.h>
Martyn Welch400822f2009-08-11 16:20:22 +010030#include <linux/mutex.h>
Martyn Welcha17a75e2009-07-31 09:28:17 +010031#include <linux/spinlock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Greg Kroah-Hartmandb3b9e92012-04-26 12:34:58 -070033#include <linux/vme.h>
Martyn Welcha17a75e2009-07-31 09:28:17 +010034
Martyn Welcha17a75e2009-07-31 09:28:17 +010035#include "vme_bridge.h"
36
Manohar Vanga733e3ef2011-08-12 12:30:48 +020037/* Bitmask and list of registered buses both protected by common mutex */
Martyn Welcha17a75e2009-07-31 09:28:17 +010038static unsigned int vme_bus_numbers;
Manohar Vanga733e3ef2011-08-12 12:30:48 +020039static LIST_HEAD(vme_bus_list);
40static DEFINE_MUTEX(vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +010041
Martyn Welchead1f3e2009-12-15 08:43:02 +000042static int __init vme_init(void);
Martyn Welcha17a75e2009-07-31 09:28:17 +010043
Manohar Vanga8f966dc2011-09-26 11:27:15 +020044static struct vme_dev *dev_to_vme_dev(struct device *dev)
Martyn Welcha17a75e2009-07-31 09:28:17 +010045{
Manohar Vanga8f966dc2011-09-26 11:27:15 +020046 return container_of(dev, struct vme_dev, dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +010047}
48
49/*
50 * Find the bridge that the resource is associated with.
51 */
52static struct vme_bridge *find_bridge(struct vme_resource *resource)
53{
54 /* Get list to search */
55 switch (resource->type) {
56 case VME_MASTER:
57 return list_entry(resource->entry, struct vme_master_resource,
58 list)->parent;
59 break;
60 case VME_SLAVE:
61 return list_entry(resource->entry, struct vme_slave_resource,
62 list)->parent;
63 break;
64 case VME_DMA:
65 return list_entry(resource->entry, struct vme_dma_resource,
66 list)->parent;
67 break;
Martyn Welch42fb5032009-08-11 17:44:56 +010068 case VME_LM:
69 return list_entry(resource->entry, struct vme_lm_resource,
70 list)->parent;
71 break;
Martyn Welcha17a75e2009-07-31 09:28:17 +010072 default:
73 printk(KERN_ERR "Unknown resource type\n");
74 return NULL;
75 break;
76 }
77}
78
79/*
80 * Allocate a contiguous block of memory for use by the driver. This is used to
81 * create the buffers for the slave windows.
Martyn Welcha17a75e2009-07-31 09:28:17 +010082 */
Martyn Welchead1f3e2009-12-15 08:43:02 +000083void *vme_alloc_consistent(struct vme_resource *resource, size_t size,
Martyn Welcha17a75e2009-07-31 09:28:17 +010084 dma_addr_t *dma)
85{
86 struct vme_bridge *bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +010087
Martyn Welchead1f3e2009-12-15 08:43:02 +000088 if (resource == NULL) {
89 printk(KERN_ERR "No resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +010090 return NULL;
91 }
92
93 bridge = find_bridge(resource);
Martyn Welchead1f3e2009-12-15 08:43:02 +000094 if (bridge == NULL) {
95 printk(KERN_ERR "Can't find bridge\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +010096 return NULL;
97 }
98
Martyn Welcha17a75e2009-07-31 09:28:17 +010099 if (bridge->parent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700100 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100101 return NULL;
102 }
Martyn Welcha17a75e2009-07-31 09:28:17 +0100103
Manohar Vanga7f58f022011-08-10 11:33:46 +0200104 if (bridge->alloc_consistent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700105 printk(KERN_ERR "alloc_consistent not supported by bridge %s\n",
106 bridge->name);
Manohar Vanga7f58f022011-08-10 11:33:46 +0200107 return NULL;
108 }
109
110 return bridge->alloc_consistent(bridge->parent, size, dma);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100111}
112EXPORT_SYMBOL(vme_alloc_consistent);
113
114/*
115 * Free previously allocated contiguous block of memory.
Martyn Welcha17a75e2009-07-31 09:28:17 +0100116 */
117void vme_free_consistent(struct vme_resource *resource, size_t size,
118 void *vaddr, dma_addr_t dma)
119{
120 struct vme_bridge *bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100121
Martyn Welchead1f3e2009-12-15 08:43:02 +0000122 if (resource == NULL) {
123 printk(KERN_ERR "No resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100124 return;
125 }
126
127 bridge = find_bridge(resource);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000128 if (bridge == NULL) {
129 printk(KERN_ERR "Can't find bridge\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100130 return;
131 }
132
Manohar Vanga7f58f022011-08-10 11:33:46 +0200133 if (bridge->parent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700134 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
Manohar Vanga7f58f022011-08-10 11:33:46 +0200135 return;
136 }
Martyn Welcha17a75e2009-07-31 09:28:17 +0100137
Manohar Vanga7f58f022011-08-10 11:33:46 +0200138 if (bridge->free_consistent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700139 printk(KERN_ERR "free_consistent not supported by bridge %s\n",
140 bridge->name);
Manohar Vanga7f58f022011-08-10 11:33:46 +0200141 return;
142 }
143
144 bridge->free_consistent(bridge->parent, size, vaddr, dma);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100145}
146EXPORT_SYMBOL(vme_free_consistent);
147
148size_t vme_get_size(struct vme_resource *resource)
149{
150 int enabled, retval;
151 unsigned long long base, size;
152 dma_addr_t buf_base;
Martyn Welch6af04b02011-12-01 17:06:29 +0000153 u32 aspace, cycle, dwidth;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100154
155 switch (resource->type) {
156 case VME_MASTER:
157 retval = vme_master_get(resource, &enabled, &base, &size,
158 &aspace, &cycle, &dwidth);
Martyn Welch6ad37562016-10-21 17:36:19 +0100159 if (retval)
160 return 0;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100161
162 return size;
163 break;
164 case VME_SLAVE:
165 retval = vme_slave_get(resource, &enabled, &base, &size,
166 &buf_base, &aspace, &cycle);
Martyn Welch6ad37562016-10-21 17:36:19 +0100167 if (retval)
168 return 0;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100169
170 return size;
171 break;
172 case VME_DMA:
173 return 0;
174 break;
175 default:
176 printk(KERN_ERR "Unknown resource type\n");
177 return 0;
178 break;
179 }
180}
181EXPORT_SYMBOL(vme_get_size);
182
Dmitry Kalinkinef73f882015-05-28 15:07:04 +0300183int vme_check_window(u32 aspace, unsigned long long vme_base,
184 unsigned long long size)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100185{
186 int retval = 0;
187
188 switch (aspace) {
189 case VME_A16:
190 if (((vme_base + size) > VME_A16_MAX) ||
191 (vme_base > VME_A16_MAX))
192 retval = -EFAULT;
193 break;
194 case VME_A24:
195 if (((vme_base + size) > VME_A24_MAX) ||
196 (vme_base > VME_A24_MAX))
197 retval = -EFAULT;
198 break;
199 case VME_A32:
200 if (((vme_base + size) > VME_A32_MAX) ||
201 (vme_base > VME_A32_MAX))
202 retval = -EFAULT;
203 break;
204 case VME_A64:
Dmitry Kalinkine7fd80c2015-05-28 15:07:03 +0300205 if ((size != 0) && (vme_base > U64_MAX + 1 - size))
206 retval = -EFAULT;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100207 break;
208 case VME_CRCSR:
209 if (((vme_base + size) > VME_CRCSR_MAX) ||
210 (vme_base > VME_CRCSR_MAX))
211 retval = -EFAULT;
212 break;
213 case VME_USER1:
214 case VME_USER2:
215 case VME_USER3:
216 case VME_USER4:
217 /* User Defined */
218 break;
219 default:
Martyn Welchead1f3e2009-12-15 08:43:02 +0000220 printk(KERN_ERR "Invalid address space\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100221 retval = -EINVAL;
222 break;
223 }
224
225 return retval;
226}
Dmitry Kalinkinef73f882015-05-28 15:07:04 +0300227EXPORT_SYMBOL(vme_check_window);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100228
Dmitry Kalinkin472f16f2015-09-18 02:01:43 +0300229static u32 vme_get_aspace(int am)
230{
231 switch (am) {
232 case 0x29:
233 case 0x2D:
234 return VME_A16;
235 case 0x38:
236 case 0x39:
237 case 0x3A:
238 case 0x3B:
239 case 0x3C:
240 case 0x3D:
241 case 0x3E:
242 case 0x3F:
243 return VME_A24;
244 case 0x8:
245 case 0x9:
246 case 0xA:
247 case 0xB:
248 case 0xC:
249 case 0xD:
250 case 0xE:
251 case 0xF:
252 return VME_A32;
253 case 0x0:
254 case 0x1:
255 case 0x3:
256 return VME_A64;
257 }
258
259 return 0;
260}
261
Martyn Welcha17a75e2009-07-31 09:28:17 +0100262/*
263 * Request a slave image with specific attributes, return some unique
264 * identifier.
265 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000266struct vme_resource *vme_slave_request(struct vme_dev *vdev, u32 address,
267 u32 cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100268{
269 struct vme_bridge *bridge;
270 struct list_head *slave_pos = NULL;
271 struct vme_slave_resource *allocated_image = NULL;
272 struct vme_slave_resource *slave_image = NULL;
273 struct vme_resource *resource = NULL;
274
Manohar Vanga8f966dc2011-09-26 11:27:15 +0200275 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100276 if (bridge == NULL) {
277 printk(KERN_ERR "Can't find VME bus\n");
278 goto err_bus;
279 }
280
281 /* Loop through slave resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000282 list_for_each(slave_pos, &bridge->slave_resources) {
Martyn Welcha17a75e2009-07-31 09:28:17 +0100283 slave_image = list_entry(slave_pos,
284 struct vme_slave_resource, list);
285
286 if (slave_image == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000287 printk(KERN_ERR "Registered NULL Slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100288 continue;
289 }
290
291 /* Find an unlocked and compatible image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000292 mutex_lock(&slave_image->mtx);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000293 if (((slave_image->address_attr & address) == address) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100294 ((slave_image->cycle_attr & cycle) == cycle) &&
295 (slave_image->locked == 0)) {
296
297 slave_image->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000298 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100299 allocated_image = slave_image;
300 break;
301 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000302 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100303 }
304
305 /* No free image */
306 if (allocated_image == NULL)
307 goto err_image;
308
309 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
310 if (resource == NULL) {
311 printk(KERN_WARNING "Unable to allocate resource structure\n");
312 goto err_alloc;
313 }
314 resource->type = VME_SLAVE;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000315 resource->entry = &allocated_image->list;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100316
317 return resource;
318
319err_alloc:
320 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000321 mutex_lock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100322 slave_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000323 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100324err_image:
325err_bus:
326 return NULL;
327}
328EXPORT_SYMBOL(vme_slave_request);
329
Martyn Welchead1f3e2009-12-15 08:43:02 +0000330int vme_slave_set(struct vme_resource *resource, int enabled,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100331 unsigned long long vme_base, unsigned long long size,
Martyn Welch6af04b02011-12-01 17:06:29 +0000332 dma_addr_t buf_base, u32 aspace, u32 cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100333{
334 struct vme_bridge *bridge = find_bridge(resource);
335 struct vme_slave_resource *image;
336 int retval;
337
338 if (resource->type != VME_SLAVE) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000339 printk(KERN_ERR "Not a slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100340 return -EINVAL;
341 }
342
343 image = list_entry(resource->entry, struct vme_slave_resource, list);
344
345 if (bridge->slave_set == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000346 printk(KERN_ERR "Function not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100347 return -ENOSYS;
348 }
349
Martyn Welchead1f3e2009-12-15 08:43:02 +0000350 if (!(((image->address_attr & aspace) == aspace) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100351 ((image->cycle_attr & cycle) == cycle))) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000352 printk(KERN_ERR "Invalid attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100353 return -EINVAL;
354 }
355
356 retval = vme_check_window(aspace, vme_base, size);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000357 if (retval)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100358 return retval;
359
360 return bridge->slave_set(image, enabled, vme_base, size, buf_base,
361 aspace, cycle);
362}
363EXPORT_SYMBOL(vme_slave_set);
364
Martyn Welchead1f3e2009-12-15 08:43:02 +0000365int vme_slave_get(struct vme_resource *resource, int *enabled,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100366 unsigned long long *vme_base, unsigned long long *size,
Martyn Welch6af04b02011-12-01 17:06:29 +0000367 dma_addr_t *buf_base, u32 *aspace, u32 *cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100368{
369 struct vme_bridge *bridge = find_bridge(resource);
370 struct vme_slave_resource *image;
371
372 if (resource->type != VME_SLAVE) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000373 printk(KERN_ERR "Not a slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100374 return -EINVAL;
375 }
376
377 image = list_entry(resource->entry, struct vme_slave_resource, list);
378
Emilio G. Cota51a569f2009-08-10 16:52:42 +0200379 if (bridge->slave_get == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000380 printk(KERN_ERR "vme_slave_get not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100381 return -EINVAL;
382 }
383
384 return bridge->slave_get(image, enabled, vme_base, size, buf_base,
385 aspace, cycle);
386}
387EXPORT_SYMBOL(vme_slave_get);
388
389void vme_slave_free(struct vme_resource *resource)
390{
391 struct vme_slave_resource *slave_image;
392
393 if (resource->type != VME_SLAVE) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000394 printk(KERN_ERR "Not a slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100395 return;
396 }
397
398 slave_image = list_entry(resource->entry, struct vme_slave_resource,
399 list);
400 if (slave_image == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000401 printk(KERN_ERR "Can't find slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100402 return;
403 }
404
405 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000406 mutex_lock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100407 if (slave_image->locked == 0)
408 printk(KERN_ERR "Image is already free\n");
409
410 slave_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000411 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100412
413 /* Free up resource memory */
414 kfree(resource);
415}
416EXPORT_SYMBOL(vme_slave_free);
417
418/*
419 * Request a master image with specific attributes, return some unique
420 * identifier.
421 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000422struct vme_resource *vme_master_request(struct vme_dev *vdev, u32 address,
423 u32 cycle, u32 dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100424{
425 struct vme_bridge *bridge;
426 struct list_head *master_pos = NULL;
427 struct vme_master_resource *allocated_image = NULL;
428 struct vme_master_resource *master_image = NULL;
429 struct vme_resource *resource = NULL;
430
Manohar Vanga8f966dc2011-09-26 11:27:15 +0200431 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100432 if (bridge == NULL) {
433 printk(KERN_ERR "Can't find VME bus\n");
434 goto err_bus;
435 }
436
437 /* Loop through master resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000438 list_for_each(master_pos, &bridge->master_resources) {
Martyn Welcha17a75e2009-07-31 09:28:17 +0100439 master_image = list_entry(master_pos,
440 struct vme_master_resource, list);
441
442 if (master_image == NULL) {
443 printk(KERN_WARNING "Registered NULL master resource\n");
444 continue;
445 }
446
447 /* Find an unlocked and compatible image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000448 spin_lock(&master_image->lock);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000449 if (((master_image->address_attr & address) == address) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100450 ((master_image->cycle_attr & cycle) == cycle) &&
451 ((master_image->width_attr & dwidth) == dwidth) &&
452 (master_image->locked == 0)) {
453
454 master_image->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000455 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100456 allocated_image = master_image;
457 break;
458 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000459 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100460 }
461
462 /* Check to see if we found a resource */
463 if (allocated_image == NULL) {
464 printk(KERN_ERR "Can't find a suitable resource\n");
465 goto err_image;
466 }
467
468 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
469 if (resource == NULL) {
470 printk(KERN_ERR "Unable to allocate resource structure\n");
471 goto err_alloc;
472 }
473 resource->type = VME_MASTER;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000474 resource->entry = &allocated_image->list;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100475
476 return resource;
477
Martyn Welcha17a75e2009-07-31 09:28:17 +0100478err_alloc:
479 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000480 spin_lock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100481 master_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000482 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100483err_image:
484err_bus:
485 return NULL;
486}
487EXPORT_SYMBOL(vme_master_request);
488
Martyn Welchead1f3e2009-12-15 08:43:02 +0000489int vme_master_set(struct vme_resource *resource, int enabled,
Martyn Welch6af04b02011-12-01 17:06:29 +0000490 unsigned long long vme_base, unsigned long long size, u32 aspace,
491 u32 cycle, u32 dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100492{
493 struct vme_bridge *bridge = find_bridge(resource);
494 struct vme_master_resource *image;
495 int retval;
496
497 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000498 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100499 return -EINVAL;
500 }
501
502 image = list_entry(resource->entry, struct vme_master_resource, list);
503
504 if (bridge->master_set == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000505 printk(KERN_WARNING "vme_master_set not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100506 return -EINVAL;
507 }
508
Martyn Welchead1f3e2009-12-15 08:43:02 +0000509 if (!(((image->address_attr & aspace) == aspace) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100510 ((image->cycle_attr & cycle) == cycle) &&
511 ((image->width_attr & dwidth) == dwidth))) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000512 printk(KERN_WARNING "Invalid attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100513 return -EINVAL;
514 }
515
516 retval = vme_check_window(aspace, vme_base, size);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000517 if (retval)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100518 return retval;
519
520 return bridge->master_set(image, enabled, vme_base, size, aspace,
521 cycle, dwidth);
522}
523EXPORT_SYMBOL(vme_master_set);
524
Martyn Welchead1f3e2009-12-15 08:43:02 +0000525int vme_master_get(struct vme_resource *resource, int *enabled,
Martyn Welch6af04b02011-12-01 17:06:29 +0000526 unsigned long long *vme_base, unsigned long long *size, u32 *aspace,
527 u32 *cycle, u32 *dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100528{
529 struct vme_bridge *bridge = find_bridge(resource);
530 struct vme_master_resource *image;
531
532 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000533 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100534 return -EINVAL;
535 }
536
537 image = list_entry(resource->entry, struct vme_master_resource, list);
538
Emilio G. Cota51a569f2009-08-10 16:52:42 +0200539 if (bridge->master_get == NULL) {
Julia Lawallc1038302014-12-07 20:20:53 +0100540 printk(KERN_WARNING "%s not supported\n", __func__);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100541 return -EINVAL;
542 }
543
544 return bridge->master_get(image, enabled, vme_base, size, aspace,
545 cycle, dwidth);
546}
547EXPORT_SYMBOL(vme_master_get);
548
549/*
550 * Read data out of VME space into a buffer.
551 */
Martyn Welchead1f3e2009-12-15 08:43:02 +0000552ssize_t vme_master_read(struct vme_resource *resource, void *buf, size_t count,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100553 loff_t offset)
554{
555 struct vme_bridge *bridge = find_bridge(resource);
556 struct vme_master_resource *image;
557 size_t length;
558
559 if (bridge->master_read == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000560 printk(KERN_WARNING "Reading from resource not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100561 return -EINVAL;
562 }
563
564 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000565 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100566 return -EINVAL;
567 }
568
569 image = list_entry(resource->entry, struct vme_master_resource, list);
570
571 length = vme_get_size(resource);
572
573 if (offset > length) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000574 printk(KERN_WARNING "Invalid Offset\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100575 return -EFAULT;
576 }
577
578 if ((offset + count) > length)
579 count = length - offset;
580
581 return bridge->master_read(image, buf, count, offset);
582
583}
584EXPORT_SYMBOL(vme_master_read);
585
586/*
587 * Write data out to VME space from a buffer.
588 */
Martyn Welchead1f3e2009-12-15 08:43:02 +0000589ssize_t vme_master_write(struct vme_resource *resource, void *buf,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100590 size_t count, loff_t offset)
591{
592 struct vme_bridge *bridge = find_bridge(resource);
593 struct vme_master_resource *image;
594 size_t length;
595
596 if (bridge->master_write == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000597 printk(KERN_WARNING "Writing to resource not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100598 return -EINVAL;
599 }
600
601 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000602 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100603 return -EINVAL;
604 }
605
606 image = list_entry(resource->entry, struct vme_master_resource, list);
607
608 length = vme_get_size(resource);
609
610 if (offset > length) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000611 printk(KERN_WARNING "Invalid Offset\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100612 return -EFAULT;
613 }
614
615 if ((offset + count) > length)
616 count = length - offset;
617
618 return bridge->master_write(image, buf, count, offset);
619}
620EXPORT_SYMBOL(vme_master_write);
621
622/*
623 * Perform RMW cycle to provided location.
624 */
Martyn Welchead1f3e2009-12-15 08:43:02 +0000625unsigned int vme_master_rmw(struct vme_resource *resource, unsigned int mask,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100626 unsigned int compare, unsigned int swap, loff_t offset)
627{
628 struct vme_bridge *bridge = find_bridge(resource);
629 struct vme_master_resource *image;
630
631 if (bridge->master_rmw == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000632 printk(KERN_WARNING "Writing to resource not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100633 return -EINVAL;
634 }
635
636 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000637 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100638 return -EINVAL;
639 }
640
641 image = list_entry(resource->entry, struct vme_master_resource, list);
642
643 return bridge->master_rmw(image, mask, compare, swap, offset);
644}
645EXPORT_SYMBOL(vme_master_rmw);
646
Dmitry Kalinkinc74a8042015-02-26 18:53:10 +0300647int vme_master_mmap(struct vme_resource *resource, struct vm_area_struct *vma)
648{
649 struct vme_master_resource *image;
650 phys_addr_t phys_addr;
651 unsigned long vma_size;
652
653 if (resource->type != VME_MASTER) {
654 pr_err("Not a master resource\n");
655 return -EINVAL;
656 }
657
658 image = list_entry(resource->entry, struct vme_master_resource, list);
659 phys_addr = image->bus_resource.start + (vma->vm_pgoff << PAGE_SHIFT);
660 vma_size = vma->vm_end - vma->vm_start;
661
662 if (phys_addr + vma_size > image->bus_resource.end + 1) {
663 pr_err("Map size cannot exceed the window size\n");
664 return -EFAULT;
665 }
666
667 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
668
669 return vm_iomap_memory(vma, phys_addr, vma->vm_end - vma->vm_start);
670}
671EXPORT_SYMBOL(vme_master_mmap);
672
Martyn Welcha17a75e2009-07-31 09:28:17 +0100673void vme_master_free(struct vme_resource *resource)
674{
675 struct vme_master_resource *master_image;
676
677 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000678 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100679 return;
680 }
681
682 master_image = list_entry(resource->entry, struct vme_master_resource,
683 list);
684 if (master_image == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000685 printk(KERN_ERR "Can't find master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100686 return;
687 }
688
689 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000690 spin_lock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100691 if (master_image->locked == 0)
692 printk(KERN_ERR "Image is already free\n");
693
694 master_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000695 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100696
697 /* Free up resource memory */
698 kfree(resource);
699}
700EXPORT_SYMBOL(vme_master_free);
701
702/*
703 * Request a DMA controller with specific attributes, return some unique
704 * identifier.
705 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000706struct vme_resource *vme_dma_request(struct vme_dev *vdev, u32 route)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100707{
708 struct vme_bridge *bridge;
709 struct list_head *dma_pos = NULL;
710 struct vme_dma_resource *allocated_ctrlr = NULL;
711 struct vme_dma_resource *dma_ctrlr = NULL;
712 struct vme_resource *resource = NULL;
713
714 /* XXX Not checking resource attributes */
715 printk(KERN_ERR "No VME resource Attribute tests done\n");
716
Manohar Vanga8f966dc2011-09-26 11:27:15 +0200717 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100718 if (bridge == NULL) {
719 printk(KERN_ERR "Can't find VME bus\n");
720 goto err_bus;
721 }
722
723 /* Loop through DMA resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000724 list_for_each(dma_pos, &bridge->dma_resources) {
Martyn Welcha17a75e2009-07-31 09:28:17 +0100725 dma_ctrlr = list_entry(dma_pos,
726 struct vme_dma_resource, list);
727
728 if (dma_ctrlr == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000729 printk(KERN_ERR "Registered NULL DMA resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100730 continue;
731 }
732
Martyn Welch4f723df2010-02-18 15:12:58 +0000733 /* Find an unlocked and compatible controller */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000734 mutex_lock(&dma_ctrlr->mtx);
Martyn Welch4f723df2010-02-18 15:12:58 +0000735 if (((dma_ctrlr->route_attr & route) == route) &&
736 (dma_ctrlr->locked == 0)) {
737
Martyn Welcha17a75e2009-07-31 09:28:17 +0100738 dma_ctrlr->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000739 mutex_unlock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100740 allocated_ctrlr = dma_ctrlr;
741 break;
742 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000743 mutex_unlock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100744 }
745
746 /* Check to see if we found a resource */
747 if (allocated_ctrlr == NULL)
748 goto err_ctrlr;
749
750 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
751 if (resource == NULL) {
752 printk(KERN_WARNING "Unable to allocate resource structure\n");
753 goto err_alloc;
754 }
755 resource->type = VME_DMA;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000756 resource->entry = &allocated_ctrlr->list;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100757
758 return resource;
759
760err_alloc:
761 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000762 mutex_lock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100763 dma_ctrlr->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000764 mutex_unlock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100765err_ctrlr:
766err_bus:
767 return NULL;
768}
Martyn Welch58e50792009-10-29 16:35:20 +0000769EXPORT_SYMBOL(vme_dma_request);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100770
771/*
772 * Start new list
773 */
774struct vme_dma_list *vme_new_dma_list(struct vme_resource *resource)
775{
776 struct vme_dma_resource *ctrlr;
777 struct vme_dma_list *dma_list;
778
779 if (resource->type != VME_DMA) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000780 printk(KERN_ERR "Not a DMA resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100781 return NULL;
782 }
783
784 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list);
785
Martyn Welchead1f3e2009-12-15 08:43:02 +0000786 dma_list = kmalloc(sizeof(struct vme_dma_list), GFP_KERNEL);
787 if (dma_list == NULL) {
Aaron Sierraf56c3d42016-04-21 11:18:22 -0500788 printk(KERN_ERR "Unable to allocate memory for new DMA list\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100789 return NULL;
790 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000791 INIT_LIST_HEAD(&dma_list->entries);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100792 dma_list->parent = ctrlr;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000793 mutex_init(&dma_list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100794
795 return dma_list;
796}
797EXPORT_SYMBOL(vme_new_dma_list);
798
799/*
800 * Create "Pattern" type attributes
801 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000802struct vme_dma_attr *vme_dma_pattern_attribute(u32 pattern, u32 type)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100803{
804 struct vme_dma_attr *attributes;
805 struct vme_dma_pattern *pattern_attr;
806
Martyn Welchead1f3e2009-12-15 08:43:02 +0000807 attributes = kmalloc(sizeof(struct vme_dma_attr), GFP_KERNEL);
808 if (attributes == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700809 printk(KERN_ERR "Unable to allocate memory for attributes structure\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100810 goto err_attr;
811 }
812
Martyn Welchead1f3e2009-12-15 08:43:02 +0000813 pattern_attr = kmalloc(sizeof(struct vme_dma_pattern), GFP_KERNEL);
814 if (pattern_attr == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700815 printk(KERN_ERR "Unable to allocate memory for pattern attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100816 goto err_pat;
817 }
818
819 attributes->type = VME_DMA_PATTERN;
820 attributes->private = (void *)pattern_attr;
821
822 pattern_attr->pattern = pattern;
823 pattern_attr->type = type;
824
825 return attributes;
826
Martyn Welcha17a75e2009-07-31 09:28:17 +0100827err_pat:
828 kfree(attributes);
829err_attr:
830 return NULL;
831}
832EXPORT_SYMBOL(vme_dma_pattern_attribute);
833
834/*
835 * Create "PCI" type attributes
836 */
837struct vme_dma_attr *vme_dma_pci_attribute(dma_addr_t address)
838{
839 struct vme_dma_attr *attributes;
840 struct vme_dma_pci *pci_attr;
841
842 /* XXX Run some sanity checks here */
843
Martyn Welchead1f3e2009-12-15 08:43:02 +0000844 attributes = kmalloc(sizeof(struct vme_dma_attr), GFP_KERNEL);
845 if (attributes == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700846 printk(KERN_ERR "Unable to allocate memory for attributes structure\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100847 goto err_attr;
848 }
849
Martyn Welchead1f3e2009-12-15 08:43:02 +0000850 pci_attr = kmalloc(sizeof(struct vme_dma_pci), GFP_KERNEL);
851 if (pci_attr == NULL) {
Aaron Sierraf56c3d42016-04-21 11:18:22 -0500852 printk(KERN_ERR "Unable to allocate memory for PCI attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100853 goto err_pci;
854 }
855
856
857
858 attributes->type = VME_DMA_PCI;
859 attributes->private = (void *)pci_attr;
860
861 pci_attr->address = address;
862
863 return attributes;
864
Martyn Welcha17a75e2009-07-31 09:28:17 +0100865err_pci:
866 kfree(attributes);
867err_attr:
868 return NULL;
869}
870EXPORT_SYMBOL(vme_dma_pci_attribute);
871
872/*
873 * Create "VME" type attributes
874 */
875struct vme_dma_attr *vme_dma_vme_attribute(unsigned long long address,
Martyn Welch6af04b02011-12-01 17:06:29 +0000876 u32 aspace, u32 cycle, u32 dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100877{
878 struct vme_dma_attr *attributes;
879 struct vme_dma_vme *vme_attr;
880
Martyn Welchead1f3e2009-12-15 08:43:02 +0000881 attributes = kmalloc(
Martyn Welcha17a75e2009-07-31 09:28:17 +0100882 sizeof(struct vme_dma_attr), GFP_KERNEL);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000883 if (attributes == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700884 printk(KERN_ERR "Unable to allocate memory for attributes structure\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100885 goto err_attr;
886 }
887
Martyn Welchead1f3e2009-12-15 08:43:02 +0000888 vme_attr = kmalloc(sizeof(struct vme_dma_vme), GFP_KERNEL);
889 if (vme_attr == NULL) {
Aaron Sierraf56c3d42016-04-21 11:18:22 -0500890 printk(KERN_ERR "Unable to allocate memory for VME attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100891 goto err_vme;
892 }
893
894 attributes->type = VME_DMA_VME;
895 attributes->private = (void *)vme_attr;
896
897 vme_attr->address = address;
898 vme_attr->aspace = aspace;
899 vme_attr->cycle = cycle;
900 vme_attr->dwidth = dwidth;
901
902 return attributes;
903
Martyn Welcha17a75e2009-07-31 09:28:17 +0100904err_vme:
905 kfree(attributes);
906err_attr:
907 return NULL;
908}
909EXPORT_SYMBOL(vme_dma_vme_attribute);
910
911/*
912 * Free attribute
913 */
914void vme_dma_free_attribute(struct vme_dma_attr *attributes)
915{
916 kfree(attributes->private);
917 kfree(attributes);
918}
919EXPORT_SYMBOL(vme_dma_free_attribute);
920
921int vme_dma_list_add(struct vme_dma_list *list, struct vme_dma_attr *src,
922 struct vme_dma_attr *dest, size_t count)
923{
924 struct vme_bridge *bridge = list->parent->parent;
925 int retval;
926
927 if (bridge->dma_list_add == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000928 printk(KERN_WARNING "Link List DMA generation not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100929 return -EINVAL;
930 }
931
Emilio G. Cota886953e2010-11-12 11:14:07 +0000932 if (!mutex_trylock(&list->mtx)) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000933 printk(KERN_ERR "Link List already submitted\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100934 return -EINVAL;
935 }
936
937 retval = bridge->dma_list_add(list, src, dest, count);
938
Emilio G. Cota886953e2010-11-12 11:14:07 +0000939 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100940
941 return retval;
942}
943EXPORT_SYMBOL(vme_dma_list_add);
944
945int vme_dma_list_exec(struct vme_dma_list *list)
946{
947 struct vme_bridge *bridge = list->parent->parent;
948 int retval;
949
950 if (bridge->dma_list_exec == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000951 printk(KERN_ERR "Link List DMA execution not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100952 return -EINVAL;
953 }
954
Emilio G. Cota886953e2010-11-12 11:14:07 +0000955 mutex_lock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100956
957 retval = bridge->dma_list_exec(list);
958
Emilio G. Cota886953e2010-11-12 11:14:07 +0000959 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100960
961 return retval;
962}
963EXPORT_SYMBOL(vme_dma_list_exec);
964
965int vme_dma_list_free(struct vme_dma_list *list)
966{
967 struct vme_bridge *bridge = list->parent->parent;
968 int retval;
969
970 if (bridge->dma_list_empty == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000971 printk(KERN_WARNING "Emptying of Link Lists not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100972 return -EINVAL;
973 }
974
Emilio G. Cota886953e2010-11-12 11:14:07 +0000975 if (!mutex_trylock(&list->mtx)) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000976 printk(KERN_ERR "Link List in use\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100977 return -EINVAL;
978 }
979
980 /*
Aaron Sierraf56c3d42016-04-21 11:18:22 -0500981 * Empty out all of the entries from the DMA list. We need to go to the
982 * low level driver as DMA entries are driver specific.
Martyn Welcha17a75e2009-07-31 09:28:17 +0100983 */
984 retval = bridge->dma_list_empty(list);
985 if (retval) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000986 printk(KERN_ERR "Unable to empty link-list entries\n");
Emilio G. Cota886953e2010-11-12 11:14:07 +0000987 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100988 return retval;
989 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000990 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100991 kfree(list);
992
993 return retval;
994}
995EXPORT_SYMBOL(vme_dma_list_free);
996
997int vme_dma_free(struct vme_resource *resource)
998{
999 struct vme_dma_resource *ctrlr;
1000
1001 if (resource->type != VME_DMA) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001002 printk(KERN_ERR "Not a DMA resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001003 return -EINVAL;
1004 }
1005
1006 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list);
1007
Emilio G. Cota886953e2010-11-12 11:14:07 +00001008 if (!mutex_trylock(&ctrlr->mtx)) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001009 printk(KERN_ERR "Resource busy, can't free\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001010 return -EBUSY;
1011 }
1012
Emilio G. Cota886953e2010-11-12 11:14:07 +00001013 if (!(list_empty(&ctrlr->pending) && list_empty(&ctrlr->running))) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001014 printk(KERN_WARNING "Resource still processing transfers\n");
Emilio G. Cota886953e2010-11-12 11:14:07 +00001015 mutex_unlock(&ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001016 return -EBUSY;
1017 }
1018
1019 ctrlr->locked = 0;
1020
Emilio G. Cota886953e2010-11-12 11:14:07 +00001021 mutex_unlock(&ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001022
Martyn Welchfd5c2562013-06-06 12:29:16 +01001023 kfree(resource);
1024
Martyn Welcha17a75e2009-07-31 09:28:17 +01001025 return 0;
1026}
1027EXPORT_SYMBOL(vme_dma_free);
1028
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001029void vme_bus_error_handler(struct vme_bridge *bridge,
Dmitry Kalinkin472f16f2015-09-18 02:01:43 +03001030 unsigned long long address, int am)
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001031{
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001032 struct list_head *handler_pos = NULL;
1033 struct vme_error_handler *handler;
Dmitry Kalinkin448535a2015-09-18 02:01:45 +03001034 int handler_triggered = 0;
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001035 u32 aspace = vme_get_aspace(am);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001036
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001037 list_for_each(handler_pos, &bridge->vme_error_handlers) {
1038 handler = list_entry(handler_pos, struct vme_error_handler,
1039 list);
1040 if ((aspace == handler->aspace) &&
1041 (address >= handler->start) &&
1042 (address < handler->end)) {
1043 if (!handler->num_errors)
1044 handler->first_error = address;
1045 if (handler->num_errors != UINT_MAX)
1046 handler->num_errors++;
Dmitry Kalinkin448535a2015-09-18 02:01:45 +03001047 handler_triggered = 1;
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001048 }
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001049 }
Dmitry Kalinkin448535a2015-09-18 02:01:45 +03001050
1051 if (!handler_triggered)
1052 dev_err(bridge->parent,
1053 "Unhandled VME access error at address 0x%llx\n",
1054 address);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001055}
1056EXPORT_SYMBOL(vme_bus_error_handler);
1057
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001058struct vme_error_handler *vme_register_error_handler(
1059 struct vme_bridge *bridge, u32 aspace,
1060 unsigned long long address, size_t len)
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001061{
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001062 struct vme_error_handler *handler;
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001063
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001064 handler = kmalloc(sizeof(*handler), GFP_KERNEL);
1065 if (!handler)
1066 return NULL;
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001067
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001068 handler->aspace = aspace;
1069 handler->start = address;
1070 handler->end = address + len;
1071 handler->num_errors = 0;
1072 handler->first_error = 0;
1073 list_add_tail(&handler->list, &bridge->vme_error_handlers);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001074
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001075 return handler;
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001076}
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001077EXPORT_SYMBOL(vme_register_error_handler);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001078
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001079void vme_unregister_error_handler(struct vme_error_handler *handler)
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001080{
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001081 list_del(&handler->list);
1082 kfree(handler);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001083}
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001084EXPORT_SYMBOL(vme_unregister_error_handler);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001085
Martyn Welchc813f592009-10-29 16:34:54 +00001086void vme_irq_handler(struct vme_bridge *bridge, int level, int statid)
1087{
1088 void (*call)(int, int, void *);
1089 void *priv_data;
1090
1091 call = bridge->irq[level - 1].callback[statid].func;
1092 priv_data = bridge->irq[level - 1].callback[statid].priv_data;
1093
1094 if (call != NULL)
1095 call(level, statid, priv_data);
1096 else
Aaron Sierraf56c3d42016-04-21 11:18:22 -05001097 printk(KERN_WARNING "Spurious VME interrupt, level:%x, vector:%x\n",
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -07001098 level, statid);
Martyn Welchc813f592009-10-29 16:34:54 +00001099}
1100EXPORT_SYMBOL(vme_irq_handler);
1101
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001102int vme_irq_request(struct vme_dev *vdev, int level, int statid,
Martyn Welch29848ac2010-02-18 15:13:05 +00001103 void (*callback)(int, int, void *),
Martyn Welcha17a75e2009-07-31 09:28:17 +01001104 void *priv_data)
1105{
1106 struct vme_bridge *bridge;
1107
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001108 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001109 if (bridge == NULL) {
1110 printk(KERN_ERR "Can't find VME bus\n");
1111 return -EINVAL;
1112 }
1113
Martyn Welchead1f3e2009-12-15 08:43:02 +00001114 if ((level < 1) || (level > 7)) {
Martyn Welchc813f592009-10-29 16:34:54 +00001115 printk(KERN_ERR "Invalid interrupt level\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001116 return -EINVAL;
1117 }
1118
Martyn Welchc813f592009-10-29 16:34:54 +00001119 if (bridge->irq_set == NULL) {
1120 printk(KERN_ERR "Configuring interrupts not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001121 return -EINVAL;
1122 }
1123
Emilio G. Cota886953e2010-11-12 11:14:07 +00001124 mutex_lock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001125
1126 if (bridge->irq[level - 1].callback[statid].func) {
Emilio G. Cota886953e2010-11-12 11:14:07 +00001127 mutex_unlock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001128 printk(KERN_WARNING "VME Interrupt already taken\n");
1129 return -EBUSY;
1130 }
1131
1132 bridge->irq[level - 1].count++;
1133 bridge->irq[level - 1].callback[statid].priv_data = priv_data;
1134 bridge->irq[level - 1].callback[statid].func = callback;
1135
1136 /* Enable IRQ level */
Martyn Welch29848ac2010-02-18 15:13:05 +00001137 bridge->irq_set(bridge, level, 1, 1);
Martyn Welchc813f592009-10-29 16:34:54 +00001138
Emilio G. Cota886953e2010-11-12 11:14:07 +00001139 mutex_unlock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001140
1141 return 0;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001142}
Martyn Welchc813f592009-10-29 16:34:54 +00001143EXPORT_SYMBOL(vme_irq_request);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001144
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001145void vme_irq_free(struct vme_dev *vdev, int level, int statid)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001146{
1147 struct vme_bridge *bridge;
1148
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001149 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001150 if (bridge == NULL) {
1151 printk(KERN_ERR "Can't find VME bus\n");
1152 return;
1153 }
1154
Martyn Welchead1f3e2009-12-15 08:43:02 +00001155 if ((level < 1) || (level > 7)) {
Martyn Welchc813f592009-10-29 16:34:54 +00001156 printk(KERN_ERR "Invalid interrupt level\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001157 return;
1158 }
1159
Martyn Welchc813f592009-10-29 16:34:54 +00001160 if (bridge->irq_set == NULL) {
1161 printk(KERN_ERR "Configuring interrupts not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001162 return;
1163 }
1164
Emilio G. Cota886953e2010-11-12 11:14:07 +00001165 mutex_lock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001166
1167 bridge->irq[level - 1].count--;
1168
1169 /* Disable IRQ level if no more interrupts attached at this level*/
1170 if (bridge->irq[level - 1].count == 0)
Martyn Welch29848ac2010-02-18 15:13:05 +00001171 bridge->irq_set(bridge, level, 0, 1);
Martyn Welchc813f592009-10-29 16:34:54 +00001172
1173 bridge->irq[level - 1].callback[statid].func = NULL;
1174 bridge->irq[level - 1].callback[statid].priv_data = NULL;
1175
Emilio G. Cota886953e2010-11-12 11:14:07 +00001176 mutex_unlock(&bridge->irq_mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001177}
Martyn Welchc813f592009-10-29 16:34:54 +00001178EXPORT_SYMBOL(vme_irq_free);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001179
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001180int vme_irq_generate(struct vme_dev *vdev, int level, int statid)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001181{
1182 struct vme_bridge *bridge;
1183
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001184 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001185 if (bridge == NULL) {
1186 printk(KERN_ERR "Can't find VME bus\n");
1187 return -EINVAL;
1188 }
1189
Martyn Welchead1f3e2009-12-15 08:43:02 +00001190 if ((level < 1) || (level > 7)) {
Martyn Welcha17a75e2009-07-31 09:28:17 +01001191 printk(KERN_WARNING "Invalid interrupt level\n");
1192 return -EINVAL;
1193 }
1194
Martyn Welchc813f592009-10-29 16:34:54 +00001195 if (bridge->irq_generate == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001196 printk(KERN_WARNING "Interrupt generation not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001197 return -EINVAL;
1198 }
1199
Martyn Welch29848ac2010-02-18 15:13:05 +00001200 return bridge->irq_generate(bridge, level, statid);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001201}
Martyn Welchc813f592009-10-29 16:34:54 +00001202EXPORT_SYMBOL(vme_irq_generate);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001203
Martyn Welch42fb5032009-08-11 17:44:56 +01001204/*
1205 * Request the location monitor, return resource or NULL
1206 */
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001207struct vme_resource *vme_lm_request(struct vme_dev *vdev)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001208{
1209 struct vme_bridge *bridge;
Martyn Welch42fb5032009-08-11 17:44:56 +01001210 struct list_head *lm_pos = NULL;
1211 struct vme_lm_resource *allocated_lm = NULL;
1212 struct vme_lm_resource *lm = NULL;
1213 struct vme_resource *resource = NULL;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001214
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001215 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001216 if (bridge == NULL) {
1217 printk(KERN_ERR "Can't find VME bus\n");
Martyn Welch42fb5032009-08-11 17:44:56 +01001218 goto err_bus;
1219 }
1220
1221 /* Loop through DMA resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +00001222 list_for_each(lm_pos, &bridge->lm_resources) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001223 lm = list_entry(lm_pos,
1224 struct vme_lm_resource, list);
1225
1226 if (lm == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -07001227 printk(KERN_ERR "Registered NULL Location Monitor resource\n");
Martyn Welch42fb5032009-08-11 17:44:56 +01001228 continue;
1229 }
1230
1231 /* Find an unlocked controller */
Emilio G. Cota886953e2010-11-12 11:14:07 +00001232 mutex_lock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001233 if (lm->locked == 0) {
1234 lm->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +00001235 mutex_unlock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001236 allocated_lm = lm;
1237 break;
1238 }
Emilio G. Cota886953e2010-11-12 11:14:07 +00001239 mutex_unlock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001240 }
1241
1242 /* Check to see if we found a resource */
1243 if (allocated_lm == NULL)
1244 goto err_lm;
1245
1246 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
1247 if (resource == NULL) {
1248 printk(KERN_ERR "Unable to allocate resource structure\n");
1249 goto err_alloc;
1250 }
1251 resource->type = VME_LM;
Emilio G. Cota886953e2010-11-12 11:14:07 +00001252 resource->entry = &allocated_lm->list;
Martyn Welch42fb5032009-08-11 17:44:56 +01001253
1254 return resource;
1255
1256err_alloc:
1257 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +00001258 mutex_lock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001259 lm->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +00001260 mutex_unlock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001261err_lm:
1262err_bus:
1263 return NULL;
1264}
1265EXPORT_SYMBOL(vme_lm_request);
1266
1267int vme_lm_count(struct vme_resource *resource)
1268{
1269 struct vme_lm_resource *lm;
1270
1271 if (resource->type != VME_LM) {
1272 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001273 return -EINVAL;
1274 }
1275
Martyn Welch42fb5032009-08-11 17:44:56 +01001276 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1277
1278 return lm->monitors;
1279}
1280EXPORT_SYMBOL(vme_lm_count);
1281
1282int vme_lm_set(struct vme_resource *resource, unsigned long long lm_base,
Martyn Welch6af04b02011-12-01 17:06:29 +00001283 u32 aspace, u32 cycle)
Martyn Welch42fb5032009-08-11 17:44:56 +01001284{
1285 struct vme_bridge *bridge = find_bridge(resource);
1286 struct vme_lm_resource *lm;
1287
1288 if (resource->type != VME_LM) {
1289 printk(KERN_ERR "Not a Location Monitor resource\n");
1290 return -EINVAL;
1291 }
1292
1293 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1294
Martyn Welcha17a75e2009-07-31 09:28:17 +01001295 if (bridge->lm_set == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001296 printk(KERN_ERR "vme_lm_set not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001297 return -EINVAL;
1298 }
1299
Martyn Welch8be92262009-10-29 16:35:08 +00001300 return bridge->lm_set(lm, lm_base, aspace, cycle);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001301}
1302EXPORT_SYMBOL(vme_lm_set);
1303
Martyn Welch42fb5032009-08-11 17:44:56 +01001304int vme_lm_get(struct vme_resource *resource, unsigned long long *lm_base,
Martyn Welch6af04b02011-12-01 17:06:29 +00001305 u32 *aspace, u32 *cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001306{
Martyn Welch42fb5032009-08-11 17:44:56 +01001307 struct vme_bridge *bridge = find_bridge(resource);
1308 struct vme_lm_resource *lm;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001309
Martyn Welch42fb5032009-08-11 17:44:56 +01001310 if (resource->type != VME_LM) {
1311 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001312 return -EINVAL;
1313 }
1314
Martyn Welch42fb5032009-08-11 17:44:56 +01001315 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1316
Martyn Welcha17a75e2009-07-31 09:28:17 +01001317 if (bridge->lm_get == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001318 printk(KERN_ERR "vme_lm_get not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001319 return -EINVAL;
1320 }
1321
Martyn Welch42fb5032009-08-11 17:44:56 +01001322 return bridge->lm_get(lm, lm_base, aspace, cycle);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001323}
1324EXPORT_SYMBOL(vme_lm_get);
1325
Martyn Welch42fb5032009-08-11 17:44:56 +01001326int vme_lm_attach(struct vme_resource *resource, int monitor,
Aaron Sierrafa54b322016-04-29 16:41:02 -05001327 void (*callback)(void *), void *data)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001328{
Martyn Welch42fb5032009-08-11 17:44:56 +01001329 struct vme_bridge *bridge = find_bridge(resource);
1330 struct vme_lm_resource *lm;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001331
Martyn Welch42fb5032009-08-11 17:44:56 +01001332 if (resource->type != VME_LM) {
1333 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001334 return -EINVAL;
1335 }
1336
Martyn Welch42fb5032009-08-11 17:44:56 +01001337 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1338
Martyn Welcha17a75e2009-07-31 09:28:17 +01001339 if (bridge->lm_attach == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001340 printk(KERN_ERR "vme_lm_attach not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001341 return -EINVAL;
1342 }
1343
Aaron Sierrafa54b322016-04-29 16:41:02 -05001344 return bridge->lm_attach(lm, monitor, callback, data);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001345}
1346EXPORT_SYMBOL(vme_lm_attach);
1347
Martyn Welch42fb5032009-08-11 17:44:56 +01001348int vme_lm_detach(struct vme_resource *resource, int monitor)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001349{
Martyn Welch42fb5032009-08-11 17:44:56 +01001350 struct vme_bridge *bridge = find_bridge(resource);
1351 struct vme_lm_resource *lm;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001352
Martyn Welch42fb5032009-08-11 17:44:56 +01001353 if (resource->type != VME_LM) {
1354 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001355 return -EINVAL;
1356 }
1357
Martyn Welch42fb5032009-08-11 17:44:56 +01001358 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1359
Martyn Welcha17a75e2009-07-31 09:28:17 +01001360 if (bridge->lm_detach == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001361 printk(KERN_ERR "vme_lm_detach not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001362 return -EINVAL;
1363 }
1364
Martyn Welch42fb5032009-08-11 17:44:56 +01001365 return bridge->lm_detach(lm, monitor);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001366}
1367EXPORT_SYMBOL(vme_lm_detach);
1368
Martyn Welch42fb5032009-08-11 17:44:56 +01001369void vme_lm_free(struct vme_resource *resource)
1370{
1371 struct vme_lm_resource *lm;
1372
1373 if (resource->type != VME_LM) {
1374 printk(KERN_ERR "Not a Location Monitor resource\n");
1375 return;
1376 }
1377
1378 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1379
Emilio G. Cota886953e2010-11-12 11:14:07 +00001380 mutex_lock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001381
Martyn Welch8be92262009-10-29 16:35:08 +00001382 /* XXX
1383 * Check to see that there aren't any callbacks still attached, if
1384 * there are we should probably be detaching them!
1385 */
Martyn Welch42fb5032009-08-11 17:44:56 +01001386
1387 lm->locked = 0;
1388
Emilio G. Cota886953e2010-11-12 11:14:07 +00001389 mutex_unlock(&lm->mtx);
Martyn Welch8be92262009-10-29 16:35:08 +00001390
1391 kfree(resource);
Martyn Welch42fb5032009-08-11 17:44:56 +01001392}
1393EXPORT_SYMBOL(vme_lm_free);
1394
Martyn Welchd7729f02013-11-08 11:58:35 +00001395int vme_slot_num(struct vme_dev *vdev)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001396{
1397 struct vme_bridge *bridge;
1398
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001399 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001400 if (bridge == NULL) {
1401 printk(KERN_ERR "Can't find VME bus\n");
1402 return -EINVAL;
1403 }
1404
1405 if (bridge->slot_get == NULL) {
Martyn Welchd7729f02013-11-08 11:58:35 +00001406 printk(KERN_WARNING "vme_slot_num not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001407 return -EINVAL;
1408 }
1409
Martyn Welch29848ac2010-02-18 15:13:05 +00001410 return bridge->slot_get(bridge);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001411}
Martyn Welchd7729f02013-11-08 11:58:35 +00001412EXPORT_SYMBOL(vme_slot_num);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001413
Martyn Welch978f47d2013-11-08 11:58:34 +00001414int vme_bus_num(struct vme_dev *vdev)
1415{
1416 struct vme_bridge *bridge;
1417
1418 bridge = vdev->bridge;
1419 if (bridge == NULL) {
1420 pr_err("Can't find VME bus\n");
1421 return -EINVAL;
1422 }
1423
1424 return bridge->num;
1425}
1426EXPORT_SYMBOL(vme_bus_num);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001427
1428/* - Bridge Registration --------------------------------------------------- */
1429
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001430static void vme_dev_release(struct device *dev)
1431{
1432 kfree(dev_to_vme_dev(dev));
1433}
1434
Aaron Sierra326071b2016-04-24 15:11:38 -05001435/* Common bridge initialization */
1436struct vme_bridge *vme_init_bridge(struct vme_bridge *bridge)
1437{
1438 INIT_LIST_HEAD(&bridge->vme_error_handlers);
1439 INIT_LIST_HEAD(&bridge->master_resources);
1440 INIT_LIST_HEAD(&bridge->slave_resources);
1441 INIT_LIST_HEAD(&bridge->dma_resources);
1442 INIT_LIST_HEAD(&bridge->lm_resources);
1443 mutex_init(&bridge->irq_mtx);
1444
1445 return bridge;
1446}
1447EXPORT_SYMBOL(vme_init_bridge);
1448
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001449int vme_register_bridge(struct vme_bridge *bridge)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001450{
1451 int i;
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001452 int ret = -1;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001453
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001454 mutex_lock(&vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001455 for (i = 0; i < sizeof(vme_bus_numbers) * 8; i++) {
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001456 if ((vme_bus_numbers & (1 << i)) == 0) {
1457 vme_bus_numbers |= (1 << i);
1458 bridge->num = i;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001459 INIT_LIST_HEAD(&bridge->devices);
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001460 list_add_tail(&bridge->bus_list, &vme_bus_list);
1461 ret = 0;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001462 break;
1463 }
1464 }
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001465 mutex_unlock(&vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001466
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001467 return ret;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001468}
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001469EXPORT_SYMBOL(vme_register_bridge);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001470
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001471void vme_unregister_bridge(struct vme_bridge *bridge)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001472{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001473 struct vme_dev *vdev;
1474 struct vme_dev *tmp;
1475
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001476 mutex_lock(&vme_buses_lock);
1477 vme_bus_numbers &= ~(1 << bridge->num);
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001478 list_for_each_entry_safe(vdev, tmp, &bridge->devices, bridge_list) {
1479 list_del(&vdev->drv_list);
1480 list_del(&vdev->bridge_list);
1481 device_unregister(&vdev->dev);
1482 }
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001483 list_del(&bridge->bus_list);
1484 mutex_unlock(&vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001485}
Martyn Welcha17a75e2009-07-31 09:28:17 +01001486EXPORT_SYMBOL(vme_unregister_bridge);
1487
Martyn Welcha17a75e2009-07-31 09:28:17 +01001488/* - Driver Registration --------------------------------------------------- */
1489
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001490static int __vme_register_driver_bus(struct vme_driver *drv,
1491 struct vme_bridge *bridge, unsigned int ndevs)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001492{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001493 int err;
1494 unsigned int i;
1495 struct vme_dev *vdev;
1496 struct vme_dev *tmp;
1497
1498 for (i = 0; i < ndevs; i++) {
1499 vdev = kzalloc(sizeof(struct vme_dev), GFP_KERNEL);
1500 if (!vdev) {
1501 err = -ENOMEM;
1502 goto err_devalloc;
1503 }
Manohar Vangaa916a392011-09-26 11:27:17 +02001504 vdev->num = i;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001505 vdev->bridge = bridge;
1506 vdev->dev.platform_data = drv;
1507 vdev->dev.release = vme_dev_release;
1508 vdev->dev.parent = bridge->parent;
1509 vdev->dev.bus = &vme_bus_type;
Manohar Vangaa916a392011-09-26 11:27:17 +02001510 dev_set_name(&vdev->dev, "%s.%u-%u", drv->name, bridge->num,
1511 vdev->num);
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001512
1513 err = device_register(&vdev->dev);
1514 if (err)
1515 goto err_reg;
1516
1517 if (vdev->dev.platform_data) {
1518 list_add_tail(&vdev->drv_list, &drv->devices);
1519 list_add_tail(&vdev->bridge_list, &bridge->devices);
1520 } else
1521 device_unregister(&vdev->dev);
1522 }
1523 return 0;
1524
1525err_reg:
Emilio G. Cotadef18202013-02-13 13:47:54 -05001526 put_device(&vdev->dev);
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001527 kfree(vdev);
1528err_devalloc:
1529 list_for_each_entry_safe(vdev, tmp, &drv->devices, drv_list) {
1530 list_del(&vdev->drv_list);
1531 list_del(&vdev->bridge_list);
1532 device_unregister(&vdev->dev);
1533 }
1534 return err;
1535}
1536
1537static int __vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1538{
1539 struct vme_bridge *bridge;
1540 int err = 0;
1541
1542 mutex_lock(&vme_buses_lock);
1543 list_for_each_entry(bridge, &vme_bus_list, bus_list) {
1544 /*
1545 * This cannot cause trouble as we already have vme_buses_lock
1546 * and if the bridge is removed, it will have to go through
1547 * vme_unregister_bridge() to do it (which calls remove() on
1548 * the bridge which in turn tries to acquire vme_buses_lock and
Manohar Vangac26f6112011-11-04 11:12:29 +01001549 * will have to wait).
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001550 */
1551 err = __vme_register_driver_bus(drv, bridge, ndevs);
1552 if (err)
1553 break;
1554 }
1555 mutex_unlock(&vme_buses_lock);
1556 return err;
1557}
1558
1559int vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1560{
1561 int err;
1562
Martyn Welcha17a75e2009-07-31 09:28:17 +01001563 drv->driver.name = drv->name;
1564 drv->driver.bus = &vme_bus_type;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001565 INIT_LIST_HEAD(&drv->devices);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001566
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001567 err = driver_register(&drv->driver);
1568 if (err)
1569 return err;
1570
1571 err = __vme_register_driver(drv, ndevs);
1572 if (err)
1573 driver_unregister(&drv->driver);
1574
1575 return err;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001576}
1577EXPORT_SYMBOL(vme_register_driver);
1578
Martyn Welchead1f3e2009-12-15 08:43:02 +00001579void vme_unregister_driver(struct vme_driver *drv)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001580{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001581 struct vme_dev *dev, *dev_tmp;
1582
1583 mutex_lock(&vme_buses_lock);
1584 list_for_each_entry_safe(dev, dev_tmp, &drv->devices, drv_list) {
1585 list_del(&dev->drv_list);
1586 list_del(&dev->bridge_list);
1587 device_unregister(&dev->dev);
1588 }
1589 mutex_unlock(&vme_buses_lock);
1590
Martyn Welcha17a75e2009-07-31 09:28:17 +01001591 driver_unregister(&drv->driver);
1592}
1593EXPORT_SYMBOL(vme_unregister_driver);
1594
1595/* - Bus Registration ------------------------------------------------------ */
1596
Martyn Welcha17a75e2009-07-31 09:28:17 +01001597static int vme_bus_match(struct device *dev, struct device_driver *drv)
1598{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001599 struct vme_driver *vme_drv;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001600
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001601 vme_drv = container_of(drv, struct vme_driver, driver);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001602
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001603 if (dev->platform_data == vme_drv) {
1604 struct vme_dev *vdev = dev_to_vme_dev(dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001605
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001606 if (vme_drv->match && vme_drv->match(vdev))
1607 return 1;
1608
1609 dev->platform_data = NULL;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001610 }
Martyn Welcha17a75e2009-07-31 09:28:17 +01001611 return 0;
1612}
1613
1614static int vme_bus_probe(struct device *dev)
1615{
Martyn Welcha17a75e2009-07-31 09:28:17 +01001616 int retval = -ENODEV;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001617 struct vme_driver *driver;
1618 struct vme_dev *vdev = dev_to_vme_dev(dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001619
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001620 driver = dev->platform_data;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001621
Martyn Welchead1f3e2009-12-15 08:43:02 +00001622 if (driver->probe != NULL)
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001623 retval = driver->probe(vdev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001624
1625 return retval;
1626}
1627
Martyn Welcha17a75e2009-07-31 09:28:17 +01001628struct bus_type vme_bus_type = {
1629 .name = "vme",
1630 .match = vme_bus_match,
1631 .probe = vme_bus_probe,
Martyn Welcha17a75e2009-07-31 09:28:17 +01001632};
1633EXPORT_SYMBOL(vme_bus_type);
1634
Martyn Welchead1f3e2009-12-15 08:43:02 +00001635static int __init vme_init(void)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001636{
1637 return bus_register(&vme_bus_type);
1638}
Aaron Sierrac326cc02013-12-09 09:54:42 -06001639subsys_initcall(vme_init);