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
 115         rq = urb->context;
 116         priv = rq->priv;
 117         pp = priv->pp;
 118         if (urb->status) {
 119                 err("async_complete: urb error %d", urb->status);
 120         } else if (rq->dr.bRequest == 3) {
 121                 memcpy(priv->reg, rq->reg, sizeof(priv->reg));
 122 #if 0
 123                 dbg("async_complete regs %02x %02x %02x %02x %02x %02x %02x",
 124                     (unsigned int)priv->reg[0], (unsigned int)priv->reg[1], (unsigned int)priv->reg[2],
 125                     (unsigned int)priv->reg[3], (unsigned int)priv->reg[4], (unsigned int)priv->reg[5],
 126                     (unsigned int)priv->reg[6]);
 127 #endif
 128                 /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
 129                 if (rq->reg[2] & rq->reg[1] & 0x10 && pp)
 130                         parport_generic_irq(0, pp);
 131         }
 132         complete(&rq->compl);
 133         kref_put(&rq->ref_count, destroy_async);
 134 }
 135
 136 static struct uss720_async_request *submit_async_request(struct parport_uss720_private *priv,
 137                                                          __u8 request, __u8 requesttype, __u16 value, __u16 index,
 138                                                          gfp_t mem_flags)
 139 {
 140         struct usb_device *usbdev;
 141         struct uss720_async_request *rq;
 142         unsigned long flags;
 143         int ret;
 144
 145         if (!priv)
 146                 return NULL;
 147         usbdev = priv->usbdev;
 148         if (!usbdev)
 149                 return NULL;
 150         rq = kmalloc(sizeof(struct uss720_async_request), mem_flags);
 151         if (!rq) {
 152                 err("submit_async_request out of memory");
 153                 return NULL;
 154         }
 155         kref_init(&rq->ref_count);
 156         INIT_LIST_HEAD(&rq->asynclist);
 157         init_completion(&rq->compl);
 158         kref_get(&priv->ref_count);
 159         rq->priv = priv;
 160         rq->urb = usb_alloc_urb(0, mem_flags);
 161         if (!rq->urb) {
 162                 kref_put(&rq->ref_count, destroy_async);
 163                 err("submit_async_request out of memory");
 164                 return NULL;
 165         }
 166         rq->dr.bRequestType = requesttype;
 167         rq->dr.bRequest = request;
 168         rq->dr.wValue = cpu_to_le16(value);
 169         rq->dr.wIndex = cpu_to_le16(index);
 170         rq->dr.wLength = cpu_to_le16((request == 3) ? sizeof(rq->reg) : 0);
 171         usb_fill_control_urb(rq->urb, usbdev, (requesttype & 0x80) ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0),
 172                              (unsigned char *)&rq->dr,
 173                              (request == 3) ? rq->reg : NULL, (request == 3) ? sizeof(rq->reg) : 0, async_complete, rq);
 174         /* rq->urb->transfer_flags |= URB_ASYNC_UNLINK; */
 175         spin_lock_irqsave(&priv->asynclock, flags);
 176         list_add_tail(&rq->asynclist, &priv->asynclist);
 177         spin_unlock_irqrestore(&priv->asynclock, flags);
 178         ret = usb_submit_urb(rq->urb, mem_flags);
 179         if (!ret) {
 180                 kref_get(&rq->ref_count);
 181                 return rq;
 182         }
 183         kref_put(&rq->ref_count, destroy_async);
 184         err("submit_async_request submit_urb failed with %d", ret);
 185         return NULL;
 186 }
 187
 188 static unsigned int kill_all_async_requests_priv(struct parport_uss720_private *priv)
 189 {
 190         struct uss720_async_request *rq;
 191         unsigned long flags;
 192         unsigned int ret = 0;
 193
 194         spin_lock_irqsave(&priv->asynclock, flags);
 195         list_for_each_entry(rq, &priv->asynclist, asynclist) {
 196                 usb_unlink_urb(rq->urb);
 197                 ret++;
 198         }
 199         spin_unlock_irqrestore(&priv->asynclock, flags);
 200         return ret;
 201 }
 202
 203 /* --------------------------------------------------------------------- */
 204
 205 static int get_1284_register(struct parport *pp, unsigned char reg, unsigned char *val, gfp_t mem_flags)
 206 {
 207         struct parport_uss720_private *priv;
 208         struct uss720_async_request *rq;
 209         static const unsigned char regindex[9] = {
 210                 4, 0, 1, 5, 5, 0, 2, 3, 6
 211         };
 212         int ret;
 213
 214         if (!pp)
 215                 return -EIO;
 216         priv = pp->private_data;
 217         rq = submit_async_request(priv, 3, 0xc0, ((unsigned int)reg) << 8, 0, mem_flags);
 218         if (!rq) {
 219                 err("get_1284_register(%u) failed", (unsigned int)reg);
 220                 return -EIO;
 221         }
 222         if (!val) {
 223                 kref_put(&rq->ref_count, destroy_async);
 224                 return 0;
 225         }
 226         if (wait_for_completion_timeout(&rq->compl, HZ)) {
 227                 ret = rq->urb->status;
 228                 *val = priv->reg[(reg >= 9) ? 0 : regindex[reg]];
 229                 if (ret)
 230                         warn("get_1284_register: usb error %d", ret);
 231                 kref_put(&rq->ref_count, destroy_async);
 232                 return ret;
 233         }
 234         warn("get_1284_register timeout");
 235         kill_all_async_requests_priv(priv);
 236         return -EIO;
 237 }
 238
 239 static int set_1284_register(struct parport *pp, unsigned char reg, unsigned char val, gfp_t mem_flags)
 240 {
 241         struct parport_uss720_private *priv;
 242         struct uss720_async_request *rq;
 243
 244         if (!pp)
 245                 return -EIO;
 246         priv = pp->private_data;
 247         rq = submit_async_request(priv, 4, 0x40, (((unsigned int)reg) << 8) | val, 0, mem_flags);
 248         if (!rq) {
 249                 err("set_1284_register(%u,%u) failed", (unsigned int)reg, (unsigned int)val);
 250                 return -EIO;
 251         }
 252         kref_put(&rq->ref_count, destroy_async);
 253         return 0;
 254 }
 255
 256 /* --------------------------------------------------------------------- */
 257
 258 /* ECR modes */
 259 #define ECR_SPP 00
 260 #define ECR_PS2 01
 261 #define ECR_PPF 02
 262 #define ECR_ECP 03
 263 #define ECR_EPP 04
 264
 265 /* Safely change the mode bits in the ECR */
 266 static int change_mode(struct parport *pp, int m)
 267 {
 268         struct parport_uss720_private *priv = pp->private_data;
 269         int mode;
 270         __u8 reg;
 271
 272         if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
 273                 return -EIO;
 274         /* Bits <7:5> contain the mode. */
 275         mode = (priv->reg[2] >> 5) & 0x7;
 276         if (mode == m)
 277                 return 0;
 278         /* We have to go through mode 000 or 001 */
 279         if (mode > ECR_PS2 && m > ECR_PS2)
 280                 if (change_mode(pp, ECR_PS2))
 281                         return -EIO;
 282
 283         if (m <= ECR_PS2 && !(priv->reg[1] & 0x20)) {
 284                 /* This mode resets the FIFO, so we may
 285                  * have to wait for it to drain first. */
 286                 unsigned long expire = jiffies + pp->physport->cad->timeout;
 287                 switch (mode) {
 288                 case ECR_PPF: /* Parallel Port FIFO mode */
 289                 case ECR_ECP: /* ECP Parallel Port mode */
 290                         /* Poll slowly. */
 291                         for (;;) {
 292                                 if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
 293                                         return -EIO;
 294                                 if (priv->reg[2] & 0x01)
 295                                         break;
 296                                 if (time_after_eq (jiffies, expire))
 297                                         /* The FIFO is stuck. */
 298                                         return -EBUSY;
 299                                 msleep_interruptible(10);
 300                                 if (signal_pending (current))
 301                                         break;
 302                         }
 303                 }
 304         }
 305         /* Set the mode. */
 306         if (set_1284_register(pp, 6, m << 5, GFP_KERNEL))
 307                 return -EIO;
 308         if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
 309                 return -EIO;
 310         return 0;
 311 }
 312
 313 /*
 314  * Clear TIMEOUT BIT in EPP MODE
 315  */
 316 static int clear_epp_timeout(struct parport *pp)
 317 {
 318         unsigned char stat;
 319
 320         if (get_1284_register(pp, 1, &stat, GFP_KERNEL))
 321                 return 1;
 322         return stat & 1;
 323 }
 324
 325 /*
 326  * Access functions.
 327  */
 328 #if 0
 329 static int uss720_irq(int usbstatus, void *buffer, int len, void *dev_id)
 330 {
 331         struct parport *pp = (struct parport *)dev_id;
 332         struct parport_uss720_private *priv = pp->private_data;
 333
 334         if (usbstatus != 0 || len < 4 || !buffer)
 335                 return 1;
 336         memcpy(priv->reg, buffer, 4);
 337         /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
 338         if (priv->reg[2] & priv->reg[1] & 0x10)
 339                 parport_generic_irq(0, pp, NULL);
 340         return 1;
 341 }
 342 #endif
 343
 344 static void parport_uss720_write_data(struct parport *pp, unsigned char d)
 345 {
 346         set_1284_register(pp, 0, d, GFP_KERNEL);
 347 }
 348
 349 static unsigned char parport_uss720_read_data(struct parport *pp)
 350 {
 351         unsigned char ret;
 352
 353         if (get_1284_register(pp, 0, &ret, GFP_KERNEL))
 354                 return 0;
 355         return ret;
 356 }
 357
 358 static void parport_uss720_write_control(struct parport *pp, unsigned char d)
 359 {
 360         struct parport_uss720_private *priv = pp->private_data;
 361
 362         d = (d & 0xf) | (priv->reg[1] & 0xf0);
 363         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 364                 return;
 365         priv->reg[1] = d;
 366 }
 367
 368 static unsigned char parport_uss720_read_control(struct parport *pp)
 369 {
 370         struct parport_uss720_private *priv = pp->private_data;
 371         return priv->reg[1] & 0xf; /* Use soft copy */
 372 }
 373
 374 static unsigned char parport_uss720_frob_control(struct parport *pp, unsigned char mask, unsigned char val)
 375 {
 376         struct parport_uss720_private *priv = pp->private_data;
 377         unsigned char d;
 378
 379         mask &= 0x0f;
 380         val &= 0x0f;
 381         d = (priv->reg[1] & (~mask)) ^ val;
 382         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 383                 return 0;
 384         priv->reg[1] = d;
 385         return d & 0xf;
 386 }
 387
 388 static unsigned char parport_uss720_read_status(struct parport *pp)
 389 {
 390         unsigned char ret;
 391
 392         if (get_1284_register(pp, 1, &ret, GFP_KERNEL))
 393                 return 0;
 394         return ret & 0xf8;
 395 }
 396
 397 static void parport_uss720_disable_irq(struct parport *pp)
 398 {
 399         struct parport_uss720_private *priv = pp->private_data;
 400         unsigned char d;
 401
 402         d = priv->reg[1] & ~0x10;
 403         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 404                 return;
 405         priv->reg[1] = d;
 406 }
 407
 408 static void parport_uss720_enable_irq(struct parport *pp)
 409 {
 410         struct parport_uss720_private *priv = pp->private_data;
 411         unsigned char d;
 412
 413         d = priv->reg[1] | 0x10;
 414         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 415                 return;
 416         priv->reg[1] = d;
 417 }
 418
 419 static void parport_uss720_data_forward (struct parport *pp)
 420 {
 421         struct parport_uss720_private *priv = pp->private_data;
 422         unsigned char d;
 423
 424         d = priv->reg[1] & ~0x20;
 425         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 426                 return;
 427         priv->reg[1] = d;
 428 }
 429
 430 static void parport_uss720_data_reverse (struct parport *pp)
 431 {
 432         struct parport_uss720_private *priv = pp->private_data;
 433         unsigned char d;
 434
 435         d = priv->reg[1] | 0x20;
 436         if (set_1284_register(pp, 2, d, GFP_KERNEL))
 437                 return;
 438         priv->reg[1] = d;
 439 }
 440
 441 static void parport_uss720_init_state(struct pardevice *dev, struct parport_state *s)
 442 {
 443         s->u.pc.ctr = 0xc | (dev->irq_func ? 0x10 : 0x0);
 444         s->u.pc.ecr = 0x24;
 445 }
 446
 447 static void parport_uss720_save_state(struct parport *pp, struct parport_state *s)
 448 {
 449         struct parport_uss720_private *priv = pp->private_data;
 450
 451 #if 0
 452         if (get_1284_register(pp, 2, NULL, GFP_ATOMIC))
 453                 return;
 454 #endif
 455         s->u.pc.ctr = priv->reg[1];
 456         s->u.pc.ecr = priv->reg[2];
 457 }
 458
 459 static void parport_uss720_restore_state(struct parport *pp, struct parport_state *s)
 460 {
 461         struct parport_uss720_private *priv = pp->private_data;
 462
 463         set_1284_register(pp, 2, s->u.pc.ctr, GFP_ATOMIC);
 464         set_1284_register(pp, 6, s->u.pc.ecr, GFP_ATOMIC);
 465         get_1284_register(pp, 2, NULL, GFP_ATOMIC);
 466         priv->reg[1] = s->u.pc.ctr;
 467         priv->reg[2] = s->u.pc.ecr;
 468 }
 469
 470 static size_t parport_uss720_epp_read_data(struct parport *pp, void *buf, size_t length, int flags)
 471 {
 472         struct parport_uss720_private *priv = pp->private_data;
 473         size_t got = 0;
 474
 475         if (change_mode(pp, ECR_EPP))
 476                 return 0;
 477         for (; got < length; got++) {
 478                 if (get_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
 479                         break;
 480                 buf++;
 481                 if (priv->reg[0] & 0x01) {
 482                         clear_epp_timeout(pp);
 483                         break;
 484                 }
 485         }
 486         change_mode(pp, ECR_PS2);
 487         return got;
 488 }
 489
 490 static size_t parport_uss720_epp_write_data(struct parport *pp, const void *buf, size_t length, int flags)
 491 {
 492 #if 0
 493         struct parport_uss720_private *priv = pp->private_data;
 494         size_t written = 0;
 495
 496         if (change_mode(pp, ECR_EPP))
 497                 return 0;
 498         for (; written < length; written++) {
 499                 if (set_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
 500                         break;
 501                 ((char*)buf)++;
 502                 if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
 503                         break;
 504                 if (priv->reg[0] & 0x01) {
 505                         clear_epp_timeout(pp);
 506                         break;
 507                 }
 508         }
 509         change_mode(pp, ECR_PS2);
 510         return written;
 511 #else
 512         struct parport_uss720_private *priv = pp->private_data;
 513         struct usb_device *usbdev = priv->usbdev;
 514         int rlen;
 515         int i;
 516
 517         if (!usbdev)
 518                 return 0;
 519         if (change_mode(pp, ECR_EPP))
 520                 return 0;
 521         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buf, length, &rlen, 20000);
 522         if (i)
 523                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buf, length, rlen);
 524         change_mode(pp, ECR_PS2);
 525         return rlen;
 526 #endif
 527 }
 528
 529 static size_t parport_uss720_epp_read_addr(struct parport *pp, void *buf, size_t length, int flags)
 530 {
 531         struct parport_uss720_private *priv = pp->private_data;
 532         size_t got = 0;
 533
 534         if (change_mode(pp, ECR_EPP))
 535                 return 0;
 536         for (; got < length; got++) {
 537                 if (get_1284_register(pp, 3, (char *)buf, GFP_KERNEL))
 538                         break;
 539                 buf++;
 540                 if (priv->reg[0] & 0x01) {
 541                         clear_epp_timeout(pp);
 542                         break;
 543                 }
 544         }
 545         change_mode(pp, ECR_PS2);
 546         return got;
 547 }
 548
 549 static size_t parport_uss720_epp_write_addr(struct parport *pp, const void *buf, size_t length, int flags)
 550 {
 551         struct parport_uss720_private *priv = pp->private_data;
 552         size_t written = 0;
 553
 554         if (change_mode(pp, ECR_EPP))
 555                 return 0;
 556         for (; written < length; written++) {
 557                 if (set_1284_register(pp, 3, *(char *)buf, GFP_KERNEL))
 558                         break;
 559                 buf++;
 560                 if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
 561                         break;
 562                 if (priv->reg[0] & 0x01) {
 563                         clear_epp_timeout(pp);
 564                         break;
 565                 }
 566         }
 567         change_mode(pp, ECR_PS2);
 568         return written;
 569 }
 570
 571 static size_t parport_uss720_ecp_write_data(struct parport *pp, const void *buffer, size_t len, int flags)
 572 {
 573         struct parport_uss720_private *priv = pp->private_data;
 574         struct usb_device *usbdev = priv->usbdev;
 575         int rlen;
 576         int i;
 577
 578         if (!usbdev)
 579                 return 0;
 580         if (change_mode(pp, ECR_ECP))
 581                 return 0;
 582         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000);
 583         if (i)
 584                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen);
 585         change_mode(pp, ECR_PS2);
 586         return rlen;
 587 }
 588
 589 static size_t parport_uss720_ecp_read_data(struct parport *pp, void *buffer, size_t len, int flags)
 590 {
 591         struct parport_uss720_private *priv = pp->private_data;
 592         struct usb_device *usbdev = priv->usbdev;
 593         int rlen;
 594         int i;
 595
 596         if (!usbdev)
 597                 return 0;
 598         if (change_mode(pp, ECR_ECP))
 599                 return 0;
 600         i = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), buffer, len, &rlen, 20000);
 601         if (i)
 602                 printk(KERN_ERR "uss720: recvbulk ep 2 buf %p len %Zu rlen %u\n", buffer, len, rlen);
 603         change_mode(pp, ECR_PS2);
 604         return rlen;
 605 }
 606
 607 static size_t parport_uss720_ecp_write_addr(struct parport *pp, const void *buffer, size_t len, int flags)
 608 {
 609         size_t written = 0;
 610
 611         if (change_mode(pp, ECR_ECP))
 612                 return 0;
 613         for (; written < len; written++) {
 614                 if (set_1284_register(pp, 5, *(char *)buffer, GFP_KERNEL))
 615                         break;
 616                 buffer++;
 617         }
 618         change_mode(pp, ECR_PS2);
 619         return written;
 620 }
 621
 622 static size_t parport_uss720_write_compat(struct parport *pp, const void *buffer, size_t len, int flags)
 623 {
 624         struct parport_uss720_private *priv = pp->private_data;
 625         struct usb_device *usbdev = priv->usbdev;
 626         int rlen;
 627         int i;
 628
 629         if (!usbdev)
 630                 return 0;
 631         if (change_mode(pp, ECR_PPF))
 632                 return 0;
 633         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000);
 634         if (i)
 635                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen);
 636         change_mode(pp, ECR_PS2);
 637         return rlen;
 638 }
 639
 640 /* --------------------------------------------------------------------- */
 641
 642 static struct parport_operations parport_uss720_ops =
 643 {
 644         .owner =                THIS_MODULE,
 645         .write_data =           parport_uss720_write_data,
 646         .read_data =            parport_uss720_read_data,
 647
 648         .write_control =        parport_uss720_write_control,
 649         .read_control =         parport_uss720_read_control,
 650         .frob_control =         parport_uss720_frob_control,
 651
 652         .read_status =          parport_uss720_read_status,
 653
 654         .enable_irq =           parport_uss720_enable_irq,
 655         .disable_irq =          parport_uss720_disable_irq,
 656
 657         .data_forward =         parport_uss720_data_forward,
 658         .data_reverse =         parport_uss720_data_reverse,
 659
 660         .init_state =           parport_uss720_init_state,
 661         .save_state =           parport_uss720_save_state,
 662         .restore_state =        parport_uss720_restore_state,
 663
 664         .epp_write_data =       parport_uss720_epp_write_data,
 665         .epp_read_data =        parport_uss720_epp_read_data,
 666         .epp_write_addr =       parport_uss720_epp_write_addr,
 667         .epp_read_addr =        parport_uss720_epp_read_addr,
 668
 669         .ecp_write_data =       parport_uss720_ecp_write_data,
 670         .ecp_read_data =        parport_uss720_ecp_read_data,
 671         .ecp_write_addr =       parport_uss720_ecp_write_addr,
 672
 673         .compat_write_data =    parport_uss720_write_compat,
 674         .nibble_read_data =     parport_ieee1284_read_nibble,
 675         .byte_read_data =       parport_ieee1284_read_byte,
 676 };
 677
 678 /* --------------------------------------------------------------------- */
 679
 680 static int uss720_probe(struct usb_interface *intf,
 681                         const struct usb_device_id *id)
 682 {
 683         struct usb_device *usbdev = usb_get_dev(interface_to_usbdev(intf));
 684         struct usb_host_interface *interface;
 685         struct usb_host_endpoint *endpoint;
 686         struct parport_uss720_private *priv;
 687         struct parport *pp;
 688         unsigned char reg;
 689         int i;
 690
 691         dbg("probe: vendor id 0x%x, device id 0x%x\n",
 692             le16_to_cpu(usbdev->descriptor.idVendor),
 693             le16_to_cpu(usbdev->descriptor.idProduct));
 694
 695         /* our known interfaces have 3 alternate settings */
 696         if (intf->num_altsetting != 3) {
 697                 usb_put_dev(usbdev);
 698                 return -ENODEV;
 699         }
 700         i = usb_set_interface(usbdev, intf->altsetting->desc.bInterfaceNumber, 2);
 701         dbg("set inteface result %d", i);
 702
 703         interface = intf->cur_altsetting;
 704
 705         /*
 706          * Allocate parport interface
 707          */
 708         if (!(priv = kzalloc(sizeof(struct parport_uss720_private), GFP_KERNEL))) {
 709                 usb_put_dev(usbdev);
 710                 return -ENOMEM;
 711         }
 712         priv->pp = NULL;
 713         priv->usbdev = usbdev;
 714         kref_init(&priv->ref_count);
 715         spin_lock_init(&priv->asynclock);
 716         INIT_LIST_HEAD(&priv->asynclist);
 717         if (!(pp = parport_register_port(0, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &parport_uss720_ops))) {
 718                 warn("could not register parport");
 719                 goto probe_abort;
 720         }
 721
 722         priv->pp = pp;
 723         pp->private_data = priv;
 724         pp->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_TRISTATE | PARPORT_MODE_EPP | PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
 725
 726         /* set the USS720 control register to manual mode, no ECP compression, enable all ints */
 727         set_1284_register(pp, 7, 0x00, GFP_KERNEL);
 728         set_1284_register(pp, 6, 0x30, GFP_KERNEL);  /* PS/2 mode */
 729         set_1284_register(pp, 2, 0x0c, GFP_KERNEL);
 730         /* debugging */
 731         get_1284_register(pp, 0, &reg, GFP_KERNEL);
 732         dbg("reg: %02x %02x %02x %02x %02x %02x %02x",
 733             priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
 734
 735         endpoint = &interface->endpoint[2];
 736         dbg("epaddr %d interval %d", endpoint->desc.bEndpointAddress, endpoint->desc.bInterval);
 737         parport_announce_port(pp);
 738
 739         usb_set_intfdata(intf, pp);
 740         return 0;
 741
 742 probe_abort:
 743         kill_all_async_requests_priv(priv);
 744         kref_put(&priv->ref_count, destroy_priv);
 745         return -ENODEV;
 746 }
 747
 748 static void uss720_disconnect(struct usb_interface *intf)
 749 {
 750         struct parport *pp = usb_get_intfdata(intf);
 751         struct parport_uss720_private *priv;
 752         struct usb_device *usbdev;
 753
 754         dbg("disconnect");
 755         usb_set_intfdata(intf, NULL);
 756         if (pp) {
 757                 priv = pp->private_data;
 758                 usbdev = priv->usbdev;
 759                 priv->usbdev = NULL;
 760                 priv->pp = NULL;
 761                 dbg("parport_remove_port");
 762                 parport_remove_port(pp);
 763                 parport_put_port(pp);
 764                 kill_all_async_requests_priv(priv);
 765                 kref_put(&priv->ref_count, destroy_priv);
 766         }
 767         dbg("disconnect done");
 768 }
 769
 770 /* table of cables that work through this driver */
 771 static struct usb_device_id uss720_table [] = {
 772         { USB_DEVICE(0x047e, 0x1001) },
 773         { USB_DEVICE(0x0557, 0x2001) },
 774         { USB_DEVICE(0x0729, 0x1284) },
 775         { USB_DEVICE(0x1293, 0x0002) },
 776         { }                                             /* Terminating entry */
 777 };
 778
 779 MODULE_DEVICE_TABLE (usb, uss720_table);
 780
 781
 782 static struct usb_driver uss720_driver = {
 783         .name =         "uss720",
 784         .probe =        uss720_probe,
 785         .disconnect =   uss720_disconnect,
 786         .id_table =     uss720_table,
 787 };
 788
 789 /* --------------------------------------------------------------------- */
 790
 791 MODULE_AUTHOR(DRIVER_AUTHOR);
 792 MODULE_DESCRIPTION(DRIVER_DESC);
 793 MODULE_LICENSE("GPL");
 794
 795 static int __init uss720_init(void)
 796 {
 797         int retval;
 798         retval = usb_register(&uss720_driver);
 799         if (retval)
 800                 goto out;
 801
 802         info(DRIVER_VERSION ":" DRIVER_DESC);
 803         info("NOTE: this is a special purpose driver to allow nonstandard");
 804         info("protocols (eg. bitbang) over USS720 usb to parallel cables");
 805         info("If you just want to connect to a printer, use usblp instead");
 806 out:
 807         return retval;
 808 }
 809
 810 static void __exit uss720_cleanup(void)
 811 {
 812         usb_deregister(&uss720_driver);
 813 }
 814
 815 module_init(uss720_init);
 816 module_exit(uss720_cleanup);
 817
 818 /* --------------------------------------------------------------------- */