Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
max6875.c
Go to the documentation of this file.
1 /*
2  * max6875.c - driver for MAX6874/MAX6875
3  *
4  * Copyright (C) 2005 Ben Gardner <[email protected]>
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 {
52 
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,
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
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:
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 
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 module_i2c_driver(max6875_driver);
212 
213 MODULE_AUTHOR("Ben Gardner <[email protected]>");
214 MODULE_DESCRIPTION("MAX6875 driver");
215 MODULE_LICENSE("GPL");