4 * LIBUSB interface code for CUPS.
6 * Copyright 2007-2013 by Apple Inc.
8 * These coded instructions, statements, and computer programs are the
9 * property of Apple Inc. and are protected by Federal copyright
10 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
11 * which should have been included with this file. If this file is
12 * file is missing or damaged, see the license at "http://www.cups.org/".
16 * list_devices() - List the available printers.
17 * print_device() - Print a file to a USB device.
18 * close_device() - Close the connection to the USB printer.
19 * compare_quirks() - Compare two quirks entries.
20 * find_device() - Find or enumerate USB printers.
21 * find_quirks() - Find the quirks for the given printer, if any.
22 * get_device_id() - Get the IEEE-1284 device ID for the printer.
23 * list_cb() - List USB printers for discovery.
24 * load_quirks() - Load all quirks files in the /usr/share/cups/usb
26 * make_device_uri() - Create a device URI for a USB printer.
27 * open_device() - Open a connection to the USB printer.
28 * print_cb() - Find a USB printer for printing.
29 * read_thread() - Thread to read the backchannel data on.
30 * sidechannel_thread() - Handle side-channel requests.
31 * soft_reset() - Send a soft reset to the device.
32 * soft_reset_printer() - Do the soft reset request specific to printers
36 * Include necessary headers...
40 #include <cups/cups-private.h>
43 #include <sys/select.h>
44 #include <sys/types.h>
51 * WAIT_EOF_DELAY is number of seconds we'll wait for responses from
52 * the printer after we've finished sending all the data
56 #define WAIT_EOF_DELAY 7
57 #define WAIT_SIDE_DELAY 3
58 #define DEFAULT_TIMEOUT 5000L
65 typedef struct usb_printer_s
/**** USB Printer Data ****/
67 struct libusb_device
*device
; /* Device info */
68 int conf
, /* Configuration */
69 origconf
, /* Original configuration */
70 iface
, /* Interface */
71 altset
, /* Alternate setting */
72 write_endp
, /* Write endpoint */
73 read_endp
, /* Read endpoint */
74 protocol
, /* Protocol: 1 = Uni-di, 2 = Bi-di. */
75 usblp_attached
, /* "usblp" kernel module attached? */
76 reset_after_job
;/* Set to 1 by print_device() */
77 unsigned quirks
; /* Quirks flags */
78 struct libusb_device_handle
*handle
; /* Open handle to device */
81 typedef int (*usb_cb_t
)(usb_printer_t
*, const char *, const char *,
84 typedef struct usb_globals_s
/* Global USB printer information */
86 usb_printer_t
*printer
; /* Printer */
88 pthread_mutex_t read_thread_mutex
;
89 pthread_cond_t read_thread_cond
;
93 pthread_mutex_t readwrite_lock_mutex
;
94 pthread_cond_t readwrite_lock_cond
;
97 int print_fd
; /* File descriptor to print */
98 ssize_t print_bytes
; /* Print bytes read */
101 int drain_output
; /* Drain all pending output */
102 int bidi_flag
; /* 0=unidirectional, 1=bidirectional */
104 pthread_mutex_t sidechannel_thread_mutex
;
105 pthread_cond_t sidechannel_thread_cond
;
106 int sidechannel_thread_stop
;
107 int sidechannel_thread_done
;
111 * Quirks: various printer quirks are handled by this structure and its flags.
113 * The quirks table used to be compiled into the backend but is now loaded from
114 * one or more files in the /usr/share/cups/usb directory.
117 #define USB_QUIRK_BLACKLIST 0x0001 /* Does not conform to the spec */
118 #define USB_QUIRK_NO_REATTACH 0x0002 /* After printing we cannot re-attach
119 the usblp kernel module */
120 #define USB_QUIRK_SOFT_RESET 0x0004 /* After printing do a soft reset
122 #define USB_QUIRK_UNIDIR 0x0008 /* Requires unidirectional mode */
123 #define USB_QUIRK_USB_INIT 0x0010 /* Needs vendor USB init string */
124 #define USB_QUIRK_VENDOR_CLASS 0x0020 /* Descriptor uses vendor-specific
126 #define USB_QUIRK_WHITELIST 0x0000 /* no quirks */
129 typedef struct usb_quirk_s
/* USB "quirk" information */
131 int vendor_id
, /* Affected vendor ID */
132 product_id
; /* Affected product ID or 0 for all */
133 unsigned quirks
; /* Quirks bitfield */
143 cups_array_t
*all_quirks
; /* Array of printer quirks */
144 usb_globals_t g
= { 0 }; /* Globals */
145 libusb_device
**all_list
; /* List of connected USB devices */
152 static int close_device(usb_printer_t
*printer
);
153 static int compare_quirks(usb_quirk_t
*a
, usb_quirk_t
*b
);
154 static usb_printer_t
*find_device(usb_cb_t cb
, const void *data
);
155 static unsigned find_quirks(int vendor_id
, int product_id
);
156 static int get_device_id(usb_printer_t
*printer
, char *buffer
,
158 static int list_cb(usb_printer_t
*printer
, const char *device_uri
,
159 const char *device_id
, const void *data
);
160 static void load_quirks(void);
161 static char *make_device_uri(usb_printer_t
*printer
,
162 const char *device_id
,
163 char *uri
, size_t uri_size
);
164 static int open_device(usb_printer_t
*printer
, int verbose
);
165 static int print_cb(usb_printer_t
*printer
, const char *device_uri
,
166 const char *device_id
, const void *data
);
167 static void *read_thread(void *reference
);
168 static void *sidechannel_thread(void *reference
);
169 static void soft_reset(void);
170 static int soft_reset_printer(usb_printer_t
*printer
);
174 * 'list_devices()' - List the available printers.
182 fputs("DEBUG: list_devices\n", stderr
);
183 find_device(list_cb
, NULL
);
188 * 'print_device()' - Print a file to a USB device.
191 int /* O - Exit status */
192 print_device(const char *uri
, /* I - Device URI */
193 const char *hostname
, /* I - Hostname/manufacturer */
194 const char *resource
, /* I - Resource/modelname */
195 char *options
, /* I - Device options/serial number */
196 int print_fd
, /* I - File descriptor to print */
197 int copies
, /* I - Copies to print */
198 int argc
, /* I - Number of command-line arguments (6 or 7) */
199 char *argv
[]) /* I - Command-line arguments */
201 int bytes
; /* Bytes written */
202 ssize_t total_bytes
; /* Total bytes written */
203 struct sigaction action
; /* Actions for POSIX signals */
204 int status
= CUPS_BACKEND_OK
,
205 /* Function results */
206 iostatus
; /* Current IO status */
207 pthread_t read_thread_id
, /* Read thread */
208 sidechannel_thread_id
; /* Side-channel thread */
209 int have_sidechannel
= 0, /* Was the side-channel thread started? */
210 have_backchannel
= 0; /* Do we have a back channel? */
211 struct stat sidechannel_info
; /* Side-channel file descriptor info */
212 unsigned char print_buffer
[8192], /* Print data buffer */
213 *print_ptr
; /* Pointer into print data buffer */
214 fd_set input_set
; /* Input set for select() */
215 int nfds
; /* Number of file descriptors */
216 struct timeval
*timeout
, /* Timeout pointer */
218 struct timespec cond_timeout
; /* pthread condition timeout */
219 int num_opts
; /* Number of options */
220 cups_option_t
*opts
; /* Options */
221 const char *val
; /* Option value */
227 * See if the side-channel descriptor is valid...
230 have_sidechannel
= !fstat(CUPS_SC_FD
, &sidechannel_info
) &&
231 S_ISSOCK(sidechannel_info
.st_mode
);
233 g
.wait_eof
= WAIT_EOF
;
236 * Connect to the printer...
239 fprintf(stderr
, "DEBUG: Printing on printer with URI: %s\n", uri
);
240 while ((g
.printer
= find_device(print_cb
, uri
)) == NULL
)
242 _cupsLangPrintFilter(stderr
, "INFO",
243 _("Waiting for printer to become available."));
247 g
.print_fd
= print_fd
;
250 * Some devices need a reset after finishing a job, these devices are
251 * marked with the USB_QUIRK_SOFT_RESET quirk.
253 g
.printer
->reset_after_job
= (g
.printer
->quirks
& USB_QUIRK_SOFT_RESET
? 1 : 0);
256 * If we are printing data from a print driver on stdin, ignore SIGTERM
257 * so that the driver can finish out any page data, e.g. to eject the
258 * current page. We only do this for stdin printing as otherwise there
259 * is no way to cancel a raw print job...
264 memset(&action
, 0, sizeof(action
));
266 sigemptyset(&action
.sa_mask
);
267 action
.sa_handler
= SIG_IGN
;
268 sigaction(SIGTERM
, &action
, NULL
);
272 * Start the side channel thread if the descriptor is valid...
275 pthread_mutex_init(&g
.readwrite_lock_mutex
, NULL
);
276 pthread_cond_init(&g
.readwrite_lock_cond
, NULL
);
277 g
.readwrite_lock
= 1;
279 if (have_sidechannel
)
281 g
.sidechannel_thread_stop
= 0;
282 g
.sidechannel_thread_done
= 0;
284 pthread_cond_init(&g
.sidechannel_thread_cond
, NULL
);
285 pthread_mutex_init(&g
.sidechannel_thread_mutex
, NULL
);
287 if (pthread_create(&sidechannel_thread_id
, NULL
, sidechannel_thread
, NULL
))
289 fprintf(stderr
, "DEBUG: Fatal USB error.\n");
290 _cupsLangPrintFilter(stderr
, "ERROR",
291 _("There was an unrecoverable USB error."));
292 fputs("DEBUG: Couldn't create side-channel thread.\n", stderr
);
293 close_device(g
.printer
);
294 return (CUPS_BACKEND_STOP
);
299 * Debug mode: If option "usb-unidir" is given, always deactivate
303 num_opts
= cupsParseOptions(argv
[5], 0, &opts
);
304 val
= cupsGetOption("usb-unidir", num_opts
, opts
);
305 if (val
&& strcasecmp(val
, "no") && strcasecmp(val
, "off") &&
306 strcasecmp(val
, "false"))
308 g
.printer
->read_endp
= -1;
309 fprintf(stderr
, "DEBUG: Forced uni-directional communication "
310 "via \"usb-unidir\" option.\n");
314 * Debug mode: If option "usb-no-reattach" is given, do not re-attach
315 * the usblp kernel module after the job has completed.
318 val
= cupsGetOption("usb-no-reattach", num_opts
, opts
);
319 if (val
&& strcasecmp(val
, "no") && strcasecmp(val
, "off") &&
320 strcasecmp(val
, "false"))
322 g
.printer
->usblp_attached
= 0;
323 fprintf(stderr
, "DEBUG: Forced not re-attaching the usblp kernel module "
324 "after the job via \"usb-no-reattach\" option.\n");
328 * Get the read thread going...
331 if (g
.printer
->read_endp
!= -1)
333 have_backchannel
= 1;
335 g
.read_thread_stop
= 0;
336 g
.read_thread_done
= 0;
338 pthread_cond_init(&g
.read_thread_cond
, NULL
);
339 pthread_mutex_init(&g
.read_thread_mutex
, NULL
);
341 if (pthread_create(&read_thread_id
, NULL
, read_thread
, NULL
))
343 fprintf(stderr
, "DEBUG: Fatal USB error.\n");
344 _cupsLangPrintFilter(stderr
, "ERROR",
345 _("There was an unrecoverable USB error."));
346 fputs("DEBUG: Couldn't create read thread.\n", stderr
);
347 close_device(g
.printer
);
348 return (CUPS_BACKEND_STOP
);
352 fprintf(stderr
, "DEBUG: Uni-directional device/mode, back channel "
356 * The main thread sends the print file...
362 print_ptr
= print_buffer
;
364 while (status
== CUPS_BACKEND_OK
&& copies
-- > 0)
366 _cupsLangPrintFilter(stderr
, "INFO", _("Sending data to printer."));
368 if (print_fd
!= STDIN_FILENO
)
370 fputs("PAGE: 1 1\n", stderr
);
371 lseek(print_fd
, 0, SEEK_SET
);
374 while (status
== CUPS_BACKEND_OK
)
379 FD_SET(print_fd
, &input_set
);
382 * Calculate select timeout...
383 * If we have data waiting to send timeout is 100ms.
384 * else if we're draining print_fd timeout is 0.
385 * else we're waiting forever...
391 tv
.tv_usec
= 100000; /* 100ms */
394 else if (g
.drain_output
)
404 * I/O is unlocked around select...
407 pthread_mutex_lock(&g
.readwrite_lock_mutex
);
408 g
.readwrite_lock
= 0;
409 pthread_cond_signal(&g
.readwrite_lock_cond
);
410 pthread_mutex_unlock(&g
.readwrite_lock_mutex
);
412 nfds
= select(print_fd
+ 1, &input_set
, NULL
, NULL
, timeout
);
415 * Reacquire the lock...
418 pthread_mutex_lock(&g
.readwrite_lock_mutex
);
419 while (g
.readwrite_lock
)
420 pthread_cond_wait(&g
.readwrite_lock_cond
, &g
.readwrite_lock_mutex
);
421 g
.readwrite_lock
= 1;
422 pthread_mutex_unlock(&g
.readwrite_lock_mutex
);
426 if (errno
== EINTR
&& total_bytes
== 0)
428 fputs("DEBUG: Received an interrupt before any bytes were "
429 "written, aborting.\n", stderr
);
430 close_device(g
.printer
);
431 return (CUPS_BACKEND_OK
);
433 else if (errno
!= EAGAIN
&& errno
!= EINTR
)
435 _cupsLangPrintFilter(stderr
, "ERROR",
436 _("Unable to read print data."));
437 perror("DEBUG: select");
438 close_device(g
.printer
);
439 return (CUPS_BACKEND_FAILED
);
444 * If drain output has finished send a response...
447 if (g
.drain_output
&& !nfds
&& !g
.print_bytes
)
449 /* Send a response... */
450 cupsSideChannelWrite(CUPS_SC_CMD_DRAIN_OUTPUT
, CUPS_SC_STATUS_OK
, NULL
, 0, 1.0);
455 * Check if we have print data ready...
458 if (FD_ISSET(print_fd
, &input_set
))
460 g
.print_bytes
= read(print_fd
, print_buffer
, sizeof(print_buffer
));
462 if (g
.print_bytes
< 0)
465 * Read error - bail if we don't see EAGAIN or EINTR...
468 if (errno
!= EAGAIN
&& errno
!= EINTR
)
470 _cupsLangPrintFilter(stderr
, "ERROR",
471 _("Unable to read print data."));
472 perror("DEBUG: read");
473 close_device(g
.printer
);
474 return (CUPS_BACKEND_FAILED
);
479 else if (g
.print_bytes
== 0)
482 * End of file, break out of the loop...
488 print_ptr
= print_buffer
;
490 fprintf(stderr
, "DEBUG: Read %d bytes of print data...\n",
496 iostatus
= libusb_bulk_transfer(g
.printer
->handle
,
497 g
.printer
->write_endp
,
498 print_buffer
, g
.print_bytes
,
501 * Ignore timeout errors, but retain the number of bytes written to
502 * avoid sending duplicate data...
505 if (iostatus
== LIBUSB_ERROR_TIMEOUT
)
507 fputs("DEBUG: Got USB transaction timeout during write.\n", stderr
);
512 * If we've stalled, retry the write...
515 else if (iostatus
== LIBUSB_ERROR_PIPE
)
517 fputs("DEBUG: Got USB pipe stalled during write.\n", stderr
);
519 iostatus
= libusb_bulk_transfer(g
.printer
->handle
,
520 g
.printer
->write_endp
,
521 print_buffer
, g
.print_bytes
,
526 * Retry a write after an aborted write since we probably just got
530 else if (iostatus
== LIBUSB_ERROR_INTERRUPTED
)
532 fputs("DEBUG: Got USB return aborted during write.\n", stderr
);
534 iostatus
= libusb_bulk_transfer(g
.printer
->handle
,
535 g
.printer
->write_endp
,
536 print_buffer
, g
.print_bytes
,
543 * Write error - bail if we don't see an error we can retry...
546 _cupsLangPrintFilter(stderr
, "ERROR",
547 _("Unable to send data to printer."));
548 fprintf(stderr
, "DEBUG: libusb write operation returned %x.\n",
551 status
= CUPS_BACKEND_FAILED
;
556 fprintf(stderr
, "DEBUG: Wrote %d bytes of print data...\n",
559 g
.print_bytes
-= bytes
;
561 total_bytes
+= bytes
;
565 if (print_fd
!= 0 && status
== CUPS_BACKEND_OK
)
566 fprintf(stderr
, "DEBUG: Sending print file, " CUPS_LLFMT
" bytes...\n",
567 CUPS_LLCAST total_bytes
);
571 fprintf(stderr
, "DEBUG: Sent " CUPS_LLFMT
" bytes...\n",
572 CUPS_LLCAST total_bytes
);
575 * Signal the side channel thread to exit...
578 if (have_sidechannel
)
581 pthread_mutex_lock(&g
.readwrite_lock_mutex
);
582 g
.readwrite_lock
= 0;
583 pthread_cond_signal(&g
.readwrite_lock_cond
);
584 pthread_mutex_unlock(&g
.readwrite_lock_mutex
);
586 g
.sidechannel_thread_stop
= 1;
587 pthread_mutex_lock(&g
.sidechannel_thread_mutex
);
589 if (!g
.sidechannel_thread_done
)
591 gettimeofday(&tv
, NULL
);
592 cond_timeout
.tv_sec
= tv
.tv_sec
+ WAIT_SIDE_DELAY
;
593 cond_timeout
.tv_nsec
= tv
.tv_usec
* 1000;
595 while (!g
.sidechannel_thread_done
)
597 if (pthread_cond_timedwait(&g
.sidechannel_thread_cond
,
598 &g
.sidechannel_thread_mutex
,
604 pthread_mutex_unlock(&g
.sidechannel_thread_mutex
);
608 * Signal the read thread to exit then wait 7 seconds for it to complete...
611 if (have_backchannel
)
613 g
.read_thread_stop
= 1;
615 pthread_mutex_lock(&g
.read_thread_mutex
);
617 if (!g
.read_thread_done
)
619 fputs("DEBUG: Waiting for read thread to exit...\n", stderr
);
621 gettimeofday(&tv
, NULL
);
622 cond_timeout
.tv_sec
= tv
.tv_sec
+ WAIT_EOF_DELAY
;
623 cond_timeout
.tv_nsec
= tv
.tv_usec
* 1000;
625 while (!g
.read_thread_done
)
627 if (pthread_cond_timedwait(&g
.read_thread_cond
, &g
.read_thread_mutex
,
633 * If it didn't exit abort the pending read and wait an additional
637 if (!g
.read_thread_done
)
639 fputs("DEBUG: Read thread still active, aborting the pending read...\n",
644 gettimeofday(&tv
, NULL
);
645 cond_timeout
.tv_sec
= tv
.tv_sec
+ 1;
646 cond_timeout
.tv_nsec
= tv
.tv_usec
* 1000;
648 while (!g
.read_thread_done
)
650 if (pthread_cond_timedwait(&g
.read_thread_cond
, &g
.read_thread_mutex
,
657 pthread_mutex_unlock(&g
.read_thread_mutex
);
661 * Close the connection and input file and general clean up...
664 close_device(g
.printer
);
670 libusb_free_device_list(all_list
, 1);
678 * 'close_device()' - Close the connection to the USB printer.
681 static int /* I - 0 on success, -1 on failure */
682 close_device(usb_printer_t
*printer
) /* I - Printer */
684 struct libusb_device_descriptor devdesc
;
685 /* Current device descriptor */
686 struct libusb_config_descriptor
*confptr
;
687 /* Pointer to current configuration */
693 * Release interfaces before closing so that we know all data is written
697 int errcode
; /* Return value of libusb function */
698 int number1
, /* Interface number */
699 number2
; /* Configuration number */
702 libusb_get_config_descriptor(printer
->device
, printer
->conf
, &confptr
);
705 number1
= confptr
->interface
[printer
->iface
].
706 altsetting
[printer
->altset
].bInterfaceNumber
;
707 libusb_release_interface(printer
->handle
, number1
);
709 number2
= confptr
->bConfigurationValue
;
711 libusb_free_config_descriptor(confptr
);
714 * If we have changed the configuration from one valid configuration
715 * to another, restore the old one
717 if (printer
->origconf
> 0 && printer
->origconf
!= number2
)
719 fprintf(stderr
, "DEBUG: Restoring USB device configuration: %d -> %d\n",
720 number2
, printer
->origconf
);
721 if ((errcode
= libusb_set_configuration(printer
->handle
,
722 printer
->origconf
)) < 0)
724 if (errcode
!= LIBUSB_ERROR_BUSY
)
727 libusb_get_device_descriptor (printer
->device
, &devdesc
);
730 "DEBUG: Failed to set configuration %d\n",
734 "DEBUG: Failed to set configuration %d for %04x:%04x\n",
735 printer
->origconf
, devdesc
.idVendor
, devdesc
.idProduct
);
741 * Re-attach "usblp" kernel module if it was attached before using this
744 if (printer
->usblp_attached
== 1)
745 if (libusb_attach_kernel_driver(printer
->handle
, number1
) < 0)
747 errcode
= libusb_get_device_descriptor (printer
->device
, &devdesc
);
750 "DEBUG: Failed to re-attach \"usblp\" kernel module\n");
753 "DEBUG: Failed to re-attach \"usblp\" kernel module to "
754 "%04x:%04x\n", devdesc
.idVendor
, devdesc
.idProduct
);
759 "DEBUG: Failed to get configuration descriptor %d\n",
763 * Reset the device to clean up after the job
766 if (printer
->reset_after_job
== 1)
768 if ((errcode
= libusb_reset_device(printer
->handle
)) < 0)
770 "DEBUG: Device reset failed, error code: %d\n",
774 "DEBUG: Resetting printer.\n");
778 * Close the interface and return...
781 libusb_close(printer
->handle
);
782 printer
->handle
= NULL
;
790 * 'compare_quirks()' - Compare two quirks entries.
793 static int /* O - Result of comparison */
794 compare_quirks(usb_quirk_t
*a
, /* I - First quirk entry */
795 usb_quirk_t
*b
) /* I - Second quirk entry */
797 int result
; /* Result of comparison */
799 if ((result
= b
->vendor_id
- a
->vendor_id
) == 0)
800 result
= b
->product_id
- a
->product_id
;
807 * 'find_device()' - Find or enumerate USB printers.
810 static usb_printer_t
* /* O - Found printer */
811 find_device(usb_cb_t cb
, /* I - Callback function */
812 const void *data
) /* I - User data for callback */
814 libusb_device
**list
; /* List of connected USB devices */
815 libusb_device
*device
= NULL
; /* Current device */
816 struct libusb_device_descriptor devdesc
;
817 /* Current device descriptor */
818 struct libusb_config_descriptor
*confptr
= NULL
;
819 /* Pointer to current configuration */
820 const struct libusb_interface
*ifaceptr
= NULL
;
821 /* Pointer to current interface */
822 const struct libusb_interface_descriptor
*altptr
= NULL
;
823 /* Pointer to current alternate setting */
824 const struct libusb_endpoint_descriptor
*endpptr
= NULL
;
825 /* Pointer to current endpoint */
826 ssize_t err
= 0, /* Error code */
827 numdevs
, /* number of connected devices */
829 uint8_t conf
, /* Current configuration */
830 iface
, /* Current interface */
831 altset
, /* Current alternate setting */
832 protocol
, /* Current protocol */
833 endp
, /* Current endpoint */
834 read_endp
, /* Current read endpoint */
835 write_endp
; /* Current write endpoint */
836 char device_id
[1024],/* IEEE-1284 device ID */
839 static usb_printer_t printer
; /* Current printer */
843 * Initialize libusb...
846 err
= libusb_init(NULL
);
849 fprintf(stderr
, "DEBUG: Unable to initialize USB access via libusb, "
850 "libusb error %i\n", (int)err
);
854 numdevs
= libusb_get_device_list(NULL
, &list
);
855 fprintf(stderr
, "DEBUG: libusb_get_device_list=%d\n", (int)numdevs
);
858 * Then loop through the devices it found...
862 for (i
= 0; i
< numdevs
; i
++)
867 * Ignore devices with no configuration data and anything that is not
871 if (libusb_get_device_descriptor(device
, &devdesc
) < 0)
874 if (!devdesc
.bNumConfigurations
|| !devdesc
.idVendor
||
878 printer
.quirks
= find_quirks(devdesc
.idVendor
, devdesc
.idProduct
);
881 * Ignore blacklisted printers...
884 if (printer
.quirks
& USB_QUIRK_BLACKLIST
)
887 for (conf
= 0; conf
< devdesc
.bNumConfigurations
; conf
++)
889 if (libusb_get_config_descriptor(device
, conf
, &confptr
) < 0)
891 for (iface
= 0, ifaceptr
= confptr
->interface
;
892 iface
< confptr
->bNumInterfaces
;
893 iface
++, ifaceptr
++)
896 * Some printers offer multiple interfaces...
901 for (altset
= 0, altptr
= ifaceptr
->altsetting
;
902 altset
< ifaceptr
->num_altsetting
;
903 altset
++, altptr
++)
906 * Currently we only support unidirectional and bidirectional
907 * printers. Future versions of this code will support the
908 * 1284.4 (packet mode) protocol as well.
911 if (((altptr
->bInterfaceClass
!= LIBUSB_CLASS_PRINTER
||
912 altptr
->bInterfaceSubClass
!= 1) &&
913 ((printer
.quirks
& USB_QUIRK_VENDOR_CLASS
) == 0)) ||
914 (altptr
->bInterfaceProtocol
!= 1 && /* Unidirectional */
915 altptr
->bInterfaceProtocol
!= 2) || /* Bidirectional */
916 altptr
->bInterfaceProtocol
< protocol
)
919 if (printer
.quirks
& USB_QUIRK_VENDOR_CLASS
)
920 fprintf(stderr
, "DEBUG: Printer does not report class 7 and/or "
921 "subclass 1 but works as a printer anyway\n");
926 for (endp
= 0, endpptr
= altptr
->endpoint
;
927 endp
< altptr
->bNumEndpoints
;
929 if ((endpptr
->bmAttributes
& LIBUSB_TRANSFER_TYPE_MASK
) ==
930 LIBUSB_TRANSFER_TYPE_BULK
)
932 if (endpptr
->bEndpointAddress
& LIBUSB_ENDPOINT_DIR_MASK
)
941 * Save the best match so far...
944 protocol
= altptr
->bInterfaceProtocol
;
945 printer
.altset
= altset
;
946 printer
.write_endp
= write_endp
;
948 printer
.read_endp
= read_endp
;
950 printer
.read_endp
= -1;
956 printer
.device
= device
;
958 printer
.iface
= iface
;
959 printer
.protocol
= protocol
;
960 printer
.handle
= NULL
;
962 if (!open_device(&printer
, data
!= NULL
))
964 get_device_id(&printer
, device_id
, sizeof(device_id
));
965 make_device_uri(&printer
, device_id
, device_uri
,
968 fprintf(stderr
, "DEBUG2: Printer found with device ID: %s "
970 device_id
, device_uri
);
972 if ((*cb
)(&printer
, device_uri
, device_id
, data
))
974 fprintf(stderr
, "DEBUG: Device protocol: %d\n",
976 if (printer
.quirks
& USB_QUIRK_UNIDIR
)
978 printer
.read_endp
= -1;
979 fprintf(stderr
, "DEBUG: Printer reports bi-di support "
980 "but in reality works only uni-directionally\n");
982 if (printer
.read_endp
!= -1)
984 printer
.read_endp
= confptr
->interface
[printer
.iface
].
985 altsetting
[printer
.altset
].
986 endpoint
[printer
.read_endp
].
990 fprintf(stderr
, "DEBUG: Uni-directional USB communication "
992 printer
.write_endp
= confptr
->interface
[printer
.iface
].
993 altsetting
[printer
.altset
].
994 endpoint
[printer
.write_endp
].
996 if (printer
.quirks
& USB_QUIRK_NO_REATTACH
)
998 printer
.usblp_attached
= 0;
999 fprintf(stderr
, "DEBUG: Printer does not like usblp "
1000 "kernel module to be re-attached after job\n");
1002 libusb_free_config_descriptor(confptr
);
1006 close_device(&printer
);
1010 libusb_free_config_descriptor(confptr
);
1015 * If we get this far without returning, then we haven't found a printer
1024 libusb_free_device_list(list
, 1);
1032 * 'find_quirks()' - Find the quirks for the given printer, if any.
1034 * First looks for an exact match, then looks for the vendor ID wildcard match.
1037 static unsigned /* O - Quirks flags */
1038 find_quirks(int vendor_id
, /* I - Vendor ID */
1039 int product_id
) /* I - Product ID */
1041 usb_quirk_t key
, /* Search key */
1042 *match
; /* Matching quirk entry */
1045 key
.vendor_id
= vendor_id
;
1046 key
.product_id
= product_id
;
1048 if ((match
= cupsArrayFind(all_quirks
, &key
)) != NULL
)
1049 return (match
->quirks
);
1053 if ((match
= cupsArrayFind(all_quirks
, &key
)) != NULL
)
1054 return (match
->quirks
);
1056 return (USB_QUIRK_WHITELIST
);
1061 * 'get_device_id()' - Get the IEEE-1284 device ID for the printer.
1064 static int /* O - 0 on success, -1 on error */
1065 get_device_id(usb_printer_t
*printer
, /* I - Printer */
1066 char *buffer
, /* I - String buffer */
1067 size_t bufsize
) /* I - Number of bytes in buffer */
1069 int length
; /* Length of device ID */
1072 if (libusb_control_transfer(printer
->handle
,
1073 LIBUSB_REQUEST_TYPE_CLASS
| LIBUSB_ENDPOINT_IN
|
1074 LIBUSB_RECIPIENT_INTERFACE
,
1076 (printer
->iface
<< 8) | printer
->altset
,
1077 (unsigned char *)buffer
, bufsize
, 5000) < 0)
1084 * Extract the length of the device ID string from the first two
1085 * bytes. The 1284 spec says the length is stored MSB first...
1088 length
= (((unsigned)buffer
[0] & 255) << 8) |
1089 ((unsigned)buffer
[1] & 255);
1092 * Check to see if the length is larger than our buffer or less than 14 bytes
1093 * (the minimum valid device ID is "MFG:x;MDL:y;" with 2 bytes for the length).
1095 * If the length is out-of-range, assume that the vendor incorrectly
1096 * implemented the 1284 spec and re-read the length as LSB first,..
1099 if (length
> bufsize
|| length
< 14)
1100 length
= (((unsigned)buffer
[1] & 255) << 8) |
1101 ((unsigned)buffer
[0] & 255);
1103 if (length
> bufsize
)
1109 * Invalid device ID, clear it!
1119 * Copy the device ID text to the beginning of the buffer and
1123 memmove(buffer
, buffer
+ 2, length
);
1124 buffer
[length
] = '\0';
1131 * 'list_cb()' - List USB printers for discovery.
1134 static int /* O - 0 to continue, 1 to stop */
1135 list_cb(usb_printer_t
*printer
, /* I - Printer */
1136 const char *device_uri
, /* I - Device URI */
1137 const char *device_id
, /* I - IEEE-1284 device ID */
1138 const void *data
) /* I - User data (not used) */
1140 char make_model
[1024]; /* Make and model */
1144 * Get the device URI and make/model strings...
1147 if (backendGetMakeModel(device_id
, make_model
, sizeof(make_model
)))
1148 strlcpy(make_model
, "Unknown", sizeof(make_model
));
1151 * Report the printer...
1154 cupsBackendReport("direct", device_uri
, make_model
, make_model
, device_id
,
1166 * 'load_quirks()' - Load all quirks files in the /usr/share/cups/usb directory.
1172 const char *datadir
; /* CUPS_DATADIR environment variable */
1173 char filename
[1024], /* Filename */
1174 line
[1024]; /* Line from file */
1175 cups_dir_t
*dir
; /* Directory */
1176 cups_dentry_t
*dent
; /* Directory entry */
1177 cups_file_t
*fp
; /* Quirks file */
1178 usb_quirk_t
*quirk
; /* New quirk */
1181 all_quirks
= cupsArrayNew((cups_array_func_t
)compare_quirks
, NULL
);
1183 if ((datadir
= getenv("CUPS_DATADIR")) == NULL
)
1184 datadir
= CUPS_DATADIR
;
1186 snprintf(filename
, sizeof(filename
), "%s/usb", datadir
);
1187 if ((dir
= cupsDirOpen(filename
)) == NULL
)
1193 fprintf(stderr
, "DEBUG: Loading USB quirks from \"%s\".\n", filename
);
1195 while ((dent
= cupsDirRead(dir
)) != NULL
)
1197 if (!S_ISREG(dent
->fileinfo
.st_mode
))
1200 snprintf(filename
, sizeof(filename
), "%s/usb/%s", datadir
, dent
->filename
);
1201 if ((fp
= cupsFileOpen(filename
, "r")) == NULL
)
1207 while (cupsFileGets(fp
, line
, sizeof(line
)))
1210 * Skip blank and comment lines...
1213 if (line
[0] == '#' || !line
[0])
1220 if ((quirk
= calloc(1, sizeof(usb_quirk_t
))) == NULL
)
1222 perror("DEBUG: Unable to allocate memory for quirk");
1226 if (sscanf(line
, "%x%x", &quirk
->vendor_id
, &quirk
->product_id
) < 1)
1228 fprintf(stderr
, "DEBUG: Bad line: %s\n", line
);
1233 if (strstr(line
, " blacklist"))
1234 quirk
->quirks
|= USB_QUIRK_BLACKLIST
;
1236 if (strstr(line
, " no-reattach"))
1237 quirk
->quirks
|= USB_QUIRK_NO_REATTACH
;
1239 if (strstr(line
, " soft-reset"))
1240 quirk
->quirks
|= USB_QUIRK_SOFT_RESET
;
1242 if (strstr(line
, " unidir"))
1243 quirk
->quirks
|= USB_QUIRK_UNIDIR
;
1245 if (strstr(line
, " usb-init"))
1246 quirk
->quirks
|= USB_QUIRK_USB_INIT
;
1248 if (strstr(line
, " vendor-class"))
1249 quirk
->quirks
|= USB_QUIRK_VENDOR_CLASS
;
1251 cupsArrayAdd(all_quirks
, quirk
);
1257 fprintf(stderr
, "DEBUG: Loaded %d quirks.\n", cupsArrayCount(all_quirks
));
1264 * 'make_device_uri()' - Create a device URI for a USB printer.
1267 static char * /* O - Device URI */
1269 usb_printer_t
*printer
, /* I - Printer */
1270 const char *device_id
, /* I - IEEE-1284 device ID */
1271 char *uri
, /* I - Device URI buffer */
1272 size_t uri_size
) /* I - Size of device URI buffer */
1274 struct libusb_device_descriptor devdesc
;
1275 /* Current device descriptor */
1276 char options
[1024]; /* Device URI options */
1277 int num_values
; /* Number of 1284 parameters */
1278 cups_option_t
*values
; /* 1284 parameters */
1279 const char *mfg
, /* Manufacturer */
1281 *des
= NULL
, /* Description */
1282 *sern
; /* Serial number */
1283 size_t mfglen
; /* Length of manufacturer string */
1284 char tempmfg
[256], /* Temporary manufacturer string */
1285 tempsern
[256], /* Temporary serial number string */
1286 *tempptr
; /* Pointer into temp string */
1290 * Get the make, model, and serial numbers...
1293 num_values
= _cupsGet1284Values(device_id
, &values
);
1295 if ((sern
= cupsGetOption("SERIALNUMBER", num_values
, values
)) == NULL
)
1296 if ((sern
= cupsGetOption("SERN", num_values
, values
)) == NULL
)
1297 if ((sern
= cupsGetOption("SN", num_values
, values
)) == NULL
&&
1298 ((libusb_get_device_descriptor(printer
->device
, &devdesc
) >= 0) &&
1299 devdesc
.iSerialNumber
))
1302 * Try getting the serial number from the device itself...
1306 libusb_get_string_descriptor_ascii(printer
->handle
,
1307 devdesc
.iSerialNumber
,
1308 (unsigned char *)tempsern
,
1309 sizeof(tempsern
) - 1);
1312 tempsern
[length
] = '\0';
1317 if ((mfg
= cupsGetOption("MANUFACTURER", num_values
, values
)) == NULL
)
1318 mfg
= cupsGetOption("MFG", num_values
, values
);
1320 if ((mdl
= cupsGetOption("MODEL", num_values
, values
)) == NULL
)
1321 mdl
= cupsGetOption("MDL", num_values
, values
);
1324 * To maintain compatibility with the original character device backend on
1325 * Linux and *BSD, map manufacturer names...
1330 if (!_cups_strcasecmp(mfg
, "Hewlett-Packard"))
1332 else if (!_cups_strcasecmp(mfg
, "Lexmark International"))
1338 * No manufacturer? Use the model string or description...
1342 _ppdNormalizeMakeAndModel(mdl
, tempmfg
, sizeof(tempmfg
));
1343 else if ((des
= cupsGetOption("DESCRIPTION", num_values
, values
)) != NULL
||
1344 (des
= cupsGetOption("DES", num_values
, values
)) != NULL
)
1345 _ppdNormalizeMakeAndModel(des
, tempmfg
, sizeof(tempmfg
));
1347 strlcpy(tempmfg
, "Unknown", sizeof(tempmfg
));
1349 if ((tempptr
= strchr(tempmfg
, ' ')) != NULL
)
1358 * No model? Use description...
1361 mdl
= des
; /* We remove the manufacturer name below */
1362 else if (!strncasecmp(mfg
, "Unknown", 7))
1365 mdl
= "Unknown Model";
1368 mfglen
= strlen(mfg
);
1370 if (!strncasecmp(mdl
, mfg
, mfglen
) && _cups_isspace(mdl
[mfglen
]))
1374 while (_cups_isspace(*mdl
))
1379 * Generate the device URI from the manufacturer, model, serial number,
1380 * and interface number...
1385 if (printer
->iface
> 0)
1386 snprintf(options
, sizeof(options
), "?serial=%s&interface=%d", sern
,
1389 snprintf(options
, sizeof(options
), "?serial=%s", sern
);
1391 else if (printer
->iface
> 0)
1392 snprintf(options
, sizeof(options
), "?interface=%d", printer
->iface
);
1396 httpAssembleURIf(HTTP_URI_CODING_ALL
, uri
, uri_size
, "usb", NULL
, mfg
, 0,
1397 "/%s%s", mdl
, options
);
1399 cupsFreeOptions(num_values
, values
);
1406 * 'open_device()' - Open a connection to the USB printer.
1409 static int /* O - 0 on success, -1 on error */
1410 open_device(usb_printer_t
*printer
, /* I - Printer */
1411 int verbose
) /* I - Update connecting-to-device state? */
1413 struct libusb_device_descriptor devdesc
;
1414 /* Current device descriptor */
1415 struct libusb_config_descriptor
*confptr
= NULL
;
1416 /* Pointer to current configuration */
1417 int number1
= -1, /* Configuration/interface/altset */
1418 number2
= -1, /* numbers */
1420 char current
; /* Current configuration */
1424 * Return immediately if we are already connected...
1427 if (printer
->handle
)
1431 * Try opening the printer...
1434 if ((errcode
= libusb_open(printer
->device
, &printer
->handle
)) < 0)
1436 fprintf(stderr
, "DEBUG: Failed to open device, code: %d\n",
1441 printer
->usblp_attached
= 0;
1442 printer
->reset_after_job
= 0;
1445 fputs("STATE: +connecting-to-device\n", stderr
);
1447 if ((errcode
= libusb_get_device_descriptor(printer
->device
, &devdesc
)) < 0)
1449 fprintf(stderr
, "DEBUG: Failed to get device descriptor, code: %d\n",
1455 * Get the "usblp" kernel module out of the way. This backend only
1456 * works without the module attached.
1459 errcode
= libusb_kernel_driver_active(printer
->handle
, printer
->iface
);
1461 printer
->usblp_attached
= 0;
1462 else if (errcode
== 1)
1464 printer
->usblp_attached
= 1;
1466 libusb_detach_kernel_driver(printer
->handle
, printer
->iface
)) < 0)
1468 fprintf(stderr
, "DEBUG: Failed to detach \"usblp\" module from %04x:%04x\n",
1469 devdesc
.idVendor
, devdesc
.idProduct
);
1475 printer
->usblp_attached
= 0;
1476 fprintf(stderr
, "DEBUG: Failed to check whether %04x:%04x has the \"usblp\" kernel module attached\n",
1477 devdesc
.idVendor
, devdesc
.idProduct
);
1482 * Set the desired configuration, but only if it needs changing. Some
1483 * printers (e.g., Samsung) don't like libusb_set_configuration. It will
1484 * succeed, but the following print job is sometimes silently lost by the
1488 if (libusb_control_transfer(printer
->handle
,
1489 LIBUSB_REQUEST_TYPE_STANDARD
| LIBUSB_ENDPOINT_IN
|
1490 LIBUSB_RECIPIENT_DEVICE
,
1491 8, /* GET_CONFIGURATION */
1492 0, 0, (unsigned char *)¤t
, 1, 5000) < 0)
1493 current
= 0; /* Assume not configured */
1495 printer
->origconf
= current
;
1498 libusb_get_config_descriptor (printer
->device
, printer
->conf
, &confptr
))
1501 fprintf(stderr
, "DEBUG: Failed to get config descriptor for %04x:%04x\n",
1502 devdesc
.idVendor
, devdesc
.idProduct
);
1505 number1
= confptr
->bConfigurationValue
;
1507 if (number1
!= current
)
1509 fprintf(stderr
, "DEBUG: Switching USB device configuration: %d -> %d\n",
1511 if ((errcode
= libusb_set_configuration(printer
->handle
, number1
)) < 0)
1514 * If the set fails, chances are that the printer only supports a
1515 * single configuration. Technically these printers don't conform to
1516 * the USB printer specification, but otherwise they'll work...
1519 if (errcode
!= LIBUSB_ERROR_BUSY
)
1520 fprintf(stderr
, "DEBUG: Failed to set configuration %d for %04x:%04x\n",
1521 number1
, devdesc
.idVendor
, devdesc
.idProduct
);
1526 * Claim interfaces as needed...
1529 number1
= confptr
->interface
[printer
->iface
].
1530 altsetting
[printer
->altset
].bInterfaceNumber
;
1532 while ((errcode
= libusb_claim_interface(printer
->handle
, number1
)) < 0)
1534 if (errcode
!= LIBUSB_ERROR_BUSY
)
1537 "DEBUG: Failed to claim interface %d for %04x:%04x: %s\n",
1538 number1
, devdesc
.idVendor
, devdesc
.idProduct
, strerror(errno
));
1545 * Set alternate setting, but only if there is more than one option. Some
1546 * printers (e.g., Samsung) don't like usb_set_altinterface.
1549 if (confptr
->interface
[printer
->iface
].num_altsetting
> 1)
1551 number1
= confptr
->interface
[printer
->iface
].
1552 altsetting
[printer
->altset
].bInterfaceNumber
;
1553 number2
= confptr
->interface
[printer
->iface
].
1554 altsetting
[printer
->altset
].bAlternateSetting
;
1557 libusb_set_interface_alt_setting(printer
->handle
, number1
, number2
))
1560 if (errcode
!= LIBUSB_ERROR_BUSY
)
1563 "DEBUG: Failed to set alternate interface %d for %04x:%04x: "
1565 number2
, devdesc
.idVendor
, devdesc
.idProduct
, strerror(errno
));
1572 libusb_free_config_descriptor(confptr
);
1575 fputs("STATE: -connecting-to-device\n", stderr
);
1580 * If we get here, there was a hard error...
1586 fputs("STATE: -connecting-to-device\n", stderr
);
1588 libusb_close(printer
->handle
);
1589 printer
->handle
= NULL
;
1596 * 'print_cb()' - Find a USB printer for printing.
1599 static int /* O - 0 to continue, 1 to stop (found) */
1600 print_cb(usb_printer_t
*printer
, /* I - Printer */
1601 const char *device_uri
, /* I - Device URI */
1602 const char *device_id
, /* I - IEEE-1284 device ID */
1603 const void *data
) /* I - User data (make, model, S/N) */
1605 char requested_uri
[1024], /* Requested URI */
1606 *requested_ptr
, /* Pointer into requested URI */
1607 detected_uri
[1024], /* Detected URI */
1608 *detected_ptr
; /* Pointer into detected URI */
1612 * If we have an exact match, stop now...
1615 if (!strcmp((char *)data
, device_uri
))
1619 * Work on copies of the URIs...
1622 strlcpy(requested_uri
, (char *)data
, sizeof(requested_uri
));
1623 strlcpy(detected_uri
, device_uri
, sizeof(detected_uri
));
1626 * libusb-discovered URIs can have an "interface" specification and this
1627 * never happens for usblp-discovered URIs, so remove the "interface"
1628 * specification from the URI which we are checking currently. This way a
1629 * queue for a usblp-discovered printer can now be accessed via libusb.
1631 * Similarly, strip "?serial=NNN...NNN" as needed.
1634 if ((requested_ptr
= strstr(requested_uri
, "?interface=")) == NULL
)
1635 requested_ptr
= strstr(requested_uri
, "&interface=");
1636 if ((detected_ptr
= strstr(detected_uri
, "?interface=")) == NULL
)
1637 detected_ptr
= strstr(detected_uri
, "&interface=");
1639 if (!requested_ptr
&& detected_ptr
)
1642 * Strip "[?&]interface=nnn" from the detected printer.
1645 *detected_ptr
= '\0';
1647 else if (requested_ptr
&& !detected_ptr
)
1650 * Strip "[?&]interface=nnn" from the requested printer.
1653 *requested_ptr
= '\0';
1656 if ((requested_ptr
= strstr(requested_uri
, "?serial=?")) != NULL
)
1659 * Strip "?serial=?" from the requested printer. This is a special
1660 * case, as "?serial=?" means no serial number and not the serial
1661 * number '?'. This is not covered by the checks below...
1664 *requested_ptr
= '\0';
1667 if ((requested_ptr
= strstr(requested_uri
, "?serial=")) == NULL
&&
1668 (detected_ptr
= strstr(detected_uri
, "?serial=")) != NULL
)
1671 * Strip "?serial=nnn" from the detected printer.
1674 *detected_ptr
= '\0';
1676 else if (requested_ptr
&& !detected_ptr
)
1679 * Strip "?serial=nnn" from the requested printer.
1682 *requested_ptr
= '\0';
1685 return (!strcmp(requested_uri
, detected_uri
));
1690 * 'read_thread()' - Thread to read the backchannel data on.
1693 static void *read_thread(void *reference
)
1695 unsigned char readbuffer
[512];
1707 * Read frequency: once every 250 milliseconds.
1711 delay
.tv_usec
= 250000;
1716 * Remember when we started so we can throttle the loop after the read
1720 gettimeofday(&now
, NULL
);
1723 * Calculate what 250 milliSeconds are in absolute time...
1726 timeradd(&now
, &delay
, &end
);
1728 rbytes
= sizeof(readbuffer
);
1729 readstatus
= libusb_bulk_transfer(g
.printer
->handle
,
1730 g
.printer
->read_endp
,
1733 if (readstatus
== LIBUSB_SUCCESS
&& rbytes
> 0)
1735 fprintf(stderr
, "DEBUG: Read %d bytes of back-channel data...\n",
1737 cupsBackChannelWrite((const char *)readbuffer
, rbytes
, 1.0);
1739 else if (readstatus
== LIBUSB_ERROR_TIMEOUT
)
1740 fputs("DEBUG: Got USB transaction timeout during read.\n", stderr
);
1741 else if (readstatus
== LIBUSB_ERROR_PIPE
)
1742 fputs("DEBUG: Got USB pipe stalled during read.\n", stderr
);
1743 else if (readstatus
== LIBUSB_ERROR_INTERRUPTED
)
1744 fputs("DEBUG: Got USB return aborted during read.\n", stderr
);
1747 * Make sure this loop executes no more than once every 250 miliseconds...
1750 if ((readstatus
!= LIBUSB_SUCCESS
|| rbytes
== 0) &&
1751 (g
.wait_eof
|| !g
.read_thread_stop
))
1753 gettimeofday(&now
, NULL
);
1754 if (timercmp(&now
, &end
, <))
1756 timersub(&end
, &now
, &timeleft
);
1757 usleep(1000000 * timeleft
.tv_sec
+ timeleft
.tv_usec
);
1760 } while (g
.wait_eof
|| !g
.read_thread_stop
);
1763 * Let the main thread know that we have completed the read thread...
1766 pthread_mutex_lock(&g
.read_thread_mutex
);
1767 g
.read_thread_done
= 1;
1768 pthread_cond_signal(&g
.read_thread_cond
);
1769 pthread_mutex_unlock(&g
.read_thread_mutex
);
1776 * 'sidechannel_thread()' - Handle side-channel requests.
1780 sidechannel_thread(void *reference
)
1782 cups_sc_command_t command
; /* Request command */
1783 cups_sc_status_t status
; /* Request/response status */
1784 char data
[2048]; /* Request/response data */
1785 int datalen
; /* Request/response data size */
1792 datalen
= sizeof(data
);
1794 if (cupsSideChannelRead(&command
, &status
, data
, &datalen
, 1.0))
1796 if (status
== CUPS_SC_STATUS_TIMEOUT
)
1804 case CUPS_SC_CMD_SOFT_RESET
: /* Do a soft reset */
1805 fputs("DEBUG: CUPS_SC_CMD_SOFT_RESET received from driver...\n",
1809 cupsSideChannelWrite(command
, CUPS_SC_STATUS_OK
, NULL
, 0, 1.0);
1810 fputs("DEBUG: Returning status CUPS_STATUS_OK with no bytes...\n",
1814 case CUPS_SC_CMD_DRAIN_OUTPUT
: /* Drain all pending output */
1815 fputs("DEBUG: CUPS_SC_CMD_DRAIN_OUTPUT received from driver...\n",
1821 case CUPS_SC_CMD_GET_BIDI
: /* Is the connection bidirectional? */
1822 fputs("DEBUG: CUPS_SC_CMD_GET_BIDI received from driver...\n",
1825 data
[0] = (g
.printer
->protocol
>= 2 ? 1 : 0);
1826 cupsSideChannelWrite(command
, CUPS_SC_STATUS_OK
, data
, 1, 1.0);
1829 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1833 case CUPS_SC_CMD_GET_DEVICE_ID
: /* Return IEEE-1284 device ID */
1834 fputs("DEBUG: CUPS_SC_CMD_GET_DEVICE_ID received from driver...\n",
1837 datalen
= sizeof(data
);
1838 if (get_device_id(g
.printer
, data
, sizeof(data
)))
1840 status
= CUPS_SC_STATUS_IO_ERROR
;
1845 status
= CUPS_SC_STATUS_OK
;
1846 datalen
= strlen(data
);
1848 cupsSideChannelWrite(command
, CUPS_SC_STATUS_OK
, data
, datalen
, 1.0);
1850 if (datalen
< sizeof(data
))
1851 data
[datalen
] = '\0';
1853 data
[sizeof(data
) - 1] = '\0';
1856 "DEBUG: Returning CUPS_SC_STATUS_OK with %d bytes (%s)...\n",
1860 case CUPS_SC_CMD_GET_STATE
: /* Return device state */
1861 fputs("DEBUG: CUPS_SC_CMD_GET_STATE received from driver...\n",
1864 data
[0] = CUPS_SC_STATE_ONLINE
;
1865 cupsSideChannelWrite(command
, CUPS_SC_STATUS_OK
, data
, 1, 1.0);
1868 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1872 case CUPS_SC_CMD_GET_CONNECTED
: /* Return whether device is
1874 fputs("DEBUG: CUPS_SC_CMD_GET_CONNECTED received from driver...\n",
1877 data
[0] = (g
.printer
->handle
? 1 : 0);
1878 cupsSideChannelWrite(command
, CUPS_SC_STATUS_OK
, data
, 1, 1.0);
1881 "DEBUG: Returned CUPS_SC_STATUS_OK with 1 byte (%02X)...\n",
1886 fprintf(stderr
, "DEBUG: Unknown side-channel command (%d) received "
1887 "from driver...\n", command
);
1889 cupsSideChannelWrite(command
, CUPS_SC_STATUS_NOT_IMPLEMENTED
,
1892 fputs("DEBUG: Returned CUPS_SC_STATUS_NOT_IMPLEMENTED with no bytes...\n",
1897 while (!g
.sidechannel_thread_stop
);
1899 pthread_mutex_lock(&g
.sidechannel_thread_mutex
);
1900 g
.sidechannel_thread_done
= 1;
1901 pthread_cond_signal(&g
.sidechannel_thread_cond
);
1902 pthread_mutex_unlock(&g
.sidechannel_thread_mutex
);
1909 * 'soft_reset()' - Send a soft reset to the device.
1915 fd_set input_set
; /* Input set for select() */
1916 struct timeval tv
; /* Time value */
1917 char buffer
[2048]; /* Buffer */
1918 struct timespec cond_timeout
; /* pthread condition timeout */
1922 * Send an abort once a second until the I/O lock is released by the main
1926 pthread_mutex_lock(&g
.readwrite_lock_mutex
);
1927 while (g
.readwrite_lock
)
1929 gettimeofday(&tv
, NULL
);
1930 cond_timeout
.tv_sec
= tv
.tv_sec
+ 1;
1931 cond_timeout
.tv_nsec
= tv
.tv_usec
* 1000;
1933 while (g
.readwrite_lock
)
1935 if (pthread_cond_timedwait(&g
.readwrite_lock_cond
,
1936 &g
.readwrite_lock_mutex
,
1937 &cond_timeout
) != 0)
1942 g
.readwrite_lock
= 1;
1943 pthread_mutex_unlock(&g
.readwrite_lock_mutex
);
1946 * Flush bytes waiting on print_fd...
1951 FD_ZERO(&input_set
);
1952 FD_SET(g
.print_fd
, &input_set
);
1957 while (select(g
.print_fd
+1, &input_set
, NULL
, NULL
, &tv
) > 0)
1958 if (read(g
.print_fd
, buffer
, sizeof(buffer
)) <= 0)
1965 soft_reset_printer(g
.printer
);
1968 * Release the I/O lock...
1971 pthread_mutex_lock(&g
.readwrite_lock_mutex
);
1972 g
.readwrite_lock
= 0;
1973 pthread_cond_signal(&g
.readwrite_lock_cond
);
1974 pthread_mutex_unlock(&g
.readwrite_lock_mutex
);
1979 * 'soft_reset_printer()' - Do the soft reset request specific to printers
1981 * This soft reset is specific to the printer device class and is much less
1982 * invasive than the general USB reset libusb_reset_device(). Especially it
1983 * does never happen that the USB addressing and configuration changes. What
1984 * is actually done is that all buffers get flushed and the bulk IN and OUT
1985 * pipes get reset to their default states. This clears all stall conditions.
1986 * See http://cholla.mmto.org/computers/linux/usb/usbprint11.pdf
1989 static int /* O - 0 on success, < 0 on error */
1991 usb_printer_t
*printer
) /* I - Printer */
1993 struct libusb_config_descriptor
*confptr
= NULL
;
1994 /* Pointer to current configuration */
1995 int interface
, /* Interface to reset */
1996 errcode
; /* Error code */
1999 if (libusb_get_config_descriptor(printer
->device
, printer
->conf
,
2001 interface
= printer
->iface
;
2003 interface
= confptr
->interface
[printer
->iface
].
2004 altsetting
[printer
->altset
].bInterfaceNumber
;
2006 libusb_free_config_descriptor(confptr
);
2008 if ((errcode
= libusb_control_transfer(printer
->handle
,
2009 LIBUSB_REQUEST_TYPE_CLASS
|
2010 LIBUSB_ENDPOINT_OUT
|
2011 LIBUSB_RECIPIENT_OTHER
,
2012 2, 0, interface
, NULL
, 0, 5000)) < 0)
2013 errcode
= libusb_control_transfer(printer
->handle
,
2014 LIBUSB_REQUEST_TYPE_CLASS
|
2015 LIBUSB_ENDPOINT_OUT
|
2016 LIBUSB_RECIPIENT_INTERFACE
,
2017 2, 0, interface
, NULL
, 0, 5000);