Linux Device Driver Development

# Load a module
sudo insmod mymodule.ko

# Check kernel logs
dmesg | tail

# Unload a module
sudo rmmod mymodule

# List loaded modules
lsmod

#include <linux/module.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name <[email protected]>");
MODULE_DESCRIPTION("A sample Linux kernel module.");
MODULE_VERSION("1.0");

# View module info
modinfo my_module.ko

# Example output:
description:  A sample driver for learning purposes.
author:       Your Name <[email protected]>
version:      1.0
license:      GPL

#include <linux/module.h>
#include <linux/init.h>

/* Called when: sudo insmod module.ko */
static int __init hello_init(void)
{
    printk(KERN_INFO "Module loaded!\n");
    return 0;  // Return 0 = success
}

/* Called when: sudo rmmod module */
static void __exit hello_exit(void)
{
    printk(KERN_INFO "Module removed!\n");
}

module_init(hello_init);  // Register init function
module_exit(hello_exit);  // Register exit function

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Hello World Kernel Module");

// Log level macros (in order of severity)
KERN_EMERG    // 0 - System is unusable
KERN_ALERT    // 1 - Action must be taken immediately
KERN_CRIT     // 2 - Critical condition
KERN_ERR      // 3 - Error condition
KERN_WARNING  // 4 - Warning condition
KERN_NOTICE   // 5 - Normal but significant
KERN_INFO     // 6 - Informational
KERN_DEBUG    // 7 - Debug-level messages

// Usage
printk(KERN_INFO "Device initialized, major = %d\n", major);
pr_info("Shorthand for KERN_INFO\n");
pr_err("Shorthand for KERN_ERR\n");

// Syntax
module_param(name, type, permissions);

// Supported types: bool, int, uint, long, ulong, short, ushort, charp

// Example
static int my_value = 10;
module_param(my_value, int, S_IRUSR | S_IWUSR);
MODULE_PARM_DESC(my_value, "An integer parameter");

// Load with custom value
sudo insmod mymodule.ko my_value=42

// Read current value
cat /sys/module/mymodule/parameters/my_value

// module_param_array(name, type, &count, permissions)
static int my_array[5];
static int array_size;
module_param_array(my_array, int, &array_size, 0444);

// Load with array values
sudo insmod mymodule.ko my_array=10,20,30

// module_param_cb() — triggers callback when parameter is updated
static int param_set_cb(const char *val, const struct kernel_param *kp)
{
    int res = kstrtoint(val, 10, &valueETX);
    pr_info("Parameter updated to: %d\n", valueETX);
    return res;
}

static const struct kernel_param_ops param_ops = {
    .set = param_set_cb,
    .get = param_get_standard_int,
};
module_param_cb(valueETX, ¶m_ops, &valueETX, 0644);

# Identify device types using ls -l /dev
ls -l /dev

# Output example:
brw-rw---- 1 root disk 8, 0  /dev/sda    # b = block device
crw-rw---- 1 root tty  4, 0  /dev/tty0   # c = character device

# b = block device, c = character device
# The two numbers are Major and Minor numbers

ls -l /dev/ttyS0
# crw-rw---- 1 root dialout 4, 64 /dev/ttyS0
# Major: 4 → Serial driver
# Minor: 64 → Specific port ttyS0

# View all registered drivers
cat /proc/devices

dev_t dev = MKDEV(202, 0);  // Major=202, Minor=0
register_chrdev_region(dev, 1, "my_device");

// Retrieve numbers
printk("Major=%d Minor=%d\n", MAJOR(dev), MINOR(dev));

// Free on exit
unregister_chrdev_region(dev, 1);

dev_t dev = 0;
alloc_chrdev_region(&dev, 0, 1, "my_device");

printk("Major=%d Minor=%d\n", MAJOR(dev), MINOR(dev));

// Free on exit
unregister_chrdev_region(dev, 1);

# mknod -m <permissions> <path> <type> <major> <minor>
sudo mknod -m 666 /dev/my_device c 202 0
# c = character device, 202 = major, 0 = minor

# Set permissions separately
sudo chmod 666 /dev/my_device

# Verify
ls -l /dev/my_device
# crw-rw-rw- 1 root root 202, 0 /dev/my_device

# Remove when done
sudo rm /dev/my_device

// In driver init function:
// 1. Allocate major/minor
alloc_chrdev_region(&dev, 0, 1, "etx_Dev");

// 2. Create a class (visible in /sys/class/)
dev_class = class_create(THIS_MODULE, "etx_class");

// 3. Create the device — udev creates /dev/etx_device automatically
device_create(dev_class, NULL, dev, NULL, "etx_device");

// In driver exit function — cleanup:
device_destroy(dev_class, dev);
class_destroy(dev_class);

// Static allocation (compile-time)
static struct cdev my_cdev;
cdev_init(&my_cdev, &my_fops);   // Link with file ops

// Dynamic allocation (runtime)
struct cdev *my_cdev = cdev_alloc();
my_cdev->ops = &my_fops;

// Register with the kernel (after init)
int cdev_add(struct cdev *cdev, dev_t dev, unsigned int count);

