← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/media/rc/mceusb.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/rc/mceusb.c
1
1
/*
2
2
 * Driver for USB Windows Media Center Ed. eHome Infrared Transceivers
3
3
 *
4
 
 * Copyright (c) 2010 by Jarod Wilson <jarod@redhat.com>
 
4
 * Copyright (c) 2010-2011, Jarod Wilson <jarod@redhat.com>
5
5
 *
6
6
 * Based on the original lirc_mceusb and lirc_mceusb2 drivers, by Dan
7
7
 * Conti, Martin Blatter and Daniel Melander, the latter of which was
15
15
 * Jon Smirl, which included enhancements and simplifications to the
16
16
 * incoming IR buffer parsing routines.
17
17
 *
 
18
 * Updated in July of 2011 with the aid of Microsoft's official
 
19
 * remote/transceiver requirements and specification document, found at
 
20
 * download.microsoft.com, title
 
21
 * Windows-Media-Center-RC-IR-Collection-Green-Button-Specification-03-08-2011-V2.pdf
 
22
 *
18
23
 *
19
24
 * This program is free software; you can redistribute it and/or modify
20
25
 * it under the terms of the GNU General Public License as published by
37
42
#include <linux/slab.h>
38
43
#include <linux/usb.h>
39
44
#include <linux/usb/input.h>
 
45
#include <linux/pm_wakeup.h>
40
46
#include <media/rc-core.h>
41
47
 
42
 
#define DRIVER_VERSION  "1.91"
43
 
#define DRIVER_AUTHOR   "Jarod Wilson <jarod@wilsonet.com>"
 
48
#define DRIVER_VERSION  "1.92"
 
49
#define DRIVER_AUTHOR   "Jarod Wilson <jarod@redhat.com>"
44
50
#define DRIVER_DESC     "Windows Media Center Ed. eHome Infrared Transceiver " \
45
51
                        "device driver"
46
52
#define DRIVER_NAME     "mceusb"
63
69
#define MCE_PULSE_MASK          0x7f /* Pulse mask */
64
70
#define MCE_MAX_PULSE_LENGTH    0x7f /* Longest transmittable pulse symbol */
65
71
 
66
 
#define MCE_HW_CMD_HEADER       0xff    /* MCE hardware command header */
67
 
#define MCE_COMMAND_HEADER      0x9f    /* MCE command header */
68
 
#define MCE_COMMAND_MASK        0xe0    /* Mask out command bits */
69
 
#define MCE_COMMAND_NULL        0x00    /* These show up various places... */
70
 
/* if buf[i] & MCE_COMMAND_MASK == 0x80 and buf[i] != MCE_COMMAND_HEADER,
71
 
 * then we're looking at a raw IR data sample */
72
 
#define MCE_COMMAND_IRDATA      0x80
73
 
#define MCE_PACKET_LENGTH_MASK  0x1f /* Packet length mask */
74
 
 
75
 
/* Sub-commands, which follow MCE_COMMAND_HEADER or MCE_HW_CMD_HEADER */
 
72
/*
 
73
 * The interface between the host and the IR hardware is command-response
 
74
 * based. All commands and responses have a consistent format, where a lead
 
75
 * byte always identifies the type of data following it. The lead byte has
 
76
 * a port value in the 3 highest bits and a length value in the 5 lowest
 
77
 * bits.
 
78
 *
 
79
 * The length field is overloaded, with a value of 11111 indicating that the
 
80
 * following byte is a command or response code, and the length of the entire
 
81
 * message is determined by the code. If the length field is not 11111, then
 
82
 * it specifies the number of bytes of port data that follow.
 
83
 */
 
84
#define MCE_CMD                 0x1f
 
85
#define MCE_PORT_IR             0x4     /* (0x4 << 5) | MCE_CMD = 0x9f */
 
86
#define MCE_PORT_SYS            0x7     /* (0x7 << 5) | MCE_CMD = 0xff */
 
87
#define MCE_PORT_SER            0x6     /* 0xc0 thru 0xdf flush & 0x1f bytes */
 
88
#define MCE_PORT_MASK   0xe0    /* Mask out command bits */
 
89
 
 
90
/* Command port headers */
 
91
#define MCE_CMD_PORT_IR         0x9f    /* IR-related cmd/rsp */
 
92
#define MCE_CMD_PORT_SYS        0xff    /* System (non-IR) device cmd/rsp */
 
93
 
 
94
/* Commands that set device state  (2-4 bytes in length) */
 
95
#define MCE_CMD_RESET           0xfe    /* Reset device, 2 bytes */
 
96
#define MCE_CMD_RESUME          0xaa    /* Resume device after error, 2 bytes */
 
97
#define MCE_CMD_SETIRCFS        0x06    /* Set tx carrier, 4 bytes */
 
98
#define MCE_CMD_SETIRTIMEOUT    0x0c    /* Set timeout, 4 bytes */
 
99
#define MCE_CMD_SETIRTXPORTS    0x08    /* Set tx ports, 3 bytes */
 
100
#define MCE_CMD_SETIRRXPORTEN   0x14    /* Set rx ports, 3 bytes */
 
