Loading...
Note: File does not exist in v6.8.
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * VME Bridge Framework
4 *
5 * Author: Martyn Welch <martyn.welch@ge.com>
6 * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
7 *
8 * Based on work by Tom Armistead and Ajit Prem
9 * Copyright 2004 Motorola Inc.
10 */
11
12#include <linux/init.h>
13#include <linux/export.h>
14#include <linux/mm.h>
15#include <linux/types.h>
16#include <linux/kernel.h>
17#include <linux/errno.h>
18#include <linux/pci.h>
19#include <linux/poll.h>
20#include <linux/highmem.h>
21#include <linux/interrupt.h>
22#include <linux/pagemap.h>
23#include <linux/device.h>
24#include <linux/dma-mapping.h>
25#include <linux/syscalls.h>
26#include <linux/mutex.h>
27#include <linux/spinlock.h>
28#include <linux/slab.h>
29#include <linux/vme.h>
30
31#include "vme_bridge.h"
32
33/* Bitmask and list of registered buses both protected by common mutex */
34static unsigned int vme_bus_numbers;
35static LIST_HEAD(vme_bus_list);
36static DEFINE_MUTEX(vme_buses_lock);
37
38static int __init vme_init(void);
39
40static struct vme_dev *dev_to_vme_dev(struct device *dev)
41{
42 return container_of(dev, struct vme_dev, dev);
43}
44
45/*
46 * Find the bridge that the resource is associated with.
47 */
48static struct vme_bridge *find_bridge(struct vme_resource *resource)
49{
50 /* Get list to search */
51 switch (resource->type) {
52 case VME_MASTER:
53 return list_entry(resource->entry, struct vme_master_resource,
54 list)->parent;
55 break;
56 case VME_SLAVE:
57 return list_entry(resource->entry, struct vme_slave_resource,
58 list)->parent;
59 break;
60 case VME_DMA:
61 return list_entry(resource->entry, struct vme_dma_resource,
62 list)->parent;
63 break;
64 case VME_LM:
65 return list_entry(resource->entry, struct vme_lm_resource,
66 list)->parent;
67 break;
68 default:
69 printk(KERN_ERR "Unknown resource type\n");
70 return NULL;
71 break;
72 }
73}
74
75/**
76 * vme_free_consistent - Allocate contiguous memory.
77 * @resource: Pointer to VME resource.
78 * @size: Size of allocation required.
79 * @dma: Pointer to variable to store physical address of allocation.
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.
83 *
84 * Return: Virtual address of allocation on success, NULL on failure.
85 */
86void *vme_alloc_consistent(struct vme_resource *resource, size_t size,
87 dma_addr_t *dma)
88{
89 struct vme_bridge *bridge;
90
91 if (!resource) {
92 printk(KERN_ERR "No resource\n");
93 return NULL;
94 }
95
96 bridge = find_bridge(resource);
97 if (!bridge) {
98 printk(KERN_ERR "Can't find bridge\n");
99 return NULL;
100 }
101
102 if (!bridge->parent) {
103 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
104 return NULL;
105 }
106
107 if (!bridge->alloc_consistent) {
108 printk(KERN_ERR "alloc_consistent not supported by bridge %s\n",
109 bridge->name);
110 return NULL;
111 }
112
113 return bridge->alloc_consistent(bridge->parent, size, dma);
114}
115EXPORT_SYMBOL(vme_alloc_consistent);
116
117/**
118 * vme_free_consistent - Free previously allocated memory.
119 * @resource: Pointer to VME resource.
120 * @size: Size of allocation to free.
121 * @vaddr: Virtual address of allocation.
122 * @dma: Physical address of allocation.
123 *
124 * Free previously allocated block of contiguous memory.
125 */
126void vme_free_consistent(struct vme_resource *resource, size_t size,
127 void *vaddr, dma_addr_t dma)
128{
129 struct vme_bridge *bridge;
130
131 if (!resource) {
132 printk(KERN_ERR "No resource\n");
133 return;
134 }
135
136 bridge = find_bridge(resource);
137 if (!bridge) {
138 printk(KERN_ERR "Can't find bridge\n");
139 return;
140 }
141
142 if (!bridge->parent) {
143 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
144 return;
145 }
146
147 if (!bridge->free_consistent) {
148 printk(KERN_ERR "free_consistent not supported by bridge %s\n",
149 bridge->name);
150 return;
151 }
152
153 bridge->free_consistent(bridge->parent, size, vaddr, dma);
154}
155EXPORT_SYMBOL(vme_free_consistent);
156
157/**
158 * vme_get_size - Helper function returning size of a VME window
159 * @resource: Pointer to VME slave or master resource.
160 *
161 * Determine the size of the VME window provided. This is a helper
162 * function, wrappering the call to vme_master_get or vme_slave_get
163 * depending on the type of window resource handed to it.
164 *
165 * Return: Size of the window on success, zero on failure.
166 */
167size_t vme_get_size(struct vme_resource *resource)
168{
169 int enabled, retval;
170 unsigned long long base, size;
171 dma_addr_t buf_base;
172 u32 aspace, cycle, dwidth;
173
174 switch (resource->type) {
175 case VME_MASTER:
176 retval = vme_master_get(resource, &enabled, &base, &size,
177 &aspace, &cycle, &dwidth);
178 if (retval)
179 return 0;
180
181 return size;
182 break;
183 case VME_SLAVE:
184 retval = vme_slave_get(resource, &enabled, &base, &size,
185 &buf_base, &aspace, &cycle);
186 if (retval)
187 return 0;
188
189 return size;
190 break;
191 case VME_DMA:
192 return 0;
193 break;
194 default:
195 printk(KERN_ERR "Unknown resource type\n");
196 return 0;
197 break;
198 }
199}
200EXPORT_SYMBOL(vme_get_size);
201
202int vme_check_window(u32 aspace, unsigned long long vme_base,
203 unsigned long long size)
204{
205 int retval = 0;
206
207 if (vme_base + size < size)
208 return -EINVAL;
209
210 switch (aspace) {
211 case VME_A16:
212 if (vme_base + size > VME_A16_MAX)
213 retval = -EFAULT;
214 break;
215 case VME_A24:
216 if (vme_base + size > VME_A24_MAX)
217 retval = -EFAULT;
218 break;
219 case VME_A32:
220 if (vme_base + size > VME_A32_MAX)
221 retval = -EFAULT;
222 break;
223 case VME_A64:
224 /* The VME_A64_MAX limit is actually U64_MAX + 1 */
225 break;
226 case VME_CRCSR:
227 if (vme_base + size > VME_CRCSR_MAX)
228 retval = -EFAULT;
229 break;
230 case VME_USER1:
231 case VME_USER2:
232 case VME_USER3:
233 case VME_USER4:
234 /* User Defined */
235 break;
236 default:
237 printk(KERN_ERR "Invalid address space\n");
238 retval = -EINVAL;
239 break;
240 }
241
242 return retval;
243}
244EXPORT_SYMBOL(vme_check_window);
245
246static u32 vme_get_aspace(int am)
247{
248 switch (am) {
249 case 0x29:
250 case 0x2D:
251 return VME_A16;
252 case 0x38:
253 case 0x39:
254 case 0x3A:
255 case 0x3B:
256 case 0x3C:
257 case 0x3D:
258 case 0x3E:
259 case 0x3F:
260 return VME_A24;
261 case 0x8:
262 case 0x9:
263 case 0xA:
264 case 0xB:
265 case 0xC:
266 case 0xD:
267 case 0xE:
268 case 0xF:
269 return VME_A32;
270 case 0x0:
271 case 0x1:
272 case 0x3:
273 return VME_A64;
274 }
275
276 return 0;
277}
278
279/**
280 * vme_slave_request - Request a VME slave window resource.
281 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
282 * @address: Required VME address space.
283 * @cycle: Required VME data transfer cycle type.
284 *
285 * Request use of a VME window resource capable of being set for the requested
286 * address space and data transfer cycle.
287 *
288 * Return: Pointer to VME resource on success, NULL on failure.
289 */
290struct vme_resource *vme_slave_request(struct vme_dev *vdev, u32 address,
291 u32 cycle)
292{
293 struct vme_bridge *bridge;
294 struct list_head *slave_pos = NULL;
295 struct vme_slave_resource *allocated_image = NULL;
296 struct vme_slave_resource *slave_image = NULL;
297 struct vme_resource *resource = NULL;
298
299 bridge = vdev->bridge;
300 if (!bridge) {
301 printk(KERN_ERR "Can't find VME bus\n");
302 goto err_bus;
303 }
304
305 /* Loop through slave resources */
306 list_for_each(slave_pos, &bridge->slave_resources) {
307 slave_image = list_entry(slave_pos,
308 struct vme_slave_resource, list);
309
310 if (!slave_image) {
311 printk(KERN_ERR "Registered NULL Slave resource\n");
312 continue;
313 }
314
315 /* Find an unlocked and compatible image */
316 mutex_lock(&slave_image->mtx);
317 if (((slave_image->address_attr & address) == address) &&
318 ((slave_image->cycle_attr & cycle) == cycle) &&
319 (slave_image->locked == 0)) {
320
321 slave_image->locked = 1;
322 mutex_unlock(&slave_image->mtx);
323 allocated_image = slave_image;
324 break;
325 }
326 mutex_unlock(&slave_image->mtx);
327 }
328
329 /* No free image */
330 if (!allocated_image)
331 goto err_image;
332
333 resource = kmalloc(sizeof(*resource), GFP_KERNEL);
334 if (!resource)
335 goto err_alloc;
336
337 resource->type = VME_SLAVE;
338 resource->entry = &allocated_image->list;
339
340 return resource;
341
342err_alloc:
343 /* Unlock image */
344 mutex_lock(&slave_image->mtx);
345 slave_image->locked = 0;
346 mutex_unlock(&slave_image->mtx);
347err_image:
348err_bus:
349 return NULL;
350}
351EXPORT_SYMBOL(vme_slave_request);
352
353/**
354 * vme_slave_set - Set VME slave window configuration.
355 * @resource: Pointer to VME slave resource.
356 * @enabled: State to which the window should be configured.
357 * @vme_base: Base address for the window.
358 * @size: Size of the VME window.
359 * @buf_base: Based address of buffer used to provide VME slave window storage.
360 * @aspace: VME address space for the VME window.
361 * @cycle: VME data transfer cycle type for the VME window.
362 *
363 * Set configuration for provided VME slave window.
364 *
365 * Return: Zero on success, -EINVAL if operation is not supported on this
366 * device, if an invalid resource has been provided or invalid
367 * attributes are provided. Hardware specific errors may also be
368 * returned.
369 */
370int vme_slave_set(struct vme_resource *resource, int enabled,
371 unsigned long long vme_base, unsigned long long size,
372 dma_addr_t buf_base, u32 aspace, u32 cycle)
373{
374 struct vme_bridge *bridge = find_bridge(resource);
375 struct vme_slave_resource *image;
376 int retval;
377
378 if (resource->type != VME_SLAVE) {
379 printk(KERN_ERR "Not a slave resource\n");
380 return -EINVAL;
381 }
382
383 image = list_entry(resource->entry, struct vme_slave_resource, list);
384
385 if (!bridge->slave_set) {
386 printk(KERN_ERR "Function not supported\n");
387 return -ENOSYS;
388 }
389
390 if (!(((image->address_attr & aspace) == aspace) &&
391 ((image->cycle_attr & cycle) == cycle))) {
392 printk(KERN_ERR "Invalid attributes\n");
393 return -EINVAL;
394 }
395
396 retval = vme_check_window(aspace, vme_base, size);
397 if (retval)
398 return retval;
399
400 return bridge->slave_set(image, enabled, vme_base, size, buf_base,
401 aspace, cycle);
402}
403EXPORT_SYMBOL(vme_slave_set);
404
405/**
406 * vme_slave_get - Retrieve VME slave window configuration.
407 * @resource: Pointer to VME slave resource.
408 * @enabled: Pointer to variable for storing state.
409 * @vme_base: Pointer to variable for storing window base address.
410 * @size: Pointer to variable for storing window size.
411 * @buf_base: Pointer to variable for storing slave buffer base address.
412 * @aspace: Pointer to variable for storing VME address space.
413 * @cycle: Pointer to variable for storing VME data transfer cycle type.
414 *
415 * Return configuration for provided VME slave window.
416 *
417 * Return: Zero on success, -EINVAL if operation is not supported on this
418 * device or if an invalid resource has been provided.
419 */
420int vme_slave_get(struct vme_resource *resource, int *enabled,
421 unsigned long long *vme_base, unsigned long long *size,
422 dma_addr_t *buf_base, u32 *aspace, u32 *cycle)
423{
424 struct vme_bridge *bridge = find_bridge(resource);
425 struct vme_slave_resource *image;
426
427 if (resource->type != VME_SLAVE) {
428 printk(KERN_ERR "Not a slave resource\n");
429 return -EINVAL;
430 }
431
432 image = list_entry(resource->entry, struct vme_slave_resource, list);
433
434 if (!bridge->slave_get) {
435 printk(KERN_ERR "vme_slave_get not supported\n");
436 return -EINVAL;
437 }
438
439 return bridge->slave_get(image, enabled, vme_base, size, buf_base,
440 aspace, cycle);
441}
442EXPORT_SYMBOL(vme_slave_get);
443
444/**
445 * vme_slave_free - Free VME slave window
446 * @resource: Pointer to VME slave resource.
447 *
448 * Free the provided slave resource so that it may be reallocated.
449 */
450void vme_slave_free(struct vme_resource *resource)
451{
452 struct vme_slave_resource *slave_image;
453
454 if (resource->type != VME_SLAVE) {
455 printk(KERN_ERR "Not a slave resource\n");
456 return;
457 }
458
459 slave_image = list_entry(resource->entry, struct vme_slave_resource,
460 list);
461 if (!slave_image) {
462 printk(KERN_ERR "Can't find slave resource\n");
463 return;
464 }
465
466 /* Unlock image */
467 mutex_lock(&slave_image->mtx);
468 if (slave_image->locked == 0)
469 printk(KERN_ERR "Image is already free\n");
470
471 slave_image->locked = 0;
472 mutex_unlock(&slave_image->mtx);
473
474 /* Free up resource memory */
475 kfree(resource);
476}
477EXPORT_SYMBOL(vme_slave_free);
478
479/**
480 * vme_master_request - Request a VME master window resource.
481 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
482 * @address: Required VME address space.
483 * @cycle: Required VME data transfer cycle type.
484 * @dwidth: Required VME data transfer width.
485 *
486 * Request use of a VME window resource capable of being set for the requested
487 * address space, data transfer cycle and width.
488 *
489 * Return: Pointer to VME resource on success, NULL on failure.
490 */
491struct vme_resource *vme_master_request(struct vme_dev *vdev, u32 address,
492 u32 cycle, u32 dwidth)
493{
494 struct vme_bridge *bridge;
495 struct list_head *master_pos = NULL;
496 struct vme_master_resource *allocated_image = NULL;
497 struct vme_master_resource *master_image = NULL;
498 struct vme_resource *resource = NULL;
499
500 bridge = vdev->bridge;
501 if (!bridge) {
502 printk(KERN_ERR "Can't find VME bus\n");
503 goto err_bus;
504 }
505
506 /* Loop through master resources */
507 list_for_each(master_pos, &bridge->master_resources) {
508 master_image = list_entry(master_pos,
509 struct vme_master_resource, list);
510
511 if (!master_image) {
512 printk(KERN_WARNING "Registered NULL master resource\n");
513 continue;
514 }
515
516 /* Find an unlocked and compatible image */
517 spin_lock(&master_image->lock);
518 if (((master_image->address_attr & address) == address) &&
519 ((master_image->cycle_attr & cycle) == cycle) &&
520 ((master_image->width_attr & dwidth) == dwidth) &&
521 (master_image->locked == 0)) {
522
523 master_image->locked = 1;
524 spin_unlock(&master_image->lock);
525 allocated_image = master_image;
526 break;
527 }
528 spin_unlock(&master_image->lock);
529 }
530
531 /* Check to see if we found a resource */
532 if (!allocated_image) {
533 printk(KERN_ERR "Can't find a suitable resource\n");
534 goto err_image;
535 }
536
537 resource = kmalloc(sizeof(*resource), GFP_KERNEL);
538 if (!resource)
539 goto err_alloc;
540
541 resource->type = VME_MASTER;
542 resource->entry = &allocated_image->list;
543
544 return resource;
545
546err_alloc:
547 /* Unlock image */
548 spin_lock(&master_image->lock);
549 master_image->locked = 0;
550 spin_unlock(&master_image->lock);
551err_image:
552err_bus:
553 return NULL;
554}
555EXPORT_SYMBOL(vme_master_request);
556
557/**
558 * vme_master_set - Set VME master window configuration.
559 * @resource: Pointer to VME master resource.
560 * @enabled: State to which the window should be configured.
561 * @vme_base: Base address for the window.
562 * @size: Size of the VME window.
563 * @aspace: VME address space for the VME window.
564 * @cycle: VME data transfer cycle type for the VME window.
565 * @dwidth: VME data transfer width for the VME window.
566 *
567 * Set configuration for provided VME master window.
568 *
569 * Return: Zero on success, -EINVAL if operation is not supported on this
570 * device, if an invalid resource has been provided or invalid
571 * attributes are provided. Hardware specific errors may also be
572 * returned.
573 */
574int vme_master_set(struct vme_resource *resource, int enabled,
575 unsigned long long vme_base, unsigned long long size, u32 aspace,
576 u32 cycle, u32 dwidth)
577{
578 struct vme_bridge *bridge = find_bridge(resource);
579 struct vme_master_resource *image;
580 int retval;
581
582 if (resource->type != VME_MASTER) {
583 printk(KERN_ERR "Not a master resource\n");
584 return -EINVAL;
585 }
586
587 image = list_entry(resource->entry, struct vme_master_resource, list);
588
589 if (!bridge->master_set) {
590 printk(KERN_WARNING "vme_master_set not supported\n");
591 return -EINVAL;
592 }
593
594 if (!(((image->address_attr & aspace) == aspace) &&
595 ((image->cycle_attr & cycle) == cycle) &&
596 ((image->width_attr & dwidth) == dwidth))) {
597 printk(KERN_WARNING "Invalid attributes\n");
598 return -EINVAL;
599 }
600
601 retval = vme_check_window(aspace, vme_base, size);
602 if (retval)
603 return retval;
604
605 return bridge->master_set(image, enabled, vme_base, size, aspace,
606 cycle, dwidth);
607}
608EXPORT_SYMBOL(vme_master_set);
609
610/**
611 * vme_master_get - Retrieve VME master window configuration.
612 * @resource: Pointer to VME master resource.
613 * @enabled: Pointer to variable for storing state.
614 * @vme_base: Pointer to variable for storing window base address.
615 * @size: Pointer to variable for storing window size.
616 * @aspace: Pointer to variable for storing VME address space.
617 * @cycle: Pointer to variable for storing VME data transfer cycle type.
618 * @dwidth: Pointer to variable for storing VME data transfer width.
619 *
620 * Return configuration for provided VME master window.
621 *
622 * Return: Zero on success, -EINVAL if operation is not supported on this
623 * device or if an invalid resource has been provided.
624 */
625int vme_master_get(struct vme_resource *resource, int *enabled,
626 unsigned long long *vme_base, unsigned long long *size, u32 *aspace,
627 u32 *cycle, u32 *dwidth)
628{
629 struct vme_bridge *bridge = find_bridge(resource);
630 struct vme_master_resource *image;
631
632 if (resource->type != VME_MASTER) {
633 printk(KERN_ERR "Not a master resource\n");
634 return -EINVAL;
635 }
636
637 image = list_entry(resource->entry, struct vme_master_resource, list);
638
639 if (!bridge->master_get) {
640 printk(KERN_WARNING "%s not supported\n", __func__);
641 return -EINVAL;
642 }
643
644 return bridge->master_get(image, enabled, vme_base, size, aspace,
645 cycle, dwidth);
646}
647EXPORT_SYMBOL(vme_master_get);
648
649/**
650 * vme_master_write - Read data from VME space into a buffer.
651 * @resource: Pointer to VME master resource.
652 * @buf: Pointer to buffer where data should be transferred.
653 * @count: Number of bytes to transfer.
654 * @offset: Offset into VME master window at which to start transfer.
655 *
656 * Perform read of count bytes of data from location on VME bus which maps into
657 * the VME master window at offset to buf.
658 *
659 * Return: Number of bytes read, -EINVAL if resource is not a VME master
660 * resource or read operation is not supported. -EFAULT returned if
661 * invalid offset is provided. Hardware specific errors may also be
662 * returned.
663 */
664ssize_t vme_master_read(struct vme_resource *resource, void *buf, size_t count,
665 loff_t offset)
666{
667 struct vme_bridge *bridge = find_bridge(resource);
668 struct vme_master_resource *image;
669 size_t length;
670
671 if (!bridge->master_read) {
672 printk(KERN_WARNING "Reading from resource not supported\n");
673 return -EINVAL;
674 }
675
676 if (resource->type != VME_MASTER) {
677 printk(KERN_ERR "Not a master resource\n");
678 return -EINVAL;
679 }
680
681 image = list_entry(resource->entry, struct vme_master_resource, list);
682
683 length = vme_get_size(resource);
684
685 if (offset > length) {
686 printk(KERN_WARNING "Invalid Offset\n");
687 return -EFAULT;
688 }
689
690 if ((offset + count) > length)
691 count = length - offset;
692
693 return bridge->master_read(image, buf, count, offset);
694
695}
696EXPORT_SYMBOL(vme_master_read);
697
698/**
699 * vme_master_write - Write data out to VME space from a buffer.
700 * @resource: Pointer to VME master resource.
701 * @buf: Pointer to buffer holding data to transfer.
702 * @count: Number of bytes to transfer.
703 * @offset: Offset into VME master window at which to start transfer.
704 *
705 * Perform write of count bytes of data from buf to location on VME bus which
706 * maps into the VME master window at offset.
707 *
708 * Return: Number of bytes written, -EINVAL if resource is not a VME master
709 * resource or write operation is not supported. -EFAULT returned if
710 * invalid offset is provided. Hardware specific errors may also be
711 * returned.
712 */
713ssize_t vme_master_write(struct vme_resource *resource, void *buf,
714 size_t count, loff_t offset)
715{
716 struct vme_bridge *bridge = find_bridge(resource);
717 struct vme_master_resource *image;
718 size_t length;
719
720 if (!bridge->master_write) {
721 printk(KERN_WARNING "Writing to resource not supported\n");
722 return -EINVAL;
723 }
724
725 if (resource->type != VME_MASTER) {
726 printk(KERN_ERR "Not a master resource\n");
727 return -EINVAL;
728 }
729
730 image = list_entry(resource->entry, struct vme_master_resource, list);
731
732 length = vme_get_size(resource);
733
734 if (offset > length) {
735 printk(KERN_WARNING "Invalid Offset\n");
736 return -EFAULT;
737 }
738
739 if ((offset + count) > length)
740 count = length - offset;
741
742 return bridge->master_write(image, buf, count, offset);
743}
744EXPORT_SYMBOL(vme_master_write);
745
746/**
747 * vme_master_rmw - Perform read-modify-write cycle.
748 * @resource: Pointer to VME master resource.
749 * @mask: Bits to be compared and swapped in operation.
750 * @compare: Bits to be compared with data read from offset.
751 * @swap: Bits to be swapped in data read from offset.
752 * @offset: Offset into VME master window at which to perform operation.
753 *
754 * Perform read-modify-write cycle on provided location:
755 * - Location on VME bus is read.
756 * - Bits selected by mask are compared with compare.
757 * - Where a selected bit matches that in compare and are selected in swap,
758 * the bit is swapped.
759 * - Result written back to location on VME bus.
760 *
761 * Return: Bytes written on success, -EINVAL if resource is not a VME master
762 * resource or RMW operation is not supported. Hardware specific
763 * errors may also be returned.
764 */
765unsigned int vme_master_rmw(struct vme_resource *resource, unsigned int mask,
766 unsigned int compare, unsigned int swap, loff_t offset)
767{
768 struct vme_bridge *bridge = find_bridge(resource);
769 struct vme_master_resource *image;
770
771 if (!bridge->master_rmw) {
772 printk(KERN_WARNING "Writing to resource not supported\n");
773 return -EINVAL;
774 }
775
776 if (resource->type != VME_MASTER) {
777 printk(KERN_ERR "Not a master resource\n");
778 return -EINVAL;
779 }
780
781 image = list_entry(resource->entry, struct vme_master_resource, list);
782
783 return bridge->master_rmw(image, mask, compare, swap, offset);
784}
785EXPORT_SYMBOL(vme_master_rmw);
786
787/**
788 * vme_master_mmap - Mmap region of VME master window.
789 * @resource: Pointer to VME master resource.
790 * @vma: Pointer to definition of user mapping.
791 *
792 * Memory map a region of the VME master window into user space.
793 *
794 * Return: Zero on success, -EINVAL if resource is not a VME master
795 * resource or -EFAULT if map exceeds window size. Other generic mmap
796 * errors may also be returned.
797 */
798int vme_master_mmap(struct vme_resource *resource, struct vm_area_struct *vma)
799{
800 struct vme_master_resource *image;
801 phys_addr_t phys_addr;
802 unsigned long vma_size;
803
804 if (resource->type != VME_MASTER) {
805 pr_err("Not a master resource\n");
806 return -EINVAL;
807 }
808
809 image = list_entry(resource->entry, struct vme_master_resource, list);
810 phys_addr = image->bus_resource.start + (vma->vm_pgoff << PAGE_SHIFT);
811 vma_size = vma->vm_end - vma->vm_start;
812
813 if (phys_addr + vma_size > image->bus_resource.end + 1) {
814 pr_err("Map size cannot exceed the window size\n");
815 return -EFAULT;
816 }
817
818 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
819
820 return vm_iomap_memory(vma, phys_addr, vma->vm_end - vma->vm_start);
821}
822EXPORT_SYMBOL(vme_master_mmap);
823
824/**
825 * vme_master_free - Free VME master window
826 * @resource: Pointer to VME master resource.
827 *
828 * Free the provided master resource so that it may be reallocated.
829 */
830void vme_master_free(struct vme_resource *resource)
831{
832 struct vme_master_resource *master_image;
833
834 if (resource->type != VME_MASTER) {
835 printk(KERN_ERR "Not a master resource\n");
836 return;
837 }
838
839 master_image = list_entry(resource->entry, struct vme_master_resource,
840 list);
841 if (!master_image) {
842 printk(KERN_ERR "Can't find master resource\n");
843 return;
844 }
845
846 /* Unlock image */
847 spin_lock(&master_image->lock);
848 if (master_image->locked == 0)
849 printk(KERN_ERR "Image is already free\n");
850
851 master_image->locked = 0;
852 spin_unlock(&master_image->lock);
853
854 /* Free up resource memory */
855 kfree(resource);
856}
857EXPORT_SYMBOL(vme_master_free);
858
859/**
860 * vme_dma_request - Request a DMA controller.
861 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
862 * @route: Required src/destination combination.
863 *
864 * Request a VME DMA controller with capability to perform transfers bewteen
865 * requested source/destination combination.
866 *
867 * Return: Pointer to VME DMA resource on success, NULL on failure.
868 */
869struct vme_resource *vme_dma_request(struct vme_dev *vdev, u32 route)
870{
871 struct vme_bridge *bridge;
872 struct list_head *dma_pos = NULL;
873 struct vme_dma_resource *allocated_ctrlr = NULL;
874 struct vme_dma_resource *dma_ctrlr = NULL;
875 struct vme_resource *resource = NULL;
876
877 /* XXX Not checking resource attributes */
878 printk(KERN_ERR "No VME resource Attribute tests done\n");
879
880 bridge = vdev->bridge;
881 if (!bridge) {
882 printk(KERN_ERR "Can't find VME bus\n");
883 goto err_bus;
884 }
885
886 /* Loop through DMA resources */
887 list_for_each(dma_pos, &bridge->dma_resources) {
888 dma_ctrlr = list_entry(dma_pos,
889 struct vme_dma_resource, list);
890 if (!dma_ctrlr) {
891 printk(KERN_ERR "Registered NULL DMA resource\n");
892 continue;
893 }
894
895 /* Find an unlocked and compatible controller */
896 mutex_lock(&dma_ctrlr->mtx);
897 if (((dma_ctrlr->route_attr & route) == route) &&
898 (dma_ctrlr->locked == 0)) {
899
900 dma_ctrlr->locked = 1;
901 mutex_unlock(&dma_ctrlr->mtx);
902 allocated_ctrlr = dma_ctrlr;
903 break;
904 }
905 mutex_unlock(&dma_ctrlr->mtx);
906 }
907
908 /* Check to see if we found a resource */
909 if (!allocated_ctrlr)
910 goto err_ctrlr;
911
912 resource = kmalloc(sizeof(*resource), GFP_KERNEL);
913 if (!resource)
914 goto err_alloc;
915
916 resource->type = VME_DMA;
917 resource->entry = &allocated_ctrlr->list;
918
919 return resource;
920
921err_alloc:
922 /* Unlock image */
923 mutex_lock(&dma_ctrlr->mtx);
924 dma_ctrlr->locked = 0;
925 mutex_unlock(&dma_ctrlr->mtx);
926err_ctrlr:
927err_bus:
928 return NULL;
929}
930EXPORT_SYMBOL(vme_dma_request);
931
932/**
933 * vme_new_dma_list - Create new VME DMA list.
934 * @resource: Pointer to VME DMA resource.
935 *
936 * Create a new VME DMA list. It is the responsibility of the user to free
937 * the list once it is no longer required with vme_dma_list_free().
938 *
939 * Return: Pointer to new VME DMA list, NULL on allocation failure or invalid
940 * VME DMA resource.
941 */
942struct vme_dma_list *vme_new_dma_list(struct vme_resource *resource)
943{
944 struct vme_dma_list *dma_list;
945
946 if (resource->type != VME_DMA) {
947 printk(KERN_ERR "Not a DMA resource\n");
948 return NULL;
949 }
950
951 dma_list = kmalloc(sizeof(*dma_list), GFP_KERNEL);
952 if (!dma_list)
953 return NULL;
954
955 INIT_LIST_HEAD(&dma_list->entries);
956 dma_list->parent = list_entry(resource->entry,
957 struct vme_dma_resource,
958 list);
959 mutex_init(&dma_list->mtx);
960
961 return dma_list;
962}
963EXPORT_SYMBOL(vme_new_dma_list);
964
965/**
966 * vme_dma_pattern_attribute - Create "Pattern" type VME DMA list attribute.
967 * @pattern: Value to use used as pattern
968 * @type: Type of pattern to be written.
969 *
970 * Create VME DMA list attribute for pattern generation. It is the
971 * responsibility of the user to free used attributes using
972 * vme_dma_free_attribute().
973 *
974 * Return: Pointer to VME DMA attribute, NULL on failure.
975 */
976struct vme_dma_attr *vme_dma_pattern_attribute(u32 pattern, u32 type)
977{
978 struct vme_dma_attr *attributes;
979 struct vme_dma_pattern *pattern_attr;
980
981 attributes = kmalloc(sizeof(*attributes), GFP_KERNEL);
982 if (!attributes)
983 goto err_attr;
984
985 pattern_attr = kmalloc(sizeof(*pattern_attr), GFP_KERNEL);
986 if (!pattern_attr)
987 goto err_pat;
988
989 attributes->type = VME_DMA_PATTERN;
990 attributes->private = (void *)pattern_attr;
991
992 pattern_attr->pattern = pattern;
993 pattern_attr->type = type;
994
995 return attributes;
996
997err_pat:
998 kfree(attributes);
999err_attr:
1000 return NULL;
1001}
1002EXPORT_SYMBOL(vme_dma_pattern_attribute);
1003
1004/**
1005 * vme_dma_pci_attribute - Create "PCI" type VME DMA list attribute.
1006 * @address: PCI base address for DMA transfer.
1007 *
1008 * Create VME DMA list attribute pointing to a location on PCI for DMA
1009 * transfers. It is the responsibility of the user to free used attributes
1010 * using vme_dma_free_attribute().
1011 *
1012 * Return: Pointer to VME DMA attribute, NULL on failure.
1013 */
1014struct vme_dma_attr *vme_dma_pci_attribute(dma_addr_t address)
1015{
1016 struct vme_dma_attr *attributes;
1017 struct vme_dma_pci *pci_attr;
1018
1019 /* XXX Run some sanity checks here */
1020
1021 attributes = kmalloc(sizeof(*attributes), GFP_KERNEL);
1022 if (!attributes)
1023 goto err_attr;
1024
1025 pci_attr = kmalloc(sizeof(*pci_attr), GFP_KERNEL);
1026 if (!pci_attr)
1027 goto err_pci;
1028
1029 attributes->type = VME_DMA_PCI;
1030 attributes->private = (void *)pci_attr;
1031
1032 pci_attr->address = address;
1033
1034 return attributes;
1035
1036err_pci:
1037 kfree(attributes);
1038err_attr:
1039 return NULL;
1040}
1041EXPORT_SYMBOL(vme_dma_pci_attribute);
1042
1043/**
1044 * vme_dma_vme_attribute - Create "VME" type VME DMA list attribute.
1045 * @address: VME base address for DMA transfer.
1046 * @aspace: VME address space to use for DMA transfer.
1047 * @cycle: VME bus cycle to use for DMA transfer.
1048 * @dwidth: VME data width to use for DMA transfer.
1049 *
1050 * Create VME DMA list attribute pointing to a location on the VME bus for DMA
1051 * transfers. It is the responsibility of the user to free used attributes
1052 * using vme_dma_free_attribute().
1053 *
1054 * Return: Pointer to VME DMA attribute, NULL on failure.
1055 */
1056struct vme_dma_attr *vme_dma_vme_attribute(unsigned long long address,
1057 u32 aspace, u32 cycle, u32 dwidth)
1058{
1059 struct vme_dma_attr *attributes;
1060 struct vme_dma_vme *vme_attr;
1061
1062 attributes = kmalloc(sizeof(*attributes), GFP_KERNEL);
1063 if (!attributes)
1064 goto err_attr;
1065
1066 vme_attr = kmalloc(sizeof(*vme_attr), GFP_KERNEL);
1067 if (!vme_attr)
1068 goto err_vme;
1069
1070 attributes->type = VME_DMA_VME;
1071 attributes->private = (void *)vme_attr;
1072
1073 vme_attr->address = address;
1074 vme_attr->aspace = aspace;
1075 vme_attr->cycle = cycle;
1076 vme_attr->dwidth = dwidth;
1077
1078 return attributes;
1079
1080err_vme:
1081 kfree(attributes);
1082err_attr:
1083 return NULL;
1084}
1085EXPORT_SYMBOL(vme_dma_vme_attribute);
1086
1087/**
1088 * vme_dma_free_attribute - Free DMA list attribute.
1089 * @attributes: Pointer to DMA list attribute.
1090 *
1091 * Free VME DMA list attribute. VME DMA list attributes can be safely freed
1092 * once vme_dma_list_add() has returned.
1093 */
1094void vme_dma_free_attribute(struct vme_dma_attr *attributes)
1095{
1096 kfree(attributes->private);
1097 kfree(attributes);
1098}
1099EXPORT_SYMBOL(vme_dma_free_attribute);
1100
1101/**
1102 * vme_dma_list_add - Add enty to a VME DMA list.
1103 * @list: Pointer to VME list.
1104 * @src: Pointer to DMA list attribute to use as source.
1105 * @dest: Pointer to DMA list attribute to use as destination.
1106 * @count: Number of bytes to transfer.
1107 *
1108 * Add an entry to the provided VME DMA list. Entry requires pointers to source
1109 * and destination DMA attributes and a count.
1110 *
1111 * Please note, the attributes supported as source and destinations for
1112 * transfers are hardware dependent.
1113 *
1114 * Return: Zero on success, -EINVAL if operation is not supported on this
1115 * device or if the link list has already been submitted for execution.
1116 * Hardware specific errors also possible.
1117 */
1118int vme_dma_list_add(struct vme_dma_list *list, struct vme_dma_attr *src,
1119 struct vme_dma_attr *dest, size_t count)
1120{
1121 struct vme_bridge *bridge = list->parent->parent;
1122 int retval;
1123
1124 if (!bridge->dma_list_add) {
1125 printk(KERN_WARNING "Link List DMA generation not supported\n");
1126 return -EINVAL;
1127 }
1128
1129 if (!mutex_trylock(&list->mtx)) {
1130 printk(KERN_ERR "Link List already submitted\n");
1131 return -EINVAL;
1132 }
1133
1134 retval = bridge->dma_list_add(list, src, dest, count);
1135
1136 mutex_unlock(&list->mtx);
1137
1138 return retval;
1139}
1140EXPORT_SYMBOL(vme_dma_list_add);
1141
1142/**
1143 * vme_dma_list_exec - Queue a VME DMA list for execution.
1144 * @list: Pointer to VME list.
1145 *
1146 * Queue the provided VME DMA list for execution. The call will return once the
1147 * list has been executed.
1148 *
1149 * Return: Zero on success, -EINVAL if operation is not supported on this
1150 * device. Hardware specific errors also possible.
1151 */
1152int vme_dma_list_exec(struct vme_dma_list *list)
1153{
1154 struct vme_bridge *bridge = list->parent->parent;
1155 int retval;
1156
1157 if (!bridge->dma_list_exec) {
1158 printk(KERN_ERR "Link List DMA execution not supported\n");
1159 return -EINVAL;
1160 }
1161
1162 mutex_lock(&list->mtx);
1163
1164 retval = bridge->dma_list_exec(list);
1165
1166 mutex_unlock(&list->mtx);
1167
1168 return retval;
1169}
1170EXPORT_SYMBOL(vme_dma_list_exec);
1171
1172/**
1173 * vme_dma_list_free - Free a VME DMA list.
1174 * @list: Pointer to VME list.
1175 *
1176 * Free the provided DMA list and all its entries.
1177 *
1178 * Return: Zero on success, -EINVAL on invalid VME resource, -EBUSY if resource
1179 * is still in use. Hardware specific errors also possible.
1180 */
1181int vme_dma_list_free(struct vme_dma_list *list)
1182{
1183 struct vme_bridge *bridge = list->parent->parent;
1184 int retval;
1185
1186 if (!bridge->dma_list_empty) {
1187 printk(KERN_WARNING "Emptying of Link Lists not supported\n");
1188 return -EINVAL;
1189 }
1190
1191 if (!mutex_trylock(&list->mtx)) {
1192 printk(KERN_ERR "Link List in use\n");
1193 return -EBUSY;
1194 }
1195
1196 /*
1197 * Empty out all of the entries from the DMA list. We need to go to the
1198 * low level driver as DMA entries are driver specific.
1199 */
1200 retval = bridge->dma_list_empty(list);
1201 if (retval) {
1202 printk(KERN_ERR "Unable to empty link-list entries\n");
1203 mutex_unlock(&list->mtx);
1204 return retval;
1205 }
1206 mutex_unlock(&list->mtx);
1207 kfree(list);
1208
1209 return retval;
1210}
1211EXPORT_SYMBOL(vme_dma_list_free);
1212
1213/**
1214 * vme_dma_free - Free a VME DMA resource.
1215 * @resource: Pointer to VME DMA resource.
1216 *
1217 * Free the provided DMA resource so that it may be reallocated.
1218 *
1219 * Return: Zero on success, -EINVAL on invalid VME resource, -EBUSY if resource
1220 * is still active.
1221 */
1222int vme_dma_free(struct vme_resource *resource)
1223{
1224 struct vme_dma_resource *ctrlr;
1225
1226 if (resource->type != VME_DMA) {
1227 printk(KERN_ERR "Not a DMA resource\n");
1228 return -EINVAL;
1229 }
1230
1231 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list);
1232
1233 if (!mutex_trylock(&ctrlr->mtx)) {
1234 printk(KERN_ERR "Resource busy, can't free\n");
1235 return -EBUSY;
1236 }
1237
1238 if (!(list_empty(&ctrlr->pending) && list_empty(&ctrlr->running))) {
1239 printk(KERN_WARNING "Resource still processing transfers\n");
1240 mutex_unlock(&ctrlr->mtx);
1241 return -EBUSY;
1242 }
1243
1244 ctrlr->locked = 0;
1245
1246 mutex_unlock(&ctrlr->mtx);
1247
1248 kfree(resource);
1249
1250 return 0;
1251}
1252EXPORT_SYMBOL(vme_dma_free);
1253
1254void vme_bus_error_handler(struct vme_bridge *bridge,
1255 unsigned long long address, int am)
1256{
1257 struct list_head *handler_pos = NULL;
1258 struct vme_error_handler *handler;
1259 int handler_triggered = 0;
1260 u32 aspace = vme_get_aspace(am);
1261
1262 list_for_each(handler_pos, &bridge->vme_error_handlers) {
1263 handler = list_entry(handler_pos, struct vme_error_handler,
1264 list);
1265 if ((aspace == handler->aspace) &&
1266 (address >= handler->start) &&
1267 (address < handler->end)) {
1268 if (!handler->num_errors)
1269 handler->first_error = address;
1270 if (handler->num_errors != UINT_MAX)
1271 handler->num_errors++;
1272 handler_triggered = 1;
1273 }
1274 }
1275
1276 if (!handler_triggered)
1277 dev_err(bridge->parent,
1278 "Unhandled VME access error at address 0x%llx\n",
1279 address);
1280}
1281EXPORT_SYMBOL(vme_bus_error_handler);
1282
1283struct vme_error_handler *vme_register_error_handler(
1284 struct vme_bridge *bridge, u32 aspace,
1285 unsigned long long address, size_t len)
1286{
1287 struct vme_error_handler *handler;
1288
1289 handler = kmalloc(sizeof(*handler), GFP_ATOMIC);
1290 if (!handler)
1291 return NULL;
1292
1293 handler->aspace = aspace;
1294 handler->start = address;
1295 handler->end = address + len;
1296 handler->num_errors = 0;
1297 handler->first_error = 0;
1298 list_add_tail(&handler->list, &bridge->vme_error_handlers);
1299
1300 return handler;
1301}
1302EXPORT_SYMBOL(vme_register_error_handler);
1303
1304void vme_unregister_error_handler(struct vme_error_handler *handler)
1305{
1306 list_del(&handler->list);
1307 kfree(handler);
1308}
1309EXPORT_SYMBOL(vme_unregister_error_handler);
1310
1311void vme_irq_handler(struct vme_bridge *bridge, int level, int statid)
1312{
1313 void (*call)(int, int, void *);
1314 void *priv_data;
1315
1316 call = bridge->irq[level - 1].callback[statid].func;
1317 priv_data = bridge->irq[level - 1].callback[statid].priv_data;
1318 if (call)
1319 call(level, statid, priv_data);
1320 else
1321 printk(KERN_WARNING "Spurious VME interrupt, level:%x, vector:%x\n",
1322 level, statid);
1323}
1324EXPORT_SYMBOL(vme_irq_handler);
1325
1326/**
1327 * vme_irq_request - Request a specific VME interrupt.
1328 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1329 * @level: Interrupt priority being requested.
1330 * @statid: Interrupt vector being requested.
1331 * @callback: Pointer to callback function called when VME interrupt/vector
1332 * received.
1333 * @priv_data: Generic pointer that will be passed to the callback function.
1334 *
1335 * Request callback to be attached as a handler for VME interrupts with provided
1336 * level and statid.
1337 *
1338 * Return: Zero on success, -EINVAL on invalid vme device, level or if the
1339 * function is not supported, -EBUSY if the level/statid combination is
1340 * already in use. Hardware specific errors also possible.
1341 */
1342int vme_irq_request(struct vme_dev *vdev, int level, int statid,
1343 void (*callback)(int, int, void *),
1344 void *priv_data)
1345{
1346 struct vme_bridge *bridge;
1347
1348 bridge = vdev->bridge;
1349 if (!bridge) {
1350 printk(KERN_ERR "Can't find VME bus\n");
1351 return -EINVAL;
1352 }
1353
1354 if ((level < 1) || (level > 7)) {
1355 printk(KERN_ERR "Invalid interrupt level\n");
1356 return -EINVAL;
1357 }
1358
1359 if (!bridge->irq_set) {
1360 printk(KERN_ERR "Configuring interrupts not supported\n");
1361 return -EINVAL;
1362 }
1363
1364 mutex_lock(&bridge->irq_mtx);
1365
1366 if (bridge->irq[level - 1].callback[statid].func) {
1367 mutex_unlock(&bridge->irq_mtx);
1368 printk(KERN_WARNING "VME Interrupt already taken\n");
1369 return -EBUSY;
1370 }
1371
1372 bridge->irq[level - 1].count++;
1373 bridge->irq[level - 1].callback[statid].priv_data = priv_data;
1374 bridge->irq[level - 1].callback[statid].func = callback;
1375
1376 /* Enable IRQ level */
1377 bridge->irq_set(bridge, level, 1, 1);
1378
1379 mutex_unlock(&bridge->irq_mtx);
1380
1381 return 0;
1382}
1383EXPORT_SYMBOL(vme_irq_request);
1384
1385/**
1386 * vme_irq_free - Free a VME interrupt.
1387 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1388 * @level: Interrupt priority of interrupt being freed.
1389 * @statid: Interrupt vector of interrupt being freed.
1390 *
1391 * Remove previously attached callback from VME interrupt priority/vector.
1392 */
1393void vme_irq_free(struct vme_dev *vdev, int level, int statid)
1394{
1395 struct vme_bridge *bridge;
1396
1397 bridge = vdev->bridge;
1398 if (!bridge) {
1399 printk(KERN_ERR "Can't find VME bus\n");
1400 return;
1401 }
1402
1403 if ((level < 1) || (level > 7)) {
1404 printk(KERN_ERR "Invalid interrupt level\n");
1405 return;
1406 }
1407
1408 if (!bridge->irq_set) {
1409 printk(KERN_ERR "Configuring interrupts not supported\n");
1410 return;
1411 }
1412
1413 mutex_lock(&bridge->irq_mtx);
1414
1415 bridge->irq[level - 1].count--;
1416
1417 /* Disable IRQ level if no more interrupts attached at this level*/
1418 if (bridge->irq[level - 1].count == 0)
1419 bridge->irq_set(bridge, level, 0, 1);
1420
1421 bridge->irq[level - 1].callback[statid].func = NULL;
1422 bridge->irq[level - 1].callback[statid].priv_data = NULL;
1423
1424 mutex_unlock(&bridge->irq_mtx);
1425}
1426EXPORT_SYMBOL(vme_irq_free);
1427
1428/**
1429 * vme_irq_generate - Generate VME interrupt.
1430 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1431 * @level: Interrupt priority at which to assert the interrupt.
1432 * @statid: Interrupt vector to associate with the interrupt.
1433 *
1434 * Generate a VME interrupt of the provided level and with the provided
1435 * statid.
1436 *
1437 * Return: Zero on success, -EINVAL on invalid vme device, level or if the
1438 * function is not supported. Hardware specific errors also possible.
1439 */
1440int vme_irq_generate(struct vme_dev *vdev, int level, int statid)
1441{
1442 struct vme_bridge *bridge;
1443
1444 bridge = vdev->bridge;
1445 if (!bridge) {
1446 printk(KERN_ERR "Can't find VME bus\n");
1447 return -EINVAL;
1448 }
1449
1450 if ((level < 1) || (level > 7)) {
1451 printk(KERN_WARNING "Invalid interrupt level\n");
1452 return -EINVAL;
1453 }
1454
1455 if (!bridge->irq_generate) {
1456 printk(KERN_WARNING "Interrupt generation not supported\n");
1457 return -EINVAL;
1458 }
1459
1460 return bridge->irq_generate(bridge, level, statid);
1461}
1462EXPORT_SYMBOL(vme_irq_generate);
1463
1464/**
1465 * vme_lm_request - Request a VME location monitor
1466 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1467 *
1468 * Allocate a location monitor resource to the driver. A location monitor
1469 * allows the driver to monitor accesses to a contiguous number of
1470 * addresses on the VME bus.
1471 *
1472 * Return: Pointer to a VME resource on success or NULL on failure.
1473 */
1474struct vme_resource *vme_lm_request(struct vme_dev *vdev)
1475{
1476 struct vme_bridge *bridge;
1477 struct list_head *lm_pos = NULL;
1478 struct vme_lm_resource *allocated_lm = NULL;
1479 struct vme_lm_resource *lm = NULL;
1480 struct vme_resource *resource = NULL;
1481
1482 bridge = vdev->bridge;
1483 if (!bridge) {
1484 printk(KERN_ERR "Can't find VME bus\n");
1485 goto err_bus;
1486 }
1487
1488 /* Loop through LM resources */
1489 list_for_each(lm_pos, &bridge->lm_resources) {
1490 lm = list_entry(lm_pos,
1491 struct vme_lm_resource, list);
1492 if (!lm) {
1493 printk(KERN_ERR "Registered NULL Location Monitor resource\n");
1494 continue;
1495 }
1496
1497 /* Find an unlocked controller */
1498 mutex_lock(&lm->mtx);
1499 if (lm->locked == 0) {
1500 lm->locked = 1;
1501 mutex_unlock(&lm->mtx);
1502 allocated_lm = lm;
1503 break;
1504 }
1505 mutex_unlock(&lm->mtx);
1506 }
1507
1508 /* Check to see if we found a resource */
1509 if (!allocated_lm)
1510 goto err_lm;
1511
1512 resource = kmalloc(sizeof(*resource), GFP_KERNEL);
1513 if (!resource)
1514 goto err_alloc;
1515
1516 resource->type = VME_LM;
1517 resource->entry = &allocated_lm->list;
1518
1519 return resource;
1520
1521err_alloc:
1522 /* Unlock image */
1523 mutex_lock(&lm->mtx);
1524 lm->locked = 0;
1525 mutex_unlock(&lm->mtx);
1526err_lm:
1527err_bus:
1528 return NULL;
1529}
1530EXPORT_SYMBOL(vme_lm_request);
1531
1532/**
1533 * vme_lm_count - Determine number of VME Addresses monitored
1534 * @resource: Pointer to VME location monitor resource.
1535 *
1536 * The number of contiguous addresses monitored is hardware dependent.
1537 * Return the number of contiguous addresses monitored by the
1538 * location monitor.
1539 *
1540 * Return: Count of addresses monitored or -EINVAL when provided with an
1541 * invalid location monitor resource.
1542 */
1543int vme_lm_count(struct vme_resource *resource)
1544{
1545 struct vme_lm_resource *lm;
1546
1547 if (resource->type != VME_LM) {
1548 printk(KERN_ERR "Not a Location Monitor resource\n");
1549 return -EINVAL;
1550 }
1551
1552 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1553
1554 return lm->monitors;
1555}
1556EXPORT_SYMBOL(vme_lm_count);
1557
1558/**
1559 * vme_lm_set - Configure location monitor
1560 * @resource: Pointer to VME location monitor resource.
1561 * @lm_base: Base address to monitor.
1562 * @aspace: VME address space to monitor.
1563 * @cycle: VME bus cycle type to monitor.
1564 *
1565 * Set the base address, address space and cycle type of accesses to be
1566 * monitored by the location monitor.
1567 *
1568 * Return: Zero on success, -EINVAL when provided with an invalid location
1569 * monitor resource or function is not supported. Hardware specific
1570 * errors may also be returned.
1571 */
1572int vme_lm_set(struct vme_resource *resource, unsigned long long lm_base,
1573 u32 aspace, u32 cycle)
1574{
1575 struct vme_bridge *bridge = find_bridge(resource);
1576 struct vme_lm_resource *lm;
1577
1578 if (resource->type != VME_LM) {
1579 printk(KERN_ERR "Not a Location Monitor resource\n");
1580 return -EINVAL;
1581 }
1582
1583 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1584
1585 if (!bridge->lm_set) {
1586 printk(KERN_ERR "vme_lm_set not supported\n");
1587 return -EINVAL;
1588 }
1589
1590 return bridge->lm_set(lm, lm_base, aspace, cycle);
1591}
1592EXPORT_SYMBOL(vme_lm_set);
1593
1594/**
1595 * vme_lm_get - Retrieve location monitor settings
1596 * @resource: Pointer to VME location monitor resource.
1597 * @lm_base: Pointer used to output the base address monitored.
1598 * @aspace: Pointer used to output the address space monitored.
1599 * @cycle: Pointer used to output the VME bus cycle type monitored.
1600 *
1601 * Retrieve the base address, address space and cycle type of accesses to
1602 * be monitored by the location monitor.
1603 *
1604 * Return: Zero on success, -EINVAL when provided with an invalid location
1605 * monitor resource or function is not supported. Hardware specific
1606 * errors may also be returned.
1607 */
1608int vme_lm_get(struct vme_resource *resource, unsigned long long *lm_base,
1609 u32 *aspace, u32 *cycle)
1610{
1611 struct vme_bridge *bridge = find_bridge(resource);
1612 struct vme_lm_resource *lm;
1613
1614 if (resource->type != VME_LM) {
1615 printk(KERN_ERR "Not a Location Monitor resource\n");
1616 return -EINVAL;
1617 }
1618
1619 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1620
1621 if (!bridge->lm_get) {
1622 printk(KERN_ERR "vme_lm_get not supported\n");
1623 return -EINVAL;
1624 }
1625
1626 return bridge->lm_get(lm, lm_base, aspace, cycle);
1627}
1628EXPORT_SYMBOL(vme_lm_get);
1629
1630/**
1631 * vme_lm_attach - Provide callback for location monitor address
1632 * @resource: Pointer to VME location monitor resource.
1633 * @monitor: Offset to which callback should be attached.
1634 * @callback: Pointer to callback function called when triggered.
1635 * @data: Generic pointer that will be passed to the callback function.
1636 *
1637 * Attach a callback to the specificed offset into the location monitors
1638 * monitored addresses. A generic pointer is provided to allow data to be
1639 * passed to the callback when called.
1640 *
1641 * Return: Zero on success, -EINVAL when provided with an invalid location
1642 * monitor resource or function is not supported. Hardware specific
1643 * errors may also be returned.
1644 */
1645int vme_lm_attach(struct vme_resource *resource, int monitor,
1646 void (*callback)(void *), void *data)
1647{
1648 struct vme_bridge *bridge = find_bridge(resource);
1649 struct vme_lm_resource *lm;
1650
1651 if (resource->type != VME_LM) {
1652 printk(KERN_ERR "Not a Location Monitor resource\n");
1653 return -EINVAL;
1654 }
1655
1656 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1657
1658 if (!bridge->lm_attach) {
1659 printk(KERN_ERR "vme_lm_attach not supported\n");
1660 return -EINVAL;
1661 }
1662
1663 return bridge->lm_attach(lm, monitor, callback, data);
1664}
1665EXPORT_SYMBOL(vme_lm_attach);
1666
1667/**
1668 * vme_lm_detach - Remove callback for location monitor address
1669 * @resource: Pointer to VME location monitor resource.
1670 * @monitor: Offset to which callback should be removed.
1671 *
1672 * Remove the callback associated with the specificed offset into the
1673 * location monitors monitored addresses.
1674 *
1675 * Return: Zero on success, -EINVAL when provided with an invalid location
1676 * monitor resource or function is not supported. Hardware specific
1677 * errors may also be returned.
1678 */
1679int vme_lm_detach(struct vme_resource *resource, int monitor)
1680{
1681 struct vme_bridge *bridge = find_bridge(resource);
1682 struct vme_lm_resource *lm;
1683
1684 if (resource->type != VME_LM) {
1685 printk(KERN_ERR "Not a Location Monitor resource\n");
1686 return -EINVAL;
1687 }
1688
1689 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1690
1691 if (!bridge->lm_detach) {
1692 printk(KERN_ERR "vme_lm_detach not supported\n");
1693 return -EINVAL;
1694 }
1695
1696 return bridge->lm_detach(lm, monitor);
1697}
1698EXPORT_SYMBOL(vme_lm_detach);
1699
1700/**
1701 * vme_lm_free - Free allocated VME location monitor
1702 * @resource: Pointer to VME location monitor resource.
1703 *
1704 * Free allocation of a VME location monitor.
1705 *
1706 * WARNING: This function currently expects that any callbacks that have
1707 * been attached to the location monitor have been removed.
1708 *
1709 * Return: Zero on success, -EINVAL when provided with an invalid location
1710 * monitor resource.
1711 */
1712void vme_lm_free(struct vme_resource *resource)
1713{
1714 struct vme_lm_resource *lm;
1715
1716 if (resource->type != VME_LM) {
1717 printk(KERN_ERR "Not a Location Monitor resource\n");
1718 return;
1719 }
1720
1721 lm = list_entry(resource->entry, struct vme_lm_resource, list);
1722
1723 mutex_lock(&lm->mtx);
1724
1725 /* XXX
1726 * Check to see that there aren't any callbacks still attached, if
1727 * there are we should probably be detaching them!
1728 */
1729
1730 lm->locked = 0;
1731
1732 mutex_unlock(&lm->mtx);
1733
1734 kfree(resource);
1735}
1736EXPORT_SYMBOL(vme_lm_free);
1737
1738/**
1739 * vme_slot_num - Retrieve slot ID
1740 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1741 *
1742 * Retrieve the slot ID associated with the provided VME device.
1743 *
1744 * Return: The slot ID on success, -EINVAL if VME bridge cannot be determined
1745 * or the function is not supported. Hardware specific errors may also
1746 * be returned.
1747 */
1748int vme_slot_num(struct vme_dev *vdev)
1749{
1750 struct vme_bridge *bridge;
1751
1752 bridge = vdev->bridge;
1753 if (!bridge) {
1754 printk(KERN_ERR "Can't find VME bus\n");
1755 return -EINVAL;
1756 }
1757
1758 if (!bridge->slot_get) {
1759 printk(KERN_WARNING "vme_slot_num not supported\n");
1760 return -EINVAL;
1761 }
1762
1763 return bridge->slot_get(bridge);
1764}
1765EXPORT_SYMBOL(vme_slot_num);
1766
1767/**
1768 * vme_bus_num - Retrieve bus number
1769 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1770 *
1771 * Retrieve the bus enumeration associated with the provided VME device.
1772 *
1773 * Return: The bus number on success, -EINVAL if VME bridge cannot be
1774 * determined.
1775 */
1776int vme_bus_num(struct vme_dev *vdev)
1777{
1778 struct vme_bridge *bridge;
1779
1780 bridge = vdev->bridge;
1781 if (!bridge) {
1782 pr_err("Can't find VME bus\n");
1783 return -EINVAL;
1784 }
1785
1786 return bridge->num;
1787}
1788EXPORT_SYMBOL(vme_bus_num);
1789
1790/* - Bridge Registration --------------------------------------------------- */
1791
1792static void vme_dev_release(struct device *dev)
1793{
1794 kfree(dev_to_vme_dev(dev));
1795}
1796
1797/* Common bridge initialization */
1798struct vme_bridge *vme_init_bridge(struct vme_bridge *bridge)
1799{
1800 INIT_LIST_HEAD(&bridge->vme_error_handlers);
1801 INIT_LIST_HEAD(&bridge->master_resources);
1802 INIT_LIST_HEAD(&bridge->slave_resources);
1803 INIT_LIST_HEAD(&bridge->dma_resources);
1804 INIT_LIST_HEAD(&bridge->lm_resources);
1805 mutex_init(&bridge->irq_mtx);
1806
1807 return bridge;
1808}
1809EXPORT_SYMBOL(vme_init_bridge);
1810
1811int vme_register_bridge(struct vme_bridge *bridge)
1812{
1813 int i;
1814 int ret = -1;
1815
1816 mutex_lock(&vme_buses_lock);
1817 for (i = 0; i < sizeof(vme_bus_numbers) * 8; i++) {
1818 if ((vme_bus_numbers & (1 << i)) == 0) {
1819 vme_bus_numbers |= (1 << i);
1820 bridge->num = i;
1821 INIT_LIST_HEAD(&bridge->devices);
1822 list_add_tail(&bridge->bus_list, &vme_bus_list);
1823 ret = 0;
1824 break;
1825 }
1826 }
1827 mutex_unlock(&vme_buses_lock);
1828
1829 return ret;
1830}
1831EXPORT_SYMBOL(vme_register_bridge);
1832
1833void vme_unregister_bridge(struct vme_bridge *bridge)
1834{
1835 struct vme_dev *vdev;
1836 struct vme_dev *tmp;
1837
1838 mutex_lock(&vme_buses_lock);
1839 vme_bus_numbers &= ~(1 << bridge->num);
1840 list_for_each_entry_safe(vdev, tmp, &bridge->devices, bridge_list) {
1841 list_del(&vdev->drv_list);
1842 list_del(&vdev->bridge_list);
1843 device_unregister(&vdev->dev);
1844 }
1845 list_del(&bridge->bus_list);
1846 mutex_unlock(&vme_buses_lock);
1847}
1848EXPORT_SYMBOL(vme_unregister_bridge);
1849
1850/* - Driver Registration --------------------------------------------------- */
1851
1852static int __vme_register_driver_bus(struct vme_driver *drv,
1853 struct vme_bridge *bridge, unsigned int ndevs)
1854{
1855 int err;
1856 unsigned int i;
1857 struct vme_dev *vdev;
1858 struct vme_dev *tmp;
1859
1860 for (i = 0; i < ndevs; i++) {
1861 vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
1862 if (!vdev) {
1863 err = -ENOMEM;
1864 goto err_devalloc;
1865 }
1866 vdev->num = i;
1867 vdev->bridge = bridge;
1868 vdev->dev.platform_data = drv;
1869 vdev->dev.release = vme_dev_release;
1870 vdev->dev.parent = bridge->parent;
1871 vdev->dev.bus = &vme_bus_type;
1872 dev_set_name(&vdev->dev, "%s.%u-%u", drv->name, bridge->num,
1873 vdev->num);
1874
1875 err = device_register(&vdev->dev);
1876 if (err)
1877 goto err_reg;
1878
1879 if (vdev->dev.platform_data) {
1880 list_add_tail(&vdev->drv_list, &drv->devices);
1881 list_add_tail(&vdev->bridge_list, &bridge->devices);
1882 } else
1883 device_unregister(&vdev->dev);
1884 }
1885 return 0;
1886
1887err_reg:
1888 put_device(&vdev->dev);
1889err_devalloc:
1890 list_for_each_entry_safe(vdev, tmp, &drv->devices, drv_list) {
1891 list_del(&vdev->drv_list);
1892 list_del(&vdev->bridge_list);
1893 device_unregister(&vdev->dev);
1894 }
1895 return err;
1896}
1897
1898static int __vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1899{
1900 struct vme_bridge *bridge;
1901 int err = 0;
1902
1903 mutex_lock(&vme_buses_lock);
1904 list_for_each_entry(bridge, &vme_bus_list, bus_list) {
1905 /*
1906 * This cannot cause trouble as we already have vme_buses_lock
1907 * and if the bridge is removed, it will have to go through
1908 * vme_unregister_bridge() to do it (which calls remove() on
1909 * the bridge which in turn tries to acquire vme_buses_lock and
1910 * will have to wait).
1911 */
1912 err = __vme_register_driver_bus(drv, bridge, ndevs);
1913 if (err)
1914 break;
1915 }
1916 mutex_unlock(&vme_buses_lock);
1917 return err;
1918}
1919
1920/**
1921 * vme_register_driver - Register a VME driver
1922 * @drv: Pointer to VME driver structure to register.
1923 * @ndevs: Maximum number of devices to allow to be enumerated.
1924 *
1925 * Register a VME device driver with the VME subsystem.
1926 *
1927 * Return: Zero on success, error value on registration failure.
1928 */
1929int vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1930{
1931 int err;
1932
1933 drv->driver.name = drv->name;
1934 drv->driver.bus = &vme_bus_type;
1935 INIT_LIST_HEAD(&drv->devices);
1936
1937 err = driver_register(&drv->driver);
1938 if (err)
1939 return err;
1940
1941 err = __vme_register_driver(drv, ndevs);
1942 if (err)
1943 driver_unregister(&drv->driver);
1944
1945 return err;
1946}
1947EXPORT_SYMBOL(vme_register_driver);
1948
1949/**
1950 * vme_unregister_driver - Unregister a VME driver
1951 * @drv: Pointer to VME driver structure to unregister.
1952 *
1953 * Unregister a VME device driver from the VME subsystem.
1954 */
1955void vme_unregister_driver(struct vme_driver *drv)
1956{
1957 struct vme_dev *dev, *dev_tmp;
1958
1959 mutex_lock(&vme_buses_lock);
1960 list_for_each_entry_safe(dev, dev_tmp, &drv->devices, drv_list) {
1961 list_del(&dev->drv_list);
1962 list_del(&dev->bridge_list);
1963 device_unregister(&dev->dev);
1964 }
1965 mutex_unlock(&vme_buses_lock);
1966
1967 driver_unregister(&drv->driver);
1968}
1969EXPORT_SYMBOL(vme_unregister_driver);
1970
1971/* - Bus Registration ------------------------------------------------------ */
1972
1973static int vme_bus_match(struct device *dev, struct device_driver *drv)
1974{
1975 struct vme_driver *vme_drv;
1976
1977 vme_drv = container_of(drv, struct vme_driver, driver);
1978
1979 if (dev->platform_data == vme_drv) {
1980 struct vme_dev *vdev = dev_to_vme_dev(dev);
1981
1982 if (vme_drv->match && vme_drv->match(vdev))
1983 return 1;
1984
1985 dev->platform_data = NULL;
1986 }
1987 return 0;
1988}
1989
1990static int vme_bus_probe(struct device *dev)
1991{
1992 struct vme_driver *driver;
1993 struct vme_dev *vdev = dev_to_vme_dev(dev);
1994
1995 driver = dev->platform_data;
1996 if (driver->probe)
1997 return driver->probe(vdev);
1998
1999 return -ENODEV;
2000}
2001
2002static int vme_bus_remove(struct device *dev)
2003{
2004 struct vme_driver *driver;
2005 struct vme_dev *vdev = dev_to_vme_dev(dev);
2006
2007 driver = dev->platform_data;
2008 if (driver->remove)
2009 return driver->remove(vdev);
2010
2011 return -ENODEV;
2012}
2013
2014struct bus_type vme_bus_type = {
2015 .name = "vme",
2016 .match = vme_bus_match,
2017 .probe = vme_bus_probe,
2018 .remove = vme_bus_remove,
2019};
2020EXPORT_SYMBOL(vme_bus_type);
2021
2022static int __init vme_init(void)
2023{
2024 return bus_register(&vme_bus_type);
2025}
2026subsys_initcall(vme_init);