blob: 72924b0632b79c8eda73b06c51e2bdcc1b73634e [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
Martyn Welcha17a75e2009-07-31 09:28:17 +010016#include <linux/module.h>
17#include <linux/moduleparam.h>
18#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 void __exit vme_exit(void);
43static int __init vme_init(void);
Martyn Welcha17a75e2009-07-31 09:28:17 +010044
Manohar Vanga8f966dc2011-09-26 11:27:15 +020045static struct vme_dev *dev_to_vme_dev(struct device *dev)
Martyn Welcha17a75e2009-07-31 09:28:17 +010046{
Manohar Vanga8f966dc2011-09-26 11:27:15 +020047 return container_of(dev, struct vme_dev, dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +010048}
49
50/*
51 * Find the bridge that the resource is associated with.
52 */
53static struct vme_bridge *find_bridge(struct vme_resource *resource)
54{
55 /* Get list to search */
56 switch (resource->type) {
57 case VME_MASTER:
58 return list_entry(resource->entry, struct vme_master_resource,
59 list)->parent;
60 break;
61 case VME_SLAVE:
62 return list_entry(resource->entry, struct vme_slave_resource,
63 list)->parent;
64 break;
65 case VME_DMA:
66 return list_entry(resource->entry, struct vme_dma_resource,
67 list)->parent;
68 break;
Martyn Welch42fb5032009-08-11 17:44:56 +010069 case VME_LM:
70 return list_entry(resource->entry, struct vme_lm_resource,
71 list)->parent;
72 break;
Martyn Welcha17a75e2009-07-31 09:28:17 +010073 default:
74 printk(KERN_ERR "Unknown resource type\n");
75 return NULL;
76 break;
77 }
78}
79
80/*
81 * Allocate a contiguous block of memory for use by the driver. This is used to
82 * create the buffers for the slave windows.
Martyn Welcha17a75e2009-07-31 09:28:17 +010083 */
Martyn Welchead1f3e2009-12-15 08:43:02 +000084void *vme_alloc_consistent(struct vme_resource *resource, size_t size,
Martyn Welcha17a75e2009-07-31 09:28:17 +010085 dma_addr_t *dma)
86{
87 struct vme_bridge *bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +010088
Martyn Welchead1f3e2009-12-15 08:43:02 +000089 if (resource == NULL) {
90 printk(KERN_ERR "No resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +010091 return NULL;
92 }
93
94 bridge = find_bridge(resource);
Martyn Welchead1f3e2009-12-15 08:43:02 +000095 if (bridge == NULL) {
96 printk(KERN_ERR "Can't find bridge\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +010097 return NULL;
98 }
99
Martyn Welcha17a75e2009-07-31 09:28:17 +0100100 if (bridge->parent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700101 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100102 return NULL;
103 }
Martyn Welcha17a75e2009-07-31 09:28:17 +0100104
Manohar Vanga7f58f022011-08-10 11:33:46 +0200105 if (bridge->alloc_consistent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700106 printk(KERN_ERR "alloc_consistent not supported by bridge %s\n",
107 bridge->name);
Manohar Vanga7f58f022011-08-10 11:33:46 +0200108 return NULL;
109 }
110
111 return bridge->alloc_consistent(bridge->parent, size, dma);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100112}
113EXPORT_SYMBOL(vme_alloc_consistent);
114
115/*
116 * Free previously allocated contiguous block of memory.
Martyn Welcha17a75e2009-07-31 09:28:17 +0100117 */
118void vme_free_consistent(struct vme_resource *resource, size_t size,
119 void *vaddr, dma_addr_t dma)
120{
121 struct vme_bridge *bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100122
Martyn Welchead1f3e2009-12-15 08:43:02 +0000123 if (resource == NULL) {
124 printk(KERN_ERR "No resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100125 return;
126 }
127
128 bridge = find_bridge(resource);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000129 if (bridge == NULL) {
130 printk(KERN_ERR "Can't find bridge\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100131 return;
132 }
133
Manohar Vanga7f58f022011-08-10 11:33:46 +0200134 if (bridge->parent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700135 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
Manohar Vanga7f58f022011-08-10 11:33:46 +0200136 return;
137 }
Martyn Welcha17a75e2009-07-31 09:28:17 +0100138
Manohar Vanga7f58f022011-08-10 11:33:46 +0200139 if (bridge->free_consistent == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700140 printk(KERN_ERR "free_consistent not supported by bridge %s\n",
141 bridge->name);
Manohar Vanga7f58f022011-08-10 11:33:46 +0200142 return;
143 }
144
145 bridge->free_consistent(bridge->parent, size, vaddr, dma);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100146}
147EXPORT_SYMBOL(vme_free_consistent);
148
149size_t vme_get_size(struct vme_resource *resource)
150{
151 int enabled, retval;
152 unsigned long long base, size;
153 dma_addr_t buf_base;
Martyn Welch6af04b02011-12-01 17:06:29 +0000154 u32 aspace, cycle, dwidth;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100155
156 switch (resource->type) {
157 case VME_MASTER:
158 retval = vme_master_get(resource, &enabled, &base, &size,
159 &aspace, &cycle, &dwidth);
160
161 return size;
162 break;
163 case VME_SLAVE:
164 retval = vme_slave_get(resource, &enabled, &base, &size,
165 &buf_base, &aspace, &cycle);
166
167 return size;
168 break;
169 case VME_DMA:
170 return 0;
171 break;
172 default:
173 printk(KERN_ERR "Unknown resource type\n");
174 return 0;
175 break;
176 }
177}
178EXPORT_SYMBOL(vme_get_size);
179
Dmitry Kalinkinef73f882015-05-28 15:07:04 +0300180int vme_check_window(u32 aspace, unsigned long long vme_base,
181 unsigned long long size)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100182{
183 int retval = 0;
184
185 switch (aspace) {
186 case VME_A16:
187 if (((vme_base + size) > VME_A16_MAX) ||
188 (vme_base > VME_A16_MAX))
189 retval = -EFAULT;
190 break;
191 case VME_A24:
192 if (((vme_base + size) > VME_A24_MAX) ||
193 (vme_base > VME_A24_MAX))
194 retval = -EFAULT;
195 break;
196 case VME_A32:
197 if (((vme_base + size) > VME_A32_MAX) ||
198 (vme_base > VME_A32_MAX))
199 retval = -EFAULT;
200 break;
201 case VME_A64:
Dmitry Kalinkine7fd80c2015-05-28 15:07:03 +0300202 if ((size != 0) && (vme_base > U64_MAX + 1 - size))
203 retval = -EFAULT;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100204 break;
205 case VME_CRCSR:
206 if (((vme_base + size) > VME_CRCSR_MAX) ||
207 (vme_base > VME_CRCSR_MAX))
208 retval = -EFAULT;
209 break;
210 case VME_USER1:
211 case VME_USER2:
212 case VME_USER3:
213 case VME_USER4:
214 /* User Defined */
215 break;
216 default:
Martyn Welchead1f3e2009-12-15 08:43:02 +0000217 printk(KERN_ERR "Invalid address space\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100218 retval = -EINVAL;
219 break;
220 }
221
222 return retval;
223}
Dmitry Kalinkinef73f882015-05-28 15:07:04 +0300224EXPORT_SYMBOL(vme_check_window);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100225
Dmitry Kalinkin472f16f2015-09-18 02:01:43 +0300226static u32 vme_get_aspace(int am)
227{
228 switch (am) {
229 case 0x29:
230 case 0x2D:
231 return VME_A16;
232 case 0x38:
233 case 0x39:
234 case 0x3A:
235 case 0x3B:
236 case 0x3C:
237 case 0x3D:
238 case 0x3E:
239 case 0x3F:
240 return VME_A24;
241 case 0x8:
242 case 0x9:
243 case 0xA:
244 case 0xB:
245 case 0xC:
246 case 0xD:
247 case 0xE:
248 case 0xF:
249 return VME_A32;
250 case 0x0:
251 case 0x1:
252 case 0x3:
253 return VME_A64;
254 }
255
256 return 0;
257}
258
Martyn Welcha17a75e2009-07-31 09:28:17 +0100259/*
260 * Request a slave image with specific attributes, return some unique
261 * identifier.
262 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000263struct vme_resource *vme_slave_request(struct vme_dev *vdev, u32 address,
264 u32 cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100265{
266 struct vme_bridge *bridge;
267 struct list_head *slave_pos = NULL;
268 struct vme_slave_resource *allocated_image = NULL;
269 struct vme_slave_resource *slave_image = NULL;
270 struct vme_resource *resource = NULL;
271
Manohar Vanga8f966dc2011-09-26 11:27:15 +0200272 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100273 if (bridge == NULL) {
274 printk(KERN_ERR "Can't find VME bus\n");
275 goto err_bus;
276 }
277
278 /* Loop through slave resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000279 list_for_each(slave_pos, &bridge->slave_resources) {
Martyn Welcha17a75e2009-07-31 09:28:17 +0100280 slave_image = list_entry(slave_pos,
281 struct vme_slave_resource, list);
282
283 if (slave_image == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000284 printk(KERN_ERR "Registered NULL Slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100285 continue;
286 }
287
288 /* Find an unlocked and compatible image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000289 mutex_lock(&slave_image->mtx);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000290 if (((slave_image->address_attr & address) == address) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100291 ((slave_image->cycle_attr & cycle) == cycle) &&
292 (slave_image->locked == 0)) {
293
294 slave_image->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000295 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100296 allocated_image = slave_image;
297 break;
298 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000299 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100300 }
301
302 /* No free image */
303 if (allocated_image == NULL)
304 goto err_image;
305
306 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
307 if (resource == NULL) {
308 printk(KERN_WARNING "Unable to allocate resource structure\n");
309 goto err_alloc;
310 }
311 resource->type = VME_SLAVE;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000312 resource->entry = &allocated_image->list;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100313
314 return resource;
315
316err_alloc:
317 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000318 mutex_lock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100319 slave_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000320 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100321err_image:
322err_bus:
323 return NULL;
324}
325EXPORT_SYMBOL(vme_slave_request);
326
Martyn Welchead1f3e2009-12-15 08:43:02 +0000327int vme_slave_set(struct vme_resource *resource, int enabled,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100328 unsigned long long vme_base, unsigned long long size,
Martyn Welch6af04b02011-12-01 17:06:29 +0000329 dma_addr_t buf_base, u32 aspace, u32 cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100330{
331 struct vme_bridge *bridge = find_bridge(resource);
332 struct vme_slave_resource *image;
333 int retval;
334
335 if (resource->type != VME_SLAVE) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000336 printk(KERN_ERR "Not a slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100337 return -EINVAL;
338 }
339
340 image = list_entry(resource->entry, struct vme_slave_resource, list);
341
342 if (bridge->slave_set == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000343 printk(KERN_ERR "Function not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100344 return -ENOSYS;
345 }
346
Martyn Welchead1f3e2009-12-15 08:43:02 +0000347 if (!(((image->address_attr & aspace) == aspace) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100348 ((image->cycle_attr & cycle) == cycle))) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000349 printk(KERN_ERR "Invalid attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100350 return -EINVAL;
351 }
352
353 retval = vme_check_window(aspace, vme_base, size);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000354 if (retval)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100355 return retval;
356
357 return bridge->slave_set(image, enabled, vme_base, size, buf_base,
358 aspace, cycle);
359}
360EXPORT_SYMBOL(vme_slave_set);
361
Martyn Welchead1f3e2009-12-15 08:43:02 +0000362int vme_slave_get(struct vme_resource *resource, int *enabled,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100363 unsigned long long *vme_base, unsigned long long *size,
Martyn Welch6af04b02011-12-01 17:06:29 +0000364 dma_addr_t *buf_base, u32 *aspace, u32 *cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100365{
366 struct vme_bridge *bridge = find_bridge(resource);
367 struct vme_slave_resource *image;
368
369 if (resource->type != VME_SLAVE) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000370 printk(KERN_ERR "Not a slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100371 return -EINVAL;
372 }
373
374 image = list_entry(resource->entry, struct vme_slave_resource, list);
375
Emilio G. Cota51a569f2009-08-10 16:52:42 +0200376 if (bridge->slave_get == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000377 printk(KERN_ERR "vme_slave_get not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100378 return -EINVAL;
379 }
380
381 return bridge->slave_get(image, enabled, vme_base, size, buf_base,
382 aspace, cycle);
383}
384EXPORT_SYMBOL(vme_slave_get);
385
386void vme_slave_free(struct vme_resource *resource)
387{
388 struct vme_slave_resource *slave_image;
389
390 if (resource->type != VME_SLAVE) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000391 printk(KERN_ERR "Not a slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100392 return;
393 }
394
395 slave_image = list_entry(resource->entry, struct vme_slave_resource,
396 list);
397 if (slave_image == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000398 printk(KERN_ERR "Can't find slave resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100399 return;
400 }
401
402 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000403 mutex_lock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100404 if (slave_image->locked == 0)
405 printk(KERN_ERR "Image is already free\n");
406
407 slave_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000408 mutex_unlock(&slave_image->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100409
410 /* Free up resource memory */
411 kfree(resource);
412}
413EXPORT_SYMBOL(vme_slave_free);
414
415/*
416 * Request a master image with specific attributes, return some unique
417 * identifier.
418 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000419struct vme_resource *vme_master_request(struct vme_dev *vdev, u32 address,
420 u32 cycle, u32 dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100421{
422 struct vme_bridge *bridge;
423 struct list_head *master_pos = NULL;
424 struct vme_master_resource *allocated_image = NULL;
425 struct vme_master_resource *master_image = NULL;
426 struct vme_resource *resource = NULL;
427
Manohar Vanga8f966dc2011-09-26 11:27:15 +0200428 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100429 if (bridge == NULL) {
430 printk(KERN_ERR "Can't find VME bus\n");
431 goto err_bus;
432 }
433
434 /* Loop through master resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000435 list_for_each(master_pos, &bridge->master_resources) {
Martyn Welcha17a75e2009-07-31 09:28:17 +0100436 master_image = list_entry(master_pos,
437 struct vme_master_resource, list);
438
439 if (master_image == NULL) {
440 printk(KERN_WARNING "Registered NULL master resource\n");
441 continue;
442 }
443
444 /* Find an unlocked and compatible image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000445 spin_lock(&master_image->lock);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000446 if (((master_image->address_attr & address) == address) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100447 ((master_image->cycle_attr & cycle) == cycle) &&
448 ((master_image->width_attr & dwidth) == dwidth) &&
449 (master_image->locked == 0)) {
450
451 master_image->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000452 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100453 allocated_image = master_image;
454 break;
455 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000456 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100457 }
458
459 /* Check to see if we found a resource */
460 if (allocated_image == NULL) {
461 printk(KERN_ERR "Can't find a suitable resource\n");
462 goto err_image;
463 }
464
465 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
466 if (resource == NULL) {
467 printk(KERN_ERR "Unable to allocate resource structure\n");
468 goto err_alloc;
469 }
470 resource->type = VME_MASTER;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000471 resource->entry = &allocated_image->list;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100472
473 return resource;
474
Martyn Welcha17a75e2009-07-31 09:28:17 +0100475err_alloc:
476 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000477 spin_lock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100478 master_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000479 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100480err_image:
481err_bus:
482 return NULL;
483}
484EXPORT_SYMBOL(vme_master_request);
485
Martyn Welchead1f3e2009-12-15 08:43:02 +0000486int vme_master_set(struct vme_resource *resource, int enabled,
Martyn Welch6af04b02011-12-01 17:06:29 +0000487 unsigned long long vme_base, unsigned long long size, u32 aspace,
488 u32 cycle, u32 dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100489{
490 struct vme_bridge *bridge = find_bridge(resource);
491 struct vme_master_resource *image;
492 int retval;
493
494 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000495 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100496 return -EINVAL;
497 }
498
499 image = list_entry(resource->entry, struct vme_master_resource, list);
500
501 if (bridge->master_set == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000502 printk(KERN_WARNING "vme_master_set not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100503 return -EINVAL;
504 }
505
Martyn Welchead1f3e2009-12-15 08:43:02 +0000506 if (!(((image->address_attr & aspace) == aspace) &&
Martyn Welcha17a75e2009-07-31 09:28:17 +0100507 ((image->cycle_attr & cycle) == cycle) &&
508 ((image->width_attr & dwidth) == dwidth))) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000509 printk(KERN_WARNING "Invalid attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100510 return -EINVAL;
511 }
512
513 retval = vme_check_window(aspace, vme_base, size);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000514 if (retval)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100515 return retval;
516
517 return bridge->master_set(image, enabled, vme_base, size, aspace,
518 cycle, dwidth);
519}
520EXPORT_SYMBOL(vme_master_set);
521
Martyn Welchead1f3e2009-12-15 08:43:02 +0000522int vme_master_get(struct vme_resource *resource, int *enabled,
Martyn Welch6af04b02011-12-01 17:06:29 +0000523 unsigned long long *vme_base, unsigned long long *size, u32 *aspace,
524 u32 *cycle, u32 *dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100525{
526 struct vme_bridge *bridge = find_bridge(resource);
527 struct vme_master_resource *image;
528
529 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000530 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100531 return -EINVAL;
532 }
533
534 image = list_entry(resource->entry, struct vme_master_resource, list);
535
Emilio G. Cota51a569f2009-08-10 16:52:42 +0200536 if (bridge->master_get == NULL) {
Julia Lawallc1038302014-12-07 20:20:53 +0100537 printk(KERN_WARNING "%s not supported\n", __func__);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100538 return -EINVAL;
539 }
540
541 return bridge->master_get(image, enabled, vme_base, size, aspace,
542 cycle, dwidth);
543}
544EXPORT_SYMBOL(vme_master_get);
545
546/*
547 * Read data out of VME space into a buffer.
548 */
Martyn Welchead1f3e2009-12-15 08:43:02 +0000549ssize_t vme_master_read(struct vme_resource *resource, void *buf, size_t count,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100550 loff_t offset)
551{
552 struct vme_bridge *bridge = find_bridge(resource);
553 struct vme_master_resource *image;
554 size_t length;
555
556 if (bridge->master_read == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000557 printk(KERN_WARNING "Reading from resource not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100558 return -EINVAL;
559 }
560
561 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000562 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100563 return -EINVAL;
564 }
565
566 image = list_entry(resource->entry, struct vme_master_resource, list);
567
568 length = vme_get_size(resource);
569
570 if (offset > length) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000571 printk(KERN_WARNING "Invalid Offset\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100572 return -EFAULT;
573 }
574
575 if ((offset + count) > length)
576 count = length - offset;
577
578 return bridge->master_read(image, buf, count, offset);
579
580}
581EXPORT_SYMBOL(vme_master_read);
582
583/*
584 * Write data out to VME space from a buffer.
585 */
Martyn Welchead1f3e2009-12-15 08:43:02 +0000586ssize_t vme_master_write(struct vme_resource *resource, void *buf,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100587 size_t count, loff_t offset)
588{
589 struct vme_bridge *bridge = find_bridge(resource);
590 struct vme_master_resource *image;
591 size_t length;
592
593 if (bridge->master_write == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000594 printk(KERN_WARNING "Writing to resource not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100595 return -EINVAL;
596 }
597
598 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000599 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100600 return -EINVAL;
601 }
602
603 image = list_entry(resource->entry, struct vme_master_resource, list);
604
605 length = vme_get_size(resource);
606
607 if (offset > length) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000608 printk(KERN_WARNING "Invalid Offset\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100609 return -EFAULT;
610 }
611
612 if ((offset + count) > length)
613 count = length - offset;
614
615 return bridge->master_write(image, buf, count, offset);
616}
617EXPORT_SYMBOL(vme_master_write);
618
619/*
620 * Perform RMW cycle to provided location.
621 */
Martyn Welchead1f3e2009-12-15 08:43:02 +0000622unsigned int vme_master_rmw(struct vme_resource *resource, unsigned int mask,
Martyn Welcha17a75e2009-07-31 09:28:17 +0100623 unsigned int compare, unsigned int swap, loff_t offset)
624{
625 struct vme_bridge *bridge = find_bridge(resource);
626 struct vme_master_resource *image;
627
628 if (bridge->master_rmw == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000629 printk(KERN_WARNING "Writing to resource not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100630 return -EINVAL;
631 }
632
633 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000634 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100635 return -EINVAL;
636 }
637
638 image = list_entry(resource->entry, struct vme_master_resource, list);
639
640 return bridge->master_rmw(image, mask, compare, swap, offset);
641}
642EXPORT_SYMBOL(vme_master_rmw);
643
Dmitry Kalinkinc74a8042015-02-26 18:53:10 +0300644int vme_master_mmap(struct vme_resource *resource, struct vm_area_struct *vma)
645{
646 struct vme_master_resource *image;
647 phys_addr_t phys_addr;
648 unsigned long vma_size;
649
650 if (resource->type != VME_MASTER) {
651 pr_err("Not a master resource\n");
652 return -EINVAL;
653 }
654
655 image = list_entry(resource->entry, struct vme_master_resource, list);
656 phys_addr = image->bus_resource.start + (vma->vm_pgoff << PAGE_SHIFT);
657 vma_size = vma->vm_end - vma->vm_start;
658
659 if (phys_addr + vma_size > image->bus_resource.end + 1) {
660 pr_err("Map size cannot exceed the window size\n");
661 return -EFAULT;
662 }
663
664 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
665
666 return vm_iomap_memory(vma, phys_addr, vma->vm_end - vma->vm_start);
667}
668EXPORT_SYMBOL(vme_master_mmap);
669
Martyn Welcha17a75e2009-07-31 09:28:17 +0100670void vme_master_free(struct vme_resource *resource)
671{
672 struct vme_master_resource *master_image;
673
674 if (resource->type != VME_MASTER) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000675 printk(KERN_ERR "Not a master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100676 return;
677 }
678
679 master_image = list_entry(resource->entry, struct vme_master_resource,
680 list);
681 if (master_image == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000682 printk(KERN_ERR "Can't find master resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100683 return;
684 }
685
686 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000687 spin_lock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100688 if (master_image->locked == 0)
689 printk(KERN_ERR "Image is already free\n");
690
691 master_image->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000692 spin_unlock(&master_image->lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100693
694 /* Free up resource memory */
695 kfree(resource);
696}
697EXPORT_SYMBOL(vme_master_free);
698
699/*
700 * Request a DMA controller with specific attributes, return some unique
701 * identifier.
702 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000703struct vme_resource *vme_dma_request(struct vme_dev *vdev, u32 route)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100704{
705 struct vme_bridge *bridge;
706 struct list_head *dma_pos = NULL;
707 struct vme_dma_resource *allocated_ctrlr = NULL;
708 struct vme_dma_resource *dma_ctrlr = NULL;
709 struct vme_resource *resource = NULL;
710
711 /* XXX Not checking resource attributes */
712 printk(KERN_ERR "No VME resource Attribute tests done\n");
713
Manohar Vanga8f966dc2011-09-26 11:27:15 +0200714 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100715 if (bridge == NULL) {
716 printk(KERN_ERR "Can't find VME bus\n");
717 goto err_bus;
718 }
719
720 /* Loop through DMA resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000721 list_for_each(dma_pos, &bridge->dma_resources) {
Martyn Welcha17a75e2009-07-31 09:28:17 +0100722 dma_ctrlr = list_entry(dma_pos,
723 struct vme_dma_resource, list);
724
725 if (dma_ctrlr == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000726 printk(KERN_ERR "Registered NULL DMA resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100727 continue;
728 }
729
Martyn Welch4f723df2010-02-18 15:12:58 +0000730 /* Find an unlocked and compatible controller */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000731 mutex_lock(&dma_ctrlr->mtx);
Martyn Welch4f723df2010-02-18 15:12:58 +0000732 if (((dma_ctrlr->route_attr & route) == route) &&
733 (dma_ctrlr->locked == 0)) {
734
Martyn Welcha17a75e2009-07-31 09:28:17 +0100735 dma_ctrlr->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000736 mutex_unlock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100737 allocated_ctrlr = dma_ctrlr;
738 break;
739 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000740 mutex_unlock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100741 }
742
743 /* Check to see if we found a resource */
744 if (allocated_ctrlr == NULL)
745 goto err_ctrlr;
746
747 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
748 if (resource == NULL) {
749 printk(KERN_WARNING "Unable to allocate resource structure\n");
750 goto err_alloc;
751 }
752 resource->type = VME_DMA;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000753 resource->entry = &allocated_ctrlr->list;
Martyn Welcha17a75e2009-07-31 09:28:17 +0100754
755 return resource;
756
757err_alloc:
758 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +0000759 mutex_lock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100760 dma_ctrlr->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000761 mutex_unlock(&dma_ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100762err_ctrlr:
763err_bus:
764 return NULL;
765}
Martyn Welch58e50792009-10-29 16:35:20 +0000766EXPORT_SYMBOL(vme_dma_request);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100767
768/*
769 * Start new list
770 */
771struct vme_dma_list *vme_new_dma_list(struct vme_resource *resource)
772{
773 struct vme_dma_resource *ctrlr;
774 struct vme_dma_list *dma_list;
775
776 if (resource->type != VME_DMA) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000777 printk(KERN_ERR "Not a DMA resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100778 return NULL;
779 }
780
781 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list);
782
Martyn Welchead1f3e2009-12-15 08:43:02 +0000783 dma_list = kmalloc(sizeof(struct vme_dma_list), GFP_KERNEL);
784 if (dma_list == NULL) {
785 printk(KERN_ERR "Unable to allocate memory for new dma list\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100786 return NULL;
787 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000788 INIT_LIST_HEAD(&dma_list->entries);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100789 dma_list->parent = ctrlr;
Emilio G. Cota886953e2010-11-12 11:14:07 +0000790 mutex_init(&dma_list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100791
792 return dma_list;
793}
794EXPORT_SYMBOL(vme_new_dma_list);
795
796/*
797 * Create "Pattern" type attributes
798 */
Martyn Welch6af04b02011-12-01 17:06:29 +0000799struct vme_dma_attr *vme_dma_pattern_attribute(u32 pattern, u32 type)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100800{
801 struct vme_dma_attr *attributes;
802 struct vme_dma_pattern *pattern_attr;
803
Martyn Welchead1f3e2009-12-15 08:43:02 +0000804 attributes = kmalloc(sizeof(struct vme_dma_attr), GFP_KERNEL);
805 if (attributes == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700806 printk(KERN_ERR "Unable to allocate memory for attributes structure\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100807 goto err_attr;
808 }
809
Martyn Welchead1f3e2009-12-15 08:43:02 +0000810 pattern_attr = kmalloc(sizeof(struct vme_dma_pattern), GFP_KERNEL);
811 if (pattern_attr == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700812 printk(KERN_ERR "Unable to allocate memory for pattern attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100813 goto err_pat;
814 }
815
816 attributes->type = VME_DMA_PATTERN;
817 attributes->private = (void *)pattern_attr;
818
819 pattern_attr->pattern = pattern;
820 pattern_attr->type = type;
821
822 return attributes;
823
Martyn Welcha17a75e2009-07-31 09:28:17 +0100824err_pat:
825 kfree(attributes);
826err_attr:
827 return NULL;
828}
829EXPORT_SYMBOL(vme_dma_pattern_attribute);
830
831/*
832 * Create "PCI" type attributes
833 */
834struct vme_dma_attr *vme_dma_pci_attribute(dma_addr_t address)
835{
836 struct vme_dma_attr *attributes;
837 struct vme_dma_pci *pci_attr;
838
839 /* XXX Run some sanity checks here */
840
Martyn Welchead1f3e2009-12-15 08:43:02 +0000841 attributes = kmalloc(sizeof(struct vme_dma_attr), GFP_KERNEL);
842 if (attributes == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700843 printk(KERN_ERR "Unable to allocate memory for attributes structure\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100844 goto err_attr;
845 }
846
Martyn Welchead1f3e2009-12-15 08:43:02 +0000847 pci_attr = kmalloc(sizeof(struct vme_dma_pci), GFP_KERNEL);
848 if (pci_attr == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700849 printk(KERN_ERR "Unable to allocate memory for pci attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100850 goto err_pci;
851 }
852
853
854
855 attributes->type = VME_DMA_PCI;
856 attributes->private = (void *)pci_attr;
857
858 pci_attr->address = address;
859
860 return attributes;
861
Martyn Welcha17a75e2009-07-31 09:28:17 +0100862err_pci:
863 kfree(attributes);
864err_attr:
865 return NULL;
866}
867EXPORT_SYMBOL(vme_dma_pci_attribute);
868
869/*
870 * Create "VME" type attributes
871 */
872struct vme_dma_attr *vme_dma_vme_attribute(unsigned long long address,
Martyn Welch6af04b02011-12-01 17:06:29 +0000873 u32 aspace, u32 cycle, u32 dwidth)
Martyn Welcha17a75e2009-07-31 09:28:17 +0100874{
875 struct vme_dma_attr *attributes;
876 struct vme_dma_vme *vme_attr;
877
Martyn Welchead1f3e2009-12-15 08:43:02 +0000878 attributes = kmalloc(
Martyn Welcha17a75e2009-07-31 09:28:17 +0100879 sizeof(struct vme_dma_attr), GFP_KERNEL);
Martyn Welchead1f3e2009-12-15 08:43:02 +0000880 if (attributes == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700881 printk(KERN_ERR "Unable to allocate memory for attributes structure\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100882 goto err_attr;
883 }
884
Martyn Welchead1f3e2009-12-15 08:43:02 +0000885 vme_attr = kmalloc(sizeof(struct vme_dma_vme), GFP_KERNEL);
886 if (vme_attr == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -0700887 printk(KERN_ERR "Unable to allocate memory for vme attributes\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100888 goto err_vme;
889 }
890
891 attributes->type = VME_DMA_VME;
892 attributes->private = (void *)vme_attr;
893
894 vme_attr->address = address;
895 vme_attr->aspace = aspace;
896 vme_attr->cycle = cycle;
897 vme_attr->dwidth = dwidth;
898
899 return attributes;
900
Martyn Welcha17a75e2009-07-31 09:28:17 +0100901err_vme:
902 kfree(attributes);
903err_attr:
904 return NULL;
905}
906EXPORT_SYMBOL(vme_dma_vme_attribute);
907
908/*
909 * Free attribute
910 */
911void vme_dma_free_attribute(struct vme_dma_attr *attributes)
912{
913 kfree(attributes->private);
914 kfree(attributes);
915}
916EXPORT_SYMBOL(vme_dma_free_attribute);
917
918int vme_dma_list_add(struct vme_dma_list *list, struct vme_dma_attr *src,
919 struct vme_dma_attr *dest, size_t count)
920{
921 struct vme_bridge *bridge = list->parent->parent;
922 int retval;
923
924 if (bridge->dma_list_add == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000925 printk(KERN_WARNING "Link List DMA generation not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100926 return -EINVAL;
927 }
928
Emilio G. Cota886953e2010-11-12 11:14:07 +0000929 if (!mutex_trylock(&list->mtx)) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000930 printk(KERN_ERR "Link List already submitted\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100931 return -EINVAL;
932 }
933
934 retval = bridge->dma_list_add(list, src, dest, count);
935
Emilio G. Cota886953e2010-11-12 11:14:07 +0000936 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100937
938 return retval;
939}
940EXPORT_SYMBOL(vme_dma_list_add);
941
942int vme_dma_list_exec(struct vme_dma_list *list)
943{
944 struct vme_bridge *bridge = list->parent->parent;
945 int retval;
946
947 if (bridge->dma_list_exec == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000948 printk(KERN_ERR "Link List DMA execution not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100949 return -EINVAL;
950 }
951
Emilio G. Cota886953e2010-11-12 11:14:07 +0000952 mutex_lock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100953
954 retval = bridge->dma_list_exec(list);
955
Emilio G. Cota886953e2010-11-12 11:14:07 +0000956 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100957
958 return retval;
959}
960EXPORT_SYMBOL(vme_dma_list_exec);
961
962int vme_dma_list_free(struct vme_dma_list *list)
963{
964 struct vme_bridge *bridge = list->parent->parent;
965 int retval;
966
967 if (bridge->dma_list_empty == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000968 printk(KERN_WARNING "Emptying of Link Lists not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100969 return -EINVAL;
970 }
971
Emilio G. Cota886953e2010-11-12 11:14:07 +0000972 if (!mutex_trylock(&list->mtx)) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000973 printk(KERN_ERR "Link List in use\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +0100974 return -EINVAL;
975 }
976
977 /*
978 * Empty out all of the entries from the dma list. We need to go to the
979 * low level driver as dma entries are driver specific.
980 */
981 retval = bridge->dma_list_empty(list);
982 if (retval) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000983 printk(KERN_ERR "Unable to empty link-list entries\n");
Emilio G. Cota886953e2010-11-12 11:14:07 +0000984 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100985 return retval;
986 }
Emilio G. Cota886953e2010-11-12 11:14:07 +0000987 mutex_unlock(&list->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +0100988 kfree(list);
989
990 return retval;
991}
992EXPORT_SYMBOL(vme_dma_list_free);
993
994int vme_dma_free(struct vme_resource *resource)
995{
996 struct vme_dma_resource *ctrlr;
997
998 if (resource->type != VME_DMA) {
Martyn Welchead1f3e2009-12-15 08:43:02 +0000999 printk(KERN_ERR "Not a DMA resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001000 return -EINVAL;
1001 }
1002
1003 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list);
1004
Emilio G. Cota886953e2010-11-12 11:14:07 +00001005 if (!mutex_trylock(&ctrlr->mtx)) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001006 printk(KERN_ERR "Resource busy, can't free\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001007 return -EBUSY;
1008 }
1009
Emilio G. Cota886953e2010-11-12 11:14:07 +00001010 if (!(list_empty(&ctrlr->pending) && list_empty(&ctrlr->running))) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001011 printk(KERN_WARNING "Resource still processing transfers\n");
Emilio G. Cota886953e2010-11-12 11:14:07 +00001012 mutex_unlock(&ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001013 return -EBUSY;
1014 }
1015
1016 ctrlr->locked = 0;
1017
Emilio G. Cota886953e2010-11-12 11:14:07 +00001018 mutex_unlock(&ctrlr->mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001019
Martyn Welchfd5c2562013-06-06 12:29:16 +01001020 kfree(resource);
1021
Martyn Welcha17a75e2009-07-31 09:28:17 +01001022 return 0;
1023}
1024EXPORT_SYMBOL(vme_dma_free);
1025
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001026void vme_bus_error_handler(struct vme_bridge *bridge,
Dmitry Kalinkin472f16f2015-09-18 02:01:43 +03001027 unsigned long long address, int am)
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001028{
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001029 struct list_head *handler_pos = NULL;
1030 struct vme_error_handler *handler;
Dmitry Kalinkin448535a2015-09-18 02:01:45 +03001031 int handler_triggered = 0;
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001032 u32 aspace = vme_get_aspace(am);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001033
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001034 list_for_each(handler_pos, &bridge->vme_error_handlers) {
1035 handler = list_entry(handler_pos, struct vme_error_handler,
1036 list);
1037 if ((aspace == handler->aspace) &&
1038 (address >= handler->start) &&
1039 (address < handler->end)) {
1040 if (!handler->num_errors)
1041 handler->first_error = address;
1042 if (handler->num_errors != UINT_MAX)
1043 handler->num_errors++;
Dmitry Kalinkin448535a2015-09-18 02:01:45 +03001044 handler_triggered = 1;
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001045 }
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001046 }
Dmitry Kalinkin448535a2015-09-18 02:01:45 +03001047
1048 if (!handler_triggered)
1049 dev_err(bridge->parent,
1050 "Unhandled VME access error at address 0x%llx\n",
1051 address);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001052}
1053EXPORT_SYMBOL(vme_bus_error_handler);
1054
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001055struct vme_error_handler *vme_register_error_handler(
1056 struct vme_bridge *bridge, u32 aspace,
1057 unsigned long long address, size_t len)
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001058{
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001059 struct vme_error_handler *handler;
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001060
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001061 handler = kmalloc(sizeof(*handler), GFP_KERNEL);
1062 if (!handler)
1063 return NULL;
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001064
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001065 handler->aspace = aspace;
1066 handler->start = address;
1067 handler->end = address + len;
1068 handler->num_errors = 0;
1069 handler->first_error = 0;
1070 list_add_tail(&handler->list, &bridge->vme_error_handlers);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001071
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001072 return handler;
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001073}
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001074EXPORT_SYMBOL(vme_register_error_handler);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001075
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001076void vme_unregister_error_handler(struct vme_error_handler *handler)
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001077{
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001078 list_del(&handler->list);
1079 kfree(handler);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001080}
Dmitry Kalinkin0b049662015-09-18 02:01:44 +03001081EXPORT_SYMBOL(vme_unregister_error_handler);
Dmitry Kalinkine2c63932015-09-18 02:01:42 +03001082
Martyn Welchc813f592009-10-29 16:34:54 +00001083void vme_irq_handler(struct vme_bridge *bridge, int level, int statid)
1084{
1085 void (*call)(int, int, void *);
1086 void *priv_data;
1087
1088 call = bridge->irq[level - 1].callback[statid].func;
1089 priv_data = bridge->irq[level - 1].callback[statid].priv_data;
1090
1091 if (call != NULL)
1092 call(level, statid, priv_data);
1093 else
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -07001094 printk(KERN_WARNING "Spurilous VME interrupt, level:%x, vector:%x\n",
1095 level, statid);
Martyn Welchc813f592009-10-29 16:34:54 +00001096}
1097EXPORT_SYMBOL(vme_irq_handler);
1098
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001099int vme_irq_request(struct vme_dev *vdev, int level, int statid,
Martyn Welch29848ac2010-02-18 15:13:05 +00001100 void (*callback)(int, int, void *),
Martyn Welcha17a75e2009-07-31 09:28:17 +01001101 void *priv_data)
1102{
1103 struct vme_bridge *bridge;
1104
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001105 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001106 if (bridge == NULL) {
1107 printk(KERN_ERR "Can't find VME bus\n");
1108 return -EINVAL;
1109 }
1110
Martyn Welchead1f3e2009-12-15 08:43:02 +00001111 if ((level < 1) || (level > 7)) {
Martyn Welchc813f592009-10-29 16:34:54 +00001112 printk(KERN_ERR "Invalid interrupt level\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001113 return -EINVAL;
1114 }
1115
Martyn Welchc813f592009-10-29 16:34:54 +00001116 if (bridge->irq_set == NULL) {
1117 printk(KERN_ERR "Configuring interrupts not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001118 return -EINVAL;
1119 }
1120
Emilio G. Cota886953e2010-11-12 11:14:07 +00001121 mutex_lock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001122
1123 if (bridge->irq[level - 1].callback[statid].func) {
Emilio G. Cota886953e2010-11-12 11:14:07 +00001124 mutex_unlock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001125 printk(KERN_WARNING "VME Interrupt already taken\n");
1126 return -EBUSY;
1127 }
1128
1129 bridge->irq[level - 1].count++;
1130 bridge->irq[level - 1].callback[statid].priv_data = priv_data;
1131 bridge->irq[level - 1].callback[statid].func = callback;
1132
1133 /* Enable IRQ level */
Martyn Welch29848ac2010-02-18 15:13:05 +00001134 bridge->irq_set(bridge, level, 1, 1);
Martyn Welchc813f592009-10-29 16:34:54 +00001135
Emilio G. Cota886953e2010-11-12 11:14:07 +00001136 mutex_unlock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001137
1138 return 0;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001139}
Martyn Welchc813f592009-10-29 16:34:54 +00001140EXPORT_SYMBOL(vme_irq_request);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001141
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001142void vme_irq_free(struct vme_dev *vdev, int level, int statid)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001143{
1144 struct vme_bridge *bridge;
1145
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001146 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001147 if (bridge == NULL) {
1148 printk(KERN_ERR "Can't find VME bus\n");
1149 return;
1150 }
1151
Martyn Welchead1f3e2009-12-15 08:43:02 +00001152 if ((level < 1) || (level > 7)) {
Martyn Welchc813f592009-10-29 16:34:54 +00001153 printk(KERN_ERR "Invalid interrupt level\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001154 return;
1155 }
1156
Martyn Welchc813f592009-10-29 16:34:54 +00001157 if (bridge->irq_set == NULL) {
1158 printk(KERN_ERR "Configuring interrupts not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001159 return;
1160 }
1161
Emilio G. Cota886953e2010-11-12 11:14:07 +00001162 mutex_lock(&bridge->irq_mtx);
Martyn Welchc813f592009-10-29 16:34:54 +00001163
1164 bridge->irq[level - 1].count--;
1165
1166 /* Disable IRQ level if no more interrupts attached at this level*/
1167 if (bridge->irq[level - 1].count == 0)
Martyn Welch29848ac2010-02-18 15:13:05 +00001168 bridge->irq_set(bridge, level, 0, 1);
Martyn Welchc813f592009-10-29 16:34:54 +00001169
1170 bridge->irq[level - 1].callback[statid].func = NULL;
1171 bridge->irq[level - 1].callback[statid].priv_data = NULL;
1172
Emilio G. Cota886953e2010-11-12 11:14:07 +00001173 mutex_unlock(&bridge->irq_mtx);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001174}
Martyn Welchc813f592009-10-29 16:34:54 +00001175EXPORT_SYMBOL(vme_irq_free);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001176
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001177int vme_irq_generate(struct vme_dev *vdev, int level, int statid)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001178{
1179 struct vme_bridge *bridge;
1180
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001181 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001182 if (bridge == NULL) {
1183 printk(KERN_ERR "Can't find VME bus\n");
1184 return -EINVAL;
1185 }
1186
Martyn Welchead1f3e2009-12-15 08:43:02 +00001187 if ((level < 1) || (level > 7)) {
Martyn Welcha17a75e2009-07-31 09:28:17 +01001188 printk(KERN_WARNING "Invalid interrupt level\n");
1189 return -EINVAL;
1190 }
1191
Martyn Welchc813f592009-10-29 16:34:54 +00001192 if (bridge->irq_generate == NULL) {
Martyn Welchead1f3e2009-12-15 08:43:02 +00001193 printk(KERN_WARNING "Interrupt generation not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001194 return -EINVAL;
1195 }
1196
Martyn Welch29848ac2010-02-18 15:13:05 +00001197 return bridge->irq_generate(bridge, level, statid);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001198}
Martyn Welchc813f592009-10-29 16:34:54 +00001199EXPORT_SYMBOL(vme_irq_generate);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001200
Martyn Welch42fb5032009-08-11 17:44:56 +01001201/*
1202 * Request the location monitor, return resource or NULL
1203 */
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001204struct vme_resource *vme_lm_request(struct vme_dev *vdev)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001205{
1206 struct vme_bridge *bridge;
Martyn Welch42fb5032009-08-11 17:44:56 +01001207 struct list_head *lm_pos = NULL;
1208 struct vme_lm_resource *allocated_lm = NULL;
1209 struct vme_lm_resource *lm = NULL;
1210 struct vme_resource *resource = NULL;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001211
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001212 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001213 if (bridge == NULL) {
1214 printk(KERN_ERR "Can't find VME bus\n");
Martyn Welch42fb5032009-08-11 17:44:56 +01001215 goto err_bus;
1216 }
1217
1218 /* Loop through DMA resources */
Emilio G. Cota886953e2010-11-12 11:14:07 +00001219 list_for_each(lm_pos, &bridge->lm_resources) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001220 lm = list_entry(lm_pos,
1221 struct vme_lm_resource, list);
1222
1223 if (lm == NULL) {
Greg Kroah-Hartman25958ce2012-04-25 11:25:46 -07001224 printk(KERN_ERR "Registered NULL Location Monitor resource\n");
Martyn Welch42fb5032009-08-11 17:44:56 +01001225 continue;
1226 }
1227
1228 /* Find an unlocked controller */
Emilio G. Cota886953e2010-11-12 11:14:07 +00001229 mutex_lock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001230 if (lm->locked == 0) {
1231 lm->locked = 1;
Emilio G. Cota886953e2010-11-12 11:14:07 +00001232 mutex_unlock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001233 allocated_lm = lm;
1234 break;
1235 }
Emilio G. Cota886953e2010-11-12 11:14:07 +00001236 mutex_unlock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001237 }
1238
1239 /* Check to see if we found a resource */
1240 if (allocated_lm == NULL)
1241 goto err_lm;
1242
1243 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL);
1244 if (resource == NULL) {
1245 printk(KERN_ERR "Unable to allocate resource structure\n");
1246 goto err_alloc;
1247 }
1248 resource->type = VME_LM;
Emilio G. Cota886953e2010-11-12 11:14:07 +00001249 resource->entry = &allocated_lm->list;
Martyn Welch42fb5032009-08-11 17:44:56 +01001250
1251 return resource;
1252
1253err_alloc:
1254 /* Unlock image */
Emilio G. Cota886953e2010-11-12 11:14:07 +00001255 mutex_lock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001256 lm->locked = 0;
Emilio G. Cota886953e2010-11-12 11:14:07 +00001257 mutex_unlock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001258err_lm:
1259err_bus:
1260 return NULL;
1261}
1262EXPORT_SYMBOL(vme_lm_request);
1263
1264int vme_lm_count(struct vme_resource *resource)
1265{
1266 struct vme_lm_resource *lm;
1267
1268 if (resource->type != VME_LM) {
1269 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001270 return -EINVAL;
1271 }
1272
Martyn Welch42fb5032009-08-11 17:44:56 +01001273 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1274
1275 return lm->monitors;
1276}
1277EXPORT_SYMBOL(vme_lm_count);
1278
1279int vme_lm_set(struct vme_resource *resource, unsigned long long lm_base,
Martyn Welch6af04b02011-12-01 17:06:29 +00001280 u32 aspace, u32 cycle)
Martyn Welch42fb5032009-08-11 17:44:56 +01001281{
1282 struct vme_bridge *bridge = find_bridge(resource);
1283 struct vme_lm_resource *lm;
1284
1285 if (resource->type != VME_LM) {
1286 printk(KERN_ERR "Not a Location Monitor resource\n");
1287 return -EINVAL;
1288 }
1289
1290 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1291
Martyn Welcha17a75e2009-07-31 09:28:17 +01001292 if (bridge->lm_set == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001293 printk(KERN_ERR "vme_lm_set not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001294 return -EINVAL;
1295 }
1296
Martyn Welch8be92262009-10-29 16:35:08 +00001297 return bridge->lm_set(lm, lm_base, aspace, cycle);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001298}
1299EXPORT_SYMBOL(vme_lm_set);
1300
Martyn Welch42fb5032009-08-11 17:44:56 +01001301int vme_lm_get(struct vme_resource *resource, unsigned long long *lm_base,
Martyn Welch6af04b02011-12-01 17:06:29 +00001302 u32 *aspace, u32 *cycle)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001303{
Martyn Welch42fb5032009-08-11 17:44:56 +01001304 struct vme_bridge *bridge = find_bridge(resource);
1305 struct vme_lm_resource *lm;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001306
Martyn Welch42fb5032009-08-11 17:44:56 +01001307 if (resource->type != VME_LM) {
1308 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001309 return -EINVAL;
1310 }
1311
Martyn Welch42fb5032009-08-11 17:44:56 +01001312 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1313
Martyn Welcha17a75e2009-07-31 09:28:17 +01001314 if (bridge->lm_get == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001315 printk(KERN_ERR "vme_lm_get not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001316 return -EINVAL;
1317 }
1318
Martyn Welch42fb5032009-08-11 17:44:56 +01001319 return bridge->lm_get(lm, lm_base, aspace, cycle);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001320}
1321EXPORT_SYMBOL(vme_lm_get);
1322
Martyn Welch42fb5032009-08-11 17:44:56 +01001323int vme_lm_attach(struct vme_resource *resource, int monitor,
1324 void (*callback)(int))
Martyn Welcha17a75e2009-07-31 09:28:17 +01001325{
Martyn Welch42fb5032009-08-11 17:44:56 +01001326 struct vme_bridge *bridge = find_bridge(resource);
1327 struct vme_lm_resource *lm;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001328
Martyn Welch42fb5032009-08-11 17:44:56 +01001329 if (resource->type != VME_LM) {
1330 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001331 return -EINVAL;
1332 }
1333
Martyn Welch42fb5032009-08-11 17:44:56 +01001334 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1335
Martyn Welcha17a75e2009-07-31 09:28:17 +01001336 if (bridge->lm_attach == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001337 printk(KERN_ERR "vme_lm_attach not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001338 return -EINVAL;
1339 }
1340
Martyn Welch42fb5032009-08-11 17:44:56 +01001341 return bridge->lm_attach(lm, monitor, callback);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001342}
1343EXPORT_SYMBOL(vme_lm_attach);
1344
Martyn Welch42fb5032009-08-11 17:44:56 +01001345int vme_lm_detach(struct vme_resource *resource, int monitor)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001346{
Martyn Welch42fb5032009-08-11 17:44:56 +01001347 struct vme_bridge *bridge = find_bridge(resource);
1348 struct vme_lm_resource *lm;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001349
Martyn Welch42fb5032009-08-11 17:44:56 +01001350 if (resource->type != VME_LM) {
1351 printk(KERN_ERR "Not a Location Monitor resource\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001352 return -EINVAL;
1353 }
1354
Martyn Welch42fb5032009-08-11 17:44:56 +01001355 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1356
Martyn Welcha17a75e2009-07-31 09:28:17 +01001357 if (bridge->lm_detach == NULL) {
Martyn Welch42fb5032009-08-11 17:44:56 +01001358 printk(KERN_ERR "vme_lm_detach not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001359 return -EINVAL;
1360 }
1361
Martyn Welch42fb5032009-08-11 17:44:56 +01001362 return bridge->lm_detach(lm, monitor);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001363}
1364EXPORT_SYMBOL(vme_lm_detach);
1365
Martyn Welch42fb5032009-08-11 17:44:56 +01001366void vme_lm_free(struct vme_resource *resource)
1367{
1368 struct vme_lm_resource *lm;
1369
1370 if (resource->type != VME_LM) {
1371 printk(KERN_ERR "Not a Location Monitor resource\n");
1372 return;
1373 }
1374
1375 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1376
Emilio G. Cota886953e2010-11-12 11:14:07 +00001377 mutex_lock(&lm->mtx);
Martyn Welch42fb5032009-08-11 17:44:56 +01001378
Martyn Welch8be92262009-10-29 16:35:08 +00001379 /* XXX
1380 * Check to see that there aren't any callbacks still attached, if
1381 * there are we should probably be detaching them!
1382 */
Martyn Welch42fb5032009-08-11 17:44:56 +01001383
1384 lm->locked = 0;
1385
Emilio G. Cota886953e2010-11-12 11:14:07 +00001386 mutex_unlock(&lm->mtx);
Martyn Welch8be92262009-10-29 16:35:08 +00001387
1388 kfree(resource);
Martyn Welch42fb5032009-08-11 17:44:56 +01001389}
1390EXPORT_SYMBOL(vme_lm_free);
1391
Martyn Welchd7729f02013-11-08 11:58:35 +00001392int vme_slot_num(struct vme_dev *vdev)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001393{
1394 struct vme_bridge *bridge;
1395
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001396 bridge = vdev->bridge;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001397 if (bridge == NULL) {
1398 printk(KERN_ERR "Can't find VME bus\n");
1399 return -EINVAL;
1400 }
1401
1402 if (bridge->slot_get == NULL) {
Martyn Welchd7729f02013-11-08 11:58:35 +00001403 printk(KERN_WARNING "vme_slot_num not supported\n");
Martyn Welcha17a75e2009-07-31 09:28:17 +01001404 return -EINVAL;
1405 }
1406
Martyn Welch29848ac2010-02-18 15:13:05 +00001407 return bridge->slot_get(bridge);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001408}
Martyn Welchd7729f02013-11-08 11:58:35 +00001409EXPORT_SYMBOL(vme_slot_num);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001410
Martyn Welch978f47d2013-11-08 11:58:34 +00001411int vme_bus_num(struct vme_dev *vdev)
1412{
1413 struct vme_bridge *bridge;
1414
1415 bridge = vdev->bridge;
1416 if (bridge == NULL) {
1417 pr_err("Can't find VME bus\n");
1418 return -EINVAL;
1419 }
1420
1421 return bridge->num;
1422}
1423EXPORT_SYMBOL(vme_bus_num);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001424
1425/* - Bridge Registration --------------------------------------------------- */
1426
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001427static void vme_dev_release(struct device *dev)
1428{
1429 kfree(dev_to_vme_dev(dev));
1430}
1431
1432int vme_register_bridge(struct vme_bridge *bridge)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001433{
1434 int i;
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001435 int ret = -1;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001436
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001437 mutex_lock(&vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001438 for (i = 0; i < sizeof(vme_bus_numbers) * 8; i++) {
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001439 if ((vme_bus_numbers & (1 << i)) == 0) {
1440 vme_bus_numbers |= (1 << i);
1441 bridge->num = i;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001442 INIT_LIST_HEAD(&bridge->devices);
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001443 list_add_tail(&bridge->bus_list, &vme_bus_list);
1444 ret = 0;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001445 break;
1446 }
1447 }
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001448 mutex_unlock(&vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001449
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001450 return ret;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001451}
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001452EXPORT_SYMBOL(vme_register_bridge);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001453
Manohar Vanga5b93c2a2011-11-04 11:12:30 +01001454void vme_unregister_bridge(struct vme_bridge *bridge)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001455{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001456 struct vme_dev *vdev;
1457 struct vme_dev *tmp;
1458
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001459 mutex_lock(&vme_buses_lock);
1460 vme_bus_numbers &= ~(1 << bridge->num);
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001461 list_for_each_entry_safe(vdev, tmp, &bridge->devices, bridge_list) {
1462 list_del(&vdev->drv_list);
1463 list_del(&vdev->bridge_list);
1464 device_unregister(&vdev->dev);
1465 }
Manohar Vanga733e3ef2011-08-12 12:30:48 +02001466 list_del(&bridge->bus_list);
1467 mutex_unlock(&vme_buses_lock);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001468}
Martyn Welcha17a75e2009-07-31 09:28:17 +01001469EXPORT_SYMBOL(vme_unregister_bridge);
1470
Martyn Welcha17a75e2009-07-31 09:28:17 +01001471/* - Driver Registration --------------------------------------------------- */
1472
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001473static int __vme_register_driver_bus(struct vme_driver *drv,
1474 struct vme_bridge *bridge, unsigned int ndevs)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001475{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001476 int err;
1477 unsigned int i;
1478 struct vme_dev *vdev;
1479 struct vme_dev *tmp;
1480
1481 for (i = 0; i < ndevs; i++) {
1482 vdev = kzalloc(sizeof(struct vme_dev), GFP_KERNEL);
1483 if (!vdev) {
1484 err = -ENOMEM;
1485 goto err_devalloc;
1486 }
Manohar Vangaa916a392011-09-26 11:27:17 +02001487 vdev->num = i;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001488 vdev->bridge = bridge;
1489 vdev->dev.platform_data = drv;
1490 vdev->dev.release = vme_dev_release;
1491 vdev->dev.parent = bridge->parent;
1492 vdev->dev.bus = &vme_bus_type;
Manohar Vangaa916a392011-09-26 11:27:17 +02001493 dev_set_name(&vdev->dev, "%s.%u-%u", drv->name, bridge->num,
1494 vdev->num);
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001495
1496 err = device_register(&vdev->dev);
1497 if (err)
1498 goto err_reg;
1499
1500 if (vdev->dev.platform_data) {
1501 list_add_tail(&vdev->drv_list, &drv->devices);
1502 list_add_tail(&vdev->bridge_list, &bridge->devices);
1503 } else
1504 device_unregister(&vdev->dev);
1505 }
1506 return 0;
1507
1508err_reg:
Emilio G. Cotadef18202013-02-13 13:47:54 -05001509 put_device(&vdev->dev);
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001510 kfree(vdev);
1511err_devalloc:
1512 list_for_each_entry_safe(vdev, tmp, &drv->devices, drv_list) {
1513 list_del(&vdev->drv_list);
1514 list_del(&vdev->bridge_list);
1515 device_unregister(&vdev->dev);
1516 }
1517 return err;
1518}
1519
1520static int __vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1521{
1522 struct vme_bridge *bridge;
1523 int err = 0;
1524
1525 mutex_lock(&vme_buses_lock);
1526 list_for_each_entry(bridge, &vme_bus_list, bus_list) {
1527 /*
1528 * This cannot cause trouble as we already have vme_buses_lock
1529 * and if the bridge is removed, it will have to go through
1530 * vme_unregister_bridge() to do it (which calls remove() on
1531 * the bridge which in turn tries to acquire vme_buses_lock and
Manohar Vangac26f6112011-11-04 11:12:29 +01001532 * will have to wait).
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001533 */
1534 err = __vme_register_driver_bus(drv, bridge, ndevs);
1535 if (err)
1536 break;
1537 }
1538 mutex_unlock(&vme_buses_lock);
1539 return err;
1540}
1541
1542int vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1543{
1544 int err;
1545
Martyn Welcha17a75e2009-07-31 09:28:17 +01001546 drv->driver.name = drv->name;
1547 drv->driver.bus = &vme_bus_type;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001548 INIT_LIST_HEAD(&drv->devices);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001549
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001550 err = driver_register(&drv->driver);
1551 if (err)
1552 return err;
1553
1554 err = __vme_register_driver(drv, ndevs);
1555 if (err)
1556 driver_unregister(&drv->driver);
1557
1558 return err;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001559}
1560EXPORT_SYMBOL(vme_register_driver);
1561
Martyn Welchead1f3e2009-12-15 08:43:02 +00001562void vme_unregister_driver(struct vme_driver *drv)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001563{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001564 struct vme_dev *dev, *dev_tmp;
1565
1566 mutex_lock(&vme_buses_lock);
1567 list_for_each_entry_safe(dev, dev_tmp, &drv->devices, drv_list) {
1568 list_del(&dev->drv_list);
1569 list_del(&dev->bridge_list);
1570 device_unregister(&dev->dev);
1571 }
1572 mutex_unlock(&vme_buses_lock);
1573
Martyn Welcha17a75e2009-07-31 09:28:17 +01001574 driver_unregister(&drv->driver);
1575}
1576EXPORT_SYMBOL(vme_unregister_driver);
1577
1578/* - Bus Registration ------------------------------------------------------ */
1579
Martyn Welcha17a75e2009-07-31 09:28:17 +01001580static int vme_bus_match(struct device *dev, struct device_driver *drv)
1581{
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001582 struct vme_driver *vme_drv;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001583
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001584 vme_drv = container_of(drv, struct vme_driver, driver);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001585
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001586 if (dev->platform_data == vme_drv) {
1587 struct vme_dev *vdev = dev_to_vme_dev(dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001588
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001589 if (vme_drv->match && vme_drv->match(vdev))
1590 return 1;
1591
1592 dev->platform_data = NULL;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001593 }
Martyn Welcha17a75e2009-07-31 09:28:17 +01001594 return 0;
1595}
1596
1597static int vme_bus_probe(struct device *dev)
1598{
Martyn Welcha17a75e2009-07-31 09:28:17 +01001599 int retval = -ENODEV;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001600 struct vme_driver *driver;
1601 struct vme_dev *vdev = dev_to_vme_dev(dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001602
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001603 driver = dev->platform_data;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001604
Martyn Welchead1f3e2009-12-15 08:43:02 +00001605 if (driver->probe != NULL)
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001606 retval = driver->probe(vdev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001607
1608 return retval;
1609}
1610
1611static int vme_bus_remove(struct device *dev)
1612{
Martyn Welcha17a75e2009-07-31 09:28:17 +01001613 int retval = -ENODEV;
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001614 struct vme_driver *driver;
1615 struct vme_dev *vdev = dev_to_vme_dev(dev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001616
Manohar Vanga5d6abf32011-09-26 11:27:16 +02001617 driver = dev->platform_data;
Martyn Welcha17a75e2009-07-31 09:28:17 +01001618
Martyn Welchead1f3e2009-12-15 08:43:02 +00001619 if (driver->remove != NULL)
Manohar Vanga8f966dc2011-09-26 11:27:15 +02001620 retval = driver->remove(vdev);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001621
1622 return retval;
1623}
1624
1625struct bus_type vme_bus_type = {
1626 .name = "vme",
1627 .match = vme_bus_match,
1628 .probe = vme_bus_probe,
1629 .remove = vme_bus_remove,
1630};
1631EXPORT_SYMBOL(vme_bus_type);
1632
Martyn Welchead1f3e2009-12-15 08:43:02 +00001633static int __init vme_init(void)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001634{
1635 return bus_register(&vme_bus_type);
1636}
1637
Martyn Welchead1f3e2009-12-15 08:43:02 +00001638static void __exit vme_exit(void)
Martyn Welcha17a75e2009-07-31 09:28:17 +01001639{
1640 bus_unregister(&vme_bus_type);
1641}
1642
Aaron Sierrac326cc02013-12-09 09:54:42 -06001643subsys_initcall(vme_init);
Martyn Welcha17a75e2009-07-31 09:28:17 +01001644module_exit(vme_exit);