2 max6875.c - driver for MAX6874/MAX6875
4 Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
6 Based on i2c/chips/eeprom.c
8 The MAX6875 has a bank of registers and two banks of EEPROM.
9 Address ranges are defined as follows:
10 * 0x0000 - 0x0046 = configuration registers
11 * 0x8000 - 0x8046 = configuration EEPROM
12 * 0x8100 - 0x82FF = user EEPROM
14 This driver makes the user EEPROM available for read.
16 The registers & config EEPROM should be accessed via i2c-dev.
18 The MAX6875 ignores the lowest address bit, so each chip responds to
19 two addresses - 0x50/0x51 and 0x52/0x53.
21 Note that the MAX6875 uses i2c_smbus_write_byte_data() to set the read
22 address, so this driver is destructive if loaded for the wrong EEPROM chip.
24 This program is free software; you can redistribute it and/or modify
25 it under the terms of the GNU General Public License as published by
26 the Free Software Foundation; version 2 of the License.
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/i2c.h>
34 #include <asm/semaphore.h>
36 /* Do not scan - the MAX6875 access method will write to some EEPROM chips */
37 static unsigned short normal_i2c
[] = {I2C_CLIENT_END
};
39 /* Insmod parameters */
40 I2C_CLIENT_INSMOD_1(max6875
);
42 /* The MAX6875 can only read/write 16 bytes at a time */
46 /* USER EEPROM is at addresses 0x8100 - 0x82FF */
47 #define USER_EEPROM_BASE 0x8100
48 #define USER_EEPROM_SIZE 0x0200
49 #define USER_EEPROM_SLICES 32
51 /* MAX6875 commands */
52 #define MAX6875_CMD_BLK_READ 0x84
54 /* Each client has this additional data */
56 struct i2c_client client
;
57 struct semaphore update_lock
;
60 u8 data
[USER_EEPROM_SIZE
];
61 unsigned long last_updated
[USER_EEPROM_SLICES
];
64 static int max6875_attach_adapter(struct i2c_adapter
*adapter
);
65 static int max6875_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
66 static int max6875_detach_client(struct i2c_client
*client
);
68 /* This is the driver that will be inserted */
69 static struct i2c_driver max6875_driver
= {
74 .attach_adapter
= max6875_attach_adapter
,
75 .detach_client
= max6875_detach_client
,
78 static void max6875_update_slice(struct i2c_client
*client
, int slice
)
80 struct max6875_data
*data
= i2c_get_clientdata(client
);
84 if (slice
>= USER_EEPROM_SLICES
)
87 down(&data
->update_lock
);
89 buf
= &data
->data
[slice
<< SLICE_BITS
];
91 if (!(data
->valid
& (1 << slice
)) ||
92 time_after(jiffies
, data
->last_updated
[slice
])) {
94 dev_dbg(&client
->dev
, "Starting update of slice %u\n", slice
);
96 data
->valid
&= ~(1 << slice
);
98 addr
= USER_EEPROM_BASE
+ (slice
<< SLICE_BITS
);
100 /* select the eeprom address */
101 if (i2c_smbus_write_byte_data(client
, addr
>> 8, addr
& 0xFF)) {
102 dev_err(&client
->dev
, "address set failed\n");
106 if (i2c_check_functionality(client
->adapter
,
107 I2C_FUNC_SMBUS_READ_I2C_BLOCK
)) {
108 if (i2c_smbus_read_i2c_block_data(client
,
109 MAX6875_CMD_BLK_READ
,
110 buf
) != SLICE_SIZE
) {
114 for (i
= 0; i
< SLICE_SIZE
; i
++) {
115 j
= i2c_smbus_read_byte(client
);
122 data
->last_updated
[slice
] = jiffies
;
123 data
->valid
|= (1 << slice
);
126 up(&data
->update_lock
);
129 static ssize_t
max6875_read(struct kobject
*kobj
, char *buf
, loff_t off
,
132 struct i2c_client
*client
= kobj_to_i2c_client(kobj
);
133 struct max6875_data
*data
= i2c_get_clientdata(client
);
134 int slice
, max_slice
;
136 if (off
> USER_EEPROM_SIZE
)
139 if (off
+ count
> USER_EEPROM_SIZE
)
140 count
= USER_EEPROM_SIZE
- off
;
142 /* refresh slices which contain requested bytes */
143 max_slice
= (off
+ count
- 1) >> SLICE_BITS
;
144 for (slice
= (off
>> SLICE_BITS
); slice
<= max_slice
; slice
++)
145 max6875_update_slice(client
, slice
);
147 memcpy(buf
, &data
->data
[off
], count
);
152 static struct bin_attribute user_eeprom_attr
= {
156 .owner
= THIS_MODULE
,
158 .size
= USER_EEPROM_SIZE
,
159 .read
= max6875_read
,
162 static int max6875_attach_adapter(struct i2c_adapter
*adapter
)
164 return i2c_probe(adapter
, &addr_data
, max6875_detect
);
167 /* This function is called by i2c_probe */
168 static int max6875_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
170 struct i2c_client
*real_client
;
171 struct i2c_client
*fake_client
;
172 struct max6875_data
*data
;
175 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_WRITE_BYTE_DATA
176 | I2C_FUNC_SMBUS_READ_BYTE
))
179 /* Only check even addresses */
183 if (!(data
= kzalloc(sizeof(struct max6875_data
), GFP_KERNEL
)))
186 /* A fake client is created on the odd address */
187 if (!(fake_client
= kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
))) {
192 /* Init real i2c_client */
193 real_client
= &data
->client
;
194 i2c_set_clientdata(real_client
, data
);
195 real_client
->addr
= address
;
196 real_client
->adapter
= adapter
;
197 real_client
->driver
= &max6875_driver
;
198 real_client
->flags
= 0;
199 strlcpy(real_client
->name
, "max6875", I2C_NAME_SIZE
);
200 init_MUTEX(&data
->update_lock
);
202 /* Init fake client data */
203 /* set the client data to the i2c_client so that it will get freed */
204 i2c_set_clientdata(fake_client
, fake_client
);
205 fake_client
->addr
= address
| 1;
206 fake_client
->adapter
= adapter
;
207 fake_client
->driver
= &max6875_driver
;
208 fake_client
->flags
= 0;
209 strlcpy(fake_client
->name
, "max6875 subclient", I2C_NAME_SIZE
);
211 /* Prevent 24RF08 corruption (in case of user error) */
212 i2c_smbus_write_quick(real_client
, 0);
214 if ((err
= i2c_attach_client(real_client
)) != 0)
217 if ((err
= i2c_attach_client(fake_client
)) != 0)
220 sysfs_create_bin_file(&real_client
->dev
.kobj
, &user_eeprom_attr
);
225 i2c_detach_client(real_client
);
233 static int max6875_detach_client(struct i2c_client
*client
)
237 err
= i2c_detach_client(client
);
240 kfree(i2c_get_clientdata(client
));
244 static int __init
max6875_init(void)
246 return i2c_add_driver(&max6875_driver
);
249 static void __exit
max6875_exit(void)
251 i2c_del_driver(&max6875_driver
);
255 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
256 MODULE_DESCRIPTION("MAX6875 driver");
257 MODULE_LICENSE("GPL");
259 module_init(max6875_init
);
260 module_exit(max6875_exit
);