Root/
1 | /* |
2 | * i2c-smbus.c - SMBus extensions to the I2C protocol |
3 | * |
4 | * Copyright (C) 2008 David Brownell |
5 | * Copyright (C) 2010 Jean Delvare <khali@linux-fr.org> |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify |
8 | * it under the terms of the GNU General Public License as published by |
9 | * the Free Software Foundation; either version 2 of the License, or |
10 | * (at your option) any later version. |
11 | * |
12 | * This program is distributed in the hope that it will be useful, |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
15 | * GNU General Public License for more details. |
16 | * |
17 | * You should have received a copy of the GNU General Public License |
18 | * along with this program; if not, write to the Free Software |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
20 | * MA 02110-1301 USA. |
21 | */ |
22 | |
23 | #include <linux/kernel.h> |
24 | #include <linux/module.h> |
25 | #include <linux/device.h> |
26 | #include <linux/interrupt.h> |
27 | #include <linux/workqueue.h> |
28 | #include <linux/i2c.h> |
29 | #include <linux/i2c-smbus.h> |
30 | #include <linux/slab.h> |
31 | |
32 | struct i2c_smbus_alert { |
33 | unsigned int alert_edge_triggered:1; |
34 | int irq; |
35 | struct work_struct alert; |
36 | struct i2c_client *ara; /* Alert response address */ |
37 | }; |
38 | |
39 | struct alert_data { |
40 | unsigned short addr; |
41 | u8 flag:1; |
42 | }; |
43 | |
44 | /* If this is the alerting device, notify its driver */ |
45 | static int smbus_do_alert(struct device *dev, void *addrp) |
46 | { |
47 | struct i2c_client *client = i2c_verify_client(dev); |
48 | struct alert_data *data = addrp; |
49 | |
50 | if (!client || client->addr != data->addr) |
51 | return 0; |
52 | if (client->flags & I2C_CLIENT_TEN) |
53 | return 0; |
54 | |
55 | /* |
56 | * Drivers should either disable alerts, or provide at least |
57 | * a minimal handler. Lock so client->driver won't change. |
58 | */ |
59 | device_lock(dev); |
60 | if (client->driver) { |
61 | if (client->driver->alert) |
62 | client->driver->alert(client, data->flag); |
63 | else |
64 | dev_warn(&client->dev, "no driver alert()!\n"); |
65 | } else |
66 | dev_dbg(&client->dev, "alert with no driver\n"); |
67 | device_unlock(dev); |
68 | |
69 | /* Stop iterating after we find the device */ |
70 | return -EBUSY; |
71 | } |
72 | |
73 | /* |
74 | * The alert IRQ handler needs to hand work off to a task which can issue |
75 | * SMBus calls, because those sleeping calls can't be made in IRQ context. |
76 | */ |
77 | static void smbus_alert(struct work_struct *work) |
78 | { |
79 | struct i2c_smbus_alert *alert; |
80 | struct i2c_client *ara; |
81 | unsigned short prev_addr = 0; /* Not a valid address */ |
82 | |
83 | alert = container_of(work, struct i2c_smbus_alert, alert); |
84 | ara = alert->ara; |
85 | |
86 | for (;;) { |
87 | s32 status; |
88 | struct alert_data data; |
89 | |
90 | /* |
91 | * Devices with pending alerts reply in address order, low |
92 | * to high, because of slave transmit arbitration. After |
93 | * responding, an SMBus device stops asserting SMBALERT#. |
94 | * |
95 | * Note that SMBus 2.0 reserves 10-bit addresess for future |
96 | * use. We neither handle them, nor try to use PEC here. |
97 | */ |
98 | status = i2c_smbus_read_byte(ara); |
99 | if (status < 0) |
100 | break; |
101 | |
102 | data.flag = status & 1; |
103 | data.addr = status >> 1; |
104 | |
105 | if (data.addr == prev_addr) { |
106 | dev_warn(&ara->dev, "Duplicate SMBALERT# from dev " |
107 | "0x%02x, skipping\n", data.addr); |
108 | break; |
109 | } |
110 | dev_dbg(&ara->dev, "SMBALERT# from dev 0x%02x, flag %d\n", |
111 | data.addr, data.flag); |
112 | |
113 | /* Notify driver for the device which issued the alert */ |
114 | device_for_each_child(&ara->adapter->dev, &data, |
115 | smbus_do_alert); |
116 | prev_addr = data.addr; |
117 | } |
118 | |
119 | /* We handled all alerts; re-enable level-triggered IRQs */ |
120 | if (!alert->alert_edge_triggered) |
121 | enable_irq(alert->irq); |
122 | } |
123 | |
124 | static irqreturn_t smbalert_irq(int irq, void *d) |
125 | { |
126 | struct i2c_smbus_alert *alert = d; |
127 | |
128 | /* Disable level-triggered IRQs until we handle them */ |
129 | if (!alert->alert_edge_triggered) |
130 | disable_irq_nosync(irq); |
131 | |
132 | schedule_work(&alert->alert); |
133 | return IRQ_HANDLED; |
134 | } |
135 | |
136 | /* Setup SMBALERT# infrastructure */ |
137 | static int smbalert_probe(struct i2c_client *ara, |
138 | const struct i2c_device_id *id) |
139 | { |
140 | struct i2c_smbus_alert_setup *setup = ara->dev.platform_data; |
141 | struct i2c_smbus_alert *alert; |
142 | struct i2c_adapter *adapter = ara->adapter; |
143 | int res; |
144 | |
145 | alert = devm_kzalloc(&ara->dev, sizeof(struct i2c_smbus_alert), |
146 | GFP_KERNEL); |
147 | if (!alert) |
148 | return -ENOMEM; |
149 | |
150 | alert->alert_edge_triggered = setup->alert_edge_triggered; |
151 | alert->irq = setup->irq; |
152 | INIT_WORK(&alert->alert, smbus_alert); |
153 | alert->ara = ara; |
154 | |
155 | if (setup->irq > 0) { |
156 | res = devm_request_irq(&ara->dev, setup->irq, smbalert_irq, |
157 | 0, "smbus_alert", alert); |
158 | if (res) |
159 | return res; |
160 | } |
161 | |
162 | i2c_set_clientdata(ara, alert); |
163 | dev_info(&adapter->dev, "supports SMBALERT#, %s trigger\n", |
164 | setup->alert_edge_triggered ? "edge" : "level"); |
165 | |
166 | return 0; |
167 | } |
168 | |
169 | /* IRQ and memory resources are managed so they are freed automatically */ |
170 | static int smbalert_remove(struct i2c_client *ara) |
171 | { |
172 | struct i2c_smbus_alert *alert = i2c_get_clientdata(ara); |
173 | |
174 | cancel_work_sync(&alert->alert); |
175 | return 0; |
176 | } |
177 | |
178 | static const struct i2c_device_id smbalert_ids[] = { |
179 | { "smbus_alert", 0 }, |
180 | { /* LIST END */ } |
181 | }; |
182 | MODULE_DEVICE_TABLE(i2c, smbalert_ids); |
183 | |
184 | static struct i2c_driver smbalert_driver = { |
185 | .driver = { |
186 | .name = "smbus_alert", |
187 | }, |
188 | .probe = smbalert_probe, |
189 | .remove = smbalert_remove, |
190 | .id_table = smbalert_ids, |
191 | }; |
192 | |
193 | /** |
194 | * i2c_setup_smbus_alert - Setup SMBus alert support |
195 | * @adapter: the target adapter |
196 | * @setup: setup data for the SMBus alert handler |
197 | * Context: can sleep |
198 | * |
199 | * Setup handling of the SMBus alert protocol on a given I2C bus segment. |
200 | * |
201 | * Handling can be done either through our IRQ handler, or by the |
202 | * adapter (from its handler, periodic polling, or whatever). |
203 | * |
204 | * NOTE that if we manage the IRQ, we *MUST* know if it's level or |
205 | * edge triggered in order to hand it to the workqueue correctly. |
206 | * If triggering the alert seems to wedge the system, you probably |
207 | * should have said it's level triggered. |
208 | * |
209 | * This returns the ara client, which should be saved for later use with |
210 | * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL |
211 | * to indicate an error. |
212 | */ |
213 | struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter, |
214 | struct i2c_smbus_alert_setup *setup) |
215 | { |
216 | struct i2c_board_info ara_board_info = { |
217 | I2C_BOARD_INFO("smbus_alert", 0x0c), |
218 | .platform_data = setup, |
219 | }; |
220 | |
221 | return i2c_new_device(adapter, &ara_board_info); |
222 | } |
223 | EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert); |
224 | |
225 | /** |
226 | * i2c_handle_smbus_alert - Handle an SMBus alert |
227 | * @ara: the ARA client on the relevant adapter |
228 | * Context: can't sleep |
229 | * |
230 | * Helper function to be called from an I2C bus driver's interrupt |
231 | * handler. It will schedule the alert work, in turn calling the |
232 | * corresponding I2C device driver's alert function. |
233 | * |
234 | * It is assumed that ara is a valid i2c client previously returned by |
235 | * i2c_setup_smbus_alert(). |
236 | */ |
237 | int i2c_handle_smbus_alert(struct i2c_client *ara) |
238 | { |
239 | struct i2c_smbus_alert *alert = i2c_get_clientdata(ara); |
240 | |
241 | return schedule_work(&alert->alert); |
242 | } |
243 | EXPORT_SYMBOL_GPL(i2c_handle_smbus_alert); |
244 | |
245 | module_i2c_driver(smbalert_driver); |
246 | |
247 | MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); |
248 | MODULE_DESCRIPTION("SMBus protocol extensions support"); |
249 | MODULE_LICENSE("GPL"); |
250 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9