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
 17struct 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
 26static LIST_HEAD(psmouse_smbus_list);
 27static DEFINE_MUTEX(psmouse_smbus_mutex);
 28
 29static struct workqueue_struct *psmouse_smbus_wq;
 30
 31static 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
 62static 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
 92static 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
112static struct notifier_block psmouse_smbus_notifier = {
113	.notifier_call = psmouse_smbus_notifier_call,
114};
115
116static psmouse_ret_t psmouse_smbus_process_byte(struct psmouse *psmouse)
117{
118	return PSMOUSE_FULL_PACKET;
119}
120
121static 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
131struct psmouse_smbus_removal_work {
132	struct work_struct work;
133	struct i2c_client *client;
134};
135
136static 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 */
157static 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
170static 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
194static 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
218void 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
234int 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
306int __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
324void psmouse_smbus_module_exit(void)
325{
326	bus_unregister_notifier(&i2c_bus_type, &psmouse_smbus_notifier);
327	destroy_workqueue(psmouse_smbus_wq);
328}