// Example
cdev_init(&etx_cdev, &fops);
if (cdev_add(&etx_cdev, dev, 1) < 0) {
    pr_err("Cannot add device to system\n");
}

// Unregister on exit
void cdev_del(struct cdev *cdev);

#include <linux/fs.h>

// Define the file operations
static struct file_operations fops = {
    .owner   = THIS_MODULE,
    .open    = etx_open,
    .release = etx_release,
    .read    = etx_read,
    .write   = etx_write,
};

// Open: called when app opens /dev/etx_device
static int etx_open(struct inode *inode, struct file *file) {
    pr_info("Driver Open Called\n");
    return 0;
}

// Release: called when app closes the device
static int etx_release(struct inode *inode, struct file *file) {
    pr_info("Driver Release Called\n");
    return 0;
}

// Read: copies data from kernel to user space
static ssize_t etx_read(struct file *filp, char __user *buf,
                        size_t len, loff_t *off) {
    copy_to_user(buf, kernel_buffer, mem_size);
    return mem_size;
}

// Write: copies data from user space to kernel
static ssize_t etx_write(struct file *filp, const char __user *buf,
                         size_t len, loff_t *off) {
    copy_from_user(kernel_buffer, buf, len);
    return len;
}

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>        // kmalloc
#include <linux/uaccess.h>     // copy_to/from_user

#define MEM_SIZE 1024

dev_t dev = 0;
static struct class  *dev_class;
static struct cdev    etx_cdev;
static char          *kernel_buffer;

/* File Operations */
static struct file_operations fops = {
    .owner   = THIS_MODULE,
    .open    = etx_open,
    .release = etx_release,
    .read    = etx_read,
    .write   = etx_write,
};

static int __init etx_driver_init(void)
{
    // 1. Allocate major/minor numbers
    alloc_chrdev_region(&dev, 0, 1, "etx_Dev");
    pr_info("Major=%d Minor=%d\n", MAJOR(dev), MINOR(dev));

    // 2. Init and add cdev
    cdev_init(&etx_cdev, &fops);
    cdev_add(&etx_cdev, dev, 1);

    // 3. Create class and device node
    dev_class = class_create(THIS_MODULE, "etx_class");
    device_create(dev_class, NULL, dev, NULL, "etx_device");

    // 4. Allocate kernel buffer
    kernel_buffer = kmalloc(MEM_SIZE, GFP_KERNEL);
    strcpy(kernel_buffer, "Hello_World");

    pr_info("Driver Inserted Successfully\n");
    return 0;
}

static void __exit etx_driver_exit(void)
{
    kfree(kernel_buffer);
    device_destroy(dev_class, dev);
    class_destroy(dev_class);
    cdev_del(&etx_cdev);
    unregister_chrdev_region(dev, 1);
    pr_info("Driver Removed Successfully\n");
}

module_init(etx_driver_init);
module_exit(etx_driver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeTronicX");
MODULE_DESCRIPTION("Simple Linux Character Device Driver");

sudo insmod driver.ko
ls /dev/etx_device
sudo cat /dev/etx_device          # Read
sudo echo "Hello" > /dev/etx_device  # Write
dmesg | tail                      # Check logs
sudo rmmod driver

#include <linux/slab.h>

// Syntax: kmalloc(size, flags)
char *buffer = kmalloc(1024, GFP_KERNEL);
if (!buffer) { pr_err("Memory allocation failed\n"); }

// Clear the memory (kmalloc does NOT zero it)
memset(buffer, 0, 1024);

// Free when done
kfree(buffer);

// Common GFP flags:
// GFP_KERNEL  — Normal allocation, may sleep (use in process context)
// GFP_ATOMIC  — No sleep (use in interrupt handlers)
// GFP_DMA     — DMA-compatible memory

// unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
// Returns: 0 on success, non-zero = bytes NOT copied

copy_from_user(kernel_buffer, user_buf, len);

// unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)

copy_to_user(user_buf, kernel_buffer, mem_size);

#include <linux/ioctl.h>

// Define IOCTL commands
#define WR_VALUE  _IOW('a', 'a', int32_t*)
#define RD_VALUE  _IOR('a', 'b', int32_t*)

int32_t value = 0;

// IOCTL handler function
static long etx_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case WR_VALUE:
        copy_from_user(&value, (int32_t*)arg, sizeof(value));
        pr_info("Value Written: %d\n", value);
        break;
    case RD_VALUE:
        copy_to_user((int32_t*)arg, &value, sizeof(value));
        pr_info("Value Read: %d\n", value);
        break;
    default:
        pr_info("Invalid IOCTL command\n");
    }
    return 0;
}

// Register in file_operations
static struct file_operations fops = {
    .unlocked_ioctl = etx_ioctl,
    // ... other ops
};

#include <sys/ioctl.h>
#define WR_VALUE  _IOW('a','a',int32_t*)
#define RD_VALUE  _IOR('a','b',int32_t*)

int fd = open("/dev/my_device", O_RDWR);
int32_t number = 42, value;

ioctl(fd, WR_VALUE, &number);  // Write 42 to driver
ioctl(fd, RD_VALUE, &value);   // Read back from driver
printf("Value from device: %d\n", value);
close(fd);

