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

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 obszaru urzadzenia"
	"w jadrze - 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 jadrze - 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ądzenia. 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 przerwania!\n");
return -ERESTARTSYS;
}
try_module_get(THIS_MODULE);

sprintf(msg, "Hello, world! mówię po raz %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);