1 // SPDX-License-Identifier: GPL-2.0
2 /*****************************************************************************
3 * USBLCD Kernel Driver *
5 * (C) 2005 Georges Toth <g.toth@e-biz.lu> *
7 * This file is licensed under the GPL. See COPYING in the package. *
8 * Based on usb-skeleton.c 2.0 by Greg Kroah-Hartman (greg@kroah.com) *
11 * 28.02.05 Complete rewrite of the original usblcd.c driver, *
12 * based on usb_skeleton.c. *
13 * This new driver allows more than one USB-LCD to be connected *
14 * and controlled, at once *
15 *****************************************************************************/
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/slab.h>
19 #include <linux/errno.h>
20 #include <linux/mutex.h>
21 #include <linux/uaccess.h>
22 #include <linux/usb.h>
24 #define DRIVER_VERSION "USBLCD Driver Version 1.05"
26 #define USBLCD_MINOR 144
28 #define IOCTL_GET_HARD_VERSION 1
29 #define IOCTL_GET_DRV_VERSION 2
32 static DEFINE_MUTEX(lcd_mutex
);
33 static const struct usb_device_id id_table
[] = {
34 { .idVendor
= 0x10D2, .match_flags
= USB_DEVICE_ID_MATCH_VENDOR
, },
37 MODULE_DEVICE_TABLE(usb
, id_table
);
39 static DEFINE_MUTEX(open_disc_mutex
);
43 struct usb_device
*udev
; /* init: probe_lcd */
44 struct usb_interface
*interface
; /* the interface for
46 unsigned char *bulk_in_buffer
; /* the buffer to receive
48 size_t bulk_in_size
; /* the size of the
50 __u8 bulk_in_endpointAddr
; /* the address of the
52 __u8 bulk_out_endpointAddr
; /* the address of the
55 struct semaphore limit_sem
; /* to stop writes at
58 struct usb_anchor submitted
; /* URBs to wait for
61 #define to_lcd_dev(d) container_of(d, struct usb_lcd, kref)
63 #define USB_LCD_CONCURRENT_WRITES 5
65 static struct usb_driver lcd_driver
;
68 static void lcd_delete(struct kref
*kref
)
70 struct usb_lcd
*dev
= to_lcd_dev(kref
);
72 usb_put_dev(dev
->udev
);
73 kfree(dev
->bulk_in_buffer
);
78 static int lcd_open(struct inode
*inode
, struct file
*file
)
81 struct usb_interface
*interface
;
84 mutex_lock(&lcd_mutex
);
85 subminor
= iminor(inode
);
87 interface
= usb_find_interface(&lcd_driver
, subminor
);
89 mutex_unlock(&lcd_mutex
);
90 printk(KERN_ERR
"USBLCD: %s - error, can't find device for minor %d\n",
95 mutex_lock(&open_disc_mutex
);
96 dev
= usb_get_intfdata(interface
);
98 mutex_unlock(&open_disc_mutex
);
99 mutex_unlock(&lcd_mutex
);
103 /* increment our usage count for the device */
104 kref_get(&dev
->kref
);
105 mutex_unlock(&open_disc_mutex
);
107 /* grab a power reference */
108 r
= usb_autopm_get_interface(interface
);
110 kref_put(&dev
->kref
, lcd_delete
);
111 mutex_unlock(&lcd_mutex
);
115 /* save our object in the file's private structure */
116 file
->private_data
= dev
;
117 mutex_unlock(&lcd_mutex
);
122 static int lcd_release(struct inode
*inode
, struct file
*file
)
126 dev
= file
->private_data
;
130 /* decrement the count on our device */
131 usb_autopm_put_interface(dev
->interface
);
132 kref_put(&dev
->kref
, lcd_delete
);
136 static ssize_t
lcd_read(struct file
*file
, char __user
* buffer
,
137 size_t count
, loff_t
*ppos
)
143 dev
= file
->private_data
;
145 /* do a blocking bulk read to get data from the device */
146 retval
= usb_bulk_msg(dev
->udev
,
147 usb_rcvbulkpipe(dev
->udev
,
148 dev
->bulk_in_endpointAddr
),
150 min(dev
->bulk_in_size
, count
),
153 /* if the read was successful, copy the data to userspace */
155 if (copy_to_user(buffer
, dev
->bulk_in_buffer
, bytes_read
))
164 static long lcd_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
170 dev
= file
->private_data
;
175 case IOCTL_GET_HARD_VERSION
:
176 mutex_lock(&lcd_mutex
);
177 bcdDevice
= le16_to_cpu((dev
->udev
)->descriptor
.bcdDevice
);
178 sprintf(buf
, "%1d%1d.%1d%1d",
179 (bcdDevice
& 0xF000)>>12,
180 (bcdDevice
& 0xF00)>>8,
181 (bcdDevice
& 0xF0)>>4,
183 mutex_unlock(&lcd_mutex
);
184 if (copy_to_user((void __user
*)arg
, buf
, strlen(buf
)) != 0)
187 case IOCTL_GET_DRV_VERSION
:
188 sprintf(buf
, DRIVER_VERSION
);
189 if (copy_to_user((void __user
*)arg
, buf
, strlen(buf
)) != 0)
200 static void lcd_write_bulk_callback(struct urb
*urb
)
203 int status
= urb
->status
;
207 /* sync/async unlink faults aren't errors */
209 !(status
== -ENOENT
||
210 status
== -ECONNRESET
||
211 status
== -ESHUTDOWN
)) {
212 dev_dbg(&dev
->interface
->dev
,
213 "nonzero write bulk status received: %d\n", status
);
216 /* free up our allocated buffer */
217 usb_free_coherent(urb
->dev
, urb
->transfer_buffer_length
,
218 urb
->transfer_buffer
, urb
->transfer_dma
);
222 static ssize_t
lcd_write(struct file
*file
, const char __user
* user_buffer
,
223 size_t count
, loff_t
*ppos
)
227 struct urb
*urb
= NULL
;
230 dev
= file
->private_data
;
232 /* verify that we actually have some data to write */
236 r
= down_interruptible(&dev
->limit_sem
);
240 /* create a urb, and a buffer for it, and copy the data to the urb */
241 urb
= usb_alloc_urb(0, GFP_KERNEL
);
247 buf
= usb_alloc_coherent(dev
->udev
, count
, GFP_KERNEL
,
254 if (copy_from_user(buf
, user_buffer
, count
)) {
259 /* initialize the urb properly */
260 usb_fill_bulk_urb(urb
, dev
->udev
,
261 usb_sndbulkpipe(dev
->udev
,
262 dev
->bulk_out_endpointAddr
),
263 buf
, count
, lcd_write_bulk_callback
, dev
);
264 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
266 usb_anchor_urb(urb
, &dev
->submitted
);
268 /* send the data out the bulk port */
269 retval
= usb_submit_urb(urb
, GFP_KERNEL
);
271 dev_err(&dev
->udev
->dev
,
272 "%s - failed submitting write urb, error %d\n",
277 /* release our reference to this urb,
278 the USB core will eventually free it entirely */
284 usb_unanchor_urb(urb
);
286 usb_free_coherent(dev
->udev
, count
, buf
, urb
->transfer_dma
);
293 static const struct file_operations lcd_fops
= {
294 .owner
= THIS_MODULE
,
298 .unlocked_ioctl
= lcd_ioctl
,
299 .release
= lcd_release
,
300 .llseek
= noop_llseek
,
304 * usb class driver info in order to get a minor number from the usb core,
305 * and to have the device registered with the driver core
307 static struct usb_class_driver lcd_class
= {
310 .minor_base
= USBLCD_MINOR
,
313 static int lcd_probe(struct usb_interface
*interface
,
314 const struct usb_device_id
*id
)
316 struct usb_lcd
*dev
= NULL
;
317 struct usb_endpoint_descriptor
*bulk_in
, *bulk_out
;
321 /* allocate memory for our device state and initialize it */
322 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
326 kref_init(&dev
->kref
);
327 sema_init(&dev
->limit_sem
, USB_LCD_CONCURRENT_WRITES
);
328 init_usb_anchor(&dev
->submitted
);
330 dev
->udev
= usb_get_dev(interface_to_usbdev(interface
));
331 dev
->interface
= interface
;
333 if (le16_to_cpu(dev
->udev
->descriptor
.idProduct
) != 0x0001) {
334 dev_warn(&interface
->dev
, "USBLCD model not supported.\n");
339 /* set up the endpoint information */
340 /* use only the first bulk-in and bulk-out endpoints */
341 retval
= usb_find_common_endpoints(interface
->cur_altsetting
,
342 &bulk_in
, &bulk_out
, NULL
, NULL
);
344 dev_err(&interface
->dev
,
345 "Could not find both bulk-in and bulk-out endpoints\n");
349 dev
->bulk_in_size
= usb_endpoint_maxp(bulk_in
);
350 dev
->bulk_in_endpointAddr
= bulk_in
->bEndpointAddress
;
351 dev
->bulk_in_buffer
= kmalloc(dev
->bulk_in_size
, GFP_KERNEL
);
352 if (!dev
->bulk_in_buffer
) {
357 dev
->bulk_out_endpointAddr
= bulk_out
->bEndpointAddress
;
359 /* save our data pointer in this interface device */
360 usb_set_intfdata(interface
, dev
);
362 /* we can register the device now, as it is ready */
363 retval
= usb_register_dev(interface
, &lcd_class
);
365 /* something prevented us from registering this driver */
366 dev_err(&interface
->dev
,
367 "Not able to get a minor for this device.\n");
368 usb_set_intfdata(interface
, NULL
);
372 i
= le16_to_cpu(dev
->udev
->descriptor
.bcdDevice
);
374 dev_info(&interface
->dev
, "USBLCD Version %1d%1d.%1d%1d found "
375 "at address %d\n", (i
& 0xF000)>>12, (i
& 0xF00)>>8,
376 (i
& 0xF0)>>4, (i
& 0xF), dev
->udev
->devnum
);
378 /* let the user know what node this device is now attached to */
379 dev_info(&interface
->dev
, "USB LCD device now attached to USBLCD-%d\n",
384 kref_put(&dev
->kref
, lcd_delete
);
388 static void lcd_draw_down(struct usb_lcd
*dev
)
392 time
= usb_wait_anchor_empty_timeout(&dev
->submitted
, 1000);
394 usb_kill_anchored_urbs(&dev
->submitted
);
397 static int lcd_suspend(struct usb_interface
*intf
, pm_message_t message
)
399 struct usb_lcd
*dev
= usb_get_intfdata(intf
);
407 static int lcd_resume(struct usb_interface
*intf
)
412 static void lcd_disconnect(struct usb_interface
*interface
)
415 int minor
= interface
->minor
;
417 mutex_lock(&open_disc_mutex
);
418 dev
= usb_get_intfdata(interface
);
419 usb_set_intfdata(interface
, NULL
);
420 mutex_unlock(&open_disc_mutex
);
422 /* give back our minor */
423 usb_deregister_dev(interface
, &lcd_class
);
425 /* decrement our usage count */
426 kref_put(&dev
->kref
, lcd_delete
);
428 dev_info(&interface
->dev
, "USB LCD #%d now disconnected\n", minor
);
431 static struct usb_driver lcd_driver
= {
434 .disconnect
= lcd_disconnect
,
435 .suspend
= lcd_suspend
,
436 .resume
= lcd_resume
,
437 .id_table
= id_table
,
438 .supports_autosuspend
= 1,
441 module_usb_driver(lcd_driver
);
443 MODULE_AUTHOR("Georges Toth <g.toth@e-biz.lu>");
444 MODULE_DESCRIPTION(DRIVER_VERSION
);
445 MODULE_LICENSE("GPL");