Blame view
drivers/i2c/i2c-core.c
58.2 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/* i2c-core.c - a device driver for the iic-bus interface */ /* ------------------------------------------------------------------------- */ /* Copyright (C) 1995-99 Simon G. Vogl This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* ------------------------------------------------------------------------- */ |
96de0e252 Convert files to ... |
19 |
/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>. |
1da177e4c Linux-2.6.12-rc2 |
20 |
All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl> |
421ef47be [PATCH] i2c: SMBu... |
21 |
SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and |
0826374bf i2c: Multiplexed ... |
22 23 24 |
Jean Delvare <khali@linux-fr.org> Mux support by Rodolfo Giometti <giometti@enneenne.com> and Michael Lawnick <michael.lawnick.ext@nsn.com> */ |
1da177e4c Linux-2.6.12-rc2 |
25 |
|
1da177e4c Linux-2.6.12-rc2 |
26 27 28 29 30 31 32 |
#include <linux/module.h> #include <linux/kernel.h> #include <linux/errno.h> #include <linux/slab.h> #include <linux/i2c.h> #include <linux/init.h> #include <linux/idr.h> |
b3585e4f5 [PATCH] I2C: Conv... |
33 |
#include <linux/mutex.h> |
959e85f77 i2c: Add OF-style... |
34 |
#include <linux/of_device.h> |
b8d6f45b3 i2c: completion h... |
35 |
#include <linux/completion.h> |
cea443a81 i2c: Support i2c_... |
36 37 |
#include <linux/hardirq.h> #include <linux/irqflags.h> |
f18c41dae i2c: Use rwsem in... |
38 |
#include <linux/rwsem.h> |
6de468ae2 i2c: Hook up runt... |
39 |
#include <linux/pm_runtime.h> |
1da177e4c Linux-2.6.12-rc2 |
40 |
#include <asm/uaccess.h> |
9c1600eda i2c: Add i2c_boar... |
41 |
#include "i2c-core.h" |
1da177e4c Linux-2.6.12-rc2 |
42 |
|
6629dcff1 i2c-core: Use per... |
43 |
/* core_lock protects i2c_adapter_idr, and guarantees |
35fc37f81 i2c: Limit core l... |
44 45 |
that device detection, deletion of detected devices, and attach_adapter and detach_adapter calls are serialized */ |
caada32af i2c: Rename main ... |
46 |
static DEFINE_MUTEX(core_lock); |
1da177e4c Linux-2.6.12-rc2 |
47 |
static DEFINE_IDR(i2c_adapter_idr); |
4f8cf8240 i2c: Convert i2c ... |
48 |
static struct device_type i2c_client_type; |
4735c98f8 i2c: Add detectio... |
49 |
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver); |
f37dd80ac i2c: Add driver s... |
50 51 |
/* ------------------------------------------------------------------------- */ |
d2653e927 i2c: Add support ... |
52 53 54 55 56 57 58 59 60 61 |
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id, const struct i2c_client *client) { while (id->name[0]) { if (strcmp(client->name, id->name) == 0) return id; id++; } return NULL; } |
1da177e4c Linux-2.6.12-rc2 |
62 63 |
static int i2c_device_match(struct device *dev, struct device_driver *drv) { |
51298d125 i2c: Convert i2c ... |
64 65 66 67 68 |
struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; if (!client) return 0; |
7b4fbc50f i2c: i2c stack ca... |
69 |
|
959e85f77 i2c: Add OF-style... |
70 71 72 |
/* Attempt an OF style match */ if (of_driver_match_device(dev, drv)) return 1; |
51298d125 i2c: Convert i2c ... |
73 |
driver = to_i2c_driver(drv); |
d2653e927 i2c: Add support ... |
74 75 76 |
/* match on an id table if there is one */ if (driver->id_table) return i2c_match_id(driver->id_table, client) != NULL; |
eb8a79080 i2c: Kill the old... |
77 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
78 |
} |
7b4fbc50f i2c: i2c stack ca... |
79 80 81 |
#ifdef CONFIG_HOTPLUG /* uevent helps with hotplug: modprobe -q $(MODALIAS) */ |
7eff2e7a8 Driver core: chan... |
82 |
static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env) |
7b4fbc50f i2c: i2c stack ca... |
83 84 |
{ struct i2c_client *client = to_i2c_client(dev); |
7b4fbc50f i2c: i2c stack ca... |
85 |
|
eb8a79080 i2c: Kill the old... |
86 87 88 |
if (add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name)) return -ENOMEM; |
7b4fbc50f i2c: i2c stack ca... |
89 90 91 92 93 94 95 96 |
dev_dbg(dev, "uevent "); return 0; } #else #define i2c_device_uevent NULL #endif /* CONFIG_HOTPLUG */ |
f37dd80ac i2c: Add driver s... |
97 |
static int i2c_device_probe(struct device *dev) |
1da177e4c Linux-2.6.12-rc2 |
98 |
{ |
51298d125 i2c: Convert i2c ... |
99 100 |
struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; |
50c3304a5 i2c: Keep client-... |
101 |
int status; |
7b4fbc50f i2c: i2c stack ca... |
102 |
|
51298d125 i2c: Convert i2c ... |
103 104 105 106 |
if (!client) return 0; driver = to_i2c_driver(dev->driver); |
e0457442f i2c: Simplify i2c... |
107 |
if (!driver->probe || !driver->id_table) |
7b4fbc50f i2c: i2c stack ca... |
108 109 |
return -ENODEV; client->driver = driver; |
ee35425c8 i2c: Fix device_i... |
110 111 112 |
if (!device_can_wakeup(&client->dev)) device_init_wakeup(&client->dev, client->flags & I2C_CLIENT_WAKE); |
7b4fbc50f i2c: i2c stack ca... |
113 114 |
dev_dbg(dev, "probe "); |
d2653e927 i2c: Add support ... |
115 |
|
e0457442f i2c: Simplify i2c... |
116 |
status = driver->probe(client, i2c_match_id(driver->id_table, client)); |
e4a7b9b04 i2c-core: Erase p... |
117 |
if (status) { |
50c3304a5 i2c: Keep client-... |
118 |
client->driver = NULL; |
e4a7b9b04 i2c-core: Erase p... |
119 120 |
i2c_set_clientdata(client, NULL); } |
50c3304a5 i2c: Keep client-... |
121 |
return status; |
f37dd80ac i2c: Add driver s... |
122 |
} |
1da177e4c Linux-2.6.12-rc2 |
123 |
|
f37dd80ac i2c: Add driver s... |
124 125 |
static int i2c_device_remove(struct device *dev) { |
51298d125 i2c: Convert i2c ... |
126 |
struct i2c_client *client = i2c_verify_client(dev); |
a1d9e6e49 i2c: i2c stack ca... |
127 128 |
struct i2c_driver *driver; int status; |
51298d125 i2c: Convert i2c ... |
129 |
if (!client || !dev->driver) |
a1d9e6e49 i2c: i2c stack ca... |
130 131 132 133 134 135 136 137 138 139 140 |
return 0; driver = to_i2c_driver(dev->driver); if (driver->remove) { dev_dbg(dev, "remove "); status = driver->remove(client); } else { dev->driver = NULL; status = 0; } |
e4a7b9b04 i2c-core: Erase p... |
141 |
if (status == 0) { |
a1d9e6e49 i2c: i2c stack ca... |
142 |
client->driver = NULL; |
e4a7b9b04 i2c-core: Erase p... |
143 144 |
i2c_set_clientdata(client, NULL); } |
a1d9e6e49 i2c: i2c stack ca... |
145 |
return status; |
1da177e4c Linux-2.6.12-rc2 |
146 |
} |
f37dd80ac i2c: Add driver s... |
147 |
static void i2c_device_shutdown(struct device *dev) |
1da177e4c Linux-2.6.12-rc2 |
148 |
{ |
51298d125 i2c: Convert i2c ... |
149 |
struct i2c_client *client = i2c_verify_client(dev); |
f37dd80ac i2c: Add driver s... |
150 |
struct i2c_driver *driver; |
51298d125 i2c: Convert i2c ... |
151 |
if (!client || !dev->driver) |
f37dd80ac i2c: Add driver s... |
152 153 154 |
return; driver = to_i2c_driver(dev->driver); if (driver->shutdown) |
51298d125 i2c: Convert i2c ... |
155 |
driver->shutdown(client); |
1da177e4c Linux-2.6.12-rc2 |
156 |
} |
2f60ba706 i2c: Fix bus-leve... |
157 158 |
#ifdef CONFIG_PM_SLEEP static int i2c_legacy_suspend(struct device *dev, pm_message_t mesg) |
54067ee20 i2c-core: i2c bus... |
159 |
{ |
2f60ba706 i2c: Fix bus-leve... |
160 161 |
struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; |
54067ee20 i2c-core: i2c bus... |
162 |
|
2f60ba706 i2c: Fix bus-leve... |
163 |
if (!client || !dev->driver) |
54067ee20 i2c-core: i2c bus... |
164 |
return 0; |
2f60ba706 i2c: Fix bus-leve... |
165 166 |
driver = to_i2c_driver(dev->driver); if (!driver->suspend) |
54067ee20 i2c-core: i2c bus... |
167 |
return 0; |
2f60ba706 i2c: Fix bus-leve... |
168 |
return driver->suspend(client, mesg); |
54067ee20 i2c-core: i2c bus... |
169 |
} |
2f60ba706 i2c: Fix bus-leve... |
170 |
static int i2c_legacy_resume(struct device *dev) |
54067ee20 i2c-core: i2c bus... |
171 |
{ |
2f60ba706 i2c: Fix bus-leve... |
172 173 |
struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; |
54067ee20 i2c-core: i2c bus... |
174 |
|
2f60ba706 i2c: Fix bus-leve... |
175 |
if (!client || !dev->driver) |
54067ee20 i2c-core: i2c bus... |
176 |
return 0; |
2f60ba706 i2c: Fix bus-leve... |
177 178 |
driver = to_i2c_driver(dev->driver); if (!driver->resume) |
54067ee20 i2c-core: i2c bus... |
179 |
return 0; |
2f60ba706 i2c: Fix bus-leve... |
180 |
return driver->resume(client); |
54067ee20 i2c-core: i2c bus... |
181 |
} |
54067ee20 i2c-core: i2c bus... |
182 |
|
2f60ba706 i2c: Fix bus-leve... |
183 |
static int i2c_device_pm_suspend(struct device *dev) |
6de468ae2 i2c: Hook up runt... |
184 |
{ |
2f60ba706 i2c: Fix bus-leve... |
185 |
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
6de468ae2 i2c: Hook up runt... |
186 |
|
d529de299 i2c: Factor out r... |
187 188 189 190 |
if (pm) return pm_generic_suspend(dev); else return i2c_legacy_suspend(dev, PMSG_SUSPEND); |
6de468ae2 i2c: Hook up runt... |
191 |
} |
2f60ba706 i2c: Fix bus-leve... |
192 |
static int i2c_device_pm_resume(struct device *dev) |
6de468ae2 i2c: Hook up runt... |
193 |
{ |
2f60ba706 i2c: Fix bus-leve... |
194 |
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
6de468ae2 i2c: Hook up runt... |
195 |
|
2f60ba706 i2c: Fix bus-leve... |
196 |
if (pm) |
d529de299 i2c: Factor out r... |
197 |
return pm_generic_resume(dev); |
2f60ba706 i2c: Fix bus-leve... |
198 |
else |
d529de299 i2c: Factor out r... |
199 |
return i2c_legacy_resume(dev); |
6de468ae2 i2c: Hook up runt... |
200 |
} |
6de468ae2 i2c: Hook up runt... |
201 |
|
2f60ba706 i2c: Fix bus-leve... |
202 |
static int i2c_device_pm_freeze(struct device *dev) |
1da177e4c Linux-2.6.12-rc2 |
203 |
{ |
2f60ba706 i2c: Fix bus-leve... |
204 |
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
f37dd80ac i2c: Add driver s... |
205 |
|
d529de299 i2c: Factor out r... |
206 207 208 209 |
if (pm) return pm_generic_freeze(dev); else return i2c_legacy_suspend(dev, PMSG_FREEZE); |
1da177e4c Linux-2.6.12-rc2 |
210 |
} |
2f60ba706 i2c: Fix bus-leve... |
211 |
static int i2c_device_pm_thaw(struct device *dev) |
1da177e4c Linux-2.6.12-rc2 |
212 |
{ |
2f60ba706 i2c: Fix bus-leve... |
213 |
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
f37dd80ac i2c: Add driver s... |
214 |
|
d529de299 i2c: Factor out r... |
215 216 217 218 |
if (pm) return pm_generic_thaw(dev); else return i2c_legacy_resume(dev); |
2f60ba706 i2c: Fix bus-leve... |
219 220 221 222 223 |
} static int i2c_device_pm_poweroff(struct device *dev) { const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
d529de299 i2c: Factor out r... |
224 225 226 227 |
if (pm) return pm_generic_poweroff(dev); else return i2c_legacy_suspend(dev, PMSG_HIBERNATE); |
2f60ba706 i2c: Fix bus-leve... |
228 229 230 231 232 |
} static int i2c_device_pm_restore(struct device *dev) { const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
2f60ba706 i2c: Fix bus-leve... |
233 234 |
if (pm) |
d529de299 i2c: Factor out r... |
235 |
return pm_generic_restore(dev); |
2f60ba706 i2c: Fix bus-leve... |
236 |
else |
d529de299 i2c: Factor out r... |
237 |
return i2c_legacy_resume(dev); |
1da177e4c Linux-2.6.12-rc2 |
238 |
} |
2f60ba706 i2c: Fix bus-leve... |
239 240 241 242 243 244 245 246 |
#else /* !CONFIG_PM_SLEEP */ #define i2c_device_pm_suspend NULL #define i2c_device_pm_resume NULL #define i2c_device_pm_freeze NULL #define i2c_device_pm_thaw NULL #define i2c_device_pm_poweroff NULL #define i2c_device_pm_restore NULL #endif /* !CONFIG_PM_SLEEP */ |
1da177e4c Linux-2.6.12-rc2 |
247 |
|
9c1600eda i2c: Add i2c_boar... |
248 249 250 251 |
static void i2c_client_dev_release(struct device *dev) { kfree(to_i2c_client(dev)); } |
09b8ce0a6 i2c-core: Some st... |
252 |
static ssize_t |
4f8cf8240 i2c: Convert i2c ... |
253 |
show_name(struct device *dev, struct device_attribute *attr, char *buf) |
7b4fbc50f i2c: i2c stack ca... |
254 |
{ |
4f8cf8240 i2c: Convert i2c ... |
255 256 257 |
return sprintf(buf, "%s ", dev->type == &i2c_client_type ? to_i2c_client(dev)->name : to_i2c_adapter(dev)->name); |
7b4fbc50f i2c: i2c stack ca... |
258 |
} |
09b8ce0a6 i2c-core: Some st... |
259 260 |
static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf) |
7b4fbc50f i2c: i2c stack ca... |
261 262 |
{ struct i2c_client *client = to_i2c_client(dev); |
eb8a79080 i2c: Kill the old... |
263 264 |
return sprintf(buf, "%s%s ", I2C_MODULE_PREFIX, client->name); |
7b4fbc50f i2c: i2c stack ca... |
265 |
} |
4f8cf8240 i2c: Convert i2c ... |
266 |
static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); |
51298d125 i2c: Convert i2c ... |
267 268 269 270 |
static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL); static struct attribute *i2c_dev_attrs[] = { &dev_attr_name.attr, |
7b4fbc50f i2c: i2c stack ca... |
271 |
/* modalias helps coldplug: modprobe $(cat .../modalias) */ |
51298d125 i2c: Convert i2c ... |
272 273 274 275 276 277 278 279 280 281 282 |
&dev_attr_modalias.attr, NULL }; static struct attribute_group i2c_dev_attr_group = { .attrs = i2c_dev_attrs, }; static const struct attribute_group *i2c_dev_attr_groups[] = { &i2c_dev_attr_group, NULL |
7b4fbc50f i2c: i2c stack ca... |
283 |
}; |
0b2c36884 i2c-core: Storage... |
284 |
static const struct dev_pm_ops i2c_device_pm_ops = { |
54067ee20 i2c-core: i2c bus... |
285 286 |
.suspend = i2c_device_pm_suspend, .resume = i2c_device_pm_resume, |
2f60ba706 i2c: Fix bus-leve... |
287 288 289 290 291 292 293 294 295 |
.freeze = i2c_device_pm_freeze, .thaw = i2c_device_pm_thaw, .poweroff = i2c_device_pm_poweroff, .restore = i2c_device_pm_restore, SET_RUNTIME_PM_OPS( pm_generic_runtime_suspend, pm_generic_runtime_resume, pm_generic_runtime_idle ) |
54067ee20 i2c-core: i2c bus... |
296 |
}; |
e9ca9eb9d i2c: Export the i... |
297 |
struct bus_type i2c_bus_type = { |
f37dd80ac i2c: Add driver s... |
298 299 300 301 302 |
.name = "i2c", .match = i2c_device_match, .probe = i2c_device_probe, .remove = i2c_device_remove, .shutdown = i2c_device_shutdown, |
54067ee20 i2c-core: i2c bus... |
303 |
.pm = &i2c_device_pm_ops, |
b864c7d5d [PATCH] Add i2c_b... |
304 |
}; |
e9ca9eb9d i2c: Export the i... |
305 |
EXPORT_SYMBOL_GPL(i2c_bus_type); |
b864c7d5d [PATCH] Add i2c_b... |
306 |
|
51298d125 i2c: Convert i2c ... |
307 308 309 310 311 |
static struct device_type i2c_client_type = { .groups = i2c_dev_attr_groups, .uevent = i2c_device_uevent, .release = i2c_client_dev_release, }; |
9b766b814 i2c: Stop using t... |
312 313 314 315 316 317 318 319 320 321 322 323 |
/** * i2c_verify_client - return parameter as i2c_client, or NULL * @dev: device, probably from some driver model iterator * * When traversing the driver model tree, perhaps using driver model * iterators like @device_for_each_child(), you can't assume very much * about the nodes you find. Use this function to avoid oopses caused * by wrongly treating some non-I2C device as an i2c_client. */ struct i2c_client *i2c_verify_client(struct device *dev) { |
51298d125 i2c: Convert i2c ... |
324 |
return (dev->type == &i2c_client_type) |
9b766b814 i2c: Stop using t... |
325 326 327 328 |
? to_i2c_client(dev) : NULL; } EXPORT_SYMBOL(i2c_verify_client); |
3a89db5f3 i2c: Check for ad... |
329 |
/* This is a permissive address validity check, I2C address map constraints |
25985edce Fix common misspe... |
330 |
* are purposely not enforced, except for the general call address. */ |
3a89db5f3 i2c: Check for ad... |
331 332 333 334 335 336 337 338 339 340 341 342 343 |
static int i2c_check_client_addr_validity(const struct i2c_client *client) { if (client->flags & I2C_CLIENT_TEN) { /* 10-bit address, all values are valid */ if (client->addr > 0x3ff) return -EINVAL; } else { /* 7-bit address, reject the general call address */ if (client->addr == 0x00 || client->addr > 0x7f) return -EINVAL; } return 0; } |
656b8761a i2c: Document res... |
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 |
/* And this is a strict address validity check, used when probing. If a * device uses a reserved address, then it shouldn't be probed. 7-bit * addressing is assumed, 10-bit address devices are rare and should be * explicitly enumerated. */ static int i2c_check_addr_validity(unsigned short addr) { /* * Reserved addresses per I2C specification: * 0x00 General call address / START byte * 0x01 CBUS address * 0x02 Reserved for different bus format * 0x03 Reserved for future purposes * 0x04-0x07 Hs-mode master code * 0x78-0x7b 10-bit slave addressing * 0x7c-0x7f Reserved for future purposes */ if (addr < 0x08 || addr > 0x77) return -EINVAL; return 0; } |
3b5f794b8 i2c: Rename i2c_c... |
364 365 366 367 368 369 370 371 372 |
static int __i2c_check_addr_busy(struct device *dev, void *addrp) { struct i2c_client *client = i2c_verify_client(dev); int addr = *(int *)addrp; if (client && client->addr == addr) return -EBUSY; return 0; } |
0826374bf i2c: Multiplexed ... |
373 374 375 |
/* walk up mux tree */ static int i2c_check_mux_parents(struct i2c_adapter *adapter, int addr) { |
97cc4d49c i2c: Let i2c_pare... |
376 |
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); |
0826374bf i2c: Multiplexed ... |
377 378 379 380 |
int result; result = device_for_each_child(&adapter->dev, &addr, __i2c_check_addr_busy); |
97cc4d49c i2c: Let i2c_pare... |
381 382 |
if (!result && parent) result = i2c_check_mux_parents(parent, addr); |
0826374bf i2c: Multiplexed ... |
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 |
return result; } /* recurse down mux tree */ static int i2c_check_mux_children(struct device *dev, void *addrp) { int result; if (dev->type == &i2c_adapter_type) result = device_for_each_child(dev, addrp, i2c_check_mux_children); else result = __i2c_check_addr_busy(dev, addrp); return result; } |
3b5f794b8 i2c: Rename i2c_c... |
400 401 |
static int i2c_check_addr_busy(struct i2c_adapter *adapter, int addr) { |
97cc4d49c i2c: Let i2c_pare... |
402 |
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); |
0826374bf i2c: Multiplexed ... |
403 |
int result = 0; |
97cc4d49c i2c: Let i2c_pare... |
404 405 |
if (parent) result = i2c_check_mux_parents(parent, addr); |
0826374bf i2c: Multiplexed ... |
406 407 408 409 410 411 |
if (!result) result = device_for_each_child(&adapter->dev, &addr, i2c_check_mux_children); return result; |
3b5f794b8 i2c: Rename i2c_c... |
412 |
} |
9c1600eda i2c: Add i2c_boar... |
413 |
/** |
fe61e07e9 i2c: Move adapter... |
414 415 416 417 418 |
* i2c_lock_adapter - Get exclusive access to an I2C bus segment * @adapter: Target I2C bus segment */ void i2c_lock_adapter(struct i2c_adapter *adapter) { |
97cc4d49c i2c: Let i2c_pare... |
419 420 421 422 |
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); if (parent) i2c_lock_adapter(parent); |
0826374bf i2c: Multiplexed ... |
423 424 |
else rt_mutex_lock(&adapter->bus_lock); |
fe61e07e9 i2c: Move adapter... |
425 426 427 428 429 430 431 432 433 |
} EXPORT_SYMBOL_GPL(i2c_lock_adapter); /** * i2c_trylock_adapter - Try to get exclusive access to an I2C bus segment * @adapter: Target I2C bus segment */ static int i2c_trylock_adapter(struct i2c_adapter *adapter) { |
97cc4d49c i2c: Let i2c_pare... |
434 435 436 437 |
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); if (parent) return i2c_trylock_adapter(parent); |
0826374bf i2c: Multiplexed ... |
438 439 |
else return rt_mutex_trylock(&adapter->bus_lock); |
fe61e07e9 i2c: Move adapter... |
440 441 442 443 444 445 446 447 |
} /** * i2c_unlock_adapter - Release exclusive access to an I2C bus segment * @adapter: Target I2C bus segment */ void i2c_unlock_adapter(struct i2c_adapter *adapter) { |
97cc4d49c i2c: Let i2c_pare... |
448 449 450 451 |
struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); if (parent) i2c_unlock_adapter(parent); |
0826374bf i2c: Multiplexed ... |
452 453 |
else rt_mutex_unlock(&adapter->bus_lock); |
fe61e07e9 i2c: Move adapter... |
454 455 456 457 |
} EXPORT_SYMBOL_GPL(i2c_unlock_adapter); /** |
f8a227e8a i2c: Merge i2c_at... |
458 |
* i2c_new_device - instantiate an i2c device |
9c1600eda i2c: Add i2c_boar... |
459 460 |
* @adap: the adapter managing the device * @info: describes one I2C device; bus_num is ignored |
d64f73be1 i2c: Add kernel d... |
461 |
* Context: can sleep |
9c1600eda i2c: Add i2c_boar... |
462 |
* |
f8a227e8a i2c: Merge i2c_at... |
463 464 465 466 467 468 |
* Create an i2c device. Binding is handled through driver model * probe()/remove() methods. A driver may be bound to this device when we * return from this function, or any later moment (e.g. maybe hotplugging will * load the driver module). This call is not appropriate for use by mainboard * initialization logic, which usually runs during an arch_initcall() long * before any i2c_adapter could exist. |
9c1600eda i2c: Add i2c_boar... |
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 |
* * This returns the new i2c client, which may be saved for later use with * i2c_unregister_device(); or NULL to indicate an error. */ struct i2c_client * i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info) { struct i2c_client *client; int status; client = kzalloc(sizeof *client, GFP_KERNEL); if (!client) return NULL; client->adapter = adap; client->dev.platform_data = info->platform_data; |
3bbb835d4 i2c: New-style de... |
486 |
|
11f1f2afd i2c: Add info->ar... |
487 488 |
if (info->archdata) client->dev.archdata = *info->archdata; |
ee35425c8 i2c: Fix device_i... |
489 |
client->flags = info->flags; |
9c1600eda i2c: Add i2c_boar... |
490 491 |
client->addr = info->addr; client->irq = info->irq; |
9c1600eda i2c: Add i2c_boar... |
492 |
strlcpy(client->name, info->type, sizeof(client->name)); |
3a89db5f3 i2c: Check for ad... |
493 494 495 496 497 498 499 500 |
/* Check for address validity */ status = i2c_check_client_addr_validity(client); if (status) { dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx ", client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr); goto out_err_silent; } |
f8a227e8a i2c: Merge i2c_at... |
501 |
/* Check for address business */ |
3b5f794b8 i2c: Rename i2c_c... |
502 |
status = i2c_check_addr_busy(adap, client->addr); |
f8a227e8a i2c: Merge i2c_at... |
503 504 505 506 507 |
if (status) goto out_err; client->dev.parent = &client->adapter->dev; client->dev.bus = &i2c_bus_type; |
51298d125 i2c: Convert i2c ... |
508 |
client->dev.type = &i2c_client_type; |
d12d42f74 i2c/of: Allow dev... |
509 |
client->dev.of_node = info->of_node; |
f8a227e8a i2c: Merge i2c_at... |
510 |
|
cbb445140 i2c: Fix device n... |
511 |
/* For 10-bit clients, add an arbitrary offset to avoid collisions */ |
f8a227e8a i2c: Merge i2c_at... |
512 |
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap), |
cbb445140 i2c: Fix device n... |
513 514 |
client->addr | ((client->flags & I2C_CLIENT_TEN) ? 0xa000 : 0)); |
f8a227e8a i2c: Merge i2c_at... |
515 516 517 |
status = device_register(&client->dev); if (status) goto out_err; |
f8a227e8a i2c: Merge i2c_at... |
518 519 520 |
dev_dbg(&adap->dev, "client [%s] registered with bus id %s ", client->name, dev_name(&client->dev)); |
9c1600eda i2c: Add i2c_boar... |
521 |
return client; |
f8a227e8a i2c: Merge i2c_at... |
522 523 524 525 526 |
out_err: dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x " "(%d) ", client->name, client->addr, status); |
3a89db5f3 i2c: Check for ad... |
527 |
out_err_silent: |
f8a227e8a i2c: Merge i2c_at... |
528 529 |
kfree(client); return NULL; |
9c1600eda i2c: Add i2c_boar... |
530 531 532 533 534 535 536 |
} EXPORT_SYMBOL_GPL(i2c_new_device); /** * i2c_unregister_device - reverse effect of i2c_new_device() * @client: value returned from i2c_new_device() |
d64f73be1 i2c: Add kernel d... |
537 |
* Context: can sleep |
9c1600eda i2c: Add i2c_boar... |
538 539 |
*/ void i2c_unregister_device(struct i2c_client *client) |
a1d9e6e49 i2c: i2c stack ca... |
540 |
{ |
a1d9e6e49 i2c: i2c stack ca... |
541 542 |
device_unregister(&client->dev); } |
9c1600eda i2c: Add i2c_boar... |
543 |
EXPORT_SYMBOL_GPL(i2c_unregister_device); |
a1d9e6e49 i2c: i2c stack ca... |
544 |
|
60b129d7b i2c: Match dummy ... |
545 546 547 548 |
static const struct i2c_device_id dummy_id[] = { { "dummy", 0 }, { }, }; |
d2653e927 i2c: Add support ... |
549 550 551 552 553 554 555 |
static int dummy_probe(struct i2c_client *client, const struct i2c_device_id *id) { return 0; } static int dummy_remove(struct i2c_client *client) |
e9f1373b6 i2c: Add i2c_new_... |
556 557 558 559 560 561 |
{ return 0; } static struct i2c_driver dummy_driver = { .driver.name = "dummy", |
d2653e927 i2c: Add support ... |
562 563 |
.probe = dummy_probe, .remove = dummy_remove, |
60b129d7b i2c: Match dummy ... |
564 |
.id_table = dummy_id, |
e9f1373b6 i2c: Add i2c_new_... |
565 566 567 568 569 570 |
}; /** * i2c_new_dummy - return a new i2c device bound to a dummy driver * @adapter: the adapter managing the device * @address: seven bit address to be used |
e9f1373b6 i2c: Add i2c_new_... |
571 572 573 574 575 576 577 578 579 580 581 582 583 584 |
* Context: can sleep * * This returns an I2C client bound to the "dummy" driver, intended for use * with devices that consume multiple addresses. Examples of such chips * include various EEPROMS (like 24c04 and 24c08 models). * * These dummy devices have two main uses. First, most I2C and SMBus calls * except i2c_transfer() need a client handle; the dummy will be that handle. * And second, this prevents the specified address from being bound to a * different driver. * * This returns the new i2c client, which should be saved for later use with * i2c_unregister_device(); or NULL to indicate an error. */ |
09b8ce0a6 i2c-core: Some st... |
585 |
struct i2c_client *i2c_new_dummy(struct i2c_adapter *adapter, u16 address) |
e9f1373b6 i2c: Add i2c_new_... |
586 587 |
{ struct i2c_board_info info = { |
60b129d7b i2c: Match dummy ... |
588 |
I2C_BOARD_INFO("dummy", address), |
e9f1373b6 i2c: Add i2c_new_... |
589 |
}; |
e9f1373b6 i2c: Add i2c_new_... |
590 591 592 |
return i2c_new_device(adapter, &info); } EXPORT_SYMBOL_GPL(i2c_new_dummy); |
f37dd80ac i2c: Add driver s... |
593 |
/* ------------------------------------------------------------------------- */ |
16ffadfc6 i2c: Class attrib... |
594 |
/* I2C bus adapters -- one roots each I2C or SMBUS segment */ |
83eaaed0d i2c-core: Make so... |
595 |
static void i2c_adapter_dev_release(struct device *dev) |
1da177e4c Linux-2.6.12-rc2 |
596 |
{ |
ef2c8321f i2c: Rename dev_t... |
597 |
struct i2c_adapter *adap = to_i2c_adapter(dev); |
1da177e4c Linux-2.6.12-rc2 |
598 599 |
complete(&adap->dev_released); } |
99cd8e258 i2c: Add a sysfs ... |
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 |
/* * Let users instantiate I2C devices through sysfs. This can be used when * platform initialization code doesn't contain the proper data for * whatever reason. Also useful for drivers that do device detection and * detection fails, either because the device uses an unexpected address, * or this is a compatible device with different ID register values. * * Parameter checking may look overzealous, but we really don't want * the user to provide incorrect parameters. */ static ssize_t i2c_sysfs_new_device(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_adapter *adap = to_i2c_adapter(dev); struct i2c_board_info info; struct i2c_client *client; char *blank, end; int res; |
99cd8e258 i2c: Add a sysfs ... |
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 |
memset(&info, 0, sizeof(struct i2c_board_info)); blank = strchr(buf, ' '); if (!blank) { dev_err(dev, "%s: Missing parameters ", "new_device"); return -EINVAL; } if (blank - buf > I2C_NAME_SIZE - 1) { dev_err(dev, "%s: Invalid device name ", "new_device"); return -EINVAL; } memcpy(info.type, buf, blank - buf); /* Parse remaining parameters, reject extra parameters */ res = sscanf(++blank, "%hi%c", &info.addr, &end); if (res < 1) { dev_err(dev, "%s: Can't parse I2C address ", "new_device"); return -EINVAL; } if (res > 1 && end != ' ') { dev_err(dev, "%s: Extra parameters ", "new_device"); return -EINVAL; } |
99cd8e258 i2c: Add a sysfs ... |
647 648 |
client = i2c_new_device(adap, &info); if (!client) |
3a89db5f3 i2c: Check for ad... |
649 |
return -EINVAL; |
99cd8e258 i2c: Add a sysfs ... |
650 651 |
/* Keep track of the added device */ |
dafc50d14 i2c: Use a separa... |
652 |
mutex_lock(&adap->userspace_clients_lock); |
6629dcff1 i2c-core: Use per... |
653 |
list_add_tail(&client->detected, &adap->userspace_clients); |
dafc50d14 i2c: Use a separa... |
654 |
mutex_unlock(&adap->userspace_clients_lock); |
99cd8e258 i2c: Add a sysfs ... |
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 |
dev_info(dev, "%s: Instantiated device %s at 0x%02hx ", "new_device", info.type, info.addr); return count; } /* * And of course let the users delete the devices they instantiated, if * they got it wrong. This interface can only be used to delete devices * instantiated by i2c_sysfs_new_device above. This guarantees that we * don't delete devices to which some kernel code still has references. * * Parameter checking may look overzealous, but we really don't want * the user to delete the wrong device. */ static ssize_t i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_adapter *adap = to_i2c_adapter(dev); struct i2c_client *client, *next; unsigned short addr; char end; int res; /* Parse parameters, reject extra parameters */ res = sscanf(buf, "%hi%c", &addr, &end); if (res < 1) { dev_err(dev, "%s: Can't parse I2C address ", "delete_device"); return -EINVAL; } if (res > 1 && end != ' ') { dev_err(dev, "%s: Extra parameters ", "delete_device"); return -EINVAL; } /* Make sure the device was added through sysfs */ res = -ENOENT; |
dafc50d14 i2c: Use a separa... |
697 |
mutex_lock(&adap->userspace_clients_lock); |
6629dcff1 i2c-core: Use per... |
698 699 700 |
list_for_each_entry_safe(client, next, &adap->userspace_clients, detected) { if (client->addr == addr) { |
99cd8e258 i2c: Add a sysfs ... |
701 702 703 704 705 706 707 708 709 710 |
dev_info(dev, "%s: Deleting device %s at 0x%02hx ", "delete_device", client->name, client->addr); list_del(&client->detected); i2c_unregister_device(client); res = count; break; } } |
dafc50d14 i2c: Use a separa... |
711 |
mutex_unlock(&adap->userspace_clients_lock); |
99cd8e258 i2c: Add a sysfs ... |
712 713 714 715 716 717 718 |
if (res < 0) dev_err(dev, "%s: Can't find device in list ", "delete_device"); return res; } |
4f8cf8240 i2c: Convert i2c ... |
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 |
static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device); static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device); static struct attribute *i2c_adapter_attrs[] = { &dev_attr_name.attr, &dev_attr_new_device.attr, &dev_attr_delete_device.attr, NULL }; static struct attribute_group i2c_adapter_attr_group = { .attrs = i2c_adapter_attrs, }; static const struct attribute_group *i2c_adapter_attr_groups[] = { &i2c_adapter_attr_group, NULL |
16ffadfc6 i2c: Class attrib... |
736 |
}; |
b119dc3f9 i2c: Migration ai... |
737 |
|
0826374bf i2c: Multiplexed ... |
738 |
struct device_type i2c_adapter_type = { |
4f8cf8240 i2c: Convert i2c ... |
739 740 |
.groups = i2c_adapter_attr_groups, .release = i2c_adapter_dev_release, |
1da177e4c Linux-2.6.12-rc2 |
741 |
}; |
0826374bf i2c: Multiplexed ... |
742 |
EXPORT_SYMBOL_GPL(i2c_adapter_type); |
1da177e4c Linux-2.6.12-rc2 |
743 |
|
2bb5095af i2c: Provide comp... |
744 745 746 |
#ifdef CONFIG_I2C_COMPAT static struct class_compat *i2c_adapter_compat_class; #endif |
9c1600eda i2c: Add i2c_boar... |
747 748 749 |
static void i2c_scan_static_board_info(struct i2c_adapter *adapter) { struct i2c_devinfo *devinfo; |
f18c41dae i2c: Use rwsem in... |
750 |
down_read(&__i2c_board_lock); |
9c1600eda i2c: Add i2c_boar... |
751 752 753 754 |
list_for_each_entry(devinfo, &__i2c_board_list, list) { if (devinfo->busnum == adapter->nr && !i2c_new_device(adapter, &devinfo->board_info)) |
09b8ce0a6 i2c-core: Some st... |
755 756 757 |
dev_err(&adapter->dev, "Can't create device at 0x%02x ", |
9c1600eda i2c: Add i2c_boar... |
758 759 |
devinfo->board_info.addr); } |
f18c41dae i2c: Use rwsem in... |
760 |
up_read(&__i2c_board_lock); |
9c1600eda i2c: Add i2c_boar... |
761 |
} |
69b0089a6 i2c: Refactor for... |
762 763 |
static int i2c_do_add_adapter(struct i2c_driver *driver, struct i2c_adapter *adap) |
026526f5a i2c: Drop redunda... |
764 |
{ |
4735c98f8 i2c: Add detectio... |
765 766 767 768 |
/* Detect supported devices on that bus, and instantiate them */ i2c_detect(adap, driver); /* Let legacy drivers scan this bus for matching devices */ |
026526f5a i2c: Drop redunda... |
769 |
if (driver->attach_adapter) { |
a920ff41c i2c: Improve depr... |
770 771 772 |
dev_warn(&adap->dev, "%s: attach_adapter method is deprecated ", driver->driver.name); |
fe6fc2585 i2c: Deprecate i2... |
773 774 775 |
dev_warn(&adap->dev, "Please use another way to instantiate " "your i2c_client "); |
026526f5a i2c: Drop redunda... |
776 777 778 779 780 |
/* We ignore the return code; if it fails, too bad */ driver->attach_adapter(adap); } return 0; } |
69b0089a6 i2c: Refactor for... |
781 782 783 784 |
static int __process_new_adapter(struct device_driver *d, void *data) { return i2c_do_add_adapter(to_i2c_driver(d), data); } |
6e13e6418 i2c: Add i2c_add_... |
785 |
static int i2c_register_adapter(struct i2c_adapter *adap) |
1da177e4c Linux-2.6.12-rc2 |
786 |
{ |
d6703281f i2c: Drop dummy v... |
787 |
int res = 0; |
1da177e4c Linux-2.6.12-rc2 |
788 |
|
1d0b19c9a i2c: Guard agains... |
789 |
/* Can't register until after driver model init */ |
35fc37f81 i2c: Limit core l... |
790 791 792 793 |
if (unlikely(WARN_ON(!i2c_bus_type.p))) { res = -EAGAIN; goto out_list; } |
1d0b19c9a i2c: Guard agains... |
794 |
|
2236baa75 i2c: Sanity check... |
795 796 797 798 799 800 801 802 803 804 805 806 807 |
/* Sanity checks */ if (unlikely(adap->name[0] == '\0')) { pr_err("i2c-core: Attempt to register an adapter with " "no name! "); return -EINVAL; } if (unlikely(!adap->algo)) { pr_err("i2c-core: Attempt to register adapter '%s' with " "no algo! ", adap->name); return -EINVAL; } |
194684e59 i2c: Prevent prio... |
808 |
rt_mutex_init(&adap->bus_lock); |
dafc50d14 i2c: Use a separa... |
809 |
mutex_init(&adap->userspace_clients_lock); |
6629dcff1 i2c-core: Use per... |
810 |
INIT_LIST_HEAD(&adap->userspace_clients); |
1da177e4c Linux-2.6.12-rc2 |
811 |
|
8fcfef6e6 i2c: Set a defaul... |
812 813 814 |
/* Set default timeout to 1 second if not already set */ if (adap->timeout == 0) adap->timeout = HZ; |
27d9c1838 i2c: Replace bus_... |
815 |
dev_set_name(&adap->dev, "i2c-%d", adap->nr); |
4f8cf8240 i2c: Convert i2c ... |
816 817 |
adap->dev.bus = &i2c_bus_type; adap->dev.type = &i2c_adapter_type; |
b119c6c95 i2c: __must_check... |
818 819 820 |
res = device_register(&adap->dev); if (res) goto out_list; |
1da177e4c Linux-2.6.12-rc2 |
821 |
|
b6d7b3d1b [PATCH] I2C: Impr... |
822 823 |
dev_dbg(&adap->dev, "adapter [%s] registered ", adap->name); |
2bb5095af i2c: Provide comp... |
824 825 826 827 828 829 830 831 |
#ifdef CONFIG_I2C_COMPAT res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev, adap->dev.parent); if (res) dev_warn(&adap->dev, "Failed to create compatibility class link "); #endif |
729d6dd57 i2c: Get rid of t... |
832 |
/* create pre-declared device nodes */ |
6e13e6418 i2c: Add i2c_add_... |
833 834 |
if (adap->nr < __i2c_first_dynamic_bus_num) i2c_scan_static_board_info(adap); |
4735c98f8 i2c: Add detectio... |
835 |
/* Notify drivers */ |
35fc37f81 i2c: Limit core l... |
836 |
mutex_lock(&core_lock); |
d6703281f i2c: Drop dummy v... |
837 |
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter); |
caada32af i2c: Rename main ... |
838 |
mutex_unlock(&core_lock); |
35fc37f81 i2c: Limit core l... |
839 840 |
return 0; |
b119c6c95 i2c: __must_check... |
841 |
|
b119c6c95 i2c: __must_check... |
842 |
out_list: |
35fc37f81 i2c: Limit core l... |
843 |
mutex_lock(&core_lock); |
b119c6c95 i2c: __must_check... |
844 |
idr_remove(&i2c_adapter_idr, adap->nr); |
35fc37f81 i2c: Limit core l... |
845 846 |
mutex_unlock(&core_lock); return res; |
1da177e4c Linux-2.6.12-rc2 |
847 |
} |
6e13e6418 i2c: Add i2c_add_... |
848 849 850 |
/** * i2c_add_adapter - declare i2c adapter, use dynamic bus number * @adapter: the adapter to add |
d64f73be1 i2c: Add kernel d... |
851 |
* Context: can sleep |
6e13e6418 i2c: Add i2c_add_... |
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 |
* * This routine is used to declare an I2C adapter when its bus number * doesn't matter. Examples: for I2C adapters dynamically added by * USB links or PCI plugin cards. * * When this returns zero, a new bus number was allocated and stored * in adap->nr, and the specified adapter became available for clients. * Otherwise, a negative errno value is returned. */ int i2c_add_adapter(struct i2c_adapter *adapter) { int id, res = 0; retry: if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) return -ENOMEM; |
caada32af i2c: Rename main ... |
868 |
mutex_lock(&core_lock); |
6e13e6418 i2c: Add i2c_add_... |
869 870 871 |
/* "above" here means "above or equal to", sigh */ res = idr_get_new_above(&i2c_adapter_idr, adapter, __i2c_first_dynamic_bus_num, &id); |
caada32af i2c: Rename main ... |
872 |
mutex_unlock(&core_lock); |
6e13e6418 i2c: Add i2c_add_... |
873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 |
if (res < 0) { if (res == -EAGAIN) goto retry; return res; } adapter->nr = id; return i2c_register_adapter(adapter); } EXPORT_SYMBOL(i2c_add_adapter); /** * i2c_add_numbered_adapter - declare i2c adapter, use static bus number * @adap: the adapter to register (with adap->nr initialized) |
d64f73be1 i2c: Add kernel d... |
888 |
* Context: can sleep |
6e13e6418 i2c: Add i2c_add_... |
889 890 |
* * This routine is used to declare an I2C adapter when its bus number |
8c07e46f3 i2c: Fix docbook ... |
891 892 |
* matters. For example, use it for I2C adapters from system-on-chip CPUs, * or otherwise built in to the system's mainboard, and where i2c_board_info |
6e13e6418 i2c: Add i2c_add_... |
893 894 |
* is used to properly configure I2C devices. * |
488bf314b i2c: Allow i2c_ad... |
895 896 897 |
* If the requested bus number is set to -1, then this function will behave * identically to i2c_add_adapter, and will dynamically assign a bus number. * |
6e13e6418 i2c: Add i2c_add_... |
898 899 900 901 902 903 904 905 906 907 908 909 910 911 |
* If no devices have pre-been declared for this bus, then be sure to * register the adapter before any dynamically allocated ones. Otherwise * the required bus ID may not be available. * * When this returns zero, the specified adapter became available for * clients using the bus number provided in adap->nr. Also, the table * of I2C devices pre-declared using i2c_register_board_info() is scanned, * and the appropriate driver model device nodes are created. Otherwise, a * negative errno value is returned. */ int i2c_add_numbered_adapter(struct i2c_adapter *adap) { int id; int status; |
488bf314b i2c: Allow i2c_ad... |
912 913 |
if (adap->nr == -1) /* -1 means dynamically assign bus id */ return i2c_add_adapter(adap); |
6e13e6418 i2c: Add i2c_add_... |
914 915 916 917 918 919 |
if (adap->nr & ~MAX_ID_MASK) return -EINVAL; retry: if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) return -ENOMEM; |
caada32af i2c: Rename main ... |
920 |
mutex_lock(&core_lock); |
6e13e6418 i2c: Add i2c_add_... |
921 922 923 924 925 926 927 928 |
/* "above" here means "above or equal to", sigh; * we need the "equal to" result to force the result */ status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id); if (status == 0 && id != adap->nr) { status = -EBUSY; idr_remove(&i2c_adapter_idr, id); } |
caada32af i2c: Rename main ... |
929 |
mutex_unlock(&core_lock); |
6e13e6418 i2c: Add i2c_add_... |
930 931 932 933 934 935 936 937 |
if (status == -EAGAIN) goto retry; if (status == 0) status = i2c_register_adapter(adap); return status; } EXPORT_SYMBOL_GPL(i2c_add_numbered_adapter); |
69b0089a6 i2c: Refactor for... |
938 939 |
static int i2c_do_del_adapter(struct i2c_driver *driver, struct i2c_adapter *adapter) |
026526f5a i2c: Drop redunda... |
940 |
{ |
4735c98f8 i2c: Add detectio... |
941 |
struct i2c_client *client, *_n; |
026526f5a i2c: Drop redunda... |
942 |
int res; |
acec211ca i2c: Clarify whic... |
943 944 |
/* Remove the devices we created ourselves as the result of hardware * probing (using a driver's detect method) */ |
4735c98f8 i2c: Add detectio... |
945 946 947 948 949 950 951 952 953 |
list_for_each_entry_safe(client, _n, &driver->clients, detected) { if (client->adapter == adapter) { dev_dbg(&adapter->dev, "Removing %s at 0x%x ", client->name, client->addr); list_del(&client->detected); i2c_unregister_device(client); } } |
026526f5a i2c: Drop redunda... |
954 955 |
if (!driver->detach_adapter) return 0; |
a920ff41c i2c: Improve depr... |
956 957 958 |
dev_warn(&adapter->dev, "%s: detach_adapter method is deprecated ", driver->driver.name); |
026526f5a i2c: Drop redunda... |
959 960 961 962 963 964 965 |
res = driver->detach_adapter(adapter); if (res) dev_err(&adapter->dev, "detach_adapter failed (%d) " "for driver [%s] ", res, driver->driver.name); return res; } |
e549c2b54 i2c: Kill the red... |
966 967 968 |
static int __unregister_client(struct device *dev, void *dummy) { struct i2c_client *client = i2c_verify_client(dev); |
5219bf884 i2c: Unregister d... |
969 970 971 972 973 974 975 976 |
if (client && strcmp(client->name, "dummy")) i2c_unregister_device(client); return 0; } static int __unregister_dummy(struct device *dev, void *dummy) { struct i2c_client *client = i2c_verify_client(dev); |
e549c2b54 i2c: Kill the red... |
977 978 979 980 |
if (client) i2c_unregister_device(client); return 0; } |
69b0089a6 i2c: Refactor for... |
981 982 983 984 |
static int __process_removed_adapter(struct device_driver *d, void *data) { return i2c_do_del_adapter(to_i2c_driver(d), data); } |
d64f73be1 i2c: Add kernel d... |
985 986 987 988 989 990 991 992 |
/** * i2c_del_adapter - unregister I2C adapter * @adap: the adapter being unregistered * Context: can sleep * * This unregisters an I2C adapter which was previously registered * by @i2c_add_adapter or @i2c_add_numbered_adapter. */ |
1da177e4c Linux-2.6.12-rc2 |
993 994 |
int i2c_del_adapter(struct i2c_adapter *adap) { |
1da177e4c Linux-2.6.12-rc2 |
995 |
int res = 0; |
35fc37f81 i2c: Limit core l... |
996 |
struct i2c_adapter *found; |
bbd2d9c91 i2c: Fix userspac... |
997 |
struct i2c_client *client, *next; |
1da177e4c Linux-2.6.12-rc2 |
998 999 |
/* First make sure that this adapter was ever added */ |
35fc37f81 i2c: Limit core l... |
1000 1001 1002 1003 |
mutex_lock(&core_lock); found = idr_find(&i2c_adapter_idr, adap->nr); mutex_unlock(&core_lock); if (found != adap) { |
b6d7b3d1b [PATCH] I2C: Impr... |
1004 1005 1006 |
pr_debug("i2c-core: attempting to delete unregistered " "adapter [%s] ", adap->name); |
35fc37f81 i2c: Limit core l... |
1007 |
return -EINVAL; |
1da177e4c Linux-2.6.12-rc2 |
1008 |
} |
026526f5a i2c: Drop redunda... |
1009 |
/* Tell drivers about this removal */ |
35fc37f81 i2c: Limit core l... |
1010 |
mutex_lock(&core_lock); |
026526f5a i2c: Drop redunda... |
1011 |
res = bus_for_each_drv(&i2c_bus_type, NULL, adap, |
69b0089a6 i2c: Refactor for... |
1012 |
__process_removed_adapter); |
35fc37f81 i2c: Limit core l... |
1013 |
mutex_unlock(&core_lock); |
026526f5a i2c: Drop redunda... |
1014 |
if (res) |
35fc37f81 i2c: Limit core l... |
1015 |
return res; |
1da177e4c Linux-2.6.12-rc2 |
1016 |
|
bbd2d9c91 i2c: Fix userspac... |
1017 |
/* Remove devices instantiated from sysfs */ |
dafc50d14 i2c: Use a separa... |
1018 |
mutex_lock(&adap->userspace_clients_lock); |
6629dcff1 i2c-core: Use per... |
1019 1020 1021 1022 1023 1024 1025 |
list_for_each_entry_safe(client, next, &adap->userspace_clients, detected) { dev_dbg(&adap->dev, "Removing %s at 0x%x ", client->name, client->addr); list_del(&client->detected); i2c_unregister_device(client); |
bbd2d9c91 i2c: Fix userspac... |
1026 |
} |
dafc50d14 i2c: Use a separa... |
1027 |
mutex_unlock(&adap->userspace_clients_lock); |
bbd2d9c91 i2c: Fix userspac... |
1028 |
|
e549c2b54 i2c: Kill the red... |
1029 |
/* Detach any active clients. This can't fail, thus we do not |
5219bf884 i2c: Unregister d... |
1030 1031 1032 1033 |
* check the returned value. This is a two-pass process, because * we can't remove the dummy devices during the first pass: they * could have been instantiated by real devices wishing to clean * them up properly, so we give them a chance to do that first. */ |
e549c2b54 i2c: Kill the red... |
1034 |
res = device_for_each_child(&adap->dev, NULL, __unregister_client); |
5219bf884 i2c: Unregister d... |
1035 |
res = device_for_each_child(&adap->dev, NULL, __unregister_dummy); |
1da177e4c Linux-2.6.12-rc2 |
1036 |
|
2bb5095af i2c: Provide comp... |
1037 1038 1039 1040 |
#ifdef CONFIG_I2C_COMPAT class_compat_remove_link(i2c_adapter_compat_class, &adap->dev, adap->dev.parent); #endif |
c55675210 i2c: Do not use d... |
1041 1042 1043 |
/* device name is gone after device_unregister */ dev_dbg(&adap->dev, "adapter [%s] unregistered ", adap->name); |
1da177e4c Linux-2.6.12-rc2 |
1044 1045 |
/* clean up the sysfs representation */ init_completion(&adap->dev_released); |
1da177e4c Linux-2.6.12-rc2 |
1046 |
device_unregister(&adap->dev); |
1da177e4c Linux-2.6.12-rc2 |
1047 1048 1049 |
/* wait for sysfs to drop all references */ wait_for_completion(&adap->dev_released); |
1da177e4c Linux-2.6.12-rc2 |
1050 |
|
6e13e6418 i2c: Add i2c_add_... |
1051 |
/* free bus id */ |
35fc37f81 i2c: Limit core l... |
1052 |
mutex_lock(&core_lock); |
1da177e4c Linux-2.6.12-rc2 |
1053 |
idr_remove(&i2c_adapter_idr, adap->nr); |
35fc37f81 i2c: Limit core l... |
1054 |
mutex_unlock(&core_lock); |
1da177e4c Linux-2.6.12-rc2 |
1055 |
|
bd4bc3dbd i2c: Clear i2c_ad... |
1056 1057 1058 |
/* Clear the device structure in case this adapter is ever going to be added again */ memset(&adap->dev, 0, sizeof(adap->dev)); |
35fc37f81 i2c: Limit core l... |
1059 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
1060 |
} |
c05646069 i2c: i2c EXPORT_S... |
1061 |
EXPORT_SYMBOL(i2c_del_adapter); |
1da177e4c Linux-2.6.12-rc2 |
1062 |
|
7b4fbc50f i2c: i2c stack ca... |
1063 |
/* ------------------------------------------------------------------------- */ |
7ae31482a i2c: Export i2c_f... |
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 |
int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *)) { int res; mutex_lock(&core_lock); res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn); mutex_unlock(&core_lock); return res; } EXPORT_SYMBOL_GPL(i2c_for_each_dev); |
69b0089a6 i2c: Refactor for... |
1075 |
static int __process_new_driver(struct device *dev, void *data) |
7f101a978 i2c: Use class_fo... |
1076 |
{ |
4f8cf8240 i2c: Convert i2c ... |
1077 1078 |
if (dev->type != &i2c_adapter_type) return 0; |
69b0089a6 i2c: Refactor for... |
1079 |
return i2c_do_add_adapter(data, to_i2c_adapter(dev)); |
7f101a978 i2c: Use class_fo... |
1080 |
} |
7b4fbc50f i2c: i2c stack ca... |
1081 1082 |
/* * An i2c_driver is used with one or more i2c_client (device) nodes to access |
729d6dd57 i2c: Get rid of t... |
1083 |
* i2c slave chips, on a bus instance associated with some i2c_adapter. |
1da177e4c Linux-2.6.12-rc2 |
1084 |
*/ |
de59cf9ed [PATCH] I2C: Make... |
1085 |
int i2c_register_driver(struct module *owner, struct i2c_driver *driver) |
1da177e4c Linux-2.6.12-rc2 |
1086 |
{ |
7eebcb7c0 [PATCH] i2c: Opti... |
1087 |
int res; |
1da177e4c Linux-2.6.12-rc2 |
1088 |
|
1d0b19c9a i2c: Guard agains... |
1089 1090 1091 |
/* Can't register until after driver model init */ if (unlikely(WARN_ON(!i2c_bus_type.p))) return -EAGAIN; |
1da177e4c Linux-2.6.12-rc2 |
1092 |
/* add the driver to the list of i2c drivers in the driver core */ |
de59cf9ed [PATCH] I2C: Make... |
1093 |
driver->driver.owner = owner; |
1da177e4c Linux-2.6.12-rc2 |
1094 |
driver->driver.bus = &i2c_bus_type; |
1da177e4c Linux-2.6.12-rc2 |
1095 |
|
729d6dd57 i2c: Get rid of t... |
1096 |
/* When registration returns, the driver core |
6e13e6418 i2c: Add i2c_add_... |
1097 1098 |
* will have called probe() for all matching-but-unbound devices. */ |
1da177e4c Linux-2.6.12-rc2 |
1099 1100 |
res = driver_register(&driver->driver); if (res) |
7eebcb7c0 [PATCH] i2c: Opti... |
1101 |
return res; |
438d6c2c0 i2c: Whitespace c... |
1102 |
|
f4e8db31a i2c: Encourage mo... |
1103 1104 1105 1106 1107 1108 1109 1110 1111 |
/* Drivers should switch to dev_pm_ops instead. */ if (driver->suspend) pr_warn("i2c-core: driver [%s] using legacy suspend method ", driver->driver.name); if (driver->resume) pr_warn("i2c-core: driver [%s] using legacy resume method ", driver->driver.name); |
35d8b2e6b [PATCH] i2c: Drop... |
1112 1113 |
pr_debug("i2c-core: driver [%s] registered ", driver->driver.name); |
1da177e4c Linux-2.6.12-rc2 |
1114 |
|
4735c98f8 i2c: Add detectio... |
1115 1116 |
INIT_LIST_HEAD(&driver->clients); /* Walk the adapters that are already present */ |
7ae31482a i2c: Export i2c_f... |
1117 |
i2c_for_each_dev(driver, __process_new_driver); |
35fc37f81 i2c: Limit core l... |
1118 |
|
7f101a978 i2c: Use class_fo... |
1119 1120 1121 |
return 0; } EXPORT_SYMBOL(i2c_register_driver); |
69b0089a6 i2c: Refactor for... |
1122 |
static int __process_removed_driver(struct device *dev, void *data) |
7f101a978 i2c: Use class_fo... |
1123 |
{ |
4f8cf8240 i2c: Convert i2c ... |
1124 1125 |
if (dev->type != &i2c_adapter_type) return 0; |
69b0089a6 i2c: Refactor for... |
1126 |
return i2c_do_del_adapter(data, to_i2c_adapter(dev)); |
1da177e4c Linux-2.6.12-rc2 |
1127 |
} |
a1d9e6e49 i2c: i2c stack ca... |
1128 1129 1130 |
/** * i2c_del_driver - unregister I2C driver * @driver: the driver being unregistered |
d64f73be1 i2c: Add kernel d... |
1131 |
* Context: can sleep |
a1d9e6e49 i2c: i2c stack ca... |
1132 |
*/ |
b3e820968 i2c: Make i2c_del... |
1133 |
void i2c_del_driver(struct i2c_driver *driver) |
1da177e4c Linux-2.6.12-rc2 |
1134 |
{ |
7ae31482a i2c: Export i2c_f... |
1135 |
i2c_for_each_dev(driver, __process_removed_driver); |
1da177e4c Linux-2.6.12-rc2 |
1136 1137 |
driver_unregister(&driver->driver); |
35d8b2e6b [PATCH] i2c: Drop... |
1138 1139 |
pr_debug("i2c-core: driver [%s] unregistered ", driver->driver.name); |
1da177e4c Linux-2.6.12-rc2 |
1140 |
} |
c05646069 i2c: i2c EXPORT_S... |
1141 |
EXPORT_SYMBOL(i2c_del_driver); |
1da177e4c Linux-2.6.12-rc2 |
1142 |
|
7b4fbc50f i2c: i2c stack ca... |
1143 |
/* ------------------------------------------------------------------------- */ |
e48d33193 i2c: Change proto... |
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 |
/** * i2c_use_client - increments the reference count of the i2c client structure * @client: the client being referenced * * Each live reference to a client should be refcounted. The driver model does * that automatically as part of driver binding, so that most drivers don't * need to do this explicitly: they hold a reference until they're unbound * from the device. * * A pointer to the client with the incremented reference counter is returned. */ struct i2c_client *i2c_use_client(struct i2c_client *client) |
1da177e4c Linux-2.6.12-rc2 |
1156 |
{ |
6ea438ec8 i2c: i2c_use_clie... |
1157 1158 1159 |
if (client && get_device(&client->dev)) return client; return NULL; |
1da177e4c Linux-2.6.12-rc2 |
1160 |
} |
c05646069 i2c: i2c EXPORT_S... |
1161 |
EXPORT_SYMBOL(i2c_use_client); |
1da177e4c Linux-2.6.12-rc2 |
1162 |
|
e48d33193 i2c: Change proto... |
1163 1164 1165 1166 1167 1168 1169 |
/** * i2c_release_client - release a use of the i2c client structure * @client: the client being no longer referenced * * Must be called when a user of a client is finished with it. */ void i2c_release_client(struct i2c_client *client) |
1da177e4c Linux-2.6.12-rc2 |
1170 |
{ |
6ea438ec8 i2c: i2c_use_clie... |
1171 1172 |
if (client) put_device(&client->dev); |
1da177e4c Linux-2.6.12-rc2 |
1173 |
} |
c05646069 i2c: i2c EXPORT_S... |
1174 |
EXPORT_SYMBOL(i2c_release_client); |
1da177e4c Linux-2.6.12-rc2 |
1175 |
|
9b766b814 i2c: Stop using t... |
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 |
struct i2c_cmd_arg { unsigned cmd; void *arg; }; static int i2c_cmd(struct device *dev, void *_arg) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_cmd_arg *arg = _arg; if (client && client->driver && client->driver->command) client->driver->command(client, arg->cmd, arg->arg); return 0; } |
1da177e4c Linux-2.6.12-rc2 |
1190 1191 |
void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg) { |
9b766b814 i2c: Stop using t... |
1192 |
struct i2c_cmd_arg cmd_arg; |
1da177e4c Linux-2.6.12-rc2 |
1193 |
|
9b766b814 i2c: Stop using t... |
1194 1195 1196 |
cmd_arg.cmd = cmd; cmd_arg.arg = arg; device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd); |
1da177e4c Linux-2.6.12-rc2 |
1197 |
} |
c05646069 i2c: i2c EXPORT_S... |
1198 |
EXPORT_SYMBOL(i2c_clients_command); |
1da177e4c Linux-2.6.12-rc2 |
1199 1200 1201 1202 1203 1204 1205 1206 |
static int __init i2c_init(void) { int retval; retval = bus_register(&i2c_bus_type); if (retval) return retval; |
2bb5095af i2c: Provide comp... |
1207 1208 1209 1210 1211 1212 1213 |
#ifdef CONFIG_I2C_COMPAT i2c_adapter_compat_class = class_compat_register("i2c-adapter"); if (!i2c_adapter_compat_class) { retval = -ENOMEM; goto bus_err; } #endif |
e9f1373b6 i2c: Add i2c_new_... |
1214 1215 |
retval = i2c_add_driver(&dummy_driver); if (retval) |
2bb5095af i2c: Provide comp... |
1216 |
goto class_err; |
e9f1373b6 i2c: Add i2c_new_... |
1217 |
return 0; |
2bb5095af i2c: Provide comp... |
1218 1219 1220 |
class_err: #ifdef CONFIG_I2C_COMPAT class_compat_unregister(i2c_adapter_compat_class); |
e9f1373b6 i2c: Add i2c_new_... |
1221 |
bus_err: |
2bb5095af i2c: Provide comp... |
1222 |
#endif |
e9f1373b6 i2c: Add i2c_new_... |
1223 1224 |
bus_unregister(&i2c_bus_type); return retval; |
1da177e4c Linux-2.6.12-rc2 |
1225 1226 1227 1228 |
} static void __exit i2c_exit(void) { |
e9f1373b6 i2c: Add i2c_new_... |
1229 |
i2c_del_driver(&dummy_driver); |
2bb5095af i2c: Provide comp... |
1230 1231 1232 |
#ifdef CONFIG_I2C_COMPAT class_compat_unregister(i2c_adapter_compat_class); #endif |
1da177e4c Linux-2.6.12-rc2 |
1233 1234 |
bus_unregister(&i2c_bus_type); } |
a10f9e7ca i2c: Do earlier d... |
1235 1236 1237 1238 |
/* We must initialize early, because some subsystems register i2c drivers * in subsys_initcall() code, but are linked (and initialized) before i2c. */ postcore_initcall(i2c_init); |
1da177e4c Linux-2.6.12-rc2 |
1239 1240 1241 1242 1243 1244 |
module_exit(i2c_exit); /* ---------------------------------------------------- * the functional interface to the i2c busses. * ---------------------------------------------------- */ |
a1cdedac6 i2c: Kerneldoc fo... |
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 |
/** * i2c_transfer - execute a single or combined I2C message * @adap: Handle to I2C bus * @msgs: One or more messages to execute before STOP is issued to * terminate the operation; each message begins with a START. * @num: Number of messages to be executed. * * Returns negative errno, else the number of messages executed. * * Note that there is no requirement that each message be sent to * the same slave address, although that is the most common model. */ |
09b8ce0a6 i2c-core: Some st... |
1257 |
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) |
1da177e4c Linux-2.6.12-rc2 |
1258 |
{ |
66b650f04 i2c: Retry automa... |
1259 1260 |
unsigned long orig_jiffies; int ret, try; |
1da177e4c Linux-2.6.12-rc2 |
1261 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 |
/* REVISIT the fault reporting model here is weak: * * - When we get an error after receiving N bytes from a slave, * there is no way to report "N". * * - When we get a NAK after transmitting N bytes to a slave, * there is no way to report "N" ... or to let the master * continue executing the rest of this combined message, if * that's the appropriate response. * * - When for example "num" is two and we successfully complete * the first message but get an error part way through the * second, it's unclear whether that should be reported as * one (discarding status on the second message) or errno * (discarding status on the first one). */ |
1da177e4c Linux-2.6.12-rc2 |
1278 1279 1280 1281 |
if (adap->algo->master_xfer) { #ifdef DEBUG for (ret = 0; ret < num; ret++) { dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, " |
209d27c3b i2c: Emulate SMBu... |
1282 1283 1284 1285 |
"len=%d%s ", ret, (msgs[ret].flags & I2C_M_RD) ? 'R' : 'W', msgs[ret].addr, msgs[ret].len, (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : ""); |
1da177e4c Linux-2.6.12-rc2 |
1286 1287 |
} #endif |
cea443a81 i2c: Support i2c_... |
1288 |
if (in_atomic() || irqs_disabled()) { |
fe61e07e9 i2c: Move adapter... |
1289 |
ret = i2c_trylock_adapter(adap); |
cea443a81 i2c: Support i2c_... |
1290 1291 1292 1293 |
if (!ret) /* I2C activity is ongoing. */ return -EAGAIN; } else { |
fe61e07e9 i2c: Move adapter... |
1294 |
i2c_lock_adapter(adap); |
cea443a81 i2c: Support i2c_... |
1295 |
} |
66b650f04 i2c: Retry automa... |
1296 1297 1298 1299 1300 1301 1302 1303 1304 |
/* Retry automatically on arbitration loss */ orig_jiffies = jiffies; for (ret = 0, try = 0; try <= adap->retries; try++) { ret = adap->algo->master_xfer(adap, msgs, num); if (ret != -EAGAIN) break; if (time_after(jiffies, orig_jiffies + adap->timeout)) break; } |
fe61e07e9 i2c: Move adapter... |
1305 |
i2c_unlock_adapter(adap); |
1da177e4c Linux-2.6.12-rc2 |
1306 1307 1308 1309 1310 |
return ret; } else { dev_dbg(&adap->dev, "I2C level transfers not supported "); |
24a5bb7b1 i2c-core: Return ... |
1311 |
return -EOPNOTSUPP; |
1da177e4c Linux-2.6.12-rc2 |
1312 1313 |
} } |
c05646069 i2c: i2c EXPORT_S... |
1314 |
EXPORT_SYMBOL(i2c_transfer); |
1da177e4c Linux-2.6.12-rc2 |
1315 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1316 1317 1318 1319 |
/** * i2c_master_send - issue a single I2C message in master transmit mode * @client: Handle to slave device * @buf: Data that will be written to the slave |
0c43ea544 i2c: Document the... |
1320 |
* @count: How many bytes to write, must be less than 64k since msg.len is u16 |
a1cdedac6 i2c: Kerneldoc fo... |
1321 1322 1323 |
* * Returns negative errno, or else the number of bytes written. */ |
0cc43a180 i2c: Constify i2c... |
1324 |
int i2c_master_send(const struct i2c_client *client, const char *buf, int count) |
1da177e4c Linux-2.6.12-rc2 |
1325 1326 |
{ int ret; |
7225acf4a i2c-core: Fix som... |
1327 |
struct i2c_adapter *adap = client->adapter; |
1da177e4c Linux-2.6.12-rc2 |
1328 |
struct i2c_msg msg; |
815f55f28 [PATCH] I2C: Remo... |
1329 1330 1331 1332 |
msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.len = count; msg.buf = (char *)buf; |
438d6c2c0 i2c: Whitespace c... |
1333 |
|
815f55f28 [PATCH] I2C: Remo... |
1334 |
ret = i2c_transfer(adap, &msg, 1); |
1da177e4c Linux-2.6.12-rc2 |
1335 |
|
815f55f28 [PATCH] I2C: Remo... |
1336 1337 1338 |
/* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; |
1da177e4c Linux-2.6.12-rc2 |
1339 |
} |
c05646069 i2c: i2c EXPORT_S... |
1340 |
EXPORT_SYMBOL(i2c_master_send); |
1da177e4c Linux-2.6.12-rc2 |
1341 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1342 1343 1344 1345 |
/** * i2c_master_recv - issue a single I2C message in master receive mode * @client: Handle to slave device * @buf: Where to store data read from slave |
0c43ea544 i2c: Document the... |
1346 |
* @count: How many bytes to read, must be less than 64k since msg.len is u16 |
a1cdedac6 i2c: Kerneldoc fo... |
1347 1348 1349 |
* * Returns negative errno, or else the number of bytes read. */ |
0cc43a180 i2c: Constify i2c... |
1350 |
int i2c_master_recv(const struct i2c_client *client, char *buf, int count) |
1da177e4c Linux-2.6.12-rc2 |
1351 |
{ |
7225acf4a i2c-core: Fix som... |
1352 |
struct i2c_adapter *adap = client->adapter; |
1da177e4c Linux-2.6.12-rc2 |
1353 1354 |
struct i2c_msg msg; int ret; |
815f55f28 [PATCH] I2C: Remo... |
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 |
msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.flags |= I2C_M_RD; msg.len = count; msg.buf = buf; ret = i2c_transfer(adap, &msg, 1); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; |
1da177e4c Linux-2.6.12-rc2 |
1367 |
} |
c05646069 i2c: i2c EXPORT_S... |
1368 |
EXPORT_SYMBOL(i2c_master_recv); |
1da177e4c Linux-2.6.12-rc2 |
1369 |
|
1da177e4c Linux-2.6.12-rc2 |
1370 1371 1372 1373 1374 |
/* ---------------------------------------------------- * the i2c address scanning function * Will not work for 10-bit addresses! * ---------------------------------------------------- */ |
1da177e4c Linux-2.6.12-rc2 |
1375 |
|
63e4e8021 i2c: Share the I2... |
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 |
/* * Legacy default probe function, mostly relevant for SMBus. The default * probe method is a quick write, but it is known to corrupt the 24RF08 * EEPROMs due to a state machine bug, and could also irreversibly * write-protect some EEPROMs, so for address ranges 0x30-0x37 and 0x50-0x5f, * we use a short byte read instead. Also, some bus drivers don't implement * quick write, so we fallback to a byte read in that case too. * On x86, there is another special case for FSC hardware monitoring chips, * which want regular byte reads (address 0x73.) Fortunately, these are the * only known chips using this I2C address on PC hardware. * Returns 1 if probe succeeded, 0 if not. */ static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr) { int err; union i2c_smbus_data dummy; #ifdef CONFIG_X86 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON) && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA)) err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE_DATA, &dummy); else #endif |
8031d79ba i2c: Make i2c_def... |
1400 1401 |
if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50) && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) |
63e4e8021 i2c: Share the I2... |
1402 1403 |
err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0, I2C_SMBUS_QUICK, NULL); |
8031d79ba i2c: Make i2c_def... |
1404 1405 1406 1407 1408 1409 1410 1411 |
else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy); else { dev_warn(&adap->dev, "No suitable probing method supported "); err = -EOPNOTSUPP; } |
63e4e8021 i2c: Share the I2... |
1412 1413 1414 |
return err >= 0; } |
ccfbbd082 i2c: Simplify i2c... |
1415 |
static int i2c_detect_address(struct i2c_client *temp_client, |
4735c98f8 i2c: Add detectio... |
1416 1417 1418 1419 1420 1421 1422 1423 |
struct i2c_driver *driver) { struct i2c_board_info info; struct i2c_adapter *adapter = temp_client->adapter; int addr = temp_client->addr; int err; /* Make sure the address is valid */ |
656b8761a i2c: Document res... |
1424 1425 |
err = i2c_check_addr_validity(addr); if (err) { |
4735c98f8 i2c: Add detectio... |
1426 1427 1428 |
dev_warn(&adapter->dev, "Invalid probe address 0x%02x ", addr); |
656b8761a i2c: Document res... |
1429 |
return err; |
4735c98f8 i2c: Add detectio... |
1430 1431 1432 |
} /* Skip if already in use */ |
3b5f794b8 i2c: Rename i2c_c... |
1433 |
if (i2c_check_addr_busy(adapter, addr)) |
4735c98f8 i2c: Add detectio... |
1434 |
return 0; |
ccfbbd082 i2c: Simplify i2c... |
1435 |
/* Make sure there is something at this address */ |
63e4e8021 i2c: Share the I2... |
1436 1437 |
if (!i2c_default_probe(adapter, addr)) return 0; |
4735c98f8 i2c: Add detectio... |
1438 1439 1440 1441 |
/* Finally call the custom detection function */ memset(&info, 0, sizeof(struct i2c_board_info)); info.addr = addr; |
310ec7921 i2c: Drop the kin... |
1442 |
err = driver->detect(temp_client, &info); |
4735c98f8 i2c: Add detectio... |
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 |
if (err) { /* -ENODEV is returned if the detection fails. We catch it here as this isn't an error. */ return err == -ENODEV ? 0 : err; } /* Consistency check */ if (info.type[0] == '\0') { dev_err(&adapter->dev, "%s detection function provided " "no name for 0x%x ", driver->driver.name, addr); } else { struct i2c_client *client; /* Detection succeeded, instantiate the device */ dev_dbg(&adapter->dev, "Creating %s at 0x%02x ", info.type, info.addr); client = i2c_new_device(adapter, &info); if (client) list_add_tail(&client->detected, &driver->clients); else dev_err(&adapter->dev, "Failed creating %s at 0x%02x ", info.type, info.addr); } return 0; } static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver) { |
c3813d6af i2c: Get rid of s... |
1475 |
const unsigned short *address_list; |
4735c98f8 i2c: Add detectio... |
1476 1477 1478 |
struct i2c_client *temp_client; int i, err = 0; int adap_id = i2c_adapter_id(adapter); |
c3813d6af i2c: Get rid of s... |
1479 1480 |
address_list = driver->address_list; if (!driver->detect || !address_list) |
4735c98f8 i2c: Add detectio... |
1481 |
return 0; |
51b54ba9b i2c: Optimize fun... |
1482 1483 1484 |
/* Stop here if the classes do not match */ if (!(adapter->class & driver->class)) return 0; |
4735c98f8 i2c: Add detectio... |
1485 1486 1487 1488 1489 |
/* Set up a temporary client to help detect callback */ temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); if (!temp_client) return -ENOMEM; temp_client->adapter = adapter; |
c3813d6af i2c: Get rid of s... |
1490 |
for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) { |
4735c98f8 i2c: Add detectio... |
1491 |
dev_dbg(&adapter->dev, "found normal entry for adapter %d, " |
c3813d6af i2c: Get rid of s... |
1492 1493 1494 |
"addr 0x%02x ", adap_id, address_list[i]); temp_client->addr = address_list[i]; |
ccfbbd082 i2c: Simplify i2c... |
1495 |
err = i2c_detect_address(temp_client, driver); |
51b54ba9b i2c: Optimize fun... |
1496 1497 |
if (unlikely(err)) break; |
4735c98f8 i2c: Add detectio... |
1498 |
} |
4735c98f8 i2c: Add detectio... |
1499 1500 1501 |
kfree(temp_client); return err; } |
d44f19d58 V4L/DVB: Use cust... |
1502 1503 1504 1505 1506 1507 |
int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr) { return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0, I2C_SMBUS_QUICK, NULL) >= 0; } EXPORT_SYMBOL_GPL(i2c_probe_func_quick_read); |
12b5053ac i2c: Add i2c_new_... |
1508 1509 1510 |
struct i2c_client * i2c_new_probed_device(struct i2c_adapter *adap, struct i2c_board_info *info, |
9a94241af i2c: Add support ... |
1511 1512 |
unsigned short const *addr_list, int (*probe)(struct i2c_adapter *, unsigned short addr)) |
12b5053ac i2c: Add i2c_new_... |
1513 1514 |
{ int i; |
8031d79ba i2c: Make i2c_def... |
1515 |
if (!probe) |
9a94241af i2c: Add support ... |
1516 |
probe = i2c_default_probe; |
12b5053ac i2c: Add i2c_new_... |
1517 |
|
12b5053ac i2c: Add i2c_new_... |
1518 1519 |
for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) { /* Check address validity */ |
656b8761a i2c: Document res... |
1520 |
if (i2c_check_addr_validity(addr_list[i]) < 0) { |
12b5053ac i2c: Add i2c_new_... |
1521 1522 1523 1524 1525 1526 1527 |
dev_warn(&adap->dev, "Invalid 7-bit address " "0x%02x ", addr_list[i]); continue; } /* Check address availability */ |
3b5f794b8 i2c: Rename i2c_c... |
1528 |
if (i2c_check_addr_busy(adap, addr_list[i])) { |
12b5053ac i2c: Add i2c_new_... |
1529 1530 1531 1532 1533 |
dev_dbg(&adap->dev, "Address 0x%02x already in " "use, not probing ", addr_list[i]); continue; } |
63e4e8021 i2c: Share the I2... |
1534 |
/* Test address responsiveness */ |
9a94241af i2c: Add support ... |
1535 |
if (probe(adap, addr_list[i])) |
63e4e8021 i2c: Share the I2... |
1536 |
break; |
12b5053ac i2c: Add i2c_new_... |
1537 |
} |
12b5053ac i2c: Add i2c_new_... |
1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 |
if (addr_list[i] == I2C_CLIENT_END) { dev_dbg(&adap->dev, "Probing failed, no device found "); return NULL; } info->addr = addr_list[i]; return i2c_new_device(adap, info); } EXPORT_SYMBOL_GPL(i2c_new_probed_device); |
d735b34db i2c: make i2c_get... |
1549 |
struct i2c_adapter *i2c_get_adapter(int nr) |
1da177e4c Linux-2.6.12-rc2 |
1550 |
{ |
1da177e4c Linux-2.6.12-rc2 |
1551 |
struct i2c_adapter *adapter; |
438d6c2c0 i2c: Whitespace c... |
1552 |
|
caada32af i2c: Rename main ... |
1553 |
mutex_lock(&core_lock); |
d735b34db i2c: make i2c_get... |
1554 |
adapter = idr_find(&i2c_adapter_idr, nr); |
a0920e104 [PATCH] i2c: make... |
1555 1556 |
if (adapter && !try_module_get(adapter->owner)) adapter = NULL; |
caada32af i2c: Rename main ... |
1557 |
mutex_unlock(&core_lock); |
a0920e104 [PATCH] i2c: make... |
1558 |
return adapter; |
1da177e4c Linux-2.6.12-rc2 |
1559 |
} |
c05646069 i2c: i2c EXPORT_S... |
1560 |
EXPORT_SYMBOL(i2c_get_adapter); |
1da177e4c Linux-2.6.12-rc2 |
1561 1562 1563 1564 1565 |
void i2c_put_adapter(struct i2c_adapter *adap) { module_put(adap->owner); } |
c05646069 i2c: i2c EXPORT_S... |
1566 |
EXPORT_SYMBOL(i2c_put_adapter); |
1da177e4c Linux-2.6.12-rc2 |
1567 1568 |
/* The SMBus parts */ |
438d6c2c0 i2c: Whitespace c... |
1569 |
#define POLY (0x1070U << 3) |
09b8ce0a6 i2c-core: Some st... |
1570 |
static u8 crc8(u16 data) |
1da177e4c Linux-2.6.12-rc2 |
1571 1572 |
{ int i; |
438d6c2c0 i2c: Whitespace c... |
1573 |
|
7225acf4a i2c-core: Fix som... |
1574 |
for (i = 0; i < 8; i++) { |
438d6c2c0 i2c: Whitespace c... |
1575 |
if (data & 0x8000) |
1da177e4c Linux-2.6.12-rc2 |
1576 1577 1578 1579 1580 |
data = data ^ POLY; data = data << 1; } return (u8)(data >> 8); } |
421ef47be [PATCH] i2c: SMBu... |
1581 1582 |
/* Incremental CRC8 over count bytes in the array pointed to by p */ static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
1583 1584 |
{ int i; |
7225acf4a i2c-core: Fix som... |
1585 |
for (i = 0; i < count; i++) |
421ef47be [PATCH] i2c: SMBu... |
1586 |
crc = crc8((crc ^ p[i]) << 8); |
1da177e4c Linux-2.6.12-rc2 |
1587 1588 |
return crc; } |
421ef47be [PATCH] i2c: SMBu... |
1589 1590 |
/* Assume a 7-bit address, which is reasonable for SMBus */ static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg) |
1da177e4c Linux-2.6.12-rc2 |
1591 |
{ |
421ef47be [PATCH] i2c: SMBu... |
1592 1593 1594 1595 1596 1597 |
/* The address will be sent first */ u8 addr = (msg->addr << 1) | !!(msg->flags & I2C_M_RD); pec = i2c_smbus_pec(pec, &addr, 1); /* The data buffer follows */ return i2c_smbus_pec(pec, msg->buf, msg->len); |
1da177e4c Linux-2.6.12-rc2 |
1598 |
} |
421ef47be [PATCH] i2c: SMBu... |
1599 1600 |
/* Used for write only transactions */ static inline void i2c_smbus_add_pec(struct i2c_msg *msg) |
1da177e4c Linux-2.6.12-rc2 |
1601 |
{ |
421ef47be [PATCH] i2c: SMBu... |
1602 1603 |
msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg); msg->len++; |
1da177e4c Linux-2.6.12-rc2 |
1604 |
} |
421ef47be [PATCH] i2c: SMBu... |
1605 1606 1607 1608 1609 1610 |
/* Return <0 on CRC error If there was a write before this read (most cases) we need to take the partial CRC from the write part into account. Note that this function does modify the message (we need to decrease the message length to hide the CRC byte from the caller). */ static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg) |
1da177e4c Linux-2.6.12-rc2 |
1611 |
{ |
421ef47be [PATCH] i2c: SMBu... |
1612 1613 |
u8 rpec = msg->buf[--msg->len]; cpec = i2c_smbus_msg_pec(cpec, msg); |
1da177e4c Linux-2.6.12-rc2 |
1614 |
|
1da177e4c Linux-2.6.12-rc2 |
1615 1616 1617 1618 |
if (rpec != cpec) { pr_debug("i2c-core: Bad PEC 0x%02x vs. 0x%02x ", rpec, cpec); |
24a5bb7b1 i2c-core: Return ... |
1619 |
return -EBADMSG; |
1da177e4c Linux-2.6.12-rc2 |
1620 |
} |
438d6c2c0 i2c: Whitespace c... |
1621 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
1622 |
} |
a1cdedac6 i2c: Kerneldoc fo... |
1623 1624 1625 1626 1627 1628 1629 |
/** * i2c_smbus_read_byte - SMBus "receive byte" protocol * @client: Handle to slave device * * This executes the SMBus "receive byte" protocol, returning negative errno * else the byte received from the device. */ |
0cc43a180 i2c: Constify i2c... |
1630 |
s32 i2c_smbus_read_byte(const struct i2c_client *client) |
1da177e4c Linux-2.6.12-rc2 |
1631 1632 |
{ union i2c_smbus_data data; |
24a5bb7b1 i2c-core: Return ... |
1633 1634 1635 1636 1637 1638 |
int status; status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data); return (status < 0) ? status : data.byte; |
1da177e4c Linux-2.6.12-rc2 |
1639 |
} |
c05646069 i2c: i2c EXPORT_S... |
1640 |
EXPORT_SYMBOL(i2c_smbus_read_byte); |
1da177e4c Linux-2.6.12-rc2 |
1641 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1642 1643 1644 1645 1646 1647 1648 1649 |
/** * i2c_smbus_write_byte - SMBus "send byte" protocol * @client: Handle to slave device * @value: Byte to be sent * * This executes the SMBus "send byte" protocol, returning negative errno * else zero on success. */ |
0cc43a180 i2c: Constify i2c... |
1650 |
s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value) |
1da177e4c Linux-2.6.12-rc2 |
1651 |
{ |
7225acf4a i2c-core: Fix som... |
1652 |
return i2c_smbus_xfer(client->adapter, client->addr, client->flags, |
421ef47be [PATCH] i2c: SMBu... |
1653 |
I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL); |
1da177e4c Linux-2.6.12-rc2 |
1654 |
} |
c05646069 i2c: i2c EXPORT_S... |
1655 |
EXPORT_SYMBOL(i2c_smbus_write_byte); |
1da177e4c Linux-2.6.12-rc2 |
1656 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1657 1658 1659 1660 1661 1662 1663 1664 |
/** * i2c_smbus_read_byte_data - SMBus "read byte" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * * This executes the SMBus "read byte" protocol, returning negative errno * else a data byte received from the device. */ |
0cc43a180 i2c: Constify i2c... |
1665 |
s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command) |
1da177e4c Linux-2.6.12-rc2 |
1666 1667 |
{ union i2c_smbus_data data; |
24a5bb7b1 i2c-core: Return ... |
1668 1669 1670 1671 1672 1673 |
int status; status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_BYTE_DATA, &data); return (status < 0) ? status : data.byte; |
1da177e4c Linux-2.6.12-rc2 |
1674 |
} |
c05646069 i2c: i2c EXPORT_S... |
1675 |
EXPORT_SYMBOL(i2c_smbus_read_byte_data); |
1da177e4c Linux-2.6.12-rc2 |
1676 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1677 1678 1679 1680 1681 1682 1683 1684 1685 |
/** * i2c_smbus_write_byte_data - SMBus "write byte" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * @value: Byte being written * * This executes the SMBus "write byte" protocol, returning negative errno * else zero on success. */ |
0cc43a180 i2c: Constify i2c... |
1686 1687 |
s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command, u8 value) |
1da177e4c Linux-2.6.12-rc2 |
1688 1689 1690 |
{ union i2c_smbus_data data; data.byte = value; |
7225acf4a i2c-core: Fix som... |
1691 1692 1693 |
return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_BYTE_DATA, &data); |
1da177e4c Linux-2.6.12-rc2 |
1694 |
} |
c05646069 i2c: i2c EXPORT_S... |
1695 |
EXPORT_SYMBOL(i2c_smbus_write_byte_data); |
1da177e4c Linux-2.6.12-rc2 |
1696 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1697 1698 1699 1700 1701 1702 1703 1704 |
/** * i2c_smbus_read_word_data - SMBus "read word" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * * This executes the SMBus "read word" protocol, returning negative errno * else a 16-bit unsigned "word" received from the device. */ |
0cc43a180 i2c: Constify i2c... |
1705 |
s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command) |
1da177e4c Linux-2.6.12-rc2 |
1706 1707 |
{ union i2c_smbus_data data; |
24a5bb7b1 i2c-core: Return ... |
1708 1709 1710 1711 1712 1713 |
int status; status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_WORD_DATA, &data); return (status < 0) ? status : data.word; |
1da177e4c Linux-2.6.12-rc2 |
1714 |
} |
c05646069 i2c: i2c EXPORT_S... |
1715 |
EXPORT_SYMBOL(i2c_smbus_read_word_data); |
1da177e4c Linux-2.6.12-rc2 |
1716 |
|
a1cdedac6 i2c: Kerneldoc fo... |
1717 1718 1719 1720 1721 1722 1723 1724 1725 |
/** * i2c_smbus_write_word_data - SMBus "write word" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * @value: 16-bit "word" being written * * This executes the SMBus "write word" protocol, returning negative errno * else zero on success. */ |
0cc43a180 i2c: Constify i2c... |
1726 1727 |
s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command, u16 value) |
1da177e4c Linux-2.6.12-rc2 |
1728 1729 1730 |
{ union i2c_smbus_data data; data.word = value; |
7225acf4a i2c-core: Fix som... |
1731 1732 1733 |
return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_WORD_DATA, &data); |
1da177e4c Linux-2.6.12-rc2 |
1734 |
} |
c05646069 i2c: i2c EXPORT_S... |
1735 |
EXPORT_SYMBOL(i2c_smbus_write_word_data); |
1da177e4c Linux-2.6.12-rc2 |
1736 |
|
a64ec07d3 i2c: Document str... |
1737 |
/** |
596c88f46 i2c: Restore i2c_... |
1738 1739 1740 1741 1742 1743 1744 1745 |
* i2c_smbus_process_call - SMBus "process call" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * @value: 16-bit "word" being written * * This executes the SMBus "process call" protocol, returning negative errno * else a 16-bit unsigned "word" received from the device. */ |
0cc43a180 i2c: Constify i2c... |
1746 1747 |
s32 i2c_smbus_process_call(const struct i2c_client *client, u8 command, u16 value) |
596c88f46 i2c: Restore i2c_... |
1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 |
{ union i2c_smbus_data data; int status; data.word = value; status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_PROC_CALL, &data); return (status < 0) ? status : data.word; } EXPORT_SYMBOL(i2c_smbus_process_call); /** |
a1cdedac6 i2c: Kerneldoc fo... |
1761 |
* i2c_smbus_read_block_data - SMBus "block read" protocol |
a64ec07d3 i2c: Document str... |
1762 |
* @client: Handle to slave device |
a1cdedac6 i2c: Kerneldoc fo... |
1763 |
* @command: Byte interpreted by slave |
a64ec07d3 i2c: Document str... |
1764 1765 1766 |
* @values: Byte array into which data will be read; big enough to hold * the data returned by the slave. SMBus allows at most 32 bytes. * |
a1cdedac6 i2c: Kerneldoc fo... |
1767 1768 |
* This executes the SMBus "block read" protocol, returning negative errno * else the number of data bytes in the slave's response. |
a64ec07d3 i2c: Document str... |
1769 1770 1771 1772 1773 1774 |
* * Note that using this function requires that the client's adapter support * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality. Not all adapter drivers * support this; its emulation through I2C messaging relies on a specific * mechanism (I2C_M_RECV_LEN) which may not be implemented. */ |
0cc43a180 i2c: Constify i2c... |
1775 |
s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command, |
b86a1bc8e i2c: Restore i2c_... |
1776 1777 1778 |
u8 *values) { union i2c_smbus_data data; |
24a5bb7b1 i2c-core: Return ... |
1779 |
int status; |
b86a1bc8e i2c: Restore i2c_... |
1780 |
|
24a5bb7b1 i2c-core: Return ... |
1781 1782 1783 1784 1785 |
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_BLOCK_DATA, &data); if (status) return status; |
b86a1bc8e i2c: Restore i2c_... |
1786 1787 1788 1789 1790 |
memcpy(values, &data.block[1], data.block[0]); return data.block[0]; } EXPORT_SYMBOL(i2c_smbus_read_block_data); |
a1cdedac6 i2c: Kerneldoc fo... |
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 |
/** * i2c_smbus_write_block_data - SMBus "block write" protocol * @client: Handle to slave device * @command: Byte interpreted by slave * @length: Size of data block; SMBus allows at most 32 bytes * @values: Byte array which will be written. * * This executes the SMBus "block write" protocol, returning negative errno * else zero on success. */ |
0cc43a180 i2c: Constify i2c... |
1801 |
s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command, |
46f5ed753 [PATCH] i2c: Mark... |
1802 |
u8 length, const u8 *values) |
1da177e4c Linux-2.6.12-rc2 |
1803 1804 |
{ union i2c_smbus_data data; |
7656032b9 [PATCH] i2c: Spee... |
1805 |
|
1da177e4c Linux-2.6.12-rc2 |
1806 1807 |
if (length > I2C_SMBUS_BLOCK_MAX) length = I2C_SMBUS_BLOCK_MAX; |
1da177e4c Linux-2.6.12-rc2 |
1808 |
data.block[0] = length; |
7656032b9 [PATCH] i2c: Spee... |
1809 |
memcpy(&data.block[1], values, length); |
7225acf4a i2c-core: Fix som... |
1810 1811 1812 |
return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_BLOCK_DATA, &data); |
1da177e4c Linux-2.6.12-rc2 |
1813 |
} |
c05646069 i2c: i2c EXPORT_S... |
1814 |
EXPORT_SYMBOL(i2c_smbus_write_block_data); |
1da177e4c Linux-2.6.12-rc2 |
1815 1816 |
/* Returns the number of read bytes */ |
0cc43a180 i2c: Constify i2c... |
1817 |
s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command, |
4b2643d7d i2c: Fix the i2c_... |
1818 |
u8 length, u8 *values) |
1da177e4c Linux-2.6.12-rc2 |
1819 1820 |
{ union i2c_smbus_data data; |
24a5bb7b1 i2c-core: Return ... |
1821 |
int status; |
7656032b9 [PATCH] i2c: Spee... |
1822 |
|
4b2643d7d i2c: Fix the i2c_... |
1823 1824 1825 |
if (length > I2C_SMBUS_BLOCK_MAX) length = I2C_SMBUS_BLOCK_MAX; data.block[0] = length; |
24a5bb7b1 i2c-core: Return ... |
1826 1827 1828 1829 1830 |
status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command, I2C_SMBUS_I2C_BLOCK_DATA, &data); if (status < 0) return status; |
7656032b9 [PATCH] i2c: Spee... |
1831 1832 1833 |
memcpy(values, &data.block[1], data.block[0]); return data.block[0]; |
1da177e4c Linux-2.6.12-rc2 |
1834 |
} |
c05646069 i2c: i2c EXPORT_S... |
1835 |
EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data); |
1da177e4c Linux-2.6.12-rc2 |
1836 |
|
0cc43a180 i2c: Constify i2c... |
1837 |
s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command, |
46f5ed753 [PATCH] i2c: Mark... |
1838 |
u8 length, const u8 *values) |
21bbd6918 [PATCH] I2C: Resu... |
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 |
{ union i2c_smbus_data data; if (length > I2C_SMBUS_BLOCK_MAX) length = I2C_SMBUS_BLOCK_MAX; data.block[0] = length; memcpy(data.block + 1, values, length); return i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_WRITE, command, I2C_SMBUS_I2C_BLOCK_DATA, &data); } |
c05646069 i2c: i2c EXPORT_S... |
1850 |
EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data); |
21bbd6918 [PATCH] I2C: Resu... |
1851 |
|
438d6c2c0 i2c: Whitespace c... |
1852 |
/* Simulate a SMBus command using the i2c protocol |
1da177e4c Linux-2.6.12-rc2 |
1853 |
No checking of parameters is done! */ |
7225acf4a i2c-core: Fix som... |
1854 1855 1856 1857 |
static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data *data) |
1da177e4c Linux-2.6.12-rc2 |
1858 1859 1860 1861 1862 |
{ /* So we need to generate a series of msgs. In the case of writing, we need to use only one message; when reading, we need two. We initialize most things with sane defaults, to keep the code below somewhat simpler. */ |
5c50d1885 [PATCH] i2c: Seve... |
1863 1864 |
unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3]; unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2]; |
7225acf4a i2c-core: Fix som... |
1865 |
int num = read_write == I2C_SMBUS_READ ? 2 : 1; |
438d6c2c0 i2c: Whitespace c... |
1866 |
struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, |
1da177e4c Linux-2.6.12-rc2 |
1867 1868 1869 |
{ addr, flags | I2C_M_RD, 0, msgbuf1 } }; int i; |
421ef47be [PATCH] i2c: SMBu... |
1870 |
u8 partial_pec = 0; |
24a5bb7b1 i2c-core: Return ... |
1871 |
int status; |
1da177e4c Linux-2.6.12-rc2 |
1872 1873 |
msgbuf0[0] = command; |
7225acf4a i2c-core: Fix som... |
1874 |
switch (size) { |
1da177e4c Linux-2.6.12-rc2 |
1875 1876 1877 |
case I2C_SMBUS_QUICK: msg[0].len = 0; /* Special case: The read/write field is used as data */ |
f29d2e027 i2c: Fix misplace... |
1878 1879 |
msg[0].flags = flags | (read_write == I2C_SMBUS_READ ? I2C_M_RD : 0); |
1da177e4c Linux-2.6.12-rc2 |
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 |
num = 1; break; case I2C_SMBUS_BYTE: if (read_write == I2C_SMBUS_READ) { /* Special case: only a read! */ msg[0].flags = I2C_M_RD | flags; num = 1; } break; case I2C_SMBUS_BYTE_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = 1; else { msg[0].len = 2; msgbuf0[1] = data->byte; } break; case I2C_SMBUS_WORD_DATA: if (read_write == I2C_SMBUS_READ) msg[1].len = 2; else { |
7225acf4a i2c-core: Fix som... |
1901 |
msg[0].len = 3; |
1da177e4c Linux-2.6.12-rc2 |
1902 |
msgbuf0[1] = data->word & 0xff; |
7eff82c8b i2c-core: Drop us... |
1903 |
msgbuf0[2] = data->word >> 8; |
1da177e4c Linux-2.6.12-rc2 |
1904 1905 1906 1907 1908 1909 1910 1911 |
} break; case I2C_SMBUS_PROC_CALL: num = 2; /* Special case */ read_write = I2C_SMBUS_READ; msg[0].len = 3; msg[1].len = 2; msgbuf0[1] = data->word & 0xff; |
7eff82c8b i2c-core: Drop us... |
1912 |
msgbuf0[2] = data->word >> 8; |
1da177e4c Linux-2.6.12-rc2 |
1913 1914 |
break; case I2C_SMBUS_BLOCK_DATA: |
1da177e4c Linux-2.6.12-rc2 |
1915 |
if (read_write == I2C_SMBUS_READ) { |
209d27c3b i2c: Emulate SMBu... |
1916 1917 1918 |
msg[1].flags |= I2C_M_RECV_LEN; msg[1].len = 1; /* block length will be added by the underlying bus driver */ |
1da177e4c Linux-2.6.12-rc2 |
1919 1920 1921 |
} else { msg[0].len = data->block[0] + 2; if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) { |
24a5bb7b1 i2c-core: Return ... |
1922 1923 1924 1925 1926 |
dev_err(&adapter->dev, "Invalid block write size %d ", data->block[0]); return -EINVAL; |
1da177e4c Linux-2.6.12-rc2 |
1927 |
} |
5c50d1885 [PATCH] i2c: Seve... |
1928 |
for (i = 1; i < msg[0].len; i++) |
1da177e4c Linux-2.6.12-rc2 |
1929 1930 1931 1932 |
msgbuf0[i] = data->block[i-1]; } break; case I2C_SMBUS_BLOCK_PROC_CALL: |
209d27c3b i2c: Emulate SMBu... |
1933 1934 1935 |
num = 2; /* Another special case */ read_write = I2C_SMBUS_READ; if (data->block[0] > I2C_SMBUS_BLOCK_MAX) { |
24a5bb7b1 i2c-core: Return ... |
1936 1937 1938 |
dev_err(&adapter->dev, "Invalid block write size %d ", |
209d27c3b i2c: Emulate SMBu... |
1939 |
data->block[0]); |
24a5bb7b1 i2c-core: Return ... |
1940 |
return -EINVAL; |
209d27c3b i2c: Emulate SMBu... |
1941 1942 1943 1944 1945 1946 1947 1948 |
} msg[0].len = data->block[0] + 2; for (i = 1; i < msg[0].len; i++) msgbuf0[i] = data->block[i-1]; msg[1].flags |= I2C_M_RECV_LEN; msg[1].len = 1; /* block length will be added by the underlying bus driver */ break; |
1da177e4c Linux-2.6.12-rc2 |
1949 1950 |
case I2C_SMBUS_I2C_BLOCK_DATA: if (read_write == I2C_SMBUS_READ) { |
4b2643d7d i2c: Fix the i2c_... |
1951 |
msg[1].len = data->block[0]; |
1da177e4c Linux-2.6.12-rc2 |
1952 1953 |
} else { msg[0].len = data->block[0] + 1; |
30dac7469 [PATCH] i2c: Drop... |
1954 |
if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) { |
24a5bb7b1 i2c-core: Return ... |
1955 1956 1957 1958 1959 |
dev_err(&adapter->dev, "Invalid block write size %d ", data->block[0]); return -EINVAL; |
1da177e4c Linux-2.6.12-rc2 |
1960 1961 1962 1963 1964 1965 |
} for (i = 1; i <= data->block[0]; i++) msgbuf0[i] = data->block[i]; } break; default: |
24a5bb7b1 i2c-core: Return ... |
1966 1967 1968 |
dev_err(&adapter->dev, "Unsupported transaction %d ", size); return -EOPNOTSUPP; |
1da177e4c Linux-2.6.12-rc2 |
1969 |
} |
421ef47be [PATCH] i2c: SMBu... |
1970 1971 1972 1973 1974 |
i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK && size != I2C_SMBUS_I2C_BLOCK_DATA); if (i) { /* Compute PEC if first message is a write */ if (!(msg[0].flags & I2C_M_RD)) { |
438d6c2c0 i2c: Whitespace c... |
1975 |
if (num == 1) /* Write only */ |
421ef47be [PATCH] i2c: SMBu... |
1976 1977 1978 1979 1980 1981 |
i2c_smbus_add_pec(&msg[0]); else /* Write followed by read */ partial_pec = i2c_smbus_msg_pec(0, &msg[0]); } /* Ask for PEC if last message is a read */ if (msg[num-1].flags & I2C_M_RD) |
438d6c2c0 i2c: Whitespace c... |
1982 |
msg[num-1].len++; |
421ef47be [PATCH] i2c: SMBu... |
1983 |
} |
24a5bb7b1 i2c-core: Return ... |
1984 1985 1986 |
status = i2c_transfer(adapter, msg, num); if (status < 0) return status; |
1da177e4c Linux-2.6.12-rc2 |
1987 |
|
421ef47be [PATCH] i2c: SMBu... |
1988 1989 |
/* Check PEC if last message is a read */ if (i && (msg[num-1].flags & I2C_M_RD)) { |
24a5bb7b1 i2c-core: Return ... |
1990 1991 1992 |
status = i2c_smbus_check_pec(partial_pec, &msg[num-1]); if (status < 0) return status; |
421ef47be [PATCH] i2c: SMBu... |
1993 |
} |
1da177e4c Linux-2.6.12-rc2 |
1994 |
if (read_write == I2C_SMBUS_READ) |
7225acf4a i2c-core: Fix som... |
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 |
switch (size) { case I2C_SMBUS_BYTE: data->byte = msgbuf0[0]; break; case I2C_SMBUS_BYTE_DATA: data->byte = msgbuf1[0]; break; case I2C_SMBUS_WORD_DATA: case I2C_SMBUS_PROC_CALL: data->word = msgbuf1[0] | (msgbuf1[1] << 8); break; case I2C_SMBUS_I2C_BLOCK_DATA: for (i = 0; i < data->block[0]; i++) data->block[i+1] = msgbuf1[i]; break; case I2C_SMBUS_BLOCK_DATA: case I2C_SMBUS_BLOCK_PROC_CALL: for (i = 0; i < msgbuf1[0] + 1; i++) data->block[i] = msgbuf1[i]; break; |
1da177e4c Linux-2.6.12-rc2 |
2015 2016 2017 |
} return 0; } |
a1cdedac6 i2c: Kerneldoc fo... |
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 |
/** * i2c_smbus_xfer - execute SMBus protocol operations * @adapter: Handle to I2C bus * @addr: Address of SMBus slave on that bus * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC) * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE * @command: Byte interpreted by slave, for protocols which use such bytes * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL * @data: Data to be read or written * * This executes an SMBus protocol operation, and returns a negative * errno code else zero on success. */ |
09b8ce0a6 i2c-core: Some st... |
2031 |
s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags, |
a1cdedac6 i2c: Kerneldoc fo... |
2032 |
char read_write, u8 command, int protocol, |
09b8ce0a6 i2c-core: Some st... |
2033 |
union i2c_smbus_data *data) |
1da177e4c Linux-2.6.12-rc2 |
2034 |
{ |
66b650f04 i2c: Retry automa... |
2035 2036 |
unsigned long orig_jiffies; int try; |
1da177e4c Linux-2.6.12-rc2 |
2037 |
s32 res; |
1da177e4c Linux-2.6.12-rc2 |
2038 2039 |
flags &= I2C_M_TEN | I2C_CLIENT_PEC; |
1da177e4c Linux-2.6.12-rc2 |
2040 2041 |
if (adapter->algo->smbus_xfer) { |
fe61e07e9 i2c: Move adapter... |
2042 |
i2c_lock_adapter(adapter); |
66b650f04 i2c: Retry automa... |
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 |
/* Retry automatically on arbitration loss */ orig_jiffies = jiffies; for (res = 0, try = 0; try <= adapter->retries; try++) { res = adapter->algo->smbus_xfer(adapter, addr, flags, read_write, command, protocol, data); if (res != -EAGAIN) break; if (time_after(jiffies, orig_jiffies + adapter->timeout)) break; } |
fe61e07e9 i2c: Move adapter... |
2056 |
i2c_unlock_adapter(adapter); |
1da177e4c Linux-2.6.12-rc2 |
2057 |
} else |
7225acf4a i2c-core: Fix som... |
2058 |
res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write, |
a1cdedac6 i2c: Kerneldoc fo... |
2059 |
command, protocol, data); |
1da177e4c Linux-2.6.12-rc2 |
2060 |
|
1da177e4c Linux-2.6.12-rc2 |
2061 2062 |
return res; } |
1da177e4c Linux-2.6.12-rc2 |
2063 |
EXPORT_SYMBOL(i2c_smbus_xfer); |
1da177e4c Linux-2.6.12-rc2 |
2064 2065 2066 2067 |
MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>"); MODULE_DESCRIPTION("I2C-Bus main module"); MODULE_LICENSE("GPL"); |