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