2 * A driver for the Griffin Technology, Inc. "PowerMate" USB controller dial.
4 * v1.1, (c)2002 William R Sowerbutts <will@sowerbutts.com>
6 * This device is a anodised aluminium knob which connects over USB. It can measure
7 * clockwise and anticlockwise rotation. The dial also acts as a pushbutton with
8 * a spring for automatic release. The base contains a pair of LEDs which illuminate
9 * the translucent base. It rotates without limit and reports its relative rotation
10 * back to the host when polled by the USB controller.
12 * Testing with the knob I have has shown that it measures approximately 94 "clicks"
13 * for one full rotation. Testing with my High Speed Rotation Actuator (ok, it was
14 * a variable speed cordless electric drill) has shown that the device can measure
15 * speeds of up to 7 clicks either clockwise or anticlockwise between pollings from
16 * the host. If it counts more than 7 clicks before it is polled, it will wrap back
17 * to zero and start counting again. This was at quite high speed, however, almost
18 * certainly faster than the human hand could turn it. Griffin say that it loses a
19 * pulse or two on a direction change; the granularity is so fine that I never
20 * noticed this in practice.
22 * The device's microcontroller can be programmed to set the LED to either a constant
23 * intensity, or to a rhythmic pulsing. Several patterns and speeds are available.
25 * Griffin were very happy to provide documentation and free hardware for development.
27 * Some userspace tools are available on the web: http://sowerbutts.com/powermate/
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/spinlock.h>
36 #include <linux/usb/input.h>
38 #define POWERMATE_VENDOR 0x077d /* Griffin Technology, Inc. */
39 #define POWERMATE_PRODUCT_NEW 0x0410 /* Griffin PowerMate */
40 #define POWERMATE_PRODUCT_OLD 0x04AA /* Griffin soundKnob */
42 #define CONTOUR_VENDOR 0x05f3 /* Contour Design, Inc. */
43 #define CONTOUR_JOG 0x0240 /* Jog and Shuttle */
45 /* these are the command codes we send to the device */
46 #define SET_STATIC_BRIGHTNESS 0x01
47 #define SET_PULSE_ASLEEP 0x02
48 #define SET_PULSE_AWAKE 0x03
49 #define SET_PULSE_MODE 0x04
51 /* these refer to bits in the powermate_device's requires_update field. */
52 #define UPDATE_STATIC_BRIGHTNESS (1<<0)
53 #define UPDATE_PULSE_ASLEEP (1<<1)
54 #define UPDATE_PULSE_AWAKE (1<<2)
55 #define UPDATE_PULSE_MODE (1<<3)
57 /* at least two versions of the hardware exist, with differing payload
58 sizes. the first three bytes always contain the "interesting" data in
59 the relevant format. */
60 #define POWERMATE_PAYLOAD_SIZE_MAX 6
61 #define POWERMATE_PAYLOAD_SIZE_MIN 3
62 struct powermate_device
{
65 struct urb
*irq
, *config
;
66 struct usb_ctrlrequest
*configcr
;
67 struct usb_device
*udev
;
68 struct usb_interface
*intf
;
69 struct input_dev
*input
;
71 int static_brightness
;
76 int requires_update
; // physical settings which are out of sync
80 static char pm_name_powermate
[] = "Griffin PowerMate";
81 static char pm_name_soundknob
[] = "Griffin SoundKnob";
83 static void powermate_config_complete(struct urb
*urb
);
85 /* Callback for data arriving from the PowerMate over the USB interrupt pipe */
86 static void powermate_irq(struct urb
*urb
)
88 struct powermate_device
*pm
= urb
->context
;
89 struct device
*dev
= &pm
->intf
->dev
;
92 switch (urb
->status
) {
99 /* this urb is terminated, clean up */
100 dev_dbg(dev
, "%s - urb shutting down with status: %d\n",
101 __func__
, urb
->status
);
104 dev_dbg(dev
, "%s - nonzero urb status received: %d\n",
105 __func__
, urb
->status
);
109 /* handle updates to device state */
110 input_report_key(pm
->input
, BTN_0
, pm
->data
[0] & 0x01);
111 input_report_rel(pm
->input
, REL_DIAL
, pm
->data
[1]);
112 input_sync(pm
->input
);
115 retval
= usb_submit_urb (urb
, GFP_ATOMIC
);
117 dev_err(dev
, "%s - usb_submit_urb failed with result: %d\n",
121 /* Decide if we need to issue a control message and do so. Must be called with pm->lock taken */
122 static void powermate_sync_state(struct powermate_device
*pm
)
124 if (pm
->requires_update
== 0)
125 return; /* no updates are required */
126 if (pm
->config
->status
== -EINPROGRESS
)
127 return; /* an update is already in progress; it'll issue this update when it completes */
129 if (pm
->requires_update
& UPDATE_PULSE_ASLEEP
){
130 pm
->configcr
->wValue
= cpu_to_le16( SET_PULSE_ASLEEP
);
131 pm
->configcr
->wIndex
= cpu_to_le16( pm
->pulse_asleep
? 1 : 0 );
132 pm
->requires_update
&= ~UPDATE_PULSE_ASLEEP
;
133 }else if (pm
->requires_update
& UPDATE_PULSE_AWAKE
){
134 pm
->configcr
->wValue
= cpu_to_le16( SET_PULSE_AWAKE
);
135 pm
->configcr
->wIndex
= cpu_to_le16( pm
->pulse_awake
? 1 : 0 );
136 pm
->requires_update
&= ~UPDATE_PULSE_AWAKE
;
137 }else if (pm
->requires_update
& UPDATE_PULSE_MODE
){
139 /* the powermate takes an operation and an argument for its pulse algorithm.
140 the operation can be:
142 1: pulse at normal speed
143 2: multiply the speed
144 the argument only has an effect for operations 0 and 2, and ranges between
145 1 (least effect) to 255 (maximum effect).
147 thus, several states are equivalent and are coalesced into one state.
149 we map this onto a range from 0 to 510, with:
150 0 -- 254 -- use divide (0 = slowest)
151 255 -- use normal speed
152 256 -- 510 -- use multiple (510 = fastest).
154 Only values of 'arg' quite close to 255 are particularly useful/spectacular.
156 if (pm
->pulse_speed
< 255) {
158 arg
= 255 - pm
->pulse_speed
;
159 } else if (pm
->pulse_speed
> 255) {
161 arg
= pm
->pulse_speed
- 255;
163 op
= 1; // normal speed
164 arg
= 0; // can be any value
166 pm
->configcr
->wValue
= cpu_to_le16( (pm
->pulse_table
<< 8) | SET_PULSE_MODE
);
167 pm
->configcr
->wIndex
= cpu_to_le16( (arg
<< 8) | op
);
168 pm
->requires_update
&= ~UPDATE_PULSE_MODE
;
169 } else if (pm
->requires_update
& UPDATE_STATIC_BRIGHTNESS
) {
170 pm
->configcr
->wValue
= cpu_to_le16( SET_STATIC_BRIGHTNESS
);
171 pm
->configcr
->wIndex
= cpu_to_le16( pm
->static_brightness
);
172 pm
->requires_update
&= ~UPDATE_STATIC_BRIGHTNESS
;
174 printk(KERN_ERR
"powermate: unknown update required");
175 pm
->requires_update
= 0; /* fudge the bug */
179 /* printk("powermate: %04x %04x\n", pm->configcr->wValue, pm->configcr->wIndex); */
181 pm
->configcr
->bRequestType
= 0x41; /* vendor request */
182 pm
->configcr
->bRequest
= 0x01;
183 pm
->configcr
->wLength
= 0;
185 usb_fill_control_urb(pm
->config
, pm
->udev
, usb_sndctrlpipe(pm
->udev
, 0),
186 (void *) pm
->configcr
, NULL
, 0,
187 powermate_config_complete
, pm
);
189 if (usb_submit_urb(pm
->config
, GFP_ATOMIC
))
190 printk(KERN_ERR
"powermate: usb_submit_urb(config) failed");
193 /* Called when our asynchronous control message completes. We may need to issue another immediately */
194 static void powermate_config_complete(struct urb
*urb
)
196 struct powermate_device
*pm
= urb
->context
;
200 printk(KERN_ERR
"powermate: config urb returned %d\n", urb
->status
);
202 spin_lock_irqsave(&pm
->lock
, flags
);
203 powermate_sync_state(pm
);
204 spin_unlock_irqrestore(&pm
->lock
, flags
);
207 /* Set the LED up as described and begin the sync with the hardware if required */
208 static void powermate_pulse_led(struct powermate_device
*pm
, int static_brightness
, int pulse_speed
,
209 int pulse_table
, int pulse_asleep
, int pulse_awake
)
217 if (pulse_speed
> 510)
222 pulse_asleep
= !!pulse_asleep
;
223 pulse_awake
= !!pulse_awake
;
226 spin_lock_irqsave(&pm
->lock
, flags
);
228 /* mark state updates which are required */
229 if (static_brightness
!= pm
->static_brightness
) {
230 pm
->static_brightness
= static_brightness
;
231 pm
->requires_update
|= UPDATE_STATIC_BRIGHTNESS
;
233 if (pulse_asleep
!= pm
->pulse_asleep
) {
234 pm
->pulse_asleep
= pulse_asleep
;
235 pm
->requires_update
|= (UPDATE_PULSE_ASLEEP
| UPDATE_STATIC_BRIGHTNESS
);
237 if (pulse_awake
!= pm
->pulse_awake
) {
238 pm
->pulse_awake
= pulse_awake
;
239 pm
->requires_update
|= (UPDATE_PULSE_AWAKE
| UPDATE_STATIC_BRIGHTNESS
);
241 if (pulse_speed
!= pm
->pulse_speed
|| pulse_table
!= pm
->pulse_table
) {
242 pm
->pulse_speed
= pulse_speed
;
243 pm
->pulse_table
= pulse_table
;
244 pm
->requires_update
|= UPDATE_PULSE_MODE
;
247 powermate_sync_state(pm
);
249 spin_unlock_irqrestore(&pm
->lock
, flags
);
252 /* Callback from the Input layer when an event arrives from userspace to configure the LED */
253 static int powermate_input_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int _value
)
255 unsigned int command
= (unsigned int)_value
;
256 struct powermate_device
*pm
= input_get_drvdata(dev
);
258 if (type
== EV_MSC
&& code
== MSC_PULSELED
){
260 bits 0- 7: 8 bits: LED brightness
261 bits 8-16: 9 bits: pulsing speed modifier (0 ... 510); 0-254 = slower, 255 = standard, 256-510 = faster.
262 bits 17-18: 2 bits: pulse table (0, 1, 2 valid)
263 bit 19: 1 bit : pulse whilst asleep?
264 bit 20: 1 bit : pulse constantly?
266 int static_brightness
= command
& 0xFF; // bits 0-7
267 int pulse_speed
= (command
>> 8) & 0x1FF; // bits 8-16
268 int pulse_table
= (command
>> 17) & 0x3; // bits 17-18
269 int pulse_asleep
= (command
>> 19) & 0x1; // bit 19
270 int pulse_awake
= (command
>> 20) & 0x1; // bit 20
272 powermate_pulse_led(pm
, static_brightness
, pulse_speed
, pulse_table
, pulse_asleep
, pulse_awake
);
278 static int powermate_alloc_buffers(struct usb_device
*udev
, struct powermate_device
*pm
)
280 pm
->data
= usb_alloc_coherent(udev
, POWERMATE_PAYLOAD_SIZE_MAX
,
281 GFP_ATOMIC
, &pm
->data_dma
);
285 pm
->configcr
= kmalloc(sizeof(*(pm
->configcr
)), GFP_KERNEL
);
292 static void powermate_free_buffers(struct usb_device
*udev
, struct powermate_device
*pm
)
294 usb_free_coherent(udev
, POWERMATE_PAYLOAD_SIZE_MAX
,
295 pm
->data
, pm
->data_dma
);
299 /* Called whenever a USB device matching one in our supported devices table is connected */
300 static int powermate_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
302 struct usb_device
*udev
= interface_to_usbdev (intf
);
303 struct usb_host_interface
*interface
;
304 struct usb_endpoint_descriptor
*endpoint
;
305 struct powermate_device
*pm
;
306 struct input_dev
*input_dev
;
310 interface
= intf
->cur_altsetting
;
311 endpoint
= &interface
->endpoint
[0].desc
;
312 if (!usb_endpoint_is_int_in(endpoint
))
315 usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
316 0x0a, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
317 0, interface
->desc
.bInterfaceNumber
, NULL
, 0,
318 USB_CTRL_SET_TIMEOUT
);
320 pm
= kzalloc(sizeof(struct powermate_device
), GFP_KERNEL
);
321 input_dev
= input_allocate_device();
322 if (!pm
|| !input_dev
)
325 if (powermate_alloc_buffers(udev
, pm
))
328 pm
->irq
= usb_alloc_urb(0, GFP_KERNEL
);
332 pm
->config
= usb_alloc_urb(0, GFP_KERNEL
);
338 pm
->input
= input_dev
;
340 usb_make_path(udev
, pm
->phys
, sizeof(pm
->phys
));
341 strlcat(pm
->phys
, "/input0", sizeof(pm
->phys
));
343 spin_lock_init(&pm
->lock
);
345 switch (le16_to_cpu(udev
->descriptor
.idProduct
)) {
346 case POWERMATE_PRODUCT_NEW
:
347 input_dev
->name
= pm_name_powermate
;
349 case POWERMATE_PRODUCT_OLD
:
350 input_dev
->name
= pm_name_soundknob
;
353 input_dev
->name
= pm_name_soundknob
;
354 printk(KERN_WARNING
"powermate: unknown product id %04x\n",
355 le16_to_cpu(udev
->descriptor
.idProduct
));
358 input_dev
->phys
= pm
->phys
;
359 usb_to_input_id(udev
, &input_dev
->id
);
360 input_dev
->dev
.parent
= &intf
->dev
;
362 input_set_drvdata(input_dev
, pm
);
364 input_dev
->event
= powermate_input_event
;
366 input_dev
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_REL
) |
368 input_dev
->keybit
[BIT_WORD(BTN_0
)] = BIT_MASK(BTN_0
);
369 input_dev
->relbit
[BIT_WORD(REL_DIAL
)] = BIT_MASK(REL_DIAL
);
370 input_dev
->mscbit
[BIT_WORD(MSC_PULSELED
)] = BIT_MASK(MSC_PULSELED
);
372 /* get a handle to the interrupt data pipe */
373 pipe
= usb_rcvintpipe(udev
, endpoint
->bEndpointAddress
);
374 maxp
= usb_maxpacket(udev
, pipe
, usb_pipeout(pipe
));
376 if (maxp
< POWERMATE_PAYLOAD_SIZE_MIN
|| maxp
> POWERMATE_PAYLOAD_SIZE_MAX
) {
377 printk(KERN_WARNING
"powermate: Expected payload of %d--%d bytes, found %d bytes!\n",
378 POWERMATE_PAYLOAD_SIZE_MIN
, POWERMATE_PAYLOAD_SIZE_MAX
, maxp
);
379 maxp
= POWERMATE_PAYLOAD_SIZE_MAX
;
382 usb_fill_int_urb(pm
->irq
, udev
, pipe
, pm
->data
,
384 pm
, endpoint
->bInterval
);
385 pm
->irq
->transfer_dma
= pm
->data_dma
;
386 pm
->irq
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
388 /* register our interrupt URB with the USB system */
389 if (usb_submit_urb(pm
->irq
, GFP_KERNEL
)) {
394 error
= input_register_device(pm
->input
);
399 /* force an update of everything */
400 pm
->requires_update
= UPDATE_PULSE_ASLEEP
| UPDATE_PULSE_AWAKE
| UPDATE_PULSE_MODE
| UPDATE_STATIC_BRIGHTNESS
;
401 powermate_pulse_led(pm
, 0x80, 255, 0, 1, 0); // set default pulse parameters
403 usb_set_intfdata(intf
, pm
);
406 fail5
: usb_kill_urb(pm
->irq
);
407 fail4
: usb_free_urb(pm
->config
);
408 fail3
: usb_free_urb(pm
->irq
);
409 fail2
: powermate_free_buffers(udev
, pm
);
410 fail1
: input_free_device(input_dev
);
415 /* Called when a USB device we've accepted ownership of is removed */
416 static void powermate_disconnect(struct usb_interface
*intf
)
418 struct powermate_device
*pm
= usb_get_intfdata (intf
);
420 usb_set_intfdata(intf
, NULL
);
422 pm
->requires_update
= 0;
423 usb_kill_urb(pm
->irq
);
424 input_unregister_device(pm
->input
);
425 usb_free_urb(pm
->irq
);
426 usb_free_urb(pm
->config
);
427 powermate_free_buffers(interface_to_usbdev(intf
), pm
);
433 static struct usb_device_id powermate_devices
[] = {
434 { USB_DEVICE(POWERMATE_VENDOR
, POWERMATE_PRODUCT_NEW
) },
435 { USB_DEVICE(POWERMATE_VENDOR
, POWERMATE_PRODUCT_OLD
) },
436 { USB_DEVICE(CONTOUR_VENDOR
, CONTOUR_JOG
) },
437 { } /* Terminating entry */
440 MODULE_DEVICE_TABLE (usb
, powermate_devices
);
442 static struct usb_driver powermate_driver
= {
444 .probe
= powermate_probe
,
445 .disconnect
= powermate_disconnect
,
446 .id_table
= powermate_devices
,
449 module_usb_driver(powermate_driver
);
451 MODULE_AUTHOR( "William R Sowerbutts" );
452 MODULE_DESCRIPTION( "Griffin Technology, Inc PowerMate driver" );
453 MODULE_LICENSE("GPL");