2 * i2c-smbus.c - SMBus extensions to the I2C protocol
4 * Copyright (C) 2008 David Brownell
5 * Copyright (C) 2010 Jean Delvare <jdelvare@suse.de>
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.
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.
18 #include <linux/device.h>
19 #include <linux/i2c.h>
20 #include <linux/i2c-smbus.h>
21 #include <linux/interrupt.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/workqueue.h>
27 struct i2c_smbus_alert
{
28 unsigned int alert_edge_triggered
:1;
30 struct work_struct alert
;
31 struct i2c_client
*ara
; /* Alert response address */
36 enum i2c_alert_protocol type
;
40 /* If this is the alerting device, notify its driver */
41 static int smbus_do_alert(struct device
*dev
, void *addrp
)
43 struct i2c_client
*client
= i2c_verify_client(dev
);
44 struct alert_data
*data
= addrp
;
45 struct i2c_driver
*driver
;
47 if (!client
|| client
->addr
!= data
->addr
)
49 if (client
->flags
& I2C_CLIENT_TEN
)
53 * Drivers should either disable alerts, or provide at least
54 * a minimal handler. Lock so the driver won't change.
57 if (client
->dev
.driver
) {
58 driver
= to_i2c_driver(client
->dev
.driver
);
60 driver
->alert(client
, data
->type
, data
->data
);
62 dev_warn(&client
->dev
, "no driver alert()!\n");
64 dev_dbg(&client
->dev
, "alert with no driver\n");
67 /* Stop iterating after we find the device */
72 * The alert IRQ handler needs to hand work off to a task which can issue
73 * SMBus calls, because those sleeping calls can't be made in IRQ context.
75 static void smbus_alert(struct work_struct
*work
)
77 struct i2c_smbus_alert
*alert
;
78 struct i2c_client
*ara
;
79 unsigned short prev_addr
= 0; /* Not a valid address */
81 alert
= container_of(work
, struct i2c_smbus_alert
, alert
);
86 struct alert_data data
;
89 * Devices with pending alerts reply in address order, low
90 * to high, because of slave transmit arbitration. After
91 * responding, an SMBus device stops asserting SMBALERT#.
93 * Note that SMBus 2.0 reserves 10-bit addresses for future
94 * use. We neither handle them, nor try to use PEC here.
96 status
= i2c_smbus_read_byte(ara
);
100 data
.data
= status
& 1;
101 data
.addr
= status
>> 1;
102 data
.type
= I2C_PROTOCOL_SMBUS_ALERT
;
104 if (data
.addr
== prev_addr
) {
105 dev_warn(&ara
->dev
, "Duplicate SMBALERT# from dev "
106 "0x%02x, skipping\n", data
.addr
);
109 dev_dbg(&ara
->dev
, "SMBALERT# from dev 0x%02x, flag %d\n",
110 data
.addr
, data
.data
);
112 /* Notify driver for the device which issued the alert */
113 device_for_each_child(&ara
->adapter
->dev
, &data
,
115 prev_addr
= data
.addr
;
118 /* We handled all alerts; re-enable level-triggered IRQs */
119 if (!alert
->alert_edge_triggered
)
120 enable_irq(alert
->irq
);
123 static irqreturn_t
smbalert_irq(int irq
, void *d
)
125 struct i2c_smbus_alert
*alert
= d
;
127 /* Disable level-triggered IRQs until we handle them */
128 if (!alert
->alert_edge_triggered
)
129 disable_irq_nosync(irq
);
131 schedule_work(&alert
->alert
);
135 /* Setup SMBALERT# infrastructure */
136 static int smbalert_probe(struct i2c_client
*ara
,
137 const struct i2c_device_id
*id
)
139 struct i2c_smbus_alert_setup
*setup
= dev_get_platdata(&ara
->dev
);
140 struct i2c_smbus_alert
*alert
;
141 struct i2c_adapter
*adapter
= ara
->adapter
;
144 alert
= devm_kzalloc(&ara
->dev
, sizeof(struct i2c_smbus_alert
),
149 alert
->alert_edge_triggered
= setup
->alert_edge_triggered
;
150 alert
->irq
= setup
->irq
;
151 INIT_WORK(&alert
->alert
, smbus_alert
);
154 if (setup
->irq
> 0) {
155 res
= devm_request_irq(&ara
->dev
, setup
->irq
, smbalert_irq
,
156 0, "smbus_alert", alert
);
161 i2c_set_clientdata(ara
, alert
);
162 dev_info(&adapter
->dev
, "supports SMBALERT#, %s trigger\n",
163 setup
->alert_edge_triggered
? "edge" : "level");
168 /* IRQ and memory resources are managed so they are freed automatically */
169 static int smbalert_remove(struct i2c_client
*ara
)
171 struct i2c_smbus_alert
*alert
= i2c_get_clientdata(ara
);
173 cancel_work_sync(&alert
->alert
);
177 static const struct i2c_device_id smbalert_ids
[] = {
178 { "smbus_alert", 0 },
181 MODULE_DEVICE_TABLE(i2c
, smbalert_ids
);
183 static struct i2c_driver smbalert_driver
= {
185 .name
= "smbus_alert",
187 .probe
= smbalert_probe
,
188 .remove
= smbalert_remove
,
189 .id_table
= smbalert_ids
,
193 * i2c_setup_smbus_alert - Setup SMBus alert support
194 * @adapter: the target adapter
195 * @setup: setup data for the SMBus alert handler
198 * Setup handling of the SMBus alert protocol on a given I2C bus segment.
200 * Handling can be done either through our IRQ handler, or by the
201 * adapter (from its handler, periodic polling, or whatever).
203 * NOTE that if we manage the IRQ, we *MUST* know if it's level or
204 * edge triggered in order to hand it to the workqueue correctly.
205 * If triggering the alert seems to wedge the system, you probably
206 * should have said it's level triggered.
208 * This returns the ara client, which should be saved for later use with
209 * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL
210 * to indicate an error.
212 struct i2c_client
*i2c_setup_smbus_alert(struct i2c_adapter
*adapter
,
213 struct i2c_smbus_alert_setup
*setup
)
215 struct i2c_board_info ara_board_info
= {
216 I2C_BOARD_INFO("smbus_alert", 0x0c),
217 .platform_data
= setup
,
220 return i2c_new_device(adapter
, &ara_board_info
);
222 EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert
);
225 * i2c_handle_smbus_alert - Handle an SMBus alert
226 * @ara: the ARA client on the relevant adapter
227 * Context: can't sleep
229 * Helper function to be called from an I2C bus driver's interrupt
230 * handler. It will schedule the alert work, in turn calling the
231 * corresponding I2C device driver's alert function.
233 * It is assumed that ara is a valid i2c client previously returned by
234 * i2c_setup_smbus_alert().
236 int i2c_handle_smbus_alert(struct i2c_client
*ara
)
238 struct i2c_smbus_alert
*alert
= i2c_get_clientdata(ara
);
240 return schedule_work(&alert
->alert
);
242 EXPORT_SYMBOL_GPL(i2c_handle_smbus_alert
);
244 module_i2c_driver(smbalert_driver
);
246 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
247 MODULE_DESCRIPTION("SMBus protocol extensions support");
248 MODULE_LICENSE("GPL");