cat /proc/devices     # All registered char/block major numbers
cat /proc/iomem       # Physical RAM and bus addresses
cat /proc/ioports     # I/O port addresses (x86)
cat /proc/interrupts  # Registered IRQ numbers
cat /proc/softirqs    # Registered soft IRQs
cat /proc/kallsyms    # Running kernel symbols
lsmod                 # All loaded kernel modules

#include <linux/proc_fs.h>

// Create proc entry
static struct proc_dir_entry *proc_entry;

static ssize_t read_proc(struct file *filp, char __user *buf,
                         size_t len, loff_t *off) {
    copy_to_user(buf, etx_array, len);
    return len;
}

static ssize_t write_proc(struct file *filp, const char *buf,
                          size_t len, loff_t *off) {
    copy_from_user(etx_array, buf, len);
    return len;
}

static struct proc_ops proc_fops = {
    .proc_read  = read_proc,
    .proc_write = write_proc,
};

// In init function
proc_entry = proc_create("my_proc_file", 0666, NULL, &proc_fops);

// In exit function
proc_remove(proc_entry);

#include <linux/kobject.h>
#include <linux/sysfs.h>

int etx_value = 0;
struct kobject *kobj_ref;

// show: called when user reads the sysfs file
static ssize_t sysfs_show(struct kobject *kobj,
                          struct kobj_attribute *attr, char *buf) {
    return sprintf(buf, "%d\n", etx_value);
}

// store: called when user writes to the sysfs file
static ssize_t sysfs_store(struct kobject *kobj,
                           struct kobj_attribute *attr,
                           const char *buf, size_t count) {
    sscanf(buf, "%d", &etx_value);
    return count;
}

// Define attribute (file name = "etx_value", permissions = 0660)
struct kobj_attribute etx_attr = __ATTR(etx_value, 0660,
                                        sysfs_show, sysfs_store);

// In init function
kobj_ref = kobject_create_and_add("etx_sysfs", kernel_kobj);
// Creates: /sys/kernel/etx_sysfs/
sysfs_create_file(kobj_ref, &etx_attr.attr);

// In exit function
sysfs_remove_file(kernel_kobj, &etx_attr.attr);
kobject_put(kobj_ref);

// Usage from user space
cat /sys/kernel/etx_sysfs/etx_value        # Read
echo 42 > /sys/kernel/etx_sysfs/etx_value  # Write

#include <linux/interrupt.h>

// Register ISR
// int request_irq(irq, handler, flags, name, dev_id)
int request_irq(unsigned int irq,
                irq_handler_t handler,
                unsigned long flags,
                const char *name,
                void *dev_id);

// Common flags
IRQF_SHARED     // Share IRQ with other devices
IRQF_DISABLED   // Disable all interrupts when handler runs

// Example ISR
static irqreturn_t my_irq_handler(int irq, void *dev_id)
{
    pr_info("Interrupt received! IRQ = %d\n", irq);
    // Handle the interrupt...
    return IRQ_HANDLED;  // or IRQ_NONE if not ours
}

// Register in init
request_irq(IRQ_NUM, my_irq_handler, IRQF_SHARED, "my_device", &dev_id);

// Unregister in exit
free_irq(IRQ_NUM, &dev_id);

// Enable/Disable IRQ
enable_irq(IRQ_NUM);
disable_irq(IRQ_NUM);
disable_irq_nosync(IRQ_NUM);  // Non-blocking disable

#include <linux/wait.h>

// 1. Declare and initialize (static)
DECLARE_WAIT_QUEUE_HEAD(my_wq);

// 1. Declare and initialize (dynamic)
wait_queue_head_t my_wq;
init_waitqueue_head(&my_wq);

// 2. Put process to sleep (various macros):

// Uninterruptible sleep until condition is true
wait_event(my_wq, condition);

// Interruptible sleep (can be woken by signals)
int ret = wait_event_interruptible(my_wq, condition);
if (ret == -ERESTARTSYS) pr_info("Interrupted by signal\n");

// Sleep with timeout (returns remaining jiffies or 0)
wait_event_timeout(my_wq, condition, HZ * 5);  // 5 second timeout

// Killable sleep (woken only by fatal signals)
wait_event_killable(my_wq, condition);

// 3. Wake up sleeping processes:
wake_up(&my_wq);                  // Wake one uninterruptible task
wake_up_all(&my_wq);              // Wake all uninterruptible tasks
wake_up_interruptible(&my_wq);    // Wake one interruptible task

#include <linux/workqueue.h>

// 1. Define and declare work (static)
void my_work_fn(struct work_struct *work) {
    pr_info("Deferred work executing!\n");
}
DECLARE_WORK(my_work, my_work_fn);

// 2. Dynamic initialization
struct work_struct my_work;
INIT_WORK(&my_work, my_work_fn);

// 3. Schedule work (adds to global workqueue)
schedule_work(&my_work);

// 4. Delayed work (execute after delay)
DECLARE_DELAYED_WORK(my_delayed_work, my_work_fn);
schedule_delayed_work(&my_delayed_work, HZ * 2);  // 2 sec delay

// 5. Wait for work to complete
flush_work(&my_work);
flush_scheduled_work();

