轉貼部落格

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

#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <asm/io.h>

#include "bus.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zl");

int zl_match(struct device * dev, struct device_driver * drv);

struct bus_type zl_bus = {
    .name = "zlbus",
    .match = zl_match,
};

int zl_device_register(struct zl_device *dev)
{
    dev->dev.bus = &zl_bus;    
    //strcpy(dev->dev.bus_id, dev->name); //2.6.13

    dev->dev.init_name = dev->name; //2.6.36

    device_register(&dev->dev);
    return 0;
}
EXPORT_SYMBOL(zl_device_register);

int zl_device_unregister(struct zl_device *dev)
{
    device_unregister(&dev->dev);
    return 0;
}
EXPORT_SYMBOL(zl_device_unregister);

int zl_driver_register(struct zl_driver *drv)
{
    drv->drv.bus = &zl_bus;

    driver_register(&drv->drv);
    return 0;
}
EXPORT_SYMBOL(zl_driver_register);

int zl_driver_unregister(struct zl_driver *drv)
{
    driver_unregister(&drv->drv);
    return 0;
}
EXPORT_SYMBOL(zl_driver_unregister);

//------------------------------------------
int zl_match(struct device * dev, struct device_driver * drv)
{
    struct zl_device *zldev;
    struct zl_driver *zldrv;

    printk("zl_match.\n");

    zldev = container_of(dev, struct zl_device, dev);
    zldrv = container_of(drv, struct zl_driver, drv);
    
    if ((zldev->idVendor == zldrv->idVendor) && (zldev->idProduct ==zldrv->idProduct)) {
        return 1;
    }
    return 0;
}

int test_init(void)
{
    int ret = 0;

    bus_register(&zl_bus);

    return ret;
}

void test_exit(void)
{
    bus_unregister(&zl_bus);
}

module_init(test_init);
module_exit(test_exit);



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

#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/device.h>

#include <asm/io.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zl");

struct bus_type zl_bus = { 
    .name = "zlbus", //this string will be show as /sys/bus/zlbus

};

EXPORT_SYMBOL(zl_bus);


int test_init(void)
{
    int ret = 0;

    bus_register(&zl_bus);

    return ret;
}

void test_exit(void)
{
    bus_unregister(&zl_bus);
}

module_init(test_init);
module_exit(test_exit);


ifneq ($(KERNELRELEASE),)
    obj-m := kprobe_clock_settime.o 
else
    KERNELDIR := /lib/modules/$(shell uname -r)/build
    PWD := $(shell pwd)
default:
        $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif
clean:
        rm -r *.ko *.o .*.cmd .tmp_versions *.mod.c *.symvers modules.order

#define COARSE_FLAGS    (1 | (1 << 4) ) //bit(1,0) = 01 coarse page base, 
#define SMALL_MEM_FLAGS        (2 | (1 << 2) | ( 1 << 3)) //bit(1,0) = 10 4KB page, bit(3,2) = 11 write back cacheable
#define SMALL_IO_FLAGS        (2 ) //bit(1,0) = 10 4KB page, bit(3,2) = 00 nocached nobuffered


(*printf)(char *, ...) = 0x33f95964;

/*
 *前面０地址开始的4KB + 0x30000000开始的64MB
 *
 *1个一级页项表对应256个二级页表项
 *
 *1个二级页表项对应1个页帧
 *
 *1个页帧4KB
 *
 */ 

#define TTB 0x32000000; //ttb基址，也是一级页目录表基址
#define TTB_L2 (0x32000000 + 0x4000) //二级页表基址, 给一级页表留足16KB

unsigned long *ttb = (void *)TTB; 
unsigned long *ttb_l2 = (void *)TTB_L2; 