101
#define MCE_CMD_FLASHLED        0x23    /* Flash receiver LED, 2 bytes */
 
102
 
 
103
/* Commands that query device state (all 2 bytes, unless noted) */
 
104
#define MCE_CMD_GETIRCFS        0x07    /* Get carrier */
 
105
#define MCE_CMD_GETIRTIMEOUT    0x0d    /* Get timeout */
 
106
#define MCE_CMD_GETIRTXPORTS    0x13    /* Get tx ports */
 
107
#define MCE_CMD_GETIRRXPORTEN   0x15    /* Get rx ports */
 
108
#define MCE_CMD_GETPORTSTATUS   0x11    /* Get tx port status, 3 bytes */
 
109
#define MCE_CMD_GETIRNUMPORTS   0x16    /* Get number of ports */
 
110
#define MCE_CMD_GETWAKESOURCE   0x17    /* Get wake source */
 
111
#define MCE_CMD_GETEMVER        0x22    /* Get emulator interface version */
 
112
#define MCE_CMD_GETDEVDETAILS   0x21    /* Get device details (em ver2 only) */
 
113
#define MCE_CMD_GETWAKESUPPORT  0x20    /* Get wake details (em ver2 only) */
 
114
#define MCE_CMD_GETWAKEVERSION  0x18    /* Get wake pattern (em ver2 only) */
 
115
 
 
116
/* Misc commands */
 
117
#define MCE_CMD_NOP             0xff    /* No operation */
 
118
 
 
119
/* Responses to commands (non-error cases) */
 
120
#define MCE_RSP_EQIRCFS         0x06    /* tx carrier, 4 bytes */
 
121
#define MCE_RSP_EQIRTIMEOUT     0x0c    /* rx timeout, 4 bytes */
 
122
#define MCE_RSP_GETWAKESOURCE   0x17    /* wake source, 3 bytes */
 
123
#define MCE_RSP_EQIRTXPORTS     0x08    /* tx port mask, 3 bytes */
 
124
#define MCE_RSP_EQIRRXPORTEN    0x14    /* rx port mask, 3 bytes */
 
125
#define MCE_RSP_GETPORTSTATUS   0x11    /* tx port status, 7 bytes */
 
126
#define MCE_RSP_EQIRRXCFCNT     0x15    /* rx carrier count, 4 bytes */
 
127
#define MCE_RSP_EQIRNUMPORTS    0x16    /* number of ports, 4 bytes */
 
128
#define MCE_RSP_EQWAKESUPPORT   0x20    /* wake capabilities, 3 bytes */
 
129
#define MCE_RSP_EQWAKEVERSION   0x18    /* wake pattern details, 6 bytes */
 
130
#define MCE_RSP_EQDEVDETAILS    0x21    /* device capabilities, 3 bytes */
 
131
#define MCE_RSP_EQEMVER         0x22    /* emulator interface ver, 3 bytes */
 
132
#define MCE_RSP_FLASHLED        0x23    /* success flashing LED, 2 bytes */
 
133
 
 
134
/* Responses to error cases, must send MCE_CMD_RESUME to clear them */
 
135
#define MCE_RSP_CMD_ILLEGAL     0xfe    /* illegal command for port, 2 bytes */
 
136
#define MCE_RSP_TX_TIMEOUT      0x81    /* tx timed out, 2 bytes */
 
137
 
 
138
/* Misc commands/responses not defined in the MCE remote/transceiver spec */
76
139
#define MCE_CMD_SIG_END         0x01    /* End of signal */
77
140
#define MCE_CMD_PING            0x03    /* Ping device */
78
141
#define MCE_CMD_UNKNOWN         0x04    /* Unknown */
79
142
#define MCE_CMD_UNKNOWN2        0x05    /* Unknown */
80
 
#define MCE_CMD_S_CARRIER       0x06    /* Set TX carrier frequency */
81
 
#define MCE_CMD_G_CARRIER       0x07    /* Get TX carrier frequency */
82
 
#define MCE_CMD_S_TXMASK        0x08    /* Set TX port bitmask */
83
143
#define MCE_CMD_UNKNOWN3        0x09    /* Unknown */
84
144
#define MCE_CMD_UNKNOWN4        0x0a    /* Unknown */
85
145
#define MCE_CMD_G_REVISION      0x0b    /* Get hw/sw revision */
86
 
#define MCE_CMD_S_TIMEOUT       0x0c    /* Set RX timeout value */
87
 
#define MCE_CMD_G_TIMEOUT       0x0d    /* Get RX timeout value */
88
146
#define MCE_CMD_UNKNOWN5        0x0e    /* Unknown */
89
147
#define MCE_CMD_UNKNOWN6        0x0f    /* Unknown */
90
 
#define MCE_CMD_G_RXPORTSTS     0x11    /* Get RX port status */
91
 
#define MCE_CMD_G_TXMASK        0x13    /* Set TX port bitmask */
92
 
#define MCE_CMD_S_RXSENSOR      0x14    /* Set RX sensor (std/learning) */
93
 
#define MCE_CMD_G_RXSENSOR      0x15    /* Get RX sensor (std/learning) */
94
 
#define MCE_RSP_PULSE_COUNT     0x15    /* RX pulse count (only if learning) */
95
 