// 6. Cancel pending work
cancel_work_sync(&my_work);
cancel_delayed_work_sync(&my_delayed_work);

// 7. Check if work is pending
if (work_pending(&my_work))
    pr_info("Work still pending\n");

obj-m += driver.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

# Cross-compilation for ARM
# make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

# Build
make

# Insert module
sudo insmod driver.ko

# Check logs
dmesg | tail -20

# Verify device created
ls -l /dev/etx_device
cat /proc/devices | grep etx

# Test read/write
sudo cat /dev/etx_device
echo "test" | sudo tee /dev/etx_device

# List loaded modules
lsmod | grep driver

# Remove module
sudo rmmod driver

# Check cleanup logs
dmesg | tail -5

sudo insmod module_name.ko   # Load
sudo rmmod module_name       # Unload
lsmod                        # List all loaded modules
modinfo module_name.ko       # Show module metadata

/ {
    compatible = "my-board";

    uart0: serial@e1000000 {
        compatible = "ns16550a";
        reg = <0xe1000000 0x1000>;
        clock-frequency = <115200>;
        interrupts = <10>;
    };

    gpio0: gpio@e1001000 {
        compatible = "gpio-controller";
        reg = <0xe1001000 0x1000>;
        #gpio-cells = <2>;
    };
};

static const struct of_device_id my_driver_ids[] = {
    { .compatible = "ns16550a" },
    { }
};
MODULE_DEVICE_TABLE(of, my_driver_ids);

static struct platform_driver my_driver = {
    .driver = {
        .name           = "my_driver",
        .of_match_table = my_driver_ids,
    },
    .probe  = my_probe,
    .remove = my_remove,
};

struct file_operations {
    int      (*open)   (struct inode *, struct file *);
    int      (*release)(struct inode *, struct file *);
    ssize_t  (*read)   (struct file *, char __user *,
                        size_t, loff_t *);
    ssize_t  (*write)  (struct file *, const char __user *,
                        size_t, loff_t *);
    long     (*unlocked_ioctl)(struct file *, unsigned int,
                               unsigned long);
    int      (*mmap)   (struct file *, struct vm_area_struct *);
    __poll_t (*poll)   (struct file *, struct poll_table_struct *);
    loff_t   (*llseek) (struct file *, loff_t, int);
    int      (*fsync)  (struct file *, loff_t, loff_t, int);
};

// Registration example
static struct file_operations fops = {
    .owner          = THIS_MODULE,
    .open           = my_open,
    .release        = my_release,
    .read           = my_read,
    .write          = my_write,
    .unlocked_ioctl = my_ioctl,
    .mmap           = my_mmap,
    .poll           = my_poll,
};

#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/semaphore.h>

/* ── Mutex ── */
DEFINE_MUTEX(my_mutex);
mutex_lock(&my_mutex);
    // critical section — can sleep here
mutex_unlock(&my_mutex);

/* ── Spinlock ── */
DEFINE_SPINLOCK(my_spinlock);
spin_lock(&my_spinlock);
    // critical section — must be fast, no sleeping
spin_unlock(&my_spinlock);

// ISR-safe variant (saves/restores IRQ state)
unsigned long flags;
spin_lock_irqsave(&my_spinlock, flags);
    // safe to use inside/outside interrupt context
spin_unlock_irqrestore(&my_spinlock, flags);

/* ── Semaphore ── */
struct semaphore my_sem;
sema_init(&my_sem, 1);   // binary semaphore (count = 1)
down(&my_sem);           // acquire (decrements count; sleeps if 0)
    // critical section
up(&my_sem);             // release (increments count)

// Define a tasklet function
static void my_tasklet_func(unsigned long data)
{
    struct my_device *dev = (struct my_device *)data;
    pr_info("Tasklet running — processing interrupt data\n");
    // Cannot call sleep, mutex_lock, kmalloc(GFP_KERNEL), etc.
}

// Declare tasklet (static)
static DECLARE_TASKLET(my_tasklet, my_tasklet_func, 0);

// Schedule from ISR (top half)
static irqreturn_t my_isr(int irq, void *dev_id)
{
    // Quick: acknowledge hardware interrupt
    tasklet_schedule(&my_tasklet);  // Defer the rest
    return IRQ_HANDLED;
}

// Disable/Kill tasklet on exit
tasklet_disable(&my_tasklet);
tasklet_kill(&my_tasklet);

// Set state of current process
set_current_state(TASK_INTERRUPTIBLE);
schedule();  // Yield CPU — go to sleep

// Set another task's state
set_task_state(task, TASK_RUNNING);

// Direct set (no memory barriers — use carefully)
__set_task_state(task, TASK_INTERRUPTIBLE);

// 'current' always points to the running process's task_struct
#include <linux/sched.h>

pr_info("PID: %d\n",    current->pid);
pr_info("Name: %s\n",   current->comm);
pr_info("State: %ld\n", current->state);

// Get thread_info (stack bottom)
current_thread_info();

#include <linux/kthread.h>

static int my_thread_fn(void *data)
{
    while (!kthread_should_stop()) {
        pr_info("Kernel thread running\n");
        msleep(1000);
    }
    return 0;
}

