vme_universe.cpp File Reference

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/page.h>
#include "midas.h"
#include "crate.h"
#include "vme_universe.h"
#include "diag.h"

Go to the source code of this file.

Macros
#define	MAX_VME_MAPPED_SIZE   (64*1024*1024)
#define	MAX_VME_HANDLES   10

Functions
unsigned long	page_round_down (unsigned long addr)
unsigned long	page_round_up (unsigned long addr)
void	vme_init ()
struct vme_handle *	vme_open (unsigned long vme_addr, struct vme_mapping_ctrl mapping, int size, int fifo_block_size)
void	vme_close (struct vme_handle *handle)
int	vme_dma_read (struct vme_handle *handle, unsigned long vme_addr, unsigned char *buffer, int size)
int	vme_dma_write (struct vme_handle *handle, unsigned long vme_addr, unsigned char *buffer, int size)

Variables
struct vme_handle	vme_handles [MAX_VME_HANDLES]

Macro Definition Documentation

#define MAX_VME_HANDLES   10

Definition at line 26 of file vme_universe.cpp.

Referenced by vme_init(), and vme_open().

#define MAX_VME_MAPPED_SIZE   (64*1024*1024)

Definition at line 24 of file vme_universe.cpp.

Referenced by vme_open().

Function Documentation

unsigned long page_round_down ( unsigned long  addr)

inline

Definition at line 29 of file vme_universe.cpp.

Referenced by vme_open().

{
  return addr & PAGE_MASK;
}

unsigned long page_round_up ( unsigned long  addr)

inline

Definition at line 34 of file vme_universe.cpp.

Referenced by vme_open().

{
  if(addr & ~PAGE_MASK == 0) {
    return addr;
  } else {
    return (addr & PAGE_MASK) + PAGE_SIZE;
  }
}

void vme_close

(

struct vme_handle *

handle)

Definition at line 162 of file vme_universe.cpp.

{
  handle->reference_count--;

  if(handle->reference_count == 0) {
    int status = munmap((void *) handle->base, handle->size);
    if(status < 0) {
        perror("Error unmapping VME:");
    }
    status = close(handle->fd);
    if(status < 0) {
        perror("Error closing VME:");
    }
    handle->used = false;
  }
}

int vme_dma_read	(	struct vme_handle *	handle,
		unsigned long	vme_addr,
		unsigned char *	buffer,
		int	size
	)

Definition at line 179 of file vme_universe.cpp.

{
  struct vme_dma_req dma_req;

  dma_req.vme_addr = vme_addr;
  dma_req.buf = buffer;
  dma_req.count = size;
  dma_req.fifo_block_size = handle->fifo_block_size;

  int bytes_read = ioctl(handle->fd, VMEIMG_DMA_READ, &dma_req);

  return bytes_read;

#if 0
  if(handle->fifo_block_size == 0) {
    return pread(handle->fd, buffer, size, vme_addr - handle->vme_base);
  } else {

    int bytes_read = 0;

    while(bytes_read < size) {
      
      int size_this_time = MIN(size - bytes_read, handle->fifo_block_size);
      
      int status = pread(handle->fd, buffer + bytes_read, size_this_time,
                         vme_addr - handle->vme_base);

      if(status > 0) {
          bytes_read += status;
      }

      if(status < size_this_time) {
        break;
      }
    }

    return bytes_read;
  }
#endif
}

int vme_dma_write	(	struct vme_handle *	handle,
		unsigned long	vme_addr,
		unsigned char *	buffer,
		int	size
	)

Definition at line 223 of file vme_universe.cpp.

{
  struct vme_dma_req dma_req;

  dma_req.vme_addr = vme_addr;
  dma_req.buf = buffer;
  dma_req.count = size;
  dma_req.fifo_block_size = handle->fifo_block_size;

  int bytes_written = ioctl(handle->fd, VMEIMG_DMA_WRITE, &dma_req);

  return bytes_written;

#if 0
  if(handle->fifo_block_size == 0) {
    return pwrite(handle->fd, buffer, size, vme_addr - handle->vme_base);
  } else {
    
    int bytes_written = 0;
    
    while(bytes_written < size) {
      
      int size_this_time = MIN(size - bytes_written, handle->fifo_block_size);
      
      int status = pwrite(handle->fd, buffer + bytes_written, size_this_time,
                         vme_addr - handle->vme_base);

      if(status > 0) {
          bytes_written += status;
      }

      if(status < size_this_time) {
        break;
      }
    }

    return bytes_written;
  }
#endif
}

