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 dma_addr_t configcr_dma
;
68 struct usb_device
*udev
;
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
, struct pt_regs
*regs
);
85 /* Callback for data arriving from the PowerMate over the USB interrupt pipe */
86 static void powermate_irq(struct urb
*urb
, struct pt_regs
*regs
)
88 struct powermate_device
*pm
= urb
->context
;
91 switch (urb
->status
) {
98 /* this urb is terminated, clean up */
99 dbg("%s - urb shutting down with status: %d", __FUNCTION__
, urb
->status
);
102 dbg("%s - nonzero urb status received: %d", __FUNCTION__
, urb
->status
);
106 /* handle updates to device state */
107 input_regs(pm
->input
, regs
);
108 input_report_key(pm
->input
, BTN_0
, pm
->data
[0] & 0x01);
109 input_report_rel(pm
->input
, REL_DIAL
, pm
->data
[1]);
110 input_sync(pm
->input
);
113 retval
= usb_submit_urb (urb
, GFP_ATOMIC
);
115 err ("%s - usb_submit_urb failed with result %d",
116 __FUNCTION__
, retval
);
119 /* Decide if we need to issue a control message and do so. Must be called with pm->lock taken */
120 static void powermate_sync_state(struct powermate_device
*pm
)
122 if (pm
->requires_update
== 0)
123 return; /* no updates are required */
124 if (pm
->config
->status
== -EINPROGRESS
)
125 return; /* an update is already in progress; it'll issue this update when it completes */
127 if (pm
->requires_update
& UPDATE_PULSE_ASLEEP
){
128 pm
->configcr
->wValue
= cpu_to_le16( SET_PULSE_ASLEEP
);
129 pm
->configcr
->wIndex
= cpu_to_le16( pm
->pulse_asleep
? 1 : 0 );
130 pm
->requires_update
&= ~UPDATE_PULSE_ASLEEP
;
131 }else if (pm
->requires_update
& UPDATE_PULSE_AWAKE
){
132 pm
->configcr
->wValue
= cpu_to_le16( SET_PULSE_AWAKE
);
133 pm
->configcr
->wIndex
= cpu_to_le16( pm
->pulse_awake
? 1 : 0 );
134 pm
->requires_update
&= ~UPDATE_PULSE_AWAKE
;
135 }else if (pm
->requires_update
& UPDATE_PULSE_MODE
){
137 /* the powermate takes an operation and an argument for its pulse algorithm.
138 the operation can be:
140 1: pulse at normal speed
141 2: multiply the speed
142 the argument only has an effect for operations 0 and 2, and ranges between
143 1 (least effect) to 255 (maximum effect).
145 thus, several states are equivalent and are coalesced into one state.
147 we map this onto a range from 0 to 510, with:
148 0 -- 254 -- use divide (0 = slowest)
149 255 -- use normal speed
150 256 -- 510 -- use multiple (510 = fastest).
152 Only values of 'arg' quite close to 255 are particularly useful/spectacular.
154 if (pm
->pulse_speed
< 255) {
156 arg
= 255 - pm
->pulse_speed
;
157 } else if (pm
->pulse_speed
> 255) {
159 arg
= pm
->pulse_speed
- 255;
161 op
= 1; // normal speed
162 arg
= 0; // can be any value
164 pm
->configcr
->wValue
= cpu_to_le16( (pm
->pulse_table
<< 8) | SET_PULSE_MODE
);
165 pm
->configcr
->wIndex
= cpu_to_le16( (arg
<< 8) | op
);
166 pm
->requires_update
&= ~UPDATE_PULSE_MODE
;
167 } else if (pm
->requires_update
& UPDATE_STATIC_BRIGHTNESS
) {
168 pm
->configcr
->wValue
= cpu_to_le16( SET_STATIC_BRIGHTNESS
);
169 pm
->configcr
->wIndex
= cpu_to_le16( pm
->static_brightness
);
170 pm
->requires_update
&= ~UPDATE_STATIC_BRIGHTNESS
;
172 printk(KERN_ERR
"powermate: unknown update required");
173 pm
->requires_update
= 0; /* fudge the bug */
177 /* printk("powermate: %04x %04x\n", pm->configcr->wValue, pm->configcr->wIndex); */
179 pm
->configcr
->bRequestType
= 0x41; /* vendor request */
180 pm
->configcr
->bRequest
= 0x01;
181 pm
->configcr
->wLength
= 0;
183 usb_fill_control_urb(pm
->config
, pm
->udev
, usb_sndctrlpipe(pm
->udev
, 0),
184 (void *) pm
->configcr
, NULL
, 0,
185 powermate_config_complete
, pm
);
186 pm
->config
->setup_dma
= pm
->configcr_dma
;
187 pm
->config
->transfer_flags
|= URB_NO_SETUP_DMA_MAP
;
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
, struct pt_regs
*regs
)
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
= dev
->private;
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_buffer_alloc(udev
, POWERMATE_PAYLOAD_SIZE_MAX
,
281 SLAB_ATOMIC
, &pm
->data_dma
);
285 pm
->configcr
= usb_buffer_alloc(udev
, sizeof(*(pm
->configcr
)),
286 SLAB_ATOMIC
, &pm
->configcr_dma
);
293 static void powermate_free_buffers(struct usb_device
*udev
, struct powermate_device
*pm
)
296 usb_buffer_free(udev
, POWERMATE_PAYLOAD_SIZE_MAX
,
297 pm
->data
, pm
->data_dma
);
299 usb_buffer_free(udev
, sizeof(*(pm
->configcr
)),
300 pm
->configcr
, pm
->configcr_dma
);
303 /* Called whenever a USB device matching one in our supported devices table is connected */
304 static int powermate_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
306 struct usb_device
*udev
= interface_to_usbdev (intf
);
307 struct usb_host_interface
*interface
;
308 struct usb_endpoint_descriptor
*endpoint
;
309 struct powermate_device
*pm
;
310 struct input_dev
*input_dev
;
314 interface
= intf
->cur_altsetting
;
315 endpoint
= &interface
->endpoint
[0].desc
;
316 if (!(endpoint
->bEndpointAddress
& 0x80))
318 if ((endpoint
->bmAttributes
& 3) != 3)
321 usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
322 0x0a, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
323 0, interface
->desc
.bInterfaceNumber
, NULL
, 0,
324 USB_CTRL_SET_TIMEOUT
);
326 pm
= kzalloc(sizeof(struct powermate_device
), GFP_KERNEL
);
327 input_dev
= input_allocate_device();
328 if (!pm
|| !input_dev
)
331 if (powermate_alloc_buffers(udev
, pm
))
334 pm
->irq
= usb_alloc_urb(0, GFP_KERNEL
);
338 pm
->config
= usb_alloc_urb(0, GFP_KERNEL
);
343 pm
->input
= input_dev
;
345 usb_make_path(udev
, pm
->phys
, sizeof(pm
->phys
));
346 strlcpy(pm
->phys
, "/input0", sizeof(pm
->phys
));
348 spin_lock_init(&pm
->lock
);
350 switch (le16_to_cpu(udev
->descriptor
.idProduct
)) {
351 case POWERMATE_PRODUCT_NEW
:
352 input_dev
->name
= pm_name_powermate
;
354 case POWERMATE_PRODUCT_OLD
:
355 input_dev
->name
= pm_name_soundknob
;
358 input_dev
->name
= pm_name_soundknob
;
359 printk(KERN_WARNING
"powermate: unknown product id %04x\n",
360 le16_to_cpu(udev
->descriptor
.idProduct
));
363 input_dev
->phys
= pm
->phys
;
364 usb_to_input_id(udev
, &input_dev
->id
);
365 input_dev
->cdev
.dev
= &intf
->dev
;
366 input_dev
->private = pm
;
368 input_dev
->event
= powermate_input_event
;
370 input_dev
->evbit
[0] = BIT(EV_KEY
) | BIT(EV_REL
) | BIT(EV_MSC
);
371 input_dev
->keybit
[LONG(BTN_0
)] = BIT(BTN_0
);
372 input_dev
->relbit
[LONG(REL_DIAL
)] = BIT(REL_DIAL
);
373 input_dev
->mscbit
[LONG(MSC_PULSELED
)] = BIT(MSC_PULSELED
);
375 /* get a handle to the interrupt data pipe */
376 pipe
= usb_rcvintpipe(udev
, endpoint
->bEndpointAddress
);
377 maxp
= usb_maxpacket(udev
, pipe
, usb_pipeout(pipe
));
379 if (maxp
< POWERMATE_PAYLOAD_SIZE_MIN
|| maxp
> POWERMATE_PAYLOAD_SIZE_MAX
) {
380 printk(KERN_WARNING
"powermate: Expected payload of %d--%d bytes, found %d bytes!\n",
381 POWERMATE_PAYLOAD_SIZE_MIN
, POWERMATE_PAYLOAD_SIZE_MAX
, maxp
);
382 maxp
= POWERMATE_PAYLOAD_SIZE_MAX
;
385 usb_fill_int_urb(pm
->irq
, udev
, pipe
, pm
->data
,
387 pm
, endpoint
->bInterval
);
388 pm
->irq
->transfer_dma
= pm
->data_dma
;
389 pm
->irq
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
391 /* register our interrupt URB with the USB system */
392 if (usb_submit_urb(pm
->irq
, GFP_KERNEL
)) {
397 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 fail4
: usb_free_urb(pm
->config
);
407 fail3
: usb_free_urb(pm
->irq
);
408 fail2
: powermate_free_buffers(udev
, pm
);
409 fail1
: input_free_device(input_dev
);
414 /* Called when a USB device we've accepted ownership of is removed */
415 static void powermate_disconnect(struct usb_interface
*intf
)
417 struct powermate_device
*pm
= usb_get_intfdata (intf
);
419 usb_set_intfdata(intf
, NULL
);
421 pm
->requires_update
= 0;
422 usb_kill_urb(pm
->irq
);
423 input_unregister_device(pm
->input
);
424 usb_free_urb(pm
->irq
);
425 usb_free_urb(pm
->config
);
426 powermate_free_buffers(interface_to_usbdev(intf
), pm
);
432 static struct usb_device_id powermate_devices
[] = {
433 { USB_DEVICE(POWERMATE_VENDOR
, POWERMATE_PRODUCT_NEW
) },
434 { USB_DEVICE(POWERMATE_VENDOR
, POWERMATE_PRODUCT_OLD
) },
435 { USB_DEVICE(CONTOUR_VENDOR
, CONTOUR_JOG
) },
436 { } /* Terminating entry */
439 MODULE_DEVICE_TABLE (usb
, powermate_devices
);
441 static struct usb_driver powermate_driver
= {
443 .probe
= powermate_probe
,
444 .disconnect
= powermate_disconnect
,
445 .id_table
= powermate_devices
,
448 static int __init
powermate_init(void)
450 return usb_register(&powermate_driver
);
453 static void __exit
powermate_cleanup(void)
455 usb_deregister(&powermate_driver
);
458 module_init(powermate_init
);
459 module_exit(powermate_cleanup
);
461 MODULE_AUTHOR( "William R Sowerbutts" );
462 MODULE_DESCRIPTION( "Griffin Technology, Inc PowerMate driver" );
463 MODULE_LICENSE("GPL");