#define MCE_CMD_TX_PORTS        0x16    /* Get number of TX ports */
96
 
#define MCE_CMD_G_WAKESRC       0x17    /* Get wake source */
97
 
#define MCE_CMD_UNKNOWN7        0x18    /* Unknown */
98
148
#define MCE_CMD_UNKNOWN8        0x19    /* Unknown */
99
149
#define MCE_CMD_UNKNOWN9        0x1b    /* Unknown */
100
 
#define MCE_CMD_DEVICE_RESET    0xaa    /* Reset the hardware */
101
 
#define MCE_RSP_CMD_INVALID     0xfe    /* Invalid command issued */
 
150
#define MCE_CMD_NULL            0x00    /* These show up various places... */
102
151
 
 
152
/* if buf[i] & MCE_PORT_MASK == 0x80 and buf[i] != MCE_CMD_PORT_IR,
 
153
 * then we're looking at a raw IR data sample */
 
154
#define MCE_COMMAND_IRDATA      0x80
 
155
#define MCE_PACKET_LENGTH_MASK  0x1f /* Packet length mask */
103
156
 
104
157
/* module parameters */
105
158
#ifdef CONFIG_USB_DEBUG
388
441
        char name[128];
389
442
        char phys[64];
390
443
        enum mceusb_model_type model;
 
444
 
 
445
        bool need_reset;        /* flag to issue a device resume cmd */
 
446
        u8 emver;               /* emulator interface version */
 
447
        u8 num_txports;         /* number of transmit ports */
 
448
        u8 num_rxports;         /* number of receive sensors */
 
449
        u8 txports_cabled;      /* bitmask of transmitters with cable */
 
450
        u8 rxports_active;      /* bitmask of active receive sensors */
391
451
};
392
452
 
393
 
/*
394
 
 * MCE Device Command Strings
395
 
 * Device command responses vary from device to device...
396
 
 * - DEVICE_RESET resets the hardware to its default state
397
 
 * - GET_REVISION fetches the hardware/software revision, common
398
 
 *   replies are ff 0b 45 ff 1b 08 and ff 0b 50 ff 1b 42
399
 
 * - GET_CARRIER_FREQ gets the carrier mode and frequency of the
400
 
 *   device, with replies in the form of 9f 06 MM FF, where MM is 0-3,
401
 
 *   meaning clk of 10000000, 2500000, 625000 or 156250, and FF is
402
 
 *   ((clk / frequency) - 1)
403
 
 * - GET_RX_TIMEOUT fetches the receiver timeout in units of 50us,
404
 
 *   response in the form of 9f 0c msb lsb
405
 
 * - GET_TX_BITMASK fetches the transmitter bitmask, replies in
406
 
 *   the form of 9f 08 bm, where bm is the bitmask
407
 
 * - GET_RX_SENSOR fetches the RX sensor setting -- long-range
408
 
 *   general use one or short-range learning one, in the form of
409
 
 *   9f 14 ss, where ss is either 01 for long-range or 02 for short
410
 
 * - SET_CARRIER_FREQ sets a new carrier mode and frequency
411
 
 * - SET_TX_BITMASK sets the transmitter bitmask
412
 
 * - SET_RX_TIMEOUT sets the receiver timeout
413
 
 * - SET_RX_SENSOR sets which receiver sensor to use
414
 
 */
415
 
static char DEVICE_RESET[]      = {MCE_COMMAND_NULL, MCE_HW_CMD_HEADER,
416
 
                                   MCE_CMD_DEVICE_RESET};
417
 
static char GET_REVISION[]      = {MCE_HW_CMD_HEADER, MCE_CMD_G_REVISION};
418
 
static char GET_UNKNOWN[]       = {MCE_HW_CMD_HEADER, MCE_CMD_UNKNOWN7};
419
 
static char GET_UNKNOWN2[]      = {MCE_COMMAND_HEADER, MCE_CMD_UNKNOWN2};
420
 
static char GET_CARRIER_FREQ[]  = {MCE_COMMAND_HEADER, MCE_CMD_G_CARRIER};
421
 
static char GET_RX_TIMEOUT[]    = {MCE_COMMAND_HEADER, MCE_CMD_G_TIMEOUT};
422
 
static char GET_TX_BITMASK[]    = {MCE_COMMAND_HEADER, MCE_CMD_G_TXMASK};
423
 
static char GET_RX_SENSOR[]     = {MCE_COMMAND_HEADER, MCE_CMD_G_RXSENSOR};
 
453
/* MCE Device Command Strings, generally a port and command pair */
 
454
static char DEVICE_RESUME[]     = {MCE_CMD_NULL, MCE_CMD_PORT_SYS,
 
455
                                   MCE_CMD_RESUME};
 
456
static char GET_REVISION[]      = {MCE_CMD_PORT_SYS, MCE_CMD_G_REVISION};
 
457
static char GET_EMVER[]         = {MCE_CMD_PORT_SYS, MCE_CMD_GETEMVER};
 
458
static char GET_WAKEVERSION[]   = {MCE_CMD_PORT_SYS, MCE_CMD_GETWAKEVERSION};
 
