#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>

#define MOD_AUTHOR "Legierski Michal"
#define MOD_DESC "Hello world"


static int __init chardev_init ( void );
static void __exit chardev_exit ( void );
static int device_open ( struct inode *, struct file * );
static int device_release( struct inode *, struct file * );
static ssize_t device_read ( struct file *, char * , size_t , loff_t * );
static ssize_t device_write( struct file *, const char * , size_t , loff_t * );
#define SUCCESS 0
#define DEVICE_NAME " chardev "
#define BUF_LEN 100

static int Major = 122;
DEFINE_MUTEX( Device_Open );
static char msg [ BUF_LEN ] ;
static char *msg_Ptr;
static int licznik = 0;
static struct cdev * chcdev;

static struct file_operations fops = {
.read = device_read,
.write = device_write,
.open = device_open,
.release = device_release
};

static int __init chardev_init( void ){
int ret;
dev_t num;

num=MKDEV(Major,0);

ret=register_chrdev_region(num,3,DEVICE_NAME);
if(ret<0){
printk(KERN_ALERT"Nieudana próba przydziału urządzenia w jądrze - zwrócony numer %d\n", ret);
return ret;
}

chcdev=cdev_alloc();
chcdev->owner = THIS_MODULE;
chcdev->ops = &fops;

ret = cdev_add(chcdev,num,3);

if(ret<0){
printk(KERN_ALERT "Nieudana próba zarejestrowania urządzenia w jądrze - zwrócony numer %d\n", ret);
return ret;
}

printk(KERN_INFO "Przydzielono mi numer urządzenia %d. Otwórz plik\n", Major);
printk(KERN_INFO "urządzenia za pomoc!"
"'mknod/dev/%s c %d 0', a potem\n", DEVICE_NAME, Major);
printk(KERN_INFO "z inną ostatnią cyfrą. Próbuj czytać i pisać do tego\n");
printk(KERN_INFO "urządzania. Po usunięciu urządzenia usuń i plik\n");
return SUCCESS;
}

static void __exit chardev_exit(void){
dev_t num;

num = MKDEV(Major,0);

cdev_del(chcdev);

unregister_chrdev_region(num,3);
printk(KERN_INFO"Żegnaj, świecie!\n");
}

static int device_open(struct inode *inoda, struct file *plik){

printk(KERN_INFO "Otwarcie pliku urządzenia o numerze pobocznym"
"%d\n",iminor(inoda));

if(mutex_lock_interruptible(&Device_Open)){
printk(KERN_INFO "Próba przejęcia semafora przerwana!\n");
return -ERESTARTSYS;
}

try_module_get(THIS_MODULE);

sprintf(msg, "Hello, world! mówię poraz%d\n",++licznik);
msg_Ptr=msg;

return SUCCESS;
}

static int device_release( struct inode *inoda, struct file *plik){

mutex_unlock(&Device_Open);

module_put(THIS_MODULE);
return 0;
}

static ssize_t device_read( struct file *plik, char *buforUz, size_t dlugosc, loff_t *offset){

int odczytano = 0;

if(*msg_Ptr == 0)
{
return 0;
}

while(dlugosc && *msg_Ptr){
put_user( *(msg_Ptr++), buforUz++);
dlugosc--;
odczytano++;
}
*offset += odczytano;
return odczytano;
}

static ssize_t device_write( struct file *plik, const char *bufor, size_t dlugosc, loff_t *offset){

printk(KERN_ALERT "To urządzenie nie obsługuje zapisu!\n");
return -EINVAL;
}





module_init(chardev_init);
module_exit(chardev_exit);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR(MOD_AUTHOR);
MODULE_DESCRIPTION(MOD_DESC);