heartbeat.c 3.71 KB
Newer Older
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
/*
 * Generic heartbeat driver for regular LED banks
 *
 * Copyright (C) 2007  Paul Mundt
 *
 * Most SH reference boards include a number of individual LEDs that can
 * be independently controlled (either via a pre-defined hardware
 * function or via the LED class, if desired -- the hardware tends to
 * encapsulate some of the same "triggers" that the LED class supports,
 * so there's not too much value in it).
 *
 * Additionally, most of these boards also have a LED bank that we've
 * traditionally used for strobing the load average. This use case is
 * handled by this driver, rather than giving each LED bit position its
 * own struct device.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/io.h>
Paul Mundt's avatar
Paul Mundt committed
27
#include <asm/heartbeat.h>
28
29

#define DRV_NAME "heartbeat"
Paul Mundt's avatar
Paul Mundt committed
30
#define DRV_VERSION "0.1.1"
31

Paul Mundt's avatar
Paul Mundt committed
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
static unsigned char default_bit_pos[] = { 0, 1, 2, 3, 4, 5, 6, 7 };

static inline void heartbeat_toggle_bit(struct heartbeat_data *hd,
					unsigned bit, unsigned int inverted)
{
	unsigned int new;

	new = (1 << hd->bit_pos[bit]);
	if (inverted)
		new = ~new;

	switch (hd->regsize) {
	case 32:
		iowrite32(new, hd->base);
		break;
	case 16:
		iowrite16(new, hd->base);
		break;
	default:
		iowrite8(new, hd->base);
		break;
	}
}
55
56
57
58
59
60

static void heartbeat_timer(unsigned long data)
{
	struct heartbeat_data *hd = (struct heartbeat_data *)data;
	static unsigned bit = 0, up = 1;

Paul Mundt's avatar
Paul Mundt committed
61
62
	heartbeat_toggle_bit(hd, bit, hd->flags & HEARTBEAT_INVERTED);

Takashi YOSHII's avatar
Takashi YOSHII committed
63
	bit += up;
Paul Mundt's avatar
Paul Mundt committed
64
	if ((bit == 0) || (bit == (hd->nr_bits)-1))
Takashi YOSHII's avatar
Takashi YOSHII committed
65
		up = -up;
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

	mod_timer(&hd->timer, jiffies + (110 - ((300 << FSHIFT) /
			((avenrun[0] / 5) + (3 << FSHIFT)))));
}

static int heartbeat_drv_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct heartbeat_data *hd;

	if (unlikely(pdev->num_resources != 1)) {
		dev_err(&pdev->dev, "invalid number of resources\n");
		return -EINVAL;
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (unlikely(res == NULL)) {
		dev_err(&pdev->dev, "invalid resource\n");
		return -EINVAL;
	}

	if (pdev->dev.platform_data) {
Paul Mundt's avatar
Paul Mundt committed
88
		hd = pdev->dev.platform_data;
89
	} else {
Paul Mundt's avatar
Paul Mundt committed
90
91
92
93
94
95
		hd = kzalloc(sizeof(struct heartbeat_data), GFP_KERNEL);
		if (unlikely(!hd))
			return -ENOMEM;
	}

	hd->base = ioremap_nocache(res->start, res->end - res->start + 1);
96
	if (unlikely(!hd->base)) {
Paul Mundt's avatar
Paul Mundt committed
97
98
99
100
101
102
103
		dev_err(&pdev->dev, "ioremap failed\n");

		if (!pdev->dev.platform_data)
			kfree(hd);

		return -ENXIO;
	}
104

Paul Mundt's avatar
Paul Mundt committed
105
106
107
	if (!hd->nr_bits) {
		hd->bit_pos = default_bit_pos;
		hd->nr_bits = ARRAY_SIZE(default_bit_pos);
108
109
	}

Paul Mundt's avatar
Paul Mundt committed
110
111
	if (!hd->regsize)
		hd->regsize = 8;	/* default access size */
112
113
114
115
116
117
118
119
120
121
122
123

	setup_timer(&hd->timer, heartbeat_timer, (unsigned long)hd);
	platform_set_drvdata(pdev, hd);

	return mod_timer(&hd->timer, jiffies + 1);
}

static int heartbeat_drv_remove(struct platform_device *pdev)
{
	struct heartbeat_data *hd = platform_get_drvdata(pdev);

	del_timer_sync(&hd->timer);
Paul Mundt's avatar
Paul Mundt committed
124
	iounmap(hd->base);
125
126
127

	platform_set_drvdata(pdev, NULL);

Paul Mundt's avatar
Paul Mundt committed
128
129
	if (!pdev->dev.platform_data)
		kfree(hd);
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

	return 0;
}

static struct platform_driver heartbeat_driver = {
	.probe		= heartbeat_drv_probe,
	.remove		= heartbeat_drv_remove,
	.driver		= {
		.name	= DRV_NAME,
	},
};

static int __init heartbeat_init(void)
{
	printk(KERN_NOTICE DRV_NAME ": version %s loaded\n", DRV_VERSION);
	return platform_driver_register(&heartbeat_driver);
}

static void __exit heartbeat_exit(void)
{
	platform_driver_unregister(&heartbeat_driver);
}
module_init(heartbeat_init);
module_exit(heartbeat_exit);

MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR("Paul Mundt");
157
MODULE_LICENSE("GPL v2");