linux/drivers/usb/misc/ftdi-elan.c
<<
>>
Prefs
   1/*
   2* USB FTDI client driver for Elan Digital Systems's Uxxx adapters
   3*
   4* Copyright(C) 2006 Elan Digital Systems Limited
   5* http://www.elandigitalsystems.com
   6*
   7* Author and Maintainer - Tony Olech - Elan Digital Systems
   8* tony.olech@elandigitalsystems.com
   9*
  10* This program is free software;you can redistribute it and/or
  11* modify it under the terms of the GNU General Public License as
  12* published by the Free Software Foundation, version 2.
  13*
  14*
  15* This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
  16* based on various USB client drivers in the 2.6.15 linux kernel
  17* with constant reference to the 3rd Edition of Linux Device Drivers
  18* published by O'Reilly
  19*
  20* The U132 adapter is a USB to CardBus adapter specifically designed
  21* for PC cards that contain an OHCI host controller. Typical PC cards
  22* are the Orange Mobile 3G Option GlobeTrotter Fusion card.
  23*
  24* The U132 adapter will *NOT *work with PC cards that do not contain
  25* an OHCI controller. A simple way to test whether a PC card has an
  26* OHCI controller as an interface is to insert the PC card directly
  27* into a laptop(or desktop) with a CardBus slot and if "lspci" shows
  28* a new USB controller and "lsusb -v" shows a new OHCI Host Controller
  29* then there is a good chance that the U132 adapter will support the
  30* PC card.(you also need the specific client driver for the PC card)
  31*
  32* Please inform the Author and Maintainer about any PC cards that
  33* contain OHCI Host Controller and work when directly connected to
  34* an embedded CardBus slot but do not work when they are connected
  35* via an ELAN U132 adapter.
  36*
  37*/
  38#include <linux/kernel.h>
  39#include <linux/errno.h>
  40#include <linux/init.h>
  41#include <linux/list.h>
  42#include <linux/ioctl.h>
  43#include <linux/pci_ids.h>
  44#include <linux/slab.h>
  45#include <linux/module.h>
  46#include <linux/kref.h>
  47#include <linux/mutex.h>
  48#include <asm/uaccess.h>
  49#include <linux/usb.h>
  50#include <linux/workqueue.h>
  51#include <linux/platform_device.h>
  52MODULE_AUTHOR("Tony Olech");
  53MODULE_DESCRIPTION("FTDI ELAN driver");
  54MODULE_LICENSE("GPL");
  55#define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
  56static int distrust_firmware = 1;
  57module_param(distrust_firmware, bool, 0);
  58MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
  59        "t setup");
  60extern struct platform_driver u132_platform_driver;
  61static struct workqueue_struct *status_queue;
  62static struct workqueue_struct *command_queue;
  63static struct workqueue_struct *respond_queue;
  64/*
  65* ftdi_module_lock exists to protect access to global variables
  66*
  67*/
  68static struct mutex ftdi_module_lock;
  69static int ftdi_instances = 0;
  70static struct list_head ftdi_static_list;
  71/*
  72* end of the global variables protected by ftdi_module_lock
  73*/
  74#include "usb_u132.h"
  75#include <asm/io.h>
  76#include <linux/usb/hcd.h>
  77
  78        /* FIXME ohci.h is ONLY for internal use by the OHCI driver.
  79         * If you're going to try stuff like this, you need to split
  80         * out shareable stuff (register declarations?) into its own
  81         * file, maybe name <linux/usb/ohci.h>
  82         */
  83
  84#include "../host/ohci.h"
  85/* Define these values to match your devices*/
  86#define USB_FTDI_ELAN_VENDOR_ID 0x0403
  87#define USB_FTDI_ELAN_PRODUCT_ID 0xd6ea
  88/* table of devices that work with this driver*/
  89static const struct usb_device_id ftdi_elan_table[] = {
  90        {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)},
  91        { /* Terminating entry */ }
  92};
  93
  94MODULE_DEVICE_TABLE(usb, ftdi_elan_table);
  95/* only the jtag(firmware upgrade device) interface requires
  96* a device file and corresponding minor number, but the
  97* interface is created unconditionally - I suppose it could
  98* be configured or not according to a module parameter.
  99* But since we(now) require one interface per device,
 100* and since it unlikely that a normal installation would
 101* require more than a couple of elan-ftdi devices, 8 seems
 102* like a reasonable limit to have here, and if someone
 103* really requires more than 8 devices, then they can frig the
 104* code and recompile
 105*/
 106#define USB_FTDI_ELAN_MINOR_BASE 192
 107#define COMMAND_BITS 5
 108#define COMMAND_SIZE (1<<COMMAND_BITS)
 109#define COMMAND_MASK (COMMAND_SIZE-1)
 110struct u132_command {
 111        u8 header;
 112        u16 length;
 113        u8 address;
 114        u8 width;
 115        u32 value;
 116        int follows;
 117        void *buffer;
 118};
 119#define RESPOND_BITS 5
 120#define RESPOND_SIZE (1<<RESPOND_BITS)
 121#define RESPOND_MASK (RESPOND_SIZE-1)
 122struct u132_respond {
 123        u8 header;
 124        u8 address;
 125        u32 *value;
 126        int *result;
 127        struct completion wait_completion;
 128};
 129struct u132_target {
 130        void *endp;
 131        struct urb *urb;
 132        int toggle_bits;
 133        int error_count;
 134        int condition_code;
 135        int repeat_number;
 136        int halted;
 137        int skipped;
 138        int actual;
 139        int non_null;
 140        int active;
 141        int abandoning;
 142        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
 143                int toggle_bits, int error_count, int condition_code,
 144                int repeat_number, int halted, int skipped, int actual,
 145                int non_null);
 146};
 147/* Structure to hold all of our device specific stuff*/
 148struct usb_ftdi {
 149        struct list_head ftdi_list;
 150        struct mutex u132_lock;
 151        int command_next;
 152        int command_head;
 153        struct u132_command command[COMMAND_SIZE];
 154        int respond_next;
 155        int respond_head;
 156        struct u132_respond respond[RESPOND_SIZE];
 157        struct u132_target target[4];
 158        char device_name[16];
 159        unsigned synchronized:1;
 160        unsigned enumerated:1;
 161        unsigned registered:1;
 162        unsigned initialized:1;
 163        unsigned card_ejected:1;
 164        int function;
 165        int sequence_num;
 166        int disconnected;
 167        int gone_away;
 168        int stuck_status;
 169        int status_queue_delay;
 170        struct semaphore sw_lock;
 171        struct usb_device *udev;
 172        struct usb_interface *interface;
 173        struct usb_class_driver *class;
 174        struct delayed_work status_work;
 175        struct delayed_work command_work;
 176        struct delayed_work respond_work;
 177        struct u132_platform_data platform_data;
 178        struct resource resources[0];
 179        struct platform_device platform_dev;
 180        unsigned char *bulk_in_buffer;
 181        size_t bulk_in_size;
 182        size_t bulk_in_last;
 183        size_t bulk_in_left;
 184        __u8 bulk_in_endpointAddr;
 185        __u8 bulk_out_endpointAddr;
 186        struct kref kref;
 187        u32 controlreg;
 188        u8 response[4 + 1024];
 189        int expected;
 190        int recieved;
 191        int ed_found;
 192};
 193#define kref_to_usb_ftdi(d) container_of(d, struct usb_ftdi, kref)
 194#define platform_device_to_usb_ftdi(d) container_of(d, struct usb_ftdi, \
 195        platform_dev)
 196static struct usb_driver ftdi_elan_driver;
 197static void ftdi_elan_delete(struct kref *kref)
 198{
 199        struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref);
 200        dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
 201        usb_put_dev(ftdi->udev);
 202        ftdi->disconnected += 1;
 203        mutex_lock(&ftdi_module_lock);
 204        list_del_init(&ftdi->ftdi_list);
 205        ftdi_instances -= 1;
 206        mutex_unlock(&ftdi_module_lock);
 207        kfree(ftdi->bulk_in_buffer);
 208        ftdi->bulk_in_buffer = NULL;
 209}
 210
 211static void ftdi_elan_put_kref(struct usb_ftdi *ftdi)
 212{
 213        kref_put(&ftdi->kref, ftdi_elan_delete);
 214}
 215
 216static void ftdi_elan_get_kref(struct usb_ftdi *ftdi)
 217{
 218        kref_get(&ftdi->kref);
 219}
 220
 221static void ftdi_elan_init_kref(struct usb_ftdi *ftdi)
 222{
 223        kref_init(&ftdi->kref);
 224}
 225
 226static void ftdi_status_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
 227{
 228        if (!queue_delayed_work(status_queue, &ftdi->status_work, delta))
 229                kref_put(&ftdi->kref, ftdi_elan_delete);
 230}
 231
 232static void ftdi_status_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 233{
 234        if (queue_delayed_work(status_queue, &ftdi->status_work, delta))
 235                kref_get(&ftdi->kref);
 236}
 237
 238static void ftdi_status_cancel_work(struct usb_ftdi *ftdi)
 239{
 240        if (cancel_delayed_work(&ftdi->status_work))
 241                kref_put(&ftdi->kref, ftdi_elan_delete);
 242}
 243
 244static void ftdi_command_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
 245{
 246        if (!queue_delayed_work(command_queue, &ftdi->command_work, delta))
 247                kref_put(&ftdi->kref, ftdi_elan_delete);
 248}
 249
 250static void ftdi_command_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 251{
 252        if (queue_delayed_work(command_queue, &ftdi->command_work, delta))
 253                kref_get(&ftdi->kref);
 254}
 255
 256static void ftdi_command_cancel_work(struct usb_ftdi *ftdi)
 257{
 258        if (cancel_delayed_work(&ftdi->command_work))
 259                kref_put(&ftdi->kref, ftdi_elan_delete);
 260}
 261
 262static void ftdi_response_requeue_work(struct usb_ftdi *ftdi,
 263        unsigned int delta)
 264{
 265        if (!queue_delayed_work(respond_queue, &ftdi->respond_work, delta))
 266                kref_put(&ftdi->kref, ftdi_elan_delete);
 267}
 268
 269static void ftdi_respond_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 270{
 271        if (queue_delayed_work(respond_queue, &ftdi->respond_work, delta))
 272                kref_get(&ftdi->kref);
 273}
 274
 275static void ftdi_response_cancel_work(struct usb_ftdi *ftdi)
 276{
 277        if (cancel_delayed_work(&ftdi->respond_work))
 278                kref_put(&ftdi->kref, ftdi_elan_delete);
 279}
 280
 281void ftdi_elan_gone_away(struct platform_device *pdev)
 282{
 283        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
 284        ftdi->gone_away += 1;
 285        ftdi_elan_put_kref(ftdi);
 286}
 287
 288
 289EXPORT_SYMBOL_GPL(ftdi_elan_gone_away);
 290static void ftdi_release_platform_dev(struct device *dev)
 291{
 292        dev->parent = NULL;
 293}
 294
 295static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
 296        struct u132_target *target, u8 *buffer, int length);
 297static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi);
 298static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi);
 299static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi);
 300static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi);
 301static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi);
 302static int ftdi_elan_synchronize(struct usb_ftdi *ftdi);
 303static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi);
 304static int ftdi_elan_command_engine(struct usb_ftdi *ftdi);
 305static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi);
 306static int ftdi_elan_hcd_init(struct usb_ftdi *ftdi)
 307{
 308        int result;
 309        if (ftdi->platform_dev.dev.parent)
 310                return -EBUSY;
 311        ftdi_elan_get_kref(ftdi);
 312        ftdi->platform_data.potpg = 100;
 313        ftdi->platform_data.reset = NULL;
 314        ftdi->platform_dev.id = ftdi->sequence_num;
 315        ftdi->platform_dev.resource = ftdi->resources;
 316        ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources);
 317        ftdi->platform_dev.dev.platform_data = &ftdi->platform_data;
 318        ftdi->platform_dev.dev.parent = NULL;
 319        ftdi->platform_dev.dev.release = ftdi_release_platform_dev;
 320        ftdi->platform_dev.dev.dma_mask = NULL;
 321        snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd");
 322        ftdi->platform_dev.name = ftdi->device_name;
 323        dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd");
 324        request_module("u132_hcd");
 325        dev_info(&ftdi->udev->dev, "registering '%s'\n",
 326                ftdi->platform_dev.name);
 327        result = platform_device_register(&ftdi->platform_dev);
 328        return result;
 329}
 330
 331static void ftdi_elan_abandon_completions(struct usb_ftdi *ftdi)
 332{
 333        mutex_lock(&ftdi->u132_lock);
 334        while (ftdi->respond_next > ftdi->respond_head) {
 335                struct u132_respond *respond = &ftdi->respond[RESPOND_MASK &
 336                        ftdi->respond_head++];
 337                *respond->result = -ESHUTDOWN;
 338                *respond->value = 0;
 339                complete(&respond->wait_completion);
 340        } mutex_unlock(&ftdi->u132_lock);
 341}
 342
 343static void ftdi_elan_abandon_targets(struct usb_ftdi *ftdi)
 344{
 345        int ed_number = 4;
 346        mutex_lock(&ftdi->u132_lock);
 347        while (ed_number-- > 0) {
 348                struct u132_target *target = &ftdi->target[ed_number];
 349                if (target->active == 1) {
 350                        target->condition_code = TD_DEVNOTRESP;
 351                        mutex_unlock(&ftdi->u132_lock);
 352                        ftdi_elan_do_callback(ftdi, target, NULL, 0);
 353                        mutex_lock(&ftdi->u132_lock);
 354                }
 355        }
 356        ftdi->recieved = 0;
 357        ftdi->expected = 4;
 358        ftdi->ed_found = 0;
 359        mutex_unlock(&ftdi->u132_lock);
 360}
 361
 362static void ftdi_elan_flush_targets(struct usb_ftdi *ftdi)
 363{
 364        int ed_number = 4;
 365        mutex_lock(&ftdi->u132_lock);
 366        while (ed_number-- > 0) {
 367                struct u132_target *target = &ftdi->target[ed_number];
 368                target->abandoning = 1;
 369              wait_1:if (target->active == 1) {
 370                        int command_size = ftdi->command_next -
 371                                ftdi->command_head;
 372                        if (command_size < COMMAND_SIZE) {
 373                                struct u132_command *command = &ftdi->command[
 374                                        COMMAND_MASK & ftdi->command_next];
 375                                command->header = 0x80 | (ed_number << 5) | 0x4;
 376                                command->length = 0x00;
 377                                command->address = 0x00;
 378                                command->width = 0x00;
 379                                command->follows = 0;
 380                                command->value = 0;
 381                                command->buffer = &command->value;
 382                                ftdi->command_next += 1;
 383                                ftdi_elan_kick_command_queue(ftdi);
 384                        } else {
 385                                mutex_unlock(&ftdi->u132_lock);
 386                                msleep(100);
 387                                mutex_lock(&ftdi->u132_lock);
 388                                goto wait_1;
 389                        }
 390                }
 391              wait_2:if (target->active == 1) {
 392                        int command_size = ftdi->command_next -
 393                                ftdi->command_head;
 394                        if (command_size < COMMAND_SIZE) {
 395                                struct u132_command *command = &ftdi->command[
 396                                        COMMAND_MASK & ftdi->command_next];
 397                                command->header = 0x90 | (ed_number << 5);
 398                                command->length = 0x00;
 399                                command->address = 0x00;
 400                                command->width = 0x00;
 401                                command->follows = 0;
 402                                command->value = 0;
 403                                command->buffer = &command->value;
 404                                ftdi->command_next += 1;
 405                                ftdi_elan_kick_command_queue(ftdi);
 406                        } else {
 407                                mutex_unlock(&ftdi->u132_lock);
 408                                msleep(100);
 409                                mutex_lock(&ftdi->u132_lock);
 410                                goto wait_2;
 411                        }
 412                }
 413        }
 414        ftdi->recieved = 0;
 415        ftdi->expected = 4;
 416        ftdi->ed_found = 0;
 417        mutex_unlock(&ftdi->u132_lock);
 418}
 419
 420static void ftdi_elan_cancel_targets(struct usb_ftdi *ftdi)
 421{
 422        int ed_number = 4;
 423        mutex_lock(&ftdi->u132_lock);
 424        while (ed_number-- > 0) {
 425                struct u132_target *target = &ftdi->target[ed_number];
 426                target->abandoning = 1;
 427              wait:if (target->active == 1) {
 428                        int command_size = ftdi->command_next -
 429                                ftdi->command_head;
 430                        if (command_size < COMMAND_SIZE) {
 431                                struct u132_command *command = &ftdi->command[
 432                                        COMMAND_MASK & ftdi->command_next];
 433                                command->header = 0x80 | (ed_number << 5) | 0x4;
 434                                command->length = 0x00;
 435                                command->address = 0x00;
 436                                command->width = 0x00;
 437                                command->follows = 0;
 438                                command->value = 0;
 439                                command->buffer = &command->value;
 440                                ftdi->command_next += 1;
 441                                ftdi_elan_kick_command_queue(ftdi);
 442                        } else {
 443                                mutex_unlock(&ftdi->u132_lock);
 444                                msleep(100);
 445                                mutex_lock(&ftdi->u132_lock);
 446                                goto wait;
 447                        }
 448                }
 449        }
 450        ftdi->recieved = 0;
 451        ftdi->expected = 4;
 452        ftdi->ed_found = 0;
 453        mutex_unlock(&ftdi->u132_lock);
 454}
 455
 456static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
 457{
 458        ftdi_command_queue_work(ftdi, 0);
 459}
 460
 461static void ftdi_elan_command_work(struct work_struct *work)
 462{
 463        struct usb_ftdi *ftdi =
 464                container_of(work, struct usb_ftdi, command_work.work);
 465
 466        if (ftdi->disconnected > 0) {
 467                ftdi_elan_put_kref(ftdi);
 468                return;
 469        } else {
 470                int retval = ftdi_elan_command_engine(ftdi);
 471                if (retval == -ESHUTDOWN) {
 472                        ftdi->disconnected += 1;
 473                } else if (retval == -ENODEV) {
 474                        ftdi->disconnected += 1;
 475                } else if (retval)
 476                        dev_err(&ftdi->udev->dev, "command error %d\n", retval);
 477                ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10));
 478                return;
 479        }
 480}
 481
 482static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
 483{
 484        ftdi_respond_queue_work(ftdi, 0);
 485}
 486
 487static void ftdi_elan_respond_work(struct work_struct *work)
 488{
 489        struct usb_ftdi *ftdi =
 490                container_of(work, struct usb_ftdi, respond_work.work);
 491        if (ftdi->disconnected > 0) {
 492                ftdi_elan_put_kref(ftdi);
 493                return;
 494        } else {
 495                int retval = ftdi_elan_respond_engine(ftdi);
 496                if (retval == 0) {
 497                } else if (retval == -ESHUTDOWN) {
 498                        ftdi->disconnected += 1;
 499                } else if (retval == -ENODEV) {
 500                        ftdi->disconnected += 1;
 501                } else if (retval == -EILSEQ) {
 502                        ftdi->disconnected += 1;
 503                } else {
 504                        ftdi->disconnected += 1;
 505                        dev_err(&ftdi->udev->dev, "respond error %d\n", retval);
 506                }
 507                if (ftdi->disconnected > 0) {
 508                        ftdi_elan_abandon_completions(ftdi);
 509                        ftdi_elan_abandon_targets(ftdi);
 510                }
 511                ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10));
 512                return;
 513        }
 514}
 515
 516
 517/*
 518* the sw_lock is initially held and will be freed
 519* after the FTDI has been synchronized
 520*
 521*/
 522static void ftdi_elan_status_work(struct work_struct *work)
 523{
 524        struct usb_ftdi *ftdi =
 525                container_of(work, struct usb_ftdi, status_work.work);
 526        int work_delay_in_msec = 0;
 527        if (ftdi->disconnected > 0) {
 528                ftdi_elan_put_kref(ftdi);
 529                return;
 530        } else if (ftdi->synchronized == 0) {
 531                down(&ftdi->sw_lock);
 532                if (ftdi_elan_synchronize(ftdi) == 0) {
 533                        ftdi->synchronized = 1;
 534                        ftdi_command_queue_work(ftdi, 1);
 535                        ftdi_respond_queue_work(ftdi, 1);
 536                        up(&ftdi->sw_lock);
 537                        work_delay_in_msec = 100;
 538                } else {
 539                        dev_err(&ftdi->udev->dev, "synchronize failed\n");
 540                        up(&ftdi->sw_lock);
 541                        work_delay_in_msec = 10 *1000;
 542                }
 543        } else if (ftdi->stuck_status > 0) {
 544                if (ftdi_elan_stuck_waiting(ftdi) == 0) {
 545                        ftdi->stuck_status = 0;
 546                        ftdi->synchronized = 0;
 547                } else if ((ftdi->stuck_status++ % 60) == 1) {
 548                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted "
 549                                "- please remove\n");
 550                } else
 551                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted "
 552                                "- checked %d times\n", ftdi->stuck_status);
 553                work_delay_in_msec = 100;
 554        } else if (ftdi->enumerated == 0) {
 555                if (ftdi_elan_enumeratePCI(ftdi) == 0) {
 556                        ftdi->enumerated = 1;
 557                        work_delay_in_msec = 250;
 558                } else
 559                        work_delay_in_msec = 1000;
 560        } else if (ftdi->initialized == 0) {
 561                if (ftdi_elan_setupOHCI(ftdi) == 0) {
 562                        ftdi->initialized = 1;
 563                        work_delay_in_msec = 500;
 564                } else {
 565                        dev_err(&ftdi->udev->dev, "initialized failed - trying "
 566                                "again in 10 seconds\n");
 567                        work_delay_in_msec = 1 *1000;
 568                }
 569        } else if (ftdi->registered == 0) {
 570                work_delay_in_msec = 10;
 571                if (ftdi_elan_hcd_init(ftdi) == 0) {
 572                        ftdi->registered = 1;
 573                } else
 574                        dev_err(&ftdi->udev->dev, "register failed\n");
 575                work_delay_in_msec = 250;
 576        } else {
 577                if (ftdi_elan_checkingPCI(ftdi) == 0) {
 578                        work_delay_in_msec = 250;
 579                } else if (ftdi->controlreg & 0x00400000) {
 580                        if (ftdi->gone_away > 0) {
 581                                dev_err(&ftdi->udev->dev, "PCI device eject con"
 582                                        "firmed platform_dev.dev.parent=%p plat"
 583                                        "form_dev.dev=%p\n",
 584                                        ftdi->platform_dev.dev.parent,
 585                                        &ftdi->platform_dev.dev);
 586                                platform_device_unregister(&ftdi->platform_dev);
 587                                ftdi->platform_dev.dev.parent = NULL;
 588                                ftdi->registered = 0;
 589                                ftdi->enumerated = 0;
 590                                ftdi->card_ejected = 0;
 591                                ftdi->initialized = 0;
 592                                ftdi->gone_away = 0;
 593                        } else
 594                                ftdi_elan_flush_targets(ftdi);
 595                        work_delay_in_msec = 250;
 596                } else {
 597                        dev_err(&ftdi->udev->dev, "PCI device has disappeared\n"
 598                                );
 599                        ftdi_elan_cancel_targets(ftdi);
 600                        work_delay_in_msec = 500;
 601                        ftdi->enumerated = 0;
 602                        ftdi->initialized = 0;
 603                }
 604        }
 605        if (ftdi->disconnected > 0) {
 606                ftdi_elan_put_kref(ftdi);
 607                return;
 608        } else {
 609                ftdi_status_requeue_work(ftdi,
 610                        msecs_to_jiffies(work_delay_in_msec));
 611                return;
 612        }
 613}
 614
 615
 616/*
 617* file_operations for the jtag interface
 618*
 619* the usage count for the device is incremented on open()
 620* and decremented on release()
 621*/
 622static int ftdi_elan_open(struct inode *inode, struct file *file)
 623{
 624        int subminor;
 625        struct usb_interface *interface;
 626
 627        subminor = iminor(inode);
 628        interface = usb_find_interface(&ftdi_elan_driver, subminor);
 629
 630        if (!interface) {
 631                printk(KERN_ERR "can't find device for minor %d\n", subminor);
 632                return -ENODEV;
 633        } else {
 634                struct usb_ftdi *ftdi = usb_get_intfdata(interface);
 635                if (!ftdi) {
 636                        return -ENODEV;
 637                } else {
 638                        if (down_interruptible(&ftdi->sw_lock)) {
 639                                return -EINTR;
 640                        } else {
 641                                ftdi_elan_get_kref(ftdi);
 642                                file->private_data = ftdi;
 643                                return 0;
 644                        }
 645                }
 646        }
 647}
 648
 649static int ftdi_elan_release(struct inode *inode, struct file *file)
 650{
 651        struct usb_ftdi *ftdi = file->private_data;
 652        if (ftdi == NULL)
 653                return -ENODEV;
 654        up(&ftdi->sw_lock);        /* decrement the count on our device */
 655        ftdi_elan_put_kref(ftdi);
 656        return 0;
 657}
 658
 659
 660/*
 661*
 662* blocking bulk reads are used to get data from the device
 663*
 664*/
 665static ssize_t ftdi_elan_read(struct file *file, char __user *buffer,
 666                              size_t count, loff_t *ppos)
 667{
 668        char data[30 *3 + 4];
 669        char *d = data;
 670        int m = (sizeof(data) - 1) / 3;
 671        int bytes_read = 0;
 672        int retry_on_empty = 10;
 673        int retry_on_timeout = 5;
 674        struct usb_ftdi *ftdi = file->private_data;
 675        if (ftdi->disconnected > 0) {
 676                return -ENODEV;
 677        }
 678        data[0] = 0;
 679      have:if (ftdi->bulk_in_left > 0) {
 680                if (count-- > 0) {
 681                        char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer;
 682                        ftdi->bulk_in_left -= 1;
 683                        if (bytes_read < m) {
 684                                d += sprintf(d, " %02X", 0x000000FF & *p);
 685                        } else if (bytes_read > m) {
 686                        } else
 687                                d += sprintf(d, " ..");
 688                        if (copy_to_user(buffer++, p, 1)) {
 689                                return -EFAULT;
 690                        } else {
 691                                bytes_read += 1;
 692                                goto have;
 693                        }
 694                } else
 695                        return bytes_read;
 696        }
 697      more:if (count > 0) {
 698                int packet_bytes = 0;
 699                int retval = usb_bulk_msg(ftdi->udev,
 700                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
 701                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
 702                        &packet_bytes, 50);
 703                if (packet_bytes > 2) {
 704                        ftdi->bulk_in_left = packet_bytes - 2;
 705                        ftdi->bulk_in_last = 1;
 706                        goto have;
 707                } else if (retval == -ETIMEDOUT) {
 708                        if (retry_on_timeout-- > 0) {
 709                                goto more;
 710                        } else if (bytes_read > 0) {
 711                                return bytes_read;
 712                        } else
 713                                return retval;
 714                } else if (retval == 0) {
 715                        if (retry_on_empty-- > 0) {
 716                                goto more;
 717                        } else
 718                                return bytes_read;
 719                } else
 720                        return retval;
 721        } else
 722                return bytes_read;
 723}
 724
 725static void ftdi_elan_write_bulk_callback(struct urb *urb)
 726{
 727        struct usb_ftdi *ftdi = urb->context;
 728        int status = urb->status;
 729
 730        if (status && !(status == -ENOENT || status == -ECONNRESET ||
 731            status == -ESHUTDOWN)) {
 732                dev_err(&ftdi->udev->dev, "urb=%p write bulk status received: %"
 733                        "d\n", urb, status);
 734        }
 735        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
 736                urb->transfer_buffer, urb->transfer_dma);
 737}
 738
 739static int fill_buffer_with_all_queued_commands(struct usb_ftdi *ftdi,
 740        char *buf, int command_size, int total_size)
 741{
 742        int ed_commands = 0;
 743        int b = 0;
 744        int I = command_size;
 745        int i = ftdi->command_head;
 746        while (I-- > 0) {
 747                struct u132_command *command = &ftdi->command[COMMAND_MASK &
 748                        i++];
 749                int F = command->follows;
 750                u8 *f = command->buffer;
 751                if (command->header & 0x80) {
 752                        ed_commands |= 1 << (0x3 & (command->header >> 5));
 753                }
 754                buf[b++] = command->header;
 755                buf[b++] = (command->length >> 0) & 0x00FF;
 756                buf[b++] = (command->length >> 8) & 0x00FF;
 757                buf[b++] = command->address;
 758                buf[b++] = command->width;
 759                while (F-- > 0) {
 760                        buf[b++] = *f++;
 761                }
 762        }
 763        return ed_commands;
 764}
 765
 766static int ftdi_elan_total_command_size(struct usb_ftdi *ftdi, int command_size)
 767{
 768        int total_size = 0;
 769        int I = command_size;
 770        int i = ftdi->command_head;
 771        while (I-- > 0) {
 772                struct u132_command *command = &ftdi->command[COMMAND_MASK &
 773                        i++];
 774                total_size += 5 + command->follows;
 775        } return total_size;
 776}
 777
 778static int ftdi_elan_command_engine(struct usb_ftdi *ftdi)
 779{
 780        int retval;
 781        char *buf;
 782        int ed_commands;
 783        int total_size;
 784        struct urb *urb;
 785        int command_size = ftdi->command_next - ftdi->command_head;
 786        if (command_size == 0)
 787                return 0;
 788        total_size = ftdi_elan_total_command_size(ftdi, command_size);
 789        urb = usb_alloc_urb(0, GFP_KERNEL);
 790        if (!urb) {
 791                dev_err(&ftdi->udev->dev, "could not get a urb to write %d comm"
 792                        "ands totaling %d bytes to the Uxxx\n", command_size,
 793                        total_size);
 794                return -ENOMEM;
 795        }
 796        buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL,
 797                &urb->transfer_dma);
 798        if (!buf) {
 799                dev_err(&ftdi->udev->dev, "could not get a buffer to write %d c"
 800                        "ommands totaling %d bytes to the Uxxx\n", command_size,
 801                         total_size);
 802                usb_free_urb(urb);
 803                return -ENOMEM;
 804        }
 805        ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf,
 806                command_size, total_size);
 807        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
 808                ftdi->bulk_out_endpointAddr), buf, total_size,
 809                ftdi_elan_write_bulk_callback, ftdi);
 810        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 811        if (ed_commands) {
 812                char diag[40 *3 + 4];
 813                char *d = diag;
 814                int m = total_size;
 815                u8 *c = buf;
 816                int s = (sizeof(diag) - 1) / 3;
 817                diag[0] = 0;
 818                while (s-- > 0 && m-- > 0) {
 819                        if (s > 0 || m == 0) {
 820                                d += sprintf(d, " %02X", *c++);
 821                        } else
 822                                d += sprintf(d, " ..");
 823                }
 824        }
 825        retval = usb_submit_urb(urb, GFP_KERNEL);
 826        if (retval) {
 827                dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write "
 828                        "%d commands totaling %d bytes to the Uxxx\n", retval,
 829                        urb, command_size, total_size);
 830                usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma);
 831                usb_free_urb(urb);
 832                return retval;
 833        }
 834        usb_free_urb(urb);        /* release our reference to this urb,
 835                the USB core will eventually free it entirely */
 836        ftdi->command_head += command_size;
 837        ftdi_elan_kick_respond_queue(ftdi);
 838        return 0;
 839}
 840
 841static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
 842        struct u132_target *target, u8 *buffer, int length)
 843{
 844        struct urb *urb = target->urb;
 845        int halted = target->halted;
 846        int skipped = target->skipped;
 847        int actual = target->actual;
 848        int non_null = target->non_null;
 849        int toggle_bits = target->toggle_bits;
 850        int error_count = target->error_count;
 851        int condition_code = target->condition_code;
 852        int repeat_number = target->repeat_number;
 853        void (*callback) (void *, struct urb *, u8 *, int, int, int, int, int,
 854                int, int, int, int) = target->callback;
 855        target->active -= 1;
 856        target->callback = NULL;
 857        (*callback) (target->endp, urb, buffer, length, toggle_bits,
 858                error_count, condition_code, repeat_number, halted, skipped,
 859                actual, non_null);
 860}
 861
 862static char *have_ed_set_response(struct usb_ftdi *ftdi,
 863        struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
 864        char *b)
 865{
 866        int payload = (ed_length >> 0) & 0x07FF;
 867        mutex_lock(&ftdi->u132_lock);
 868        target->actual = 0;
 869        target->non_null = (ed_length >> 15) & 0x0001;
 870        target->repeat_number = (ed_length >> 11) & 0x000F;
 871        if (ed_type == 0x02) {
 872                if (payload == 0 || target->abandoning > 0) {
 873                        target->abandoning = 0;
 874                        mutex_unlock(&ftdi->u132_lock);
 875                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
 876                                payload);
 877                        ftdi->recieved = 0;
 878                        ftdi->expected = 4;
 879                        ftdi->ed_found = 0;
 880                        return ftdi->response;
 881                } else {
 882                        ftdi->expected = 4 + payload;
 883                        ftdi->ed_found = 1;
 884                        mutex_unlock(&ftdi->u132_lock);
 885                        return b;
 886                }
 887        } else if (ed_type == 0x03) {
 888                if (payload == 0 || target->abandoning > 0) {
 889                        target->abandoning = 0;
 890                        mutex_unlock(&ftdi->u132_lock);
 891                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
 892                                payload);
 893                        ftdi->recieved = 0;
 894                        ftdi->expected = 4;
 895                        ftdi->ed_found = 0;
 896                        return ftdi->response;
 897                } else {
 898                        ftdi->expected = 4 + payload;
 899                        ftdi->ed_found = 1;
 900                        mutex_unlock(&ftdi->u132_lock);
 901                        return b;
 902                }
 903        } else if (ed_type == 0x01) {
 904                target->abandoning = 0;
 905                mutex_unlock(&ftdi->u132_lock);
 906                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
 907                        payload);
 908                ftdi->recieved = 0;
 909                ftdi->expected = 4;
 910                ftdi->ed_found = 0;
 911                return ftdi->response;
 912        } else {
 913                target->abandoning = 0;
 914                mutex_unlock(&ftdi->u132_lock);
 915                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
 916                        payload);
 917                ftdi->recieved = 0;
 918                ftdi->expected = 4;
 919                ftdi->ed_found = 0;
 920                return ftdi->response;
 921        }
 922}
 923
 924static char *have_ed_get_response(struct usb_ftdi *ftdi,
 925        struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
 926        char *b)
 927{
 928        mutex_lock(&ftdi->u132_lock);
 929        target->condition_code = TD_DEVNOTRESP;
 930        target->actual = (ed_length >> 0) & 0x01FF;
 931        target->non_null = (ed_length >> 15) & 0x0001;
 932        target->repeat_number = (ed_length >> 11) & 0x000F;
 933        mutex_unlock(&ftdi->u132_lock);
 934        if (target->active)
 935                ftdi_elan_do_callback(ftdi, target, NULL, 0);
 936        target->abandoning = 0;
 937        ftdi->recieved = 0;
 938        ftdi->expected = 4;
 939        ftdi->ed_found = 0;
 940        return ftdi->response;
 941}
 942
 943
 944/*
 945* The engine tries to empty the FTDI fifo
 946*
 947* all responses found in the fifo data are dispatched thus
 948* the response buffer can only ever hold a maximum sized
 949* response from the Uxxx.
 950*
 951*/
 952static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi)
 953{
 954        u8 *b = ftdi->response + ftdi->recieved;
 955        int bytes_read = 0;
 956        int retry_on_empty = 1;
 957        int retry_on_timeout = 3;
 958        int empty_packets = 0;
 959      read:{
 960                int packet_bytes = 0;
 961                int retval = usb_bulk_msg(ftdi->udev,
 962                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
 963                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
 964                        &packet_bytes, 500);
 965                char diag[30 *3 + 4];
 966                char *d = diag;
 967                int m = packet_bytes;
 968                u8 *c = ftdi->bulk_in_buffer;
 969                int s = (sizeof(diag) - 1) / 3;
 970                diag[0] = 0;
 971                while (s-- > 0 && m-- > 0) {
 972                        if (s > 0 || m == 0) {
 973                                d += sprintf(d, " %02X", *c++);
 974                        } else
 975                                d += sprintf(d, " ..");
 976                }
 977                if (packet_bytes > 2) {
 978                        ftdi->bulk_in_left = packet_bytes - 2;
 979                        ftdi->bulk_in_last = 1;
 980                        goto have;
 981                } else if (retval == -ETIMEDOUT) {
 982                        if (retry_on_timeout-- > 0) {
 983                                dev_err(&ftdi->udev->dev, "TIMED OUT with packe"
 984                                        "t_bytes = %d with total %d bytes%s\n",
 985                                        packet_bytes, bytes_read, diag);
 986                                goto more;
 987                        } else if (bytes_read > 0) {
 988                                dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n",
 989                                        bytes_read, diag);
 990                                return -ENOMEM;
 991                        } else {
 992                                dev_err(&ftdi->udev->dev, "TIMED OUT with packe"
 993                                        "t_bytes = %d with total %d bytes%s\n",
 994                                        packet_bytes, bytes_read, diag);
 995                                return -ENOMEM;
 996                        }
 997                } else if (retval == -EILSEQ) {
 998                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes"
 999                                " = %d with total %d bytes%s\n", retval,
1000                                packet_bytes, bytes_read, diag);
1001                        return retval;
1002                } else if (retval) {
1003                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes"
1004                                " = %d with total %d bytes%s\n", retval,
1005                                packet_bytes, bytes_read, diag);
1006                        return retval;
1007                } else if (packet_bytes == 2) {
1008                        unsigned char s0 = ftdi->bulk_in_buffer[0];
1009                        unsigned char s1 = ftdi->bulk_in_buffer[1];
1010                        empty_packets += 1;
1011                        if (s0 == 0x31 && s1 == 0x60) {
1012                                if (retry_on_empty-- > 0) {
1013                                        goto more;
1014                                } else
1015                                        return 0;
1016                        } else if (s0 == 0x31 && s1 == 0x00) {
1017                                if (retry_on_empty-- > 0) {
1018                                        goto more;
1019                                } else
1020                                        return 0;
1021                        } else {
1022                                if (retry_on_empty-- > 0) {
1023                                        goto more;
1024                                } else
1025                                        return 0;
1026                        }
1027                } else if (packet_bytes == 1) {
1028                        if (retry_on_empty-- > 0) {
1029                                goto more;
1030                        } else
1031                                return 0;
1032                } else {
1033                        if (retry_on_empty-- > 0) {
1034                                goto more;
1035                        } else
1036                                return 0;
1037                }
1038        }
1039      more:{
1040                goto read;
1041        }
1042      have:if (ftdi->bulk_in_left > 0) {
1043                u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last];
1044                bytes_read += 1;
1045                ftdi->bulk_in_left -= 1;
1046                if (ftdi->recieved == 0 && c == 0xFF) {
1047                        goto have;
1048                } else
1049                        *b++ = c;
1050                if (++ftdi->recieved < ftdi->expected) {
1051                        goto have;
1052                } else if (ftdi->ed_found) {
1053                        int ed_number = (ftdi->response[0] >> 5) & 0x03;
1054                        u16 ed_length = (ftdi->response[2] << 8) |
1055                                ftdi->response[1];
1056                        struct u132_target *target = &ftdi->target[ed_number];
1057                        int payload = (ed_length >> 0) & 0x07FF;
1058                        char diag[30 *3 + 4];
1059                        char *d = diag;
1060                        int m = payload;
1061                        u8 *c = 4 + ftdi->response;
1062                        int s = (sizeof(diag) - 1) / 3;
1063                        diag[0] = 0;
1064                        while (s-- > 0 && m-- > 0) {
1065                                if (s > 0 || m == 0) {
1066                                        d += sprintf(d, " %02X", *c++);
1067                                } else
1068                                        d += sprintf(d, " ..");
1069                        }
1070                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
1071                                payload);
1072                        ftdi->recieved = 0;
1073                        ftdi->expected = 4;
1074                        ftdi->ed_found = 0;
1075                        b = ftdi->response;
1076                        goto have;
1077                } else if (ftdi->expected == 8) {
1078                        u8 buscmd;
1079                        int respond_head = ftdi->respond_head++;
1080                        struct u132_respond *respond = &ftdi->respond[
1081                                RESPOND_MASK & respond_head];
1082                        u32 data = ftdi->response[7];
1083                        data <<= 8;
1084                        data |= ftdi->response[6];
1085                        data <<= 8;
1086                        data |= ftdi->response[5];
1087                        data <<= 8;
1088                        data |= ftdi->response[4];
1089                        *respond->value = data;
1090                        *respond->result = 0;
1091                        complete(&respond->wait_completion);
1092                        ftdi->recieved = 0;
1093                        ftdi->expected = 4;
1094                        ftdi->ed_found = 0;
1095                        b = ftdi->response;
1096                        buscmd = (ftdi->response[0] >> 0) & 0x0F;
1097                        if (buscmd == 0x00) {
1098                        } else if (buscmd == 0x02) {
1099                        } else if (buscmd == 0x06) {
1100                        } else if (buscmd == 0x0A) {
1101                        } else
1102                                dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) va"
1103                                        "lue = %08X\n", buscmd, data);
1104                        goto have;
1105                } else {
1106                        if ((ftdi->response[0] & 0x80) == 0x00) {
1107                                ftdi->expected = 8;
1108                                goto have;
1109                        } else {
1110                                int ed_number = (ftdi->response[0] >> 5) & 0x03;
1111                                int ed_type = (ftdi->response[0] >> 0) & 0x03;
1112                                u16 ed_length = (ftdi->response[2] << 8) |
1113                                        ftdi->response[1];
1114                                struct u132_target *target = &ftdi->target[
1115                                        ed_number];
1116                                target->halted = (ftdi->response[0] >> 3) &
1117                                        0x01;
1118                                target->skipped = (ftdi->response[0] >> 2) &
1119                                        0x01;
1120                                target->toggle_bits = (ftdi->response[3] >> 6)
1121                                        & 0x03;
1122                                target->error_count = (ftdi->response[3] >> 4)
1123                                        & 0x03;
1124                                target->condition_code = (ftdi->response[
1125                                        3] >> 0) & 0x0F;
1126                                if ((ftdi->response[0] & 0x10) == 0x00) {
1127                                        b = have_ed_set_response(ftdi, target,
1128                                                ed_length, ed_number, ed_type,
1129                                                b);
1130                                        goto have;
1131                                } else {
1132                                        b = have_ed_get_response(ftdi, target,
1133                                                ed_length, ed_number, ed_type,
1134                                                b);
1135                                        goto have;
1136                                }
1137                        }
1138                }
1139        } else
1140                goto more;
1141}
1142
1143
1144/*
1145* create a urb, and a buffer for it, and copy the data to the urb
1146*
1147*/
1148static ssize_t ftdi_elan_write(struct file *file,
1149                               const char __user *user_buffer, size_t count,
1150                               loff_t *ppos)
1151{
1152        int retval = 0;
1153        struct urb *urb;
1154        char *buf;
1155        struct usb_ftdi *ftdi = file->private_data;
1156
1157        if (ftdi->disconnected > 0) {
1158                return -ENODEV;
1159        }
1160        if (count == 0) {
1161                goto exit;
1162        }
1163        urb = usb_alloc_urb(0, GFP_KERNEL);
1164        if (!urb) {
1165                retval = -ENOMEM;
1166                goto error_1;
1167        }
1168        buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL,
1169                &urb->transfer_dma);
1170        if (!buf) {
1171                retval = -ENOMEM;
1172                goto error_2;
1173        }
1174        if (copy_from_user(buf, user_buffer, count)) {
1175                retval = -EFAULT;
1176                goto error_3;
1177        }
1178        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
1179                ftdi->bulk_out_endpointAddr), buf, count,
1180                ftdi_elan_write_bulk_callback, ftdi);
1181        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1182        retval = usb_submit_urb(urb, GFP_KERNEL);
1183        if (retval) {
1184                dev_err(&ftdi->udev->dev, "failed submitting write urb, error %"
1185                        "d\n", retval);
1186                goto error_3;
1187        }
1188        usb_free_urb(urb);
1189
1190exit:
1191        return count;
1192error_3:
1193        usb_free_coherent(ftdi->udev, count, buf, urb->transfer_dma);
1194error_2:
1195        usb_free_urb(urb);
1196error_1:
1197        return retval;
1198}
1199
1200static const struct file_operations ftdi_elan_fops = {
1201        .owner = THIS_MODULE,
1202        .llseek = no_llseek,
1203        .read = ftdi_elan_read,
1204        .write = ftdi_elan_write,
1205        .open = ftdi_elan_open,
1206        .release = ftdi_elan_release,
1207};
1208
1209/*
1210* usb class driver info in order to get a minor number from the usb core,
1211* and to have the device registered with the driver core
1212*/
1213static struct usb_class_driver ftdi_elan_jtag_class = {
1214        .name = "ftdi-%d-jtag",
1215        .fops = &ftdi_elan_fops,
1216        .minor_base = USB_FTDI_ELAN_MINOR_BASE,
1217};
1218
1219/*
1220* the following definitions are for the
1221* ELAN FPGA state machgine processor that
1222* lies on the other side of the FTDI chip
1223*/
1224#define cPCIu132rd 0x0
1225#define cPCIu132wr 0x1
1226#define cPCIiord 0x2
1227#define cPCIiowr 0x3
1228#define cPCImemrd 0x6
1229#define cPCImemwr 0x7
1230#define cPCIcfgrd 0xA
1231#define cPCIcfgwr 0xB
1232#define cPCInull 0xF
1233#define cU132cmd_status 0x0
1234#define cU132flash 0x1
1235#define cPIDsetup 0x0
1236#define cPIDout 0x1
1237#define cPIDin 0x2
1238#define cPIDinonce 0x3
1239#define cCCnoerror 0x0
1240#define cCCcrc 0x1
1241#define cCCbitstuff 0x2
1242#define cCCtoggle 0x3
1243#define cCCstall 0x4
1244#define cCCnoresp 0x5
1245#define cCCbadpid1 0x6
1246#define cCCbadpid2 0x7
1247#define cCCdataoverrun 0x8
1248#define cCCdataunderrun 0x9
1249#define cCCbuffoverrun 0xC
1250#define cCCbuffunderrun 0xD
1251#define cCCnotaccessed 0xF
1252static int ftdi_elan_write_reg(struct usb_ftdi *ftdi, u32 data)
1253{
1254      wait:if (ftdi->disconnected > 0) {
1255                return -ENODEV;
1256        } else {
1257                int command_size;
1258                mutex_lock(&ftdi->u132_lock);
1259                command_size = ftdi->command_next - ftdi->command_head;
1260                if (command_size < COMMAND_SIZE) {
1261                        struct u132_command *command = &ftdi->command[
1262                                COMMAND_MASK & ftdi->command_next];
1263                        command->header = 0x00 | cPCIu132wr;
1264                        command->length = 0x04;
1265                        command->address = 0x00;
1266                        command->width = 0x00;
1267                        command->follows = 4;
1268                        command->value = data;
1269                        command->buffer = &command->value;
1270                        ftdi->command_next += 1;
1271                        ftdi_elan_kick_command_queue(ftdi);
1272                        mutex_unlock(&ftdi->u132_lock);
1273                        return 0;
1274                } else {
1275                        mutex_unlock(&ftdi->u132_lock);
1276                        msleep(100);
1277                        goto wait;
1278                }
1279        }
1280}
1281
1282static int ftdi_elan_write_config(struct usb_ftdi *ftdi, int config_offset,
1283        u8 width, u32 data)
1284{
1285        u8 addressofs = config_offset / 4;
1286      wait:if (ftdi->disconnected > 0) {
1287                return -ENODEV;
1288        } else {
1289                int command_size;
1290                mutex_lock(&ftdi->u132_lock);
1291                command_size = ftdi->command_next - ftdi->command_head;
1292                if (command_size < COMMAND_SIZE) {
1293                        struct u132_command *command = &ftdi->command[
1294                                COMMAND_MASK & ftdi->command_next];
1295                        command->header = 0x00 | (cPCIcfgwr & 0x0F);
1296                        command->length = 0x04;
1297                        command->address = addressofs;
1298                        command->width = 0x00 | (width & 0x0F);
1299                        command->follows = 4;
1300                        command->value = data;
1301                        command->buffer = &command->value;
1302                        ftdi->command_next += 1;
1303                        ftdi_elan_kick_command_queue(ftdi);
1304                        mutex_unlock(&ftdi->u132_lock);
1305                        return 0;
1306                } else {
1307                        mutex_unlock(&ftdi->u132_lock);
1308                        msleep(100);
1309                        goto wait;
1310                }
1311        }
1312}
1313
1314static int ftdi_elan_write_pcimem(struct usb_ftdi *ftdi, int mem_offset,
1315        u8 width, u32 data)
1316{
1317        u8 addressofs = mem_offset / 4;
1318      wait:if (ftdi->disconnected > 0) {
1319                return -ENODEV;
1320        } else {
1321                int command_size;
1322                mutex_lock(&ftdi->u132_lock);
1323                command_size = ftdi->command_next - ftdi->command_head;
1324                if (command_size < COMMAND_SIZE) {
1325                        struct u132_command *command = &ftdi->command[
1326                                COMMAND_MASK & ftdi->command_next];
1327                        command->header = 0x00 | (cPCImemwr & 0x0F);
1328                        command->length = 0x04;
1329                        command->address = addressofs;
1330                        command->width = 0x00 | (width & 0x0F);
1331                        command->follows = 4;
1332                        command->value = data;
1333                        command->buffer = &command->value;
1334                        ftdi->command_next += 1;
1335                        ftdi_elan_kick_command_queue(ftdi);
1336                        mutex_unlock(&ftdi->u132_lock);
1337                        return 0;
1338                } else {
1339                        mutex_unlock(&ftdi->u132_lock);
1340                        msleep(100);
1341                        goto wait;
1342                }
1343        }
1344}
1345
1346int usb_ftdi_elan_write_pcimem(struct platform_device *pdev, int mem_offset,
1347        u8 width, u32 data)
1348{
1349        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1350        return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data);
1351}
1352
1353
1354EXPORT_SYMBOL_GPL(usb_ftdi_elan_write_pcimem);
1355static int ftdi_elan_read_reg(struct usb_ftdi *ftdi, u32 *data)
1356{
1357      wait:if (ftdi->disconnected > 0) {
1358                return -ENODEV;
1359        } else {
1360                int command_size;
1361                int respond_size;
1362                mutex_lock(&ftdi->u132_lock);
1363                command_size = ftdi->command_next - ftdi->command_head;
1364                respond_size = ftdi->respond_next - ftdi->respond_head;
1365                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
1366                        {
1367                        struct u132_command *command = &ftdi->command[
1368                                COMMAND_MASK & ftdi->command_next];
1369                        struct u132_respond *respond = &ftdi->respond[
1370                                RESPOND_MASK & ftdi->respond_next];
1371                        int result = -ENODEV;
1372                        respond->result = &result;
1373                        respond->header = command->header = 0x00 | cPCIu132rd;
1374                        command->length = 0x04;
1375                        respond->address = command->address = cU132cmd_status;
1376                        command->width = 0x00;
1377                        command->follows = 0;
1378                        command->value = 0;
1379                        command->buffer = NULL;
1380                        respond->value = data;
1381                        init_completion(&respond->wait_completion);
1382                        ftdi->command_next += 1;
1383                        ftdi->respond_next += 1;
1384                        ftdi_elan_kick_command_queue(ftdi);
1385                        mutex_unlock(&ftdi->u132_lock);
1386                        wait_for_completion(&respond->wait_completion);
1387                        return result;
1388                } else {
1389                        mutex_unlock(&ftdi->u132_lock);
1390                        msleep(100);
1391                        goto wait;
1392                }
1393        }
1394}
1395
1396static int ftdi_elan_read_config(struct usb_ftdi *ftdi, int config_offset,
1397        u8 width, u32 *data)
1398{
1399        u8 addressofs = config_offset / 4;
1400      wait:if (ftdi->disconnected > 0) {
1401                return -ENODEV;
1402        } else {
1403                int command_size;
1404                int respond_size;
1405                mutex_lock(&ftdi->u132_lock);
1406                command_size = ftdi->command_next - ftdi->command_head;
1407                respond_size = ftdi->respond_next - ftdi->respond_head;
1408                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
1409                        {
1410                        struct u132_command *command = &ftdi->command[
1411                                COMMAND_MASK & ftdi->command_next];
1412                        struct u132_respond *respond = &ftdi->respond[
1413                                RESPOND_MASK & ftdi->respond_next];
1414                        int result = -ENODEV;
1415                        respond->result = &result;
1416                        respond->header = command->header = 0x00 | (cPCIcfgrd &
1417                                0x0F);
1418                        command->length = 0x04;
1419                        respond->address = command->address = addressofs;
1420                        command->width = 0x00 | (width & 0x0F);
1421                        command->follows = 0;
1422                        command->value = 0;
1423                        command->buffer = NULL;
1424                        respond->value = data;
1425                        init_completion(&respond->wait_completion);
1426                        ftdi->command_next += 1;
1427                        ftdi->respond_next += 1;
1428                        ftdi_elan_kick_command_queue(ftdi);
1429                        mutex_unlock(&ftdi->u132_lock);
1430                        wait_for_completion(&respond->wait_completion);
1431                        return result;
1432                } else {
1433                        mutex_unlock(&ftdi->u132_lock);
1434                        msleep(100);
1435                        goto wait;
1436                }
1437        }
1438}
1439
1440static int ftdi_elan_read_pcimem(struct usb_ftdi *ftdi, int mem_offset,
1441        u8 width, u32 *data)
1442{
1443        u8 addressofs = mem_offset / 4;
1444      wait:if (ftdi->disconnected > 0) {
1445                return -ENODEV;
1446        } else {
1447                int command_size;
1448                int respond_size;
1449                mutex_lock(&ftdi->u132_lock);
1450                command_size = ftdi->command_next - ftdi->command_head;
1451                respond_size = ftdi->respond_next - ftdi->respond_head;
1452                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
1453                        {
1454                        struct u132_command *command = &ftdi->command[
1455                                COMMAND_MASK & ftdi->command_next];
1456                        struct u132_respond *respond = &ftdi->respond[
1457                                RESPOND_MASK & ftdi->respond_next];
1458                        int result = -ENODEV;
1459                        respond->result = &result;
1460                        respond->header = command->header = 0x00 | (cPCImemrd &
1461                                0x0F);
1462                        command->length = 0x04;
1463                        respond->address = command->address = addressofs;
1464                        command->width = 0x00 | (width & 0x0F);
1465                        command->follows = 0;
1466                        command->value = 0;
1467                        command->buffer = NULL;
1468                        respond->value = data;
1469                        init_completion(&respond->wait_completion);
1470                        ftdi->command_next += 1;
1471                        ftdi->respond_next += 1;
1472                        ftdi_elan_kick_command_queue(ftdi);
1473                        mutex_unlock(&ftdi->u132_lock);
1474                        wait_for_completion(&respond->wait_completion);
1475                        return result;
1476                } else {
1477                        mutex_unlock(&ftdi->u132_lock);
1478                        msleep(100);
1479                        goto wait;
1480                }
1481        }
1482}
1483
1484int usb_ftdi_elan_read_pcimem(struct platform_device *pdev, int mem_offset,
1485        u8 width, u32 *data)
1486{
1487        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1488        if (ftdi->initialized == 0) {
1489                return -ENODEV;
1490        } else
1491                return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data);
1492}
1493
1494
1495EXPORT_SYMBOL_GPL(usb_ftdi_elan_read_pcimem);
1496static int ftdi_elan_edset_setup(struct usb_ftdi *ftdi, u8 ed_number,
1497        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1498        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1499        int toggle_bits, int error_count, int condition_code, int repeat_number,
1500         int halted, int skipped, int actual, int non_null))
1501{
1502        u8 ed = ed_number - 1;
1503      wait:if (ftdi->disconnected > 0) {
1504                return -ENODEV;
1505        } else if (ftdi->initialized == 0) {
1506                return -ENODEV;
1507        } else {
1508                int command_size;
1509                mutex_lock(&ftdi->u132_lock);
1510                command_size = ftdi->command_next - ftdi->command_head;
1511                if (command_size < COMMAND_SIZE) {
1512                        struct u132_target *target = &ftdi->target[ed];
1513                        struct u132_command *command = &ftdi->command[
1514                                COMMAND_MASK & ftdi->command_next];
1515                        command->header = 0x80 | (ed << 5);
1516                        command->length = 0x8007;
1517                        command->address = (toggle_bits << 6) | (ep_number << 2)
1518                                | (address << 0);
1519                        command->width = usb_maxpacket(urb->dev, urb->pipe,
1520                                usb_pipeout(urb->pipe));
1521                        command->follows = 8;
1522                        command->value = 0;
1523                        command->buffer = urb->setup_packet;
1524                        target->callback = callback;
1525                        target->endp = endp;
1526                        target->urb = urb;
1527                        target->active = 1;
1528                        ftdi->command_next += 1;
1529                        ftdi_elan_kick_command_queue(ftdi);
1530                        mutex_unlock(&ftdi->u132_lock);
1531                        return 0;
1532                } else {
1533                        mutex_unlock(&ftdi->u132_lock);
1534                        msleep(100);
1535                        goto wait;
1536                }
1537        }
1538}
1539
1540int usb_ftdi_elan_edset_setup(struct platform_device *pdev, u8 ed_number,
1541        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1542        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1543        int toggle_bits, int error_count, int condition_code, int repeat_number,
1544         int halted, int skipped, int actual, int non_null))
1545{
1546        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1547        return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address,
1548                ep_number, toggle_bits, callback);
1549}
1550
1551
1552EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_setup);
1553static int ftdi_elan_edset_input(struct usb_ftdi *ftdi, u8 ed_number,
1554        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1555        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1556        int toggle_bits, int error_count, int condition_code, int repeat_number,
1557         int halted, int skipped, int actual, int non_null))
1558{
1559        u8 ed = ed_number - 1;
1560      wait:if (ftdi->disconnected > 0) {
1561                return -ENODEV;
1562        } else if (ftdi->initialized == 0) {
1563                return -ENODEV;
1564        } else {
1565                int command_size;
1566                mutex_lock(&ftdi->u132_lock);
1567                command_size = ftdi->command_next - ftdi->command_head;
1568                if (command_size < COMMAND_SIZE) {
1569                        struct u132_target *target = &ftdi->target[ed];
1570                        struct u132_command *command = &ftdi->command[
1571                                COMMAND_MASK & ftdi->command_next];
1572                        u32 remaining_length = urb->transfer_buffer_length -
1573                                urb->actual_length;
1574                        command->header = 0x82 | (ed << 5);
1575                        if (remaining_length == 0) {
1576                                command->length = 0x0000;
1577                        } else if (remaining_length > 1024) {
1578                                command->length = 0x8000 | 1023;
1579                        } else
1580                                command->length = 0x8000 | (remaining_length -
1581                                        1);
1582                        command->address = (toggle_bits << 6) | (ep_number << 2)
1583                                | (address << 0);
1584                        command->width = usb_maxpacket(urb->dev, urb->pipe,
1585                                usb_pipeout(urb->pipe));
1586                        command->follows = 0;
1587                        command->value = 0;
1588                        command->buffer = NULL;
1589                        target->callback = callback;
1590                        target->endp = endp;
1591                        target->urb = urb;
1592                        target->active = 1;
1593                        ftdi->command_next += 1;
1594                        ftdi_elan_kick_command_queue(ftdi);
1595                        mutex_unlock(&ftdi->u132_lock);
1596                        return 0;
1597                } else {
1598                        mutex_unlock(&ftdi->u132_lock);
1599                        msleep(100);
1600                        goto wait;
1601                }
1602        }
1603}
1604
1605int usb_ftdi_elan_edset_input(struct platform_device *pdev, u8 ed_number,
1606        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1607        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1608        int toggle_bits, int error_count, int condition_code, int repeat_number,
1609         int halted, int skipped, int actual, int non_null))
1610{
1611        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1612        return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address,
1613                ep_number, toggle_bits, callback);
1614}
1615
1616
1617EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_input);
1618static int ftdi_elan_edset_empty(struct usb_ftdi *ftdi, u8 ed_number,
1619        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1620        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1621        int toggle_bits, int error_count, int condition_code, int repeat_number,
1622         int halted, int skipped, int actual, int non_null))
1623{
1624        u8 ed = ed_number - 1;
1625      wait:if (ftdi->disconnected > 0) {
1626                return -ENODEV;
1627        } else if (ftdi->initialized == 0) {
1628                return -ENODEV;
1629        } else {
1630                int command_size;
1631                mutex_lock(&ftdi->u132_lock);
1632                command_size = ftdi->command_next - ftdi->command_head;
1633                if (command_size < COMMAND_SIZE) {
1634                        struct u132_target *target = &ftdi->target[ed];
1635                        struct u132_command *command = &ftdi->command[
1636                                COMMAND_MASK & ftdi->command_next];
1637                        command->header = 0x81 | (ed << 5);
1638                        command->length = 0x0000;
1639                        command->address = (toggle_bits << 6) | (ep_number << 2)
1640                                | (address << 0);
1641                        command->width = usb_maxpacket(urb->dev, urb->pipe,
1642                                usb_pipeout(urb->pipe));
1643                        command->follows = 0;
1644                        command->value = 0;
1645                        command->buffer = NULL;
1646                        target->callback = callback;
1647                        target->endp = endp;
1648                        target->urb = urb;
1649                        target->active = 1;
1650                        ftdi->command_next += 1;
1651                        ftdi_elan_kick_command_queue(ftdi);
1652                        mutex_unlock(&ftdi->u132_lock);
1653                        return 0;
1654                } else {
1655                        mutex_unlock(&ftdi->u132_lock);
1656                        msleep(100);
1657                        goto wait;
1658                }
1659        }
1660}
1661
1662int usb_ftdi_elan_edset_empty(struct platform_device *pdev, u8 ed_number,
1663        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1664        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1665        int toggle_bits, int error_count, int condition_code, int repeat_number,
1666         int halted, int skipped, int actual, int non_null))
1667{
1668        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1669        return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address,
1670                ep_number, toggle_bits, callback);
1671}
1672
1673
1674EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_empty);
1675static int ftdi_elan_edset_output(struct usb_ftdi *ftdi, u8 ed_number,
1676        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1677        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1678        int toggle_bits, int error_count, int condition_code, int repeat_number,
1679         int halted, int skipped, int actual, int non_null))
1680{
1681        u8 ed = ed_number - 1;
1682      wait:if (ftdi->disconnected > 0) {
1683                return -ENODEV;
1684        } else if (ftdi->initialized == 0) {
1685                return -ENODEV;
1686        } else {
1687                int command_size;
1688                mutex_lock(&ftdi->u132_lock);
1689                command_size = ftdi->command_next - ftdi->command_head;
1690                if (command_size < COMMAND_SIZE) {
1691                        u8 *b;
1692                        u16 urb_size;
1693                        int i = 0;
1694                        char data[30 *3 + 4];
1695                        char *d = data;
1696                        int m = (sizeof(data) - 1) / 3;
1697                        int l = 0;
1698                        struct u132_target *target = &ftdi->target[ed];
1699                        struct u132_command *command = &ftdi->command[
1700                                COMMAND_MASK & ftdi->command_next];
1701                        command->header = 0x81 | (ed << 5);
1702                        command->address = (toggle_bits << 6) | (ep_number << 2)
1703                                | (address << 0);
1704                        command->width = usb_maxpacket(urb->dev, urb->pipe,
1705                                usb_pipeout(urb->pipe));
1706                        command->follows = min_t(u32, 1024,
1707                                urb->transfer_buffer_length -
1708                                urb->actual_length);
1709                        command->value = 0;
1710                        command->buffer = urb->transfer_buffer +
1711                                urb->actual_length;
1712                        command->length = 0x8000 | (command->follows - 1);
1713                        b = command->buffer;
1714                        urb_size = command->follows;
1715                        data[0] = 0;
1716                        while (urb_size-- > 0) {
1717                                if (i > m) {
1718                                } else if (i++ < m) {
1719                                        int w = sprintf(d, " %02X", *b++);
1720                                        d += w;
1721                                        l += w;
1722                                } else
1723                                        d += sprintf(d, " ..");
1724                        }
1725                        target->callback = callback;
1726                        target->endp = endp;
1727                        target->urb = urb;
1728                        target->active = 1;
1729                        ftdi->command_next += 1;
1730                        ftdi_elan_kick_command_queue(ftdi);
1731                        mutex_unlock(&ftdi->u132_lock);
1732                        return 0;
1733                } else {
1734                        mutex_unlock(&ftdi->u132_lock);
1735                        msleep(100);
1736                        goto wait;
1737                }
1738        }
1739}
1740
1741int usb_ftdi_elan_edset_output(struct platform_device *pdev, u8 ed_number,
1742        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1743        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1744        int toggle_bits, int error_count, int condition_code, int repeat_number,
1745         int halted, int skipped, int actual, int non_null))
1746{
1747        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1748        return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address,
1749                ep_number, toggle_bits, callback);
1750}
1751
1752
1753EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_output);
1754static int ftdi_elan_edset_single(struct usb_ftdi *ftdi, u8 ed_number,
1755        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1756        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1757        int toggle_bits, int error_count, int condition_code, int repeat_number,
1758         int halted, int skipped, int actual, int non_null))
1759{
1760        u8 ed = ed_number - 1;
1761      wait:if (ftdi->disconnected > 0) {
1762                return -ENODEV;
1763        } else if (ftdi->initialized == 0) {
1764                return -ENODEV;
1765        } else {
1766                int command_size;
1767                mutex_lock(&ftdi->u132_lock);
1768                command_size = ftdi->command_next - ftdi->command_head;
1769                if (command_size < COMMAND_SIZE) {
1770                        u32 remaining_length = urb->transfer_buffer_length -
1771                                urb->actual_length;
1772                        struct u132_target *target = &ftdi->target[ed];
1773                        struct u132_command *command = &ftdi->command[
1774                                COMMAND_MASK & ftdi->command_next];
1775                        command->header = 0x83 | (ed << 5);
1776                        if (remaining_length == 0) {
1777                                command->length = 0x0000;
1778                        } else if (remaining_length > 1024) {
1779                                command->length = 0x8000 | 1023;
1780                        } else
1781                                command->length = 0x8000 | (remaining_length -
1782                                        1);
1783                        command->address = (toggle_bits << 6) | (ep_number << 2)
1784                                | (address << 0);
1785                        command->width = usb_maxpacket(urb->dev, urb->pipe,
1786                                usb_pipeout(urb->pipe));
1787                        command->follows = 0;
1788                        command->value = 0;
1789                        command->buffer = NULL;
1790                        target->callback = callback;
1791                        target->endp = endp;
1792                        target->urb = urb;
1793                        target->active = 1;
1794                        ftdi->command_next += 1;
1795                        ftdi_elan_kick_command_queue(ftdi);
1796                        mutex_unlock(&ftdi->u132_lock);
1797                        return 0;
1798                } else {
1799                        mutex_unlock(&ftdi->u132_lock);
1800                        msleep(100);
1801                        goto wait;
1802                }
1803        }
1804}
1805
1806int usb_ftdi_elan_edset_single(struct platform_device *pdev, u8 ed_number,
1807        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
1808        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
1809        int toggle_bits, int error_count, int condition_code, int repeat_number,
1810         int halted, int skipped, int actual, int non_null))
1811{
1812        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1813        return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address,
1814                ep_number, toggle_bits, callback);
1815}
1816
1817
1818EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_single);
1819static int ftdi_elan_edset_flush(struct usb_ftdi *ftdi, u8 ed_number,
1820        void *endp)
1821{
1822        u8 ed = ed_number - 1;
1823        if (ftdi->disconnected > 0) {
1824                return -ENODEV;
1825        } else if (ftdi->initialized == 0) {
1826                return -ENODEV;
1827        } else {
1828                struct u132_target *target = &ftdi->target[ed];
1829                mutex_lock(&ftdi->u132_lock);
1830                if (target->abandoning > 0) {
1831                        mutex_unlock(&ftdi->u132_lock);
1832                        return 0;
1833                } else {
1834                        target->abandoning = 1;
1835                      wait_1:if (target->active == 1) {
1836                                int command_size = ftdi->command_next -
1837                                        ftdi->command_head;
1838                                if (command_size < COMMAND_SIZE) {
1839                                        struct u132_command *command =
1840                                                &ftdi->command[COMMAND_MASK &
1841                                                ftdi->command_next];
1842                                        command->header = 0x80 | (ed << 5) |
1843                                                0x4;
1844                                        command->length = 0x00;
1845                                        command->address = 0x00;
1846                                        command->width = 0x00;
1847                                        command->follows = 0;
1848                                        command->value = 0;
1849                                        command->buffer = &command->value;
1850                                        ftdi->command_next += 1;
1851                                        ftdi_elan_kick_command_queue(ftdi);
1852                                } else {
1853                                        mutex_unlock(&ftdi->u132_lock);
1854                                        msleep(100);
1855                                        mutex_lock(&ftdi->u132_lock);
1856                                        goto wait_1;
1857                                }
1858                        }
1859                        mutex_unlock(&ftdi->u132_lock);
1860                        return 0;
1861                }
1862        }
1863}
1864
1865int usb_ftdi_elan_edset_flush(struct platform_device *pdev, u8 ed_number,
1866        void *endp)
1867{
1868        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1869        return ftdi_elan_edset_flush(ftdi, ed_number, endp);
1870}
1871
1872
1873EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_flush);
1874static int ftdi_elan_flush_input_fifo(struct usb_ftdi *ftdi)
1875{
1876        int retry_on_empty = 10;
1877        int retry_on_timeout = 5;
1878        int retry_on_status = 20;
1879      more:{
1880                int packet_bytes = 0;
1881                int retval = usb_bulk_msg(ftdi->udev,
1882                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
1883                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
1884                        &packet_bytes, 100);
1885                if (packet_bytes > 2) {
1886                        char diag[30 *3 + 4];
1887                        char *d = diag;
1888                        int m = (sizeof(diag) - 1) / 3;
1889                        char *b = ftdi->bulk_in_buffer;
1890                        int bytes_read = 0;
1891                        diag[0] = 0;
1892                        while (packet_bytes-- > 0) {
1893                                char c = *b++;
1894                                if (bytes_read < m) {
1895                                        d += sprintf(d, " %02X",
1896                                                0x000000FF & c);
1897                                } else if (bytes_read > m) {
1898                                } else
1899                                        d += sprintf(d, " ..");
1900                                bytes_read += 1;
1901                                continue;
1902                        }
1903                        goto more;
1904                } else if (packet_bytes > 1) {
1905                        char s1 = ftdi->bulk_in_buffer[0];
1906                        char s2 = ftdi->bulk_in_buffer[1];
1907                        if (s1 == 0x31 && s2 == 0x60) {
1908                                return 0;
1909                        } else if (retry_on_status-- > 0) {
1910                                goto more;
1911                        } else {
1912                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
1913                                        "imit reached\n");
1914                                return -EFAULT;
1915                        }
1916                } else if (packet_bytes > 0) {
1917                        char b1 = ftdi->bulk_in_buffer[0];
1918                        dev_err(&ftdi->udev->dev, "only one byte flushed from F"
1919                                "TDI = %02X\n", b1);
1920                        if (retry_on_status-- > 0) {
1921                                goto more;
1922                        } else {
1923                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
1924                                        "imit reached\n");
1925                                return -EFAULT;
1926                        }
1927                } else if (retval == -ETIMEDOUT) {
1928                        if (retry_on_timeout-- > 0) {
1929                                goto more;
1930                        } else {
1931                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limi"
1932                                        "t reached\n");
1933                                return -ENOMEM;
1934                        }
1935                } else if (retval == 0) {
1936                        if (retry_on_empty-- > 0) {
1937                                goto more;
1938                        } else {
1939                                dev_err(&ftdi->udev->dev, "empty packet retry l"
1940                                        "imit reached\n");
1941                                return -ENOMEM;
1942                        }
1943                } else {
1944                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
1945                        return retval;
1946                }
1947        }
1948        return -1;
1949}
1950
1951
1952/*
1953* send the long flush sequence
1954*
1955*/
1956static int ftdi_elan_synchronize_flush(struct usb_ftdi *ftdi)
1957{
1958        int retval;
1959        struct urb *urb;
1960        char *buf;
1961        int I = 257;
1962        int i = 0;
1963        urb = usb_alloc_urb(0, GFP_KERNEL);
1964        if (!urb) {
1965                dev_err(&ftdi->udev->dev, "could not alloc a urb for flush sequ"
1966                        "ence\n");
1967                return -ENOMEM;
1968        }
1969        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
1970        if (!buf) {
1971                dev_err(&ftdi->udev->dev, "could not get a buffer for flush seq"
1972                        "uence\n");
1973                usb_free_urb(urb);
1974                return -ENOMEM;
1975        }
1976        while (I-- > 0)
1977                buf[i++] = 0x55;
1978        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
1979                ftdi->bulk_out_endpointAddr), buf, i,
1980                ftdi_elan_write_bulk_callback, ftdi);
1981        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1982        retval = usb_submit_urb(urb, GFP_KERNEL);
1983        if (retval) {
1984                dev_err(&ftdi->udev->dev, "failed to submit urb containing the "
1985                        "flush sequence\n");
1986                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
1987                usb_free_urb(urb);
1988                return -ENOMEM;
1989        }
1990        usb_free_urb(urb);
1991        return 0;
1992}
1993
1994
1995/*
1996* send the reset sequence
1997*
1998*/
1999static int ftdi_elan_synchronize_reset(struct usb_ftdi *ftdi)
2000{
2001        int retval;
2002        struct urb *urb;
2003        char *buf;
2004        int I = 4;
2005        int i = 0;
2006        urb = usb_alloc_urb(0, GFP_KERNEL);
2007        if (!urb) {
2008                dev_err(&ftdi->udev->dev, "could not get a urb for the reset se"
2009                        "quence\n");
2010                return -ENOMEM;
2011        }
2012        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
2013        if (!buf) {
2014                dev_err(&ftdi->udev->dev, "could not get a buffer for the reset"
2015                        " sequence\n");
2016                usb_free_urb(urb);
2017                return -ENOMEM;
2018        }
2019        buf[i++] = 0x55;
2020        buf[i++] = 0xAA;
2021        buf[i++] = 0x5A;
2022        buf[i++] = 0xA5;
2023        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
2024                ftdi->bulk_out_endpointAddr), buf, i,
2025                ftdi_elan_write_bulk_callback, ftdi);
2026        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
2027        retval = usb_submit_urb(urb, GFP_KERNEL);
2028        if (retval) {
2029                dev_err(&ftdi->udev->dev, "failed to submit urb containing the "
2030                        "reset sequence\n");
2031                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
2032                usb_free_urb(urb);
2033                return -ENOMEM;
2034        }
2035        usb_free_urb(urb);
2036        return 0;
2037}
2038
2039static int ftdi_elan_synchronize(struct usb_ftdi *ftdi)
2040{
2041        int retval;
2042        int long_stop = 10;
2043        int retry_on_timeout = 5;
2044        int retry_on_empty = 10;
2045        int err_count = 0;
2046        retval = ftdi_elan_flush_input_fifo(ftdi);
2047        if (retval)
2048                return retval;
2049        ftdi->bulk_in_left = 0;
2050        ftdi->bulk_in_last = -1;
2051        while (long_stop-- > 0) {
2052                int read_stop;
2053                int read_stuck;
2054                retval = ftdi_elan_synchronize_flush(ftdi);
2055                if (retval)
2056                        return retval;
2057                retval = ftdi_elan_flush_input_fifo(ftdi);
2058                if (retval)
2059                        return retval;
2060              reset:retval = ftdi_elan_synchronize_reset(ftdi);
2061                if (retval)
2062                        return retval;
2063                read_stop = 100;
2064                read_stuck = 10;
2065              read:{
2066                        int packet_bytes = 0;
2067                        retval = usb_bulk_msg(ftdi->udev,
2068                                usb_rcvbulkpipe(ftdi->udev,
2069                                ftdi->bulk_in_endpointAddr),
2070                                ftdi->bulk_in_buffer, ftdi->bulk_in_size,
2071                                &packet_bytes, 500);
2072                        if (packet_bytes > 2) {
2073                                char diag[30 *3 + 4];
2074                                char *d = diag;
2075                                int m = (sizeof(diag) - 1) / 3;
2076                                char *b = ftdi->bulk_in_buffer;
2077                                int bytes_read = 0;
2078                                unsigned char c = 0;
2079                                diag[0] = 0;
2080                                while (packet_bytes-- > 0) {
2081                                        c = *b++;
2082                                        if (bytes_read < m) {
2083                                                d += sprintf(d, " %02X", c);
2084                                        } else if (bytes_read > m) {
2085                                        } else
2086                                                d += sprintf(d, " ..");
2087                                        bytes_read += 1;
2088                                        continue;
2089                                }
2090                                if (c == 0x7E) {
2091                                        return 0;
2092                                } else {
2093                                        if (c == 0x55) {
2094                                                goto read;
2095                                        } else if (read_stop-- > 0) {
2096                                                goto read;
2097                                        } else {
2098                                                dev_err(&ftdi->udev->dev, "retr"
2099                                                        "y limit reached\n");
2100                                                continue;
2101                                        }
2102                                }
2103                        } else if (packet_bytes > 1) {
2104                                unsigned char s1 = ftdi->bulk_in_buffer[0];
2105                                unsigned char s2 = ftdi->bulk_in_buffer[1];
2106                                if (s1 == 0x31 && s2 == 0x00) {
2107                                        if (read_stuck-- > 0) {
2108                                                goto read;
2109                                        } else
2110                                                goto reset;
2111                                } else if (s1 == 0x31 && s2 == 0x60) {
2112                                        if (read_stop-- > 0) {
2113                                                goto read;
2114                                        } else {
2115                                                dev_err(&ftdi->udev->dev, "retr"
2116                                                        "y limit reached\n");
2117                                                continue;
2118                                        }
2119                                } else {
2120                                        if (read_stop-- > 0) {
2121                                                goto read;
2122                                        } else {
2123                                                dev_err(&ftdi->udev->dev, "retr"
2124                                                        "y limit reached\n");
2125                                                continue;
2126                                        }
2127                                }
2128                        } else if (packet_bytes > 0) {
2129                                if (read_stop-- > 0) {
2130                                        goto read;
2131                                } else {
2132                                        dev_err(&ftdi->udev->dev, "retry limit "
2133                                                "reached\n");
2134                                        continue;
2135                                }
2136                        } else if (retval == -ETIMEDOUT) {
2137                                if (retry_on_timeout-- > 0) {
2138                                        goto read;
2139                                } else {
2140                                        dev_err(&ftdi->udev->dev, "TIMED OUT re"
2141                                                "try limit reached\n");
2142                                        continue;
2143                                }
2144                        } else if (retval == 0) {
2145                                if (retry_on_empty-- > 0) {
2146                                        goto read;
2147                                } else {
2148                                        dev_err(&ftdi->udev->dev, "empty packet"
2149                                                " retry limit reached\n");
2150                                        continue;
2151                                }
2152                        } else {
2153                                err_count += 1;
2154                                dev_err(&ftdi->udev->dev, "error = %d\n",
2155                                        retval);
2156                                if (read_stop-- > 0) {
2157                                        goto read;
2158                                } else {
2159                                        dev_err(&ftdi->udev->dev, "retry limit "
2160                                                "reached\n");
2161                                        continue;
2162                                }
2163                        }
2164                }
2165        }
2166        dev_err(&ftdi->udev->dev, "failed to synchronize\n");
2167        return -EFAULT;
2168}
2169
2170static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi)
2171{
2172        int retry_on_empty = 10;
2173        int retry_on_timeout = 5;
2174        int retry_on_status = 50;
2175      more:{
2176                int packet_bytes = 0;
2177                int retval = usb_bulk_msg(ftdi->udev,
2178                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
2179                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
2180                        &packet_bytes, 1000);
2181                if (packet_bytes > 2) {
2182                        char diag[30 *3 + 4];
2183                        char *d = diag;
2184                        int m = (sizeof(diag) - 1) / 3;
2185                        char *b = ftdi->bulk_in_buffer;
2186                        int bytes_read = 0;
2187                        diag[0] = 0;
2188                        while (packet_bytes-- > 0) {
2189                                char c = *b++;
2190                                if (bytes_read < m) {
2191                                        d += sprintf(d, " %02X",
2192                                                0x000000FF & c);
2193                                } else if (bytes_read > m) {
2194                                } else
2195                                        d += sprintf(d, " ..");
2196                                bytes_read += 1;
2197                                continue;
2198                        }
2199                        goto more;
2200                } else if (packet_bytes > 1) {
2201                        char s1 = ftdi->bulk_in_buffer[0];
2202                        char s2 = ftdi->bulk_in_buffer[1];
2203                        if (s1 == 0x31 && s2 == 0x60) {
2204                                return 0;
2205                        } else if (retry_on_status-- > 0) {
2206                                msleep(5);
2207                                goto more;
2208                        } else
2209                                return -EFAULT;
2210                } else if (packet_bytes > 0) {
2211                        char b1 = ftdi->bulk_in_buffer[0];
2212                        dev_err(&ftdi->udev->dev, "only one byte flushed from F"
2213                                "TDI = %02X\n", b1);
2214                        if (retry_on_status-- > 0) {
2215                                msleep(5);
2216                                goto more;
2217                        } else {
2218                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
2219                                        "imit reached\n");
2220                                return -EFAULT;
2221                        }
2222                } else if (retval == -ETIMEDOUT) {
2223                        if (retry_on_timeout-- > 0) {
2224                                goto more;
2225                        } else {
2226                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limi"
2227                                        "t reached\n");
2228                                return -ENOMEM;
2229                        }
2230                } else if (retval == 0) {
2231                        if (retry_on_empty-- > 0) {
2232                                goto more;
2233                        } else {
2234                                dev_err(&ftdi->udev->dev, "empty packet retry l"
2235                                        "imit reached\n");
2236                                return -ENOMEM;
2237                        }
2238                } else {
2239                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
2240                        return -ENOMEM;
2241                }
2242        }
2243        return -1;
2244}
2245
2246static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi)
2247{
2248        int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg);
2249        if (UxxxStatus)
2250                return UxxxStatus;
2251        if (ftdi->controlreg & 0x00400000) {
2252                if (ftdi->card_ejected) {
2253                } else {
2254                        ftdi->card_ejected = 1;
2255                        dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = "
2256                                "%08X\n", ftdi->controlreg);
2257                }
2258                return -ENODEV;
2259        } else {
2260                u8 fn = ftdi->function - 1;
2261                int activePCIfn = fn << 8;
2262                u32 pcidata;
2263                u32 pciVID;
2264                u32 pciPID;
2265                int reg = 0;
2266                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2267                        &pcidata);
2268                if (UxxxStatus)
2269                        return UxxxStatus;
2270                pciVID = pcidata & 0xFFFF;
2271                pciPID = (pcidata >> 16) & 0xFFFF;
2272                if (pciVID == ftdi->platform_data.vendor && pciPID ==
2273                        ftdi->platform_data.device) {
2274                        return 0;
2275                } else {
2276                        dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X devi"
2277                                "ce=%04X pciPID=%04X\n",
2278                                ftdi->platform_data.vendor, pciVID,
2279                                ftdi->platform_data.device, pciPID);
2280                        return -ENODEV;
2281                }
2282        }
2283}
2284
2285
2286#define ftdi_read_pcimem(ftdi, member, data) ftdi_elan_read_pcimem(ftdi, \
2287        offsetof(struct ohci_regs, member), 0, data);
2288#define ftdi_write_pcimem(ftdi, member, data) ftdi_elan_write_pcimem(ftdi, \
2289        offsetof(struct ohci_regs, member), 0, data);
2290
2291#define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
2292#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
2293        OHCI_INTR_WDH)
2294static int ftdi_elan_check_controller(struct usb_ftdi *ftdi, int quirk)
2295{
2296        int devices = 0;
2297        int retval;
2298        u32 hc_control;
2299        int num_ports;
2300        u32 control;
2301        u32 rh_a = -1;
2302        u32 status;
2303        u32 fminterval;
2304        u32 hc_fminterval;
2305        u32 periodicstart;
2306        u32 cmdstatus;
2307        u32 roothub_a;
2308        int mask = OHCI_INTR_INIT;
2309        int sleep_time = 0;
2310        int reset_timeout = 30;        /* ... allow extra time */
2311        int temp;
2312        retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE);
2313        if (retval)
2314                return retval;
2315        retval = ftdi_read_pcimem(ftdi, control, &control);
2316        if (retval)
2317                return retval;
2318        retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a);
2319        if (retval)
2320                return retval;
2321        num_ports = rh_a & RH_A_NDP;
2322        retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval);
2323        if (retval)
2324                return retval;
2325        hc_fminterval &= 0x3fff;
2326        if (hc_fminterval != FI) {
2327        }
2328        hc_fminterval |= FSMP(hc_fminterval) << 16;
2329        retval = ftdi_read_pcimem(ftdi, control, &hc_control);
2330        if (retval)
2331                return retval;
2332        switch (hc_control & OHCI_CTRL_HCFS) {
2333        case OHCI_USB_OPER:
2334                sleep_time = 0;
2335                break;
2336        case OHCI_USB_SUSPEND:
2337        case OHCI_USB_RESUME:
2338                hc_control &= OHCI_CTRL_RWC;
2339                hc_control |= OHCI_USB_RESUME;
2340                sleep_time = 10;
2341                break;
2342        default:
2343                hc_control &= OHCI_CTRL_RWC;
2344                hc_control |= OHCI_USB_RESET;
2345                sleep_time = 50;
2346                break;
2347        }
2348        retval = ftdi_write_pcimem(ftdi, control, hc_control);
2349        if (retval)
2350                return retval;
2351        retval = ftdi_read_pcimem(ftdi, control, &control);
2352        if (retval)
2353                return retval;
2354        msleep(sleep_time);
2355        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
2356        if (retval)
2357                return retval;
2358        if (!(roothub_a & RH_A_NPS)) {        /* power down each port */
2359                for (temp = 0; temp < num_ports; temp++) {
2360                        retval = ftdi_write_pcimem(ftdi,
2361                                roothub.portstatus[temp], RH_PS_LSDA);
2362                        if (retval)
2363                                return retval;
2364                }
2365        }
2366        retval = ftdi_read_pcimem(ftdi, control, &control);
2367        if (retval)
2368                return retval;
2369      retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
2370        if (retval)
2371                return retval;
2372        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR);
2373        if (retval)
2374                return retval;
2375      extra:{
2376                retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
2377                if (retval)
2378                        return retval;
2379                if (0 != (status & OHCI_HCR)) {
2380                        if (--reset_timeout == 0) {
2381                                dev_err(&ftdi->udev->dev, "USB HC reset timed o"
2382                                        "ut!\n");
2383                                return -ENODEV;
2384                        } else {
2385                                msleep(5);
2386                                goto extra;
2387                        }
2388                }
2389        }
2390        if (quirk & OHCI_QUIRK_INITRESET) {
2391                retval = ftdi_write_pcimem(ftdi, control, hc_control);
2392                if (retval)
2393                        return retval;
2394                retval = ftdi_read_pcimem(ftdi, control, &control);
2395                if (retval)
2396                        return retval;
2397        }
2398        retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000);
2399        if (retval)
2400                return retval;
2401        retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000);
2402        if (retval)
2403                return retval;
2404        retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000);
2405        if (retval)
2406                return retval;
2407        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
2408        if (retval)
2409                return retval;
2410        retval = ftdi_write_pcimem(ftdi, fminterval,
2411                ((fminterval & FIT) ^ FIT) | hc_fminterval);
2412        if (retval)
2413                return retval;
2414        retval = ftdi_write_pcimem(ftdi, periodicstart,
2415                ((9 *hc_fminterval) / 10) & 0x3fff);
2416        if (retval)
2417                return retval;
2418        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
2419        if (retval)
2420                return retval;
2421        retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart);
2422        if (retval)
2423                return retval;
2424        if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
2425                if (!(quirk & OHCI_QUIRK_INITRESET)) {
2426                        quirk |= OHCI_QUIRK_INITRESET;
2427                        goto retry;
2428                } else
2429                        dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n",
2430                                fminterval, periodicstart);
2431        }                        /* start controller operations */
2432        hc_control &= OHCI_CTRL_RWC;
2433        hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
2434        retval = ftdi_write_pcimem(ftdi, control, hc_control);
2435        if (retval)
2436                return retval;
2437        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF);
2438        if (retval)
2439                return retval;
2440        retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus);
2441        if (retval)
2442                return retval;
2443        retval = ftdi_read_pcimem(ftdi, control, &control);
2444        if (retval)
2445                return retval;
2446        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE);
2447        if (retval)
2448                return retval;
2449        retval = ftdi_write_pcimem(ftdi, intrstatus, mask);
2450        if (retval)
2451                return retval;
2452        retval = ftdi_write_pcimem(ftdi, intrdisable,
2453                OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
2454                OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
2455                OHCI_INTR_SO);
2456        if (retval)
2457                return retval;        /* handle root hub init quirks ... */
2458        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
2459        if (retval)
2460                return retval;
2461        roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
2462        if (quirk & OHCI_QUIRK_SUPERIO) {
2463                roothub_a |= RH_A_NOCP;
2464                roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
2465                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
2466                if (retval)
2467                        return retval;
2468        } else if ((quirk & OHCI_QUIRK_AMD756) || distrust_firmware) {
2469                roothub_a |= RH_A_NPS;
2470                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
2471                if (retval)
2472                        return retval;
2473        }
2474        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC);
2475        if (retval)
2476                return retval;
2477        retval = ftdi_write_pcimem(ftdi, roothub.b,
2478                (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
2479        if (retval)
2480                return retval;
2481        retval = ftdi_read_pcimem(ftdi, control, &control);
2482        if (retval)
2483                return retval;
2484        mdelay((roothub_a >> 23) & 0x1fe);
2485        for (temp = 0; temp < num_ports; temp++) {
2486                u32 portstatus;
2487                retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp],
2488                        &portstatus);
2489                if (retval)
2490                        return retval;
2491                if (1 & portstatus)
2492                        devices += 1;
2493        }
2494        return devices;
2495}
2496
2497static int ftdi_elan_setup_controller(struct usb_ftdi *ftdi, int fn)
2498{
2499        u32 latence_timer;
2500        int UxxxStatus;
2501        u32 pcidata;
2502        int reg = 0;
2503        int activePCIfn = fn << 8;
2504        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
2505        if (UxxxStatus)
2506                return UxxxStatus;
2507        reg = 16;
2508        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2509                0xFFFFFFFF);
2510        if (UxxxStatus)
2511                return UxxxStatus;
2512        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2513                &pcidata);
2514        if (UxxxStatus)
2515                return UxxxStatus;
2516        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2517                0xF0000000);
2518        if (UxxxStatus)
2519                return UxxxStatus;
2520        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2521                &pcidata);
2522        if (UxxxStatus)
2523                return UxxxStatus;
2524        reg = 12;
2525        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2526                &latence_timer);
2527        if (UxxxStatus)
2528                return UxxxStatus;
2529        latence_timer &= 0xFFFF00FF;
2530        latence_timer |= 0x00001600;
2531        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2532                latence_timer);
2533        if (UxxxStatus)
2534                return UxxxStatus;
2535        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2536                &pcidata);
2537        if (UxxxStatus)
2538                return UxxxStatus;
2539        reg = 4;
2540        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2541                0x06);
2542        if (UxxxStatus)
2543                return UxxxStatus;
2544        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2545                &pcidata);
2546        if (UxxxStatus)
2547                return UxxxStatus;
2548        for (reg = 0; reg <= 0x54; reg += 4) {
2549                UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata);
2550                if (UxxxStatus)
2551                        return UxxxStatus;
2552        }
2553        return 0;
2554}
2555
2556static int ftdi_elan_close_controller(struct usb_ftdi *ftdi, int fn)
2557{
2558        u32 latence_timer;
2559        int UxxxStatus;
2560        u32 pcidata;
2561        int reg = 0;
2562        int activePCIfn = fn << 8;
2563        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
2564        if (UxxxStatus)
2565                return UxxxStatus;
2566        reg = 16;
2567        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2568                0xFFFFFFFF);
2569        if (UxxxStatus)
2570                return UxxxStatus;
2571        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2572                &pcidata);
2573        if (UxxxStatus)
2574                return UxxxStatus;
2575        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2576                0x00000000);
2577        if (UxxxStatus)
2578                return UxxxStatus;
2579        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2580                &pcidata);
2581        if (UxxxStatus)
2582                return UxxxStatus;
2583        reg = 12;
2584        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2585                &latence_timer);
2586        if (UxxxStatus)
2587                return UxxxStatus;
2588        latence_timer &= 0xFFFF00FF;
2589        latence_timer |= 0x00001600;
2590        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2591                latence_timer);
2592        if (UxxxStatus)
2593                return UxxxStatus;
2594        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2595                &pcidata);
2596        if (UxxxStatus)
2597                return UxxxStatus;
2598        reg = 4;
2599        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2600                0x00);
2601        if (UxxxStatus)
2602                return UxxxStatus;
2603        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2604                &pcidata);
2605        if (UxxxStatus)
2606                return UxxxStatus;
2607        return 0;
2608}
2609
2610static int ftdi_elan_found_controller(struct usb_ftdi *ftdi, int fn, int quirk)
2611{
2612        int result;
2613        int UxxxStatus;
2614        UxxxStatus = ftdi_elan_setup_controller(ftdi, fn);
2615        if (UxxxStatus)
2616                return UxxxStatus;
2617        result = ftdi_elan_check_controller(ftdi, quirk);
2618        UxxxStatus = ftdi_elan_close_controller(ftdi, fn);
2619        if (UxxxStatus)
2620                return UxxxStatus;
2621        return result;
2622}
2623
2624static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi)
2625{
2626        u32 controlreg;
2627        u8 sensebits;
2628        int UxxxStatus;
2629        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2630        if (UxxxStatus)
2631                return UxxxStatus;
2632        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L);
2633        if (UxxxStatus)
2634                return UxxxStatus;
2635        msleep(750);
2636        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100);
2637        if (UxxxStatus)
2638                return UxxxStatus;
2639        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500);
2640        if (UxxxStatus)
2641                return UxxxStatus;
2642        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2643        if (UxxxStatus)
2644                return UxxxStatus;
2645        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000);
2646        if (UxxxStatus)
2647                return UxxxStatus;
2648        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000);
2649        if (UxxxStatus)
2650                return UxxxStatus;
2651        msleep(250);
2652        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000);
2653        if (UxxxStatus)
2654                return UxxxStatus;
2655        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2656        if (UxxxStatus)
2657                return UxxxStatus;
2658        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800);
2659        if (UxxxStatus)
2660                return UxxxStatus;
2661        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2662        if (UxxxStatus)
2663                return UxxxStatus;
2664        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2665        if (UxxxStatus)
2666                return UxxxStatus;
2667        msleep(1000);
2668        sensebits = (controlreg >> 16) & 0x000F;
2669        if (0x0D == sensebits)
2670                return 0;
2671        else
2672                return - ENXIO;
2673}
2674
2675static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi)
2676{
2677        int UxxxStatus;
2678        u32 pcidata;
2679        int reg = 0;
2680        u8 fn;
2681        int activePCIfn = 0;
2682        int max_devices = 0;
2683        int controllers = 0;
2684        int unrecognized = 0;
2685        ftdi->function = 0;
2686        for (fn = 0; (fn < 4); fn++) {
2687                u32 pciVID = 0;
2688                u32 pciPID = 0;
2689                int devices = 0;
2690                activePCIfn = fn << 8;
2691                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2692                        &pcidata);
2693                if (UxxxStatus)
2694                        return UxxxStatus;
2695                pciVID = pcidata & 0xFFFF;
2696                pciPID = (pcidata >> 16) & 0xFFFF;
2697                if ((pciVID == PCI_VENDOR_ID_OPTI) && (pciPID == 0xc861)) {
2698                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
2699                        controllers += 1;
2700                } else if ((pciVID == PCI_VENDOR_ID_NEC) && (pciPID == 0x0035))
2701                        {
2702                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
2703                        controllers += 1;
2704                } else if ((pciVID == PCI_VENDOR_ID_AL) && (pciPID == 0x5237)) {
2705                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
2706                        controllers += 1;
2707                } else if ((pciVID == PCI_VENDOR_ID_ATT) && (pciPID == 0x5802))
2708                        {
2709                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
2710                        controllers += 1;
2711                } else if (pciVID == PCI_VENDOR_ID_AMD && pciPID == 0x740c) {
2712                        devices = ftdi_elan_found_controller(ftdi, fn,
2713                                OHCI_QUIRK_AMD756);
2714                        controllers += 1;
2715                } else if (pciVID == PCI_VENDOR_ID_COMPAQ && pciPID == 0xa0f8) {
2716                        devices = ftdi_elan_found_controller(ftdi, fn,
2717                                OHCI_QUIRK_ZFMICRO);
2718                        controllers += 1;
2719                } else if (0 == pcidata) {
2720                } else
2721                        unrecognized += 1;
2722                if (devices > max_devices) {
2723                        max_devices = devices;
2724                        ftdi->function = fn + 1;
2725                        ftdi->platform_data.vendor = pciVID;
2726                        ftdi->platform_data.device = pciPID;
2727                }
2728        }
2729        if (ftdi->function > 0) {
2730                UxxxStatus = ftdi_elan_setup_controller(ftdi,
2731                        ftdi->function - 1);
2732                if (UxxxStatus)
2733                        return UxxxStatus;
2734                return 0;
2735        } else if (controllers > 0) {
2736                return -ENXIO;
2737        } else if (unrecognized > 0) {
2738                return -ENXIO;
2739        } else {
2740                ftdi->enumerated = 0;
2741                return -ENXIO;
2742        }
2743}
2744
2745
2746/*
2747* we use only the first bulk-in and bulk-out endpoints
2748*/
2749static int ftdi_elan_probe(struct usb_interface *interface,
2750        const struct usb_device_id *id)
2751{
2752        struct usb_host_interface *iface_desc;
2753        struct usb_endpoint_descriptor *endpoint;
2754        size_t buffer_size;
2755        int i;
2756        int retval = -ENOMEM;
2757        struct usb_ftdi *ftdi;
2758
2759        ftdi = kzalloc(sizeof(struct usb_ftdi), GFP_KERNEL);
2760        if (!ftdi) {
2761                printk(KERN_ERR "Out of memory\n");
2762                return -ENOMEM;
2763        }
2764
2765        mutex_lock(&ftdi_module_lock);
2766        list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
2767        ftdi->sequence_num = ++ftdi_instances;
2768        mutex_unlock(&ftdi_module_lock);
2769        ftdi_elan_init_kref(ftdi);
2770        sema_init(&ftdi->sw_lock, 1);
2771        ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
2772        ftdi->interface = interface;
2773        mutex_init(&ftdi->u132_lock);
2774        ftdi->expected = 4;
2775        iface_desc = interface->cur_altsetting;
2776        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2777                endpoint = &iface_desc->endpoint[i].desc;
2778                if (!ftdi->bulk_in_endpointAddr &&
2779                    usb_endpoint_is_bulk_in(endpoint)) {
2780                        buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
2781                        ftdi->bulk_in_size = buffer_size;
2782                        ftdi->bulk_in_endpointAddr = endpoint->bEndpointAddress;
2783                        ftdi->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
2784                        if (!ftdi->bulk_in_buffer) {
2785                                dev_err(&ftdi->udev->dev, "Could not allocate b"
2786                                        "ulk_in_buffer\n");
2787                                retval = -ENOMEM;
2788                                goto error;
2789                        }
2790                }
2791                if (!ftdi->bulk_out_endpointAddr &&
2792                    usb_endpoint_is_bulk_out(endpoint)) {
2793                        ftdi->bulk_out_endpointAddr =
2794                                endpoint->bEndpointAddress;
2795                }
2796        }
2797        if (!(ftdi->bulk_in_endpointAddr && ftdi->bulk_out_endpointAddr)) {
2798                dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk"
2799                        "-out endpoints\n");
2800                retval = -ENODEV;
2801                goto error;
2802        }
2803        dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n",
2804                iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr,
2805                ftdi->bulk_out_endpointAddr);
2806        usb_set_intfdata(interface, ftdi);
2807        if (iface_desc->desc.bInterfaceNumber == 0 &&
2808                ftdi->bulk_in_endpointAddr == 0x81 &&
2809                ftdi->bulk_out_endpointAddr == 0x02) {
2810                retval = usb_register_dev(interface, &ftdi_elan_jtag_class);
2811                if (retval) {
2812                        dev_err(&ftdi->udev->dev, "Not able to get a minor for "
2813                                "this device.\n");
2814                        usb_set_intfdata(interface, NULL);
2815                        retval = -ENOMEM;
2816                        goto error;
2817                } else {
2818                        ftdi->class = &ftdi_elan_jtag_class;
2819                        dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface "
2820                                "%d now attached to ftdi%d\n", ftdi,
2821                                iface_desc->desc.bInterfaceNumber,
2822                                interface->minor);
2823                        return 0;
2824                }
2825        } else if (iface_desc->desc.bInterfaceNumber == 1 &&
2826                ftdi->bulk_in_endpointAddr == 0x83 &&
2827                ftdi->bulk_out_endpointAddr == 0x04) {
2828                ftdi->class = NULL;
2829                dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now a"
2830                        "ctivated\n", ftdi, iface_desc->desc.bInterfaceNumber);
2831                INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
2832                INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
2833                INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
2834                ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
2835                return 0;
2836        } else {
2837                dev_err(&ftdi->udev->dev,
2838                        "Could not find ELAN's U132 device\n");
2839                retval = -ENODEV;
2840                goto error;
2841        }
2842      error:if (ftdi) {
2843                ftdi_elan_put_kref(ftdi);
2844        }
2845        return retval;
2846}
2847
2848static void ftdi_elan_disconnect(struct usb_interface *interface)
2849{
2850        struct usb_ftdi *ftdi = usb_get_intfdata(interface);
2851        ftdi->disconnected += 1;
2852        if (ftdi->class) {
2853                int minor = interface->minor;
2854                struct usb_class_driver *class = ftdi->class;
2855                usb_set_intfdata(interface, NULL);
2856                usb_deregister_dev(interface, class);
2857                dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on min"
2858                        "or %d now disconnected\n", minor);
2859        } else {
2860                ftdi_status_cancel_work(ftdi);
2861                ftdi_command_cancel_work(ftdi);
2862                ftdi_response_cancel_work(ftdi);
2863                ftdi_elan_abandon_completions(ftdi);
2864                ftdi_elan_abandon_targets(ftdi);
2865                if (ftdi->registered) {
2866                        platform_device_unregister(&ftdi->platform_dev);
2867                        ftdi->synchronized = 0;
2868                        ftdi->enumerated = 0;
2869                        ftdi->initialized = 0;
2870                        ftdi->registered = 0;
2871                }
2872                flush_workqueue(status_queue);
2873                flush_workqueue(command_queue);
2874                flush_workqueue(respond_queue);
2875                ftdi->disconnected += 1;
2876                usb_set_intfdata(interface, NULL);
2877                dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller inter"
2878                        "face now disconnected\n");
2879        }
2880        ftdi_elan_put_kref(ftdi);
2881}
2882
2883static struct usb_driver ftdi_elan_driver = {
2884        .name = "ftdi-elan",
2885        .probe = ftdi_elan_probe,
2886        .disconnect = ftdi_elan_disconnect,
2887        .id_table = ftdi_elan_table,
2888};
2889static int __init ftdi_elan_init(void)
2890{
2891        int result;
2892        printk(KERN_INFO "driver %s built at %s on %s\n", ftdi_elan_driver.name,
2893               __TIME__, __DATE__);
2894        mutex_init(&ftdi_module_lock);
2895        INIT_LIST_HEAD(&ftdi_static_list);
2896        status_queue = create_singlethread_workqueue("ftdi-status-control");
2897        if (!status_queue)
2898                goto err_status_queue;
2899        command_queue = create_singlethread_workqueue("ftdi-command-engine");
2900        if (!command_queue)
2901                goto err_command_queue;
2902        respond_queue = create_singlethread_workqueue("ftdi-respond-engine");
2903        if (!respond_queue)
2904                goto err_respond_queue;
2905        result = usb_register(&ftdi_elan_driver);
2906        if (result) {
2907                destroy_workqueue(status_queue);
2908                destroy_workqueue(command_queue);
2909                destroy_workqueue(respond_queue);
2910                printk(KERN_ERR "usb_register failed. Error number %d\n",
2911                       result);
2912        }
2913        return result;
2914
2915 err_respond_queue:
2916        destroy_workqueue(command_queue);
2917 err_command_queue:
2918        destroy_workqueue(status_queue);
2919 err_status_queue:
2920        printk(KERN_ERR "%s couldn't create workqueue\n", ftdi_elan_driver.name);
2921        return -ENOMEM;
2922}
2923
2924static void __exit ftdi_elan_exit(void)
2925{
2926        struct usb_ftdi *ftdi;
2927        struct usb_ftdi *temp;
2928        usb_deregister(&ftdi_elan_driver);
2929        printk(KERN_INFO "ftdi_u132 driver deregistered\n");
2930        list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) {
2931                ftdi_status_cancel_work(ftdi);
2932                ftdi_command_cancel_work(ftdi);
2933                ftdi_response_cancel_work(ftdi);
2934        } flush_workqueue(status_queue);
2935        destroy_workqueue(status_queue);
2936        status_queue = NULL;
2937        flush_workqueue(command_queue);
2938        destroy_workqueue(command_queue);
2939        command_queue = NULL;
2940        flush_workqueue(respond_queue);
2941        destroy_workqueue(respond_queue);
2942        respond_queue = NULL;
2943}
2944
2945
2946module_init(ftdi_elan_init);
2947module_exit(ftdi_elan_exit);
2948