drivers/usb/misc/uss720.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *      uss720.c  --  USS720 USB Parport Cable.
   5  *
   6  *      Copyright (C) 1999, 2005
   7  *          Thomas Sailer (t.sailer@alumni.ethz.ch)
   8  *
   9  *      This program is free software; you can redistribute it and/or modify
  10  *      it under the terms of the GNU General Public License as published by
  11  *      the Free Software Foundation; either version 2 of the License, or
  12  *      (at your option) any later version.
  13  *
  14  *      This program is distributed in the hope that it will be useful,
  15  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *      GNU General Public License for more details.
  18  *
  19  *      You should have received a copy of the GNU General Public License
  20  *      along with this program; if not, write to the Free Software
  21  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  *  Based on parport_pc.c
  24  *
  25  *  History:
  26  *   0.1  04.08.1999  Created
  27  *   0.2  07.08.1999  Some fixes mainly suggested by Tim Waugh
  28  *                    Interrupt handling currently disabled because
  29  *                    usb_request_irq crashes somewhere within ohci.c
  30  *                    for no apparent reason (that is for me, anyway)
  31  *                    ECP currently untested
  32  *   0.3  10.08.1999  fixing merge errors
  33  *   0.4  13.08.1999  Added Vendor/Product ID of Brad Hard's cable
  34  *   0.5  20.09.1999  usb_control_msg wrapper used
  35  *        Nov01.2000  usb_device_table support by Adam J. Richter
  36  *        08.04.2001  Identify version on module load.  gb
  37  *   0.6  02.09.2005  Fix "scheduling in interrupt" problem by making save/restore
  38  *                    context asynchronous
  39  *
  40  */
  41
  42 /*****************************************************************************/
  43
  44 #include <linux/module.h>
  45 #include <linux/socket.h>
  46 #include <linux/parport.h>
  47 #include <linux/init.h>
  48 #include <linux/usb.h>
  49 #include <linux/delay.h>
  50 #include <linux/completion.h>
  51 #include <linux/kref.h>
  52
  53 /*
  54  * Version Information
  55  */
  56 #define DRIVER_VERSION "v0.6"
  57 #define DRIVER_AUTHOR "Thomas M. Sailer, t.sailer@alumni.ethz.ch"
  58 #define DRIVER_DESC "USB Parport Cable driver for Cables using the Lucent Technologies USS720 Chip"
  59
  60 /* --------------------------------------------------------------------- */
  61
  62 struct parport_uss720_private {
  63         struct usb_device *usbdev;
  64         struct parport *pp;
  65         struct kref ref_count;
  66         __u8 reg[7];  /* USB registers */
  67         struct list_head asynclist;
  68         spinlock_t asynclock;
  69 };
  70
  71 struct uss720_async_request {
  72         struct parport_uss720_private *priv;
  73         struct kref ref_count;
  74         struct list_head asynclist;
  75         struct completion compl;
  76         struct urb *urb;
  77         struct usb_ctrlrequest dr;
  78         __u8 reg[7];
  79 };
  80
  81 /* --------------------------------------------------------------------- */
  82
  83 static void destroy_priv(struct kref *kref)
  84 {
  85         struct parport_uss720_private *priv = container_of(kref, struct parport_uss720_private, ref_count);
  86
  87         usb_put_dev(priv->usbdev);
  88         kfree(priv);
  89         dbg("destroying priv datastructure");
  90 }
  91
  92 static void destroy_async(struct kref *kref)
  93 {
  94         struct uss720_async_request *rq = container_of(kref, struct uss720_async_request, ref_count);
  95         struct parport_uss720_private *priv = rq->priv;
  96         unsigned long flags;
  97
  98         if (likely(rq->urb))
  99                 usb_free_urb(rq->urb);
 100         spin_lock_irqsave(&priv->asynclock, flags);
 101         list_del_init(&rq->asynclist);
 102         spin_unlock_irqrestore(&priv->asynclock, flags);
 103         kfree(rq);
 104         kref_put(&priv->ref_count, destroy_priv);
 105 }
 106
 107 /* --------------------------------------------------------------------- */
 108
 109 static void async_complete(struct urb *urb)
 110 {
 111         struct uss720_async_request *rq;
 112         struct parport *pp;
 113         struct parport_uss720_private *priv;
 114         int status = urb->status;
 115
 116         rq = urb->context;
 117         priv = rq->priv;
 118         pp = priv->pp;
 119         if (status) {
 120                 err("async_complete: urb error %d", status);
 121         } else if (rq->dr.bRequest == 3) {
 122                 memcpy(priv->reg, rq->reg, sizeof(priv->reg));
 123 #if 0
 124                 dbg("async_complete regs %02x %02x %02x %02x %02x %02x %02x",
 125                     (unsigned int)priv->reg[0], (unsigned int)priv->reg[1], (unsigned int)priv->reg[2],
 126                     (unsigned int)priv->reg[3], (unsigned int)priv->reg[4], (unsigned int)priv->reg[5],
 127                     (unsigned int)priv->reg[6]);
 128 #endif
 129                 /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
 130                 if (rq->reg[2] & rq->reg[1] & 0x10 && pp)
 131                         parport_generic_irq(pp);
 132         }
 133         complete(&rq->compl);
 134         kref_put(&rq->ref_count, destroy_async);
 135 }
 136
 137 static struct uss720_async_request *submit_async_request(struct parport_uss720_private *priv,
 138                                                          __u8 request, __u8 requesttype, __u16 value, __u16 index,
 139                                                          gfp_t mem_flags)
 140 {
 141         struct usb_device *usbdev;
 142         struct uss720_async_request *rq;
 143         unsigned long flags;
 144         int ret;
 145
 146         if (!priv)
 147                 return NULL;
 148         usbdev = priv->usbdev;
 149         if (!usbdev)
 150                 return NULL;
 151         rq = kmalloc(sizeof(struct uss720_async_request), mem_flags);
 152         if (!rq) {
 153                 err("submit_async_request out of memory");
 154                 return NULL;
 155         }
 156         kref_init(&rq->ref_count);
 157         INIT_LIST_HEAD(&rq->asynclist);
 158         init_completion(&rq->compl);
 159         kref_get(&priv->ref_count);
 160         rq->priv = priv;
 161         rq->urb = usb_alloc_urb(0, mem_flags);
 162         if (!rq->urb) {
 163                 kref_put(&rq->ref_count, destroy_async);
 164                 err("submit_async_request out of memory");
 165                 return NULL;
 166         }
 167         rq->dr.bRequestType = requesttype;
 168         rq->dr.bRequest = request;
 169         rq->dr.wValue = cpu_to_le16(value);
 170         rq->dr.wIndex = cpu_to_le16(index);
 171         rq->dr.wLength = cpu_to_le16((request == 3) ? sizeof(rq->reg) : 0);
 172         usb_fill_control_urb(rq->urb, usbdev, (requesttype & 0x80) ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0),
 173                              (unsigned char *)&rq->dr,
 174                              (request == 3) ? rq->reg : NULL, (request == 3) ? sizeof(rq->reg) : 0, async_complete, rq);
 175         /* rq->urb->transfer_flags |= URB_ASYNC_UNLINK; */
 176         spin_lock_irqsave(&priv->asynclock, flags);
 177         list_add_tail(&rq->asynclist, &priv->asynclist);
 178         spin_unlock_irqrestore(&priv->asynclock, flags);
 179         ret = usb_submit_urb(rq->urb, mem_flags);
 180         if (!ret) {
 181                 kref_get(&rq->ref_count);
 182                 return rq;
 183         }
 184         kref_put(&rq->ref_count, destroy_async);
 185         err("submit_async_request submit_urb failed with %d", ret);
 186         return NULL;
 187 }
 188
 189 static unsigned int kill_all_async_requests_priv(struct parport_uss720_private *priv)
 190 {
 191         struct uss720_async_request *rq;
 192         unsigned long flags;
 193         unsigned int ret = 0;
 194
 195         spin_lock_irqsave(&priv->asynclock, flags);
 196         list_for_each_entry(rq, &priv->asynclist, asynclist) {
 197                 usb_unlink_urb(rq->urb);
 198                 ret++;
 199         }
 200         spin_unlock_irqrestore(&priv->asynclock, flags);
 201         return ret;
 202 }
 203
 204 /* --------------------------------------------------------------------- */
 205
 206 static int get_1284_register(struct parport *pp, unsigned char reg, unsigned char *val, gfp_t mem_flags)
 207 {
 208         struct parport_uss720_private *priv;
 209         struct uss720_async_request *rq;
 210         static const unsigned char regindex[9] = {
 211                 4, 0, 1, 5, 5, 0, 2, 3, 6
 212         };
 213         int ret;
 214
 215         if (!pp)
 216                 return -EIO;
 217         priv = pp->private_data;
 218         rq = submit_async_request(priv, 3, 0xc0, ((unsigned int)reg) << 8, 0, mem_flags);
 219         if (!rq) {
 220                 err("get_1284_register(%u) failed", (unsigned int)reg);
 221                 return -EIO;
 222         }
 223         if (!val) {
 224                 kref_put(&rq->ref_count, destroy_async);
 225                 return 0;
 226         }
 227         if (wait_for_completion_timeout(&rq->compl, HZ)) {
 228                 ret = rq->urb->status;
 229                 *val = priv->reg[(reg >= 9) ? 0 : regindex[reg]];
 230                 if (ret)
 231                         printk(KERN_WARNING "get_1284_register: "
 232                                "usb error %d\n", ret);
 233                 kref_put(&rq->ref_count, destroy_async);
 234                 return ret;
 235         }
 236         printk(KERN_WARNING "get_1284_register timeout\n");
 237         kill_all_async_requests_priv(priv);
 238         return -EIO;
 239 }
 240
 241 static int set_1284_register(struct parport *pp, unsigned char reg, unsigned char val, gfp_t mem_flags)
 242 {
 243         struct parport_uss720_private *priv;
 244         struct uss720_async_request *rq;
 245
 246         if (!pp)
 247                 return -EIO;
 248         priv = pp->private_data;
 249         rq = submit_async_request(priv, 4, 0x40, (((unsigned int)reg) << 8) | val, 0, mem_flags);
 250         if (!rq) {
 251                 err("set_1284_register(%u,%u) failed", (unsigned int)reg, (unsigned int)val);
 252                 return -EIO;
 253         }
 254         kref_put(&rq->ref_count, destroy_async);
 255         return 0;
 256 }
 257
 258 /* --------------------------------------------------------------------- */
 259
 260 /* ECR modes */
 261 #define ECR_SPP 00
 262 #define ECR_PS2 01
 263 #define ECR_PPF 02
 264 #define ECR_ECP 03
 265 #define ECR_EPP 04
 266
 267 /* Safely change the mode bits in the ECR */
 268 static int change_mode(struct parport *pp, int m)
 269 {
 270         struct parport_uss720_private *priv = pp->private_data;
 271         int mode;
 272         __u8 reg;
 273
 274         if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
 275                 return -EIO;
 276         /* Bits <7:5> contain the mode. */
 277         mode = (priv->reg[2] >> 5) & 0x7;
 278         if (mode == m)
 279                 return 0;
 280         /* We have to go through mode 000 or 001 */
 281         if (mode > ECR_PS2 && m > ECR_PS2)
 282                 if (change_mode(pp, ECR_PS2))
 283                         return -EIO;
 284
 285         if (m <= ECR_PS2 && !(priv->reg[1] & 0x20)) {
 286                 /* This mode resets the FIFO, so we may
 287                  * have to wait for it to drain first. */
 288                 unsigned long expire = jiffies + pp->physport->cad->timeout;
 289                 switch (mode) {
 290                 case ECR_PPF: /* Parallel Port FIFO mode */
 291                 case ECR_ECP: /* ECP Parallel Port mode */
 292                         /* Poll slowly. */
 293                         for (;;) {
 294                                 if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
 295                                         return -EIO;
 296                                 if (priv->reg[2] & 0x01)
 297                                         break;
 298                                 if (time_after_eq (jiffies, expire))
 299                                         /* The FIFO is stuck. */
 300                                         return -EBUSY;
 301                                 msleep_interruptible(10);
 302                                 if (signal_pending (current))
 303                                         break;
 304                         }
 305                 }
 306         }
 307         /* Set the mode. */
 308         if (set_1284_register(pp, 6, m << 5, GFP_KERNEL))
 309                 return -EIO;
 310         if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
 311                 return -EIO;
 312         return 0;
 313 }
 314
 315 /*
 316  * Clear TIMEOUT BIT in EPP MODE
 317  */
 318 static int clear_epp_timeout(struct parport *pp)
 319 {
 320         unsigned char stat;
 321
 322         if (get_1284_register(pp, 1, &stat, GFP_KERNEL))
 323                 return 1;
 324         return stat & 1;
 325 }
 326
 327 /*
 328  * Access functions.
 329  */
 330 #if 0
 331 static int uss720_irq(int usbstatus, void *buffer, int len, void *dev_id)
 332 {
 333         struct parport *pp = (struct parport *)dev_id;
 334         struct parport_uss720_private *priv = pp->private_data;
 335
 336         if (usbstatus != 0 || len < 4 || !buffer)
 337                 return 1;
 338         memcpy(priv->reg, buffer, 4);
 339         /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
 340         if (priv->reg[2] & priv->reg[1] & 0x10)
 341                 parport_generic_irq(pp);
 342         return 1;
 343 }
 344 #endif
 345
 346 static void parport_uss720_write_data(struct parport *pp, unsigned char d)
 347 {
 348         set_1284_register(pp, 0, d, GFP_KERNEL);
 349 }
 350
 351 static unsigned char parport_uss720_read_data(struct parport *pp)
 352 {
 353         unsigned char ret;
 354
 355         if (get_1284_register(pp, 0, &ret, GFP_KERNEL))
 356                 return 0;
 357         return ret;
 358 }
 359
 360 static void parport_uss720_write_control(struct parport *pp, unsigned char d)
 361 {
 362         struct parport_uss720_private *priv = pp->private_data;
 363
 364         d = (d & 0xf) | (priv->reg[1] & 0xf0);
 365         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 366                 return;
 367         priv->reg[1] = d;
 368 }
 369
 370 static unsigned char parport_uss720_read_control(struct parport *pp)
 371 {
 372         struct parport_uss720_private *priv = pp->private_data;
 373         return priv->reg[1] & 0xf; /* Use soft copy */
 374 }
 375
 376 static unsigned char parport_uss720_frob_control(struct parport *pp, unsigned char mask, unsigned char val)
 377 {
 378         struct parport_uss720_private *priv = pp->private_data;
 379         unsigned char d;
 380
 381         mask &= 0x0f;
 382         val &= 0x0f;
 383         d = (priv->reg[1] & (~mask)) ^ val;
 384         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 385                 return 0;
 386         priv->reg[1] = d;
 387         return d & 0xf;
 388 }
 389
 390 static unsigned char parport_uss720_read_status(struct parport *pp)
 391 {
 392         unsigned char ret;
 393
 394         if (get_1284_register(pp, 1, &ret, GFP_KERNEL))
 395                 return 0;
 396         return ret & 0xf8;
 397 }
 398
 399 static void parport_uss720_disable_irq(struct parport *pp)
 400 {
 401         struct parport_uss720_private *priv = pp->private_data;
 402         unsigned char d;
 403
 404         d = priv->reg[1] & ~0x10;
 405         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 406                 return;
 407         priv->reg[1] = d;
 408 }
 409
 410 static void parport_uss720_enable_irq(struct parport *pp)
 411 {
 412         struct parport_uss720_private *priv = pp->private_data;
 413         unsigned char d;
 414
 415         d = priv->reg[1] | 0x10;
 416         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 417                 return;
 418         priv->reg[1] = d;
 419 }
 420
 421 static void parport_uss720_data_forward (struct parport *pp)
 422 {
 423         struct parport_uss720_private *priv = pp->private_data;
 424         unsigned char d;
 425
 426         d = priv->reg[1] & ~0x20;
 427         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 428                 return;
 429         priv->reg[1] = d;
 430 }
 431
 432 static void parport_uss720_data_reverse (struct parport *pp)
 433 {
 434         struct parport_uss720_private *priv = pp->private_data;
 435         unsigned char d;
 436
 437         d = priv->reg[1] | 0x20;
 438         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 439                 return;
 440         priv->reg[1] = d;
 441 }
 442
 443 static void parport_uss720_init_state(struct pardevice *dev, struct parport_state *s)
 444 {
 445         s->u.pc.ctr = 0xc | (dev->irq_func ? 0x10 : 0x0);
 446         s->u.pc.ecr = 0x24;
 447 }
 448
 449 static void parport_uss720_save_state(struct parport *pp, struct parport_state *s)
 450 {
 451         struct parport_uss720_private *priv = pp->private_data;
 452
 453 #if 0
 454         if (get_1284_register(pp, 2, NULL, GFP_ATOMIC))
 455                 return;
 456 #endif
 457         s->u.pc.ctr = priv->reg[1];
 458         s->u.pc.ecr = priv->reg[2];
 459 }
 460
 461 static void parport_uss720_restore_state(struct parport *pp, struct parport_state *s)
 462 {
 463         struct parport_uss720_private *priv = pp->private_data;
 464
 465         set_1284_register(pp, 2, s->u.pc.ctr, GFP_ATOMIC);
 466         set_1284_register(pp, 6, s->u.pc.ecr, GFP_ATOMIC);
 467         get_1284_register(pp, 2, NULL, GFP_ATOMIC);
 468         priv->reg[1] = s->u.pc.ctr;
 469         priv->reg[2] = s->u.pc.ecr;
 470 }
 471
 472 static size_t parport_uss720_epp_read_data(struct parport *pp, void *buf, size_t length, int flags)
 473 {
 474         struct parport_uss720_private *priv = pp->private_data;
 475         size_t got = 0;
 476
 477         if (change_mode(pp, ECR_EPP))
 478                 return 0;
 479         for (; got < length; got++) {
 480                 if (get_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
 481                         break;
 482                 buf++;
 483                 if (priv->reg[0] & 0x01) {
 484                         clear_epp_timeout(pp);
 485                         break;
 486                 }
 487         }
 488         change_mode(pp, ECR_PS2);
 489         return got;
 490 }
 491
 492 static size_t parport_uss720_epp_write_data(struct parport *pp, const void *buf, size_t length, int flags)
 493 {
 494 #if 0
 495         struct parport_uss720_private *priv = pp->private_data;
 496         size_t written = 0;
 497
 498         if (change_mode(pp, ECR_EPP))
 499                 return 0;
 500         for (; written < length; written++) {
 501                 if (set_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
 502                         break;
 503                 ((char*)buf)++;
 504                 if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
 505                         break;
 506                 if (priv->reg[0] & 0x01) {
 507                         clear_epp_timeout(pp);
 508                         break;
 509                 }
 510         }
 511         change_mode(pp, ECR_PS2);
 512         return written;
 513 #else
 514         struct parport_uss720_private *priv = pp->private_data;
 515         struct usb_device *usbdev = priv->usbdev;
 516         int rlen;
 517         int i;
 518
 519         if (!usbdev)
 520                 return 0;
 521         if (change_mode(pp, ECR_EPP))
 522                 return 0;
 523         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buf, length, &rlen, 20000);
 524         if (i)
 525                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buf, length, rlen);
 526         change_mode(pp, ECR_PS2);
 527         return rlen;
 528 #endif
 529 }
 530
 531 static size_t parport_uss720_epp_read_addr(struct parport *pp, void *buf, size_t length, int flags)
 532 {
 533         struct parport_uss720_private *priv = pp->private_data;
 534         size_t got = 0;
 535
 536         if (change_mode(pp, ECR_EPP))
 537                 return 0;
 538         for (; got < length; got++) {
 539                 if (get_1284_register(pp, 3, (char *)buf, GFP_KERNEL))
 540                         break;
 541                 buf++;
 542                 if (priv->reg[0] & 0x01) {
 543                         clear_epp_timeout(pp);
 544                         break;
 545                 }
 546         }
 547         change_mode(pp, ECR_PS2);
 548         return got;
 549 }
 550
 551 static size_t parport_uss720_epp_write_addr(struct parport *pp, const void *buf, size_t length, int flags)
 552 {
 553         struct parport_uss720_private *priv = pp->private_data;
 554         size_t written = 0;
 555
 556         if (change_mode(pp, ECR_EPP))
 557                 return 0;
 558         for (; written < length; written++) {
 559                 if (set_1284_register(pp, 3, *(char *)buf, GFP_KERNEL))
 560                         break;
 561                 buf++;
 562                 if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
 563                         break;
 564                 if (priv->reg[0] & 0x01) {
 565                         clear_epp_timeout(pp);
 566                         break;
 567                 }
 568         }
 569         change_mode(pp, ECR_PS2);
 570         return written;
 571 }
 572
 573 static size_t parport_uss720_ecp_write_data(struct parport *pp, const void *buffer, size_t len, int flags)
 574 {
 575         struct parport_uss720_private *priv = pp->private_data;
 576         struct usb_device *usbdev = priv->usbdev;
 577         int rlen;
 578         int i;
 579
 580         if (!usbdev)
 581                 return 0;
 582         if (change_mode(pp, ECR_ECP))
 583                 return 0;
 584         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000);
 585         if (i)
 586                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen);
 587         change_mode(pp, ECR_PS2);
 588         return rlen;
 589 }
 590
 591 static size_t parport_uss720_ecp_read_data(struct parport *pp, void *buffer, size_t len, int flags)
 592 {
 593         struct parport_uss720_private *priv = pp->private_data;
 594         struct usb_device *usbdev = priv->usbdev;
 595         int rlen;
 596         int i;
 597
 598         if (!usbdev)
 599                 return 0;
 600         if (change_mode(pp, ECR_ECP))
 601                 return 0;
 602         i = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), buffer, len, &rlen, 20000);
 603         if (i)
 604                 printk(KERN_ERR "uss720: recvbulk ep 2 buf %p len %Zu rlen %u\n", buffer, len, rlen);
 605         change_mode(pp, ECR_PS2);
 606         return rlen;
 607 }
 608
 609 static size_t parport_uss720_ecp_write_addr(struct parport *pp, const void *buffer, size_t len, int flags)
 610 {
 611         size_t written = 0;
 612
 613         if (change_mode(pp, ECR_ECP))
 614                 return 0;
 615         for (; written < len; written++) {
 616                 if (set_1284_register(pp, 5, *(char *)buffer, GFP_KERNEL))
 617                         break;
 618                 buffer++;
 619         }
 620         change_mode(pp, ECR_PS2);
 621         return written;
 622 }
 623
 624 static size_t parport_uss720_write_compat(struct parport *pp, const void *buffer, size_t len, int flags)
 625 {
 626         struct parport_uss720_private *priv = pp->private_data;
 627         struct usb_device *usbdev = priv->usbdev;
 628         int rlen;
 629         int i;
 630
 631         if (!usbdev)
 632                 return 0;
 633         if (change_mode(pp, ECR_PPF))
 634                 return 0;
 635         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000);
 636         if (i)
 637                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen);
 638         change_mode(pp, ECR_PS2);
 639         return rlen;
 640 }
 641
 642 /* --------------------------------------------------------------------- */
 643
 644 static struct parport_operations parport_uss720_ops =
 645 {
 646         .owner =                THIS_MODULE,
 647         .write_data =           parport_uss720_write_data,
 648         .read_data =            parport_uss720_read_data,
 649
 650         .write_control =        parport_uss720_write_control,
 651         .read_control =         parport_uss720_read_control,
 652         .frob_control =         parport_uss720_frob_control,
 653
 654         .read_status =          parport_uss720_read_status,
 655
 656         .enable_irq =           parport_uss720_enable_irq,
 657         .disable_irq =          parport_uss720_disable_irq,
 658
 659         .data_forward =         parport_uss720_data_forward,
 660         .data_reverse =         parport_uss720_data_reverse,
 661
 662         .init_state =           parport_uss720_init_state,
 663         .save_state =           parport_uss720_save_state,
 664         .restore_state =        parport_uss720_restore_state,
 665
 666         .epp_write_data =       parport_uss720_epp_write_data,
 667         .epp_read_data =        parport_uss720_epp_read_data,
 668         .epp_write_addr =       parport_uss720_epp_write_addr,
 669         .epp_read_addr =        parport_uss720_epp_read_addr,
 670
 671         .ecp_write_data =       parport_uss720_ecp_write_data,
 672         .ecp_read_data =        parport_uss720_ecp_read_data,
 673         .ecp_write_addr =       parport_uss720_ecp_write_addr,
 674
 675         .compat_write_data =    parport_uss720_write_compat,
 676         .nibble_read_data =     parport_ieee1284_read_nibble,
 677         .byte_read_data =       parport_ieee1284_read_byte,
 678 };
 679
 680 /* --------------------------------------------------------------------- */
 681
 682 static int uss720_probe(struct usb_interface *intf,
 683                         const struct usb_device_id *id)
 684 {
 685         struct usb_device *usbdev = usb_get_dev(interface_to_usbdev(intf));
 686         struct usb_host_interface *interface;
 687         struct usb_host_endpoint *endpoint;
 688         struct parport_uss720_private *priv;
 689         struct parport *pp;
 690         unsigned char reg;
 691         int i;
 692
 693         dbg("probe: vendor id 0x%x, device id 0x%x\n",
 694             le16_to_cpu(usbdev->descriptor.idVendor),
 695             le16_to_cpu(usbdev->descriptor.idProduct));
 696
 697         /* our known interfaces have 3 alternate settings */
 698         if (intf->num_altsetting != 3) {
 699                 usb_put_dev(usbdev);
 700                 return -ENODEV;
 701         }
 702         i = usb_set_interface(usbdev, intf->altsetting->desc.bInterfaceNumber, 2);
 703         dbg("set inteface result %d", i);
 704
 705         interface = intf->cur_altsetting;
 706
 707         /*
 708          * Allocate parport interface
 709          */
 710         if (!(priv = kzalloc(sizeof(struct parport_uss720_private), GFP_KERNEL))) {
 711                 usb_put_dev(usbdev);
 712                 return -ENOMEM;
 713         }
 714         priv->pp = NULL;
 715         priv->usbdev = usbdev;
 716         kref_init(&priv->ref_count);
 717         spin_lock_init(&priv->asynclock);
 718         INIT_LIST_HEAD(&priv->asynclist);
 719         if (!(pp = parport_register_port(0, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &parport_uss720_ops))) {
 720                 printk(KERN_WARNING "uss720: could not register parport\n");
 721                 goto probe_abort;
 722         }
 723
 724         priv->pp = pp;
 725         pp->private_data = priv;
 726         pp->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_TRISTATE | PARPORT_MODE_EPP | PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
 727
 728         /* set the USS720 control register to manual mode, no ECP compression, enable all ints */
 729         set_1284_register(pp, 7, 0x00, GFP_KERNEL);
 730         set_1284_register(pp, 6, 0x30, GFP_KERNEL);  /* PS/2 mode */
 731         set_1284_register(pp, 2, 0x0c, GFP_KERNEL);
 732         /* debugging */
 733         get_1284_register(pp, 0, &reg, GFP_KERNEL);
 734         dbg("reg: %02x %02x %02x %02x %02x %02x %02x",
 735             priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
 736
 737         endpoint = &interface->endpoint[2];
 738         dbg("epaddr %d interval %d", endpoint->desc.bEndpointAddress, endpoint->desc.bInterval);
 739         parport_announce_port(pp);
 740
 741         usb_set_intfdata(intf, pp);
 742         return 0;
 743
 744 probe_abort:
 745         kill_all_async_requests_priv(priv);
 746         kref_put(&priv->ref_count, destroy_priv);
 747         return -ENODEV;
 748 }
 749
 750 static void uss720_disconnect(struct usb_interface *intf)
 751 {
 752         struct parport *pp = usb_get_intfdata(intf);
 753         struct parport_uss720_private *priv;
 754         struct usb_device *usbdev;
 755
 756         dbg("disconnect");
 757         usb_set_intfdata(intf, NULL);
 758         if (pp) {
 759                 priv = pp->private_data;
 760                 usbdev = priv->usbdev;
 761                 priv->usbdev = NULL;
 762                 priv->pp = NULL;
 763                 dbg("parport_remove_port");
 764                 parport_remove_port(pp);
 765                 parport_put_port(pp);
 766                 kill_all_async_requests_priv(priv);
 767                 kref_put(&priv->ref_count, destroy_priv);
 768         }
 769         dbg("disconnect done");
 770 }
 771
 772 /* table of cables that work through this driver */
 773 static struct usb_device_id uss720_table [] = {
 774         { USB_DEVICE(0x047e, 0x1001) },
 775         { USB_DEVICE(0x0557, 0x2001) },
 776         { USB_DEVICE(0x0729, 0x1284) },
 777         { USB_DEVICE(0x1293, 0x0002) },
 778         { }                                             /* Terminating entry */
 779 };
 780
 781 MODULE_DEVICE_TABLE (usb, uss720_table);
 782
 783
 784 static struct usb_driver uss720_driver = {
 785         .name =         "uss720",
 786         .probe =        uss720_probe,
 787         .disconnect =   uss720_disconnect,
 788         .id_table =     uss720_table,
 789 };
 790
 791 /* --------------------------------------------------------------------- */
 792
 793 MODULE_AUTHOR(DRIVER_AUTHOR);
 794 MODULE_DESCRIPTION(DRIVER_DESC);
 795 MODULE_LICENSE("GPL");
 796
 797 static int __init uss720_init(void)
 798 {
 799         int retval;
 800         retval = usb_register(&uss720_driver);
 801         if (retval)
 802                 goto out;
 803
 804         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 805                DRIVER_DESC "\n");
 806         printk(KERN_INFO KBUILD_MODNAME ": NOTE: this is a special purpose "
 807                "driver to allow nonstandard\n");
 808         printk(KERN_INFO KBUILD_MODNAME ": protocols (eg. bitbang) over "
 809                "USS720 usb to parallel cables\n");
 810         printk(KERN_INFO KBUILD_MODNAME ": If you just want to connect to a "
 811                "printer, use usblp instead\n");
 812 out:
 813         return retval;
 814 }
 815
 816 static void __exit uss720_cleanup(void)
 817 {
 818         usb_deregister(&uss720_driver);
 819 }
 820
 821 module_init(uss720_init);
 822 module_exit(uss720_cleanup);
 823
 824 /* --------------------------------------------------------------------- */