void vme_init

(

)

Definition at line 43 of file vme_universe.cpp.

References i, MAX_VME_HANDLES, vme_handle::used, and vme_handles.

{
  // Mark all handles as unused
  for(int i = 0; i < MAX_VME_HANDLES; i++) {
    vme_handles[i].used = false;
  }
}

struct vme_handle* vme_open	(	unsigned long	vme_addr,
		struct vme_mapping_ctrl	mapping,
		int	size,
		int	fifo_block_size
	)

Definition at line 51 of file vme_universe.cpp.

{
  struct vme_handle *handle = NULL;
  unsigned long new_vme_base = 0;
  unsigned long new_vme_size = 0;

  vme_addr = page_round_down(vme_addr);
  unsigned long vme_addr_end = page_round_up(vme_addr + size);

  // Search through the currently-allocated windows, looking for
  // one that would be compatible.
  for(int i = 0; i < MAX_VME_HANDLES; i++) {
    if(vme_handles[i].used &&
       vme_handles[i].mapping.address_space == mapping.address_space &&
       vme_handles[i].mapping.supuseram == mapping.supuseram &&
       vme_handles[i].mapping.prgdataam == mapping.prgdataam &&
       vme_handles[i].fifo_block_size == fifo_block_size) {

      new_vme_base = 
        MIN(vme_addr, vme_handles[i].vme_base);
      unsigned long new_vme_addr_end = 
        MAX(vme_addr_end, vme_handles[i].vme_base + vme_handles[i].size);
      new_vme_size = new_vme_addr_end - new_vme_base;

      if(new_vme_size <= MAX_VME_MAPPED_SIZE) {
        handle = &vme_handles[i];
        break;
      }
    }
  }

  // If we didn't find one, then look for a brand-new window
  if(handle == NULL) {
    new_vme_base = vme_addr;
    new_vme_size = vme_addr_end - vme_addr;

    for(int i = 0; i < MAX_VME_HANDLES; i++) {
      if(!(vme_handles[i].used)) {
        handle = &vme_handles[i];
      }
    }
  }

  // If the window is brand-new, then open a file descriptor for it.
  if(!handle->used) {

    // Try each of the device special files
    for(int i = 0; i < 8; i++) {
      char filename[20];
      sprintf(filename, "/dev/vme_a32_%d", i);
      handle->fd = open(filename, O_RDWR);
      if(handle->fd >= 0) {
        break;
      }
    }

    // Check that we found one
    if(handle->fd < 0) {
      diag_print(0, "Unable to open a VME device file\n");
      return NULL;
    }
  }
  // Otherwise, unmap the associated memory 
  else {
    munmap((void *) handle->base, handle->size);
  }

  // Set the address space mapping
  if(ioctl(handle->fd, VMEIMG_SETMAPPING, &mapping)) {
    perror("ioctl VMEIMG_SETMAPPING");
    return NULL;
  }

  // Set the VME base address appropriately
  if(ioctl(handle->fd, VMEIMG_SETVMEADDR, new_vme_base)) {
    perror("ioctl VMEIMG_SETVMEADDR");
    return NULL;
  }

  // Retrieve the base address that the driver actually accepted
  if(ioctl(handle->fd, VMEIMG_GETVMEADDR, &handle->vme_base)) {
    perror("ioctl VMEIMG_GETVMEADDR");
    return NULL;
  }

  // Map some memory for the region of interest
  handle->base = (volatile unsigned char *) 
    mmap(NULL, new_vme_size, PROT_WRITE | PROT_READ, MAP_SHARED, handle->fd, 0);
  if(handle->base == (volatile unsigned char *) -1) {
    perror("mmap VME address space");
    return NULL;
  }

  // Remember the basic properties of this handle
  handle->used = true;
  handle->mapping.max_datawidth = mapping.max_datawidth;
  handle->mapping.address_space = mapping.address_space;
  handle->mapping.supuseram = mapping.supuseram;
  handle->mapping.prgdataam = mapping.prgdataam;
  handle->fifo_block_size = fifo_block_size;
  handle->size = new_vme_size;  

  // Keep a reference count
  handle->reference_count++;

  return handle;
}

Variable Documentation

struct vme_handle vme_handles[MAX_VME_HANDLES]

Definition at line 27 of file vme_universe.cpp.

Referenced by vme_init(), and vme_open().