1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2017 Red Hat, Inc 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/libps2.h> 11 #include <linux/i2c.h> 12 #include <linux/serio.h> 13 #include <linux/slab.h> 14 #include <linux/workqueue.h> 15 #include "psmouse.h" 16 17 struct psmouse_smbus_dev { 18 struct i2c_board_info board; 19 struct psmouse *psmouse; 20 struct i2c_client *client; 21 struct list_head node; 22 bool dead; 23 bool need_deactivate; 24 }; 25 26 static LIST_HEAD(psmouse_smbus_list); 27 static DEFINE_MUTEX(psmouse_smbus_mutex); 28 29 static struct workqueue_struct *psmouse_smbus_wq; 30 31 static void psmouse_smbus_check_adapter(struct i2c_adapter *adapter) 32 { 33 struct psmouse_smbus_dev *smbdev; 34 35 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_HOST_NOTIFY)) 36 return; 37 38 guard(mutex)(&psmouse_smbus_mutex); 39 40 list_for_each_entry(smbdev, &psmouse_smbus_list, node) { 41 if (smbdev->dead) 42 continue; 43 44 if (smbdev->client) 45 continue; 46 47 /* 48 * Here would be a good place to check if device is actually 49 * present, but it seems that SMBus will not respond unless we 50 * fully reset PS/2 connection. So cross our fingers, and try 51 * to switch over, hopefully our system will not have too many 52 * "host notify" I2C adapters. 53 */ 54 psmouse_dbg(smbdev->psmouse, 55 "SMBus candidate adapter appeared, triggering rescan\n"); 56 serio_rescan(smbdev->psmouse->ps2dev.serio); 57 } 58 } 59 60 static void psmouse_smbus_detach_i2c_client(struct i2c_client *client) 61 { 62 struct psmouse_smbus_dev *smbdev, *tmp; 63 64 guard(mutex)(&psmouse_smbus_mutex); 65 66 list_for_each_entry_safe(smbdev, tmp, &psmouse_smbus_list, node) { 67 if (smbdev->client != client) 68 continue; 69 70 kfree(client->dev.platform_data); 71 client->dev.platform_data = NULL; 72 73 if (!smbdev->dead) { 74 psmouse_dbg(smbdev->psmouse, 75 "Marking SMBus companion %s as gone\n", 76 dev_name(&smbdev->client->dev)); 77 smbdev->dead = true; 78 device_link_remove(&smbdev->client->dev, 79 &smbdev->psmouse->ps2dev.serio->dev); 80 serio_rescan(smbdev->psmouse->ps2dev.serio); 81 } else { 82 list_del(&smbdev->node); 83 kfree(smbdev); 84 } 85 } 86 } 87 88 static int psmouse_smbus_notifier_call(struct notifier_block *nb, 89 unsigned long action, void *data) 90 { 91 struct device *dev = data; 92 93 switch (action) { 94 case BUS_NOTIFY_ADD_DEVICE: 95 if (dev->type == &i2c_adapter_type) 96 psmouse_smbus_check_adapter(to_i2c_adapter(dev)); 97 break; 98 99 case BUS_NOTIFY_REMOVED_DEVICE: 100 if (dev->type == &i2c_client_type) 101 psmouse_smbus_detach_i2c_client(to_i2c_client(dev)); 102 break; 103 } 104 105 return 0; 106 } 107 108 static struct notifier_block psmouse_smbus_notifier = { 109 .notifier_call = psmouse_smbus_notifier_call, 110 }; 111 112 static psmouse_ret_t psmouse_smbus_process_byte(struct psmouse *psmouse) 113 { 114 return PSMOUSE_FULL_PACKET; 115 } 116 117 static int psmouse_smbus_reconnect(struct psmouse *psmouse) 118 { 119 struct psmouse_smbus_dev *smbdev = psmouse->private; 120 121 if (smbdev->need_deactivate) 122 psmouse_deactivate(psmouse); 123 124 return 0; 125 } 126 127 struct psmouse_smbus_removal_work { 128 struct work_struct work; 129 struct i2c_client *client; 130 }; 131 132 static void psmouse_smbus_remove_i2c_device(struct work_struct *work) 133 { 134 struct psmouse_smbus_removal_work *rwork = 135 container_of(work, struct psmouse_smbus_removal_work, work); 136 137 dev_dbg(&rwork->client->dev, "destroying SMBus companion device\n"); 138 i2c_unregister_device(rwork->client); 139 140 kfree(rwork); 141 } 142 143 /* 144 * This schedules removal of SMBus companion device. We have to do 145 * it in a separate tread to avoid deadlocking on psmouse_mutex in 146 * case the device has a trackstick (which is also driven by psmouse). 147 * 148 * Note that this may be racing with i2c adapter removal, but we 149 * can't do anything about that: i2c automatically destroys clients 150 * attached to an adapter that is being removed. This has to be 151 * fixed in i2c core. 152 */ 153 static void psmouse_smbus_schedule_remove(struct i2c_client *client) 154 { 155 struct psmouse_smbus_removal_work *rwork; 156 157 rwork = kzalloc(sizeof(*rwork), GFP_KERNEL); 158 if (rwork) { 159 INIT_WORK(&rwork->work, psmouse_smbus_remove_i2c_device); 160 rwork->client = client; 161 162 queue_work(psmouse_smbus_wq, &rwork->work); 163 } 164 } 165 166 static void psmouse_smbus_disconnect(struct psmouse *psmouse) 167 { 168 struct psmouse_smbus_dev *smbdev = psmouse->private; 169 170 guard(mutex)(&psmouse_smbus_mutex); 171 172 if (smbdev->dead) { 173 list_del(&smbdev->node); 174 kfree(smbdev); 175 } else { 176 smbdev->dead = true; 177 device_link_remove(&smbdev->client->dev, 178 &psmouse->ps2dev.serio->dev); 179 psmouse_dbg(smbdev->psmouse, 180 "posting removal request for SMBus companion %s\n", 181 dev_name(&smbdev->client->dev)); 182 psmouse_smbus_schedule_remove(smbdev->client); 183 } 184 185 psmouse->private = NULL; 186 } 187 188 static int psmouse_smbus_create_companion(struct device *dev, void *data) 189 { 190 struct psmouse_smbus_dev *smbdev = data; 191 unsigned short addr_list[] = { smbdev->board.addr, I2C_CLIENT_END }; 192 struct i2c_adapter *adapter; 193 struct i2c_client *client; 194 195 adapter = i2c_verify_adapter(dev); 196 if (!adapter) 197 return 0; 198 199 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_HOST_NOTIFY)) 200 return 0; 201 202 client = i2c_new_scanned_device(adapter, &smbdev->board, 203 addr_list, NULL); 204 if (IS_ERR(client)) 205 return 0; 206 207 /* We have our(?) device, stop iterating i2c bus. */ 208 smbdev->client = client; 209 return 1; 210 } 211 212 void psmouse_smbus_cleanup(struct psmouse *psmouse) 213 { 214 struct psmouse_smbus_dev *smbdev, *tmp; 215 216 guard(mutex)(&psmouse_smbus_mutex); 217 218 list_for_each_entry_safe(smbdev, tmp, &psmouse_smbus_list, node) { 219 if (psmouse == smbdev->psmouse) { 220 list_del(&smbdev->node); 221 kfree(smbdev); 222 } 223 } 224 } 225 226 int psmouse_smbus_init(struct psmouse *psmouse, 227 const struct i2c_board_info *board, 228 const void *pdata, size_t pdata_size, 229 bool need_deactivate, 230 bool leave_breadcrumbs) 231 { 232 struct psmouse_smbus_dev *smbdev; 233 int error; 234 235 smbdev = kzalloc(sizeof(*smbdev), GFP_KERNEL); 236 if (!smbdev) 237 return -ENOMEM; 238 239 smbdev->psmouse = psmouse; 240 smbdev->board = *board; 241 smbdev->need_deactivate = need_deactivate; 242 243 if (pdata) { 244 smbdev->board.platform_data = kmemdup(pdata, pdata_size, 245 GFP_KERNEL); 246 if (!smbdev->board.platform_data) { 247 kfree(smbdev); 248 return -ENOMEM; 249 } 250 } 251 252 if (need_deactivate) 253 psmouse_deactivate(psmouse); 254 255 psmouse->private = smbdev; 256 psmouse->protocol_handler = psmouse_smbus_process_byte; 257 psmouse->reconnect = psmouse_smbus_reconnect; 258 psmouse->fast_reconnect = psmouse_smbus_reconnect; 259 psmouse->disconnect = psmouse_smbus_disconnect; 260 psmouse->resync_time = 0; 261 262 scoped_guard(mutex, &psmouse_smbus_mutex) { 263 list_add_tail(&smbdev->node, &psmouse_smbus_list); 264 } 265 266 /* Bind to already existing adapters right away */ 267 error = i2c_for_each_dev(smbdev, psmouse_smbus_create_companion); 268 269 if (smbdev->client) { 270 /* We have our companion device */ 271 if (!device_link_add(&smbdev->client->dev, 272 &psmouse->ps2dev.serio->dev, 273 DL_FLAG_STATELESS)) 274 psmouse_warn(psmouse, 275 "failed to set up link with iSMBus companion %s\n", 276 dev_name(&smbdev->client->dev)); 277 return 0; 278 } 279 280 /* 281 * If we did not create i2c device we will not need platform 282 * data even if we are leaving breadcrumbs. 283 */ 284 kfree(smbdev->board.platform_data); 285 smbdev->board.platform_data = NULL; 286 287 if (error < 0 || !leave_breadcrumbs) { 288 scoped_guard(mutex, &psmouse_smbus_mutex) { 289 list_del(&smbdev->node); 290 } 291 292 kfree(smbdev); 293 } 294 295 return error < 0 ? error : -EAGAIN; 296 } 297 298 int __init psmouse_smbus_module_init(void) 299 { 300 int error; 301 302 psmouse_smbus_wq = alloc_workqueue("psmouse-smbus", 0, 0); 303 if (!psmouse_smbus_wq) 304 return -ENOMEM; 305 306 error = bus_register_notifier(&i2c_bus_type, &psmouse_smbus_notifier); 307 if (error) { 308 pr_err("failed to register i2c bus notifier: %d\n", error); 309 destroy_workqueue(psmouse_smbus_wq); 310 return error; 311 } 312 313 return 0; 314 } 315 316 void psmouse_smbus_module_exit(void) 317 { 318 bus_unregister_notifier(&i2c_bus_type, &psmouse_smbus_notifier); 319 destroy_workqueue(psmouse_smbus_wq); 320 } 321