mirror of
https://github.com/torvalds/linux.git
synced 2024-11-13 23:51:39 +00:00
Staging: Update VME vme_user module
* Add ifdef wrapper to vme_user.h * Correct Initialisation routine * Add remove routine to correct probe routine * Remove old test routines Signed-off-by: Martyn Welch <martyn.welch@gefanuc.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Martyn Welch
Greg Kroah-Hartman
parent
75155020c8
commit
238add523b
@ -39,6 +39,11 @@
|
||||
#include "../vme.h"
|
||||
#include "vme_user.h"
|
||||
|
||||
static char driver_name[] = "vme_user";
|
||||
|
||||
static int bus[USER_BUS_MAX];
|
||||
static int bus_num;
|
||||
|
||||
/* Currently Documentation/devices.txt defines the following for VME:
|
||||
*
|
||||
* 221 char VME bus
|
||||
@ -65,6 +70,10 @@
|
||||
* defined above and try to support at least some of the interface from
|
||||
* http://www.vmelinux.org/ as an alternative drive can be written providing a
|
||||
* saner interface later.
|
||||
*
|
||||
* The vmelinux.org driver never supported slave images, the devices reserved
|
||||
* for slaves were repurposed to support all 8 master images on the UniverseII!
|
||||
* We shall support 4 masters and 4 slaves with this driver.
|
||||
*/
|
||||
#define VME_MAJOR 221 /* VME Major Device Number */
|
||||
#define VME_DEVS 9 /* Number of dev entries */
|
||||
@ -107,7 +116,6 @@ struct cdev *vme_user_cdev; /* Character device */
|
||||
struct class *vme_user_sysfs_class; /* Sysfs class */
|
||||
struct device *vme_user_bridge; /* Pointer to the bridge device */
|
||||
|
||||
static char driver_name[] = "vme_user";
|
||||
|
||||
static const int type[VME_DEVS] = { MASTER_MINOR, MASTER_MINOR,
|
||||
MASTER_MINOR, MASTER_MINOR,
|
||||
@ -125,7 +133,8 @@ static loff_t vme_user_llseek(struct file *, loff_t, int);
|
||||
static int vme_user_ioctl(struct inode *, struct file *, unsigned int,
|
||||
unsigned long);
|
||||
|
||||
static int __init vme_user_probe(struct device *dev);
|
||||
static int __init vme_user_probe(struct device *, int, int);
|
||||
static int __exit vme_user_remove(struct device *, int, int);
|
||||
|
||||
static struct file_operations vme_user_fops = {
|
||||
.open = vme_user_open,
|
||||
@ -151,61 +160,6 @@ static void reset_counters(void)
|
||||
statistics.timeouts = 0;
|
||||
}
|
||||
|
||||
void lmcall(int monitor)
|
||||
{
|
||||
printk("Caught Location Monitor %d access\n", monitor);
|
||||
}
|
||||
|
||||
static void tests(void)
|
||||
{
|
||||
struct vme_resource *dma_res;
|
||||
struct vme_dma_list *dma_list;
|
||||
struct vme_dma_attr *pattern_attr, *vme_attr;
|
||||
|
||||
int retval;
|
||||
unsigned int data;
|
||||
|
||||
printk("Running VME DMA test\n");
|
||||
dma_res = vme_request_dma(vme_user_bridge);
|
||||
dma_list = vme_new_dma_list(dma_res);
|
||||
pattern_attr = vme_dma_pattern_attribute(0x0,
|
||||
VME_DMA_PATTERN_WORD |
|
||||
VME_DMA_PATTERN_INCREMENT);
|
||||
vme_attr = vme_dma_vme_attribute(0x10000, VME_A32,
|
||||
VME_SCT, VME_D32);
|
||||
retval = vme_dma_list_add(dma_list, pattern_attr,
|
||||
vme_attr, 0x10000);
|
||||
#if 0
|
||||
vme_dma_free_attribute(vme_attr);
|
||||
vme_attr = vme_dma_vme_attribute(0x20000, VME_A32,
|
||||
VME_SCT, VME_D32);
|
||||
retval = vme_dma_list_add(dma_list, pattern_attr,
|
||||
vme_attr, 0x10000);
|
||||
#endif
|
||||
retval = vme_dma_list_exec(dma_list);
|
||||
vme_dma_free_attribute(pattern_attr);
|
||||
vme_dma_free_attribute(vme_attr);
|
||||
vme_dma_list_free(dma_list);
|
||||
#if 0
|
||||
printk("Generating a VME interrupt\n");
|
||||
vme_generate_irq(dma_res, 0x3, 0xaa);
|
||||
printk("Interrupt returned\n");
|
||||
#endif
|
||||
vme_dma_free(dma_res);
|
||||
|
||||
/* Attempt RMW */
|
||||
data = vme_master_rmw(image[0].resource, 0x80000000, 0x00000000,
|
||||
0x80000000, 0);
|
||||
printk("RMW returned 0x%8.8x\n", data);
|
||||
|
||||
|
||||
/* Location Monitor */
|
||||
printk("vme_lm_set:%d\n", vme_lm_set(vme_user_bridge, 0x60000, VME_A32, VME_SCT | VME_USER | VME_DATA));
|
||||
printk("vme_lm_attach:%d\n", vme_lm_attach(vme_user_bridge, 0, lmcall));
|
||||
|
||||
printk("Board in VME slot:%d\n", vme_slot_get(vme_user_bridge));
|
||||
}
|
||||
|
||||
static int vme_user_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
int err;
|
||||
@ -451,57 +405,118 @@ static loff_t vme_user_llseek(struct file *file, loff_t off, int whence)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* The ioctls provided by the old VME access method (the one at vmelinux.org)
|
||||
* are most certainly wrong as the effectively push the registers layout
|
||||
* through to user space. Given that the VME core can handle multiple bridges,
|
||||
* with different register layouts this is most certainly not the way to go.
|
||||
*
|
||||
* We aren't using the structures defined in the Motorola driver either - these
|
||||
* are also quite low level, however we should use the definitions that have
|
||||
* already been defined.
|
||||
*/
|
||||
static int vme_user_ioctl(struct inode *inode, struct file *file,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct vme_master master;
|
||||
struct vme_slave slave;
|
||||
unsigned long copied;
|
||||
unsigned int minor = MINOR(inode->i_rdev);
|
||||
#if 0
|
||||
int ret_val;
|
||||
#endif
|
||||
unsigned long copyRet;
|
||||
vme_slave_t slave;
|
||||
int retval;
|
||||
dma_addr_t pci_addr;
|
||||
|
||||
statistics.ioctls++;
|
||||
|
||||
switch (type[minor]) {
|
||||
case CONTROL_MINOR:
|
||||
break;
|
||||
case MASTER_MINOR:
|
||||
break;
|
||||
case SLAVE_MINOR:
|
||||
switch (cmd) {
|
||||
case VME_SET_SLAVE:
|
||||
case VME_GET_MASTER:
|
||||
memset(&master, 0, sizeof(struct vme_master));
|
||||
|
||||
copyRet = copy_from_user(&slave, (char *)arg,
|
||||
sizeof(slave));
|
||||
if (copyRet != 0) {
|
||||
/* XXX We do not want to push aspace, cycle and width
|
||||
* to userspace as they are
|
||||
*/
|
||||
retval = vme_master_get(image[minor].resource,
|
||||
&(master.enable), &(master.vme_addr),
|
||||
&(master.size), &(master.aspace),
|
||||
&(master.cycle), &(master.dwidth));
|
||||
|
||||
copied = copy_to_user((char *)arg, &master,
|
||||
sizeof(struct vme_master));
|
||||
if (copied != 0) {
|
||||
printk(KERN_WARNING "Partial copy to "
|
||||
"userspace\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return retval;
|
||||
break;
|
||||
|
||||
case VME_SET_MASTER:
|
||||
|
||||
copied = copy_from_user(&master, (char *)arg,
|
||||
sizeof(master));
|
||||
if (copied != 0) {
|
||||
printk(KERN_WARNING "Partial copy from "
|
||||
"userspace\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
/* XXX We do not want to push aspace, cycle and width
|
||||
* to userspace as they are
|
||||
*/
|
||||
return vme_master_set(image[minor].resource,
|
||||
master.enable, master.vme_addr, master.size,
|
||||
master.aspace, master.cycle, master.dwidth);
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case SLAVE_MINOR:
|
||||
switch (cmd) {
|
||||
case VME_GET_SLAVE:
|
||||
memset(&slave, 0, sizeof(struct vme_slave));
|
||||
|
||||
/* XXX We do not want to push aspace, cycle and width
|
||||
* to userspace as they are
|
||||
*/
|
||||
retval = vme_slave_get(image[minor].resource,
|
||||
&(slave.enable), &(slave.vme_addr),
|
||||
&(slave.size), &pci_addr, &(slave.aspace),
|
||||
&(slave.cycle));
|
||||
|
||||
copied = copy_to_user((char *)arg, &slave,
|
||||
sizeof(struct vme_slave));
|
||||
if (copied != 0) {
|
||||
printk(KERN_WARNING "Partial copy to "
|
||||
"userspace\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return retval;
|
||||
break;
|
||||
|
||||
case VME_SET_SLAVE:
|
||||
|
||||
copied = copy_from_user(&slave, (char *)arg,
|
||||
sizeof(slave));
|
||||
if (copied != 0) {
|
||||
printk(KERN_WARNING "Partial copy from "
|
||||
"userspace\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
/* XXX We do not want to push aspace, cycle and width
|
||||
* to userspace as they are
|
||||
*/
|
||||
return vme_slave_set(image[minor].resource,
|
||||
slave.enable, slave.vme_addr, slave.size,
|
||||
image[minor].pci_buf, slave.aspace,
|
||||
slave.cycle);
|
||||
|
||||
break;
|
||||
#if 0
|
||||
case VME_GET_SLAVE:
|
||||
vme_slave_t slave;
|
||||
|
||||
ret_val = vme_slave_get(minor, &iRegs);
|
||||
|
||||
copyRet = copy_to_user((char *)arg, &slave,
|
||||
sizeof(slave));
|
||||
if (copyRet != 0) {
|
||||
printk(KERN_WARNING "Partial copy to "
|
||||
"userspace\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return ret_val;
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -538,36 +553,87 @@ static void buf_unalloc (int num)
|
||||
static struct vme_driver vme_user_driver = {
|
||||
.name = driver_name,
|
||||
.probe = vme_user_probe,
|
||||
.remove = vme_user_remove,
|
||||
};
|
||||
|
||||
|
||||
static int __init vme_user_init(void)
|
||||
{
|
||||
int retval = 0;
|
||||
int i;
|
||||
struct vme_device_id *ids;
|
||||
|
||||
printk(KERN_INFO "VME User Space Access Driver\n");
|
||||
|
||||
if (bus_num == 0) {
|
||||
printk(KERN_ERR "%s: No cards, skipping registration\n",
|
||||
driver_name);
|
||||
goto err_nocard;
|
||||
}
|
||||
|
||||
/* Let's start by supporting one bus, we can support more than one
|
||||
* in future revisions if that ever becomes necessary.
|
||||
*/
|
||||
if (bus_num > USER_BUS_MAX) {
|
||||
printk(KERN_ERR "%s: Driver only able to handle %d PIO2 "
|
||||
"Cards\n", driver_name, USER_BUS_MAX);
|
||||
bus_num = USER_BUS_MAX;
|
||||
}
|
||||
|
||||
|
||||
/* Dynamically create the bind table based on module parameters */
|
||||
ids = kmalloc(sizeof(struct vme_device_id) * (bus_num + 1), GFP_KERNEL);
|
||||
if (ids == NULL) {
|
||||
printk(KERN_ERR "%s: Unable to allocate ID table\n",
|
||||
driver_name);
|
||||
goto err_id;
|
||||
}
|
||||
|
||||
memset(ids, 0, (sizeof(struct vme_device_id) * (bus_num + 1)));
|
||||
|
||||
for (i = 0; i < bus_num; i++) {
|
||||
ids[i].bus = bus[i];
|
||||
/*
|
||||
* We register the driver against the slot occupied by *this*
|
||||
* card, since it's really a low level way of controlling
|
||||
* the VME bridge
|
||||
*/
|
||||
ids[i].slot = VME_SLOT_CURRENT;
|
||||
}
|
||||
|
||||
vme_user_driver.bind_table = ids;
|
||||
|
||||
retval = vme_register_driver(&vme_user_driver);
|
||||
if (retval != 0)
|
||||
goto err_reg;
|
||||
|
||||
return retval;
|
||||
|
||||
vme_unregister_driver(&vme_user_driver);
|
||||
err_reg:
|
||||
kfree(ids);
|
||||
err_id:
|
||||
err_nocard:
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* In this simple access driver, the old behaviour is being preserved as much
|
||||
* as practical. We will therefore reserve the buffers and request the images
|
||||
* here so that we don't have to do it later.
|
||||
*/
|
||||
static int __init vme_bridge_init(void)
|
||||
{
|
||||
int retval;
|
||||
printk(KERN_INFO "VME User Space Access Driver\n");
|
||||
printk("vme_user_driver:%p\n", &vme_user_driver);
|
||||
retval = vme_register_driver(&vme_user_driver);
|
||||
printk("vme_register_driver returned %d\n", retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* This structure gets passed a device, this should be the device created at
|
||||
* registration.
|
||||
*/
|
||||
static int __init vme_user_probe(struct device *dev)
|
||||
static int __init vme_user_probe(struct device *dev, int cur_bus, int cur_slot)
|
||||
{
|
||||
int i, err;
|
||||
char name[8];
|
||||
|
||||
printk("Running vme_user_probe()\n");
|
||||
|
||||
/* Pointer to the bridge device */
|
||||
/* Save pointer to the bridge device */
|
||||
if (vme_user_bridge != NULL) {
|
||||
printk(KERN_ERR "%s: Driver can only be loaded for 1 device\n",
|
||||
driver_name);
|
||||
err = -EINVAL;
|
||||
goto err_dev;
|
||||
}
|
||||
vme_user_bridge = dev;
|
||||
|
||||
/* Initialise descriptors */
|
||||
@ -610,7 +676,7 @@ static int __init vme_user_probe(struct device *dev)
|
||||
if (image[i].resource == NULL) {
|
||||
printk(KERN_WARNING "Unable to allocate slave "
|
||||
"resource\n");
|
||||
goto err_buf;
|
||||
goto err_slave;
|
||||
}
|
||||
image[i].size_buf = PCI_BUF_SIZE;
|
||||
image[i].kern_buf = vme_alloc_consistent(image[i].resource,
|
||||
@ -621,7 +687,7 @@ static int __init vme_user_probe(struct device *dev)
|
||||
image[i].pci_buf = 0;
|
||||
vme_slave_free(image[i].resource);
|
||||
err = -ENOMEM;
|
||||
goto err_buf;
|
||||
goto err_slave;
|
||||
}
|
||||
}
|
||||
|
||||
@ -636,38 +702,7 @@ static int __init vme_user_probe(struct device *dev)
|
||||
if (image[i].resource == NULL) {
|
||||
printk(KERN_WARNING "Unable to allocate master "
|
||||
"resource\n");
|
||||
goto err_buf;
|
||||
}
|
||||
image[i].size_buf = PAGE_SIZE;
|
||||
image[i].kern_buf = vme_alloc_consistent(image[i].resource,
|
||||
image[i].size_buf, &(image[i].pci_buf));
|
||||
if (image[i].kern_buf == NULL) {
|
||||
printk(KERN_WARNING "Unable to allocate memory for "
|
||||
"buffer\n");
|
||||
image[i].pci_buf = 0;
|
||||
vme_master_free(image[i].resource);
|
||||
err = -ENOMEM;
|
||||
goto err_buf;
|
||||
}
|
||||
}
|
||||
|
||||
/* Setup some debug windows */
|
||||
for (i = SLAVE_MINOR; i < (SLAVE_MAX + 1); i++) {
|
||||
err = vme_slave_set(image[i].resource, 1, 0x4000*(i-4),
|
||||
0x4000, image[i].pci_buf, VME_A16,
|
||||
VME_SCT | VME_SUPER | VME_USER | VME_PROG | VME_DATA);
|
||||
if (err != 0) {
|
||||
printk(KERN_WARNING "Failed to configure window\n");
|
||||
goto err_buf;
|
||||
}
|
||||
}
|
||||
for (i = MASTER_MINOR; i < (MASTER_MAX + 1); i++) {
|
||||
err = vme_master_set(image[i].resource, 1,
|
||||
(0x10000 + (0x10000*i)), 0x10000,
|
||||
VME_A32, VME_SCT | VME_USER | VME_DATA, VME_D32);
|
||||
if (err != 0) {
|
||||
printk(KERN_WARNING "Failed to configure window\n");
|
||||
goto err_buf;
|
||||
goto err_master;
|
||||
}
|
||||
}
|
||||
|
||||
@ -709,11 +744,6 @@ static int __init vme_user_probe(struct device *dev)
|
||||
}
|
||||
}
|
||||
|
||||
/* XXX Run tests */
|
||||
/*
|
||||
tests();
|
||||
*/
|
||||
|
||||
return 0;
|
||||
|
||||
/* Ensure counter set correcty to destroy all sysfs devices */
|
||||
@ -725,12 +755,21 @@ err_sysfs:
|
||||
}
|
||||
class_destroy(vme_user_sysfs_class);
|
||||
|
||||
/* Ensure counter set correcty to unalloc all slave buffers */
|
||||
/* Ensure counter set correcty to unalloc all master windows */
|
||||
i = MASTER_MAX + 1;
|
||||
err_master:
|
||||
while (i > MASTER_MINOR) {
|
||||
i--;
|
||||
vme_master_free(image[i].resource);
|
||||
}
|
||||
|
||||
/*
|
||||
* Ensure counter set correcty to unalloc all slave windows and buffers
|
||||
*/
|
||||
i = SLAVE_MAX + 1;
|
||||
err_buf:
|
||||
err_slave:
|
||||
while (i > SLAVE_MINOR) {
|
||||
i--;
|
||||
vme_slave_set(image[i].resource, 0, 0, 0, 0, VME_A32, 0);
|
||||
vme_slave_free(image[i].resource);
|
||||
buf_unalloc(i);
|
||||
}
|
||||
@ -739,10 +778,11 @@ err_class:
|
||||
err_char:
|
||||
unregister_chrdev_region(MKDEV(VME_MAJOR, 0), VME_DEVS);
|
||||
err_region:
|
||||
err_dev:
|
||||
return err;
|
||||
}
|
||||
|
||||
static void __exit vme_bridge_exit(void)
|
||||
static int __exit vme_user_remove(struct device *dev, int cur_bus, int cur_slot)
|
||||
{
|
||||
int i;
|
||||
|
||||
@ -753,6 +793,8 @@ static void __exit vme_bridge_exit(void)
|
||||
class_destroy(vme_user_sysfs_class);
|
||||
|
||||
for (i = SLAVE_MINOR; i < (SLAVE_MAX + 1); i++) {
|
||||
vme_slave_set(image[i].resource, 0, 0, 0, 0, VME_A32, 0);
|
||||
vme_slave_free(image[i].resource);
|
||||
buf_unalloc(i);
|
||||
}
|
||||
|
||||
@ -761,11 +803,24 @@ static void __exit vme_bridge_exit(void)
|
||||
|
||||
/* Unregiser the major and minor device numbers */
|
||||
unregister_chrdev_region(MKDEV(VME_MAJOR, 0), VME_DEVS);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit vme_user_exit(void)
|
||||
{
|
||||
vme_unregister_driver(&vme_user_driver);
|
||||
|
||||
kfree(vme_user_driver.bind_table);
|
||||
}
|
||||
|
||||
|
||||
MODULE_PARM_DESC(bus, "Enumeration of VMEbus to which the driver is connected");
|
||||
module_param_array(bus, int, &bus_num, 0);
|
||||
|
||||
MODULE_DESCRIPTION("VME User Space Access Driver");
|
||||
MODULE_AUTHOR("Martyn Welch <martyn.welch@gefanuc.com");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
module_init(vme_bridge_init);
|
||||
module_exit(vme_bridge_exit);
|
||||
module_init(vme_user_init);
|
||||
module_exit(vme_user_exit);
|
||||
|
||||
@ -1,9 +1,13 @@
|
||||
#ifndef _VME_USER_H_
|
||||
#define _VME_USER_H_
|
||||
|
||||
#define USER_BUS_MAX 1
|
||||
|
||||
/*
|
||||
* VMEbus Master Window Configuration Structure
|
||||
*/
|
||||
typedef struct {
|
||||
char enable; /* State of Window */
|
||||
struct vme_master {
|
||||
int enable; /* State of Window */
|
||||
unsigned long long vme_addr; /* Starting Address on the VMEbus */
|
||||
unsigned long long size; /* Window Size */
|
||||
vme_address_t aspace; /* Address Space */
|
||||
@ -14,7 +18,7 @@ typedef struct {
|
||||
int prefetchSize; /* Prefetch Read Size (Cache Lines) */
|
||||
char wrPostEnable; /* Write Post State */
|
||||
#endif
|
||||
} vme_master_t;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
@ -26,8 +30,8 @@ typedef struct {
|
||||
|
||||
|
||||
/* VMEbus Slave Window Configuration Structure */
|
||||
typedef struct {
|
||||
char enable; /* State of Window */
|
||||
struct vme_slave {
|
||||
int enable; /* State of Window */
|
||||
unsigned long long vme_addr; /* Starting Address on the VMEbus */
|
||||
unsigned long long size; /* Window Size */
|
||||
vme_address_t aspace; /* Address Space */
|
||||
@ -37,7 +41,12 @@ typedef struct {
|
||||
char rmwLock; /* Lock PCI during RMW Cycles */
|
||||
char data64BitCapable; /* non-VMEbus capable of 64-bit Data */
|
||||
#endif
|
||||
} vme_slave_t;
|
||||
};
|
||||
|
||||
#define VME_SET_SLAVE _IOW(VME_IOC_MAGIC, 10, vme_slave_t)
|
||||
#define VME_GET_SLAVE _IOR(VME_IOC_MAGIC, 1, struct vme_slave)
|
||||
#define VME_SET_SLAVE _IOW(VME_IOC_MAGIC, 2, struct vme_slave)
|
||||
#define VME_GET_MASTER _IOR(VME_IOC_MAGIC, 3, struct vme_master)
|
||||
#define VME_SET_MASTER _IOW(VME_IOC_MAGIC, 4, struct vme_master)
|
||||
|
||||
#endif /* _VME_USER_H_ */
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user