459
static char FLASH_LED[]         = {MCE_CMD_PORT_SYS, MCE_CMD_FLASHLED};
 
460
static char GET_UNKNOWN2[]      = {MCE_CMD_PORT_IR, MCE_CMD_UNKNOWN2};
 
461
static char GET_CARRIER_FREQ[]  = {MCE_CMD_PORT_IR, MCE_CMD_GETIRCFS};
 
462
static char GET_RX_TIMEOUT[]    = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTIMEOUT};
 
463
static char GET_NUM_PORTS[]     = {MCE_CMD_PORT_IR, MCE_CMD_GETIRNUMPORTS};
 
464
static char GET_TX_BITMASK[]    = {MCE_CMD_PORT_IR, MCE_CMD_GETIRTXPORTS};
 
465
static char GET_RX_SENSOR[]     = {MCE_CMD_PORT_IR, MCE_CMD_GETIRRXPORTEN};
424
466
/* sub in desired values in lower byte or bytes for full command */
425
467
/* FIXME: make use of these for transmit.
426
 
static char SET_CARRIER_FREQ[]  = {MCE_COMMAND_HEADER,
427
 
                                   MCE_CMD_S_CARRIER, 0x00, 0x00};
428
 
static char SET_TX_BITMASK[]    = {MCE_COMMAND_HEADER, MCE_CMD_S_TXMASK, 0x00};
429
 
static char SET_RX_TIMEOUT[]    = {MCE_COMMAND_HEADER,
430
 
                                   MCE_CMD_S_TIMEOUT, 0x00, 0x00};
431
 
static char SET_RX_SENSOR[]     = {MCE_COMMAND_HEADER,
432
 
                                   MCE_CMD_S_RXSENSOR, 0x00};
 
468
static char SET_CARRIER_FREQ[]  = {MCE_CMD_PORT_IR,
 
469
                                   MCE_CMD_SETIRCFS, 0x00, 0x00};
 
470
static char SET_TX_BITMASK[]    = {MCE_CMD_PORT_IR, MCE_CMD_SETIRTXPORTS, 0x00};
 
471
static char SET_RX_TIMEOUT[]    = {MCE_CMD_PORT_IR,
 
472
                                   MCE_CMD_SETIRTIMEOUT, 0x00, 0x00};
 
473
static char SET_RX_SENSOR[]     = {MCE_CMD_PORT_IR,
 
474
                                   MCE_RSP_EQIRRXPORTEN, 0x00};
433
475
*/
434
476
 
435
477
static int mceusb_cmdsize(u8 cmd, u8 subcmd)
437
479
        int datasize = 0;
438
480
 
