2 Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl> and
3 Philip Edelbrock <phil@netroedge.com>
4 Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
5 Copyright (C) 2003 IBM Corp.
6 Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/mutex.h>
31 /* Addresses to scan */
32 static const unsigned short normal_i2c
[] = { 0x50, 0x51, 0x52, 0x53, 0x54,
33 0x55, 0x56, 0x57, I2C_CLIENT_END
};
35 /* Insmod parameters */
36 I2C_CLIENT_INSMOD_1(eeprom
);
39 /* Size of EEPROM in bytes */
40 #define EEPROM_SIZE 256
42 /* possible types of eeprom devices */
48 /* Each client has this additional data */
50 struct i2c_client client
;
51 struct mutex update_lock
;
52 u8 valid
; /* bitfield, bit!=0 if slice is valid */
53 unsigned long last_updated
[8]; /* In jiffies, 8 slices */
54 u8 data
[EEPROM_SIZE
]; /* Register values */
55 enum eeprom_nature nature
;
59 static int eeprom_attach_adapter(struct i2c_adapter
*adapter
);
60 static int eeprom_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
61 static int eeprom_detach_client(struct i2c_client
*client
);
63 /* This is the driver that will be inserted */
64 static struct i2c_driver eeprom_driver
= {
68 .attach_adapter
= eeprom_attach_adapter
,
69 .detach_client
= eeprom_detach_client
,
72 static void eeprom_update_client(struct i2c_client
*client
, u8 slice
)
74 struct eeprom_data
*data
= i2c_get_clientdata(client
);
77 mutex_lock(&data
->update_lock
);
79 if (!(data
->valid
& (1 << slice
)) ||
80 time_after(jiffies
, data
->last_updated
[slice
] + 300 * HZ
)) {
81 dev_dbg(&client
->dev
, "Starting eeprom update, slice %u\n", slice
);
83 if (i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_READ_I2C_BLOCK
)) {
84 for (i
= slice
<< 5; i
< (slice
+ 1) << 5; i
+= 32)
85 if (i2c_smbus_read_i2c_block_data(client
, i
,
90 for (i
= slice
<< 5; i
< (slice
+ 1) << 5; i
+= 2) {
91 int word
= i2c_smbus_read_word_data(client
, i
);
94 data
->data
[i
] = word
& 0xff;
95 data
->data
[i
+ 1] = word
>> 8;
98 data
->last_updated
[slice
] = jiffies
;
99 data
->valid
|= (1 << slice
);
102 mutex_unlock(&data
->update_lock
);
105 static ssize_t
eeprom_read(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
106 char *buf
, loff_t off
, size_t count
)
108 struct i2c_client
*client
= to_i2c_client(container_of(kobj
, struct device
, kobj
));
109 struct eeprom_data
*data
= i2c_get_clientdata(client
);
112 if (off
> EEPROM_SIZE
)
114 if (off
+ count
> EEPROM_SIZE
)
115 count
= EEPROM_SIZE
- off
;
117 /* Only refresh slices which contain requested bytes */
118 for (slice
= off
>> 5; slice
<= (off
+ count
- 1) >> 5; slice
++)
119 eeprom_update_client(client
, slice
);
121 /* Hide Vaio private settings to regular users:
122 - BIOS passwords: bytes 0x00 to 0x0f
123 - UUID: bytes 0x10 to 0x1f
124 - Serial number: 0xc0 to 0xdf */
125 if (data
->nature
== VAIO
&& !capable(CAP_SYS_ADMIN
)) {
128 for (i
= 0; i
< count
; i
++) {
129 if ((off
+ i
<= 0x1f) ||
130 (off
+ i
>= 0xc0 && off
+ i
<= 0xdf))
133 buf
[i
] = data
->data
[off
+ i
];
136 memcpy(buf
, &data
->data
[off
], count
);
142 static struct bin_attribute eeprom_attr
= {
151 static int eeprom_attach_adapter(struct i2c_adapter
*adapter
)
153 if (!(adapter
->class & (I2C_CLASS_DDC
| I2C_CLASS_SPD
)))
155 return i2c_probe(adapter
, &addr_data
, eeprom_detect
);
158 /* This function is called by i2c_probe */
159 static int eeprom_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
161 struct i2c_client
*client
;
162 struct eeprom_data
*data
;
165 /* EDID EEPROMs are often 24C00 EEPROMs, which answer to all
166 addresses 0x50-0x57, but we only care about 0x50. So decline
167 attaching to addresses >= 0x51 on DDC buses */
168 if (!(adapter
->class & I2C_CLASS_SPD
) && address
>= 0x51)
171 /* There are four ways we can read the EEPROM data:
172 (1) I2C block reads (faster, but unsupported by most adapters)
173 (2) Word reads (128% overhead)
174 (3) Consecutive byte reads (88% overhead, unsafe)
175 (4) Regular byte data reads (265% overhead)
176 The third and fourth methods are not implemented by this driver
177 because all known adapters support one of the first two. */
178 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_READ_WORD_DATA
)
179 && !i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_READ_I2C_BLOCK
))
182 if (!(data
= kzalloc(sizeof(struct eeprom_data
), GFP_KERNEL
))) {
187 client
= &data
->client
;
188 memset(data
->data
, 0xff, EEPROM_SIZE
);
189 i2c_set_clientdata(client
, data
);
190 client
->addr
= address
;
191 client
->adapter
= adapter
;
192 client
->driver
= &eeprom_driver
;
194 /* Fill in the remaining client fields */
195 strlcpy(client
->name
, "eeprom", I2C_NAME_SIZE
);
196 mutex_init(&data
->update_lock
);
197 data
->nature
= UNKNOWN
;
199 /* Tell the I2C layer a new client has arrived */
200 if ((err
= i2c_attach_client(client
)))
203 /* Detect the Vaio nature of EEPROMs.
204 We use the "PCG-" or "VGN-" prefix as the signature. */
206 && i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_READ_BYTE_DATA
)) {
209 name
[0] = i2c_smbus_read_byte_data(client
, 0x80);
210 name
[1] = i2c_smbus_read_byte_data(client
, 0x81);
211 name
[2] = i2c_smbus_read_byte_data(client
, 0x82);
212 name
[3] = i2c_smbus_read_byte_data(client
, 0x83);
214 if (!memcmp(name
, "PCG-", 4) || !memcmp(name
, "VGN-", 4)) {
215 dev_info(&client
->dev
, "Vaio EEPROM detected, "
216 "enabling privacy protection\n");
221 /* create the sysfs eeprom file */
222 err
= sysfs_create_bin_file(&client
->dev
.kobj
, &eeprom_attr
);
229 i2c_detach_client(client
);
236 static int eeprom_detach_client(struct i2c_client
*client
)
240 sysfs_remove_bin_file(&client
->dev
.kobj
, &eeprom_attr
);
242 err
= i2c_detach_client(client
);
246 kfree(i2c_get_clientdata(client
));
251 static int __init
eeprom_init(void)
253 return i2c_add_driver(&eeprom_driver
);
256 static void __exit
eeprom_exit(void)
258 i2c_del_driver(&eeprom_driver
);
262 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
263 "Philip Edelbrock <phil@netroedge.com> and "
264 "Greg Kroah-Hartman <greg@kroah.com>");
265 MODULE_DESCRIPTION("I2C EEPROM driver");
266 MODULE_LICENSE("GPL");
268 module_init(eeprom_init
);
269 module_exit(eeprom_exit
);