4 * Author: Martyn Welch <martyn.welch@ge.com>
5 * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
7 * Based on work by Tom Armistead and Ajit Prem
8 * Copyright 2004 Motorola Inc.
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.
16 #include <linux/module.h>
17 #include <linux/moduleparam.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>
30 #include <linux/mutex.h>
31 #include <linux/spinlock.h>
32 #include <linux/slab.h>
33 #include <linux/vme.h>
35 #include "vme_bridge.h"
37 /* Bitmask and list of registered buses both protected by common mutex */
38 static unsigned int vme_bus_numbers
;
39 static LIST_HEAD(vme_bus_list
);
40 static DEFINE_MUTEX(vme_buses_lock
);
42 static void __exit
vme_exit(void);
43 static int __init
vme_init(void);
45 static struct vme_dev
*dev_to_vme_dev(struct device
*dev
)
47 return container_of(dev
, struct vme_dev
, dev
);
51 * Find the bridge that the resource is associated with.
53 static struct vme_bridge
*find_bridge(struct vme_resource
*resource
)
55 /* Get list to search */
56 switch (resource
->type
) {
58 return list_entry(resource
->entry
, struct vme_master_resource
,
62 return list_entry(resource
->entry
, struct vme_slave_resource
,
66 return list_entry(resource
->entry
, struct vme_dma_resource
,
70 return list_entry(resource
->entry
, struct vme_lm_resource
,
74 printk(KERN_ERR
"Unknown resource type\n");
81 * Allocate a contiguous block of memory for use by the driver. This is used to
82 * create the buffers for the slave windows.
84 void *vme_alloc_consistent(struct vme_resource
*resource
, size_t size
,
87 struct vme_bridge
*bridge
;
89 if (resource
== NULL
) {
90 printk(KERN_ERR
"No resource\n");
94 bridge
= find_bridge(resource
);
96 printk(KERN_ERR
"Can't find bridge\n");
100 if (bridge
->parent
== NULL
) {
101 printk(KERN_ERR
"Dev entry NULL for bridge %s\n", bridge
->name
);
105 if (bridge
->alloc_consistent
== NULL
) {
106 printk(KERN_ERR
"alloc_consistent not supported by bridge %s\n",
111 return bridge
->alloc_consistent(bridge
->parent
, size
, dma
);
113 EXPORT_SYMBOL(vme_alloc_consistent
);
116 * Free previously allocated contiguous block of memory.
118 void vme_free_consistent(struct vme_resource
*resource
, size_t size
,
119 void *vaddr
, dma_addr_t dma
)
121 struct vme_bridge
*bridge
;
123 if (resource
== NULL
) {
124 printk(KERN_ERR
"No resource\n");
128 bridge
= find_bridge(resource
);
129 if (bridge
== NULL
) {
130 printk(KERN_ERR
"Can't find bridge\n");
134 if (bridge
->parent
== NULL
) {
135 printk(KERN_ERR
"Dev entry NULL for bridge %s\n", bridge
->name
);
139 if (bridge
->free_consistent
== NULL
) {
140 printk(KERN_ERR
"free_consistent not supported by bridge %s\n",
145 bridge
->free_consistent(bridge
->parent
, size
, vaddr
, dma
);
147 EXPORT_SYMBOL(vme_free_consistent
);
149 size_t vme_get_size(struct vme_resource
*resource
)
152 unsigned long long base
, size
;
154 u32 aspace
, cycle
, dwidth
;
156 switch (resource
->type
) {
158 retval
= vme_master_get(resource
, &enabled
, &base
, &size
,
159 &aspace
, &cycle
, &dwidth
);
164 retval
= vme_slave_get(resource
, &enabled
, &base
, &size
,
165 &buf_base
, &aspace
, &cycle
);
173 printk(KERN_ERR
"Unknown resource type\n");
178 EXPORT_SYMBOL(vme_get_size
);
180 static int vme_check_window(u32 aspace
, unsigned long long vme_base
,
181 unsigned long long size
)
187 if (((vme_base
+ size
) > VME_A16_MAX
) ||
188 (vme_base
> VME_A16_MAX
))
192 if (((vme_base
+ size
) > VME_A24_MAX
) ||
193 (vme_base
> VME_A24_MAX
))
197 if (((vme_base
+ size
) > VME_A32_MAX
) ||
198 (vme_base
> VME_A32_MAX
))
203 * Any value held in an unsigned long long can be used as the
208 if (((vme_base
+ size
) > VME_CRCSR_MAX
) ||
209 (vme_base
> VME_CRCSR_MAX
))
219 printk(KERN_ERR
"Invalid address space\n");
228 * Request a slave image with specific attributes, return some unique
231 struct vme_resource
*vme_slave_request(struct vme_dev
*vdev
, u32 address
,
234 struct vme_bridge
*bridge
;
235 struct list_head
*slave_pos
= NULL
;
236 struct vme_slave_resource
*allocated_image
= NULL
;
237 struct vme_slave_resource
*slave_image
= NULL
;
238 struct vme_resource
*resource
= NULL
;
240 bridge
= vdev
->bridge
;
241 if (bridge
== NULL
) {
242 printk(KERN_ERR
"Can't find VME bus\n");
246 /* Loop through slave resources */
247 list_for_each(slave_pos
, &bridge
->slave_resources
) {
248 slave_image
= list_entry(slave_pos
,
249 struct vme_slave_resource
, list
);
251 if (slave_image
== NULL
) {
252 printk(KERN_ERR
"Registered NULL Slave resource\n");
256 /* Find an unlocked and compatible image */
257 mutex_lock(&slave_image
->mtx
);
258 if (((slave_image
->address_attr
& address
) == address
) &&
259 ((slave_image
->cycle_attr
& cycle
) == cycle
) &&
260 (slave_image
->locked
== 0)) {
262 slave_image
->locked
= 1;
263 mutex_unlock(&slave_image
->mtx
);
264 allocated_image
= slave_image
;
267 mutex_unlock(&slave_image
->mtx
);
271 if (allocated_image
== NULL
)
274 resource
= kmalloc(sizeof(struct vme_resource
), GFP_KERNEL
);
275 if (resource
== NULL
) {
276 printk(KERN_WARNING
"Unable to allocate resource structure\n");
279 resource
->type
= VME_SLAVE
;
280 resource
->entry
= &allocated_image
->list
;
286 mutex_lock(&slave_image
->mtx
);
287 slave_image
->locked
= 0;
288 mutex_unlock(&slave_image
->mtx
);
293 EXPORT_SYMBOL(vme_slave_request
);
295 int vme_slave_set(struct vme_resource
*resource
, int enabled
,
296 unsigned long long vme_base
, unsigned long long size
,
297 dma_addr_t buf_base
, u32 aspace
, u32 cycle
)
299 struct vme_bridge
*bridge
= find_bridge(resource
);
300 struct vme_slave_resource
*image
;
303 if (resource
->type
!= VME_SLAVE
) {
304 printk(KERN_ERR
"Not a slave resource\n");
308 image
= list_entry(resource
->entry
, struct vme_slave_resource
, list
);
310 if (bridge
->slave_set
== NULL
) {
311 printk(KERN_ERR
"Function not supported\n");
315 if (!(((image
->address_attr
& aspace
) == aspace
) &&
316 ((image
->cycle_attr
& cycle
) == cycle
))) {
317 printk(KERN_ERR
"Invalid attributes\n");
321 retval
= vme_check_window(aspace
, vme_base
, size
);
325 return bridge
->slave_set(image
, enabled
, vme_base
, size
, buf_base
,
328 EXPORT_SYMBOL(vme_slave_set
);
330 int vme_slave_get(struct vme_resource
*resource
, int *enabled
,
331 unsigned long long *vme_base
, unsigned long long *size
,
332 dma_addr_t
*buf_base
, u32
*aspace
, u32
*cycle
)
334 struct vme_bridge
*bridge
= find_bridge(resource
);
335 struct vme_slave_resource
*image
;
337 if (resource
->type
!= VME_SLAVE
) {
338 printk(KERN_ERR
"Not a slave resource\n");
342 image
= list_entry(resource
->entry
, struct vme_slave_resource
, list
);
344 if (bridge
->slave_get
== NULL
) {
345 printk(KERN_ERR
"vme_slave_get not supported\n");
349 return bridge
->slave_get(image
, enabled
, vme_base
, size
, buf_base
,
352 EXPORT_SYMBOL(vme_slave_get
);
354 void vme_slave_free(struct vme_resource
*resource
)
356 struct vme_slave_resource
*slave_image
;
358 if (resource
->type
!= VME_SLAVE
) {
359 printk(KERN_ERR
"Not a slave resource\n");
363 slave_image
= list_entry(resource
->entry
, struct vme_slave_resource
,
365 if (slave_image
== NULL
) {
366 printk(KERN_ERR
"Can't find slave resource\n");
371 mutex_lock(&slave_image
->mtx
);
372 if (slave_image
->locked
== 0)
373 printk(KERN_ERR
"Image is already free\n");
375 slave_image
->locked
= 0;
376 mutex_unlock(&slave_image
->mtx
);
378 /* Free up resource memory */
381 EXPORT_SYMBOL(vme_slave_free
);
384 * Request a master image with specific attributes, return some unique
387 struct vme_resource
*vme_master_request(struct vme_dev
*vdev
, u32 address
,
388 u32 cycle
, u32 dwidth
)
390 struct vme_bridge
*bridge
;
391 struct list_head
*master_pos
= NULL
;
392 struct vme_master_resource
*allocated_image
= NULL
;
393 struct vme_master_resource
*master_image
= NULL
;
394 struct vme_resource
*resource
= NULL
;
396 bridge
= vdev
->bridge
;
397 if (bridge
== NULL
) {
398 printk(KERN_ERR
"Can't find VME bus\n");
402 /* Loop through master resources */
403 list_for_each(master_pos
, &bridge
->master_resources
) {
404 master_image
= list_entry(master_pos
,
405 struct vme_master_resource
, list
);
407 if (master_image
== NULL
) {
408 printk(KERN_WARNING
"Registered NULL master resource\n");
412 /* Find an unlocked and compatible image */
413 spin_lock(&master_image
->lock
);
414 if (((master_image
->address_attr
& address
) == address
) &&
415 ((master_image
->cycle_attr
& cycle
) == cycle
) &&
416 ((master_image
->width_attr
& dwidth
) == dwidth
) &&
417 (master_image
->locked
== 0)) {
419 master_image
->locked
= 1;
420 spin_unlock(&master_image
->lock
);
421 allocated_image
= master_image
;
424 spin_unlock(&master_image
->lock
);
427 /* Check to see if we found a resource */
428 if (allocated_image
== NULL
) {
429 printk(KERN_ERR
"Can't find a suitable resource\n");
433 resource
= kmalloc(sizeof(struct vme_resource
), GFP_KERNEL
);
434 if (resource
== NULL
) {
435 printk(KERN_ERR
"Unable to allocate resource structure\n");
438 resource
->type
= VME_MASTER
;
439 resource
->entry
= &allocated_image
->list
;
445 spin_lock(&master_image
->lock
);
446 master_image
->locked
= 0;
447 spin_unlock(&master_image
->lock
);
452 EXPORT_SYMBOL(vme_master_request
);
454 int vme_master_set(struct vme_resource
*resource
, int enabled
,
455 unsigned long long vme_base
, unsigned long long size
, u32 aspace
,
456 u32 cycle
, u32 dwidth
)
458 struct vme_bridge
*bridge
= find_bridge(resource
);
459 struct vme_master_resource
*image
;
462 if (resource
->type
!= VME_MASTER
) {
463 printk(KERN_ERR
"Not a master resource\n");
467 image
= list_entry(resource
->entry
, struct vme_master_resource
, list
);
469 if (bridge
->master_set
== NULL
) {
470 printk(KERN_WARNING
"vme_master_set not supported\n");
474 if (!(((image
->address_attr
& aspace
) == aspace
) &&
475 ((image
->cycle_attr
& cycle
) == cycle
) &&
476 ((image
->width_attr
& dwidth
) == dwidth
))) {
477 printk(KERN_WARNING
"Invalid attributes\n");
481 retval
= vme_check_window(aspace
, vme_base
, size
);
485 return bridge
->master_set(image
, enabled
, vme_base
, size
, aspace
,
488 EXPORT_SYMBOL(vme_master_set
);
490 int vme_master_get(struct vme_resource
*resource
, int *enabled
,
491 unsigned long long *vme_base
, unsigned long long *size
, u32
*aspace
,
492 u32
*cycle
, u32
*dwidth
)
494 struct vme_bridge
*bridge
= find_bridge(resource
);
495 struct vme_master_resource
*image
;
497 if (resource
->type
!= VME_MASTER
) {
498 printk(KERN_ERR
"Not a master resource\n");
502 image
= list_entry(resource
->entry
, struct vme_master_resource
, list
);
504 if (bridge
->master_get
== NULL
) {
505 printk(KERN_WARNING
"%s not supported\n", __func__
);
509 return bridge
->master_get(image
, enabled
, vme_base
, size
, aspace
,
512 EXPORT_SYMBOL(vme_master_get
);
515 * Read data out of VME space into a buffer.
517 ssize_t
vme_master_read(struct vme_resource
*resource
, void *buf
, size_t count
,
520 struct vme_bridge
*bridge
= find_bridge(resource
);
521 struct vme_master_resource
*image
;
524 if (bridge
->master_read
== NULL
) {
525 printk(KERN_WARNING
"Reading from resource not supported\n");
529 if (resource
->type
!= VME_MASTER
) {
530 printk(KERN_ERR
"Not a master resource\n");
534 image
= list_entry(resource
->entry
, struct vme_master_resource
, list
);
536 length
= vme_get_size(resource
);
538 if (offset
> length
) {
539 printk(KERN_WARNING
"Invalid Offset\n");
543 if ((offset
+ count
) > length
)
544 count
= length
- offset
;
546 return bridge
->master_read(image
, buf
, count
, offset
);
549 EXPORT_SYMBOL(vme_master_read
);
552 * Write data out to VME space from a buffer.
554 ssize_t
vme_master_write(struct vme_resource
*resource
, void *buf
,
555 size_t count
, loff_t offset
)
557 struct vme_bridge
*bridge
= find_bridge(resource
);
558 struct vme_master_resource
*image
;
561 if (bridge
->master_write
== NULL
) {
562 printk(KERN_WARNING
"Writing to resource not supported\n");
566 if (resource
->type
!= VME_MASTER
) {
567 printk(KERN_ERR
"Not a master resource\n");
571 image
= list_entry(resource
->entry
, struct vme_master_resource
, list
);
573 length
= vme_get_size(resource
);
575 if (offset
> length
) {
576 printk(KERN_WARNING
"Invalid Offset\n");
580 if ((offset
+ count
) > length
)
581 count
= length
- offset
;
583 return bridge
->master_write(image
, buf
, count
, offset
);
585 EXPORT_SYMBOL(vme_master_write
);
588 * Perform RMW cycle to provided location.
590 unsigned int vme_master_rmw(struct vme_resource
*resource
, unsigned int mask
,
591 unsigned int compare
, unsigned int swap
, loff_t offset
)
593 struct vme_bridge
*bridge
= find_bridge(resource
);
594 struct vme_master_resource
*image
;
596 if (bridge
->master_rmw
== NULL
) {
597 printk(KERN_WARNING
"Writing to resource not supported\n");
601 if (resource
->type
!= VME_MASTER
) {
602 printk(KERN_ERR
"Not a master resource\n");
606 image
= list_entry(resource
->entry
, struct vme_master_resource
, list
);
608 return bridge
->master_rmw(image
, mask
, compare
, swap
, offset
);
610 EXPORT_SYMBOL(vme_master_rmw
);
612 int vme_master_mmap(struct vme_resource
*resource
, struct vm_area_struct
*vma
)
614 struct vme_master_resource
*image
;
615 phys_addr_t phys_addr
;
616 unsigned long vma_size
;
618 if (resource
->type
!= VME_MASTER
) {
619 pr_err("Not a master resource\n");
623 image
= list_entry(resource
->entry
, struct vme_master_resource
, list
);
624 phys_addr
= image
->bus_resource
.start
+ (vma
->vm_pgoff
<< PAGE_SHIFT
);
625 vma_size
= vma
->vm_end
- vma
->vm_start
;
627 if (phys_addr
+ vma_size
> image
->bus_resource
.end
+ 1) {
628 pr_err("Map size cannot exceed the window size\n");
632 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
634 return vm_iomap_memory(vma
, phys_addr
, vma
->vm_end
- vma
->vm_start
);
636 EXPORT_SYMBOL(vme_master_mmap
);
638 void vme_master_free(struct vme_resource
*resource
)
640 struct vme_master_resource
*master_image
;
642 if (resource
->type
!= VME_MASTER
) {
643 printk(KERN_ERR
"Not a master resource\n");
647 master_image
= list_entry(resource
->entry
, struct vme_master_resource
,
649 if (master_image
== NULL
) {
650 printk(KERN_ERR
"Can't find master resource\n");
655 spin_lock(&master_image
->lock
);
656 if (master_image
->locked
== 0)
657 printk(KERN_ERR
"Image is already free\n");
659 master_image
->locked
= 0;
660 spin_unlock(&master_image
->lock
);
662 /* Free up resource memory */
665 EXPORT_SYMBOL(vme_master_free
);
668 * Request a DMA controller with specific attributes, return some unique
671 struct vme_resource
*vme_dma_request(struct vme_dev
*vdev
, u32 route
)
673 struct vme_bridge
*bridge
;
674 struct list_head
*dma_pos
= NULL
;
675 struct vme_dma_resource
*allocated_ctrlr
= NULL
;
676 struct vme_dma_resource
*dma_ctrlr
= NULL
;
677 struct vme_resource
*resource
= NULL
;
679 /* XXX Not checking resource attributes */
680 printk(KERN_ERR
"No VME resource Attribute tests done\n");
682 bridge
= vdev
->bridge
;
683 if (bridge
== NULL
) {
684 printk(KERN_ERR
"Can't find VME bus\n");
688 /* Loop through DMA resources */
689 list_for_each(dma_pos
, &bridge
->dma_resources
) {
690 dma_ctrlr
= list_entry(dma_pos
,
691 struct vme_dma_resource
, list
);
693 if (dma_ctrlr
== NULL
) {
694 printk(KERN_ERR
"Registered NULL DMA resource\n");
698 /* Find an unlocked and compatible controller */
699 mutex_lock(&dma_ctrlr
->mtx
);
700 if (((dma_ctrlr
->route_attr
& route
) == route
) &&
701 (dma_ctrlr
->locked
== 0)) {
703 dma_ctrlr
->locked
= 1;
704 mutex_unlock(&dma_ctrlr
->mtx
);
705 allocated_ctrlr
= dma_ctrlr
;
708 mutex_unlock(&dma_ctrlr
->mtx
);
711 /* Check to see if we found a resource */
712 if (allocated_ctrlr
== NULL
)
715 resource
= kmalloc(sizeof(struct vme_resource
), GFP_KERNEL
);
716 if (resource
== NULL
) {
717 printk(KERN_WARNING
"Unable to allocate resource structure\n");
720 resource
->type
= VME_DMA
;
721 resource
->entry
= &allocated_ctrlr
->list
;
727 mutex_lock(&dma_ctrlr
->mtx
);
728 dma_ctrlr
->locked
= 0;
729 mutex_unlock(&dma_ctrlr
->mtx
);
734 EXPORT_SYMBOL(vme_dma_request
);
739 struct vme_dma_list
*vme_new_dma_list(struct vme_resource
*resource
)
741 struct vme_dma_resource
*ctrlr
;
742 struct vme_dma_list
*dma_list
;
744 if (resource
->type
!= VME_DMA
) {
745 printk(KERN_ERR
"Not a DMA resource\n");
749 ctrlr
= list_entry(resource
->entry
, struct vme_dma_resource
, list
);
751 dma_list
= kmalloc(sizeof(struct vme_dma_list
), GFP_KERNEL
);
752 if (dma_list
== NULL
) {
753 printk(KERN_ERR
"Unable to allocate memory for new dma list\n");
756 INIT_LIST_HEAD(&dma_list
->entries
);
757 dma_list
->parent
= ctrlr
;
758 mutex_init(&dma_list
->mtx
);
762 EXPORT_SYMBOL(vme_new_dma_list
);
765 * Create "Pattern" type attributes
767 struct vme_dma_attr
*vme_dma_pattern_attribute(u32 pattern
, u32 type
)
769 struct vme_dma_attr
*attributes
;
770 struct vme_dma_pattern
*pattern_attr
;
772 attributes
= kmalloc(sizeof(struct vme_dma_attr
), GFP_KERNEL
);
773 if (attributes
== NULL
) {
774 printk(KERN_ERR
"Unable to allocate memory for attributes structure\n");
778 pattern_attr
= kmalloc(sizeof(struct vme_dma_pattern
), GFP_KERNEL
);
779 if (pattern_attr
== NULL
) {
780 printk(KERN_ERR
"Unable to allocate memory for pattern attributes\n");
784 attributes
->type
= VME_DMA_PATTERN
;
785 attributes
->private = (void *)pattern_attr
;
787 pattern_attr
->pattern
= pattern
;
788 pattern_attr
->type
= type
;
797 EXPORT_SYMBOL(vme_dma_pattern_attribute
);
800 * Create "PCI" type attributes
802 struct vme_dma_attr
*vme_dma_pci_attribute(dma_addr_t address
)
804 struct vme_dma_attr
*attributes
;
805 struct vme_dma_pci
*pci_attr
;
807 /* XXX Run some sanity checks here */
809 attributes
= kmalloc(sizeof(struct vme_dma_attr
), GFP_KERNEL
);
810 if (attributes
== NULL
) {
811 printk(KERN_ERR
"Unable to allocate memory for attributes structure\n");
815 pci_attr
= kmalloc(sizeof(struct vme_dma_pci
), GFP_KERNEL
);
816 if (pci_attr
== NULL
) {
817 printk(KERN_ERR
"Unable to allocate memory for pci attributes\n");
823 attributes
->type
= VME_DMA_PCI
;
824 attributes
->private = (void *)pci_attr
;
826 pci_attr
->address
= address
;
835 EXPORT_SYMBOL(vme_dma_pci_attribute
);
838 * Create "VME" type attributes
840 struct vme_dma_attr
*vme_dma_vme_attribute(unsigned long long address
,
841 u32 aspace
, u32 cycle
, u32 dwidth
)
843 struct vme_dma_attr
*attributes
;
844 struct vme_dma_vme
*vme_attr
;
846 attributes
= kmalloc(
847 sizeof(struct vme_dma_attr
), GFP_KERNEL
);
848 if (attributes
== NULL
) {
849 printk(KERN_ERR
"Unable to allocate memory for attributes structure\n");
853 vme_attr
= kmalloc(sizeof(struct vme_dma_vme
), GFP_KERNEL
);
854 if (vme_attr
== NULL
) {
855 printk(KERN_ERR
"Unable to allocate memory for vme attributes\n");
859 attributes
->type
= VME_DMA_VME
;
860 attributes
->private = (void *)vme_attr
;
862 vme_attr
->address
= address
;
863 vme_attr
->aspace
= aspace
;
864 vme_attr
->cycle
= cycle
;
865 vme_attr
->dwidth
= dwidth
;
874 EXPORT_SYMBOL(vme_dma_vme_attribute
);
879 void vme_dma_free_attribute(struct vme_dma_attr
*attributes
)
881 kfree(attributes
->private);
884 EXPORT_SYMBOL(vme_dma_free_attribute
);
886 int vme_dma_list_add(struct vme_dma_list
*list
, struct vme_dma_attr
*src
,
887 struct vme_dma_attr
*dest
, size_t count
)
889 struct vme_bridge
*bridge
= list
->parent
->parent
;
892 if (bridge
->dma_list_add
== NULL
) {
893 printk(KERN_WARNING
"Link List DMA generation not supported\n");
897 if (!mutex_trylock(&list
->mtx
)) {
898 printk(KERN_ERR
"Link List already submitted\n");
902 retval
= bridge
->dma_list_add(list
, src
, dest
, count
);
904 mutex_unlock(&list
->mtx
);
908 EXPORT_SYMBOL(vme_dma_list_add
);
910 int vme_dma_list_exec(struct vme_dma_list
*list
)
912 struct vme_bridge
*bridge
= list
->parent
->parent
;
915 if (bridge
->dma_list_exec
== NULL
) {
916 printk(KERN_ERR
"Link List DMA execution not supported\n");
920 mutex_lock(&list
->mtx
);
922 retval
= bridge
->dma_list_exec(list
);
924 mutex_unlock(&list
->mtx
);
928 EXPORT_SYMBOL(vme_dma_list_exec
);
930 int vme_dma_list_free(struct vme_dma_list
*list
)
932 struct vme_bridge
*bridge
= list
->parent
->parent
;
935 if (bridge
->dma_list_empty
== NULL
) {
936 printk(KERN_WARNING
"Emptying of Link Lists not supported\n");
940 if (!mutex_trylock(&list
->mtx
)) {
941 printk(KERN_ERR
"Link List in use\n");
946 * Empty out all of the entries from the dma list. We need to go to the
947 * low level driver as dma entries are driver specific.
949 retval
= bridge
->dma_list_empty(list
);
951 printk(KERN_ERR
"Unable to empty link-list entries\n");
952 mutex_unlock(&list
->mtx
);
955 mutex_unlock(&list
->mtx
);
960 EXPORT_SYMBOL(vme_dma_list_free
);
962 int vme_dma_free(struct vme_resource
*resource
)
964 struct vme_dma_resource
*ctrlr
;
966 if (resource
->type
!= VME_DMA
) {
967 printk(KERN_ERR
"Not a DMA resource\n");
971 ctrlr
= list_entry(resource
->entry
, struct vme_dma_resource
, list
);
973 if (!mutex_trylock(&ctrlr
->mtx
)) {
974 printk(KERN_ERR
"Resource busy, can't free\n");
978 if (!(list_empty(&ctrlr
->pending
) && list_empty(&ctrlr
->running
))) {
979 printk(KERN_WARNING
"Resource still processing transfers\n");
980 mutex_unlock(&ctrlr
->mtx
);
986 mutex_unlock(&ctrlr
->mtx
);
992 EXPORT_SYMBOL(vme_dma_free
);
994 void vme_irq_handler(struct vme_bridge
*bridge
, int level
, int statid
)
996 void (*call
)(int, int, void *);
999 call
= bridge
->irq
[level
- 1].callback
[statid
].func
;
1000 priv_data
= bridge
->irq
[level
- 1].callback
[statid
].priv_data
;
1003 call(level
, statid
, priv_data
);
1005 printk(KERN_WARNING
"Spurilous VME interrupt, level:%x, vector:%x\n",
1008 EXPORT_SYMBOL(vme_irq_handler
);
1010 int vme_irq_request(struct vme_dev
*vdev
, int level
, int statid
,
1011 void (*callback
)(int, int, void *),
1014 struct vme_bridge
*bridge
;
1016 bridge
= vdev
->bridge
;
1017 if (bridge
== NULL
) {
1018 printk(KERN_ERR
"Can't find VME bus\n");
1022 if ((level
< 1) || (level
> 7)) {
1023 printk(KERN_ERR
"Invalid interrupt level\n");
1027 if (bridge
->irq_set
== NULL
) {
1028 printk(KERN_ERR
"Configuring interrupts not supported\n");
1032 mutex_lock(&bridge
->irq_mtx
);
1034 if (bridge
->irq
[level
- 1].callback
[statid
].func
) {
1035 mutex_unlock(&bridge
->irq_mtx
);
1036 printk(KERN_WARNING
"VME Interrupt already taken\n");
1040 bridge
->irq
[level
- 1].count
++;
1041 bridge
->irq
[level
- 1].callback
[statid
].priv_data
= priv_data
;
1042 bridge
->irq
[level
- 1].callback
[statid
].func
= callback
;
1044 /* Enable IRQ level */
1045 bridge
->irq_set(bridge
, level
, 1, 1);
1047 mutex_unlock(&bridge
->irq_mtx
);
1051 EXPORT_SYMBOL(vme_irq_request
);
1053 void vme_irq_free(struct vme_dev
*vdev
, int level
, int statid
)
1055 struct vme_bridge
*bridge
;
1057 bridge
= vdev
->bridge
;
1058 if (bridge
== NULL
) {
1059 printk(KERN_ERR
"Can't find VME bus\n");
1063 if ((level
< 1) || (level
> 7)) {
1064 printk(KERN_ERR
"Invalid interrupt level\n");
1068 if (bridge
->irq_set
== NULL
) {
1069 printk(KERN_ERR
"Configuring interrupts not supported\n");
1073 mutex_lock(&bridge
->irq_mtx
);
1075 bridge
->irq
[level
- 1].count
--;
1077 /* Disable IRQ level if no more interrupts attached at this level*/
1078 if (bridge
->irq
[level
- 1].count
== 0)
1079 bridge
->irq_set(bridge
, level
, 0, 1);
1081 bridge
->irq
[level
- 1].callback
[statid
].func
= NULL
;
1082 bridge
->irq
[level
- 1].callback
[statid
].priv_data
= NULL
;
1084 mutex_unlock(&bridge
->irq_mtx
);
1086 EXPORT_SYMBOL(vme_irq_free
);
1088 int vme_irq_generate(struct vme_dev
*vdev
, int level
, int statid
)
1090 struct vme_bridge
*bridge
;
1092 bridge
= vdev
->bridge
;
1093 if (bridge
== NULL
) {
1094 printk(KERN_ERR
"Can't find VME bus\n");
1098 if ((level
< 1) || (level
> 7)) {
1099 printk(KERN_WARNING
"Invalid interrupt level\n");
1103 if (bridge
->irq_generate
== NULL
) {
1104 printk(KERN_WARNING
"Interrupt generation not supported\n");
1108 return bridge
->irq_generate(bridge
, level
, statid
);
1110 EXPORT_SYMBOL(vme_irq_generate
);
1113 * Request the location monitor, return resource or NULL
1115 struct vme_resource
*vme_lm_request(struct vme_dev
*vdev
)
1117 struct vme_bridge
*bridge
;
1118 struct list_head
*lm_pos
= NULL
;
1119 struct vme_lm_resource
*allocated_lm
= NULL
;
1120 struct vme_lm_resource
*lm
= NULL
;
1121 struct vme_resource
*resource
= NULL
;
1123 bridge
= vdev
->bridge
;
1124 if (bridge
== NULL
) {
1125 printk(KERN_ERR
"Can't find VME bus\n");
1129 /* Loop through DMA resources */
1130 list_for_each(lm_pos
, &bridge
->lm_resources
) {
1131 lm
= list_entry(lm_pos
,
1132 struct vme_lm_resource
, list
);
1135 printk(KERN_ERR
"Registered NULL Location Monitor resource\n");
1139 /* Find an unlocked controller */
1140 mutex_lock(&lm
->mtx
);
1141 if (lm
->locked
== 0) {
1143 mutex_unlock(&lm
->mtx
);
1147 mutex_unlock(&lm
->mtx
);
1150 /* Check to see if we found a resource */
1151 if (allocated_lm
== NULL
)
1154 resource
= kmalloc(sizeof(struct vme_resource
), GFP_KERNEL
);
1155 if (resource
== NULL
) {
1156 printk(KERN_ERR
"Unable to allocate resource structure\n");
1159 resource
->type
= VME_LM
;
1160 resource
->entry
= &allocated_lm
->list
;
1166 mutex_lock(&lm
->mtx
);
1168 mutex_unlock(&lm
->mtx
);
1173 EXPORT_SYMBOL(vme_lm_request
);
1175 int vme_lm_count(struct vme_resource
*resource
)
1177 struct vme_lm_resource
*lm
;
1179 if (resource
->type
!= VME_LM
) {
1180 printk(KERN_ERR
"Not a Location Monitor resource\n");
1184 lm
= list_entry(resource
->entry
, struct vme_lm_resource
, list
);
1186 return lm
->monitors
;
1188 EXPORT_SYMBOL(vme_lm_count
);
1190 int vme_lm_set(struct vme_resource
*resource
, unsigned long long lm_base
,
1191 u32 aspace
, u32 cycle
)
1193 struct vme_bridge
*bridge
= find_bridge(resource
);
1194 struct vme_lm_resource
*lm
;
1196 if (resource
->type
!= VME_LM
) {
1197 printk(KERN_ERR
"Not a Location Monitor resource\n");
1201 lm
= list_entry(resource
->entry
, struct vme_lm_resource
, list
);
1203 if (bridge
->lm_set
== NULL
) {
1204 printk(KERN_ERR
"vme_lm_set not supported\n");
1208 return bridge
->lm_set(lm
, lm_base
, aspace
, cycle
);
1210 EXPORT_SYMBOL(vme_lm_set
);
1212 int vme_lm_get(struct vme_resource
*resource
, unsigned long long *lm_base
,
1213 u32
*aspace
, u32
*cycle
)
1215 struct vme_bridge
*bridge
= find_bridge(resource
);
1216 struct vme_lm_resource
*lm
;
1218 if (resource
->type
!= VME_LM
) {
1219 printk(KERN_ERR
"Not a Location Monitor resource\n");
1223 lm
= list_entry(resource
->entry
, struct vme_lm_resource
, list
);
1225 if (bridge
->lm_get
== NULL
) {
1226 printk(KERN_ERR
"vme_lm_get not supported\n");
1230 return bridge
->lm_get(lm
, lm_base
, aspace
, cycle
);
1232 EXPORT_SYMBOL(vme_lm_get
);
1234 int vme_lm_attach(struct vme_resource
*resource
, int monitor
,
1235 void (*callback
)(int))
1237 struct vme_bridge
*bridge
= find_bridge(resource
);
1238 struct vme_lm_resource
*lm
;
1240 if (resource
->type
!= VME_LM
) {
1241 printk(KERN_ERR
"Not a Location Monitor resource\n");
1245 lm
= list_entry(resource
->entry
, struct vme_lm_resource
, list
);
1247 if (bridge
->lm_attach
== NULL
) {
1248 printk(KERN_ERR
"vme_lm_attach not supported\n");
1252 return bridge
->lm_attach(lm
, monitor
, callback
);
1254 EXPORT_SYMBOL(vme_lm_attach
);
1256 int vme_lm_detach(struct vme_resource
*resource
, int monitor
)
1258 struct vme_bridge
*bridge
= find_bridge(resource
);
1259 struct vme_lm_resource
*lm
;
1261 if (resource
->type
!= VME_LM
) {
1262 printk(KERN_ERR
"Not a Location Monitor resource\n");
1266 lm
= list_entry(resource
->entry
, struct vme_lm_resource
, list
);
1268 if (bridge
->lm_detach
== NULL
) {
1269 printk(KERN_ERR
"vme_lm_detach not supported\n");
1273 return bridge
->lm_detach(lm
, monitor
);
1275 EXPORT_SYMBOL(vme_lm_detach
);
1277 void vme_lm_free(struct vme_resource
*resource
)
1279 struct vme_lm_resource
*lm
;
1281 if (resource
->type
!= VME_LM
) {
1282 printk(KERN_ERR
"Not a Location Monitor resource\n");
1286 lm
= list_entry(resource
->entry
, struct vme_lm_resource
, list
);
1288 mutex_lock(&lm
->mtx
);
1291 * Check to see that there aren't any callbacks still attached, if
1292 * there are we should probably be detaching them!
1297 mutex_unlock(&lm
->mtx
);
1301 EXPORT_SYMBOL(vme_lm_free
);
1303 int vme_slot_num(struct vme_dev
*vdev
)
1305 struct vme_bridge
*bridge
;
1307 bridge
= vdev
->bridge
;
1308 if (bridge
== NULL
) {
1309 printk(KERN_ERR
"Can't find VME bus\n");
1313 if (bridge
->slot_get
== NULL
) {
1314 printk(KERN_WARNING
"vme_slot_num not supported\n");
1318 return bridge
->slot_get(bridge
);
1320 EXPORT_SYMBOL(vme_slot_num
);
1322 int vme_bus_num(struct vme_dev
*vdev
)
1324 struct vme_bridge
*bridge
;
1326 bridge
= vdev
->bridge
;
1327 if (bridge
== NULL
) {
1328 pr_err("Can't find VME bus\n");
1334 EXPORT_SYMBOL(vme_bus_num
);
1336 /* - Bridge Registration --------------------------------------------------- */
1338 static void vme_dev_release(struct device
*dev
)
1340 kfree(dev_to_vme_dev(dev
));
1343 int vme_register_bridge(struct vme_bridge
*bridge
)
1348 mutex_lock(&vme_buses_lock
);
1349 for (i
= 0; i
< sizeof(vme_bus_numbers
) * 8; i
++) {
1350 if ((vme_bus_numbers
& (1 << i
)) == 0) {
1351 vme_bus_numbers
|= (1 << i
);
1353 INIT_LIST_HEAD(&bridge
->devices
);
1354 list_add_tail(&bridge
->bus_list
, &vme_bus_list
);
1359 mutex_unlock(&vme_buses_lock
);
1363 EXPORT_SYMBOL(vme_register_bridge
);
1365 void vme_unregister_bridge(struct vme_bridge
*bridge
)
1367 struct vme_dev
*vdev
;
1368 struct vme_dev
*tmp
;
1370 mutex_lock(&vme_buses_lock
);
1371 vme_bus_numbers
&= ~(1 << bridge
->num
);
1372 list_for_each_entry_safe(vdev
, tmp
, &bridge
->devices
, bridge_list
) {
1373 list_del(&vdev
->drv_list
);
1374 list_del(&vdev
->bridge_list
);
1375 device_unregister(&vdev
->dev
);
1377 list_del(&bridge
->bus_list
);
1378 mutex_unlock(&vme_buses_lock
);
1380 EXPORT_SYMBOL(vme_unregister_bridge
);
1382 /* - Driver Registration --------------------------------------------------- */
1384 static int __vme_register_driver_bus(struct vme_driver
*drv
,
1385 struct vme_bridge
*bridge
, unsigned int ndevs
)
1389 struct vme_dev
*vdev
;
1390 struct vme_dev
*tmp
;
1392 for (i
= 0; i
< ndevs
; i
++) {
1393 vdev
= kzalloc(sizeof(struct vme_dev
), GFP_KERNEL
);
1399 vdev
->bridge
= bridge
;
1400 vdev
->dev
.platform_data
= drv
;
1401 vdev
->dev
.release
= vme_dev_release
;
1402 vdev
->dev
.parent
= bridge
->parent
;
1403 vdev
->dev
.bus
= &vme_bus_type
;
1404 dev_set_name(&vdev
->dev
, "%s.%u-%u", drv
->name
, bridge
->num
,
1407 err
= device_register(&vdev
->dev
);
1411 if (vdev
->dev
.platform_data
) {
1412 list_add_tail(&vdev
->drv_list
, &drv
->devices
);
1413 list_add_tail(&vdev
->bridge_list
, &bridge
->devices
);
1415 device_unregister(&vdev
->dev
);
1420 put_device(&vdev
->dev
);
1423 list_for_each_entry_safe(vdev
, tmp
, &drv
->devices
, drv_list
) {
1424 list_del(&vdev
->drv_list
);
1425 list_del(&vdev
->bridge_list
);
1426 device_unregister(&vdev
->dev
);
1431 static int __vme_register_driver(struct vme_driver
*drv
, unsigned int ndevs
)
1433 struct vme_bridge
*bridge
;
1436 mutex_lock(&vme_buses_lock
);
1437 list_for_each_entry(bridge
, &vme_bus_list
, bus_list
) {
1439 * This cannot cause trouble as we already have vme_buses_lock
1440 * and if the bridge is removed, it will have to go through
1441 * vme_unregister_bridge() to do it (which calls remove() on
1442 * the bridge which in turn tries to acquire vme_buses_lock and
1443 * will have to wait).
1445 err
= __vme_register_driver_bus(drv
, bridge
, ndevs
);
1449 mutex_unlock(&vme_buses_lock
);
1453 int vme_register_driver(struct vme_driver
*drv
, unsigned int ndevs
)
1457 drv
->driver
.name
= drv
->name
;
1458 drv
->driver
.bus
= &vme_bus_type
;
1459 INIT_LIST_HEAD(&drv
->devices
);
1461 err
= driver_register(&drv
->driver
);
1465 err
= __vme_register_driver(drv
, ndevs
);
1467 driver_unregister(&drv
->driver
);
1471 EXPORT_SYMBOL(vme_register_driver
);
1473 void vme_unregister_driver(struct vme_driver
*drv
)
1475 struct vme_dev
*dev
, *dev_tmp
;
1477 mutex_lock(&vme_buses_lock
);
1478 list_for_each_entry_safe(dev
, dev_tmp
, &drv
->devices
, drv_list
) {
1479 list_del(&dev
->drv_list
);
1480 list_del(&dev
->bridge_list
);
1481 device_unregister(&dev
->dev
);
1483 mutex_unlock(&vme_buses_lock
);
1485 driver_unregister(&drv
->driver
);
1487 EXPORT_SYMBOL(vme_unregister_driver
);
1489 /* - Bus Registration ------------------------------------------------------ */
1491 static int vme_bus_match(struct device
*dev
, struct device_driver
*drv
)
1493 struct vme_driver
*vme_drv
;
1495 vme_drv
= container_of(drv
, struct vme_driver
, driver
);
1497 if (dev
->platform_data
== vme_drv
) {
1498 struct vme_dev
*vdev
= dev_to_vme_dev(dev
);
1500 if (vme_drv
->match
&& vme_drv
->match(vdev
))
1503 dev
->platform_data
= NULL
;
1508 static int vme_bus_probe(struct device
*dev
)
1510 int retval
= -ENODEV
;
1511 struct vme_driver
*driver
;
1512 struct vme_dev
*vdev
= dev_to_vme_dev(dev
);
1514 driver
= dev
->platform_data
;
1516 if (driver
->probe
!= NULL
)
1517 retval
= driver
->probe(vdev
);
1522 static int vme_bus_remove(struct device
*dev
)
1524 int retval
= -ENODEV
;
1525 struct vme_driver
*driver
;
1526 struct vme_dev
*vdev
= dev_to_vme_dev(dev
);
1528 driver
= dev
->platform_data
;
1530 if (driver
->remove
!= NULL
)
1531 retval
= driver
->remove(vdev
);
1536 struct bus_type vme_bus_type
= {
1538 .match
= vme_bus_match
,
1539 .probe
= vme_bus_probe
,
1540 .remove
= vme_bus_remove
,
1542 EXPORT_SYMBOL(vme_bus_type
);
1544 static int __init
vme_init(void)
1546 return bus_register(&vme_bus_type
);
1549 static void __exit
vme_exit(void)
1551 bus_unregister(&vme_bus_type
);
1554 subsys_initcall(vme_init
);
1555 module_exit(vme_exit
);