439
481
        switch (cmd) {
440
 
        case MCE_COMMAND_NULL:
441
 
                if (subcmd == MCE_HW_CMD_HEADER)
 
482
        case MCE_CMD_NULL:
 
483
                if (subcmd == MCE_CMD_PORT_SYS)
442
484
                        datasize = 1;
443
485
                break;
444
 
        case MCE_HW_CMD_HEADER:
 
486
        case MCE_CMD_PORT_SYS:
445
487
                switch (subcmd) {
 
488
                case MCE_RSP_EQWAKEVERSION:
 
489
                        datasize = 4;
 
490
                        break;
446
491
                case MCE_CMD_G_REVISION:
447
492
                        datasize = 2;
448
493
                        break;
 
494
                case MCE_RSP_EQWAKESUPPORT:
 
495
                        datasize = 1;
 
496
                        break;
449
497
                }
450
 
        case MCE_COMMAND_HEADER:
 
498
        case MCE_CMD_PORT_IR:
451
499
                switch (subcmd) {
452
500
                case MCE_CMD_UNKNOWN:
453
 
                case MCE_CMD_S_CARRIER:
454
 
                case MCE_CMD_S_TIMEOUT:
455
 
                case MCE_RSP_PULSE_COUNT:
 
501
                case MCE_RSP_EQIRCFS:
 
502
                case MCE_RSP_EQIRTIMEOUT:
 
503
                case MCE_RSP_EQIRRXCFCNT:
456
504
                        datasize = 2;
457
505
                        break;
458
506
                case MCE_CMD_SIG_END:
459
 
                case MCE_CMD_S_TXMASK:
460
 
                case MCE_CMD_S_RXSENSOR:
 
507
                case MCE_RSP_EQIRTXPORTS:
 
508
                case MCE_RSP_EQIRRXPORTEN:
461
509
                        datasize = 1;
462
510
                        break;
463
511
                }
470
518
{
471
519
        char codes[USB_BUFLEN * 3 + 1];
472
520
        char inout[9];
473
 
        u8 cmd, subcmd, data1, data2;
 
521
        u8 cmd, subcmd, data1, data2, data3, data4, data5;
474
522
        struct device *dev = ir->dev;
475
523
        int i, start, skip = 0;
 
524
        u32 carrier, period;
476
525
 
477
526
        if (!debug)
478
527
                return;
500
549
        subcmd = buf[start + 1] & 0xff;
501
550
        data1  = buf[start + 2] & 0xff;
502
551
        data2  = buf[start + 3] & 0xff;
 
552
        data3  = buf[start + 4] & 0xff;
 
553
        data4  = buf[start + 5] & 0xff;
 
554
        data5  = buf[start + 6] & 0xff;
503
555
 
504
556
        switch (cmd) {
505
 
        case MCE_COMMAND_NULL:
506
 
                if ((subcmd == MCE_HW_CMD_HEADER) &&
507
 
                    (data1 == MCE_CMD_DEVICE_RESET))
508
 
                        dev_info(dev, "Device reset requested\n");
 
557
        case MCE_CMD_NULL:
 
558
                if (subcmd == MCE_CMD_NULL)
 
559
                        break;
 
560
                if ((subcmd == MCE_CMD_PORT_SYS) &&
 
561
                    (data1 == MCE_CMD_RESUME))
 
562
                        dev_info(dev, "Device resume requested\n");
509
563
                else
510
564
                        dev_info(dev, "Unknown command 0x%02x 0x%02x\n",
511
565
                                 cmd, subcmd);
512
566
                break;
513
 
        case MCE_HW_CMD_HEADER:
 
567
        case MCE_CMD_PORT_SYS:
514
568
                switch (subcmd) {
 
569
                case MCE_RSP_EQEMVER:
 
570
                        if (!out)
 
571
                                dev_info(dev, "Emulator interface version %x\n",
 
572
                                         data1);
 
573
                        break;
515
574
                case MCE_CMD_G_REVISION:
516
575
                        if (len == 2)
517
576
                                dev_info(dev, "Get hw/sw rev?\n");
520
579
                                         "0x%02x 0x%02x\n", data1, data2,
521
580
                                         buf[start + 4], buf[start + 5]);
522
581
                        break;
523
 
                case MCE_CMD_DEVICE_RESET:
524
 
                        dev_info(dev, "Device reset requested\n");
525
 
                        break;
526
 
                case MCE_RSP_CMD_INVALID:
527
 
                        dev_info(dev, "Previous command not supported\n");
528
 
                        break;
529
 
                case MCE_CMD_UNKNOWN7:
530
 
                case MCE_CMD_UNKNOWN9:
 
582
                case MCE_CMD_RESUME:
 
583
                        dev_info(dev, "Device resume requested\n");
 
584
                        break;
 
585
                case MCE_RSP_CMD_ILLEGAL:
 
586
                        dev_info(dev, "Illegal PORT_SYS command\n");
 
587
                        break;
 
588
                case MCE_RSP_EQWAKEVERSION:
 
589
                        if (!out)
 
590
                                dev_info(dev, "Wake version, proto: 0x%02x, "
 
591
                                         "payload: 0x%02x, address: 0x%02x, "
 
592
                                         "version: 0x%02x\n",
 
593
                                         data1, data2, data3, data4);
 
594
                        break;
 
595
                case MCE_RSP_GETPORTSTATUS:
 
596
                        if (!out)
 
597
                                /* We use data1 + 1 here, to match hw labels */
 
598
                                dev_info(dev, "TX port %d: blaster is%s connected\n",
 
599
                                         data1 + 1, data4 ? " not" : "");
 
600
                        break;
 
601
                case MCE_CMD_FLASHLED:
 
602
                        dev_info(dev, "Attempting to flash LED\n");
 
603
                        break;
531
604
                default:
532
605
                        dev_info(dev, "Unknown command 0x%02x 0x%02x\n",
533
606
                                 cmd, subcmd);
534
607
                        break;
535
608
                }
536
609
                break;
537
 
        case MCE_COMMAND_HEADER:
 
610
        case MCE_CMD_PORT_IR:
538
611
                switch (subcmd) {
539
612
                case MCE_CMD_SIG_END:
540
613
                        dev_info(dev, "End of signal\n");
546
619
                        dev_info(dev, "Resp to 9f 05 of 0x%02x 0x%02x\n",
547
620
                                 data1, data2);
548
621
                        break;
549
 
                case MCE_CMD_S_CARRIER:
550
 
                        dev_info(dev, "%s carrier mode and freq of "
551
 
                                 "0x%02x 0x%02x\n", inout, data1, data2);
 
622
                case MCE_RSP_EQIRCFS:
 
623
                        period = DIV_ROUND_CLOSEST(
 
624
                                        (1 << data1 * 2) * (data2 + 1), 10);
 
625
                        if (!period)
 
626
                                break;
 
627
                        carrier = (1000 * 1000) / period;
 
628
                        dev_info(dev, "%s carrier of %u Hz (period %uus)\n",
 
629
                                 inout, carrier, period);
552
630
                        break;
553
 
                case MCE_CMD_G_CARRIER:
 
631
                case MCE_CMD_GETIRCFS:
554
632
                        dev_info(dev, "Get carrier mode and freq\n");
555
633
                        break;
556
 
                case MCE_CMD_S_TXMASK:
 
634
                case MCE_RSP_EQIRTXPORTS:
557
635
                        dev_info(dev, "%s transmit blaster mask of 0x%02x\n",
558
636
                                 inout, data1);
559
637
                        break;
560
 
                case MCE_CMD_S_TIMEOUT:
 
638
                case MCE_RSP_EQIRTIMEOUT:
561
639
                        /* value is in units of 50us, so x*50/1000 ms */
 
640
                        period = ((data1 << 8) | data2) * MCE_TIME_UNIT / 1000;
562
641
                        dev_info(dev, "%s receive timeout of %d ms\n",
563
 
                                 inout,
564
 
                                 ((data1 << 8) | data2) * MCE_TIME_UNIT / 1000);
 
642
                                 inout, period);
565
643
                        break;
566
 
                case MCE_CMD_G_TIMEOUT:
 
644
                case MCE_CMD_GETIRTIMEOUT:
567
645
                        dev_info(dev, "Get receive timeout\n");
568
646
                        break;
569
 
                case MCE_CMD_G_TXMASK:
 
647
                case MCE_CMD_GETIRTXPORTS:
570
648
                        dev_info(dev, "Get transmit blaster mask\n");
571
649
                        break;
572
 
                case MCE_CMD_S_RXSENSOR:
 
650
                case MCE_RSP_EQIRRXPORTEN:
573
651
                        dev_info(dev, "%s %s-range receive sensor in use\n",
574
652
                                 inout, data1 == 0x02 ? "short" : "long");
575
653
                        break;
576
 
                case MCE_CMD_G_RXSENSOR:
577
 
                /* aka MCE_RSP_PULSE_COUNT */
 
654
                case MCE_CMD_GETIRRXPORTEN:
 
655
                /* aka MCE_RSP_EQIRRXCFCNT */
578
656
                        if (out)
579
657
                                dev_info(dev, "Get receive sensor\n");
580
658
                        else if (ir->learning_enabled)
581
659
                                dev_info(dev, "RX pulse count: %d\n",
582
660
                                         ((data1 << 8) | data2));
583
661
                        break;
584
 
                case MCE_RSP_CMD_INVALID:
585
 
                        dev_info(dev, "Error! Hardware is likely wedged...\n");
586
 
                        break;
587
 
                case MCE_CMD_UNKNOWN2:
588
 
                case MCE_CMD_UNKNOWN3:
589
 
                case MCE_CMD_UNKNOWN5:
 
662
                case MCE_RSP_EQIRNUMPORTS:
 
663
                        if (out)
 
664
                                break;
 
665
                        dev_info(dev, "Num TX ports: %x, num RX ports: %x\n",
 
666
                                 data1, data2);
 
667
                        break;
 
668
                case MCE_RSP_CMD_ILLEGAL:
 
669
                        dev_info(dev, "Illegal PORT_IR command\n");
 
670
                        break;
590
671
                default:
591
672
                        dev_info(dev, "Unknown command 0x%02x 0x%02x\n",
592
673
                                 cmd, subcmd);
599
680
 
600
681
        if (cmd == MCE_IRDATA_TRAILER)
601
682
                dev_info(dev, "End of raw IR data\n");
602
 
        else if ((cmd != MCE_COMMAND_HEADER) &&
603
 
                 ((cmd & MCE_COMMAND_MASK) == MCE_COMMAND_IRDATA))
 
683
        else if ((cmd != MCE_CMD_PORT_IR) &&
 
684
                 ((cmd & MCE_PORT_MASK) == MCE_COMMAND_IRDATA))
604
685
                dev_info(dev, "Raw IR data, %d pulse/space samples\n", ir->rem);
605
686
}
606
687
 
616
697
        if (ir) {
617
698
                len = urb->actual_length;
618
699
 
619
 
                mce_dbg(ir->dev, "callback called (status=%d len=%d)\n",
620
 
                        urb->status, len);
621
 
 
622
700
                mceusb_dev_printdata(ir, urb->transfer_buffer, 0, len, true);
623
701
        }
624
702
 
683
761
 
684
762
static void mce_async_out(struct mceusb_dev *ir, unsigned char *data, int size)
685
763
{
 
764
        int rsize = sizeof(DEVICE_RESUME);
 
765
 
 
766
        if (ir->need_reset) {
 
767
                ir->need_reset = false;
 
768
                mce_request_packet(ir, DEVICE_RESUME, rsize, MCEUSB_TX);
 
769
                msleep(10);
 
770
        }
 
771
 
686
772
        mce_request_packet(ir, data, size, MCEUSB_TX);
 
773
        msleep(10);
687
774
}
688
775
 
689
776
static void mce_flush_rx_buffer(struct mceusb_dev *ir, int size)
692
779
}
693
780
 
