---

E12fops.c

/*E12fops.c
file operations module for the 37E12 driver
*/
#include "E12.h"
#include "E12fops.h"
#include "sE12.h"
#include "../includes/E12user.h"
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <linux/slab.h>




struct file_operations E12fops={
  open:    E12_Open,
  read:    E12_Read,
  write:   E12_Write,
  ioctl:   E12_Ioctl,
  fasync:  E12_fasync,
  release: E12_Release,
};


static int AllocDevice(E12_device *device)
{
request_region(device->address,E12_IOSIZE,device->devicename);
request_irq(device->IRQ, E12_Interrupt, 0, device->devicename, device);
return 0;
}

static int DeallocDevice(E12_device *device)
{
if(device->valid!=TRUE)
  return -1;//device not allocated properly

if(device->IRQ!=UNSET)
  free_irq(device->IRQ,device);

if(device->address!=UNSET)
  release_region(device->address,E12_IOSIZE);
return 0;
}


int E12_Open (struct inode *inode, struct file *filp)
{
int minor = NUM(inode->i_rdev);
extern E12_device Global_E12device[E12MAXBOARDS];
E12_device *device;

if(minor>=E12MAXBOARDS) /*if the minor number is too high return with an error*/
  {
    GENDEBUG("invalid board number\n");
    return -ENODEV;
  }


MOD_INC_USE_COUNT;


GENDEBUG("device memory allocated\n");

device =  &Global_E12device[minor];

filp->private_data = device;

if(device->valid==TRUE)
  AllocDevice(device);

GENDEBUG(E12NAME"device %x opened\n",minor);
return 0;
}

int E12_Ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
E12_device *device = filp->private_data;
E12_config_struct config; 
u8 identity; 
isodata data;

switch(cmd)
  {
  case E12_CONFIG:
 
DeallocDevice(device);//first deallocate old device if needed;
if(access_ok(VERIFY_READ,(void *)arg,sizeof(E12_config_struct)))
    copy_from_user(&config,(E12_config_struct *)arg,sizeof(E12_config_struct));
else
  {
    E12MESSAGE("couldn't copy 37E12 config structure from user space\n");
    return -1;
  }


if(0>check_region(config.address,E12_IOSIZE))
  {
    E12MESSAGE("IO address %x not available\n",config.address);
    return -1;
  }

request_region(config.address,E12_IOSIZE,device->devicename);
device->address = config.address;

IDENT_CHECK(device,identity);

if(identity!=PLDR1_IDENT)
  {
    E12MESSAGE("37e12 device not found at %x\n",config.address);
    release_region(device->address,E12_IOSIZE);
    device->address = UNSET;
    return -1;
  }

IODEBUG("37e12 found at address %x\n",device->address);

if(0>request_irq(config.IRQ, E12_Interrupt, 0, device->devicename, device))
  {
    E12MESSAGE("IRQ %u not available\n",config.IRQ);
    return -1;
  }

device->IRQ = config.IRQ;

if(config.IRQedge)
  device->IRQedge = RISING_EDGE;
else
  device->IRQedge = FALLING_EDGE;

device->valid = TRUE;


IRQ_EDGE_INIT(device);
return 0;

  case ISO_DIG_OUT:
    if(device->valid!=TRUE)
      {     
    E12MESSAGE("invalid device configuration\n"); 
    return -ENODEV;
      }
    if(access_ok(VERIFY_READ,(void *)arg,sizeof(isodata)))
      copy_from_user(&data,(isodata *)arg,sizeof(isodata));
    else
      {
    E12MESSAGE("couldn't copy 37E12 ISO data from user space\n");
    return -1;
      }
    ISO_OUT(device,data);
    return 0;


  case ISO_DIG_IN:
    if(device->valid!=TRUE)
      {
    E12MESSAGE("invalid device configuration\n");
    return -ENODEV;
      }
    ISO_IN(device,data);
    if(access_ok(VERIFY_READ,(void *)arg,sizeof(isodata)))
      copy_to_user((isodata *)arg,&data,sizeof(isodata));
    else
      {
    E12MESSAGE("couldn't copy 37E12 ISO data to user space\n");
    return -1;
      }
    return 0;
  }
IODEBUG("invalid command\n");
return -1;
}


