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 mutex_lock(&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 mutex_unlock(&psmouse_smbus_mutex); 60 } 61 62 static void psmouse_smbus_detach_i2c_client(struct i2c_client *client) 63 { 64 struct psmouse_smbus_dev *smbdev, *tmp; 65 66 mutex_lock(&psmouse_smbus_mutex); 67 68 list_for_each_entry_safe(smbdev, tmp, &psmouse_smbus_list, node) { 69 if (smbdev->client != client) 70 continue; 71 72 kfree(client->dev.platform_data); 73 client->dev.platform_data = NULL; 74 75 if (!smbdev->dead) { 76 psmouse_dbg(smbdev->psmouse, 77 "Marking SMBus companion %s as gone\n", 78 dev_name(&smbdev->client->dev)); 79 smbdev->dead = true; 80 device_link_remove(&smbdev->client->dev, 81 &smbdev->psmouse->ps2dev.serio->dev); 82 serio_rescan(smbdev->psmouse->ps2dev.serio); 83 } else { 84 list_del(&smbdev->node); 85 kfree(smbdev); 86 } 87 } 88 89 mutex_unlock(&psmouse_smbus_mutex); 90 } 91 92 static int psmouse_smbus_notifier_call(struct notifier_block *nb, 93 unsigned long action, void *data) 94 { 95 struct device *dev = data; 96 97 switch (action) { 98 case BUS_NOTIFY_ADD_DEVICE: 99 if (dev->type == &i2c_adapter_type) 100 psmouse_smbus_check_adapter(to_i2c_adapter(dev)); 101 break; 102 103 case BUS_NOTIFY_REMOVED_DEVICE: 104 if (dev->type == &i2c_client_type) 105 psmouse_smbus_detach_i2c_client(to_i2c_client(dev)); 106 break; 107 } 108 109 return 0; 110 } 111 112 static struct notifier_block psmouse_smbus_notifier = { 113 .notifier_call = psmouse_smbus_notifier_call, 114 }; 115 116 static psmouse_ret_t psmouse_smbus_process_byte(struct psmouse *psmouse) 117 { 118 return PSMOUSE_FULL_PACKET; 119 } 120 121 static int psmouse_smbus_reconnect(struct psmouse *psmouse) 122 { 123 struct psmouse_smbus_dev *smbdev = psmouse->private; 124 125 if (smbdev->need_deactivate) 126 psmouse_deactivate(psmouse); 127 128 return 0; 129 } 130 131 struct psmouse_smbus_removal_work { 132 struct work_struct work; 133 struct i2c_client *client; 134 }; 135 136 static void psmouse_smbus_remove_i2c_device(struct work_struct *work) 137 { 138 struct psmouse_smbus_removal_work *rwork = 139 container_of(work, struct psmouse_smbus_removal_work, work); 140 141 dev_dbg(&rwork->client->dev, "destroying SMBus companion device\n"); 142 i2c_unregister_device(rwork->client); 143 144 kfree(rwork); 145 } 146 147 /* 148 * This schedules removal of SMBus companion device. We have to do 149 * it in a separate tread to avoid deadlocking on psmouse_mutex in 150 * case the device has a trackstick (which is also driven by psmouse). 151 * 152 * Note that this may be racing with i2c adapter removal, but we 153 * can't do anything about that: i2c automatically destroys clients 154 * attached to an adapter that is being removed. This has to be 155 * fixed in i2c core. 156 */ 157 static void psmouse_smbus_schedule_remove(struct i2c_client *client) 158 { 159 struct psmouse_smbus_removal_work *rwork; 160 161 rwork = kzalloc(sizeof(*rwork), GFP_KERNEL); 162 if (rwork) { 163 INIT_WORK(&rwork->work, psmouse_smbus_remove_i2c_device); 164 rwork->client = client; 165 166 queue_work(psmouse_smbus_wq, &rwork->work); 167 } 168 } 169 170 static void psmouse_smbus_disconnect(struct psmouse *psmouse) 171 { 172 struct psmouse_smbus_dev *smbdev = psmouse->private; 173 174 mutex_lock(&psmouse_smbus_mutex); 175 176 if (smbdev->dead) { 177 list_del(&smbdev->node); 178 kfree(smbdev); 179 } else { 180 smbdev->dead = true; 181 device_link_remove(&smbdev->client->dev, 182 &psmouse->ps2dev.serio->dev); 183 psmouse_dbg(smbdev->psmouse, 184 "posting removal request for SMBus companion %s\n", 185 dev_name(&smbdev->client->dev)); 186 psmouse_smbus_schedule_remove(smbdev->client); 187 } 188 189 mutex_unlock(&psmouse_smbus_mutex); 190 191 psmouse->private = NULL; 192 } 193 194 static int psmouse_smbus_create_companion(struct device *dev, void *data) 195 { 196 struct psmouse_smbus_dev *smbdev = data; 197 unsigned short addr_list[] = { smbdev->board.addr, I2C_CLIENT_END }; 198 struct i2c_adapter *adapter; 199 struct i2c_client *client; 200 201 adapter = i2c_verify_adapter(dev); 202 if (!adapter) 203 return 0; 204 205 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_HOST_NOTIFY)) 206 return 0; 207 208 client = i2c_new_scanned_device(adapter, &smbdev->board, 209 addr_list, NULL); 210 if (IS_ERR(client)) 211 return 0; 212 213 /* We have our(?) device, stop iterating i2c bus. */ 214 smbdev->client = client; 215 return 1; 216 } 217 218 void psmouse_smbus_cleanup(struct psmouse *psmouse) 219 { 220 struct psmouse_smbus_dev *smbdev, *tmp; 221 222 mutex_lock(&psmouse_smbus_mutex); 223 224 list_for_each_entry_safe(smbdev, tmp, &psmouse_smbus_list, node) { 225 if (psmouse == smbdev->psmouse) { 226 list_del(&smbdev->node); 227 kfree(smbdev); 228 } 229 } 230 231 mutex_unlock(&psmouse_smbus_mutex); 232 } 233 234 int psmouse_smbus_init(struct psmouse *psmouse, 235 const struct i2c_board_info *board, 236 const void *pdata, size_t pdata_size, 237 bool need_deactivate, 238 bool leave_breadcrumbs) 239 { 240 struct psmouse_smbus_dev *smbdev; 241 int error; 242 243 smbdev = kzalloc(sizeof(*smbdev), GFP_KERNEL); 244 if (!smbdev) 245 return -ENOMEM; 246 247 smbdev->psmouse = psmouse; 248 smbdev->board = *board; 249 smbdev->need_deactivate = need_deactivate; 250 251 if (pdata) { 252 smbdev->board.platform_data = kmemdup(pdata, pdata_size, 253 GFP_KERNEL); 254 if (!smbdev->board.platform_data) { 255 kfree(smbdev); 256 return -ENOMEM; 257 } 258 } 259 260 if (need_deactivate) 261 psmouse_deactivate(psmouse); 262 263 psmouse->private = smbdev; 264 psmouse->protocol_handler = psmouse_smbus_process_byte; 265 psmouse->reconnect = psmouse_smbus_reconnect; 266 psmouse->fast_reconnect = psmouse_smbus_reconnect; 267 psmouse->disconnect = psmouse_smbus_disconnect; 268 psmouse->resync_time = 0; 269 270 mutex_lock(&psmouse_smbus_mutex); 271 list_add_tail(&smbdev->node, &psmouse_smbus_list); 272 mutex_unlock(&psmouse_smbus_mutex); 273 274 /* Bind to already existing adapters right away */ 275 error = i2c_for_each_dev(smbdev, psmouse_smbus_create_companion); 276 277 if (smbdev->client) { 278 /* We have our companion device */ 279 if (!device_link_add(&smbdev->client->dev, 280 &psmouse->ps2dev.serio->dev, 281 DL_FLAG_STATELESS)) 282 psmouse_warn(psmouse, 283 "failed to set up link with iSMBus companion %s\n", 284 dev_name(&smbdev->client->dev)); 285 return 0; 286 } 287 288 /* 289 * If we did not create i2c device we will not need platform 290 * data even if we are leaving breadcrumbs. 291 */ 292 kfree(smbdev->board.platform_data); 293 smbdev->board.platform_data = NULL; 294 295 if (error < 0 || !leave_breadcrumbs) { 296 mutex_lock(&psmouse_smbus_mutex); 297 list_del(&smbdev->node); 298 mutex_unlock(&psmouse_smbus_mutex); 299 300 kfree(smbdev); 301 } 302 303 return error < 0 ? error : -EAGAIN; 304 } 305 306 int __init psmouse_smbus_module_init(void) 307 { 308 int error; 309 310 psmouse_smbus_wq = alloc_workqueue("psmouse-smbus", 0, 0); 311 if (!psmouse_smbus_wq) 312 return -ENOMEM; 313 314 error = bus_register_notifier(&i2c_bus_type, &psmouse_smbus_notifier); 315 if (error) { 316 pr_err("failed to register i2c bus notifier: %d\n", error); 317 destroy_workqueue(psmouse_smbus_wq); 318 return error; 319 } 320 321 return 0; 322 } 323 324 void psmouse_smbus_module_exit(void) 325 { 326 bus_unregister_notifier(&i2c_bus_type, &psmouse_smbus_notifier); 327 destroy_workqueue(psmouse_smbus_wq); 328 } 329