drivers/input/joystick/psxpad-spi.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * PlayStation 1/2 joypads via SPI interface Driver
   4  *
   5  * Copyright (C) 2017 Tomohiro Yoshidomi <sylph23k@gmail.com>
   6  *
   7  * PlayStation 1/2 joypad's plug (not socket)
   8  *  123 456 789
   9  * (...|...|...)
  10  *
  11  * 1: DAT -> MISO (pullup with 1k owm to 3.3V)
  12  * 2: CMD -> MOSI
  13  * 3: 9V (for motor, if not use N.C.)
  14  * 4: GND
  15  * 5: 3.3V
  16  * 6: Attention -> CS(SS)
  17  * 7: SCK -> SCK
  18  * 8: N.C.
  19  * 9: ACK -> N.C.
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/device.h>
  24 #include <linux/input.h>
  25 #include <linux/module.h>
  26 #include <linux/spi/spi.h>
  27 #include <linux/types.h>
  28 #include <linux/pm.h>
  29 #include <linux/pm_runtime.h>
  30
  31 #define REVERSE_BIT(x) ((((x) & 0x80) >> 7) | (((x) & 0x40) >> 5) | \
  32         (((x) & 0x20) >> 3) | (((x) & 0x10) >> 1) | (((x) & 0x08) << 1) | \
  33         (((x) & 0x04) << 3) | (((x) & 0x02) << 5) | (((x) & 0x01) << 7))
  34
  35 /* PlayStation 1/2 joypad command and response are LSBFIRST. */
  36
  37 /*
  38  *      0x01, 0x42, 0x00, 0x00, 0x00,
  39  *      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  40  *      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  41  */
  42 static const u8 PSX_CMD_POLL[] = {
  43         0x80, 0x42, 0x00, 0x00, 0x00,
  44         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  45         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  46 };
  47
  48 #ifdef CONFIG_JOYSTICK_PSXPAD_SPI_FF
  49 /*      0x01, 0x43, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 */
  50 static const u8 PSX_CMD_ENTER_CFG[] = {
  51         0x80, 0xC2, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00
  52 };
  53 /*      0x01, 0x43, 0x00, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A */
  54 static const u8 PSX_CMD_EXIT_CFG[] = {
  55         0x80, 0xC2, 0x00, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A
  56 };
  57 /*      0x01, 0x4D, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF */
  58 static const u8 PSX_CMD_ENABLE_MOTOR[]  = {
  59         0x80, 0xB2, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xFF, 0xFF
  60 };
  61 #endif /* CONFIG_JOYSTICK_PSXPAD_SPI_FF */
  62
  63 struct psxpad {
  64         struct spi_device *spi;
  65         struct input_dev *idev;
  66         char phys[0x20];
  67         bool motor1enable;
  68         bool motor2enable;
  69         u8 motor1level;
  70         u8 motor2level;
  71         u8 sendbuf[0x20] ____cacheline_aligned;
  72         u8 response[sizeof(PSX_CMD_POLL)] ____cacheline_aligned;
  73 };
  74
  75 static int psxpad_command(struct psxpad *pad, const u8 sendcmdlen)
  76 {
  77         struct spi_transfer xfers = {
  78                 .tx_buf         = pad->sendbuf,
  79                 .rx_buf         = pad->response,
  80                 .len            = sendcmdlen,
  81         };
  82         int err;
  83
  84         err = spi_sync_transfer(pad->spi, &xfers, 1);
  85         if (err) {
  86                 dev_err(&pad->spi->dev,
  87                         "%s: failed to SPI xfers mode: %d\n",
  88                         __func__, err);
  89                 return err;
  90         }
  91
  92         return 0;
  93 }
  94
  95 #ifdef CONFIG_JOYSTICK_PSXPAD_SPI_FF
  96 static void psxpad_control_motor(struct psxpad *pad,
  97                                  bool motor1enable, bool motor2enable)
  98 {
  99         int err;
 100
 101         pad->motor1enable = motor1enable;
 102         pad->motor2enable = motor2enable;
 103
 104         memcpy(pad->sendbuf, PSX_CMD_ENTER_CFG, sizeof(PSX_CMD_ENTER_CFG));
 105         err = psxpad_command(pad, sizeof(PSX_CMD_ENTER_CFG));
 106         if (err) {
 107                 dev_err(&pad->spi->dev,
 108                         "%s: failed to enter config mode: %d\n",
 109                         __func__, err);
 110                 return;
 111         }
 112
 113         memcpy(pad->sendbuf, PSX_CMD_ENABLE_MOTOR,
 114                sizeof(PSX_CMD_ENABLE_MOTOR));
 115         pad->sendbuf[3] = pad->motor1enable ? 0x00 : 0xFF;
 116         pad->sendbuf[4] = pad->motor2enable ? 0x80 : 0xFF;
 117         err = psxpad_command(pad, sizeof(PSX_CMD_ENABLE_MOTOR));
 118         if (err) {
 119                 dev_err(&pad->spi->dev,
 120                         "%s: failed to enable motor mode: %d\n",
 121                         __func__, err);
 122                 return;
 123         }
 124
 125         memcpy(pad->sendbuf, PSX_CMD_EXIT_CFG, sizeof(PSX_CMD_EXIT_CFG));
 126         err = psxpad_command(pad, sizeof(PSX_CMD_EXIT_CFG));
 127         if (err) {
 128                 dev_err(&pad->spi->dev,
 129                         "%s: failed to exit config mode: %d\n",
 130                         __func__, err);
 131                 return;
 132         }
 133 }
 134
 135 static void psxpad_set_motor_level(struct psxpad *pad,
 136                                    u8 motor1level, u8 motor2level)
 137 {
 138         pad->motor1level = motor1level ? 0xFF : 0x00;
 139         pad->motor2level = REVERSE_BIT(motor2level);
 140 }
 141
 142 static int psxpad_spi_play_effect(struct input_dev *idev,
 143                                   void *data, struct ff_effect *effect)
 144 {
 145         struct psxpad *pad = input_get_drvdata(idev);
 146
 147         switch (effect->type) {
 148         case FF_RUMBLE:
 149                 psxpad_set_motor_level(pad,
 150                         (effect->u.rumble.weak_magnitude >> 8) & 0xFFU,
 151                         (effect->u.rumble.strong_magnitude >> 8) & 0xFFU);
 152                 break;
 153         }
 154
 155         return 0;
 156 }
 157
 158 static int psxpad_spi_init_ff(struct psxpad *pad)
 159 {
 160         int err;
 161
 162         input_set_capability(pad->idev, EV_FF, FF_RUMBLE);
 163
 164         err = input_ff_create_memless(pad->idev, NULL, psxpad_spi_play_effect);
 165         if (err) {
 166                 dev_err(&pad->spi->dev,
 167                         "input_ff_create_memless() failed: %d\n", err);
 168                 return err;
 169         }
 170
 171         return 0;
 172 }
 173
 174 #else   /* CONFIG_JOYSTICK_PSXPAD_SPI_FF */
 175
 176 static void psxpad_control_motor(struct psxpad *pad,
 177                                  bool motor1enable, bool motor2enable)
 178 {
 179 }
 180
 181 static void psxpad_set_motor_level(struct psxpad *pad,
 182                                    u8 motor1level, u8 motor2level)
 183 {
 184 }
 185
 186 static inline int psxpad_spi_init_ff(struct psxpad *pad)
 187 {
 188         return 0;
 189 }
 190 #endif  /* CONFIG_JOYSTICK_PSXPAD_SPI_FF */
 191
 192 static int psxpad_spi_poll_open(struct input_dev *input)
 193 {
 194         struct psxpad *pad = input_get_drvdata(input);
 195
 196         pm_runtime_get_sync(&pad->spi->dev);
 197
 198         return 0;
 199 }
 200
 201 static void psxpad_spi_poll_close(struct input_dev *input)
 202 {
 203         struct psxpad *pad = input_get_drvdata(input);
 204
 205         pm_runtime_put_sync(&pad->spi->dev);
 206 }
 207
 208 static void psxpad_spi_poll(struct input_dev *input)
 209 {
 210         struct psxpad *pad = input_get_drvdata(input);
 211         u8 b_rsp3, b_rsp4;
 212         int err;
 213
 214         psxpad_control_motor(pad, true, true);
 215
 216         memcpy(pad->sendbuf, PSX_CMD_POLL, sizeof(PSX_CMD_POLL));
 217         pad->sendbuf[3] = pad->motor1enable ? pad->motor1level : 0x00;
 218         pad->sendbuf[4] = pad->motor2enable ? pad->motor2level : 0x00;
 219         err = psxpad_command(pad, sizeof(PSX_CMD_POLL));
 220         if (err) {
 221                 dev_err(&pad->spi->dev,
 222                         "%s: poll command failed mode: %d\n", __func__, err);
 223                 return;
 224         }
 225
 226         switch (pad->response[1]) {
 227         case 0xCE:      /* 0x73 : analog 1 */
 228                 /* button data is inverted */
 229                 b_rsp3 = ~pad->response[3];
 230                 b_rsp4 = ~pad->response[4];
 231
 232                 input_report_abs(input, ABS_X, REVERSE_BIT(pad->response[7]));
 233                 input_report_abs(input, ABS_Y, REVERSE_BIT(pad->response[8]));
 234                 input_report_abs(input, ABS_RX, REVERSE_BIT(pad->response[5]));
 235                 input_report_abs(input, ABS_RY, REVERSE_BIT(pad->response[6]));
 236                 input_report_key(input, BTN_DPAD_UP, b_rsp3 & BIT(3));
 237                 input_report_key(input, BTN_DPAD_DOWN, b_rsp3 & BIT(1));
 238                 input_report_key(input, BTN_DPAD_LEFT, b_rsp3 & BIT(0));
 239                 input_report_key(input, BTN_DPAD_RIGHT, b_rsp3 & BIT(2));
 240                 input_report_key(input, BTN_X, b_rsp4 & BIT(3));
 241                 input_report_key(input, BTN_A, b_rsp4 & BIT(2));
 242                 input_report_key(input, BTN_B, b_rsp4 & BIT(1));
 243                 input_report_key(input, BTN_Y, b_rsp4 & BIT(0));
 244                 input_report_key(input, BTN_TL, b_rsp4 & BIT(5));
 245                 input_report_key(input, BTN_TR, b_rsp4 & BIT(4));
 246                 input_report_key(input, BTN_TL2, b_rsp4 & BIT(7));
 247                 input_report_key(input, BTN_TR2, b_rsp4 & BIT(6));
 248                 input_report_key(input, BTN_THUMBL, b_rsp3 & BIT(6));
 249                 input_report_key(input, BTN_THUMBR, b_rsp3 & BIT(5));
 250                 input_report_key(input, BTN_SELECT, b_rsp3 & BIT(7));
 251                 input_report_key(input, BTN_START, b_rsp3 & BIT(4));
 252                 break;
 253
 254         case 0x82:      /* 0x41 : digital */
 255                 /* button data is inverted */
 256                 b_rsp3 = ~pad->response[3];
 257                 b_rsp4 = ~pad->response[4];
 258
 259                 input_report_abs(input, ABS_X, 0x80);
 260                 input_report_abs(input, ABS_Y, 0x80);
 261                 input_report_abs(input, ABS_RX, 0x80);
 262                 input_report_abs(input, ABS_RY, 0x80);
 263                 input_report_key(input, BTN_DPAD_UP, b_rsp3 & BIT(3));
 264                 input_report_key(input, BTN_DPAD_DOWN, b_rsp3 & BIT(1));
 265                 input_report_key(input, BTN_DPAD_LEFT, b_rsp3 & BIT(0));
 266                 input_report_key(input, BTN_DPAD_RIGHT, b_rsp3 & BIT(2));
 267                 input_report_key(input, BTN_X, b_rsp4 & BIT(3));
 268                 input_report_key(input, BTN_A, b_rsp4 & BIT(2));
 269                 input_report_key(input, BTN_B, b_rsp4 & BIT(1));
 270                 input_report_key(input, BTN_Y, b_rsp4 & BIT(0));
 271                 input_report_key(input, BTN_TL, b_rsp4 & BIT(5));
 272                 input_report_key(input, BTN_TR, b_rsp4 & BIT(4));
 273                 input_report_key(input, BTN_TL2, b_rsp4 & BIT(7));
 274                 input_report_key(input, BTN_TR2, b_rsp4 & BIT(6));
 275                 input_report_key(input, BTN_THUMBL, false);
 276                 input_report_key(input, BTN_THUMBR, false);
 277                 input_report_key(input, BTN_SELECT, b_rsp3 & BIT(7));
 278                 input_report_key(input, BTN_START, b_rsp3 & BIT(4));
 279                 break;
 280         }
 281
 282         input_sync(input);
 283 }
 284
 285 static int psxpad_spi_probe(struct spi_device *spi)
 286 {
 287         struct psxpad *pad;
 288         struct input_dev *idev;
 289         int err;
 290
 291         pad = devm_kzalloc(&spi->dev, sizeof(struct psxpad), GFP_KERNEL);
 292         if (!pad)
 293                 return -ENOMEM;
 294
 295         idev = devm_input_allocate_device(&spi->dev);
 296         if (!idev) {
 297                 dev_err(&spi->dev, "failed to allocate input device\n");
 298                 return -ENOMEM;
 299         }
 300
 301         /* input poll device settings */
 302         pad->idev = idev;
 303         pad->spi = spi;
 304
 305         /* input device settings */
 306         input_set_drvdata(idev, pad);
 307
 308         idev->name = "PlayStation 1/2 joypad";
 309         snprintf(pad->phys, sizeof(pad->phys), "%s/input", dev_name(&spi->dev));
 310         idev->id.bustype = BUS_SPI;
 311
 312         idev->open = psxpad_spi_poll_open;
 313         idev->close = psxpad_spi_poll_close;
 314
 315         /* key/value map settings */
 316         input_set_abs_params(idev, ABS_X, 0, 255, 0, 0);
 317         input_set_abs_params(idev, ABS_Y, 0, 255, 0, 0);
 318         input_set_abs_params(idev, ABS_RX, 0, 255, 0, 0);
 319         input_set_abs_params(idev, ABS_RY, 0, 255, 0, 0);
 320         input_set_capability(idev, EV_KEY, BTN_DPAD_UP);
 321         input_set_capability(idev, EV_KEY, BTN_DPAD_DOWN);
 322         input_set_capability(idev, EV_KEY, BTN_DPAD_LEFT);
 323         input_set_capability(idev, EV_KEY, BTN_DPAD_RIGHT);
 324         input_set_capability(idev, EV_KEY, BTN_A);
 325         input_set_capability(idev, EV_KEY, BTN_B);
 326         input_set_capability(idev, EV_KEY, BTN_X);
 327         input_set_capability(idev, EV_KEY, BTN_Y);
 328         input_set_capability(idev, EV_KEY, BTN_TL);
 329         input_set_capability(idev, EV_KEY, BTN_TR);
 330         input_set_capability(idev, EV_KEY, BTN_TL2);
 331         input_set_capability(idev, EV_KEY, BTN_TR2);
 332         input_set_capability(idev, EV_KEY, BTN_THUMBL);
 333         input_set_capability(idev, EV_KEY, BTN_THUMBR);
 334         input_set_capability(idev, EV_KEY, BTN_SELECT);
 335         input_set_capability(idev, EV_KEY, BTN_START);
 336
 337         err = psxpad_spi_init_ff(pad);
 338         if (err)
 339                 return err;
 340
 341         /* SPI settings */
 342         spi->mode = SPI_MODE_3;
 343         spi->bits_per_word = 8;
 344         /* (PlayStation 1/2 joypad might be possible works 250kHz/500kHz) */
 345         spi->master->min_speed_hz = 125000;
 346         spi->master->max_speed_hz = 125000;
 347         spi_setup(spi);
 348
 349         /* pad settings */
 350         psxpad_set_motor_level(pad, 0, 0);
 351
 352
 353         err = input_setup_polling(idev, psxpad_spi_poll);
 354         if (err) {
 355                 dev_err(&spi->dev, "failed to set up polling: %d\n", err);
 356                 return err;
 357         }
 358
 359         /* poll interval is about 60fps */
 360         input_set_poll_interval(idev, 16);
 361         input_set_min_poll_interval(idev, 8);
 362         input_set_max_poll_interval(idev, 32);
 363
 364         /* register input poll device */
 365         err = input_register_device(idev);
 366         if (err) {
 367                 dev_err(&spi->dev,
 368                         "failed to register input device: %d\n", err);
 369                 return err;
 370         }
 371
 372         pm_runtime_enable(&spi->dev);
 373
 374         return 0;
 375 }
 376
 377 static int psxpad_spi_suspend(struct device *dev)
 378 {
 379         struct spi_device *spi = to_spi_device(dev);
 380         struct psxpad *pad = spi_get_drvdata(spi);
 381
 382         psxpad_set_motor_level(pad, 0, 0);
 383
 384         return 0;
 385 }
 386
 387 static DEFINE_SIMPLE_DEV_PM_OPS(psxpad_spi_pm, psxpad_spi_suspend, NULL);
 388
 389 static const struct spi_device_id psxpad_spi_id[] = {
 390         { "psxpad-spi", 0 },
 391         { }
 392 };
 393 MODULE_DEVICE_TABLE(spi, psxpad_spi_id);
 394
 395 static struct spi_driver psxpad_spi_driver = {
 396         .driver = {
 397                 .name = "psxpad-spi",
 398                 .pm = pm_sleep_ptr(&psxpad_spi_pm),
 399         },
 400         .id_table = psxpad_spi_id,
 401         .probe   = psxpad_spi_probe,
 402 };
 403
 404 module_spi_driver(psxpad_spi_driver);
 405
 406 MODULE_AUTHOR("Tomohiro Yoshidomi <sylph23k@gmail.com>");
 407 MODULE_DESCRIPTION("PlayStation 1/2 joypads via SPI interface Driver");
 408 MODULE_LICENSE("GPL");