// Create and start thread
struct task_struct *t = kthread_create(my_thread_fn, NULL, "my_kthread");
if (!IS_ERR(t))
    wake_up_process(t);

// Stop thread on exit
kthread_stop(t);

// fork() — parent and child run independently
pid_t pid = fork();
if (pid == 0) {
    // Child code — has own copy of memory (copy-on-write)
    exit(0);
} else if (pid > 0) {
    // Parent continues — pid = child's PID
    wait(NULL);  // Reap child to avoid zombie
}

// vfork() — parent blocks until child exec()/exit()
pid_t pid = vfork();
if (pid == 0) {
    // Child MUST call exec() or _exit() immediately
    execv("/bin/ls", args);
} else {
    // Parent resumes here after child calls exec/exit
}

pid_t pid = fork();
if (pid == 0) {
    exit(5);              // Child exits immediately
} else {
    sleep(10);            // Child is ZOMBIE during this gap!
    wait(NULL);           // Parent reaps zombie — frees task_struct
}

// To detect zombies
// ps aux | grep 'Z'   or   cat /proc/<pid>/status | grep State

nice -n 10 my_app          # Start app with nice +10 (lower priority)
renice -n -5 -p 1234       # Change running PID 1234 to nice -5
ps axo pid,ni,comm         # View nice values of all processes

# In kernel — set scheduling priority programmatically
set_user_nice(current, 10);

// Kernel context_switch() flow (simplified)
context_switch(rq, prev, next) {
    struct mm_struct *mm = next->mm;
    struct mm_struct *oldmm = prev->active_mm;

    if (!mm)                        // Next is kernel thread
        next->active_mm = oldmm;    // Borrow prev's mm
    else
        switch_mm(oldmm, mm, next); // Switch page tables + TLB

    switch_to(prev, next, prev);    // Save/restore registers, stack
}

// Cost of context switch: typically 1–10 µs
// Minimise by: reducing lock contention, using per-CPU data

// Allocate pages directly (returns struct page *)
struct page *p = alloc_pages(GFP_KERNEL, order); // 2^order pages

// Allocate and get virtual address
unsigned long addr = __get_free_pages(GFP_KERNEL, 0); // 1 page

// Small allocations — slab allocator
struct mydata *d = kmalloc(sizeof(*d), GFP_KERNEL);

// Large non-contiguous virtual allocation
void *buf = vmalloc(1024 * 1024);  // 1 MB

// Zero-filled single page
unsigned long zp = get_zeroed_page(GFP_KERNEL);

// Free functions
kfree(d);
vfree(buf);
free_pages(addr, 0);

// kmalloc — physically contiguous, fast
char *buf = kmalloc(512, GFP_KERNEL);    // Process context — can sleep
char *isr_buf = kmalloc(64, GFP_ATOMIC); // Interrupt context — no sleep
kfree(buf);

// vmalloc — virtually contiguous, large
void *large = vmalloc(4 * 1024 * 1024);  // 4 MB
vfree(large);

// kzalloc — kmalloc + zero fill
struct mydev *dev = kzalloc(sizeof(*dev), GFP_KERNEL);

// kcalloc — kmalloc array + zero fill
int *arr = kcalloc(100, sizeof(int), GFP_KERNEL);

DEFINE_SPINLOCK(my_lock);

/* Basic */
spin_lock(&my_lock);
    // critical section
spin_unlock(&my_lock);

/* IRQ-safe (preferred in drivers) */
unsigned long flags;
spin_lock_irqsave(&my_lock, flags);
    // safe from both process and interrupt context
spin_unlock_irqrestore(&my_lock, flags);

/* Bottom-half safe */
spin_lock_bh(&my_lock);
    // safe from tasklets/softirqs
spin_unlock_bh(&my_lock);

/* Nested locks — ALWAYS acquire in the same order to avoid deadlock */
spin_lock(&lock_a);
spin_lock(&lock_b);
    // work
spin_unlock(&lock_b);
spin_unlock(&lock_a);

#include <linux/atomic.h>

atomic_t count;

atomic_set(&count, 5);            // Set to 5
int val = atomic_read(&count);    // Read value
atomic_inc(&count);               // Increment
atomic_dec(&count);               // Decrement
atomic_add(3, &count);            // Add 3
atomic_sub(2, &count);            // Subtract 2
bool z = atomic_inc_and_test(&count);  // Inc, returns true if now 0
bool z = atomic_dec_and_test(&count);  // Dec, returns true if now 0
atomic_xchg(&count, 10);              // Swap, returns old value
atomic_cmpxchg(&count, 5, 10);        // If val==5, set to 10

struct my_device {
    atomic_t refcount;
    // ... other fields
};

// Grab a reference
void get_device(struct my_device *dev) {
    atomic_inc(&dev->refcount);
}

// Release a reference — free when count hits 0
void put_device(struct my_device *dev) {
    if (atomic_dec_and_test(&dev->refcount))
        kfree(dev);
}

// Preferred modern API: kref
#include <linux/kref.h>
struct my_device { struct kref kref; };
kref_init(&dev->kref);
kref_get(&dev->kref);
kref_put(&dev->kref, my_release_fn);

