開發板：tiny4412SDK + S702 + 4GB Flash
要移植的核心版本：Linux-4.4.0 （支援device tree）
u-boot版本：友善之臂自帶的 U-Boot 2010.12
busybox版本：busybox 1.25

目標：
學習裝置樹中普通中斷的表示方法。

裝置樹參考：

    watchdog: watchdog@10060000 {
        compatible = "samsung,s3c2410-wdt";
        reg = <0x10060000 0x100>;
        interrupts = <0 43
 
 0>;
        clocks = <&clock CLK_WDT>;
        clock-names = "watchdog";
        status = "disabled";
    };

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

參考 arm,gic.txt

ARM SMP cores are often associated with a GIC, providing per processor
interrupts (PPI), shared processor interrupts (SPI) and software
generated interrupts (SGI).

Primary GIC is attached directly to
 
 the CPU and typically has PPIs and SGIs.
Secondary GICs are cascaded into the upward interrupt controller and do not
have PPIs or SGIs.

Main node required properties:

- compatible : should be one of:
    "arm,arm1176jzf-devchip-gic"
    "arm,arm11mp-gic"
    "arm,cortex-a15-gic"
    "arm,cortex-a7-gic"
 

    "arm,cortex-a9-gic"
    "arm,gic-400"
    "arm,pl390"
    "brcm,brahma-b15-gic"
    "qcom,msm-8660-qgic"
    "qcom,msm-qgic2"
- interrupt-controller : Identifies the node as an interrupt controller
- #interrupt-cells : Specifies the number of cells needed to encode an
  interrupt source.  The type shall be a <u32> and the value shall be 3.

  The 1st cell is the interrupt type; 0 for SPI interrupts, 1 for PPI interrupts.
  The 2nd cell contains the interrupt number for the interrupt type. SPI interrupts are in the range [0-987].  PPI interrupts are in the range [0-15].
  The 3rd cell is the flags, encoded as follows:
    bits[3:0] trigger type and level flags.
        1 = low-to-high edge triggered
        2 = high-to-low edge triggered (invalid for SPIs)
        4 = active high level-sensitive
        8 = active low level-sensitive (invalid for SPIs).
    bits[15:8] PPI interrupt cpu mask.  Each bit corresponds to each of
    the 8 possible cpus attached to the GIC.  A bit set to '1' indicated
    the interrupt is wired to that CPU.  Only valid for PPI interrupts.
    Also note that the configurability of PPI interrupts is IMPLEMENTATION
    DEFINED and as such not guaranteed to be present (most SoC available
    in 2014 seem to ignore the setting of this flag and use the hardware
    default value).

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

interrupts = <0 43 0>;
0 flags:

• shared processor interrupts (SPI) // 共享中斷
• providing per processor interrupts (PPI) // 每個處理器擁有獨立中斷

43 中斷號：

0 觸發方式：

• 1 = low-to-high edge triggered
• 2 = high-to-low edge triggered (invalid for SPIs)
• 4 = active high level-sensitive
• 8 = active low level-sensitive (invalid for SPIs).

這裡裝置樹中雖然包含了中斷資源，但是隻是演示一下，程式碼中其實並沒有用到，看門狗定時器時間到達時可以選擇復位或者中斷，這裡採用的是復位。此外，在 4412 中看門狗復位還需要設定晶片手冊中第八章的相關暫存器。具體，請參考程式碼。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/bitops.h>
#include <linux/clk.h>
#include <linux/export.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/time.h>

/*
    PCLK 時鐘頻率 100M
    1/(100M / 100 / 128)
    128us
*/

#define  MAGIC_NUMBER    'k'
#define  WTD_ON     _IO(MAGIC_NUMBER    ,0)
#define  WTD_OFF    _IO(MAGIC_NUMBER    ,1)
#define  WTD_FEED   _IO(MAGIC_NUMBER    ,2)
#define  WTD_READ   _IO(MAGIC_NUMBER    ,3)

struct WTD_BASE
{
    unsigned int wtcon;     // 0
    unsigned int wtdat;     // 4
    unsigned int wtcnt;     // 8
    unsigned int wtclrint;  // c
};

