1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/kernel.h>
24#include <linux/errno.h>
25#include <linux/init.h>
26#include <linux/module.h>
27#include <linux/usb.h>
28#include <linux/backlight.h>
29#include <linux/timer.h>
30#include <linux/workqueue.h>
31#include <asm/atomic.h>
32
33#define APPLE_VENDOR_ID 0x05AC
34
35#define USB_REQ_GET_REPORT 0x01
36#define USB_REQ_SET_REPORT 0x09
37
38#define ACD_USB_TIMEOUT 250
39
40#define ACD_USB_EDID 0x0302
41#define ACD_USB_BRIGHTNESS 0x0310
42
43#define ACD_BTN_NONE 0
44#define ACD_BTN_BRIGHT_UP 3
45#define ACD_BTN_BRIGHT_DOWN 4
46
47#define ACD_URB_BUFFER_LEN 2
48#define ACD_MSG_BUFFER_LEN 2
49
50#define APPLEDISPLAY_DEVICE(prod) \
51 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
52 USB_DEVICE_ID_MATCH_INT_CLASS | \
53 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
54 .idVendor = APPLE_VENDOR_ID, \
55 .idProduct = (prod), \
56 .bInterfaceClass = USB_CLASS_HID, \
57 .bInterfaceProtocol = 0x00
58
59
60static struct usb_device_id appledisplay_table [] = {
61 { APPLEDISPLAY_DEVICE(0x9218) },
62 { APPLEDISPLAY_DEVICE(0x9219) },
63 { APPLEDISPLAY_DEVICE(0x921d) },
64
65
66 { }
67};
68MODULE_DEVICE_TABLE(usb, appledisplay_table);
69
70
71struct appledisplay {
72 struct usb_device *udev;
73 struct urb *urb;
74 struct backlight_device *bd;
75 char *urbdata;
76 char *msgdata;
77
78 struct delayed_work work;
79 int button_pressed;
80 spinlock_t lock;
81};
82
83static atomic_t count_displays = ATOMIC_INIT(0);
84static struct workqueue_struct *wq;
85
86static void appledisplay_complete(struct urb *urb)
87{
88 struct appledisplay *pdata = urb->context;
89 unsigned long flags;
90 int status = urb->status;
91 int retval;
92
93 switch (status) {
94 case 0:
95
96 break;
97 case -EOVERFLOW:
98 printk(KERN_ERR "appletouch: OVERFLOW with data "
99 "length %d, actual length is %d\n",
100 ACD_URB_BUFFER_LEN, pdata->urb->actual_length);
101 case -ECONNRESET:
102 case -ENOENT:
103 case -ESHUTDOWN:
104
105 dbg("%s - urb shuttingdown with status: %d",
106 __func__, status);
107 return;
108 default:
109 dbg("%s - nonzero urb status received: %d",
110 __func__, status);
111 goto exit;
112 }
113
114 spin_lock_irqsave(&pdata->lock, flags);
115
116 switch(pdata->urbdata[1]) {
117 case ACD_BTN_BRIGHT_UP:
118 case ACD_BTN_BRIGHT_DOWN:
119 pdata->button_pressed = 1;
120 queue_delayed_work(wq, &pdata->work, 0);
121 break;
122 case ACD_BTN_NONE:
123 default:
124 pdata->button_pressed = 0;
125 break;
126 }
127
128 spin_unlock_irqrestore(&pdata->lock, flags);
129
130exit:
131 retval = usb_submit_urb(pdata->urb, GFP_ATOMIC);
132 if (retval) {
133 dev_err(&pdata->udev->dev,
134 "%s - usb_submit_urb failed with result %d\n",
135 __func__, retval);
136 }
137}
138
139static int appledisplay_bl_update_status(struct backlight_device *bd)
140{
141 struct appledisplay *pdata = bl_get_data(bd);
142 int retval;
143
144 pdata->msgdata[0] = 0x10;
145 pdata->msgdata[1] = bd->props.brightness;
146
147 retval = usb_control_msg(
148 pdata->udev,
149 usb_sndctrlpipe(pdata->udev, 0),
150 USB_REQ_SET_REPORT,
151 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
152 ACD_USB_BRIGHTNESS,
153 0,
154 pdata->msgdata, 2,
155 ACD_USB_TIMEOUT);
156
157 return retval;
158}
159
160static int appledisplay_bl_get_brightness(struct backlight_device *bd)
161{
162 struct appledisplay *pdata = bl_get_data(bd);
163 int retval;
164
165 retval = usb_control_msg(
166 pdata->udev,
167 usb_rcvctrlpipe(pdata->udev, 0),
168 USB_REQ_GET_REPORT,
169 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
170 ACD_USB_BRIGHTNESS,
171 0,
172 pdata->msgdata, 2,
173 ACD_USB_TIMEOUT);
174
175 if (retval < 0)
176 return retval;
177 else
178 return pdata->msgdata[1];
179}
180
181static struct backlight_ops appledisplay_bl_data = {
182 .get_brightness = appledisplay_bl_get_brightness,
183 .update_status = appledisplay_bl_update_status,
184};
185
186static void appledisplay_work(struct work_struct *work)
187{
188 struct appledisplay *pdata =
189 container_of(work, struct appledisplay, work.work);
190 int retval;
191
192 retval = appledisplay_bl_get_brightness(pdata->bd);
193 if (retval >= 0)
194 pdata->bd->props.brightness = retval;
195
196
197 if (pdata->button_pressed)
198 schedule_delayed_work(&pdata->work, HZ / 8);
199}
200
201static int appledisplay_probe(struct usb_interface *iface,
202 const struct usb_device_id *id)
203{
204 struct appledisplay *pdata;
205 struct usb_device *udev = interface_to_usbdev(iface);
206 struct usb_host_interface *iface_desc;
207 struct usb_endpoint_descriptor *endpoint;
208 int int_in_endpointAddr = 0;
209 int i, retval = -ENOMEM, brightness;
210 char bl_name[20];
211
212
213
214 iface_desc = iface->cur_altsetting;
215 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
216 endpoint = &iface_desc->endpoint[i].desc;
217 if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
218
219 int_in_endpointAddr = endpoint->bEndpointAddress;
220 break;
221 }
222 }
223 if (!int_in_endpointAddr) {
224 dev_err(&iface->dev, "Could not find int-in endpoint\n");
225 return -EIO;
226 }
227
228
229 pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL);
230 if (!pdata) {
231 retval = -ENOMEM;
232 dev_err(&iface->dev, "Out of memory\n");
233 goto error;
234 }
235
236 pdata->udev = udev;
237
238 spin_lock_init(&pdata->lock);
239 INIT_DELAYED_WORK(&pdata->work, appledisplay_work);
240
241
242 pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL);
243 if (!pdata->msgdata) {
244 retval = -ENOMEM;
245 dev_err(&iface->dev,
246 "Allocating buffer for control messages failed\n");
247 goto error;
248 }
249
250
251 pdata->urb = usb_alloc_urb(0, GFP_KERNEL);
252 if (!pdata->urb) {
253 retval = -ENOMEM;
254 dev_err(&iface->dev, "Allocating URB failed\n");
255 goto error;
256 }
257
258
259 pdata->urbdata = usb_buffer_alloc(pdata->udev, ACD_URB_BUFFER_LEN,
260 GFP_KERNEL, &pdata->urb->transfer_dma);
261 if (!pdata->urbdata) {
262 retval = -ENOMEM;
263 dev_err(&iface->dev, "Allocating URB buffer failed\n");
264 goto error;
265 }
266
267
268 usb_fill_int_urb(pdata->urb, udev,
269 usb_rcvintpipe(udev, int_in_endpointAddr),
270 pdata->urbdata, ACD_URB_BUFFER_LEN, appledisplay_complete,
271 pdata, 1);
272 if (usb_submit_urb(pdata->urb, GFP_KERNEL)) {
273 retval = -EIO;
274 dev_err(&iface->dev, "Submitting URB failed\n");
275 goto error;
276 }
277
278
279 snprintf(bl_name, sizeof(bl_name), "appledisplay%d",
280 atomic_inc_return(&count_displays) - 1);
281 pdata->bd = backlight_device_register(bl_name, NULL, pdata,
282 &appledisplay_bl_data);
283 if (IS_ERR(pdata->bd)) {
284 dev_err(&iface->dev, "Backlight registration failed\n");
285 goto error;
286 }
287
288 pdata->bd->props.max_brightness = 0xff;
289
290
291 brightness = appledisplay_bl_get_brightness(pdata->bd);
292
293 if (brightness < 0) {
294 retval = brightness;
295 dev_err(&iface->dev,
296 "Error while getting initial brightness: %d\n", retval);
297 goto error;
298 }
299
300
301 pdata->bd->props.brightness = brightness;
302
303
304 usb_set_intfdata(iface, pdata);
305
306 printk(KERN_INFO "appledisplay: Apple Cinema Display connected\n");
307
308 return 0;
309
310error:
311 if (pdata) {
312 if (pdata->urb) {
313 usb_kill_urb(pdata->urb);
314 if (pdata->urbdata)
315 usb_buffer_free(pdata->udev, ACD_URB_BUFFER_LEN,
316 pdata->urbdata, pdata->urb->transfer_dma);
317 usb_free_urb(pdata->urb);
318 }
319 if (pdata->bd && !IS_ERR(pdata->bd))
320 backlight_device_unregister(pdata->bd);
321 kfree(pdata->msgdata);
322 }
323 usb_set_intfdata(iface, NULL);
324 kfree(pdata);
325 return retval;
326}
327
328static void appledisplay_disconnect(struct usb_interface *iface)
329{
330 struct appledisplay *pdata = usb_get_intfdata(iface);
331
332 if (pdata) {
333 usb_kill_urb(pdata->urb);
334 cancel_delayed_work(&pdata->work);
335 backlight_device_unregister(pdata->bd);
336 usb_buffer_free(pdata->udev, ACD_URB_BUFFER_LEN,
337 pdata->urbdata, pdata->urb->transfer_dma);
338 usb_free_urb(pdata->urb);
339 kfree(pdata->msgdata);
340 kfree(pdata);
341 }
342
343 printk(KERN_INFO "appledisplay: Apple Cinema Display disconnected\n");
344}
345
346static struct usb_driver appledisplay_driver = {
347 .name = "appledisplay",
348 .probe = appledisplay_probe,
349 .disconnect = appledisplay_disconnect,
350 .id_table = appledisplay_table,
351};
352
353static int __init appledisplay_init(void)
354{
355 wq = create_singlethread_workqueue("appledisplay");
356 if (!wq) {
357 printk(KERN_ERR "appledisplay: Could not create work queue\n");
358 return -ENOMEM;
359 }
360
361 return usb_register(&appledisplay_driver);
362}
363
364static void __exit appledisplay_exit(void)
365{
366 flush_workqueue(wq);
367 destroy_workqueue(wq);
368 usb_deregister(&appledisplay_driver);
369}
370
371MODULE_AUTHOR("Michael Hanselmann");
372MODULE_DESCRIPTION("Apple Cinema Display driver");
373MODULE_LICENSE("GPL");
374
375module_init(appledisplay_init);
376module_exit(appledisplay_exit);
377