/* ── Tasklet ── */
void my_tasklet_fn(unsigned long data) {
    pr_info("Tasklet running\n");
}
DECLARE_TASKLET(my_tasklet, my_tasklet_fn, 0);
tasklet_schedule(&my_tasklet);    // From ISR or anywhere
tasklet_kill(&my_tasklet);        // On driver exit

/* ── Workqueue ── */
void my_work_fn(struct work_struct *work) {
    pr_info("Work running in process context\n");
    msleep(100);       // Can sleep!
    mutex_lock(&my_mutex); // Can use mutexes!
}
DECLARE_WORK(my_work, my_work_fn);
schedule_work(&my_work);          // Add to global workqueue
flush_work(&my_work);             // Wait for completion
cancel_work_sync(&my_work);       // Cancel + wait

$ ls -l /dev/ttyS0
crw-rw---- 1 root dialout 4, 64 /dev/ttyS0
│                           │  └─ minor number (64)
│                           └──── major number (4)
└──────────────────────────────── 'c' = character device

$ ls -l /dev/sda
brw-rw---- 1 root disk 8, 0 /dev/sda
└─ 'b' = block device

# Device file types:
# c = character device  (serial port, keyboard, GPIO)
# b = block device      (HDD, SSD, SD card)
# l = symbolic link
# s = socket
# p = named pipe (FIFO)

#include <linux/fs.h>

/* ── Static allocation ── */
dev_t dev = MKDEV(240, 0);
if (register_chrdev_region(dev, 1, "my_device") < 0) {
    pr_err("Static alloc failed\n");
    return -1;
}

/* ── Dynamic allocation (RECOMMENDED) ── */
dev_t dev;
if (alloc_chrdev_region(&dev, 0, 1, "my_device") < 0) {
    pr_err("Dynamic alloc failed\n");
    return -1;
}
int major = MAJOR(dev);
int minor = MINOR(dev);
pr_info("Got major=%d minor=%d\n", major, minor);

/* ── Always free in module exit ── */
static void __exit my_exit(void) {
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev, 1);   // MUST call this!
}

#include <linux/device.h>
#include <linux/fs.h>

static dev_t dev;
static struct class  *dev_class;
static struct cdev    my_cdev;

static int __init my_init(void)
{
    /* 1. Allocate device number */
    alloc_chrdev_region(&dev, 0, 1, "my_device");

    /* 2. Initialize and register cdev */
    cdev_init(&my_cdev, &my_fops);
    my_cdev.owner = THIS_MODULE;
    cdev_add(&my_cdev, dev, 1);

    /* 3. Create device class → appears in /sys/class/ */
    dev_class = class_create(THIS_MODULE, "my_class");
    if (IS_ERR(dev_class)) {
        cdev_del(&my_cdev);
        unregister_chrdev_region(dev, 1);
        return PTR_ERR(dev_class);
    }

    /* 4. Create device → udev creates /dev/my_device automatically */
    if (IS_ERR(device_create(dev_class, NULL, dev, NULL, "my_device"))) {
        class_destroy(dev_class);
        cdev_del(&my_cdev);
        unregister_chrdev_region(dev, 1);
        return -1;
    }

    pr_info("/dev/my_device created automatically!\n");
    return 0;
}

static void __exit my_exit(void)
{
    device_destroy(dev_class, dev);    /* Remove /dev node */
    class_destroy(dev_class);          /* Remove /sys/class entry */
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev, 1);
}

#include <linux/list.h>

/* Embed list_head inside your struct */
struct my_device {
    int  id;
    char name[32];
    struct list_head list;   /* ← kernel list node */
};

/* Declare and initialize the list head */
static LIST_HEAD(device_list);
static DEFINE_SPINLOCK(list_lock);

/* ── Add device to tail ── */
void add_device(struct my_device *dev) {
    spin_lock(&list_lock);
    list_add_tail(&dev->list, &device_list);
    spin_unlock(&list_lock);
}

/* ── Remove device ── */
void remove_device(struct my_device *dev) {
    spin_lock(&list_lock);
    list_del(&dev->list);
    spin_unlock(&list_lock);
}

/* ── Find by ID ── */
struct my_device *find_device(int id) {
    struct my_device *dev;
    spin_lock(&list_lock);
    list_for_each_entry(dev, &device_list, list) {
        if (dev->id == id) {
            spin_unlock(&list_lock);
            return dev;
        }
    }
    spin_unlock(&list_lock);
    return NULL;
}

/* ── Print all ── */
void print_all(void) {
    struct my_device *dev;
    list_for_each_entry(dev, &device_list, list)
        pr_info("Device: %s (id=%d)\n", dev->name, dev->id);
}

#include <linux/timer.h>

static struct timer_list heartbeat_timer;
static int count = 0;

/* Timer callback — runs in softirq context, cannot sleep */
void timer_callback(struct timer_list *t)
{
    count++;
    pr_info("Heartbeat #%d\n", count);

    /* Reschedule every 5 seconds */
    mod_timer(&heartbeat_timer, jiffies + (5 * HZ));
}

