Il nuovo kernel 2.6.x attualmente in distribuzione presenta alcune differenze che hanno reso inutili gli esempi pubblicati sino ad oggi. Vediamo quindi qui alcune considerazioni utili a realizzare un modulo per la porta parallela, che mi servirà a pilotare il motore stepper unipolare già postato in precedenza e che è in fase di sviluppo. Premetto che maggiori info si possono trovare nei repository ufficiali della distribuzione che si utilizza (inutile mettere qui i link che ce ne sono a iosa)
Il kernel di linux fa un largo uso di driver caricabili dinamicamente quando serve, il che ci dà la possibilità di evitare la ricompilazione dello stesso in caso fosse necessario utilizzare delle periferiche nuove. Un altra comodità di linux è che "tutto è un file", ovvero i dispositivi possono essere utilizzati come se fossero dei files. Ci posso scrivere e ci posso leggere. Ciò ci permette di avere accesso ad aree di memoria protette o accedere a basso livello alle periferiche che normalmente equipaggiano i PC. Per fare ciò è necessario "vedere" il dispositivo nella gerarchia /dev. Negli esempi di codice che seguono, si utilizza il linguaggio C. Il codice è preso da vari esempi, cercando di tradurre alcune istruzioni scritte in klingon che si trovano "spezzettate" in vari post di altri programmatori.
Il kernel di linux fa un largo uso di driver caricabili dinamicamente quando serve, il che ci dà la possibilità di evitare la ricompilazione dello stesso in caso fosse necessario utilizzare delle periferiche nuove. Un altra comodità di linux è che "tutto è un file", ovvero i dispositivi possono essere utilizzati come se fossero dei files. Ci posso scrivere e ci posso leggere. Ciò ci permette di avere accesso ad aree di memoria protette o accedere a basso livello alle periferiche che normalmente equipaggiano i PC. Per fare ciò è necessario "vedere" il dispositivo nella gerarchia /dev. Negli esempi di codice che seguono, si utilizza il linguaggio C. Il codice è preso da vari esempi, cercando di tradurre alcune istruzioni scritte in klingon che si trovano "spezzettate" in vari post di altri programmatori.
Apertura del driver
static int miaporta_open(struct inode *inode, struct file *filep)
{
//ci limitiamo a scrivere un messaggio
printk("Dispositivo aperto\n");
return 0;
}
Chiusura del driver
static int miaporta_release(struct inode *inode, struct file *filep)
{
//anche qui scriviamo solamente un messaggio
printk("Dispositivo chiuso\n");
return 0;
}
La scrittura sul driver
static ssize_t miaporta_write(struct file *filep, const char *buf, size_t count, loff_t *f_pos)
{
outb(0x00,0x37A); // porta parallela 1 in uscita
outb(buf[0],0x37B); // Scrittura sul registro ADDRESS
return 0;
}
La lettura dal driver
static ssize_t miaporta_read(struct file *filep, char *buf, size_t count, loff_t *f_pos)
{
outb(0x20,0x37A); // Porta parallela1 in Input
buf[0]=inb(0x37B); // lettura dal registro ADDRESS
return 0;
}
Occorre ora associare le procedure alle funzioni dei files. Per farlo, quest’ultime devono essere esportate al sistema. Questo lavoro viene svolto riempendo una struttura particolare di tipo ”file operations”, definita nell’header file ”linux/fs.h”.
struct file_operations epp_fops =
{
owner: THIS_MODULE,
open: miaporta_open,
release: miaporta_release,
read: miaporta_read,
write: miaporta_write,
};
Per l'inizializzazione del modulo occorre anche associare, con la funzione "register chardev", un ben definito device al nostro driver. Basta passare come parametri, nell’ordine, il major-char-number (20), una stringa con il nome del driver e la struttura con registrate le funzioni specifiche di accesso.
static int __init init_mod(void)
{
int result;
if ((result = register_chrdev(20, "miaporta", &epp_fops)) < style="color: rgb(51, 204, 0);">Chiusura del driver (deregistrazione9
static void __exit end_mod(void)
{
unregister_chrdev(20, "miaporta");
printk("Driver MIAPORTA unloaded.\n");
}
Per ultimo occorre aggiungere la linea in testa MODULE_LICENSE("GPL"); (o altre opzioni disponibili in base al tipo di licenza prescelto) e in fondo
module_init(init_mod);
module_exit(end_mod);
Per compilare, occorre creare un Makefile come segue:
obj-m:= miaporta_drv.o
KDIR = /lib/modules/$(shell uname -r)/build
PWD = $(shell pwd)
default:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
clean:
rm -f *.mod.* *.o *.ko
Una volta compilato occorre caricare il modulo con insmod ./miaporta_drv.ko e per poterlo utilizzare basta dare il comando mknod -m 0666 /dev/miaporta c 20 0
Funziona?. non lo so, devo ancora provare.
In attesa che sviluppi il codice e inizi a testarlo vediamo come si prevede di utilizzarlo all'interno del programma che lo utilizza...
Funziona?. non lo so, devo ancora provare.
In attesa che sviluppi il codice e inizi a testarlo vediamo come si prevede di utilizzarlo all'interno del programma che lo utilizza...
#include "fcntl.h"
#include "stdio.h"
int main()
{
char buffer[1];
int fd;
fd=open("/dev/miaporta",O_RDWR);
buffer[0]=0x00;
write(fd,buffer,1,NULL); //scrivo il byte
read(fd,buffer,1,NULL); //leggo i byte
printf("Valore : 0x%02x\n",buffer[0]);
close(fd);
}
Dovrebbe funzionare. Se nei prossimi giorni trovo il tempo di svilupparlo e mi accorgo che qualcosa non va, provvederò alle modifiche. Per ora STOP. Una domenica passata al PC approfittando del maltempo mi pare sufficiente. Ora un pò di relax. un abbraccio
P.S. Mille bit fanno un megabit. Ripeto: Mille bit fanno un megabit.
