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