2 /* Driver for USB Printers
4 * (C) Michael Gee (michael@linuxspecific.com) 1999
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/sched.h>
11 #include <linux/signal.h>
12 #include <linux/errno.h>
13 #include <linux/miscdevice.h>
14 #include <linux/random.h>
15 #include <linux/poll.h>
16 #include <linux/init.h>
17 #include <linux/malloc.h>
19 #include <linux/spinlock.h>
23 #define NAK_TIMEOUT (HZ) /* stall wait for printer */
24 #define MAX_RETRY_COUNT ((60*60*HZ)/NAK_TIMEOUT) /* should not take 1 minute a page! */
26 #ifndef USB_PRINTER_MAJOR
27 #define USB_PRINTER_MAJOR 63
30 static int mymajor
= USB_PRINTER_MAJOR
;
32 #define MAX_PRINTERS 8
35 struct usb_device
*pusb_dev
;
36 __u8 isopen
; /* nz if open */
37 __u8 noinput
; /* nz if no input stream */
38 __u8 minor
; /* minor number of device */
39 __u8 status
; /* last status from device */
40 int maxin
, maxout
; /* max transfer size in and out */
41 char *obuf
; /* transfer buffer (out only) */
42 wait_queue_head_t wait_q
; /* for timeouts */
43 unsigned int last_error
; /* save for checking */
46 static struct pp_usb_data
*minor_data
[MAX_PRINTERS
];
48 #define PPDATA(x) ((struct pp_usb_data *)(x))
50 unsigned char printer_read_status(struct pp_usb_data
*p
)
54 struct usb_device
*dev
= p
->pusb_dev
;
56 dr
.requesttype
= USB_TYPE_CLASS
| USB_RT_INTERFACE
| 0x80;
61 if (dev
->bus
->op
->control_msg(dev
, usb_rcvctrlpipe(dev
,0), &dr
, &status
, 1)) {
67 static int printer_check_status(struct pp_usb_data
*p
)
69 unsigned int last
= p
->last_error
;
70 unsigned char status
= printer_read_status(p
);
72 if (status
& LP_PERRORP
)
75 else if ((status
& LP_POUTPA
)) {
76 if (last
!= LP_POUTPA
) {
78 printk(KERN_INFO
"usblp%d out of paper\n", p
->minor
);
80 } else if (!(status
& LP_PSELECD
)) {
81 if (last
!= LP_PSELECD
) {
83 printk(KERN_INFO
"usblp%d off-line\n", p
->minor
);
86 if (last
!= LP_PERRORP
) {
88 printk(KERN_INFO
"usblp%d on fire\n", p
->minor
);
97 void printer_reset(struct pp_usb_data
*p
)
100 struct usb_device
*dev
= p
->pusb_dev
;
102 dr
.requesttype
= USB_TYPE_CLASS
| USB_RECIP_OTHER
;
107 dev
->bus
->op
->control_msg(dev
, usb_sndctrlpipe(dev
,0), &dr
, NULL
, 0);
110 static int open_printer(struct inode
* inode
, struct file
* file
)
112 struct pp_usb_data
*p
;
114 if(MINOR(inode
->i_rdev
) >= MAX_PRINTERS
||
115 !minor_data
[MINOR(inode
->i_rdev
)]) {
119 p
= minor_data
[MINOR(inode
->i_rdev
)];
120 p
->minor
= MINOR(inode
->i_rdev
);
125 if (!(p
->obuf
= (char *)__get_free_page(GFP_KERNEL
))) {
130 printer_check_status(p
);
133 file
->private_data
= p
;
135 init_waitqueue_head(&p
->wait_q
);
139 static int close_printer(struct inode
* inode
, struct file
* file
)
141 struct pp_usb_data
*p
= file
->private_data
;
143 free_page((unsigned long)p
->obuf
);
145 file
->private_data
= NULL
;
147 minor_data
[p
->minor
] = NULL
;
156 static ssize_t
write_printer(struct file
* file
,
157 const char * buffer
, size_t count
, loff_t
*ppos
)
159 struct pp_usb_data
*p
= file
->private_data
;
160 unsigned long copy_size
;
161 unsigned long bytes_written
= 0;
162 unsigned long partial
;
163 int result
= USB_ST_NOERROR
;
166 struct usb_interface_descriptor
*interface
;
168 interface
= p
->pusb_dev
->config
->interface
->altsetting
;
169 endpoint_num
= (interface
->endpoint
[1].bEndpointAddress
& 0x0f);
172 char *obuf
= p
->obuf
;
173 unsigned long thistime
;
175 thistime
= copy_size
= (count
> p
->maxout
) ? p
->maxout
: count
;
176 if (copy_from_user(p
->obuf
, buffer
, copy_size
))
178 maxretry
= MAX_RETRY_COUNT
;
182 if (signal_pending(current
)) {
183 return bytes_written
? bytes_written
: -EINTR
;
185 result
= p
->pusb_dev
->bus
->op
->bulk_msg(p
->pusb_dev
,
186 usb_sndbulkpipe(p
->pusb_dev
, endpoint_num
),
187 obuf
, thistime
, &partial
);
191 maxretry
= MAX_RETRY_COUNT
;
193 if (result
== USB_ST_TIMEOUT
) { /* NAK - so hold for a while */
196 interruptible_sleep_on_timeout(&p
->wait_q
, NAK_TIMEOUT
);
198 } else if (!result
&& !partial
) {
203 /* whoops - let's reset and fail the request */
204 // printk("Whoops - %x\n", result);
206 interruptible_sleep_on_timeout(&p
->wait_q
, 5*HZ
); /* let reset do its stuff */
209 bytes_written
+= copy_size
;
212 } while ( count
> 0 );
214 return bytes_written
? bytes_written
: -EIO
;
217 static ssize_t
read_printer(struct file
* file
,
218 char * buffer
, size_t count
, loff_t
*ppos
)
220 struct pp_usb_data
*p
= file
->private_data
;
224 unsigned long partial
;
227 struct usb_interface_descriptor
*interface
;
229 interface
= p
->pusb_dev
->config
->interface
->altsetting
;
230 endpoint_num
= (interface
->endpoint
[0].bEndpointAddress
& 0x0f);
237 if (signal_pending(current
)) {
238 return read_count
? read_count
: -EINTR
;
242 this_read
= (count
> sizeof(buf
)) ? sizeof(buf
) : count
;
244 result
= p
->pusb_dev
->bus
->op
->bulk_msg(p
->pusb_dev
,
245 usb_rcvbulkpipe(p
->pusb_dev
, endpoint_num
),
246 buf
, this_read
, &partial
);
248 /* unlike writes, we don't retry a NAK, just stop now */
249 if (!result
& partial
)
250 count
= this_read
= partial
;
255 if (copy_to_user(buffer
, buf
, this_read
))
258 read_count
+= this_read
;
265 static int printer_probe(struct usb_device
*dev
)
267 struct usb_interface_descriptor
*interface
;
271 * FIXME - this will not cope with combined printer/scanners
273 if ((dev
->descriptor
.bDeviceClass
!= 7 &&
274 dev
->descriptor
.bDeviceClass
!= 0) ||
275 dev
->descriptor
.bNumConfigurations
!= 1 ||
276 dev
->config
[0].bNumInterfaces
!= 1) {
280 interface
= &dev
->config
[0].interface
[0].altsetting
[0];
282 /* Lets be paranoid (for the moment)*/
283 if (interface
->bInterfaceClass
!= 7 ||
284 interface
->bInterfaceSubClass
!= 1 ||
285 (interface
->bInterfaceProtocol
!= 2 && interface
->bInterfaceProtocol
!= 1)||
286 interface
->bNumEndpoints
> 2) {
290 if ((interface
->endpoint
[0].bEndpointAddress
& 0xf0) != 0x00 ||
291 interface
->endpoint
[0].bmAttributes
!= 0x02 ||
292 (interface
->bNumEndpoints
> 1 && (
293 (interface
->endpoint
[1].bEndpointAddress
& 0xf0) != 0x80 ||
294 interface
->endpoint
[1].bmAttributes
!= 0x02))) {
298 for (i
=0; i
<MAX_PRINTERS
; i
++) {
302 if (i
>= MAX_PRINTERS
) {
306 printk(KERN_INFO
"USB Printer found at address %d\n", dev
->devnum
);
308 if (!(dev
->private = kmalloc(sizeof(struct pp_usb_data
), GFP_KERNEL
))) {
309 printk( KERN_DEBUG
"usb_printer: no memory!\n");
313 memset(dev
->private, 0, sizeof(struct pp_usb_data
));
314 minor_data
[i
] = PPDATA(dev
->private);
315 minor_data
[i
]->minor
= i
;
316 minor_data
[i
]->pusb_dev
= dev
;
317 /* The max packet size can't be more than 64 (& will be 64 for
318 * any decent bulk device); this calculation was silly. -greg
319 * minor_data[i]->maxout = interface->endpoint[0].wMaxPacketSize * 16;
321 minor_data
[i
]->maxout
= 8192;
322 if (minor_data
[i
]->maxout
> PAGE_SIZE
) {
323 minor_data
[i
]->maxout
= PAGE_SIZE
;
325 if (interface
->bInterfaceProtocol
!= 2)
326 minor_data
[i
]->noinput
= 1;
328 minor_data
[i
]->maxin
= interface
->endpoint
[1].wMaxPacketSize
;
331 if (usb_set_configuration(dev
, dev
->config
[0].bConfigurationValue
)) {
332 printk(KERN_INFO
" Failed usb_set_configuration: printer\n");
341 /* Lets get the device id if possible */
342 dr
.requesttype
= USB_TYPE_CLASS
| USB_RT_INTERFACE
| 0x80;
346 dr
.length
= sizeof(ieee_id
) - 1;
347 if (dev
->bus
->op
->control_msg(dev
, usb_rcvctrlpipe(dev
,0), &dr
, ieee_id
, sizeof(ieee_id
)-1) == 0) {
348 if (ieee_id
[1] < sizeof(ieee_id
) - 1)
349 ieee_id
[ieee_id
[1]+2] = '\0';
351 ieee_id
[sizeof(ieee_id
)-1] = '\0';
352 printk(KERN_INFO
" Printer ID is %s\n", &ieee_id
[2]);
354 status
= printer_read_status(PPDATA(dev
->private));
355 printk(KERN_INFO
" Status is %s,%s,%s\n",
356 (status
& 0x10) ? "Selected" : "Not Selected",
357 (status
& 0x20) ? "No Paper" : "Paper",
358 (status
& 0x08) ? "No Error" : "Error");
364 static void printer_disconnect(struct usb_device
*dev
)
366 struct pp_usb_data
*pp
= dev
->private;
369 /* better let it finish - the release will do whats needed */
373 minor_data
[pp
->minor
] = NULL
;
375 dev
->private = NULL
; /* just in case */
379 static struct usb_driver printer_driver
= {
386 static struct file_operations usb_printer_fops
= {
391 NULL
, /* poll - out for the moment */
401 int usb_printer_init(void)
407 if ((result
= register_chrdev(USB_PRINTER_MAJOR
, "usblp", &usb_printer_fops
)) < 0) {
408 printk(KERN_WARNING
"usbprinter: Cannot register device\n");
414 usb_register(&printer_driver
);
415 printk(KERN_INFO
"USB Printer support registered.\n");
420 int init_module(void)
423 return usb_printer_init();
426 void cleanup_module(void)
428 usb_deregister(&printer_driver
);
429 unregister_chrdev(mymajor
, "usblp");