input/joystick/adi.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (c) 1998-2005 Vojtech Pavlik
0004  */
0005
0006 /*
0007  * Logitech ADI joystick family driver for Linux
0008  */
0009
0010 /*
0011  */
0012
0013 #include <linux/delay.h>
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/string.h>
0017 #include <linux/slab.h>
0018 #include <linux/input.h>
0019 #include <linux/gameport.h>
0020 #include <linux/jiffies.h>
0021
0022 #define DRIVER_DESC "Logitech ADI joystick family driver"
0023
0024 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
0025 MODULE_DESCRIPTION(DRIVER_DESC);
0026 MODULE_LICENSE("GPL");
0027
0028 /*
0029  * Times, array sizes, flags, ids.
0030  */
0031
0032 #define ADI_MAX_START       200 /* Trigger to packet timeout [200us] */
0033 #define ADI_MAX_STROBE      40  /* Single bit timeout [40us] */
0034 #define ADI_INIT_DELAY      10  /* Delay after init packet [10ms] */
0035 #define ADI_DATA_DELAY      4   /* Delay after data packet [4ms] */
0036
0037 #define ADI_MAX_LENGTH      256
0038 #define ADI_MIN_LENGTH      8
0039 #define ADI_MIN_LEN_LENGTH  10
0040 #define ADI_MIN_ID_LENGTH   66
0041 #define ADI_MAX_NAME_LENGTH 64
0042 #define ADI_MAX_CNAME_LENGTH    16
0043 #define ADI_MAX_PHYS_LENGTH 64
0044
0045 #define ADI_FLAG_HAT        0x04
0046 #define ADI_FLAG_10BIT      0x08
0047
0048 #define ADI_ID_TPD      0x01
0049 #define ADI_ID_WGP      0x06
0050 #define ADI_ID_WGPE     0x08
0051 #define ADI_ID_MAX      0x0a
0052
0053 /*
0054  * Names, buttons, axes ...
0055  */
0056
0057 static char *adi_names[] = {    "WingMan Extreme Digital", "ThunderPad Digital", "SideCar", "CyberMan 2",
0058                 "WingMan Interceptor", "WingMan Formula", "WingMan GamePad",
0059                 "WingMan Extreme Digital 3D", "WingMan GamePad Extreme",
0060                 "WingMan GamePad USB", "Unknown Device %#x" };
0061
0062 static char adi_wmgpe_abs[] =   { ABS_X, ABS_Y, ABS_HAT0X, ABS_HAT0Y };
0063 static char adi_wmi_abs[] = { ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, ABS_HAT1X, ABS_HAT1Y, ABS_HAT2X, ABS_HAT2Y };
0064 static char adi_wmed3d_abs[] =  { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RZ, ABS_HAT0X, ABS_HAT0Y };
0065 static char adi_cm2_abs[] = { ABS_X, ABS_Y, ABS_Z, ABS_RX, ABS_RY, ABS_RZ };
0066 static char adi_wmf_abs[] = { ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, ABS_HAT1X, ABS_HAT1Y, ABS_HAT2X, ABS_HAT2Y };
0067
0068 static short adi_wmgpe_key[] =  { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z,  BTN_TL, BTN_TR, BTN_START, BTN_MODE, BTN_SELECT };
0069 static short adi_wmi_key[] =    { BTN_TRIGGER,  BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE, BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_EXTRA };
0070 static short adi_wmed3d_key[] = { BTN_TRIGGER, BTN_THUMB, BTN_THUMB2, BTN_TOP, BTN_TOP2, BTN_BASE, BTN_BASE2 };
0071 static short adi_cm2_key[] =    { BTN_1, BTN_2, BTN_3, BTN_4, BTN_5, BTN_6, BTN_7, BTN_8 };
0072
0073 static char* adi_abs[] = { adi_wmi_abs, adi_wmgpe_abs, adi_wmf_abs, adi_cm2_abs, adi_wmi_abs, adi_wmf_abs,
0074                adi_wmgpe_abs, adi_wmed3d_abs, adi_wmgpe_abs, adi_wmgpe_abs, adi_wmi_abs };
0075
0076 static short* adi_key[] = { adi_wmi_key, adi_wmgpe_key, adi_cm2_key, adi_cm2_key, adi_wmi_key, adi_cm2_key,
0077                 adi_wmgpe_key, adi_wmed3d_key, adi_wmgpe_key, adi_wmgpe_key, adi_wmi_key };
0078
0079 /*
0080  * Hat to axis conversion arrays.
0081  */
0082
0083 static struct {
0084     int x;
0085     int y;
0086 } adi_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
0087
0088 /*
0089  * Per-port information.
0090  */
0091
0092 struct adi {
0093     struct input_dev *dev;
0094     int length;
0095     int ret;
0096     int idx;
0097     unsigned char id;
0098     char buttons;
0099     char axes10;
0100     char axes8;
0101     signed char pad;
0102     char hats;
0103     char *abs;
0104     short *key;
0105     char name[ADI_MAX_NAME_LENGTH];
0106     char cname[ADI_MAX_CNAME_LENGTH];
0107     char phys[ADI_MAX_PHYS_LENGTH];
0108     unsigned char data[ADI_MAX_LENGTH];
0109 };
0110
0111 struct adi_port {
0112     struct gameport *gameport;
0113     struct adi adi[2];
0114     int bad;
0115     int reads;
0116 };
0117
0118 /*
0119  * adi_read_packet() reads a Logitech ADI packet.
0120  */
0121
0122 static void adi_read_packet(struct adi_port *port)
0123 {
0124     struct adi *adi = port->adi;
0125     struct gameport *gameport = port->gameport;
0126     unsigned char u, v, w, x;
0127     int t[2], s[2], i;
0128     unsigned long flags;
0129
0130     for (i = 0; i < 2; i++) {
0131         adi[i].ret = -1;
0132         t[i] = gameport_time(gameport, ADI_MAX_START);
0133         s[i] = 0;
0134     }
0135
0136     local_irq_save(flags);
0137
0138     gameport_trigger(gameport);
0139     v = gameport_read(gameport);
0140
0141     do {
0142         u = v;
0143         w = u ^ (v = x = gameport_read(gameport));
0144         for (i = 0; i < 2; i++, w >>= 2, x >>= 2) {
0145             t[i]--;
0146             if ((w & 0x30) && s[i]) {
0147                 if ((w & 0x30) < 0x30 && adi[i].ret < ADI_MAX_LENGTH && t[i] > 0) {
0148                     adi[i].data[++adi[i].ret] = w;
0149                     t[i] = gameport_time(gameport, ADI_MAX_STROBE);
0150                 } else t[i] = 0;
0151             } else if (!(x & 0x30)) s[i] = 1;
0152         }
0153     } while (t[0] > 0 || t[1] > 0);
0154
0155     local_irq_restore(flags);
0156
0157     return;
0158 }
0159
0160 /*
0161  * adi_move_bits() detects a possible 2-stream mode, and moves
0162  * the bits accordingly.
0163  */
0164
0165 static void adi_move_bits(struct adi_port *port, int length)
0166 {
0167     int i;
0168     struct adi *adi = port->adi;
0169
0170     adi[0].idx = adi[1].idx = 0;
0171
0172     if (adi[0].ret <= 0 || adi[1].ret <= 0) return;
0173     if (adi[0].data[0] & 0x20 || ~adi[1].data[0] & 0x20) return;
0174
0175     for (i = 1; i <= adi[1].ret; i++)
0176         adi[0].data[((length - 1) >> 1) + i + 1] = adi[1].data[i];
0177
0178     adi[0].ret += adi[1].ret;
0179     adi[1].ret = -1;
0180 }
0181
0182 /*
0183  * adi_get_bits() gathers bits from the data packet.
0184  */
0185
0186 static inline int adi_get_bits(struct adi *adi, int count)
0187 {
0188     int bits = 0;
0189     int i;
0190     if ((adi->idx += count) > adi->ret) return 0;
0191     for (i = 0; i < count; i++)
0192         bits |= ((adi->data[adi->idx - i] >> 5) & 1) << i;
0193     return bits;
0194 }
0195
0196 /*
0197  * adi_decode() decodes Logitech joystick data into input events.
0198  */
0199
0200 static int adi_decode(struct adi *adi)
0201 {
0202     struct input_dev *dev = adi->dev;
0203     char *abs = adi->abs;
0204     short *key = adi->key;
0205     int i, t;
0206
0207     if (adi->ret < adi->length || adi->id != (adi_get_bits(adi, 4) | (adi_get_bits(adi, 4) << 4)))
0208         return -1;
0209
0210     for (i = 0; i < adi->axes10; i++)
0211         input_report_abs(dev, *abs++, adi_get_bits(adi, 10));
0212
0213     for (i = 0; i < adi->axes8; i++)
0214         input_report_abs(dev, *abs++, adi_get_bits(adi, 8));
0215
0216     for (i = 0; i < adi->buttons && i < 63; i++) {
0217         if (i == adi->pad) {
0218             t = adi_get_bits(adi, 4);
0219             input_report_abs(dev, *abs++, ((t >> 2) & 1) - ( t       & 1));
0220             input_report_abs(dev, *abs++, ((t >> 1) & 1) - ((t >> 3) & 1));
0221         }
0222         input_report_key(dev, *key++, adi_get_bits(adi, 1));
0223     }
0224
0225     for (i = 0; i < adi->hats; i++) {
0226         if ((t = adi_get_bits(adi, 4)) > 8) t = 0;
0227         input_report_abs(dev, *abs++, adi_hat_to_axis[t].x);
0228         input_report_abs(dev, *abs++, adi_hat_to_axis[t].y);
0229     }
0230
0231     for (i = 63; i < adi->buttons; i++)
0232         input_report_key(dev, *key++, adi_get_bits(adi, 1));
0233
0234     input_sync(dev);
0235
0236     return 0;
0237 }
0238
0239 /*
0240  * adi_read() reads the data packet and decodes it.
0241  */
0242
0243 static int adi_read(struct adi_port *port)
0244 {
0245     int i;
0246     int result = 0;
0247
0248     adi_read_packet(port);
0249     adi_move_bits(port, port->adi[0].length);
0250
0251     for (i = 0; i < 2; i++)
0252         if (port->adi[i].length)
0253              result |= adi_decode(port->adi + i);
0254
0255     return result;
0256 }
0257
0258 /*
0259  * adi_poll() repeatedly polls the Logitech joysticks.
0260  */
0261
0262 static void adi_poll(struct gameport *gameport)
0263 {
0264     struct adi_port *port = gameport_get_drvdata(gameport);
0265
0266     port->bad -= adi_read(port);
0267     port->reads++;
0268 }
0269
0270 /*
0271  * adi_open() is a callback from the input open routine.
0272  */
0273
0274 static int adi_open(struct input_dev *dev)
0275 {
0276     struct adi_port *port = input_get_drvdata(dev);
0277
0278     gameport_start_polling(port->gameport);
0279     return 0;
0280 }
0281
0282 /*
0283  * adi_close() is a callback from the input close routine.
0284  */
0285
0286 static void adi_close(struct input_dev *dev)
0287 {
0288     struct adi_port *port = input_get_drvdata(dev);
0289
0290     gameport_stop_polling(port->gameport);
0291 }
0292
0293 /*
0294  * adi_init_digital() sends a trigger & delay sequence
0295  * to reset and initialize a Logitech joystick into digital mode.
0296  */
0297
0298 static void adi_init_digital(struct gameport *gameport)
0299 {
0300     static const int seq[] = { 4, -2, -3, 10, -6, -11, -7, -9, 11, 0 };
0301     int i;
0302
0303     for (i = 0; seq[i]; i++) {
0304         gameport_trigger(gameport);
0305         if (seq[i] > 0)
0306             msleep(seq[i]);
0307         if (seq[i] < 0) {
0308             mdelay(-seq[i]);
0309             udelay(-seq[i]*14); /* It looks like mdelay() is off by approx 1.4% */
0310         }
0311     }
0312 }
0313
0314 static void adi_id_decode(struct adi *adi, struct adi_port *port)
0315 {
0316     int i, t;
0317
0318     if (adi->ret < ADI_MIN_ID_LENGTH) /* Minimum ID packet length */
0319         return;
0320
0321     if (adi->ret < (t = adi_get_bits(adi, 10))) {
0322         printk(KERN_WARNING "adi: Short ID packet: reported: %d != read: %d\n", t, adi->ret);
0323         return;
0324     }
0325
0326     adi->id = adi_get_bits(adi, 4) | (adi_get_bits(adi, 4) << 4);
0327
0328     if ((t = adi_get_bits(adi, 4)) & ADI_FLAG_HAT) adi->hats++;
0329
0330     adi->length = adi_get_bits(adi, 10);
0331
0332     if (adi->length >= ADI_MAX_LENGTH || adi->length < ADI_MIN_LENGTH) {
0333         printk(KERN_WARNING "adi: Bad data packet length (%d).\n", adi->length);
0334         adi->length = 0;
0335         return;
0336     }
0337
0338     adi->axes8 = adi_get_bits(adi, 4);
0339     adi->buttons = adi_get_bits(adi, 6);
0340
0341     if (adi_get_bits(adi, 6) != 8 && adi->hats) {
0342         printk(KERN_WARNING "adi: Other than 8-dir POVs not supported yet.\n");
0343         adi->length = 0;
0344         return;
0345     }
0346
0347     adi->buttons += adi_get_bits(adi, 6);
0348     adi->hats += adi_get_bits(adi, 4);
0349
0350     i = adi_get_bits(adi, 4);
0351
0352     if (t & ADI_FLAG_10BIT) {
0353         adi->axes10 = adi->axes8 - i;
0354         adi->axes8 = i;
0355     }
0356
0357     t = adi_get_bits(adi, 4);
0358
0359     for (i = 0; i < t; i++)
0360         adi->cname[i] = adi_get_bits(adi, 8);
0361     adi->cname[i] = 0;
0362
0363     t = 8 + adi->buttons + adi->axes10 * 10 + adi->axes8 * 8 + adi->hats * 4;
0364     if (adi->length != t && adi->length != t + (t & 1)) {
0365         printk(KERN_WARNING "adi: Expected length %d != data length %d\n", t, adi->length);
0366         adi->length = 0;
0367         return;
0368     }
0369
0370     switch (adi->id) {
0371         case ADI_ID_TPD:
0372             adi->pad = 4;
0373             adi->buttons -= 4;
0374             break;
0375         case ADI_ID_WGP:
0376             adi->pad = 0;
0377             adi->buttons -= 4;
0378             break;
0379         default:
0380             adi->pad = -1;
0381             break;
0382     }
0383 }
0384
0385 static int adi_init_input(struct adi *adi, struct adi_port *port, int half)
0386 {
0387     struct input_dev *input_dev;
0388     char buf[ADI_MAX_NAME_LENGTH];
0389     int i, t;
0390
0391     adi->dev = input_dev = input_allocate_device();
0392     if (!input_dev)
0393         return -ENOMEM;
0394
0395     t = adi->id < ADI_ID_MAX ? adi->id : ADI_ID_MAX;
0396
0397     snprintf(buf, ADI_MAX_PHYS_LENGTH, adi_names[t], adi->id);
0398     snprintf(adi->name, ADI_MAX_NAME_LENGTH, "Logitech %s [%s]", buf, adi->cname);
0399     snprintf(adi->phys, ADI_MAX_PHYS_LENGTH, "%s/input%d", port->gameport->phys, half);
0400
0401     adi->abs = adi_abs[t];
0402     adi->key = adi_key[t];
0403
0404     input_dev->name = adi->name;
0405     input_dev->phys = adi->phys;
0406     input_dev->id.bustype = BUS_GAMEPORT;
0407     input_dev->id.vendor = GAMEPORT_ID_VENDOR_LOGITECH;
0408     input_dev->id.product = adi->id;
0409     input_dev->id.version = 0x0100;
0410     input_dev->dev.parent = &port->gameport->dev;
0411
0412     input_set_drvdata(input_dev, port);
0413
0414     input_dev->open = adi_open;
0415     input_dev->close = adi_close;
0416
0417     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0418
0419     for (i = 0; i < adi->axes10 + adi->axes8 + (adi->hats + (adi->pad != -1)) * 2; i++)
0420         set_bit(adi->abs[i], input_dev->absbit);
0421
0422     for (i = 0; i < adi->buttons; i++)
0423         set_bit(adi->key[i], input_dev->keybit);
0424
0425     return 0;
0426 }
0427
0428 static void adi_init_center(struct adi *adi)
0429 {
0430     int i, t, x;
0431
0432     if (!adi->length)
0433         return;
0434
0435     for (i = 0; i < adi->axes10 + adi->axes8 + (adi->hats + (adi->pad != -1)) * 2; i++) {
0436
0437         t = adi->abs[i];
0438         x = input_abs_get_val(adi->dev, t);
0439
0440         if (t == ABS_THROTTLE || t == ABS_RUDDER || adi->id == ADI_ID_WGPE)
0441             x = i < adi->axes10 ? 512 : 128;
0442
0443         if (i < adi->axes10)
0444             input_set_abs_params(adi->dev, t, 64, x * 2 - 64, 2, 16);
0445         else if (i < adi->axes10 + adi->axes8)
0446             input_set_abs_params(adi->dev, t, 48, x * 2 - 48, 1, 16);
0447         else
0448             input_set_abs_params(adi->dev, t, -1, 1, 0, 0);
0449     }
0450 }
0451
0452 /*
0453  * adi_connect() probes for Logitech ADI joysticks.
0454  */
0455
0456 static int adi_connect(struct gameport *gameport, struct gameport_driver *drv)
0457 {
0458     struct adi_port *port;
0459     int i;
0460     int err;
0461
0462     port = kzalloc(sizeof(struct adi_port), GFP_KERNEL);
0463     if (!port)
0464         return -ENOMEM;
0465
0466     port->gameport = gameport;
0467
0468     gameport_set_drvdata(gameport, port);
0469
0470     err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
0471     if (err)
0472         goto fail1;
0473
0474     adi_init_digital(gameport);
0475     adi_read_packet(port);
0476
0477     if (port->adi[0].ret >= ADI_MIN_LEN_LENGTH)
0478         adi_move_bits(port, adi_get_bits(port->adi, 10));
0479
0480     for (i = 0; i < 2; i++) {
0481         adi_id_decode(port->adi + i, port);
0482
0483         if (!port->adi[i].length)
0484             continue;
0485
0486         err = adi_init_input(port->adi + i, port, i);
0487         if (err)
0488             goto fail2;
0489     }
0490
0491     if (!port->adi[0].length && !port->adi[1].length) {
0492         err = -ENODEV;
0493         goto fail2;
0494     }
0495
0496     gameport_set_poll_handler(gameport, adi_poll);
0497     gameport_set_poll_interval(gameport, 20);
0498
0499     msleep(ADI_INIT_DELAY);
0500     if (adi_read(port)) {
0501         msleep(ADI_DATA_DELAY);
0502         adi_read(port);
0503     }
0504
0505     for (i = 0; i < 2; i++)
0506         if (port->adi[i].length > 0) {
0507             adi_init_center(port->adi + i);
0508             err = input_register_device(port->adi[i].dev);
0509             if (err)
0510                 goto fail3;
0511         }
0512
0513     return 0;
0514
0515  fail3: while (--i >= 0) {
0516         if (port->adi[i].length > 0) {
0517             input_unregister_device(port->adi[i].dev);
0518             port->adi[i].dev = NULL;
0519         }
0520     }
0521  fail2: for (i = 0; i < 2; i++)
0522         input_free_device(port->adi[i].dev);
0523     gameport_close(gameport);
0524  fail1: gameport_set_drvdata(gameport, NULL);
0525     kfree(port);
0526     return err;
0527 }
0528
0529 static void adi_disconnect(struct gameport *gameport)
0530 {
0531     int i;
0532     struct adi_port *port = gameport_get_drvdata(gameport);
0533
0534     for (i = 0; i < 2; i++)
0535         if (port->adi[i].length > 0)
0536             input_unregister_device(port->adi[i].dev);
0537     gameport_close(gameport);
0538     gameport_set_drvdata(gameport, NULL);
0539     kfree(port);
0540 }
0541
0542 static struct gameport_driver adi_drv = {
0543     .driver     = {
0544         .name   = "adi",
0545     },
0546     .description    = DRIVER_DESC,
0547     .connect    = adi_connect,
0548     .disconnect = adi_disconnect,
0549 };
0550
0551 module_gameport_driver(adi_drv);