void memset(char *dst, char ch, int size);
void _start(void)
{
    unsigned long c1_flags;
    unsigned long virt, phys, temp, addr;
    int *p;

    memset(ttb, 0x00, 4096 * 4);

    c1_flags = 1 | (1 << 1) | (0xf << 3) | (0x3 << 30); //bit0 = 1 MMU enable,bit1 = 1 fault check, bit6..3 = 0xf write, bit31,30 = 0x3 async clock mode

/*第一个4KB, 第一页*/
    ttb[0] = ((unsigned long)ttb_l2) | COARSE_FLAGS;
    ttb_l2[0] = 0 | SMALL_MEM_FLAGS;
    ttb_l2 = TTB_L2 + 256 * 4;
/*线性地址空间[0x30000000, 0x34000000] 映射到物理地址空间[0x30000000, 0x34000000]*/
    for (addr = 0x30000000; addr < 0x34000000; ttb_l2 += 256) {
        ttb[addr >> 20]    = ((unsigned long )ttb_l2 & 0xfffffc00) | COARSE_FLAGS;

        temp = addr + 0x100000; //限定处理1MB空间对应的页表

        for (; addr < temp; addr += 0x1000) {
            ttb_l2[(addr & 0xff000) >> 12] = (addr & 0xfffff000) | SMALL_MEM_FLAGS;
        }    
    }
    
/*线性地址空间[0x48000000, 0x60000000] 映射到物理地址空间[0x48000000, 0x60000000]*/
    for (addr = 0x48000000; addr < 0x60000000; ttb_l2 += 256) {
        ttb[addr >> 20]    = ((unsigned long)ttb_l2 & 0xfffffc00) | COARSE_FLAGS;

        temp = addr + 0x100000; //限定处理1MB空间对应的页表

        for (; addr < temp; addr += 0x1000) {
            ttb_l2[(addr & 0xff000) >> 12] = (addr & 0xfffff000) | SMALL_IO_FLAGS;
        }
    }

/*线性地址空间[0xc0000000, 0xc4000000] 映射到物理地址空间[0x30000000, 0x34000000]*/
    for (virt = 0xc0000000; virt < 0xc4000000; ttb_l2 += 256) {
        ttb[virt >> 20]    = ((unsigned long )ttb_l2 & 0xfffffc00) | COARSE_FLAGS;

        temp = virt + 0x100000; //每一个一级页表项限定处理1MB空间对应的页表

        for (; virt < temp; virt += 0x1000) {
            phys = virt - 0xc0000000 + 0x30000000; //虚拟地址与物理地址之间的关系

            ttb_l2[(virt & 0xff000) >> 12] = (phys & 0xfffff000) | SMALL_MEM_FLAGS;
        }    
    }
//------------------------------------------


    __asm__ __volatile__ (    
        "mov r0, #0\n"            
        "mcr p15, 0, r0, c7, c7, 0\n" //清除I-cache和D-cache的内容：
        "mcr p15, 0, r0, c8, c7, 0\n" //清除I & D TLB 的内容

        "mvn r0, #0\n"
        "mcr p15, 0, r0, c3, c0, 0\n" //clear Domain access control
        //--------------------------------
        "mcr p15, 0, %1, c2, c0, 0\n" //ttb写入c2
        "mcr p15, 0, %0, c1, c0, 0\n" //c1_flags写入c1
        :
        : "r" (c1_flags), "r" (ttb)
        : "r0"
    );
/*先看初始值*/
    virt = 0x30130000;
    printf("0x30130000 = %x\n", *(int *)virt);
    virt = 0xc0130000;
    printf("0xc0130000 = %x\n", *(int *)virt);

/*修改0x30130000地址处的值, 再看0xc0130000处的值*/
    virt = 0x30130000;
    *(int *)virt = 0x2222;
    virt = 0xc0130000;
    printf("0xc0130000 = %x\n", *(int *)virt);

/*修改0x30130000地址处的值, 再看0xc0130000处的值*/
    virt = 0x30130000;
    *(int *)virt = 0x3333;
    virt = 0xc0130000;
    printf("0xc0130000 = %x\n", *(int *)virt);
}

void memset(char *dst, char ch, int size)
{
    int i;
    for (i = 0; i < size; i ++) {
        dst[i] = ch;
    }
}


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

#include <linux/mm.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/workqueue.h>

#include <asm/current.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhanglong");

struct work_struct my_work;

void work_handle(struct work_struct* arg)
{
    long data = atomic_long_read(&arg->data);

    printk("current: %s, pid: %d\n", current->comm, current->pid);
    ssleep(3);
    printk("after sleep, data = %ld\n", data);    
    //printk("&my_work = 0x%x\n", (unsigned int)&my_work);    

}

irqreturn_t irq_handle(int irq, void *dev_id)
{
    schedule_work(&my_work);
    printk("----irq handle. dev_id = %d\n", (int)dev_id);
    return 0;
}

int test_init(void)
{
    int ret = 0;

    INIT_WORK(&my_work, work_handle);

    set_irq_type(IRQ_EINT0, IRQ_TYPE_EDGE_RISING);
    ret = request_irq(IRQ_EINT0, irq_handle, 0, "my irq", (void *)123);
    if (ret) {    
        printk("request irq failed.\n");
        return -EBUSY;
    }

    return 0;
}

void test_exit(void)
{
    free_irq(IRQ_EINT0, (void *)123);
}

module_init(test_init);
module_exit(test_exit);

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

#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/delay.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhanglong");

struct tasklet_struct my_tasklet;

void tasklet_action(unsigned long arg)
{
    printk("tasklet handle. arg = %ld\n", arg);    
}

static irqreturn_t irq_handle(int irq, void *dev_id)
{
    tasklet_schedule(&my_tasklet);　　　　//再中断处理函数中调度tasklet
    printk("------irq handle. dev_id = %d\n", (int)dev_id);
    return IRQ_HANDLED;
}

int test_init(void)
{
    int ret = 0;

    tasklet_init(&my_tasklet, tasklet_action, 789);

    set_irq_type(IRQ_EINT0, IRQ_TYPE_EDGE_RISING);
    ret = request_irq(IRQ_EINT0, irq_handle, 0, "my irq", (void *)123);
    if (ret) {    
        printk("request irq failed.\n");
        return -EBUSY;
    }

    return 0;
}

void test_exit(void)
{
    free_irq(IRQ_EINT0, (void *)123);
}

module_init(test_init);
module_exit(test_exit);

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

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhanglong");

void my_softirq_action(struct softirq_action *data)
{
    printk("my softirq atcion ok!\n");
    return;
}

static irqreturn_t irq_handle(int irq, void *dev_id, struct pt_regs *regs)
{
    int flag;

    raise_softirq(MY_SOFTIRQ); //触发软中断
    printk("irq %s ok.\n", dev_id);