Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 1 | /* |
| 2 | * i2c-smbus.c - SMBus extensions to the I2C protocol |
| 3 | * |
| 4 | * Copyright (C) 2008 David Brownell |
Jean Delvare | 7c81c60 | 2014-01-29 20:40:08 +0100 | [diff] [blame] | 5 | * Copyright (C) 2010 Jean Delvare <jdelvare@suse.de> |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 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. |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 16 | */ |
| 17 | |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 18 | #include <linux/device.h> |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 19 | #include <linux/i2c.h> |
| 20 | #include <linux/i2c-smbus.h> |
Wolfram Sang | 62c874a | 2016-02-20 23:33:39 +0100 | [diff] [blame] | 21 | #include <linux/interrupt.h> |
| 22 | #include <linux/kernel.h> |
| 23 | #include <linux/module.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 24 | #include <linux/slab.h> |
Wolfram Sang | 62c874a | 2016-02-20 23:33:39 +0100 | [diff] [blame] | 25 | #include <linux/workqueue.h> |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 26 | |
| 27 | struct i2c_smbus_alert { |
| 28 | unsigned int alert_edge_triggered:1; |
| 29 | int irq; |
| 30 | struct work_struct alert; |
| 31 | struct i2c_client *ara; /* Alert response address */ |
| 32 | }; |
| 33 | |
| 34 | struct alert_data { |
| 35 | unsigned short addr; |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 36 | enum i2c_alert_protocol type; |
| 37 | unsigned int data; |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 38 | }; |
| 39 | |
| 40 | /* If this is the alerting device, notify its driver */ |
| 41 | static int smbus_do_alert(struct device *dev, void *addrp) |
| 42 | { |
| 43 | struct i2c_client *client = i2c_verify_client(dev); |
| 44 | struct alert_data *data = addrp; |
Lars-Peter Clausen | 0acc2b3 | 2013-09-29 10:51:06 +0200 | [diff] [blame] | 45 | struct i2c_driver *driver; |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 46 | |
| 47 | if (!client || client->addr != data->addr) |
| 48 | return 0; |
| 49 | if (client->flags & I2C_CLIENT_TEN) |
| 50 | return 0; |
| 51 | |
| 52 | /* |
| 53 | * Drivers should either disable alerts, or provide at least |
Lars-Peter Clausen | 0acc2b3 | 2013-09-29 10:51:06 +0200 | [diff] [blame] | 54 | * a minimal handler. Lock so the driver won't change. |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 55 | */ |
Stephen Rothwell | f635a1e | 2010-03-01 16:04:45 +1100 | [diff] [blame] | 56 | device_lock(dev); |
Lars-Peter Clausen | 0acc2b3 | 2013-09-29 10:51:06 +0200 | [diff] [blame] | 57 | if (client->dev.driver) { |
| 58 | driver = to_i2c_driver(client->dev.driver); |
| 59 | if (driver->alert) |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 60 | driver->alert(client, data->type, data->data); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 61 | else |
| 62 | dev_warn(&client->dev, "no driver alert()!\n"); |
| 63 | } else |
| 64 | dev_dbg(&client->dev, "alert with no driver\n"); |
Stephen Rothwell | f635a1e | 2010-03-01 16:04:45 +1100 | [diff] [blame] | 65 | device_unlock(dev); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 66 | |
| 67 | /* Stop iterating after we find the device */ |
| 68 | return -EBUSY; |
| 69 | } |
| 70 | |
| 71 | /* |
| 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. |
| 74 | */ |
| 75 | static void smbus_alert(struct work_struct *work) |
| 76 | { |
| 77 | struct i2c_smbus_alert *alert; |
| 78 | struct i2c_client *ara; |
| 79 | unsigned short prev_addr = 0; /* Not a valid address */ |
| 80 | |
| 81 | alert = container_of(work, struct i2c_smbus_alert, alert); |
| 82 | ara = alert->ara; |
| 83 | |
| 84 | for (;;) { |
| 85 | s32 status; |
| 86 | struct alert_data data; |
| 87 | |
| 88 | /* |
| 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#. |
| 92 | * |
Shailendra Verma | edc9102 | 2015-05-19 20:09:41 +0530 | [diff] [blame] | 93 | * Note that SMBus 2.0 reserves 10-bit addresses for future |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 94 | * use. We neither handle them, nor try to use PEC here. |
| 95 | */ |
| 96 | status = i2c_smbus_read_byte(ara); |
| 97 | if (status < 0) |
| 98 | break; |
| 99 | |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 100 | data.data = status & 1; |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 101 | data.addr = status >> 1; |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 102 | data.type = I2C_PROTOCOL_SMBUS_ALERT; |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 103 | |
| 104 | if (data.addr == prev_addr) { |
| 105 | dev_warn(&ara->dev, "Duplicate SMBALERT# from dev " |
| 106 | "0x%02x, skipping\n", data.addr); |
| 107 | break; |
| 108 | } |
| 109 | dev_dbg(&ara->dev, "SMBALERT# from dev 0x%02x, flag %d\n", |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 110 | data.addr, data.data); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 111 | |
| 112 | /* Notify driver for the device which issued the alert */ |
| 113 | device_for_each_child(&ara->adapter->dev, &data, |
| 114 | smbus_do_alert); |
| 115 | prev_addr = data.addr; |
| 116 | } |
| 117 | |
| 118 | /* We handled all alerts; re-enable level-triggered IRQs */ |
| 119 | if (!alert->alert_edge_triggered) |
| 120 | enable_irq(alert->irq); |
| 121 | } |
| 122 | |
| 123 | static irqreturn_t smbalert_irq(int irq, void *d) |
| 124 | { |
| 125 | struct i2c_smbus_alert *alert = d; |
| 126 | |
| 127 | /* Disable level-triggered IRQs until we handle them */ |
| 128 | if (!alert->alert_edge_triggered) |
| 129 | disable_irq_nosync(irq); |
| 130 | |
| 131 | schedule_work(&alert->alert); |
| 132 | return IRQ_HANDLED; |
| 133 | } |
| 134 | |
| 135 | /* Setup SMBALERT# infrastructure */ |
| 136 | static int smbalert_probe(struct i2c_client *ara, |
| 137 | const struct i2c_device_id *id) |
| 138 | { |
Jingoo Han | 6d4028c | 2013-07-30 16:59:33 +0900 | [diff] [blame] | 139 | struct i2c_smbus_alert_setup *setup = dev_get_platdata(&ara->dev); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 140 | struct i2c_smbus_alert *alert; |
| 141 | struct i2c_adapter *adapter = ara->adapter; |
| 142 | int res; |
| 143 | |
Julia Lawall | 71b5784 | 2012-10-05 22:23:52 +0200 | [diff] [blame] | 144 | alert = devm_kzalloc(&ara->dev, sizeof(struct i2c_smbus_alert), |
| 145 | GFP_KERNEL); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 146 | if (!alert) |
| 147 | return -ENOMEM; |
| 148 | |
| 149 | alert->alert_edge_triggered = setup->alert_edge_triggered; |
| 150 | alert->irq = setup->irq; |
| 151 | INIT_WORK(&alert->alert, smbus_alert); |
| 152 | alert->ara = ara; |
| 153 | |
| 154 | if (setup->irq > 0) { |
| 155 | res = devm_request_irq(&ara->dev, setup->irq, smbalert_irq, |
| 156 | 0, "smbus_alert", alert); |
Julia Lawall | 71b5784 | 2012-10-05 22:23:52 +0200 | [diff] [blame] | 157 | if (res) |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 158 | return res; |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | i2c_set_clientdata(ara, alert); |
| 162 | dev_info(&adapter->dev, "supports SMBALERT#, %s trigger\n", |
| 163 | setup->alert_edge_triggered ? "edge" : "level"); |
| 164 | |
| 165 | return 0; |
| 166 | } |
| 167 | |
Julia Lawall | 71b5784 | 2012-10-05 22:23:52 +0200 | [diff] [blame] | 168 | /* IRQ and memory resources are managed so they are freed automatically */ |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 169 | static int smbalert_remove(struct i2c_client *ara) |
| 170 | { |
| 171 | struct i2c_smbus_alert *alert = i2c_get_clientdata(ara); |
| 172 | |
| 173 | cancel_work_sync(&alert->alert); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 174 | return 0; |
| 175 | } |
| 176 | |
| 177 | static const struct i2c_device_id smbalert_ids[] = { |
| 178 | { "smbus_alert", 0 }, |
| 179 | { /* LIST END */ } |
| 180 | }; |
| 181 | MODULE_DEVICE_TABLE(i2c, smbalert_ids); |
| 182 | |
| 183 | static struct i2c_driver smbalert_driver = { |
| 184 | .driver = { |
| 185 | .name = "smbus_alert", |
| 186 | }, |
| 187 | .probe = smbalert_probe, |
| 188 | .remove = smbalert_remove, |
| 189 | .id_table = smbalert_ids, |
| 190 | }; |
| 191 | |
| 192 | /** |
| 193 | * i2c_setup_smbus_alert - Setup SMBus alert support |
| 194 | * @adapter: the target adapter |
| 195 | * @setup: setup data for the SMBus alert handler |
| 196 | * Context: can sleep |
| 197 | * |
| 198 | * Setup handling of the SMBus alert protocol on a given I2C bus segment. |
| 199 | * |
| 200 | * Handling can be done either through our IRQ handler, or by the |
| 201 | * adapter (from its handler, periodic polling, or whatever). |
| 202 | * |
| 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. |
| 207 | * |
| 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. |
| 211 | */ |
| 212 | struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter, |
| 213 | struct i2c_smbus_alert_setup *setup) |
| 214 | { |
| 215 | struct i2c_board_info ara_board_info = { |
| 216 | I2C_BOARD_INFO("smbus_alert", 0x0c), |
| 217 | .platform_data = setup, |
| 218 | }; |
| 219 | |
| 220 | return i2c_new_device(adapter, &ara_board_info); |
| 221 | } |
| 222 | EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert); |
| 223 | |
| 224 | /** |
| 225 | * i2c_handle_smbus_alert - Handle an SMBus alert |
| 226 | * @ara: the ARA client on the relevant adapter |
| 227 | * Context: can't sleep |
| 228 | * |
| 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. |
| 232 | * |
| 233 | * It is assumed that ara is a valid i2c client previously returned by |
| 234 | * i2c_setup_smbus_alert(). |
| 235 | */ |
| 236 | int i2c_handle_smbus_alert(struct i2c_client *ara) |
| 237 | { |
| 238 | struct i2c_smbus_alert *alert = i2c_get_clientdata(ara); |
| 239 | |
| 240 | return schedule_work(&alert->alert); |
| 241 | } |
| 242 | EXPORT_SYMBOL_GPL(i2c_handle_smbus_alert); |
| 243 | |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 244 | static void smbus_host_notify_work(struct work_struct *work) |
| 245 | { |
| 246 | struct alert_data alert; |
| 247 | struct i2c_adapter *adapter; |
| 248 | unsigned long flags; |
| 249 | u16 payload; |
| 250 | u8 addr; |
| 251 | struct smbus_host_notify *data; |
| 252 | |
| 253 | data = container_of(work, struct smbus_host_notify, work); |
| 254 | |
| 255 | spin_lock_irqsave(&data->lock, flags); |
| 256 | payload = data->payload; |
| 257 | addr = data->addr; |
| 258 | adapter = data->adapter; |
| 259 | |
| 260 | /* clear the pending bit and release the spinlock */ |
| 261 | data->pending = false; |
| 262 | spin_unlock_irqrestore(&data->lock, flags); |
| 263 | |
| 264 | if (!adapter || !addr) |
| 265 | return; |
| 266 | |
| 267 | alert.type = I2C_PROTOCOL_SMBUS_HOST_NOTIFY; |
| 268 | alert.addr = addr; |
| 269 | alert.data = payload; |
| 270 | |
| 271 | device_for_each_child(&adapter->dev, &alert, smbus_do_alert); |
| 272 | } |
| 273 | |
| 274 | /** |
| 275 | * i2c_setup_smbus_host_notify - Allocate a new smbus_host_notify for the given |
| 276 | * I2C adapter. |
| 277 | * @adapter: the adapter we want to associate a Host Notify function |
| 278 | * |
| 279 | * Returns a struct smbus_host_notify pointer on success, and NULL on failure. |
| 280 | * The resulting smbus_host_notify must not be freed afterwards, it is a |
| 281 | * managed resource already. |
| 282 | */ |
| 283 | struct smbus_host_notify *i2c_setup_smbus_host_notify(struct i2c_adapter *adap) |
| 284 | { |
| 285 | struct smbus_host_notify *host_notify; |
| 286 | |
| 287 | host_notify = devm_kzalloc(&adap->dev, sizeof(struct smbus_host_notify), |
| 288 | GFP_KERNEL); |
| 289 | if (!host_notify) |
| 290 | return NULL; |
| 291 | |
| 292 | host_notify->adapter = adap; |
| 293 | |
| 294 | spin_lock_init(&host_notify->lock); |
| 295 | INIT_WORK(&host_notify->work, smbus_host_notify_work); |
| 296 | |
| 297 | return host_notify; |
| 298 | } |
| 299 | EXPORT_SYMBOL_GPL(i2c_setup_smbus_host_notify); |
| 300 | |
| 301 | /** |
| 302 | * i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct |
| 303 | * I2C client. |
| 304 | * @host_notify: the struct host_notify attached to the relevant adapter |
Jean Delvare | 1847bbd | 2016-07-16 15:45:23 +0200 | [diff] [blame] | 305 | * @addr: the I2C address of the notifying device |
| 306 | * @data: the payload of the notification |
Benjamin Tissoires | e456cd3 | 2016-06-09 16:53:48 +0200 | [diff] [blame] | 307 | * Context: can't sleep |
| 308 | * |
| 309 | * Helper function to be called from an I2C bus driver's interrupt |
| 310 | * handler. It will schedule the Host Notify work, in turn calling the |
| 311 | * corresponding I2C device driver's alert function. |
| 312 | * |
| 313 | * host_notify should be a valid pointer previously returned by |
| 314 | * i2c_setup_smbus_host_notify(). |
| 315 | */ |
| 316 | int i2c_handle_smbus_host_notify(struct smbus_host_notify *host_notify, |
| 317 | unsigned short addr, unsigned int data) |
| 318 | { |
| 319 | unsigned long flags; |
| 320 | struct i2c_adapter *adapter; |
| 321 | |
| 322 | if (!host_notify || !host_notify->adapter) |
| 323 | return -EINVAL; |
| 324 | |
| 325 | adapter = host_notify->adapter; |
| 326 | |
| 327 | spin_lock_irqsave(&host_notify->lock, flags); |
| 328 | |
| 329 | if (host_notify->pending) { |
| 330 | spin_unlock_irqrestore(&host_notify->lock, flags); |
| 331 | dev_warn(&adapter->dev, "Host Notify already scheduled.\n"); |
| 332 | return -EBUSY; |
| 333 | } |
| 334 | |
| 335 | host_notify->payload = data; |
| 336 | host_notify->addr = addr; |
| 337 | |
| 338 | /* Mark that there is a pending notification and release the lock */ |
| 339 | host_notify->pending = true; |
| 340 | spin_unlock_irqrestore(&host_notify->lock, flags); |
| 341 | |
| 342 | return schedule_work(&host_notify->work); |
| 343 | } |
| 344 | EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify); |
| 345 | |
Fabio Estevam | fda2f4a | 2012-07-24 14:13:57 +0200 | [diff] [blame] | 346 | module_i2c_driver(smbalert_driver); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 347 | |
Jean Delvare | 7c81c60 | 2014-01-29 20:40:08 +0100 | [diff] [blame] | 348 | MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>"); |
Jean Delvare | b5527a7 | 2010-03-02 12:23:42 +0100 | [diff] [blame] | 349 | MODULE_DESCRIPTION("SMBus protocol extensions support"); |
| 350 | MODULE_LICENSE("GPL"); |