ARM: 6214/2: driver for the character LCD found in ARM refdesigns
[linux-2.6.git] / drivers / misc / eeprom / max6875.c
1 /*
2  * max6875.c - driver for MAX6874/MAX6875
3  *
4  * Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
5  *
6  * Based on eeprom.c
7  *
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
13  *
14  * This driver makes the user EEPROM available for read.
15  *
16  * The registers & config EEPROM should be accessed via i2c-dev.
17  *
18  * The MAX6875 ignores the lowest address bit, so each chip responds to
19  * two addresses - 0x50/0x51 and 0x52/0x53.
20  *
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.
23  *
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.
27  */
28
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 <linux/mutex.h>
35
36 /* The MAX6875 can only read/write 16 bytes at a time */
37 #define SLICE_SIZE                      16
38 #define SLICE_BITS                      4
39
40 /* USER EEPROM is at addresses 0x8100 - 0x82FF */
41 #define USER_EEPROM_BASE                0x8100
42 #define USER_EEPROM_SIZE                0x0200
43 #define USER_EEPROM_SLICES              32
44
45 /* MAX6875 commands */
46 #define MAX6875_CMD_BLK_READ            0x84
47
48 /* Each client has this additional data */
49 struct max6875_data {
50         struct i2c_client       *fake_client;
51         struct mutex            update_lock;
52
53         u32                     valid;
54         u8                      data[USER_EEPROM_SIZE];
55         unsigned long           last_updated[USER_EEPROM_SLICES];
56 };
57
58 static void max6875_update_slice(struct i2c_client *client, int slice)
59 {
60         struct max6875_data *data = i2c_get_clientdata(client);
61         int i, j, addr;
62         u8 *buf;
63
64         if (slice >= USER_EEPROM_SLICES)
65                 return;
66
67         mutex_lock(&data->update_lock);
68
69         buf = &data->data[slice << SLICE_BITS];
70
71         if (!(data->valid & (1 << slice)) ||
72             time_after(jiffies, data->last_updated[slice])) {
73
74                 dev_dbg(&client->dev, "Starting update of slice %u\n", slice);
75
76                 data->valid &= ~(1 << slice);
77
78                 addr = USER_EEPROM_BASE + (slice << SLICE_BITS);
79
80                 /* select the eeprom address */
81                 if (i2c_smbus_write_byte_data(client, addr >> 8, addr & 0xFF)) {
82                         dev_err(&client->dev, "address set failed\n");
83                         goto exit_up;
84                 }
85
86                 if (i2c_check_functionality(client->adapter,
87                                             I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
88                         if (i2c_smbus_read_i2c_block_data(client,
89                                                           MAX6875_CMD_BLK_READ,
90                                                           SLICE_SIZE,
91                                                           buf) != SLICE_SIZE) {
92                                 goto exit_up;
93                         }
94                 } else {
95                         for (i = 0; i < SLICE_SIZE; i++) {
96                                 j = i2c_smbus_read_byte(client);
97                                 if (j < 0) {
98                                         goto exit_up;
99                                 }
100                                 buf[i] = j;
101                         }
102                 }
103                 data->last_updated[slice] = jiffies;
104                 data->valid |= (1 << slice);
105         }
106 exit_up:
107         mutex_unlock(&data->update_lock);
108 }
109
110 static ssize_t max6875_read(struct file *filp, struct kobject *kobj,
111                             struct bin_attribute *bin_attr,
112                             char *buf, loff_t off, size_t count)
113 {
114         struct i2c_client *client = kobj_to_i2c_client(kobj);
115         struct max6875_data *data = i2c_get_clientdata(client);
116         int slice, max_slice;
117
118         if (off > USER_EEPROM_SIZE)
119                 return 0;
120
121         if (off + count > USER_EEPROM_SIZE)
122                 count = USER_EEPROM_SIZE - off;
123
124         /* refresh slices which contain requested bytes */
125         max_slice = (off + count - 1) >> SLICE_BITS;
126         for (slice = (off >> SLICE_BITS); slice <= max_slice; slice++)
127                 max6875_update_slice(client, slice);
128
129         memcpy(buf, &data->data[off], count);
130
131         return count;
132 }
133
134 static struct bin_attribute user_eeprom_attr = {
135         .attr = {
136                 .name = "eeprom",
137                 .mode = S_IRUGO,
138         },
139         .size = USER_EEPROM_SIZE,
140         .read = max6875_read,
141 };
142
143 static int max6875_probe(struct i2c_client *client,
144                          const struct i2c_device_id *id)
145 {
146         struct i2c_adapter *adapter = client->adapter;
147         struct max6875_data *data;
148         int err;
149
150         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA
151                                      | I2C_FUNC_SMBUS_READ_BYTE))
152                 return -ENODEV;
153
154         /* Only bind to even addresses */
155         if (client->addr & 1)
156                 return -ENODEV;
157
158         if (!(data = kzalloc(sizeof(struct max6875_data), GFP_KERNEL)))
159                 return -ENOMEM;
160
161         /* A fake client is created on the odd address */
162         data->fake_client = i2c_new_dummy(client->adapter, client->addr + 1);
163         if (!data->fake_client) {
164                 err = -ENOMEM;
165                 goto exit_kfree;
166         }
167
168         /* Init real i2c_client */
169         i2c_set_clientdata(client, data);
170         mutex_init(&data->update_lock);
171
172         err = sysfs_create_bin_file(&client->dev.kobj, &user_eeprom_attr);
173         if (err)
174                 goto exit_remove_fake;
175
176         return 0;
177
178 exit_remove_fake:
179         i2c_unregister_device(data->fake_client);
180 exit_kfree:
181         kfree(data);
182         return err;
183 }
184
185 static int max6875_remove(struct i2c_client *client)
186 {
187         struct max6875_data *data = i2c_get_clientdata(client);
188
189         i2c_unregister_device(data->fake_client);
190
191         sysfs_remove_bin_file(&client->dev.kobj, &user_eeprom_attr);
192         kfree(data);
193
194         return 0;
195 }
196
197 static const struct i2c_device_id max6875_id[] = {
198         { "max6875", 0 },
199         { }
200 };
201
202 static struct i2c_driver max6875_driver = {
203         .driver = {
204                 .name   = "max6875",
205         },
206         .probe          = max6875_probe,
207         .remove         = max6875_remove,
208         .id_table       = max6875_id,
209 };
210
211 static int __init max6875_init(void)
212 {
213         return i2c_add_driver(&max6875_driver);
214 }
215
216 static void __exit max6875_exit(void)
217 {
218         i2c_del_driver(&max6875_driver);
219 }
220
221
222 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
223 MODULE_DESCRIPTION("MAX6875 driver");
224 MODULE_LICENSE("GPL");
225
226 module_init(max6875_init);
227 module_exit(max6875_exit);