1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * HID driver for the Prodikeys PC-MIDI Keyboard
4 * providing midi & extra multimedia keys functionality
6 * Copyright (c) 2009 Don Prince <dhprince.devel@yahoo.co.uk>
8 * Controls for Octave Shift Up/Down, Channel, and
9 * Sustain Duration available via sysfs.
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/device.h>
18 #include <linux/module.h>
19 #include <linux/usb.h>
20 #include <linux/mutex.h>
21 #include <linux/hid.h>
22 #include <sound/core.h>
23 #include <sound/initval.h>
24 #include <sound/rawmidi.h>
28 #define pk_debug(format, arg...) \
29 pr_debug("hid-prodikeys: " format "\n" , ## arg)
30 #define pk_error(format, arg...) \
31 pr_err("hid-prodikeys: " format "\n" , ## arg)
35 struct pcmidi_sustain
{
37 struct pcmidi_snd
*pm
;
38 struct timer_list timer
;
41 unsigned char velocity
;
44 #define PCMIDI_SUSTAINED_MAX 32
46 struct hid_device
*hdev
;
48 struct hid_report
*pcmidi_report6
;
49 struct input_dev
*input_ep82
;
50 unsigned short midi_mode
;
51 unsigned short midi_sustain_mode
;
52 unsigned short midi_sustain
;
53 unsigned short midi_channel
;
55 struct pcmidi_sustain sustained_notes
[PCMIDI_SUSTAINED_MAX
];
56 unsigned short fn_state
;
57 unsigned short last_key
[24];
58 spinlock_t rawmidi_in_lock
;
59 struct snd_card
*card
;
60 struct snd_rawmidi
*rwmidi
;
61 struct snd_rawmidi_substream
*in_substream
;
62 unsigned long in_triggered
;
65 #define PK_QUIRK_NOGET 0x00010000
66 #define PCMIDI_MIDDLE_C 60
67 #define PCMIDI_CHANNEL_MIN 0
68 #define PCMIDI_CHANNEL_MAX 15
69 #define PCMIDI_OCTAVE_MIN (-2)
70 #define PCMIDI_OCTAVE_MAX 2
71 #define PCMIDI_SUSTAIN_MIN 0
72 #define PCMIDI_SUSTAIN_MAX 5000
74 static const char shortname
[] = "PC-MIDI";
75 static const char longname
[] = "Prodikeys PC-MIDI Keyboard";
77 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
78 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
79 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
81 module_param_array(index
, int, NULL
, 0444);
82 module_param_array(id
, charp
, NULL
, 0444);
83 module_param_array(enable
, bool, NULL
, 0444);
84 MODULE_PARM_DESC(index
, "Index value for the PC-MIDI virtual audio driver");
85 MODULE_PARM_DESC(id
, "ID string for the PC-MIDI virtual audio driver");
86 MODULE_PARM_DESC(enable
, "Enable for the PC-MIDI virtual audio driver");
89 /* Output routine for the sysfs channel file */
90 static ssize_t
show_channel(struct device
*dev
,
91 struct device_attribute
*attr
, char *buf
)
93 struct hid_device
*hdev
= to_hid_device(dev
);
94 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
96 dbg_hid("pcmidi sysfs read channel=%u\n", pm
->midi_channel
);
98 return sprintf(buf
, "%u (min:%u, max:%u)\n", pm
->midi_channel
,
99 PCMIDI_CHANNEL_MIN
, PCMIDI_CHANNEL_MAX
);
102 /* Input routine for the sysfs channel file */
103 static ssize_t
store_channel(struct device
*dev
,
104 struct device_attribute
*attr
, const char *buf
, size_t count
)
106 struct hid_device
*hdev
= to_hid_device(dev
);
107 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
109 unsigned channel
= 0;
111 if (sscanf(buf
, "%u", &channel
) > 0 && channel
<= PCMIDI_CHANNEL_MAX
) {
112 dbg_hid("pcmidi sysfs write channel=%u\n", channel
);
113 pm
->midi_channel
= channel
;
119 static DEVICE_ATTR(channel
, S_IRUGO
| S_IWUSR
| S_IWGRP
, show_channel
,
122 static struct device_attribute
*sysfs_device_attr_channel
= {
126 /* Output routine for the sysfs sustain file */
127 static ssize_t
show_sustain(struct device
*dev
,
128 struct device_attribute
*attr
, char *buf
)
130 struct hid_device
*hdev
= to_hid_device(dev
);
131 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
133 dbg_hid("pcmidi sysfs read sustain=%u\n", pm
->midi_sustain
);
135 return sprintf(buf
, "%u (off:%u, max:%u (ms))\n", pm
->midi_sustain
,
136 PCMIDI_SUSTAIN_MIN
, PCMIDI_SUSTAIN_MAX
);
139 /* Input routine for the sysfs sustain file */
140 static ssize_t
store_sustain(struct device
*dev
,
141 struct device_attribute
*attr
, const char *buf
, size_t count
)
143 struct hid_device
*hdev
= to_hid_device(dev
);
144 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
146 unsigned sustain
= 0;
148 if (sscanf(buf
, "%u", &sustain
) > 0 && sustain
<= PCMIDI_SUSTAIN_MAX
) {
149 dbg_hid("pcmidi sysfs write sustain=%u\n", sustain
);
150 pm
->midi_sustain
= sustain
;
151 pm
->midi_sustain_mode
= (0 == sustain
|| !pm
->midi_mode
) ? 0 : 1;
157 static DEVICE_ATTR(sustain
, S_IRUGO
| S_IWUSR
| S_IWGRP
, show_sustain
,
160 static struct device_attribute
*sysfs_device_attr_sustain
= {
164 /* Output routine for the sysfs octave file */
165 static ssize_t
show_octave(struct device
*dev
,
166 struct device_attribute
*attr
, char *buf
)
168 struct hid_device
*hdev
= to_hid_device(dev
);
169 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
171 dbg_hid("pcmidi sysfs read octave=%d\n", pm
->midi_octave
);
173 return sprintf(buf
, "%d (min:%d, max:%d)\n", pm
->midi_octave
,
174 PCMIDI_OCTAVE_MIN
, PCMIDI_OCTAVE_MAX
);
177 /* Input routine for the sysfs octave file */
178 static ssize_t
store_octave(struct device
*dev
,
179 struct device_attribute
*attr
, const char *buf
, size_t count
)
181 struct hid_device
*hdev
= to_hid_device(dev
);
182 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
186 if (sscanf(buf
, "%d", &octave
) > 0 &&
187 octave
>= PCMIDI_OCTAVE_MIN
&& octave
<= PCMIDI_OCTAVE_MAX
) {
188 dbg_hid("pcmidi sysfs write octave=%d\n", octave
);
189 pm
->midi_octave
= octave
;
195 static DEVICE_ATTR(octave
, S_IRUGO
| S_IWUSR
| S_IWGRP
, show_octave
,
198 static struct device_attribute
*sysfs_device_attr_octave
= {
203 static void pcmidi_send_note(struct pcmidi_snd
*pm
,
204 unsigned char status
, unsigned char note
, unsigned char velocity
)
207 unsigned char buffer
[3];
211 buffer
[2] = velocity
;
213 spin_lock_irqsave(&pm
->rawmidi_in_lock
, flags
);
215 if (!pm
->in_substream
)
217 if (!test_bit(pm
->in_substream
->number
, &pm
->in_triggered
))
220 snd_rawmidi_receive(pm
->in_substream
, buffer
, 3);
223 spin_unlock_irqrestore(&pm
->rawmidi_in_lock
, flags
);
228 static void pcmidi_sustained_note_release(struct timer_list
*t
)
230 struct pcmidi_sustain
*pms
= from_timer(pms
, t
, timer
);
232 pcmidi_send_note(pms
->pm
, pms
->status
, pms
->note
, pms
->velocity
);
236 static void init_sustain_timers(struct pcmidi_snd
*pm
)
238 struct pcmidi_sustain
*pms
;
241 for (i
= 0; i
< PCMIDI_SUSTAINED_MAX
; i
++) {
242 pms
= &pm
->sustained_notes
[i
];
245 timer_setup(&pms
->timer
, pcmidi_sustained_note_release
, 0);
249 static void stop_sustain_timers(struct pcmidi_snd
*pm
)
251 struct pcmidi_sustain
*pms
;
254 for (i
= 0; i
< PCMIDI_SUSTAINED_MAX
; i
++) {
255 pms
= &pm
->sustained_notes
[i
];
257 del_timer_sync(&pms
->timer
);
261 static int pcmidi_get_output_report(struct pcmidi_snd
*pm
)
263 struct hid_device
*hdev
= pm
->hdev
;
264 struct hid_report
*report
;
266 list_for_each_entry(report
,
267 &hdev
->report_enum
[HID_OUTPUT_REPORT
].report_list
, list
) {
268 if (!(6 == report
->id
))
271 if (report
->maxfield
< 1) {
272 hid_err(hdev
, "output report is empty\n");
275 if (report
->field
[0]->report_count
!= 2) {
276 hid_err(hdev
, "field count too low\n");
279 pm
->pcmidi_report6
= report
;
282 /* should never get here */
286 static void pcmidi_submit_output_report(struct pcmidi_snd
*pm
, int state
)
288 struct hid_device
*hdev
= pm
->hdev
;
289 struct hid_report
*report
= pm
->pcmidi_report6
;
290 report
->field
[0]->value
[0] = 0x01;
291 report
->field
[0]->value
[1] = state
;
293 hid_hw_request(hdev
, report
, HID_REQ_SET_REPORT
);
296 static int pcmidi_handle_report1(struct pcmidi_snd
*pm
, u8
*data
)
301 bit_mask
= (bit_mask
<< 8) | data
[2];
302 bit_mask
= (bit_mask
<< 8) | data
[3];
304 dbg_hid("pcmidi mode: %d\n", pm
->midi_mode
);
306 /*KEY_MAIL or octave down*/
307 if (pm
->midi_mode
&& bit_mask
== 0x004000) {
310 if (pm
->midi_octave
< -2)
311 pm
->midi_octave
= -2;
312 dbg_hid("pcmidi mode: %d octave: %d\n",
313 pm
->midi_mode
, pm
->midi_octave
);
316 /*KEY_WWW or sustain*/
317 else if (pm
->midi_mode
&& bit_mask
== 0x000004) {
319 pm
->midi_sustain_mode
^= 0x1;
323 return 0; /* continue key processing */
326 static int pcmidi_handle_report3(struct pcmidi_snd
*pm
, u8
*data
, int size
)
328 struct pcmidi_sustain
*pms
;
330 unsigned char status
, note
, velocity
;
332 unsigned num_notes
= (size
-1)/2;
333 for (j
= 0; j
< num_notes
; j
++) {
335 velocity
= data
[j
*2+2];
337 if (note
< 0x81) { /* note on */
338 status
= 128 + 16 + pm
->midi_channel
; /* 1001nnnn */
339 note
= note
- 0x54 + PCMIDI_MIDDLE_C
+
340 (pm
->midi_octave
* 12);
342 velocity
= 1; /* force note on */
343 } else { /* note off */
344 status
= 128 + pm
->midi_channel
; /* 1000nnnn */
345 note
= note
- 0x94 + PCMIDI_MIDDLE_C
+
346 (pm
->midi_octave
*12);
348 if (pm
->midi_sustain_mode
) {
349 for (i
= 0; i
< PCMIDI_SUSTAINED_MAX
; i
++) {
350 pms
= &pm
->sustained_notes
[i
];
352 pms
->status
= status
;
354 pms
->velocity
= velocity
;
357 mod_timer(&pms
->timer
,
359 msecs_to_jiffies(pm
->midi_sustain
));
365 pcmidi_send_note(pm
, status
, note
, velocity
);
371 static int pcmidi_handle_report4(struct pcmidi_snd
*pm
, u8
*data
)
378 bit_mask
= (bit_mask
<< 8) | data
[2];
379 bit_mask
= (bit_mask
<< 8) | data
[3];
382 for (bit_index
= 0; bit_index
< 24; bit_index
++) {
383 if (!((0x01 << bit_index
) & bit_mask
)) {
384 input_event(pm
->input_ep82
, EV_KEY
,
385 pm
->last_key
[bit_index
], 0);
386 pm
->last_key
[bit_index
] = 0;
391 for (bit_index
= 0; bit_index
< 24; bit_index
++) {
393 switch ((0x01 << bit_index
) & bit_mask
) {
394 case 0x000010: /* Fn lock*/
395 pm
->fn_state
^= 0x000010;
397 pcmidi_submit_output_report(pm
, 0xc5);
399 pcmidi_submit_output_report(pm
, 0xc6);
401 case 0x020000: /* midi launcher..send a key (qwerty) or not? */
402 pcmidi_submit_output_report(pm
, 0xc1);
403 pm
->midi_mode
^= 0x01;
405 dbg_hid("pcmidi mode: %d\n", pm
->midi_mode
);
407 case 0x100000: /* KEY_MESSENGER or octave up */
408 dbg_hid("pcmidi mode: %d\n", pm
->midi_mode
);
411 if (pm
->midi_octave
> 2)
413 dbg_hid("pcmidi mode: %d octave: %d\n",
414 pm
->midi_mode
, pm
->midi_octave
);
423 key
= KEY_ADDRESSBOOK
;
429 key
= KEY_WORDPROCESSOR
;
432 key
= KEY_SPREADSHEET
;
447 key
= KEY_FORWARDMAIL
;
468 key
= KEY_SPELLCHECK
;
475 input_event(pm
->input_ep82
, EV_KEY
, key
, 1);
476 pm
->last_key
[bit_index
] = key
;
483 static int pcmidi_handle_report(
484 struct pcmidi_snd
*pm
, unsigned report_id
, u8
*data
, int size
)
489 case 0x01: /* midi keys (qwerty)*/
490 ret
= pcmidi_handle_report1(pm
, data
);
492 case 0x03: /* midi keyboard (musical)*/
493 ret
= pcmidi_handle_report3(pm
, data
, size
);
495 case 0x04: /* multimedia/midi keys (qwerty)*/
496 ret
= pcmidi_handle_report4(pm
, data
);
502 static void pcmidi_setup_extra_keys(
503 struct pcmidi_snd
*pm
, struct input_dev
*input
)
505 /* reassigned functionality for N/A keys
506 MY PICTURES => KEY_WORDPROCESSOR
507 MY MUSIC=> KEY_SPREADSHEET
509 static const unsigned int keys
[] = {
511 KEY_MESSENGER
, KEY_CALENDAR
,
512 KEY_ADDRESSBOOK
, KEY_DOCUMENTS
,
517 KEY_REPLY
, KEY_FORWARDMAIL
,
521 KEY_SPELLCHECK
, KEY_PRINT
,
525 const unsigned int *pkeys
= &keys
[0];
528 if (pm
->ifnum
!= 1) /* only set up ONCE for interace 1 */
531 pm
->input_ep82
= input
;
533 for (i
= 0; i
< 24; i
++)
536 while (*pkeys
!= 0) {
537 set_bit(*pkeys
, pm
->input_ep82
->keybit
);
542 static int pcmidi_set_operational(struct pcmidi_snd
*pm
)
547 return 0; /* only set up ONCE for interace 1 */
549 rc
= pcmidi_get_output_report(pm
);
552 pcmidi_submit_output_report(pm
, 0xc1);
556 static int pcmidi_snd_free(struct snd_device
*dev
)
561 static int pcmidi_in_open(struct snd_rawmidi_substream
*substream
)
563 struct pcmidi_snd
*pm
= substream
->rmidi
->private_data
;
565 dbg_hid("pcmidi in open\n");
566 pm
->in_substream
= substream
;
570 static int pcmidi_in_close(struct snd_rawmidi_substream
*substream
)
572 dbg_hid("pcmidi in close\n");
576 static void pcmidi_in_trigger(struct snd_rawmidi_substream
*substream
, int up
)
578 struct pcmidi_snd
*pm
= substream
->rmidi
->private_data
;
580 dbg_hid("pcmidi in trigger %d\n", up
);
582 pm
->in_triggered
= up
;
585 static const struct snd_rawmidi_ops pcmidi_in_ops
= {
586 .open
= pcmidi_in_open
,
587 .close
= pcmidi_in_close
,
588 .trigger
= pcmidi_in_trigger
591 static int pcmidi_snd_initialise(struct pcmidi_snd
*pm
)
594 struct snd_card
*card
;
595 struct snd_rawmidi
*rwmidi
;
598 static struct snd_device_ops ops
= {
599 .dev_free
= pcmidi_snd_free
,
603 return 0; /* only set up midi device ONCE for interace 1 */
605 if (dev
>= SNDRV_CARDS
)
613 /* Setup sound card */
615 err
= snd_card_new(&pm
->hdev
->dev
, index
[dev
], id
[dev
],
616 THIS_MODULE
, 0, &card
);
618 pk_error("failed to create pc-midi sound card\n");
624 /* Setup sound device */
625 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, pm
, &ops
);
627 pk_error("failed to create pc-midi sound device: error %d\n",
632 strscpy(card
->driver
, shortname
, sizeof(card
->driver
));
633 strscpy(card
->shortname
, shortname
, sizeof(card
->shortname
));
634 strscpy(card
->longname
, longname
, sizeof(card
->longname
));
637 err
= snd_rawmidi_new(card
, card
->shortname
, 0,
640 pk_error("failed to create pc-midi rawmidi device: error %d\n",
645 strscpy(rwmidi
->name
, card
->shortname
, sizeof(rwmidi
->name
));
646 rwmidi
->info_flags
= SNDRV_RAWMIDI_INFO_INPUT
;
647 rwmidi
->private_data
= pm
;
649 snd_rawmidi_set_ops(rwmidi
, SNDRV_RAWMIDI_STREAM_INPUT
,
652 /* create sysfs variables */
653 err
= device_create_file(&pm
->hdev
->dev
,
654 sysfs_device_attr_channel
);
656 pk_error("failed to create sysfs attribute channel: error %d\n",
661 err
= device_create_file(&pm
->hdev
->dev
,
662 sysfs_device_attr_sustain
);
664 pk_error("failed to create sysfs attribute sustain: error %d\n",
666 goto fail_attr_sustain
;
669 err
= device_create_file(&pm
->hdev
->dev
,
670 sysfs_device_attr_octave
);
672 pk_error("failed to create sysfs attribute octave: error %d\n",
674 goto fail_attr_octave
;
677 spin_lock_init(&pm
->rawmidi_in_lock
);
679 init_sustain_timers(pm
);
680 err
= pcmidi_set_operational(pm
);
682 pk_error("failed to find output report\n");
687 err
= snd_card_register(card
);
689 pk_error("failed to register pc-midi sound card: error %d\n",
694 dbg_hid("pcmidi_snd_initialise finished ok\n");
698 stop_sustain_timers(pm
);
699 device_remove_file(&pm
->hdev
->dev
, sysfs_device_attr_octave
);
701 device_remove_file(&pm
->hdev
->dev
, sysfs_device_attr_sustain
);
703 device_remove_file(&pm
->hdev
->dev
, sysfs_device_attr_channel
);
706 snd_card_free(pm
->card
);
712 static int pcmidi_snd_terminate(struct pcmidi_snd
*pm
)
715 stop_sustain_timers(pm
);
717 device_remove_file(&pm
->hdev
->dev
, sysfs_device_attr_channel
);
718 device_remove_file(&pm
->hdev
->dev
, sysfs_device_attr_sustain
);
719 device_remove_file(&pm
->hdev
->dev
, sysfs_device_attr_octave
);
721 snd_card_disconnect(pm
->card
);
722 snd_card_free_when_closed(pm
->card
);
729 * PC-MIDI report descriptor for report id is wrong.
731 static __u8
*pk_report_fixup(struct hid_device
*hdev
, __u8
*rdesc
,
735 rdesc
[111] == 0x06 && rdesc
[112] == 0x00 &&
736 rdesc
[113] == 0xff) {
738 "fixing up pc-midi keyboard report descriptor\n");
740 rdesc
[144] = 0x18; /* report 4: was 0x10 report count */
745 static int pk_input_mapping(struct hid_device
*hdev
, struct hid_input
*hi
,
746 struct hid_field
*field
, struct hid_usage
*usage
,
747 unsigned long **bit
, int *max
)
749 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
751 if (HID_UP_MSVENDOR
== (usage
->hid
& HID_USAGE_PAGE
) &&
753 pcmidi_setup_extra_keys(pm
, hi
->input
);
761 static int pk_raw_event(struct hid_device
*hdev
, struct hid_report
*report
,
764 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
767 if (1 == pm
->ifnum
) {
768 if (report
->id
== data
[0])
769 switch (report
->id
) {
770 case 0x01: /* midi keys (qwerty)*/
771 case 0x03: /* midi keyboard (musical)*/
772 case 0x04: /* extra/midi keys (qwerty)*/
773 ret
= pcmidi_handle_report(pm
,
774 report
->id
, data
, size
);
782 static int pk_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
785 struct usb_interface
*intf
;
786 unsigned short ifnum
;
787 unsigned long quirks
= id
->driver_data
;
788 struct pcmidi_snd
*pm
;
790 if (!hid_is_usb(hdev
))
793 intf
= to_usb_interface(hdev
->dev
.parent
);
794 ifnum
= intf
->cur_altsetting
->desc
.bInterfaceNumber
;
796 pm
= kzalloc(sizeof(*pm
), GFP_KERNEL
);
798 hid_err(hdev
, "can't alloc descriptor\n");
805 hid_set_drvdata(hdev
, pm
);
807 ret
= hid_parse(hdev
);
809 hid_err(hdev
, "hid parse failed\n");
813 if (quirks
& PK_QUIRK_NOGET
) { /* hid_parse cleared all the quirks */
814 hdev
->quirks
|= HID_QUIRK_NOGET
;
817 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
819 hid_err(hdev
, "hw start failed\n");
823 ret
= pcmidi_snd_initialise(pm
);
836 static void pk_remove(struct hid_device
*hdev
)
838 struct pcmidi_snd
*pm
= hid_get_drvdata(hdev
);
840 pcmidi_snd_terminate(pm
);
846 static const struct hid_device_id pk_devices
[] = {
847 {HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS
,
848 USB_DEVICE_ID_PRODIKEYS_PCMIDI
),
849 .driver_data
= PK_QUIRK_NOGET
},
852 MODULE_DEVICE_TABLE(hid
, pk_devices
);
854 static struct hid_driver pk_driver
= {
856 .id_table
= pk_devices
,
857 .report_fixup
= pk_report_fixup
,
858 .input_mapping
= pk_input_mapping
,
859 .raw_event
= pk_raw_event
,
863 module_hid_driver(pk_driver
);
865 MODULE_DESCRIPTION("HID driver for the Prodikeys PC-MIDI Keyboard");
866 MODULE_LICENSE("GPL");