ssize_t E12_Write(struct file *filp, const char *buff, size_t count, loff_t *offp)
{
E12_device *device = filp->private_data;
u8 *data;
int bytenum;

if(device->valid!=TRUE)
  {
 E12MESSAGE("invalid device configuration\n");
  return -ENODEV;
  }
IODEBUG("writing data\n");

data = vmalloc(count);
disable_irq(device->IRQ);

copy_from_user(data,buff,count); 

WRITE_MODE(device);

for(bytenum=0;bytenum<count;bytenum++)
  {
    WAIT_FOR_IRQ_HIGH(device);/*wait for IRQ*/

    BUSOUT(device,data[bytenum]);
 
    DTACK_ON(device);

WAIT_FOR_IRQ_LOW(device);/*wait for ACK*/
    
    if(bytenum<(count-1))
    DTACK_OFF(device);/*give bus away for next transfer*/

  }

enable_irq(device->IRQ);/*this should generate a blank IRQ*/
READ_MODE(device);
DTACK_OFF(device);/*return bus control to COP*/
vfree(data);
IODEBUG("wrote %u bytes\n",bytenum);\
return bytenum;
}

ssize_t E12_Read(struct file *filp, char *buff, size_t count, loff_t *offp)
{
E12_device *device = filp->private_data;
char *data;
int bytenum;
u8 bitnine=0;

IODEBUG("E12_Read\n");

if(device->valid!=TRUE)
  {
    E12MESSAGE("invalid device configuration\n");
    return -ENODEV;
  }
rmb();
if(MIRQ_LOW(device))
  {
    IODEBUG("Transfer not pending\n");

    if(filp->f_flags & O_NONBLOCK)
      return 0;/*non-blocking operation, return immediatly*/

    IODEBUG("device is in blocking mode, sleeping\n");
    rmb();
    /*else it's a blocking operation, sleep until data arrives*/
    if(wait_event_interruptible(device->readqueue, MIRQ_HIGH(device))==-ERESTARTSYS){
      E12MESSAGE("37e12 read killed while waiting for data");
      return 0;
    }

    rmb();
    IODEBUG("device awoken\n");
  }

disable_irq(device->IRQ);
data = vmalloc(count);

for(bytenum=0;bytenum<count;bytenum++)
  {
DTACK_ON(device);
//IODEBUG("wait for COP IRQ ack\n");
WAIT_FOR_IRQ_LOW(device);/*wait for coprocessor to ack*/

DATA_PORT(device,data[bytenum]);
IODEBUG(" %c",data[bytenum]);
BIT_NINE_READ(device,bitnine);

//IODEBUG("%x %x\n",bytenum,bitnine);

if(bitnine)
  {
    IODEBUG("transfer completed - bit nine set\n");
    enable_irq(device->IRQ);/*this should generate a blank*/
    copy_to_user(buff,data,(bytenum+1));/*move data to user space*/
    vfree(data);
    DTACK_OFF(device);
    return(bytenum+1);
  }

if(bytenum<(count-1))/*wait for next byte if the buffer isn't full*/
  {
    DTACK_OFF(device);
    WAIT_FOR_IRQ_HIGH(device);
  }

  }
IODEBUG("transfer completed - buffer filled\n");
enable_irq(device->IRQ);/*this doesn't seem to  generate a blank*/
copy_to_user(buff,data,bytenum);/*move data to user space*/
vfree(data);
DTACK_OFF(device);/*give the COP it's bus back*/
IODEBUG("returned %u bytes\n",bytenum);
return bytenum;
}


int E12_fasync(int fd, struct file *filp, int mode)
{
E12_device *device = filp->private_data;
IODEBUG("fasync call\n");

if(device==NULL)
  {
GENDEBUG("NULL device, async failed\n");
return -1;
  }

return(fasync_helper(fd, filp, mode, &device->dataready)); 
}



int E12_Release(struct inode *inode, struct file *filp)
{
E12_device *device = filp->private_data;
int minor = device->num;
DeallocDevice(device);
E12_fasync(-1,filp,0);
GENDEBUG(E12NAME"-%u device closed\n",minor);
MOD_DEC_USE_COUNT;
return SUCCESS;
}

---