mirror of
https://github.com/cirosantilli/linux-kernel-module-cheat.git
synced 2026-01-13 20:12:26 +00:00
145 lines
4.0 KiB
C
145 lines
4.0 KiB
C
/*
|
|
Only works for ARM.
|
|
|
|
Uses:
|
|
|
|
- hw/misc/lkmc_platform_device.c minimal device added in our QEMU fork
|
|
|
|
- the device tree entry we added to our Linux kernel fork:
|
|
https://github.com/cirosantilli/linux/blob/361bb623671a52a36a077a6dd45843389a687a33/arch/arm/boot/dts/versatile-pb.dts#L42
|
|
|
|
See: https://stackoverflow.com/questions/28315265/how-to-add-a-new-device-in-qemu-source-code/44612957#44612957
|
|
|
|
Expected outcome after insmod:
|
|
|
|
- QEMU reports MMIO with printfs
|
|
- IRQs are generated and handled by this module, which logs to dmesg
|
|
|
|
Also without insmodding this module, try:
|
|
|
|
devmem 0x101e9000 w 0x12345678
|
|
|
|
which touches from userland through /dev/mem.
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/io.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
static struct resource res;
|
|
static unsigned int irq;
|
|
static void __iomem *map;
|
|
|
|
static irqreturn_t lkmc_irq_handler(int irq, void *dev)
|
|
{
|
|
/* TODO this 34 and not 18 as in the DTS, likely the interrupt controller moves it around.
|
|
* Understand precisely. 34 = 18 + 16, I think 16 is by how much the controller will shift it. */
|
|
pr_info("lkmc_irq_handler irq = %d dev = %llx\n", irq, *(unsigned long long *)dev);
|
|
/* ACK the IRQ. */
|
|
iowrite32(0x9ABCDEF0, map + 4);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int lkmc_platform_device_probe(struct platform_device *pdev)
|
|
{
|
|
int asdf;
|
|
struct device *dev = &pdev->dev;
|
|
struct device_node *np = dev->of_node;
|
|
|
|
dev_info(dev, "probe\n");
|
|
|
|
/* Play with our custom device tree poperty. */
|
|
if (of_property_read_u32(np, "lkmc-asdf", &asdf) ) {
|
|
dev_err(dev, "of_property_read_u32\n");
|
|
return -EINVAL;
|
|
}
|
|
if (asdf != 0x12345678) {
|
|
dev_err(dev, "asdf = %llx\n", (unsigned long long)asdf);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* IRQ. Shared so that other test modules may snoop it. */
|
|
irq = irq_of_parse_and_map(dev->of_node, 0);
|
|
if (request_irq(irq, lkmc_irq_handler, IRQF_SHARED, "lkmc_platform_device", dev) < 0) {
|
|
dev_err(dev, "request_irq");
|
|
return -EINVAL;
|
|
}
|
|
dev_info(dev, "irq = %u\n", irq);
|
|
|
|
/* MMIO. */
|
|
if (of_address_to_resource(pdev->dev.of_node, 0, &res)) {
|
|
dev_err(dev, "of_address_to_resource");
|
|
return -EINVAL;
|
|
}
|
|
if (!request_mem_region(res.start, resource_size(&res), "lkmc_platform_device")) {
|
|
dev_err(dev, "request_mem_region");
|
|
return -EINVAL;
|
|
}
|
|
map = of_iomap(pdev->dev.of_node, 0);
|
|
if (!map) {
|
|
dev_err(dev, "of_iomap");
|
|
return -EINVAL;
|
|
}
|
|
dev_info(dev, "res.start = %llx resource_size = %llx\n",
|
|
(unsigned long long)res.start, (unsigned long long)resource_size(&res));
|
|
|
|
/* Test MMIO and IRQ: writing to the register generates an IRQ. */
|
|
iowrite32(0x12345678, map);
|
|
|
|
/* Test register read. */
|
|
if (ioread32(map + 0) != 0x12340000) panic("assert");
|
|
if (ioread32(map + 8) != 0x12340008) panic("assert");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lkmc_platform_device_remove(struct platform_device *pdev)
|
|
{
|
|
dev_info(&pdev->dev, "remove\n");
|
|
free_irq(irq, &pdev->dev);
|
|
iounmap(map);
|
|
release_mem_region(res.start, resource_size(&res));
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id of_lkmc_platform_device_match[] = {
|
|
/* This tells our driver which device tree node it will use.
|
|
* It matches the kmc_platform_device@XXXX entry that we added to the device tree. */
|
|
{ .compatible = "lkmc_platform_device", },
|
|
{},
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, of_lkmc_platform_device_match);
|
|
|
|
static struct platform_driver lkmc_plaform_driver = {
|
|
.probe = lkmc_platform_device_probe,
|
|
.remove = lkmc_platform_device_remove,
|
|
.driver = {
|
|
.name = "lkmc_platform_device",
|
|
.of_match_table = of_lkmc_platform_device_match,
|
|
.owner = THIS_MODULE,
|
|
},
|
|
};
|
|
|
|
static int lkmc_platform_device_init(void)
|
|
{
|
|
pr_info("lkmc_platform_device_init\n");
|
|
return platform_driver_register(&lkmc_plaform_driver);
|
|
}
|
|
|
|
static void lkmc_platform_device_exit(void)
|
|
{
|
|
pr_info("lkmc_platform_device_exit\n");
|
|
platform_driver_unregister(&lkmc_plaform_driver);
|
|
}
|
|
|
|
module_init(lkmc_platform_device_init)
|
|
module_exit(lkmc_platform_device_exit)
|
|
MODULE_LICENSE("GPL");
|