int                         major;
struct      cdev            wtd_cdev;
struct      class           *cls;
volatile    unsigned long   *mask_wtd_reset;
struct wtddev
{
    struct      clk             *base_clk;
    volatile    struct WTD_BASE *wtd_base;
};

static struct wtddev wtd;

static void wtd_on(unsigned long arg)
{
    int ret;
    unsigned int buf;
    unsigned int wtcon;
    printk("%s\n", __func__);
    ret = copy_from_user(&buf, (const void __user *)arg, 4);

    if (ret < 0)
    {
        printk("%s copy_from_user error\n", __func__);
    }

    wtcon = wtd.wtd_base->wtcon;
    wtcon |= (0x63 << 8) | (0x03 << 3) | (0x01 << 5);
    wtcon &= ~(0x01 << 1);
    wtcon |= (0x01 << 0);
    printk("wtcon %x\n", wtcon);
    wtd.wtd_base->wtcnt = buf;
    wtd.wtd_base->wtdat = buf;
    wtd.wtd_base->wtcon = wtcon;
}

static void wtd_off(void)
{
    printk("%s\n", __func__);
    wtd.wtd_base->wtcon &= ~(0x01 << 5);
}

static void wtd_feed(unsigned long arg)
{
    int ret;
    unsigned int buf;
    printk("%s\n", __func__);
    ret = copy_from_user(&buf, (const void __user *)arg, 4);

    if (ret < 0)
    {
        printk("%s copy_from_user error\n", __func__);
    }

    wtd.wtd_base->wtcnt = buf;
}

static void wtd_read(unsigned long arg)
{
    int ret;
    unsigned int buf = wtd.wtd_base->wtcnt;
    printk("wtcnt %x\n", wtd.wtd_base->wtcnt);
    ret = copy_to_user((void __user *)arg, &buf, 4);

    if (ret < 0)
    {
        printk("%s copy_to_user error\n", __func__);
    }
}

static long wtd_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
    switch (cmd)
    {
        case WTD_ON:
            wtd_on(arg);
            break;
        case WTD_OFF:
            wtd_off();
            break;
        case WTD_FEED:
            wtd_feed(arg);
            break;
        case WTD_READ:
            wtd_read(arg);
        default :
            return -EINVAL;
    };

    return 0;
}

static int wtd_open(struct inode *inode, struct file *file)
{
    printk("wtd_open\n");
    return 0;
}

static int wtd_release(struct inode *inode, struct file *file)
{
    printk("wtd_exit\n");
    return 0;
}

static struct file_operations wtd_fops =
{
    .owner              = THIS_MODULE,
    .open               = wtd_open,
    .release            = wtd_release,
    .unlocked_ioctl     = wtd_ioctl,
};

static int wtd_probe(struct platform_device *pdev)
{
    dev_t       devid;
    struct      device      *dev    = &pdev->dev;
    struct      resource    *res    = NULL;
    struct      resource    *res1   = NULL;
    int ret;
    printk("enter %s\n", __func__);
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    res1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);//reset mask /unit 8 pmu

    if (res == NULL || res1 == NULL)
    {
        printk("platform_get_resource error\n");
        return -EINVAL;
    }

    printk("res: %x\n", (unsigned int)res->start);
    printk("res1: %x\n", (unsigned int)res1->start);
    wtd.base_clk = devm_clk_get(&pdev->dev, "watchdog");

    if (IS_ERR(wtd.base_clk))
    {
        dev_err(dev, "failed to get timer base clk\n");
        return PTR_ERR(wtd.base_clk);
    }

    ret = clk_prepare_enable(wtd.base_clk);

    if (ret != 0)
    {
        dev_err(dev, "failed to enable base clock\n");
        return ret;
    }

    wtd.wtd_base = devm_ioremap_resource(&pdev->dev, res);
    mask_wtd_reset = ioremap(res1->start, 0x04);
    writel(0x00, mask_wtd_reset);

    if (wtd.wtd_base == NULL)
    {
        printk("devm_ioremap_resource error\n");
        goto err_clk;
    }

    if (alloc_chrdev_region(&devid, 0, 1, "wtd") < 0)
    {
        printk("%s ERROR\n", __func__);
        goto err_clk;
    }

    major = MAJOR(devid);
    cdev_init(&wtd_cdev, &wtd_fops);
    cdev_add(&wtd_cdev, devid, 1);
    cls = class_create(THIS_MODULE, "mywtd");
    device_create(cls, NULL, MKDEV(major, 0), NULL, "wtd");
    return 0;
