Linux Treiber Speicherzugriff

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/ioport.h>

#include <asm/uaccess.h>

#include <asm/io.h>

int init_module(void);

void cleanup_module(void);

static int SPI_open(struct inode *, struct file *);

static int SPI_release(struct inode *, struct file *);

static ssize_t SPI_read(struct file *, char *, size_t, loff_t *);

static ssize_t SPI_write(struct file *, const char *, size_t, loff_t *);

#define SUCCESS 0

#define FAIL -1

#define DEVICE_NAME "hello_1"   // DEV name as it appears in /proc/devices

#define BUF_LEN 80         //Max length of the message from the device

static int Major;        //Major number assigned to our device driver

static int Device_Open = 0;    //Device Open? ==> Prevent multiple access to device

static char msg[BUF_LEN];    //The msg the device will give when asked

static char *msg_Ptr;

unsigned long rev_address_start = 0x4803014C;

unsigned long len = 4;

struct resource* spi0_region = NULL;

void* pMcspi0 = NULL;

int register_value = 0;

static struct file_operations fops = {

  .read = SPI_read,

  .write = SPI_write,

  .open = SPI_open,

  .release = SPI_release

};

//////////////////// INIT AND EXIT MODULE ///////////////////////////////////////////

int init_module(void)

{

  Major = register_chrdev(0, DEVICE_NAME, &fops);

  if(Major < 0)

  {

    printk(KERN_ALERT "Registering char device failed with %d\n", Major);

    return FAIL;

  }

  printk(KERN_INFO "I was assigned major number %d. To talk to\n", Major);

  printk(KERN_INFO "the driver, create a dev file with\n");

  printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major);

  printk(KERN_INFO "Try various minor numbers. Try to cat and echo to\n");

  printk(KERN_INFO "the device file.\n");

  printk(KERN_INFO "Remove the device file and module when done.\n");

  printk(KERN_INFO "Try to request_mem_region() for IO-memory!");

  spi0_region = request_mem_region(rev_address_start, len, DEVICE_NAME);

  if(spi0_region == NULL)

  {

    printk(KERN_INFO "Error in allocating memory region!!!");

    return FAIL;

  }

  printk(KERN_INFO "Allocating memory region (request_mem_region()) was successful!");

  printk(KERN_INFO "Try to ioremap() IO-memory!");

  printk(KERN_INFO "START: %d", (*spi0_region).start);

  printk(KERN_INFO "START: %d", (*spi0_region).end);

  printk(KERN_INFO "NAME: %s", (*spi0_region).name);

  //printk(KERN_INFO "NAME: %l", (*spi0_region).flags);

  /* pMcspi0 = ioremap(rev_address_start, len);

  if(pMcspi0 == NULL)

  {

    printk(KERN_INFO "Error in remapping memory !!!!!");

    printk(KERN_INFO "Deallocation of memory_region: release_mem_region()");

    release_mem_region(rev_address_start, len);

    return FAIL;

  }

  printk(KERN_INFO "Remapping IO-memory was successful!");

  printk(KERN_INFO "Try to read from IO-memory!");

  register_value = ioread32(pMcspi0); 

  printk(KERN_INFO "Tried to read from IO-memory!");

  printk(KERN_INFO "The requested revision address holds the value: %d", register_value);

   */

  printk(KERN_INFO "Initialization of SPI module was successful");

  return SUCCESS;

}

void cleanup_module(void)

{

  //int ret = unregister_chrdev(Major, DEVICE_NAME);

  //returns void !!!

  //if(unregister_chrdev(Major, DEVICE_NAME) < 0)

  //{

    //printk(KERN_ALERT "Error in unregister_chrdev: %d\n", ret)

  //}

  printk(KERN_INFO "Free allocated memory space"); 

  //free allocated memory space

  //iounmap(pMcspi0);

  release_mem_region(rev_address_start, len);

  unregister_chrdev(Major, DEVICE_NAME);

  printk(KERN_ALERT "Unregister char device completed!");

}

/////////////////////  FILE-OPERATIONS  ///////////////////////////////////////////

//called when a process tries to open the device file, like "cat /dev/mycharfile"

static int SPI_open(struct inode *inode, struct file *file)

{

  static int counter = 0;

  if (Device_Open)

  {

    return -EBUSY;

  }

  Device_Open++;

  sprintf(msg, "I already told you %d times Hello world!\n", counter++);

  msg_Ptr = msg;

  try_module_get(THIS_MODULE);

  return SUCCESS;

}

//called when a process closes the device file

static int SPI_release(struct inode *inode, struct file *file)

{

  Device_Open--;       //We are ready for our next caller

  module_put(THIS_MODULE);

  return 0;

}

//called when a process, which already opened the dev file, attemps to read from it

static ssize_t SPI_read(struct file *filp, char *buffer, size_t length, loff_t *offset)

{

  //filp:    see include/linux/fs.h

  //buffer:  buffer to fill with data

  //length:   length of the buffer

  //Number of bytes actually written to the buffer

  int bytes_read = 0;

  //if end if message => sign EOF

  if(*msg_Ptr == 0)

  {

    return 0;

  }

  //Put data into buffer

  while(length && *msg_Ptr)

  {

    //buffer is in the user data segment, not kernel,

    //therefore "*" wont work => we have to use put_user

    //put_user copies data from kernel data segment to user data segment

    put_user(*(msg_Ptr++), buffer++);

    length--;

    bytes_read++;

  }

  //Most read functions are returning the number of bytes put into buffer

  return bytes_read;

}

//called when a process writes to dev file: "echo "hi" > /dev/hello

static ssize_t SPI_write(struct file *filp, const char *buff, size_t len, loff_t *off)

{

  printk(KERN_ALERT "Sorry, this operation is not supported.\n");

  return -EINVAL;

}