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 /* Do not scan - the MAX6875 access method will write to some EEPROM chips */ 37 static const unsigned short normal_i2c[] = { I2C_CLIENT_END }; 38 39 /* Insmod parameters */ 40 I2C_CLIENT_INSMOD_1(max6875); 41 42 /* The MAX6875 can only read/write 16 bytes at a time */ 43 #define SLICE_SIZE 16 44 #define SLICE_BITS 4 45 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 50 51 /* MAX6875 commands */ 52 #define MAX6875_CMD_BLK_READ 0x84 53 54 /* Each client has this additional data */ 55 struct max6875_data { 56 struct i2c_client *fake_client; 57 struct mutex update_lock; 58 59 u32 valid; 60 u8 data[USER_EEPROM_SIZE]; 61 unsigned long last_updated[USER_EEPROM_SLICES]; 62 }; 63 64 static void max6875_update_slice(struct i2c_client *client, int slice) 65 { 66 struct max6875_data *data = i2c_get_clientdata(client); 67 int i, j, addr; 68 u8 *buf; 69 70 if (slice >= USER_EEPROM_SLICES) 71 return; 72 73 mutex_lock(&data->update_lock); 74 75 buf = &data->data[slice << SLICE_BITS]; 76 77 if (!(data->valid & (1 << slice)) || 78 time_after(jiffies, data->last_updated[slice])) { 79 80 dev_dbg(&client->dev, "Starting update of slice %u\n", slice); 81 82 data->valid &= ~(1 << slice); 83 84 addr = USER_EEPROM_BASE + (slice << SLICE_BITS); 85 86 /* select the eeprom address */ 87 if (i2c_smbus_write_byte_data(client, addr >> 8, addr & 0xFF)) { 88 dev_err(&client->dev, "address set failed\n"); 89 goto exit_up; 90 } 91 92 if (i2c_check_functionality(client->adapter, 93 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 94 if (i2c_smbus_read_i2c_block_data(client, 95 MAX6875_CMD_BLK_READ, 96 SLICE_SIZE, 97 buf) != SLICE_SIZE) { 98 goto exit_up; 99 } 100 } else { 101 for (i = 0; i < SLICE_SIZE; i++) { 102 j = i2c_smbus_read_byte(client); 103 if (j < 0) { 104 goto exit_up; 105 } 106 buf[i] = j; 107 } 108 } 109 data->last_updated[slice] = jiffies; 110 data->valid |= (1 << slice); 111 } 112 exit_up: 113 mutex_unlock(&data->update_lock); 114 } 115 116 static ssize_t max6875_read(struct kobject *kobj, 117 struct bin_attribute *bin_attr, 118 char *buf, loff_t off, size_t count) 119 { 120 struct i2c_client *client = kobj_to_i2c_client(kobj); 121 struct max6875_data *data = i2c_get_clientdata(client); 122 int slice, max_slice; 123 124 if (off > USER_EEPROM_SIZE) 125 return 0; 126 127 if (off + count > USER_EEPROM_SIZE) 128 count = USER_EEPROM_SIZE - off; 129 130 /* refresh slices which contain requested bytes */ 131 max_slice = (off + count - 1) >> SLICE_BITS; 132 for (slice = (off >> SLICE_BITS); slice <= max_slice; slice++) 133 max6875_update_slice(client, slice); 134 135 memcpy(buf, &data->data[off], count); 136 137 return count; 138 } 139 140 static struct bin_attribute user_eeprom_attr = { 141 .attr = { 142 .name = "eeprom", 143 .mode = S_IRUGO, 144 }, 145 .size = USER_EEPROM_SIZE, 146 .read = max6875_read, 147 }; 148 149 /* Return 0 if detection is successful, -ENODEV otherwise */ 150 static int max6875_detect(struct i2c_client *client, int kind, 151 struct i2c_board_info *info) 152 { 153 struct i2c_adapter *adapter = client->adapter; 154 155 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA 156 | I2C_FUNC_SMBUS_READ_BYTE)) 157 return -ENODEV; 158 159 /* Only check even addresses */ 160 if (client->addr & 1) 161 return -ENODEV; 162 163 strlcpy(info->type, "max6875", I2C_NAME_SIZE); 164 165 return 0; 166 } 167 168 static int max6875_probe(struct i2c_client *client, 169 const struct i2c_device_id *id) 170 { 171 struct max6875_data *data; 172 int err; 173 174 if (!(data = kzalloc(sizeof(struct max6875_data), GFP_KERNEL))) 175 return -ENOMEM; 176 177 /* A fake client is created on the odd address */ 178 data->fake_client = i2c_new_dummy(client->adapter, client->addr + 1); 179 if (!data->fake_client) { 180 err = -ENOMEM; 181 goto exit_kfree; 182 } 183 184 /* Init real i2c_client */ 185 i2c_set_clientdata(client, data); 186 mutex_init(&data->update_lock); 187 188 err = sysfs_create_bin_file(&client->dev.kobj, &user_eeprom_attr); 189 if (err) 190 goto exit_remove_fake; 191 192 return 0; 193 194 exit_remove_fake: 195 i2c_unregister_device(data->fake_client); 196 exit_kfree: 197 kfree(data); 198 return err; 199 } 200 201 static int max6875_remove(struct i2c_client *client) 202 { 203 struct max6875_data *data = i2c_get_clientdata(client); 204 205 i2c_unregister_device(data->fake_client); 206 207 sysfs_remove_bin_file(&client->dev.kobj, &user_eeprom_attr); 208 kfree(data); 209 210 return 0; 211 } 212 213 static const struct i2c_device_id max6875_id[] = { 214 { "max6875", 0 }, 215 { } 216 }; 217 218 static struct i2c_driver max6875_driver = { 219 .driver = { 220 .name = "max6875", 221 }, 222 .probe = max6875_probe, 223 .remove = max6875_remove, 224 .id_table = max6875_id, 225 226 .detect = max6875_detect, 227 .address_data = &addr_data, 228 }; 229 230 static int __init max6875_init(void) 231 { 232 return i2c_add_driver(&max6875_driver); 233 } 234 235 static void __exit max6875_exit(void) 236 { 237 i2c_del_driver(&max6875_driver); 238 } 239 240 241 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>"); 242 MODULE_DESCRIPTION("MAX6875 driver"); 243 MODULE_LICENSE("GPL"); 244 245 module_init(max6875_init); 246 module_exit(max6875_exit); 247