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
|
Add EEPROM notifiers
These help board level code by allowing a callback when EEPROMs are
loaded, this permits system level configuration to be loaded from the
EEPROM. This is particularly useful when the ethernet MAC ids are
stored in EEPROM and when the ethernet hardware is generic (so it
has no board level knowledge), then the MACs can be loaded into
the 'maclist' code and read out by the ethernet config.
Signed-off-by: John Bowler <jbowler@acm.org>
--- linux-2.6.15/drivers/i2c/chips/eeprom.c 1970-01-01 00:00:00.000000000 +0000
+++ linux-2.6.15/drivers/i2c/chips/eeprom.c 1970-01-01 00:00:00.000000000 +0000
@@ -25,7 +25,6 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
@@ -33,6 +32,9 @@
#include <linux/sched.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
+#include <linux/notifier.h>
+
+#include <linux/eeprom.h>
/* Addresses to scan */
static unsigned short normal_i2c[] = { 0x50, 0x51, 0x52, 0x53, 0x54,
@@ -41,6 +43,9 @@ static unsigned short normal_i2c[] = { 0
/* Insmod parameters */
I2C_CLIENT_INSMOD_1(eeprom);
+/* Notifier list */
+static DECLARE_MUTEX(eeprom_notifier_mutex);
+static LIST_HEAD(eeprom_notifiers);
/* Size of EEPROM in bytes */
#define EEPROM_SIZE 256
@@ -160,6 +165,7 @@ static int eeprom_detect(struct i2c_adap
struct i2c_client *new_client;
struct eeprom_data *data;
int err = 0;
+ struct list_head *this;
/* There are three ways we can read the EEPROM data:
(1) I2C block reads (faster, but unsupported by most adapters)
@@ -196,7 +202,7 @@ static int eeprom_detect(struct i2c_adap
/* Detect the Vaio nature of EEPROMs.
We use the "PCG-" prefix as the signature. */
- if (address == 0x57) {
+ if (list_empty(&eeprom_notifiers) && address == 0x57) {
if (i2c_smbus_read_byte_data(new_client, 0x80) == 'P'
&& i2c_smbus_read_byte(new_client) == 'C'
&& i2c_smbus_read_byte(new_client) == 'G'
@@ -210,6 +216,14 @@ static int eeprom_detect(struct i2c_adap
/* create the sysfs eeprom file */
sysfs_create_bin_file(&new_client->dev.kobj, &eeprom_attr);
+ /* Call each notifier callback */
+ down(&eeprom_notifier_mutex);
+ list_for_each(this, &eeprom_notifiers) {
+ struct eeprom_notifier *not = list_entry(this, struct eeprom_notifier, list);
+ not->add(address, kind, &new_client->dev.kobj, &eeprom_attr);
+ }
+ up(&eeprom_notifier_mutex);
+
return 0;
exit_kfree:
@@ -231,6 +245,51 @@ static int eeprom_detach_client(struct i
return 0;
}
+/**
+ * register_eeprom_user - register a 'user' of EEPROM devices.
+ * @new: pointer to notifier info structure
+ *
+ * Registers a callback function to be called upon detection
+ * of an EEPROM device. Detection invokes the 'add' callback
+ * with the kobj of the mutex and a bin_attribute which allows
+ * read from the EEPROM. The intention is that the notifier
+ * will be able to read system configuration from the notifier.
+ *
+ * Only EEPROMs detected *after* the addition of the notifier
+ * are notified. I.e. EEPROMs already known to the system
+ * will not be notified - add the notifier from board level
+ * code!
+ */
+void register_eeprom_user (struct eeprom_notifier *new)
+{
+ down(&eeprom_notifier_mutex);
+
+ list_add(&new->list, &eeprom_notifiers);
+
+ up(&eeprom_notifier_mutex);
+}
+
+/**
+ * unregister_eeprom_user - unregister a 'user' of EEPROM devices.
+ * @old: pointer to notifier info structure
+ *
+ * Removes a callback function from the list of 'users' to be
+ * notified upon detection of EEPROM devices.
+ */
+void unregister_eeprom_user (struct eeprom_notifier *old)
+{
+ down(&eeprom_notifier_mutex);
+
+ list_del(&old->list);
+
+ up(&eeprom_notifier_mutex);
+}
+
+
+EXPORT_SYMBOL(register_eeprom_user);
+EXPORT_SYMBOL(unregister_eeprom_user);
+
+
static int __init eeprom_init(void)
{
return i2c_add_driver(&eeprom_driver);
--- linux-2.6.15/include/linux/eeprom.h 1970-01-01 00:00:00.000000000 +0000
+++ linux-2.6.15/include/linux/eeprom.h 1970-01-01 00:00:00.000000000 +0000
@@ -0,0 +1,56 @@
+#ifndef _LINUX_EEPROM_H
+#define _LINUX_EEPROM_H
+/*
+ * $Id: 45-eeprom-notifier.patch,v 1.1 2006/02/07 00:38:33 azummo Exp $
+ *
+ * Copyright (C) 2006 John Bowler
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __KERNEL__
+#error This is a kernel header
+#endif
+
+#include <linux/list.h>
+#include <linux/kobject.h>
+#include <linux/sysfs.h>
+
+/*
+ * This is very basic.
+ *
+ * If an EEPROM is detected on the I2C bus (this only works for
+ * I2C EEPROMs) the eeprom_notifier::add method is called with
+ * both the I2C information and the kobject for the sysfs
+ * device which has been registers. It is then possible to
+ * read from the device via the bin_attribute::read method
+ * to extract configuration information.
+ *
+ * Register the notifier in the board level code, there is no
+ * need to unregister it but you can if you want (it will save
+ * a little bit or kernel memory to do so).
+ */
+struct eeprom_notifier {
+ void (*add)(int address, int kind, struct kobject *kobj,
+ struct bin_attribute *eeprom_attr);
+ struct list_head list;
+};
+
+extern void register_eeprom_user (struct eeprom_notifier *new);
+extern void unregister_eeprom_user (struct eeprom_notifier *old);
+
+#endif /* _LINUX_EEPROM_H */
|
