media/rc/xbox_remote.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 // Driver for Xbox DVD Movie Playback Kit
0003 // Copyright (c) 2018 by Benjamin Valentin <benpicco@googlemail.com>
0004
0005 /*
0006  *  Xbox DVD Movie Playback Kit USB IR dongle support
0007  *
0008  *  The driver was derived from the ati_remote driver 2.2.1
0009  *          and used information from lirc_xbox.c
0010  *
0011  *          Copyright (c) 2011, 2012 Anssi Hannula <anssi.hannula@iki.fi>
0012  *          Copyright (c) 2004 Torrey Hoffman <thoffman@arnor.net>
0013  *          Copyright (c) 2002 Vladimir Dergachev
0014  *          Copyright (c) 2003-2004 Paul Miller <pmiller9@users.sourceforge.net>
0015  */
0016
0017 #include <linux/slab.h>
0018 #include <linux/module.h>
0019 #include <linux/usb/input.h>
0020 #include <media/rc-core.h>
0021
0022 /*
0023  * Module and Version Information
0024  */
0025 #define DRIVER_VERSION  "1.0.0"
0026 #define DRIVER_AUTHOR   "Benjamin Valentin <benpicco@googlemail.com>"
0027 #define DRIVER_DESC     "Xbox DVD USB Remote Control"
0028
0029 #define NAME_BUFSIZE      80    /* size of product name, path buffers */
0030 #define DATA_BUFSIZE      8     /* size of URB data buffers */
0031
0032 /*
0033  * USB vendor ids for XBOX DVD Dongles
0034  */
0035 #define VENDOR_GAMESTER     0x040b
0036 #define VENDOR_MICROSOFT    0x045e
0037
0038 static const struct usb_device_id xbox_remote_table[] = {
0039     /* Gamester Xbox DVD Movie Playback Kit IR */
0040     {
0041         USB_DEVICE(VENDOR_GAMESTER, 0x6521),
0042     },
0043     /* Microsoft Xbox DVD Movie Playback Kit IR */
0044     {
0045         USB_DEVICE(VENDOR_MICROSOFT, 0x0284),
0046     },
0047     {}  /* Terminating entry */
0048 };
0049
0050 MODULE_DEVICE_TABLE(usb, xbox_remote_table);
0051
0052 struct xbox_remote {
0053     struct rc_dev *rdev;
0054     struct usb_device *udev;
0055     struct usb_interface *interface;
0056
0057     struct urb *irq_urb;
0058     unsigned char inbuf[DATA_BUFSIZE] __aligned(sizeof(u16));
0059
0060     char rc_name[NAME_BUFSIZE];
0061     char rc_phys[NAME_BUFSIZE];
0062 };
0063
0064 static int xbox_remote_rc_open(struct rc_dev *rdev)
0065 {
0066     struct xbox_remote *xbox_remote = rdev->priv;
0067
0068     /* On first open, submit the read urb which was set up previously. */
0069     xbox_remote->irq_urb->dev = xbox_remote->udev;
0070     if (usb_submit_urb(xbox_remote->irq_urb, GFP_KERNEL)) {
0071         dev_err(&xbox_remote->interface->dev,
0072             "%s: usb_submit_urb failed!\n", __func__);
0073         return -EIO;
0074     }
0075
0076     return 0;
0077 }
0078
0079 static void xbox_remote_rc_close(struct rc_dev *rdev)
0080 {
0081     struct xbox_remote *xbox_remote = rdev->priv;
0082
0083     usb_kill_urb(xbox_remote->irq_urb);
0084 }
0085
0086 /*
0087  * xbox_remote_report_input
0088  */
0089 static void xbox_remote_input_report(struct urb *urb)
0090 {
0091     struct xbox_remote *xbox_remote = urb->context;
0092     unsigned char *data = xbox_remote->inbuf;
0093
0094     /*
0095      * data[0] = 0x00
0096      * data[1] = length - always 0x06
0097      * data[2] = the key code
0098      * data[3] = high part of key code
0099      * data[4] = last_press_ms (low)
0100      * data[5] = last_press_ms (high)
0101      */
0102
0103     /* Deal with strange looking inputs */
0104     if (urb->actual_length != 6 || urb->actual_length != data[1]) {
0105         dev_warn(&urb->dev->dev, "Weird data, len=%d: %*ph\n",
0106              urb->actual_length, urb->actual_length, data);
0107         return;
0108     }
0109
0110     rc_keydown(xbox_remote->rdev, RC_PROTO_XBOX_DVD,
0111            le16_to_cpup((__le16 *)(data + 2)), 0);
0112 }
0113
0114 /*
0115  * xbox_remote_irq_in
0116  */
0117 static void xbox_remote_irq_in(struct urb *urb)
0118 {
0119     struct xbox_remote *xbox_remote = urb->context;
0120     int retval;
0121
0122     switch (urb->status) {
0123     case 0:         /* success */
0124         xbox_remote_input_report(urb);
0125         break;
0126     case -ECONNRESET:   /* unlink */
0127     case -ENOENT:
0128     case -ESHUTDOWN:
0129         dev_dbg(&xbox_remote->interface->dev,
0130             "%s: urb error status, unlink?\n",
0131             __func__);
0132         return;
0133     default:        /* error */
0134         dev_dbg(&xbox_remote->interface->dev,
0135             "%s: Nonzero urb status %d\n",
0136             __func__, urb->status);
0137     }
0138
0139     retval = usb_submit_urb(urb, GFP_ATOMIC);
0140     if (retval)
0141         dev_err(&xbox_remote->interface->dev,
0142             "%s: usb_submit_urb()=%d\n",
0143             __func__, retval);
0144 }
0145
0146 static void xbox_remote_rc_init(struct xbox_remote *xbox_remote)
0147 {
0148     struct rc_dev *rdev = xbox_remote->rdev;
0149
0150     rdev->priv = xbox_remote;
0151     rdev->allowed_protocols = RC_PROTO_BIT_XBOX_DVD;
0152     rdev->driver_name = "xbox_remote";
0153
0154     rdev->open = xbox_remote_rc_open;
0155     rdev->close = xbox_remote_rc_close;
0156
0157     rdev->device_name = xbox_remote->rc_name;
0158     rdev->input_phys = xbox_remote->rc_phys;
0159
0160     rdev->timeout = MS_TO_US(10);
0161
0162     usb_to_input_id(xbox_remote->udev, &rdev->input_id);
0163     rdev->dev.parent = &xbox_remote->interface->dev;
0164 }
0165
0166 static void xbox_remote_initialize(struct xbox_remote *xbox_remote,
0167                    struct usb_endpoint_descriptor *endpoint_in)
0168 {
0169     struct usb_device *udev = xbox_remote->udev;
0170     int pipe, maxp;
0171
0172     /* Set up irq_urb */
0173     pipe = usb_rcvintpipe(udev, endpoint_in->bEndpointAddress);
0174     maxp = usb_maxpacket(udev, pipe);
0175     maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp;
0176
0177     usb_fill_int_urb(xbox_remote->irq_urb, udev, pipe, xbox_remote->inbuf,
0178              maxp, xbox_remote_irq_in, xbox_remote,
0179              endpoint_in->bInterval);
0180 }
0181
0182 /*
0183  * xbox_remote_probe
0184  */
0185 static int xbox_remote_probe(struct usb_interface *interface,
0186                  const struct usb_device_id *id)
0187 {
0188     struct usb_device *udev = interface_to_usbdev(interface);
0189     struct usb_host_interface *iface_host = interface->cur_altsetting;
0190     struct usb_endpoint_descriptor *endpoint_in;
0191     struct xbox_remote *xbox_remote;
0192     struct rc_dev *rc_dev;
0193     int err = -ENOMEM;
0194
0195     // why is there also a device with no endpoints?
0196     if (iface_host->desc.bNumEndpoints == 0)
0197         return -ENODEV;
0198
0199     if (iface_host->desc.bNumEndpoints != 1) {
0200         pr_err("%s: Unexpected desc.bNumEndpoints: %d\n",
0201                __func__, iface_host->desc.bNumEndpoints);
0202         return -ENODEV;
0203     }
0204
0205     endpoint_in = &iface_host->endpoint[0].desc;
0206
0207     if (!usb_endpoint_is_int_in(endpoint_in)) {
0208         pr_err("%s: Unexpected endpoint_in\n", __func__);
0209         return -ENODEV;
0210     }
0211     if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) {
0212         pr_err("%s: endpoint_in message size==0?\n", __func__);
0213         return -ENODEV;
0214     }
0215
0216     xbox_remote = kzalloc(sizeof(*xbox_remote), GFP_KERNEL);
0217     rc_dev = rc_allocate_device(RC_DRIVER_SCANCODE);
0218     if (!xbox_remote || !rc_dev)
0219         goto exit_free_dev_rdev;
0220
0221     /* Allocate URB buffer */
0222     xbox_remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
0223     if (!xbox_remote->irq_urb)
0224         goto exit_free_buffers;
0225
0226     xbox_remote->udev = udev;
0227     xbox_remote->rdev = rc_dev;
0228     xbox_remote->interface = interface;
0229
0230     usb_make_path(udev, xbox_remote->rc_phys, sizeof(xbox_remote->rc_phys));
0231
0232     strlcat(xbox_remote->rc_phys, "/input0", sizeof(xbox_remote->rc_phys));
0233
0234     snprintf(xbox_remote->rc_name, sizeof(xbox_remote->rc_name), "%s%s%s",
0235          udev->manufacturer ?: "",
0236          udev->manufacturer && udev->product ? " " : "",
0237          udev->product ?: "");
0238
0239     if (!strlen(xbox_remote->rc_name))
0240         snprintf(xbox_remote->rc_name, sizeof(xbox_remote->rc_name),
0241              DRIVER_DESC "(%04x,%04x)",
0242              le16_to_cpu(xbox_remote->udev->descriptor.idVendor),
0243              le16_to_cpu(xbox_remote->udev->descriptor.idProduct));
0244
0245     rc_dev->map_name = RC_MAP_XBOX_DVD; /* default map */
0246
0247     xbox_remote_rc_init(xbox_remote);
0248
0249     /* Device Hardware Initialization */
0250     xbox_remote_initialize(xbox_remote, endpoint_in);
0251
0252     /* Set up and register rc device */
0253     err = rc_register_device(xbox_remote->rdev);
0254     if (err)
0255         goto exit_kill_urbs;
0256
0257     usb_set_intfdata(interface, xbox_remote);
0258
0259     return 0;
0260
0261 exit_kill_urbs:
0262     usb_kill_urb(xbox_remote->irq_urb);
0263 exit_free_buffers:
0264     usb_free_urb(xbox_remote->irq_urb);
0265 exit_free_dev_rdev:
0266     rc_free_device(rc_dev);
0267     kfree(xbox_remote);
0268
0269     return err;
0270 }
0271
0272 /*
0273  * xbox_remote_disconnect
0274  */
0275 static void xbox_remote_disconnect(struct usb_interface *interface)
0276 {
0277     struct xbox_remote *xbox_remote;
0278
0279     xbox_remote = usb_get_intfdata(interface);
0280     usb_set_intfdata(interface, NULL);
0281     if (!xbox_remote) {
0282         dev_warn(&interface->dev, "%s - null device?\n", __func__);
0283         return;
0284     }
0285
0286     usb_kill_urb(xbox_remote->irq_urb);
0287     rc_unregister_device(xbox_remote->rdev);
0288     usb_free_urb(xbox_remote->irq_urb);
0289     kfree(xbox_remote);
0290 }
0291
0292 /* usb specific object to register with the usb subsystem */
0293 static struct usb_driver xbox_remote_driver = {
0294     .name         = "xbox_remote",
0295     .probe        = xbox_remote_probe,
0296     .disconnect   = xbox_remote_disconnect,
0297     .id_table     = xbox_remote_table,
0298 };
0299
0300 module_usb_driver(xbox_remote_driver);
0301
0302 MODULE_AUTHOR(DRIVER_AUTHOR);
0303 MODULE_DESCRIPTION(DRIVER_DESC);
0304 MODULE_LICENSE("GPL");