694
781
/* Send data out the IR blaster port(s) */
695
 
static int mceusb_tx_ir(struct rc_dev *dev, int *txbuf, u32 n)
 
782
static int mceusb_tx_ir(struct rc_dev *dev, unsigned *txbuf, unsigned count)
696
783
{
697
784
        struct mceusb_dev *ir = dev->priv;
698
785
        int i, ret = 0;
699
 
        int count, cmdcount = 0;
 
786
        int cmdcount = 0;
700
787
        unsigned char *cmdbuf; /* MCE command buffer */
701
788
        long signal_duration = 0; /* Singnal length in us */
702
789
        struct timeval start_time, end_time;
703
790
 
704
791
        do_gettimeofday(&start_time);
705
792
 
706
 
        count = n / sizeof(int);
707
 
 
708
 
        cmdbuf = kzalloc(sizeof(int) * MCE_CMDBUF_SIZE, GFP_KERNEL);
 
793
        cmdbuf = kzalloc(sizeof(unsigned) * MCE_CMDBUF_SIZE, GFP_KERNEL);
709
794
        if (!cmdbuf)
710
795
                return -ENOMEM;
711
796
 
712
797
        /* MCE tx init header */
713
 
        cmdbuf[cmdcount++] = MCE_COMMAND_HEADER;
714
 
        cmdbuf[cmdcount++] = MCE_CMD_S_TXMASK;
 
798
        cmdbuf[cmdcount++] = MCE_CMD_PORT_IR;
 
799
        cmdbuf[cmdcount++] = MCE_CMD_SETIRTXPORTS;
715
800
        cmdbuf[cmdcount++] = ir->tx_mask;
716
801
 
717
802
        /* Generate mce packet data */
774
859
 
775
860
out:
776
861
        kfree(cmdbuf);
777
 
        return ret ? ret : n;
 
862
        return ret ? ret : count;
778
863
}
779
864
 