static int __init driver_init(void)
{
    /* Initialize timer */
    timer_setup(&heartbeat_timer, timer_callback, 0);

    /* Start timer: fires in 1 second */
    mod_timer(&heartbeat_timer, jiffies + HZ);
    return 0;
}

static void __exit driver_exit(void)
{
    del_timer_sync(&heartbeat_timer);  /* Wait for any running callback */
}

/* ── Timer operations ── */
// mod_timer(&t, jiffies + HZ)    — start or reset timer
// del_timer(&t)                  — cancel timer (may already be running)
// del_timer_sync(&t)             — cancel and wait for completion ✅
// timer_pending(&t)              — returns 1 if timer is scheduled

#include <linux/hrtimer.h>
#include <linux/ktime.h>

static struct hrtimer my_hrtimer;

/* Callback — return value controls rescheduling */
enum hrtimer_restart hrt_callback(struct hrtimer *timer)
{
    pr_info("HRT fired — nanosecond precision!\n");

    /* Reschedule every 100ms */
    hrtimer_forward_now(timer, ktime_set(0, 100000000)); /* 100ms */
    return HRTIMER_RESTART;          /* Keep repeating */
    // return HRTIMER_NORESTART;     /* One-shot */
}

static int __init my_init(void)
{
    /* Initialize with monotonic clock */
    hrtimer_init(&my_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
    my_hrtimer.function = hrt_callback;

    /* Start: fires in 1 second */
    hrtimer_start(&my_hrtimer, ktime_set(1, 0), HRTIMER_MODE_REL);
    return 0;
}

static void __exit my_exit(void)
{
    hrtimer_cancel(&my_hrtimer);   /* Cancel and wait */
}

/* Time creation helpers */
ktime_t t1 = ktime_set(1, 500000000);  /* 1.5 seconds */
ktime_t t2 = ktime_set(0,   1000000);  /* 1 millisecond */
ktime_t t3 = ktime_set(0,      1000);  /* 1 microsecond */

#include <linux/spinlock.h>

static DEFINE_RWLOCK(my_rwlock);
static int shared_data = 0;

/* ── Many readers can run concurrently ── */
int read_data(void)
{
    int val;
    read_lock(&my_rwlock);         /* Multiple readers OK */
    val = shared_data;
    read_unlock(&my_rwlock);
    return val;
}

/* ── Only one writer at a time ── */
void write_data(int new_val)
{
    write_lock(&my_rwlock);        /* Exclusive access */
    shared_data = new_val;
    write_unlock(&my_rwlock);
}

/* ── IRQ-safe variants ── */
unsigned long flags;
read_lock_irqsave(&my_rwlock, flags);
    // read
read_unlock_irqrestore(&my_rwlock, flags);

write_lock_irqsave(&my_rwlock, flags);
    // write
write_unlock_irqrestore(&my_rwlock, flags);

#include <linux/kthread.h>
#include <linux/delay.h>

static struct task_struct *my_thread;

/* Thread function — runs until kthread_should_stop() returns true */
static int thread_fn(void *data)
{
    pr_info("Kernel thread started\n");

    while (!kthread_should_stop()) {
        pr_info("Thread tick\n");
        msleep(1000);              /* Sleep 1 second — OK to sleep! */
    }

    pr_info("Kernel thread stopping\n");
    return 0;
}

static int __init my_init(void)
{
    /* Create thread (does NOT start it yet) */
    my_thread = kthread_create(thread_fn, NULL, "my_kthread_%d", 0);
    if (IS_ERR(my_thread))
        return PTR_ERR(my_thread);

    /* Start the thread */
    wake_up_process(my_thread);
    return 0;
}

static void __exit my_exit(void)
{
    if (my_thread) {
        kthread_stop(my_thread);   /* Signal stop + wait for exit */
        my_thread = NULL;
    }
}

/* Bind thread to specific CPU */
// kthread_bind(my_thread, 0);    /* Run only on CPU 0 */

#include <linux/gpio.h>
#include <linux/interrupt.h>

#define GPIO_OUTPUT_PIN   17    /* LED */
#define GPIO_INPUT_PIN    27    /* Button */

static int irq_number;

static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
{
    pr_info("GPIO interrupt! Value=%d\n",
            gpio_get_value(GPIO_INPUT_PIN));
    return IRQ_HANDLED;
}

static int __init gpio_driver_init(void)
{
    /* ── Validate ── */
    if (!gpio_is_valid(GPIO_OUTPUT_PIN) || !gpio_is_valid(GPIO_INPUT_PIN)) {
        pr_err("Invalid GPIO number\n");
        return -EINVAL;
    }

    /* ── Request ownership ── */
    gpio_request(GPIO_OUTPUT_PIN, "led_gpio");
    gpio_request(GPIO_INPUT_PIN,  "btn_gpio");

    /* ── Configure direction ── */
    gpio_direction_output(GPIO_OUTPUT_PIN, 0);   /* Output, init LOW */
    gpio_direction_input(GPIO_INPUT_PIN);         /* Input */

    /* ── Drive and read ── */
    gpio_set_value(GPIO_OUTPUT_PIN, 1);           /* LED ON */
    int btn = gpio_get_value(GPIO_INPUT_PIN);     /* Read button */
    pr_info("Button state: %d\n", btn);

    /* ── GPIO as interrupt ── */
    irq_number = gpio_to_irq(GPIO_INPUT_PIN);
    request_irq(irq_number, gpio_irq_handler,
                IRQF_TRIGGER_RISING, "gpio_int", NULL);

    /* ── Export to user space via /sys/class/gpio/ ── */
    gpio_export(GPIO_OUTPUT_PIN, false);   /* false = no direction change */
    return 0;
}

static void __exit gpio_driver_exit(void)
{
    gpio_set_value(GPIO_OUTPUT_PIN, 0);
    gpio_unexport(GPIO_OUTPUT_PIN);
    free_irq(irq_number, NULL);
    gpio_free(GPIO_OUTPUT_PIN);
    gpio_free(GPIO_INPUT_PIN);
    pr_info("GPIO driver removed\n");
}

# Export GPIO 17
echo 17 > /sys/class/gpio/export

# Set as output
echo "out" > /sys/class/gpio/gpio17/direction

# Drive high / low
echo 1 > /sys/class/gpio/gpio17/value
echo 0 > /sys/class/gpio/gpio17/value

# Set as input and read
echo "in" > /sys/class/gpio/gpio17/direction
cat /sys/class/gpio/gpio17/value

# Unexport when done
echo 17 > /sys/class/gpio/unexport

/* ── Kernel driver: send SIGIO to user process ── */
#include <linux/signal.h>
#include <linux/sched/signal.h>

static struct fasync_struct *async_queue;

/* Handle fasync() system call from user space */
static int my_fasync(int fd, struct file *filp, int mode)
{
    return fasync_helper(fd, filp, mode, &async_queue);
}

/* In ISR or timer: notify user-space process */
void notify_user(void)
{
    if (async_queue)
        kill_fasync(&async_queue, SIGIO, POLL_IN);
}

/* Add to file_operations */
static struct file_operations my_fops = {
    .fasync  = my_fasync,
    /* ... other ops ... */
};

/* ── User space: receive async notification ── */
/*
#include <signal.h>
#include <fcntl.h>

void sigio_handler(int sig) {
    printf("Async data ready from driver!\n");
}

int main() {
    int fd = open("/dev/my_device", O_RDWR);
    signal(SIGIO, sigio_handler);        // Install handler
    fcntl(fd, F_SETOWN, getpid());       // This process owns the signal
    fcntl(fd, F_SETFL, O_ASYNC | O_NONBLOCK);  // Enable async
    pause();                              // Wait for signal
}
*/

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/wait.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "mydev"
#define BUF_SIZE    1024

MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeddedLinuxCareer");

static dev_t             dev_num;
static struct cdev       my_cdev;
static struct class     *my_class;
static DEFINE_MUTEX(dev_mutex);
static DECLARE_WAIT_QUEUE_HEAD(read_queue);

static char   kernel_buf[BUF_SIZE];
static int    data_ready = 0;

static int my_open(struct inode *i, struct file *f)
{
    pr_info("%s: opened\n", DEVICE_NAME);
    return 0;
}

static int my_release(struct inode *i, struct file *f)
{
    pr_info("%s: closed\n", DEVICE_NAME);
    return 0;
}

static ssize_t my_read(struct file *f, char __user *buf,
                       size_t count, loff_t *off)
{
    /* Block until data is available */
    if (wait_event_interruptible(read_queue, data_ready))
        return -ERESTARTSYS;

    mutex_lock(&dev_mutex);
    if (copy_to_user(buf, kernel_buf, min(count, (size_t)BUF_SIZE))) {
        mutex_unlock(&dev_mutex);
        return -EFAULT;
    }
    data_ready = 0;
    mutex_unlock(&dev_mutex);
    return min(count, (size_t)BUF_SIZE);
}

static ssize_t my_write(struct file *f, const char __user *buf,
                        size_t count, loff_t *off)
{
    mutex_lock(&dev_mutex);
    if (copy_from_user(kernel_buf, buf, min(count, (size_t)BUF_SIZE))) {
        mutex_unlock(&dev_mutex);
        return -EFAULT;
    }
    data_ready = 1;
    mutex_unlock(&dev_mutex);

    wake_up_interruptible(&read_queue);   /* Wake blocked readers */
    return count;
}

static struct file_operations fops = {
    .owner   = THIS_MODULE,
    .open    = my_open,
    .release = my_release,
    .read    = my_read,
    .write   = my_write,
};

static int __init my_init(void)
{
    alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    cdev_init(&my_cdev, &fops);
    my_cdev.owner = THIS_MODULE;
    cdev_add(&my_cdev, dev_num, 1);
    my_class = class_create(THIS_MODULE, DEVICE_NAME);
    device_create(my_class, NULL, dev_num, NULL, DEVICE_NAME);
    pr_info("/dev/%s ready (major=%d)\n", DEVICE_NAME, MAJOR(dev_num));
    return 0;
}

static void __exit my_exit(void)
{
    device_destroy(my_class, dev_num);
    class_destroy(my_class);
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev_num, 1);
    pr_info("/dev/%s removed\n", DEVICE_NAME);
}

module_init(my_init);
module_exit(my_exit);