drivers/macintosh/mac_hid.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * drivers/macintosh/mac_hid.c
0004  *
0005  * HID support stuff for Macintosh computers.
0006  *
0007  * Copyright (C) 2000 Franz Sirl.
0008  *
0009  * This file will soon be removed in favor of an uinput userspace tool.
0010  */
0011
0012 #include <linux/init.h>
0013 #include <linux/proc_fs.h>
0014 #include <linux/sysctl.h>
0015 #include <linux/input.h>
0016 #include <linux/module.h>
0017 #include <linux/slab.h>
0018
0019 MODULE_LICENSE("GPL");
0020
0021 static int mouse_emulate_buttons;
0022 static int mouse_button2_keycode = KEY_RIGHTCTRL;   /* right control key */
0023 static int mouse_button3_keycode = KEY_RIGHTALT;    /* right option key */
0024
0025 static struct input_dev *mac_hid_emumouse_dev;
0026
0027 static DEFINE_MUTEX(mac_hid_emumouse_mutex);
0028
0029 static int mac_hid_create_emumouse(void)
0030 {
0031     static struct lock_class_key mac_hid_emumouse_dev_event_class;
0032     static struct lock_class_key mac_hid_emumouse_dev_mutex_class;
0033     int err;
0034
0035     mac_hid_emumouse_dev = input_allocate_device();
0036     if (!mac_hid_emumouse_dev)
0037         return -ENOMEM;
0038
0039     lockdep_set_class(&mac_hid_emumouse_dev->event_lock,
0040               &mac_hid_emumouse_dev_event_class);
0041     lockdep_set_class(&mac_hid_emumouse_dev->mutex,
0042               &mac_hid_emumouse_dev_mutex_class);
0043
0044     mac_hid_emumouse_dev->name = "Macintosh mouse button emulation";
0045     mac_hid_emumouse_dev->id.bustype = BUS_ADB;
0046     mac_hid_emumouse_dev->id.vendor = 0x0001;
0047     mac_hid_emumouse_dev->id.product = 0x0001;
0048     mac_hid_emumouse_dev->id.version = 0x0100;
0049
0050     mac_hid_emumouse_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
0051     mac_hid_emumouse_dev->keybit[BIT_WORD(BTN_MOUSE)] =
0052         BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
0053     mac_hid_emumouse_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
0054
0055     err = input_register_device(mac_hid_emumouse_dev);
0056     if (err) {
0057         input_free_device(mac_hid_emumouse_dev);
0058         mac_hid_emumouse_dev = NULL;
0059         return err;
0060     }
0061
0062     return 0;
0063 }
0064
0065 static void mac_hid_destroy_emumouse(void)
0066 {
0067     input_unregister_device(mac_hid_emumouse_dev);
0068     mac_hid_emumouse_dev = NULL;
0069 }
0070
0071 static bool mac_hid_emumouse_filter(struct input_handle *handle,
0072                     unsigned int type, unsigned int code,
0073                     int value)
0074 {
0075     unsigned int btn;
0076
0077     if (type != EV_KEY)
0078         return false;
0079
0080     if (code == mouse_button2_keycode)
0081         btn = BTN_MIDDLE;
0082     else if (code == mouse_button3_keycode)
0083         btn = BTN_RIGHT;
0084     else
0085         return false;
0086
0087     input_report_key(mac_hid_emumouse_dev, btn, value);
0088     input_sync(mac_hid_emumouse_dev);
0089
0090     return true;
0091 }
0092
0093 static int mac_hid_emumouse_connect(struct input_handler *handler,
0094                     struct input_dev *dev,
0095                     const struct input_device_id *id)
0096 {
0097     struct input_handle *handle;
0098     int error;
0099
0100     /* Don't bind to ourselves */
0101     if (dev == mac_hid_emumouse_dev)
0102         return -ENODEV;
0103
0104     handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
0105     if (!handle)
0106         return -ENOMEM;
0107
0108     handle->dev = dev;
0109     handle->handler = handler;
0110     handle->name = "mac-button-emul";
0111
0112     error = input_register_handle(handle);
0113     if (error) {
0114         printk(KERN_ERR
0115             "mac_hid: Failed to register button emulation handle, "
0116             "error %d\n", error);
0117         goto err_free;
0118     }
0119
0120     error = input_open_device(handle);
0121     if (error) {
0122         printk(KERN_ERR
0123             "mac_hid: Failed to open input device, error %d\n",
0124             error);
0125         goto err_unregister;
0126     }
0127
0128     return 0;
0129
0130  err_unregister:
0131     input_unregister_handle(handle);
0132  err_free:
0133     kfree(handle);
0134     return error;
0135 }
0136
0137 static void mac_hid_emumouse_disconnect(struct input_handle *handle)
0138 {
0139     input_close_device(handle);
0140     input_unregister_handle(handle);
0141     kfree(handle);
0142 }
0143
0144 static const struct input_device_id mac_hid_emumouse_ids[] = {
0145     {
0146         .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
0147         .evbit = { BIT_MASK(EV_KEY) },
0148     },
0149     { },
0150 };
0151
0152 MODULE_DEVICE_TABLE(input, mac_hid_emumouse_ids);
0153
0154 static struct input_handler mac_hid_emumouse_handler = {
0155     .filter     = mac_hid_emumouse_filter,
0156     .connect    = mac_hid_emumouse_connect,
0157     .disconnect = mac_hid_emumouse_disconnect,
0158     .name       = "mac-button-emul",
0159     .id_table   = mac_hid_emumouse_ids,
0160 };
0161
0162 static int mac_hid_start_emulation(void)
0163 {
0164     int err;
0165
0166     err = mac_hid_create_emumouse();
0167     if (err)
0168         return err;
0169
0170     err = input_register_handler(&mac_hid_emumouse_handler);
0171     if (err) {
0172         mac_hid_destroy_emumouse();
0173         return err;
0174     }
0175
0176     return 0;
0177 }
0178
0179 static void mac_hid_stop_emulation(void)
0180 {
0181     input_unregister_handler(&mac_hid_emumouse_handler);
0182     mac_hid_destroy_emumouse();
0183 }
0184
0185 static int mac_hid_toggle_emumouse(struct ctl_table *table, int write,
0186                    void *buffer, size_t *lenp, loff_t *ppos)
0187 {
0188     int *valp = table->data;
0189     int old_val = *valp;
0190     int rc;
0191
0192     rc = mutex_lock_killable(&mac_hid_emumouse_mutex);
0193     if (rc)
0194         return rc;
0195
0196     rc = proc_dointvec(table, write, buffer, lenp, ppos);
0197
0198     if (rc == 0 && write && *valp != old_val) {
0199         if (*valp == 1)
0200             rc = mac_hid_start_emulation();
0201         else if (*valp == 0)
0202             mac_hid_stop_emulation();
0203         else
0204             rc = -EINVAL;
0205     }
0206
0207     /* Restore the old value in case of error */
0208     if (rc)
0209         *valp = old_val;
0210
0211     mutex_unlock(&mac_hid_emumouse_mutex);
0212
0213     return rc;
0214 }
0215
0216 /* file(s) in /proc/sys/dev/mac_hid */
0217 static struct ctl_table mac_hid_files[] = {
0218     {
0219         .procname   = "mouse_button_emulation",
0220         .data       = &mouse_emulate_buttons,
0221         .maxlen     = sizeof(int),
0222         .mode       = 0644,
0223         .proc_handler   = mac_hid_toggle_emumouse,
0224     },
0225     {
0226         .procname   = "mouse_button2_keycode",
0227         .data       = &mouse_button2_keycode,
0228         .maxlen     = sizeof(int),
0229         .mode       = 0644,
0230         .proc_handler   = proc_dointvec,
0231     },
0232     {
0233         .procname   = "mouse_button3_keycode",
0234         .data       = &mouse_button3_keycode,
0235         .maxlen     = sizeof(int),
0236         .mode       = 0644,
0237         .proc_handler   = proc_dointvec,
0238     },
0239     { }
0240 };
0241
0242 static struct ctl_table_header *mac_hid_sysctl_header;
0243
0244 static int __init mac_hid_init(void)
0245 {
0246     mac_hid_sysctl_header = register_sysctl("dev/mac_hid", mac_hid_files);
0247     if (!mac_hid_sysctl_header)
0248         return -ENOMEM;
0249
0250     return 0;
0251 }
0252 module_init(mac_hid_init);
0253
0254 static void __exit mac_hid_exit(void)
0255 {
0256     unregister_sysctl_table(mac_hid_sysctl_header);
0257
0258     if (mouse_emulate_buttons)
0259         mac_hid_stop_emulation();
0260 }
0261 module_exit(mac_hid_exit);