780
865
/* Sets active IR outputs -- mce devices typically have two */
797
882
        struct mceusb_dev *ir = dev->priv;
798
883
        int clk = 10000000;
799
884
        int prescaler = 0, divisor = 0;
800
 
        unsigned char cmdbuf[4] = { MCE_COMMAND_HEADER,
801
 
                                    MCE_CMD_S_CARRIER, 0x00, 0x00 };
 
885
        unsigned char cmdbuf[4] = { MCE_CMD_PORT_IR,
 
886
                                    MCE_CMD_SETIRCFS, 0x00, 0x00 };
802
887
 
803
888
        /* Carrier has changed */
804
889
        if (ir->carrier != carrier) {
846
931
        u8 lo = ir->buf_in[index + 2] & 0xff;
847
932
 
848
933
        switch (ir->buf_in[index]) {
 
934
        /* the one and only 5-byte return value command */
 
935
        case MCE_RSP_GETPORTSTATUS:
 
936
                if ((ir->buf_in[index + 4] & 0xff) == 0x00)
 
937
                        ir->txports_cabled |= 1 << hi;
 
938
                break;
 
939
 
849
940
        /* 2-byte return value commands */
850
 
        case MCE_CMD_S_TIMEOUT:
 
941
        case MCE_RSP_EQIRTIMEOUT:
851
942
                ir->rc->timeout = US_TO_NS((hi << 8 | lo) * MCE_TIME_UNIT);
852
943
                break;
 
944
        case MCE_RSP_EQIRNUMPORTS:
 
945
                ir->num_txports = hi;
 
946
                ir->num_rxports = lo;
 
947
                break;
853
948
 
854
949
        /* 1-byte return value commands */
855
 
        case MCE_CMD_S_TXMASK:
 
950
        case MCE_RSP_EQEMVER:
 
951
                ir->emver = hi;
 
952
                break;
 
953
        case MCE_RSP_EQIRTXPORTS:
856
954
                ir->tx_mask = hi;
857
955
                break;
858
 
        case MCE_CMD_S_RXSENSOR:
859
 
                ir->learning_enabled = (hi == 0x02);
 
956
        case MCE_RSP_EQIRRXPORTEN:
 
957
                ir->learning_enabled = ((hi & 0x02) == 0x02);
 
958
                ir->rxports_active = hi;
 
959
                break;
 
960
        case MCE_RSP_CMD_ILLEGAL:
 
961
                ir->need_reset = true;
860
962
                break;
861
963
        default:
862
964
                break;
905
1007
                        /* decode mce packets of the form (84),AA,BB,CC,DD */
906
1008
                        /* IR data packets can span USB messages - rem */
907
1009
                        ir->cmd = ir->buf_in[i];
908
 
                        if ((ir->cmd == MCE_COMMAND_HEADER) ||
909
 
                            ((ir->cmd & MCE_COMMAND_MASK) !=
 
1010
                        if ((ir->cmd == MCE_CMD_PORT_IR) ||
 
1011
                            ((ir->cmd & MCE_PORT_MASK) !=
910
1012
                             MCE_COMMAND_IRDATA)) {
911
1013
                                ir->parser_state = SUBCMD;
912
1014
                                continue;
971
1073
        usb_submit_urb(urb, GFP_ATOMIC);
972
1074
}
973
1075
 
 
1076
static void mceusb_get_emulator_version(struct mceusb_dev *ir)
 
1077
{
 
1078
        /* If we get no reply or an illegal command reply, its ver 1, says MS */
 
1079
        ir->emver = 1;
 
1080
        mce_async_out(ir, GET_EMVER, sizeof(GET_EMVER));
 
1081
}
 
1082
 
974
1083
static void mceusb_gen1_init(struct mceusb_dev *ir)
975
1084
{
976
1085
        int ret;
1013
1122
                              0x0000, 0x0100, NULL, 0, HZ * 3);
1014
1123
        mce_dbg(dev, "%s - retC = %d\n", __func__, ret);
1015
1124
 
1016
 
        /* device reset */
1017
 
        mce_async_out(ir, DEVICE_RESET, sizeof(DEVICE_RESET));
 
1125
        /* device resume */
 
1126
        mce_async_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1018
1127
 
1019
1128
        /* get hw/sw revision? */
1020
1129
        mce_async_out(ir, GET_REVISION, sizeof(GET_REVISION));
1024
1133
 
1025
1134
static void mceusb_gen2_init(struct mceusb_dev *ir)
1026
1135
{
1027
 
        /* device reset */
1028
 
        mce_async_out(ir, DEVICE_RESET, sizeof(DEVICE_RESET));
 
1136
        /* device resume */
 
1137
        mce_async_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1029
1138
 
1030
1139
        /* get hw/sw revision? */
1031
1140
        mce_async_out(ir, GET_REVISION, sizeof(GET_REVISION));
1032
1141
 
1033
 
        /* unknown what the next two actually return... */
1034
 
        mce_async_out(ir, GET_UNKNOWN, sizeof(GET_UNKNOWN));
 
1142
        /* get wake version (protocol, key, address) */
 
1143
        mce_async_out(ir, GET_WAKEVERSION, sizeof(GET_WAKEVERSION));
 
1144
 
 
1145
        /* unknown what this one actually returns... */
1035
1146
        mce_async_out(ir, GET_UNKNOWN2, sizeof(GET_UNKNOWN2));
1036
1147
}
1037
1148
 
1038
1149
static void mceusb_get_parameters(struct mceusb_dev *ir)
1039
1150
{
 
1151
        int i;
 
1152
        unsigned char cmdbuf[3] = { MCE_CMD_PORT_SYS,
 
1153
                                    MCE_CMD_GETPORTSTATUS, 0x00 };
 
1154
 
 
1155
        /* defaults, if the hardware doesn't support querying */
 
1156
        ir->num_txports = 2;
 
1157
        ir->num_rxports = 2;
 
1158
 
 
1159
        /* get number of tx and rx ports */
 
1160
        mce_async_out(ir, GET_NUM_PORTS, sizeof(GET_NUM_PORTS));
 
1161
 
1040
1162
        /* get the carrier and frequency */
1041
1163
        mce_async_out(ir, GET_CARRIER_FREQ, sizeof(GET_CARRIER_FREQ));
1042
1164
 
1043
 
        if (!ir->flags.no_tx)
 
1165
        if (ir->num_txports && !ir->flags.no_tx)
1044
1166
                /* get the transmitter bitmask */
1045
1167
                mce_async_out(ir, GET_TX_BITMASK, sizeof(GET_TX_BITMASK));
1046
1168
 
1049
1171
 
1050
1172
        /* get receiver sensor setting */
1051
1173
        mce_async_out(ir, GET_RX_SENSOR, sizeof(GET_RX_SENSOR));
 
1174
 
 
1175
        for (i = 0; i < ir->num_txports; i++) {
 
1176
                cmdbuf[2] = i;
 
1177
                mce_async_out(ir, cmdbuf, sizeof(cmdbuf));
 
1178
        }
 
1179
}
 
1180
 
 
1181
static void mceusb_flash_led(struct mceusb_dev *ir)
 
1182
{
 
1183
        if (ir->emver < 2)
 
1184
                return;
 
1185
 
 
1186
        mce_async_out(ir, FLASH_LED, sizeof(FLASH_LED));
1052
1187
}
1053
1188
 
1054
1189
static struct rc_dev *mceusb_init_rc_dev(struct mceusb_dev *ir)
1222
1357
        mce_dbg(&intf->dev, "Flushing receive buffers\n");
1223
1358
        mce_flush_rx_buffer(ir, maxp);
1224
1359
 
 
1360
        /* figure out which firmware/emulator version this hardware has */
 
1361
        mceusb_get_emulator_version(ir);
 
1362
 
1225
1363
        /* initialize device */
1226
1364
        if (ir->flags.microsoft_gen1)
1227
1365
                mceusb_gen1_init(ir);
1230
1368
 
1231
1369
        mceusb_get_parameters(ir);
1232
1370
 
 
1371
        mceusb_flash_led(ir);
 
1372
 
1233
1373
        if (!ir->flags.no_tx)
1234
1374
                mceusb_set_tx_mask(ir->rc, MCE_DEFAULT_TX_MASK);
1235
1375
 
1236
1376
        usb_set_intfdata(intf, ir);
1237
1377
 
1238
 
        dev_info(&intf->dev, "Registered %s on usb%d:%d\n", name,
1239
 
                 dev->bus->busnum, dev->devnum);
 
1378
        /* enable wake via this device */
 
1379
        device_set_wakeup_capable(ir->dev, true);
 
1380
        device_set_wakeup_enable(ir->dev, true);
 
1381
 
 
1382
        dev_info(&intf->dev, "Registered %s with mce emulator interface "
 
1383
                 "version %x\n", name, ir->emver);
 
1384
        dev_info(&intf->dev, "%x tx ports (0x%x cabled) and "
 
1385
                 "%x rx sensors (0x%x active)\n",
 
1386
                 ir->num_txports, ir->txports_cabled,
 
1387
                 ir->num_rxports, ir->rxports_active);
1240
1388
 
1241
1389
        return 0;
1242
1390