Linux Treiber Speicherzugriff

[Florian R. (fossa)]

Hallo,

ich heiße Florian und bin Student. Innerhalb meines 6. Semesters habe 
ich in einer Firma ein BAC-Praktikum zu absolvieren, in dem ich eine 
BAC-Arbeit schreiben soll.

Als Aufgabenstellung wurde mir die Implementierung eines 
Linux-Gerätetreibers aufgegeben, für den BeagleBone Black(Sitara 
AM3358). Dieser soll eine SPI Schnittstelle zur Verfügung stellen, in 
der der BeagleBone als Slave arbeitet. Damit ich das bewerkstelligen 
kann, möchte ich einen Linux-Treiber schreiben. Ich beschäftige mich nun 
zum ersten mal praktisch mit Linux-Treibern, also bitte ich um 
Nachsicht... ;) Ich bin nun schon so weit, dass der Char Device Treiber 
läuft. Um nun die Register des Prozessors zu manipulieren, hätte ich nun 
mit request_mem_region() mir einen Speicher allokiert und mit ioremap() 
die Register in den virtuellen Speicher geholt. Leider funktioniert die 
Funktion ioread() nicht, obwohl ich ihr den Pointer von ioremap() 
übergebe.

ich hoffe, jemand weiß weiter...

LG - ein schönes Wochenende

Flo

[Clemens L. (c_l)]

Florian R. schrieb:
> Dieser soll eine SPI Schnittstelle zur Verfügung stellen, in
> der der BeagleBone als Slave arbeitet.

https://groups.google.com/d/topic/beagleboard/0ge_TozyTIE
https://groups.google.com/d/topic/beagleboard/UC6pUfQXsWg

> ich hoffe, jemand weiß weiter...

Ohne Quellcode?

[Florian R. (fossa)]

Da das mit den oben genannten Möglichkeiten nicht geht, würde ich es 
gerne mit dem Linuxkernel implementieren, der Prozessor kann als Slave 
arbeiten, jedoch muss ich dazu auf die Register des Prozessors zugreifen 
können.

Anbei der Code:

#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;
}

[Rufus Τ. F. (rufus)]

Florian R. schrieb:
> Um nun die Register des Prozessors zu manipulieren,

Was hat das mit einem SPI-Devicetreiber zu tun? Was für Daten soll der 
"Slave"-Treiber denn dem Master zur Verfügung stellen?

Das klingt reichlich wirr.

[Strubi (Gast)]

Moin,

von einem solchen Vorhaben kann ich gleich abraten, ein Linux-Host kann 
niemals zuverlässig als SPI Slave arbeiten. Das hat schlicht damit zu 
tun, dass das Timing von Linux nicht garantiert werden kann. Was geht, 
ist i2c.
Tut mir leid, aber hier erschleicht sich der Eindruck, dass der 
Aufgabensteller nicht viel nachgedacht hat. Für einen SPI Slave ist auf 
jeden Fall eine HW-Implementierung nötig. Also, wenn es denn eine 
Übungsaufgabe mit Sinn sein soll: Gleich zum FPGA greifen.

Grüsse,

- Strubi

[Clemens L. (c_l)]

Es wäre vielleicht eine bessere Idee, den SPI-(Master-)Treiber 
entsprechend anzupassen:
https://e2e.ti.com/support/arm/sitara_arm/f/791/p/281877/987362
https://patchwork.kernel.org/patch/76677/

[Clemens L. (c_l)]

Strubi schrieb:
> ein Linux-Host kann niemals zuverlässig als SPI Slave arbeiten.

Eine allgemeine SPI-Schnittstelle, bei der man in Echtzeit reagieren 
muss, ist in der Tat nicht möglich.

Allerdings haben die McSPI FIFOs und DMA-Unterstützung; je nach Art des 
tatsächlich verwendeten Protokolls könnte man damit durchaus etwas 
anfangen.

[foobar (Gast)]

Schau dir mal die PRUs auf dem BBB an.

[Hellmut K. (hkohlsdorf)]

Ich kann hier nur auf die Möglichkeit verweisen mit dem reservieren 
eines der Cores für den Echtzeit betrieb. Stichwörter „Mercury” und 
„Cobalt”. So würde das Linux um den Echtzeit fähigen „Cobalt” erweitert.