err_clk:
    clk_disable(wtd.base_clk);
    clk_unprepare(wtd.base_clk);
    return -EINVAL;
}

static int wtd_remove(struct platform_device *pdev)
{
    printk("enter %s\n", __func__);
    device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    cdev_del(&wtd_cdev);
    unregister_chrdev_region(MKDEV(major, 0), 1);
    clk_disable(wtd.base_clk);
    clk_unprepare(wtd.base_clk);
    iounmap(mask_wtd_reset);
    printk("%s enter.\n", __func__);
    return 0;
}

static const struct of_device_id wtd_dt_ids[] =
{
    { .compatible = "tiny4412,wtd_demo", },
    {},
};

MODULE_DEVICE_TABLE(of, wtd_dt_ids);

static struct platform_driver wtd_driver =
{
    .driver        = {
        .name      = "wtd_demo",
        .of_match_table    = of_match_ptr(wtd_dt_ids),
    },
    .probe         = wtd_probe,
    .remove        = wtd_remove,
};

static int wtd_init(void)
{
    int ret;
    printk("enter %s\n", __func__);
    ret = platform_driver_register(&wtd_driver);

    if (ret)
    {
        printk(KERN_ERR "wtd demo: probe faiwtd: %d\n", ret);
    }

    return ret;
}

static void wtd_exit(void)
{
    printk("enter %s\n", __func__);
    platform_driver_unregister(&wtd_driver);
}

module_init(wtd_init);
module_exit(wtd_exit);
MODULE_LICENSE("GPL");

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165
• 166
• 167
• 168
• 169
• 170
• 171
• 172
• 173
• 174
• 175
• 176
• 177
• 178
• 179
• 180
• 181
• 182
• 183
• 184
• 185
• 186
• 187
• 188
• 189
• 190
• 191
• 192
• 193
• 194
• 195
• 196
• 197
• 198
• 199
• 200
• 201
• 202
• 203
• 204
• 205
• 206
• 207
• 208
• 209
• 210
• 211
• 212
• 213
• 214
• 215
• 216
• 217
• 218
• 219
• 220
• 221
• 222
• 223
• 224
• 225
• 226
• 227
• 228
• 229
• 230
• 231
• 232
• 233
• 234
• 235
• 236
• 237
• 238
• 239
• 240
• 241
• 242
• 243
• 244
• 245
• 246
• 247
• 248
• 249
• 250
• 251
• 252
• 253
• 254
• 255
• 256
• 257
• 258
• 259
• 260
• 261
• 262
• 263
• 264
• 265
• 266
• 267
• 268
• 269

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165
• 166
• 167
• 168
• 169
• 170
• 171
• 172
• 173
• 174
• 175
• 176
• 177
• 178
• 179
• 180
• 181
• 182
• 183
• 184
• 185
• 186
• 187
• 188
• 189
• 190
• 191
• 192
• 193
• 194
• 195
• 196
• 197
• 198
• 199
• 200
• 201
• 202
• 203
• 204
• 205
• 206
• 207
• 208
• 209
• 210
• 211
• 212
• 213
• 214
• 215
• 216
• 217
• 218
• 219
• 220
• 221
• 222
• 223
• 224
• 225
• 226
• 227
• 228
• 229
• 230
• 231
• 232
• 233
• 234
• 235
• 236
• 237
• 238
• 239
• 240
• 241
• 242
• 243
• 244
• 245
• 246
• 247
• 248
• 249
• 250
• 251
• 252
• 253
• 254
• 255
• 256
• 257
• 258
• 259
• 260
• 261
• 262
• 263
• 264
• 265
• 266
• 267
• 268
• 269