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