drivers/usb/gadget/ci13xxx_udc.c

   1 /*
   2  * ci13xxx_udc.c - MIPS USB IP core family device controller
   3  *
   4  * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
   5  *
   6  * Author: David Lopo
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 /*
  14  * Description: MIPS USB IP core family device controller
  15  *              Currently it only supports IP part number CI13412
  16  *
  17  * This driver is composed of several blocks:
  18  * - HW:     hardware interface
  19  * - DBG:    debug facilities (optional)
  20  * - UTIL:   utilities
  21  * - ISR:    interrupts handling
  22  * - ENDPT:  endpoint operations (Gadget API)
  23  * - GADGET: gadget operations (Gadget API)
  24  * - BUS:    bus glue code, bus abstraction layer
  25  *
  26  * Compile Options
  27  * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
  28  * - STALL_IN:  non-empty bulk-in pipes cannot be halted
  29  *              if defined mass storage compliance succeeds but with warnings
  30  *              => case 4: Hi >  Dn
  31  *              => case 5: Hi >  Di
  32  *              => case 8: Hi <> Do
  33  *              if undefined usbtest 13 fails
  34  * - TRACE:     enable function tracing (depends on DEBUG)
  35  *
  36  * Main Features
  37  * - Chapter 9 & Mass Storage Compliance with Gadget File Storage
  38  * - Chapter 9 Compliance with Gadget Zero (STALL_IN undefined)
  39  * - Normal & LPM support
  40  *
  41  * USBTEST Report
  42  * - OK: 0-12, 13 (STALL_IN defined) & 14
  43  * - Not Supported: 15 & 16 (ISO)
  44  *
  45  * TODO List
  46  * - OTG
  47  * - Isochronous & Interrupt Traffic
  48  * - Handle requests which spawns into several TDs
  49  * - GET_STATUS(device) - always reports 0
  50  * - Gadget API (majority of optional features)
  51  * - Suspend & Remote Wakeup
  52  */
  53 #include <linux/delay.h>
  54 #include <linux/device.h>
  55 #include <linux/dmapool.h>
  56 #include <linux/dma-mapping.h>
  57 #include <linux/init.h>
  58 #include <linux/interrupt.h>
  59 #include <linux/io.h>
  60 #include <linux/irq.h>
  61 #include <linux/kernel.h>
  62 #include <linux/slab.h>
  63 #include <linux/pm_runtime.h>
  64 #include <linux/usb/ch9.h>
  65 #include <linux/usb/gadget.h>
  66 #include <linux/usb/otg.h>
  67
  68 #include "ci13xxx_udc.h"
  69
  70
  71 /******************************************************************************
  72  * DEFINE
  73  *****************************************************************************/
  74 /* ctrl register bank access */
  75 static DEFINE_SPINLOCK(udc_lock);
  76
  77 /* control endpoint description */
  78 static const struct usb_endpoint_descriptor
  79 ctrl_endpt_desc = {
  80         .bLength         = USB_DT_ENDPOINT_SIZE,
  81         .bDescriptorType = USB_DT_ENDPOINT,
  82
  83         .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
  84         .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
  85 };
  86
  87 /* UDC descriptor */
  88 static struct ci13xxx *_udc;
  89
  90 /* Interrupt statistics */
  91 #define ISR_MASK   0x1F
  92 static struct {
  93         u32 test;
  94         u32 ui;
  95         u32 uei;
  96         u32 pci;
  97         u32 uri;
  98         u32 sli;
  99         u32 none;
 100         struct {
 101                 u32 cnt;
 102                 u32 buf[ISR_MASK+1];
 103                 u32 idx;
 104         } hndl;
 105 } isr_statistics;
 106
 107 /**
 108  * ffs_nr: find first (least significant) bit set
 109  * @x: the word to search
 110  *
 111  * This function returns bit number (instead of position)
 112  */
 113 static int ffs_nr(u32 x)
 114 {
 115         int n = ffs(x);
 116
 117         return n ? n-1 : 32;
 118 }
 119
 120 /******************************************************************************
 121  * HW block
 122  *****************************************************************************/
 123 /* register bank descriptor */
 124 static struct {
 125         unsigned      lpm;    /* is LPM? */
 126         void __iomem *abs;    /* bus map offset */
 127         void __iomem *cap;    /* bus map offset + CAP offset + CAP data */
 128         size_t        size;   /* bank size */
 129 } hw_bank;
 130
 131 /* MSM specific */
 132 #define ABS_AHBBURST        (0x0090UL)
 133 #define ABS_AHBMODE         (0x0098UL)
 134 /* UDC register map */
 135 #define ABS_CAPLENGTH       (0x100UL)
 136 #define ABS_HCCPARAMS       (0x108UL)
 137 #define ABS_DCCPARAMS       (0x124UL)
 138 #define ABS_TESTMODE        (hw_bank.lpm ? 0x0FCUL : 0x138UL)
 139 /* offset to CAPLENTGH (addr + data) */
 140 #define CAP_USBCMD          (0x000UL)
 141 #define CAP_USBSTS          (0x004UL)
 142 #define CAP_USBINTR         (0x008UL)
 143 #define CAP_DEVICEADDR      (0x014UL)
 144 #define CAP_ENDPTLISTADDR   (0x018UL)
 145 #define CAP_PORTSC          (0x044UL)
 146 #define CAP_DEVLC           (0x084UL)
 147 #define CAP_USBMODE         (hw_bank.lpm ? 0x0C8UL : 0x068UL)
 148 #define CAP_ENDPTSETUPSTAT  (hw_bank.lpm ? 0x0D8UL : 0x06CUL)
 149 #define CAP_ENDPTPRIME      (hw_bank.lpm ? 0x0DCUL : 0x070UL)
 150 #define CAP_ENDPTFLUSH      (hw_bank.lpm ? 0x0E0UL : 0x074UL)
 151 #define CAP_ENDPTSTAT       (hw_bank.lpm ? 0x0E4UL : 0x078UL)
 152 #define CAP_ENDPTCOMPLETE   (hw_bank.lpm ? 0x0E8UL : 0x07CUL)
 153 #define CAP_ENDPTCTRL       (hw_bank.lpm ? 0x0ECUL : 0x080UL)
 154 #define CAP_LAST            (hw_bank.lpm ? 0x12CUL : 0x0C0UL)
 155
 156 /* maximum number of enpoints: valid only after hw_device_reset() */
 157 static unsigned hw_ep_max;
 158
 159 /**
 160  * hw_ep_bit: calculates the bit number
 161  * @num: endpoint number
 162  * @dir: endpoint direction
 163  *
 164  * This function returns bit number
 165  */
 166 static inline int hw_ep_bit(int num, int dir)
 167 {
 168         return num + (dir ? 16 : 0);
 169 }
 170
 171 /**
 172  * hw_aread: reads from register bitfield
 173  * @addr: address relative to bus map
 174  * @mask: bitfield mask
 175  *
 176  * This function returns register bitfield data
 177  */
 178 static u32 hw_aread(u32 addr, u32 mask)
 179 {
 180         return ioread32(addr + hw_bank.abs) & mask;
 181 }
 182
 183 /**
 184  * hw_awrite: writes to register bitfield
 185  * @addr: address relative to bus map
 186  * @mask: bitfield mask
 187  * @data: new data
 188  */
 189 static void hw_awrite(u32 addr, u32 mask, u32 data)
 190 {
 191         iowrite32(hw_aread(addr, ~mask) | (data & mask),
 192                   addr + hw_bank.abs);
 193 }
 194
 195 /**
 196  * hw_cread: reads from register bitfield
 197  * @addr: address relative to CAP offset plus content
 198  * @mask: bitfield mask
 199  *
 200  * This function returns register bitfield data
 201  */
 202 static u32 hw_cread(u32 addr, u32 mask)
 203 {
 204         return ioread32(addr + hw_bank.cap) & mask;
 205 }
 206
 207 /**
 208  * hw_cwrite: writes to register bitfield
 209  * @addr: address relative to CAP offset plus content
 210  * @mask: bitfield mask
 211  * @data: new data
 212  */
 213 static void hw_cwrite(u32 addr, u32 mask, u32 data)
 214 {
 215         iowrite32(hw_cread(addr, ~mask) | (data & mask),
 216                   addr + hw_bank.cap);
 217 }
 218
 219 /**
 220  * hw_ctest_and_clear: tests & clears register bitfield
 221  * @addr: address relative to CAP offset plus content
 222  * @mask: bitfield mask
 223  *
 224  * This function returns register bitfield data
 225  */
 226 static u32 hw_ctest_and_clear(u32 addr, u32 mask)
 227 {
 228         u32 reg = hw_cread(addr, mask);
 229
 230         iowrite32(reg, addr + hw_bank.cap);
 231         return reg;
 232 }
 233
 234 /**
 235  * hw_ctest_and_write: tests & writes register bitfield
 236  * @addr: address relative to CAP offset plus content
 237  * @mask: bitfield mask
 238  * @data: new data
 239  *
 240  * This function returns register bitfield data
 241  */
 242 static u32 hw_ctest_and_write(u32 addr, u32 mask, u32 data)
 243 {
 244         u32 reg = hw_cread(addr, ~0);
 245
 246         iowrite32((reg & ~mask) | (data & mask), addr + hw_bank.cap);
 247         return (reg & mask) >> ffs_nr(mask);
 248 }
 249
 250 static int hw_device_init(void __iomem *base)
 251 {
 252         u32 reg;
 253
 254         /* bank is a module variable */
 255         hw_bank.abs = base;
 256
 257         hw_bank.cap = hw_bank.abs;
 258         hw_bank.cap += ABS_CAPLENGTH;
 259         hw_bank.cap += ioread8(hw_bank.cap);
 260
 261         reg = hw_aread(ABS_HCCPARAMS, HCCPARAMS_LEN) >> ffs_nr(HCCPARAMS_LEN);
 262         hw_bank.lpm  = reg;
 263         hw_bank.size = hw_bank.cap - hw_bank.abs;
 264         hw_bank.size += CAP_LAST;
 265         hw_bank.size /= sizeof(u32);
 266
 267         reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
 268         if (reg == 0 || reg > ENDPT_MAX)
 269                 return -ENODEV;
 270
 271         hw_ep_max = reg;   /* cache hw ENDPT_MAX */
 272
 273         /* setup lock mode ? */
 274
 275         /* ENDPTSETUPSTAT is '0' by default */
 276
 277         /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
 278
 279         return 0;
 280 }
 281 /**
 282  * hw_device_reset: resets chip (execute without interruption)
 283  * @base: register base address
 284  *
 285  * This function returns an error code
 286  */
 287 static int hw_device_reset(struct ci13xxx *udc)
 288 {
 289         /* should flush & stop before reset */
 290         hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0);
 291         hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
 292
 293         hw_cwrite(CAP_USBCMD, USBCMD_RST, USBCMD_RST);
 294         while (hw_cread(CAP_USBCMD, USBCMD_RST))
 295                 udelay(10);             /* not RTOS friendly */
 296
 297
 298         if (udc->udc_driver->notify_event)
 299                 udc->udc_driver->notify_event(udc,
 300                         CI13XXX_CONTROLLER_RESET_EVENT);
 301
 302         if (udc->udc_driver->flags && CI13XXX_DISABLE_STREAMING)
 303                 hw_cwrite(CAP_USBMODE, USBMODE_SDIS, USBMODE_SDIS);
 304
 305         /* USBMODE should be configured step by step */
 306         hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_IDLE);
 307         hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_DEVICE);
 308         hw_cwrite(CAP_USBMODE, USBMODE_SLOM, USBMODE_SLOM);  /* HW >= 2.3 */
 309
 310         if (hw_cread(CAP_USBMODE, USBMODE_CM) != USBMODE_CM_DEVICE) {
 311                 pr_err("cannot enter in device mode");
 312                 pr_err("lpm = %i", hw_bank.lpm);
 313                 return -ENODEV;
 314         }
 315
 316         return 0;
 317 }
 318
 319 /**
 320  * hw_device_state: enables/disables interrupts & starts/stops device (execute
 321  *                  without interruption)
 322  * @dma: 0 => disable, !0 => enable and set dma engine
 323  *
 324  * This function returns an error code
 325  */
 326 static int hw_device_state(u32 dma)
 327 {
 328         if (dma) {
 329                 hw_cwrite(CAP_ENDPTLISTADDR, ~0, dma);
 330                 /* interrupt, error, port change, reset, sleep/suspend */
 331                 hw_cwrite(CAP_USBINTR, ~0,
 332                              USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
 333                 hw_cwrite(CAP_USBCMD, USBCMD_RS, USBCMD_RS);
 334         } else {
 335                 hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
 336                 hw_cwrite(CAP_USBINTR, ~0, 0);
 337         }
 338         return 0;
 339 }
 340
 341 /**
 342  * hw_ep_flush: flush endpoint fifo (execute without interruption)
 343  * @num: endpoint number
 344  * @dir: endpoint direction
 345  *
 346  * This function returns an error code
 347  */
 348 static int hw_ep_flush(int num, int dir)
 349 {
 350         int n = hw_ep_bit(num, dir);
 351
 352         do {
 353                 /* flush any pending transfer */
 354                 hw_cwrite(CAP_ENDPTFLUSH, BIT(n), BIT(n));
 355                 while (hw_cread(CAP_ENDPTFLUSH, BIT(n)))
 356                         cpu_relax();
 357         } while (hw_cread(CAP_ENDPTSTAT, BIT(n)));
 358
 359         return 0;
 360 }
 361
 362 /**
 363  * hw_ep_disable: disables endpoint (execute without interruption)
 364  * @num: endpoint number
 365  * @dir: endpoint direction
 366  *
 367  * This function returns an error code
 368  */
 369 static int hw_ep_disable(int num, int dir)
 370 {
 371         hw_ep_flush(num, dir);
 372         hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32),
 373                   dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
 374         return 0;
 375 }
 376
 377 /**
 378  * hw_ep_enable: enables endpoint (execute without interruption)
 379  * @num:  endpoint number
 380  * @dir:  endpoint direction
 381  * @type: endpoint type
 382  *
 383  * This function returns an error code
 384  */
 385 static int hw_ep_enable(int num, int dir, int type)
 386 {
 387         u32 mask, data;
 388
 389         if (dir) {
 390                 mask  = ENDPTCTRL_TXT;  /* type    */
 391                 data  = type << ffs_nr(mask);
 392
 393                 mask |= ENDPTCTRL_TXS;  /* unstall */
 394                 mask |= ENDPTCTRL_TXR;  /* reset data toggle */
 395                 data |= ENDPTCTRL_TXR;
 396                 mask |= ENDPTCTRL_TXE;  /* enable  */
 397                 data |= ENDPTCTRL_TXE;
 398         } else {
 399                 mask  = ENDPTCTRL_RXT;  /* type    */
 400                 data  = type << ffs_nr(mask);
 401
 402                 mask |= ENDPTCTRL_RXS;  /* unstall */
 403                 mask |= ENDPTCTRL_RXR;  /* reset data toggle */
 404                 data |= ENDPTCTRL_RXR;
 405                 mask |= ENDPTCTRL_RXE;  /* enable  */
 406                 data |= ENDPTCTRL_RXE;
 407         }
 408         hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32), mask, data);
 409         return 0;
 410 }
 411
 412 /**
 413  * hw_ep_get_halt: return endpoint halt status
 414  * @num: endpoint number
 415  * @dir: endpoint direction
 416  *
 417  * This function returns 1 if endpoint halted
 418  */
 419 static int hw_ep_get_halt(int num, int dir)
 420 {
 421         u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
 422
 423         return hw_cread(CAP_ENDPTCTRL + num * sizeof(u32), mask) ? 1 : 0;
 424 }
 425
 426 /**
 427  * hw_ep_is_primed: test if endpoint is primed (execute without interruption)
 428  * @num:   endpoint number
 429  * @dir:   endpoint direction
 430  *
 431  * This function returns true if endpoint primed
 432  */
 433 static int hw_ep_is_primed(int num, int dir)
 434 {
 435         u32 reg = hw_cread(CAP_ENDPTPRIME, ~0) | hw_cread(CAP_ENDPTSTAT, ~0);
 436
 437         return test_bit(hw_ep_bit(num, dir), (void *)&reg);
 438 }
 439
 440 /**
 441  * hw_test_and_clear_setup_status: test & clear setup status (execute without
 442  *                                 interruption)
 443  * @n: bit number (endpoint)
 444  *
 445  * This function returns setup status
 446  */
 447 static int hw_test_and_clear_setup_status(int n)
 448 {
 449         return hw_ctest_and_clear(CAP_ENDPTSETUPSTAT, BIT(n));
 450 }
 451
 452 /**
 453  * hw_ep_prime: primes endpoint (execute without interruption)
 454  * @num:     endpoint number
 455  * @dir:     endpoint direction
 456  * @is_ctrl: true if control endpoint
 457  *
 458  * This function returns an error code
 459  */
 460 static int hw_ep_prime(int num, int dir, int is_ctrl)
 461 {
 462         int n = hw_ep_bit(num, dir);
 463
 464         /* the caller should flush first */
 465         if (hw_ep_is_primed(num, dir))
 466                 return -EBUSY;
 467
 468         if (is_ctrl && dir == RX && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
 469                 return -EAGAIN;
 470
 471         hw_cwrite(CAP_ENDPTPRIME, BIT(n), BIT(n));
 472
 473         while (hw_cread(CAP_ENDPTPRIME, BIT(n)))
 474                 cpu_relax();
 475         if (is_ctrl && dir == RX  && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
 476                 return -EAGAIN;
 477
 478         /* status shoult be tested according with manual but it doesn't work */
 479         return 0;
 480 }
 481
 482 /**
 483  * hw_ep_set_halt: configures ep halt & resets data toggle after clear (execute
 484  *                 without interruption)
 485  * @num:   endpoint number
 486  * @dir:   endpoint direction
 487  * @value: true => stall, false => unstall
 488  *
 489  * This function returns an error code
 490  */
 491 static int hw_ep_set_halt(int num, int dir, int value)
 492 {
 493         if (value != 0 && value != 1)
 494                 return -EINVAL;
 495
 496         do {
 497                 u32 addr = CAP_ENDPTCTRL + num * sizeof(u32);
 498                 u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
 499                 u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
 500
 501                 /* data toggle - reserved for EP0 but it's in ESS */
 502                 hw_cwrite(addr, mask_xs|mask_xr, value ? mask_xs : mask_xr);
 503
 504         } while (value != hw_ep_get_halt(num, dir));
 505
 506         return 0;
 507 }
 508
 509 /**
 510  * hw_intr_clear: disables interrupt & clears interrupt status (execute without
 511  *                interruption)
 512  * @n: interrupt bit
 513  *
 514  * This function returns an error code
 515  */
 516 static int hw_intr_clear(int n)
 517 {
 518         if (n >= REG_BITS)
 519                 return -EINVAL;
 520
 521         hw_cwrite(CAP_USBINTR, BIT(n), 0);
 522         hw_cwrite(CAP_USBSTS,  BIT(n), BIT(n));
 523         return 0;
 524 }
 525
 526 /**
 527  * hw_intr_force: enables interrupt & forces interrupt status (execute without
 528  *                interruption)
 529  * @n: interrupt bit
 530  *
 531  * This function returns an error code
 532  */
 533 static int hw_intr_force(int n)
 534 {
 535         if (n >= REG_BITS)
 536                 return -EINVAL;
 537
 538         hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
 539         hw_cwrite(CAP_USBINTR,  BIT(n), BIT(n));
 540         hw_cwrite(CAP_USBSTS,   BIT(n), BIT(n));
 541         hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, 0);
 542         return 0;
 543 }
 544
 545 /**
 546  * hw_is_port_high_speed: test if port is high speed
 547  *
 548  * This function returns true if high speed port
 549  */
 550 static int hw_port_is_high_speed(void)
 551 {
 552         return hw_bank.lpm ? hw_cread(CAP_DEVLC, DEVLC_PSPD) :
 553                 hw_cread(CAP_PORTSC, PORTSC_HSP);
 554 }
 555
 556 /**
 557  * hw_port_test_get: reads port test mode value
 558  *
 559  * This function returns port test mode value
 560  */
 561 static u8 hw_port_test_get(void)
 562 {
 563         return hw_cread(CAP_PORTSC, PORTSC_PTC) >> ffs_nr(PORTSC_PTC);
 564 }
 565
 566 /**
 567  * hw_port_test_set: writes port test mode (execute without interruption)
 568  * @mode: new value
 569  *
 570  * This function returns an error code
 571  */
 572 static int hw_port_test_set(u8 mode)
 573 {
 574         const u8 TEST_MODE_MAX = 7;
 575
 576         if (mode > TEST_MODE_MAX)
 577                 return -EINVAL;
 578
 579         hw_cwrite(CAP_PORTSC, PORTSC_PTC, mode << ffs_nr(PORTSC_PTC));
 580         return 0;
 581 }
 582
 583 /**
 584  * hw_read_intr_enable: returns interrupt enable register
 585  *
 586  * This function returns register data
 587  */
 588 static u32 hw_read_intr_enable(void)
 589 {
 590         return hw_cread(CAP_USBINTR, ~0);
 591 }
 592
 593 /**
 594  * hw_read_intr_status: returns interrupt status register
 595  *
 596  * This function returns register data
 597  */
 598 static u32 hw_read_intr_status(void)
 599 {
 600         return hw_cread(CAP_USBSTS, ~0);
 601 }
 602
 603 /**
 604  * hw_register_read: reads all device registers (execute without interruption)
 605  * @buf:  destination buffer
 606  * @size: buffer size
 607  *
 608  * This function returns number of registers read
 609  */
 610 static size_t hw_register_read(u32 *buf, size_t size)
 611 {
 612         unsigned i;
 613
 614         if (size > hw_bank.size)
 615                 size = hw_bank.size;
 616
 617         for (i = 0; i < size; i++)
 618                 buf[i] = hw_aread(i * sizeof(u32), ~0);
 619
 620         return size;
 621 }
 622
 623 /**
 624  * hw_register_write: writes to register
 625  * @addr: register address
 626  * @data: register value
 627  *
 628  * This function returns an error code
 629  */
 630 static int hw_register_write(u16 addr, u32 data)
 631 {
 632         /* align */
 633         addr /= sizeof(u32);
 634
 635         if (addr >= hw_bank.size)
 636                 return -EINVAL;
 637
 638         /* align */
 639         addr *= sizeof(u32);
 640
 641         hw_awrite(addr, ~0, data);
 642         return 0;
 643 }
 644
 645 /**
 646  * hw_test_and_clear_complete: test & clear complete status (execute without
 647  *                             interruption)
 648  * @n: bit number (endpoint)
 649  *
 650  * This function returns complete status
 651  */
 652 static int hw_test_and_clear_complete(int n)
 653 {
 654         return hw_ctest_and_clear(CAP_ENDPTCOMPLETE, BIT(n));
 655 }
 656
 657 /**
 658  * hw_test_and_clear_intr_active: test & clear active interrupts (execute
 659  *                                without interruption)
 660  *
 661  * This function returns active interrutps
 662  */
 663 static u32 hw_test_and_clear_intr_active(void)
 664 {
 665         u32 reg = hw_read_intr_status() & hw_read_intr_enable();
 666
 667         hw_cwrite(CAP_USBSTS, ~0, reg);
 668         return reg;
 669 }
 670
 671 /**
 672  * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
 673  *                                interruption)
 674  *
 675  * This function returns guard value
 676  */
 677 static int hw_test_and_clear_setup_guard(void)
 678 {
 679         return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, 0);
 680 }
 681
 682 /**
 683  * hw_test_and_set_setup_guard: test & set setup guard (execute without
 684  *                              interruption)
 685  *
 686  * This function returns guard value
 687  */
 688 static int hw_test_and_set_setup_guard(void)
 689 {
 690         return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
 691 }
 692
 693 /**
 694  * hw_usb_set_address: configures USB address (execute without interruption)
 695  * @value: new USB address
 696  *
 697  * This function returns an error code
 698  */
 699 static int hw_usb_set_address(u8 value)
 700 {
 701         /* advance */
 702         hw_cwrite(CAP_DEVICEADDR, DEVICEADDR_USBADR | DEVICEADDR_USBADRA,
 703                   value << ffs_nr(DEVICEADDR_USBADR) | DEVICEADDR_USBADRA);
 704         return 0;
 705 }
 706
 707 /**
 708  * hw_usb_reset: restart device after a bus reset (execute without
 709  *               interruption)
 710  *
 711  * This function returns an error code
 712  */
 713 static int hw_usb_reset(void)
 714 {
 715         hw_usb_set_address(0);
 716
 717         /* ESS flushes only at end?!? */
 718         hw_cwrite(CAP_ENDPTFLUSH,    ~0, ~0);   /* flush all EPs */
 719
 720         /* clear setup token semaphores */
 721         hw_cwrite(CAP_ENDPTSETUPSTAT, 0,  0);   /* writes its content */
 722
 723         /* clear complete status */
 724         hw_cwrite(CAP_ENDPTCOMPLETE,  0,  0);   /* writes its content */
 725
 726         /* wait until all bits cleared */
 727         while (hw_cread(CAP_ENDPTPRIME, ~0))
 728                 udelay(10);             /* not RTOS friendly */
 729
 730         /* reset all endpoints ? */
 731
 732         /* reset internal status and wait for further instructions
 733            no need to verify the port reset status (ESS does it) */
 734
 735         return 0;
 736 }
 737
 738 /******************************************************************************
 739  * DBG block
 740  *****************************************************************************/
 741 /**
 742  * show_device: prints information about device capabilities and status
 743  *
 744  * Check "device.h" for details
 745  */
 746 static ssize_t show_device(struct device *dev, struct device_attribute *attr,
 747                            char *buf)
 748 {
 749         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
 750         struct usb_gadget *gadget = &udc->gadget;
 751         int n = 0;
 752
 753         dbg_trace("[%s] %p\n", __func__, buf);
 754         if (attr == NULL || buf == NULL) {
 755                 dev_err(dev, "[%s] EINVAL\n", __func__);
 756                 return 0;
 757         }
 758
 759         n += scnprintf(buf + n, PAGE_SIZE - n, "speed             = %d\n",
 760                        gadget->speed);
 761         n += scnprintf(buf + n, PAGE_SIZE - n, "is_dualspeed      = %d\n",
 762                        gadget->is_dualspeed);
 763         n += scnprintf(buf + n, PAGE_SIZE - n, "is_otg            = %d\n",
 764                        gadget->is_otg);
 765         n += scnprintf(buf + n, PAGE_SIZE - n, "is_a_peripheral   = %d\n",
 766                        gadget->is_a_peripheral);
 767         n += scnprintf(buf + n, PAGE_SIZE - n, "b_hnp_enable      = %d\n",
 768                        gadget->b_hnp_enable);
 769         n += scnprintf(buf + n, PAGE_SIZE - n, "a_hnp_support     = %d\n",
 770                        gadget->a_hnp_support);
 771         n += scnprintf(buf + n, PAGE_SIZE - n, "a_alt_hnp_support = %d\n",
 772                        gadget->a_alt_hnp_support);
 773         n += scnprintf(buf + n, PAGE_SIZE - n, "name              = %s\n",
 774                        (gadget->name ? gadget->name : ""));
 775
 776         return n;
 777 }
 778 static DEVICE_ATTR(device, S_IRUSR, show_device, NULL);
 779
 780 /**
 781  * show_driver: prints information about attached gadget (if any)
 782  *
 783  * Check "device.h" for details
 784  */
 785 static ssize_t show_driver(struct device *dev, struct device_attribute *attr,
 786                            char *buf)
 787 {
 788         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
 789         struct usb_gadget_driver *driver = udc->driver;
 790         int n = 0;
 791
 792         dbg_trace("[%s] %p\n", __func__, buf);
 793         if (attr == NULL || buf == NULL) {
 794                 dev_err(dev, "[%s] EINVAL\n", __func__);
 795                 return 0;
 796         }
 797
 798         if (driver == NULL)
 799                 return scnprintf(buf, PAGE_SIZE,
 800                                  "There is no gadget attached!\n");
 801
 802         n += scnprintf(buf + n, PAGE_SIZE - n, "function  = %s\n",
 803                        (driver->function ? driver->function : ""));
 804         n += scnprintf(buf + n, PAGE_SIZE - n, "max speed = %d\n",
 805                        driver->speed);
 806
 807         return n;
 808 }
 809 static DEVICE_ATTR(driver, S_IRUSR, show_driver, NULL);
 810
 811 /* Maximum event message length */
 812 #define DBG_DATA_MSG   64UL
 813
 814 /* Maximum event messages */
 815 #define DBG_DATA_MAX   128UL
 816
 817 /* Event buffer descriptor */
 818 static struct {
 819         char     (buf[DBG_DATA_MAX])[DBG_DATA_MSG];   /* buffer */
 820         unsigned idx;   /* index */
 821         unsigned tty;   /* print to console? */
 822         rwlock_t lck;   /* lock */
 823 } dbg_data = {
 824         .idx = 0,
 825         .tty = 0,
 826         .lck = __RW_LOCK_UNLOCKED(lck)
 827 };
 828
 829 /**
 830  * dbg_dec: decrements debug event index
 831  * @idx: buffer index
 832  */
 833 static void dbg_dec(unsigned *idx)
 834 {
 835         *idx = (*idx - 1) & (DBG_DATA_MAX-1);
 836 }
 837
 838 /**
 839  * dbg_inc: increments debug event index
 840  * @idx: buffer index
 841  */
 842 static void dbg_inc(unsigned *idx)
 843 {
 844         *idx = (*idx + 1) & (DBG_DATA_MAX-1);
 845 }
 846
 847 /**
 848  * dbg_print:  prints the common part of the event
 849  * @addr:   endpoint address
 850  * @name:   event name
 851  * @status: status
 852  * @extra:  extra information
 853  */
 854 static void dbg_print(u8 addr, const char *name, int status, const char *extra)
 855 {
 856         struct timeval tval;
 857         unsigned int stamp;
 858         unsigned long flags;
 859
 860         write_lock_irqsave(&dbg_data.lck, flags);
 861
 862         do_gettimeofday(&tval);
 863         stamp = tval.tv_sec & 0xFFFF;   /* 2^32 = 4294967296. Limit to 4096s */
 864         stamp = stamp * 1000000 + tval.tv_usec;
 865
 866         scnprintf(dbg_data.buf[dbg_data.idx], DBG_DATA_MSG,
 867                   "%04X\t» %02X %-7.7s %4i «\t%s\n",
 868                   stamp, addr, name, status, extra);
 869
 870         dbg_inc(&dbg_data.idx);
 871
 872         write_unlock_irqrestore(&dbg_data.lck, flags);
 873
 874         if (dbg_data.tty != 0)
 875                 pr_notice("%04X\t» %02X %-7.7s %4i «\t%s\n",
 876                           stamp, addr, name, status, extra);
 877 }
 878
 879 /**
 880  * dbg_done: prints a DONE event
 881  * @addr:   endpoint address
 882  * @td:     transfer descriptor
 883  * @status: status
 884  */
 885 static void dbg_done(u8 addr, const u32 token, int status)
 886 {
 887         char msg[DBG_DATA_MSG];
 888
 889         scnprintf(msg, sizeof(msg), "%d %02X",
 890                   (int)(token & TD_TOTAL_BYTES) >> ffs_nr(TD_TOTAL_BYTES),
 891                   (int)(token & TD_STATUS)      >> ffs_nr(TD_STATUS));
 892         dbg_print(addr, "DONE", status, msg);
 893 }
 894
 895 /**
 896  * dbg_event: prints a generic event
 897  * @addr:   endpoint address
 898  * @name:   event name
 899  * @status: status
 900  */
 901 static void dbg_event(u8 addr, const char *name, int status)
 902 {
 903         if (name != NULL)
 904                 dbg_print(addr, name, status, "");
 905 }
 906
 907 /*
 908  * dbg_queue: prints a QUEUE event
 909  * @addr:   endpoint address
 910  * @req:    USB request
 911  * @status: status
 912  */
 913 static void dbg_queue(u8 addr, const struct usb_request *req, int status)
 914 {
 915         char msg[DBG_DATA_MSG];
 916
 917         if (req != NULL) {
 918                 scnprintf(msg, sizeof(msg),
 919                           "%d %d", !req->no_interrupt, req->length);
 920                 dbg_print(addr, "QUEUE", status, msg);
 921         }
 922 }
 923
 924 /**
 925  * dbg_setup: prints a SETUP event
 926  * @addr: endpoint address
 927  * @req:  setup request
 928  */
 929 static void dbg_setup(u8 addr, const struct usb_ctrlrequest *req)
 930 {
 931         char msg[DBG_DATA_MSG];
 932
 933         if (req != NULL) {
 934                 scnprintf(msg, sizeof(msg),
 935                           "%02X %02X %04X %04X %d", req->bRequestType,
 936                           req->bRequest, le16_to_cpu(req->wValue),
 937                           le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength));
 938                 dbg_print(addr, "SETUP", 0, msg);
 939         }
 940 }
 941
 942 /**
 943  * show_events: displays the event buffer
 944  *
 945  * Check "device.h" for details
 946  */
 947 static ssize_t show_events(struct device *dev, struct device_attribute *attr,
 948                            char *buf)
 949 {
 950         unsigned long flags;
 951         unsigned i, j, n = 0;
 952
 953         dbg_trace("[%s] %p\n", __func__, buf);
 954         if (attr == NULL || buf == NULL) {
 955                 dev_err(dev, "[%s] EINVAL\n", __func__);
 956                 return 0;
 957         }
 958
 959         read_lock_irqsave(&dbg_data.lck, flags);
 960
 961         i = dbg_data.idx;
 962         for (dbg_dec(&i); i != dbg_data.idx; dbg_dec(&i)) {
 963                 n += strlen(dbg_data.buf[i]);
 964                 if (n >= PAGE_SIZE) {
 965                         n -= strlen(dbg_data.buf[i]);
 966                         break;
 967                 }
 968         }
 969         for (j = 0, dbg_inc(&i); j < n; dbg_inc(&i))
 970                 j += scnprintf(buf + j, PAGE_SIZE - j,
 971                                "%s", dbg_data.buf[i]);
 972
 973         read_unlock_irqrestore(&dbg_data.lck, flags);
 974
 975         return n;
 976 }
 977
 978 /**
 979  * store_events: configure if events are going to be also printed to console
 980  *
 981  * Check "device.h" for details
 982  */
 983 static ssize_t store_events(struct device *dev, struct device_attribute *attr,
 984                             const char *buf, size_t count)
 985 {
 986         unsigned tty;
 987
 988         dbg_trace("[%s] %p, %d\n", __func__, buf, count);
 989         if (attr == NULL || buf == NULL) {
 990                 dev_err(dev, "[%s] EINVAL\n", __func__);
 991                 goto done;
 992         }
 993
 994         if (sscanf(buf, "%u", &tty) != 1 || tty > 1) {
 995                 dev_err(dev, "<1|0>: enable|disable console log\n");
 996                 goto done;
 997         }
 998
 999         dbg_data.tty = tty;
1000         dev_info(dev, "tty = %u", dbg_data.tty);
1001
1002  done:
1003         return count;
1004 }
1005 static DEVICE_ATTR(events, S_IRUSR | S_IWUSR, show_events, store_events);
1006
1007 /**
1008  * show_inters: interrupt status, enable status and historic
1009  *
1010  * Check "device.h" for details
1011  */
1012 static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
1013                            char *buf)
1014 {
1015         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1016         unsigned long flags;
1017         u32 intr;
1018         unsigned i, j, n = 0;
1019
1020         dbg_trace("[%s] %p\n", __func__, buf);
1021         if (attr == NULL || buf == NULL) {
1022                 dev_err(dev, "[%s] EINVAL\n", __func__);
1023                 return 0;
1024         }
1025
1026         spin_lock_irqsave(udc->lock, flags);
1027
1028         n += scnprintf(buf + n, PAGE_SIZE - n,
1029                        "status = %08x\n", hw_read_intr_status());
1030         n += scnprintf(buf + n, PAGE_SIZE - n,
1031                        "enable = %08x\n", hw_read_intr_enable());
1032
1033         n += scnprintf(buf + n, PAGE_SIZE - n, "*test = %d\n",
1034                        isr_statistics.test);
1035         n += scnprintf(buf + n, PAGE_SIZE - n, "» ui  = %d\n",
1036                        isr_statistics.ui);
1037         n += scnprintf(buf + n, PAGE_SIZE - n, "» uei = %d\n",
1038                        isr_statistics.uei);
1039         n += scnprintf(buf + n, PAGE_SIZE - n, "» pci = %d\n",
1040                        isr_statistics.pci);
1041         n += scnprintf(buf + n, PAGE_SIZE - n, "» uri = %d\n",
1042                        isr_statistics.uri);
1043         n += scnprintf(buf + n, PAGE_SIZE - n, "» sli = %d\n",
1044                        isr_statistics.sli);
1045         n += scnprintf(buf + n, PAGE_SIZE - n, "*none = %d\n",
1046                        isr_statistics.none);
1047         n += scnprintf(buf + n, PAGE_SIZE - n, "*hndl = %d\n",
1048                        isr_statistics.hndl.cnt);
1049
1050         for (i = isr_statistics.hndl.idx, j = 0; j <= ISR_MASK; j++, i++) {
1051                 i   &= ISR_MASK;
1052                 intr = isr_statistics.hndl.buf[i];
1053
1054                 if (USBi_UI  & intr)
1055                         n += scnprintf(buf + n, PAGE_SIZE - n, "ui  ");
1056                 intr &= ~USBi_UI;
1057                 if (USBi_UEI & intr)
1058                         n += scnprintf(buf + n, PAGE_SIZE - n, "uei ");
1059                 intr &= ~USBi_UEI;
1060                 if (USBi_PCI & intr)
1061                         n += scnprintf(buf + n, PAGE_SIZE - n, "pci ");
1062                 intr &= ~USBi_PCI;
1063                 if (USBi_URI & intr)
1064                         n += scnprintf(buf + n, PAGE_SIZE - n, "uri ");
1065                 intr &= ~USBi_URI;
1066                 if (USBi_SLI & intr)
1067                         n += scnprintf(buf + n, PAGE_SIZE - n, "sli ");
1068                 intr &= ~USBi_SLI;
1069                 if (intr)
1070                         n += scnprintf(buf + n, PAGE_SIZE - n, "??? ");
1071                 if (isr_statistics.hndl.buf[i])
1072                         n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
1073         }
1074
1075         spin_unlock_irqrestore(udc->lock, flags);
1076
1077         return n;
1078 }
1079
1080 /**
1081  * store_inters: enable & force or disable an individual interrutps
1082  *                   (to be used for test purposes only)
1083  *
1084  * Check "device.h" for details
1085  */
1086 static ssize_t store_inters(struct device *dev, struct device_attribute *attr,
1087                             const char *buf, size_t count)
1088 {
1089         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1090         unsigned long flags;
1091         unsigned en, bit;
1092
1093         dbg_trace("[%s] %p, %d\n", __func__, buf, count);
1094         if (attr == NULL || buf == NULL) {
1095                 dev_err(dev, "[%s] EINVAL\n", __func__);
1096                 goto done;
1097         }
1098
1099         if (sscanf(buf, "%u %u", &en, &bit) != 2 || en > 1) {
1100                 dev_err(dev, "<1|0> <bit>: enable|disable interrupt");
1101                 goto done;
1102         }
1103
1104         spin_lock_irqsave(udc->lock, flags);
1105         if (en) {
1106                 if (hw_intr_force(bit))
1107                         dev_err(dev, "invalid bit number\n");
1108                 else
1109                         isr_statistics.test++;
1110         } else {
1111                 if (hw_intr_clear(bit))
1112                         dev_err(dev, "invalid bit number\n");
1113         }
1114         spin_unlock_irqrestore(udc->lock, flags);
1115
1116  done:
1117         return count;
1118 }
1119 static DEVICE_ATTR(inters, S_IRUSR | S_IWUSR, show_inters, store_inters);
1120
1121 /**
1122  * show_port_test: reads port test mode
1123  *
1124  * Check "device.h" for details
1125  */
1126 static ssize_t show_port_test(struct device *dev,
1127                               struct device_attribute *attr, char *buf)
1128 {
1129         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1130         unsigned long flags;
1131         unsigned mode;
1132
1133         dbg_trace("[%s] %p\n", __func__, buf);
1134         if (attr == NULL || buf == NULL) {
1135                 dev_err(dev, "[%s] EINVAL\n", __func__);
1136                 return 0;
1137         }
1138
1139         spin_lock_irqsave(udc->lock, flags);
1140         mode = hw_port_test_get();
1141         spin_unlock_irqrestore(udc->lock, flags);
1142
1143         return scnprintf(buf, PAGE_SIZE, "mode = %u\n", mode);
1144 }
1145
1146 /**
1147  * store_port_test: writes port test mode
1148  *
1149  * Check "device.h" for details
1150  */
1151 static ssize_t store_port_test(struct device *dev,
1152                                struct device_attribute *attr,
1153                                const char *buf, size_t count)
1154 {
1155         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1156         unsigned long flags;
1157         unsigned mode;
1158
1159         dbg_trace("[%s] %p, %d\n", __func__, buf, count);
1160         if (attr == NULL || buf == NULL) {
1161                 dev_err(dev, "[%s] EINVAL\n", __func__);
1162                 goto done;
1163         }
1164
1165         if (sscanf(buf, "%u", &mode) != 1) {
1166                 dev_err(dev, "<mode>: set port test mode");
1167                 goto done;
1168         }
1169
1170         spin_lock_irqsave(udc->lock, flags);
1171         if (hw_port_test_set(mode))
1172                 dev_err(dev, "invalid mode\n");
1173         spin_unlock_irqrestore(udc->lock, flags);
1174
1175  done:
1176         return count;
1177 }
1178 static DEVICE_ATTR(port_test, S_IRUSR | S_IWUSR,
1179                    show_port_test, store_port_test);
1180
1181 /**
1182  * show_qheads: DMA contents of all queue heads
1183  *
1184  * Check "device.h" for details
1185  */
1186 static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
1187                            char *buf)
1188 {
1189         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1190         unsigned long flags;
1191         unsigned i, j, n = 0;
1192
1193         dbg_trace("[%s] %p\n", __func__, buf);
1194         if (attr == NULL || buf == NULL) {
1195                 dev_err(dev, "[%s] EINVAL\n", __func__);
1196                 return 0;
1197         }
1198
1199         spin_lock_irqsave(udc->lock, flags);
1200         for (i = 0; i < hw_ep_max; i++) {
1201                 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
1202                 n += scnprintf(buf + n, PAGE_SIZE - n,
1203                                "EP=%02i: RX=%08X TX=%08X\n",
1204                                i, (u32)mEp->qh[RX].dma, (u32)mEp->qh[TX].dma);
1205                 for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++) {
1206                         n += scnprintf(buf + n, PAGE_SIZE - n,
1207                                        " %04X:    %08X    %08X\n", j,
1208                                        *((u32 *)mEp->qh[RX].ptr + j),
1209                                        *((u32 *)mEp->qh[TX].ptr + j));
1210                 }
1211         }
1212         spin_unlock_irqrestore(udc->lock, flags);
1213
1214         return n;
1215 }
1216 static DEVICE_ATTR(qheads, S_IRUSR, show_qheads, NULL);
1217
1218 /**
1219  * show_registers: dumps all registers
1220  *
1221  * Check "device.h" for details
1222  */
1223 static ssize_t show_registers(struct device *dev,
1224                               struct device_attribute *attr, char *buf)
1225 {
1226         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1227         unsigned long flags;
1228         u32 dump[512];
1229         unsigned i, k, n = 0;
1230
1231         dbg_trace("[%s] %p\n", __func__, buf);
1232         if (attr == NULL || buf == NULL) {
1233                 dev_err(dev, "[%s] EINVAL\n", __func__);
1234                 return 0;
1235         }
1236
1237         spin_lock_irqsave(udc->lock, flags);
1238         k = hw_register_read(dump, sizeof(dump)/sizeof(u32));
1239         spin_unlock_irqrestore(udc->lock, flags);
1240
1241         for (i = 0; i < k; i++) {
1242                 n += scnprintf(buf + n, PAGE_SIZE - n,
1243                                "reg[0x%04X] = 0x%08X\n",
1244                                i * (unsigned)sizeof(u32), dump[i]);
1245         }
1246
1247         return n;
1248 }
1249
1250 /**
1251  * store_registers: writes value to register address
1252  *
1253  * Check "device.h" for details
1254  */
1255 static ssize_t store_registers(struct device *dev,
1256                                struct device_attribute *attr,
1257                                const char *buf, size_t count)
1258 {
1259         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1260         unsigned long addr, data, flags;
1261
1262         dbg_trace("[%s] %p, %d\n", __func__, buf, count);
1263         if (attr == NULL || buf == NULL) {
1264                 dev_err(dev, "[%s] EINVAL\n", __func__);
1265                 goto done;
1266         }
1267
1268         if (sscanf(buf, "%li %li", &addr, &data) != 2) {
1269                 dev_err(dev, "<addr> <data>: write data to register address");
1270                 goto done;
1271         }
1272
1273         spin_lock_irqsave(udc->lock, flags);
1274         if (hw_register_write(addr, data))
1275                 dev_err(dev, "invalid address range\n");
1276         spin_unlock_irqrestore(udc->lock, flags);
1277
1278  done:
1279         return count;
1280 }
1281 static DEVICE_ATTR(registers, S_IRUSR | S_IWUSR,
1282                    show_registers, store_registers);
1283
1284 /**
1285  * show_requests: DMA contents of all requests currently queued (all endpts)
1286  *
1287  * Check "device.h" for details
1288  */
1289 static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
1290                              char *buf)
1291 {
1292         struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
1293         unsigned long flags;
1294         struct list_head   *ptr = NULL;
1295         struct ci13xxx_req *req = NULL;
1296         unsigned i, j, k, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
1297
1298         dbg_trace("[%s] %p\n", __func__, buf);
1299         if (attr == NULL || buf == NULL) {
1300                 dev_err(dev, "[%s] EINVAL\n", __func__);
1301                 return 0;
1302         }
1303
1304         spin_lock_irqsave(udc->lock, flags);
1305         for (i = 0; i < hw_ep_max; i++)
1306                 for (k = RX; k <= TX; k++)
1307                         list_for_each(ptr, &udc->ci13xxx_ep[i].qh[k].queue)
1308                         {
1309                                 req = list_entry(ptr,
1310                                                  struct ci13xxx_req, queue);
1311
1312                                 n += scnprintf(buf + n, PAGE_SIZE - n,
1313                                                "EP=%02i: TD=%08X %s\n",
1314                                                i, (u32)req->dma,
1315                                                ((k == RX) ? "RX" : "TX"));
1316
1317                                 for (j = 0; j < qSize; j++)
1318                                         n += scnprintf(buf + n, PAGE_SIZE - n,
1319                                                        " %04X:    %08X\n", j,
1320                                                        *((u32 *)req->ptr + j));
1321                         }
1322         spin_unlock_irqrestore(udc->lock, flags);
1323
1324         return n;
1325 }
1326 static DEVICE_ATTR(requests, S_IRUSR, show_requests, NULL);
1327
1328 /**
1329  * dbg_create_files: initializes the attribute interface
1330  * @dev: device
1331  *
1332  * This function returns an error code
1333  */
1334 __maybe_unused static int dbg_create_files(struct device *dev)
1335 {
1336         int retval = 0;
1337
1338         if (dev == NULL)
1339                 return -EINVAL;
1340         retval = device_create_file(dev, &dev_attr_device);
1341         if (retval)
1342                 goto done;
1343         retval = device_create_file(dev, &dev_attr_driver);
1344         if (retval)
1345                 goto rm_device;
1346         retval = device_create_file(dev, &dev_attr_events);
1347         if (retval)
1348                 goto rm_driver;
1349         retval = device_create_file(dev, &dev_attr_inters);
1350         if (retval)
1351                 goto rm_events;
1352         retval = device_create_file(dev, &dev_attr_port_test);
1353         if (retval)
1354                 goto rm_inters;
1355         retval = device_create_file(dev, &dev_attr_qheads);
1356         if (retval)
1357                 goto rm_port_test;
1358         retval = device_create_file(dev, &dev_attr_registers);
1359         if (retval)
1360                 goto rm_qheads;
1361         retval = device_create_file(dev, &dev_attr_requests);
1362         if (retval)
1363                 goto rm_registers;
1364         return 0;
1365
1366  rm_registers:
1367         device_remove_file(dev, &dev_attr_registers);
1368  rm_qheads:
1369         device_remove_file(dev, &dev_attr_qheads);
1370  rm_port_test:
1371         device_remove_file(dev, &dev_attr_port_test);
1372  rm_inters:
1373         device_remove_file(dev, &dev_attr_inters);
1374  rm_events:
1375         device_remove_file(dev, &dev_attr_events);
1376  rm_driver:
1377         device_remove_file(dev, &dev_attr_driver);
1378  rm_device:
1379         device_remove_file(dev, &dev_attr_device);
1380  done:
1381         return retval;
1382 }
1383
1384 /**
1385  * dbg_remove_files: destroys the attribute interface
1386  * @dev: device
1387  *
1388  * This function returns an error code
1389  */
1390 __maybe_unused static int dbg_remove_files(struct device *dev)
1391 {
1392         if (dev == NULL)
1393                 return -EINVAL;
1394         device_remove_file(dev, &dev_attr_requests);
1395         device_remove_file(dev, &dev_attr_registers);
1396         device_remove_file(dev, &dev_attr_qheads);
1397         device_remove_file(dev, &dev_attr_port_test);
1398         device_remove_file(dev, &dev_attr_inters);
1399         device_remove_file(dev, &dev_attr_events);
1400         device_remove_file(dev, &dev_attr_driver);
1401         device_remove_file(dev, &dev_attr_device);
1402         return 0;
1403 }
1404
1405 /******************************************************************************
1406  * UTIL block
1407  *****************************************************************************/
1408 /**
1409  * _usb_addr: calculates endpoint address from direction & number
1410  * @ep:  endpoint
1411  */
1412 static inline u8 _usb_addr(struct ci13xxx_ep *ep)
1413 {
1414         return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
1415 }
1416
1417 /**
1418  * _hardware_queue: configures a request at hardware level
1419  * @gadget: gadget
1420  * @mEp:    endpoint
1421  *
1422  * This function returns an error code
1423  */
1424 static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
1425 {
1426         unsigned i;
1427
1428         trace("%p, %p", mEp, mReq);
1429
1430         /* don't queue twice */
1431         if (mReq->req.status == -EALREADY)
1432                 return -EALREADY;
1433
1434         if (hw_ep_is_primed(mEp->num, mEp->dir))
1435                 return -EBUSY;
1436
1437         mReq->req.status = -EALREADY;
1438
1439         if (mReq->req.length && !mReq->req.dma) {
1440                 mReq->req.dma = \
1441                         dma_map_single(mEp->device, mReq->req.buf,
1442                                        mReq->req.length, mEp->dir ?
1443                                        DMA_TO_DEVICE : DMA_FROM_DEVICE);
1444                 if (mReq->req.dma == 0)
1445                         return -ENOMEM;
1446
1447                 mReq->map = 1;
1448         }
1449
1450         /*
1451          * TD configuration
1452          * TODO - handle requests which spawns into several TDs
1453          */
1454         memset(mReq->ptr, 0, sizeof(*mReq->ptr));
1455         mReq->ptr->next    |= TD_TERMINATE;
1456         mReq->ptr->token    = mReq->req.length << ffs_nr(TD_TOTAL_BYTES);
1457         mReq->ptr->token   &= TD_TOTAL_BYTES;
1458         mReq->ptr->token   |= TD_IOC;
1459         mReq->ptr->token   |= TD_STATUS_ACTIVE;
1460         mReq->ptr->page[0]  = mReq->req.dma;
1461         for (i = 1; i < 5; i++)
1462                 mReq->ptr->page[i] =
1463                         (mReq->req.dma + i * CI13XXX_PAGE_SIZE) & ~TD_RESERVED_MASK;
1464
1465         /*
1466          *  QH configuration
1467          *  At this point it's guaranteed exclusive access to qhead
1468          *  (endpt is not primed) so it's no need to use tripwire
1469          */
1470         mEp->qh[mEp->dir].ptr->td.next   = mReq->dma;    /* TERMINATE = 0 */
1471         mEp->qh[mEp->dir].ptr->td.token &= ~TD_STATUS;   /* clear status */
1472         if (mReq->req.zero == 0)
1473                 mEp->qh[mEp->dir].ptr->cap |=  QH_ZLT;
1474         else
1475                 mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
1476
1477         wmb();   /* synchronize before ep prime */
1478
1479         return hw_ep_prime(mEp->num, mEp->dir,
1480                            mEp->type == USB_ENDPOINT_XFER_CONTROL);
1481 }
1482
1483 /**
1484  * _hardware_dequeue: handles a request at hardware level
1485  * @gadget: gadget
1486  * @mEp:    endpoint
1487  *
1488  * This function returns an error code
1489  */
1490 static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
1491 {
1492         trace("%p, %p", mEp, mReq);
1493
1494         if (mReq->req.status != -EALREADY)
1495                 return -EINVAL;
1496
1497         if (hw_ep_is_primed(mEp->num, mEp->dir))
1498                 hw_ep_flush(mEp->num, mEp->dir);
1499
1500         mReq->req.status = 0;
1501
1502         if (mReq->map) {
1503                 dma_unmap_single(mEp->device, mReq->req.dma, mReq->req.length,
1504                                  mEp->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
1505                 mReq->req.dma = 0;
1506                 mReq->map     = 0;
1507         }
1508
1509         mReq->req.status = mReq->ptr->token & TD_STATUS;
1510         if      ((TD_STATUS_ACTIVE & mReq->req.status) != 0)
1511                 mReq->req.status = -ECONNRESET;
1512         else if ((TD_STATUS_HALTED & mReq->req.status) != 0)
1513                 mReq->req.status = -1;
1514         else if ((TD_STATUS_DT_ERR & mReq->req.status) != 0)
1515                 mReq->req.status = -1;
1516         else if ((TD_STATUS_TR_ERR & mReq->req.status) != 0)
1517                 mReq->req.status = -1;
1518
1519         mReq->req.actual   = mReq->ptr->token & TD_TOTAL_BYTES;
1520         mReq->req.actual >>= ffs_nr(TD_TOTAL_BYTES);
1521         mReq->req.actual   = mReq->req.length - mReq->req.actual;
1522         mReq->req.actual   = mReq->req.status ? 0 : mReq->req.actual;
1523
1524         return mReq->req.actual;
1525 }
1526
1527 /**
1528  * _ep_nuke: dequeues all endpoint requests
1529  * @mEp: endpoint
1530  *
1531  * This function returns an error code
1532  * Caller must hold lock
1533  */
1534 static int _ep_nuke(struct ci13xxx_ep *mEp)
1535 __releases(mEp->lock)
1536 __acquires(mEp->lock)
1537 {
1538         trace("%p", mEp);
1539
1540         if (mEp == NULL)
1541                 return -EINVAL;
1542
1543         hw_ep_flush(mEp->num, mEp->dir);
1544
1545         while (!list_empty(&mEp->qh[mEp->dir].queue)) {
1546
1547                 /* pop oldest request */
1548                 struct ci13xxx_req *mReq = \
1549                         list_entry(mEp->qh[mEp->dir].queue.next,
1550                                    struct ci13xxx_req, queue);
1551                 list_del_init(&mReq->queue);
1552                 mReq->req.status = -ESHUTDOWN;
1553
1554                 if (mReq->req.complete != NULL) {
1555                         spin_unlock(mEp->lock);
1556                         mReq->req.complete(&mEp->ep, &mReq->req);
1557                         spin_lock(mEp->lock);
1558                 }
1559         }
1560         return 0;
1561 }
1562
1563 /**
1564  * _gadget_stop_activity: stops all USB activity, flushes & disables all endpts
1565  * @gadget: gadget
1566  *
1567  * This function returns an error code
1568  * Caller must hold lock
1569  */
1570 static int _gadget_stop_activity(struct usb_gadget *gadget)
1571 {
1572         struct usb_ep *ep;
1573         struct ci13xxx    *udc = container_of(gadget, struct ci13xxx, gadget);
1574         struct ci13xxx_ep *mEp = container_of(gadget->ep0,
1575                                               struct ci13xxx_ep, ep);
1576
1577         trace("%p", gadget);
1578
1579         if (gadget == NULL)
1580                 return -EINVAL;
1581
1582         /* flush all endpoints */
1583         gadget_for_each_ep(ep, gadget) {
1584                 usb_ep_fifo_flush(ep);
1585         }
1586         usb_ep_fifo_flush(gadget->ep0);
1587
1588         udc->driver->disconnect(gadget);
1589
1590         /* make sure to disable all endpoints */
1591         gadget_for_each_ep(ep, gadget) {
1592                 usb_ep_disable(ep);
1593         }
1594         usb_ep_disable(gadget->ep0);
1595
1596         if (mEp->status != NULL) {
1597                 usb_ep_free_request(gadget->ep0, mEp->status);
1598                 mEp->status = NULL;
1599         }
1600
1601         return 0;
1602 }
1603
1604 /******************************************************************************
1605  * ISR block
1606  *****************************************************************************/
1607 /**
1608  * isr_reset_handler: USB reset interrupt handler
1609  * @udc: UDC device
1610  *
1611  * This function resets USB engine after a bus reset occurred
1612  */
1613 static void isr_reset_handler(struct ci13xxx *udc)
1614 __releases(udc->lock)
1615 __acquires(udc->lock)
1616 {
1617         struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[0];
1618         int retval;
1619
1620         trace("%p", udc);
1621
1622         if (udc == NULL) {
1623                 err("EINVAL");
1624                 return;
1625         }
1626
1627         dbg_event(0xFF, "BUS RST", 0);
1628
1629         spin_unlock(udc->lock);
1630         retval = _gadget_stop_activity(&udc->gadget);
1631         if (retval)
1632                 goto done;
1633
1634         retval = hw_usb_reset();
1635         if (retval)
1636                 goto done;
1637
1638         retval = usb_ep_enable(&mEp->ep, &ctrl_endpt_desc);
1639         if (!retval) {
1640                 mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_ATOMIC);
1641                 if (mEp->status == NULL) {
1642                         usb_ep_disable(&mEp->ep);
1643                         retval = -ENOMEM;
1644                 }
1645         }
1646         spin_lock(udc->lock);
1647
1648  done:
1649         if (retval)
1650                 err("error: %i", retval);
1651 }
1652
1653 /**
1654  * isr_get_status_complete: get_status request complete function
1655  * @ep:  endpoint
1656  * @req: request handled
1657  *
1658  * Caller must release lock
1659  */
1660 static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
1661 {
1662         trace("%p, %p", ep, req);
1663
1664         if (ep == NULL || req == NULL) {
1665                 err("EINVAL");
1666                 return;
1667         }
1668
1669         kfree(req->buf);
1670         usb_ep_free_request(ep, req);
1671 }
1672
1673 /**
1674  * isr_get_status_response: get_status request response
1675  * @ep:    endpoint
1676  * @setup: setup request packet
1677  *
1678  * This function returns an error code
1679  */
1680 static int isr_get_status_response(struct ci13xxx_ep *mEp,
1681                                    struct usb_ctrlrequest *setup)
1682 __releases(mEp->lock)
1683 __acquires(mEp->lock)
1684 {
1685         struct usb_request *req = NULL;
1686         gfp_t gfp_flags = GFP_ATOMIC;
1687         int dir, num, retval;
1688
1689         trace("%p, %p", mEp, setup);
1690
1691         if (mEp == NULL || setup == NULL)
1692                 return -EINVAL;
1693
1694         spin_unlock(mEp->lock);
1695         req = usb_ep_alloc_request(&mEp->ep, gfp_flags);
1696         spin_lock(mEp->lock);
1697         if (req == NULL)
1698                 return -ENOMEM;
1699
1700         req->complete = isr_get_status_complete;
1701         req->length   = 2;
1702         req->buf      = kzalloc(req->length, gfp_flags);
1703         if (req->buf == NULL) {
1704                 retval = -ENOMEM;
1705                 goto err_free_req;
1706         }
1707
1708         if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
1709                 /* TODO: D1 - Remote Wakeup; D0 - Self Powered */
1710                 retval = 0;
1711         } else if ((setup->bRequestType & USB_RECIP_MASK) \
1712                    == USB_RECIP_ENDPOINT) {
1713                 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
1714                         TX : RX;
1715                 num =  le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
1716                 *((u16 *)req->buf) = hw_ep_get_halt(num, dir);
1717         }
1718         /* else do nothing; reserved for future use */
1719
1720         spin_unlock(mEp->lock);
1721         retval = usb_ep_queue(&mEp->ep, req, gfp_flags);
1722         spin_lock(mEp->lock);
1723         if (retval)
1724                 goto err_free_buf;
1725
1726         return 0;
1727
1728  err_free_buf:
1729         kfree(req->buf);
1730  err_free_req:
1731         spin_unlock(mEp->lock);
1732         usb_ep_free_request(&mEp->ep, req);
1733         spin_lock(mEp->lock);
1734         return retval;
1735 }
1736
1737 /**
1738  * isr_setup_status_phase: queues the status phase of a setup transation
1739  * @mEp: endpoint
1740  *
1741  * This function returns an error code
1742  */
1743 static int isr_setup_status_phase(struct ci13xxx_ep *mEp)
1744 __releases(mEp->lock)
1745 __acquires(mEp->lock)
1746 {
1747         int retval;
1748
1749         trace("%p", mEp);
1750
1751         /* mEp is always valid & configured */
1752
1753         if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
1754                 mEp->dir = (mEp->dir == TX) ? RX : TX;
1755
1756         mEp->status->no_interrupt = 1;
1757
1758         spin_unlock(mEp->lock);
1759         retval = usb_ep_queue(&mEp->ep, mEp->status, GFP_ATOMIC);
1760         spin_lock(mEp->lock);
1761
1762         return retval;
1763 }
1764
1765 /**
1766  * isr_tr_complete_low: transaction complete low level handler
1767  * @mEp: endpoint
1768  *
1769  * This function returns an error code
1770  * Caller must hold lock
1771  */
1772 static int isr_tr_complete_low(struct ci13xxx_ep *mEp)
1773 __releases(mEp->lock)
1774 __acquires(mEp->lock)
1775 {
1776         struct ci13xxx_req *mReq;
1777         int retval;
1778
1779         trace("%p", mEp);
1780
1781         if (list_empty(&mEp->qh[mEp->dir].queue))
1782                 return -EINVAL;
1783
1784         /* pop oldest request */
1785         mReq = list_entry(mEp->qh[mEp->dir].queue.next,
1786                           struct ci13xxx_req, queue);
1787         list_del_init(&mReq->queue);
1788
1789         retval = _hardware_dequeue(mEp, mReq);
1790         if (retval < 0) {
1791                 dbg_event(_usb_addr(mEp), "DONE", retval);
1792                 goto done;
1793         }
1794
1795         dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
1796
1797         if (!list_empty(&mEp->qh[mEp->dir].queue)) {
1798                 struct ci13xxx_req* mReqEnq;
1799
1800                 mReqEnq = list_entry(mEp->qh[mEp->dir].queue.next,
1801                                   struct ci13xxx_req, queue);
1802                 _hardware_enqueue(mEp, mReqEnq);
1803         }
1804
1805         if (mReq->req.complete != NULL) {
1806                 spin_unlock(mEp->lock);
1807                 mReq->req.complete(&mEp->ep, &mReq->req);
1808                 spin_lock(mEp->lock);
1809         }
1810
1811  done:
1812         return retval;
1813 }
1814
1815 /**
1816  * isr_tr_complete_handler: transaction complete interrupt handler
1817  * @udc: UDC descriptor
1818  *
1819  * This function handles traffic events
1820  */
1821 static void isr_tr_complete_handler(struct ci13xxx *udc)
1822 __releases(udc->lock)
1823 __acquires(udc->lock)
1824 {
1825         unsigned i;
1826
1827         trace("%p", udc);
1828
1829         if (udc == NULL) {
1830                 err("EINVAL");
1831                 return;
1832         }
1833
1834         for (i = 0; i < hw_ep_max; i++) {
1835                 struct ci13xxx_ep *mEp  = &udc->ci13xxx_ep[i];
1836                 int type, num, err = -EINVAL;
1837                 struct usb_ctrlrequest req;
1838
1839
1840                 if (mEp->desc == NULL)
1841                         continue;   /* not configured */
1842
1843                 if ((mEp->dir == RX && hw_test_and_clear_complete(i)) ||
1844                     (mEp->dir == TX && hw_test_and_clear_complete(i + 16))) {
1845                         err = isr_tr_complete_low(mEp);
1846                         if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
1847                                 if (err > 0)   /* needs status phase */
1848                                         err = isr_setup_status_phase(mEp);
1849                                 if (err < 0) {
1850                                         dbg_event(_usb_addr(mEp),
1851                                                   "ERROR", err);
1852                                         spin_unlock(udc->lock);
1853                                         if (usb_ep_set_halt(&mEp->ep))
1854                                                 err("error: ep_set_halt");
1855                                         spin_lock(udc->lock);
1856                                 }
1857                         }
1858                 }
1859
1860                 if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
1861                     !hw_test_and_clear_setup_status(i))
1862                         continue;
1863
1864                 if (i != 0) {
1865                         warn("ctrl traffic received at endpoint");
1866                         continue;
1867                 }
1868
1869                 /* read_setup_packet */
1870                 do {
1871                         hw_test_and_set_setup_guard();
1872                         memcpy(&req, &mEp->qh[RX].ptr->setup, sizeof(req));
1873                 } while (!hw_test_and_clear_setup_guard());
1874
1875                 type = req.bRequestType;
1876
1877                 mEp->dir = (type & USB_DIR_IN) ? TX : RX;
1878
1879                 dbg_setup(_usb_addr(mEp), &req);
1880
1881                 switch (req.bRequest) {
1882                 case USB_REQ_CLEAR_FEATURE:
1883                         if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1884                             le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
1885                                 goto delegate;
1886                         if (req.wLength != 0)
1887                                 break;
1888                         num  = le16_to_cpu(req.wIndex);
1889                         num &= USB_ENDPOINT_NUMBER_MASK;
1890                         if (!udc->ci13xxx_ep[num].wedge) {
1891                                 spin_unlock(udc->lock);
1892                                 err = usb_ep_clear_halt(
1893                                         &udc->ci13xxx_ep[num].ep);
1894                                 spin_lock(udc->lock);
1895                                 if (err)
1896                                         break;
1897                         }
1898                         err = isr_setup_status_phase(mEp);
1899                         break;
1900                 case USB_REQ_GET_STATUS:
1901                         if (type != (USB_DIR_IN|USB_RECIP_DEVICE)   &&
1902                             type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
1903                             type != (USB_DIR_IN|USB_RECIP_INTERFACE))
1904                                 goto delegate;
1905                         if (le16_to_cpu(req.wLength) != 2 ||
1906                             le16_to_cpu(req.wValue)  != 0)
1907                                 break;
1908                         err = isr_get_status_response(mEp, &req);
1909                         break;
1910                 case USB_REQ_SET_ADDRESS:
1911                         if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
1912                                 goto delegate;
1913                         if (le16_to_cpu(req.wLength) != 0 ||
1914                             le16_to_cpu(req.wIndex)  != 0)
1915                                 break;
1916                         err = hw_usb_set_address((u8)le16_to_cpu(req.wValue));
1917                         if (err)
1918                                 break;
1919                         err = isr_setup_status_phase(mEp);
1920                         break;
1921                 case USB_REQ_SET_FEATURE:
1922                         if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
1923                             le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
1924                                 goto delegate;
1925                         if (req.wLength != 0)
1926                                 break;
1927                         num  = le16_to_cpu(req.wIndex);
1928                         num &= USB_ENDPOINT_NUMBER_MASK;
1929
1930                         spin_unlock(udc->lock);
1931                         err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
1932                         spin_lock(udc->lock);
1933                         if (err)
1934                                 break;
1935                         err = isr_setup_status_phase(mEp);
1936                         break;
1937                 default:
1938 delegate:
1939                         if (req.wLength == 0)   /* no data phase */
1940                                 mEp->dir = TX;
1941
1942                         spin_unlock(udc->lock);
1943                         err = udc->driver->setup(&udc->gadget, &req);
1944                         spin_lock(udc->lock);
1945                         break;
1946                 }
1947
1948                 if (err < 0) {
1949                         dbg_event(_usb_addr(mEp), "ERROR", err);
1950
1951                         spin_unlock(udc->lock);
1952                         if (usb_ep_set_halt(&mEp->ep))
1953                                 err("error: ep_set_halt");
1954                         spin_lock(udc->lock);
1955                 }
1956         }
1957 }
1958
1959 /******************************************************************************
1960  * ENDPT block
1961  *****************************************************************************/
1962 /**
1963  * ep_enable: configure endpoint, making it usable
1964  *
1965  * Check usb_ep_enable() at "usb_gadget.h" for details
1966  */
1967 static int ep_enable(struct usb_ep *ep,
1968                      const struct usb_endpoint_descriptor *desc)
1969 {
1970         struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1971         int direction, retval = 0;
1972         unsigned long flags;
1973
1974         trace("%p, %p", ep, desc);
1975
1976         if (ep == NULL || desc == NULL)
1977                 return -EINVAL;
1978
1979         spin_lock_irqsave(mEp->lock, flags);
1980
1981         /* only internal SW should enable ctrl endpts */
1982
1983         mEp->desc = desc;
1984
1985         if (!list_empty(&mEp->qh[mEp->dir].queue))
1986                 warn("enabling a non-empty endpoint!");
1987
1988         mEp->dir  = usb_endpoint_dir_in(desc) ? TX : RX;
1989         mEp->num  = usb_endpoint_num(desc);
1990         mEp->type = usb_endpoint_type(desc);
1991
1992         mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize);
1993
1994         direction = mEp->dir;
1995         do {
1996                 dbg_event(_usb_addr(mEp), "ENABLE", 0);
1997
1998                 mEp->qh[mEp->dir].ptr->cap = 0;
1999
2000                 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2001                         mEp->qh[mEp->dir].ptr->cap |=  QH_IOS;
2002                 else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
2003                         mEp->qh[mEp->dir].ptr->cap &= ~QH_MULT;
2004                 else
2005                         mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
2006
2007                 mEp->qh[mEp->dir].ptr->cap |=
2008                         (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
2009                 mEp->qh[mEp->dir].ptr->td.next |= TD_TERMINATE;   /* needed? */
2010
2011                 retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
2012
2013                 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2014                         mEp->dir = (mEp->dir == TX) ? RX : TX;
2015
2016         } while (mEp->dir != direction);
2017
2018         spin_unlock_irqrestore(mEp->lock, flags);
2019         return retval;
2020 }
2021
2022 /**
2023  * ep_disable: endpoint is no longer usable
2024  *
2025  * Check usb_ep_disable() at "usb_gadget.h" for details
2026  */
2027 static int ep_disable(struct usb_ep *ep)
2028 {
2029         struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2030         int direction, retval = 0;
2031         unsigned long flags;
2032
2033         trace("%p", ep);
2034
2035         if (ep == NULL)
2036                 return -EINVAL;
2037         else if (mEp->desc == NULL)
2038                 return -EBUSY;
2039
2040         spin_lock_irqsave(mEp->lock, flags);
2041
2042         /* only internal SW should disable ctrl endpts */
2043
2044         direction = mEp->dir;
2045         do {
2046                 dbg_event(_usb_addr(mEp), "DISABLE", 0);
2047
2048                 retval |= _ep_nuke(mEp);
2049                 retval |= hw_ep_disable(mEp->num, mEp->dir);
2050
2051                 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2052                         mEp->dir = (mEp->dir == TX) ? RX : TX;
2053
2054         } while (mEp->dir != direction);
2055
2056         mEp->desc = NULL;
2057
2058         spin_unlock_irqrestore(mEp->lock, flags);
2059         return retval;
2060 }
2061
2062 /**
2063  * ep_alloc_request: allocate a request object to use with this endpoint
2064  *
2065  * Check usb_ep_alloc_request() at "usb_gadget.h" for details
2066  */
2067 static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
2068 {
2069         struct ci13xxx_ep  *mEp  = container_of(ep, struct ci13xxx_ep, ep);
2070         struct ci13xxx_req *mReq = NULL;
2071
2072         trace("%p, %i", ep, gfp_flags);
2073
2074         if (ep == NULL) {
2075                 err("EINVAL");
2076                 return NULL;
2077         }
2078
2079         mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
2080         if (mReq != NULL) {
2081                 INIT_LIST_HEAD(&mReq->queue);
2082
2083                 mReq->ptr = dma_pool_alloc(mEp->td_pool, gfp_flags,
2084                                            &mReq->dma);
2085                 if (mReq->ptr == NULL) {
2086                         kfree(mReq);
2087                         mReq = NULL;
2088                 }
2089         }
2090
2091         dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
2092
2093         return (mReq == NULL) ? NULL : &mReq->req;
2094 }
2095
2096 /**
2097  * ep_free_request: frees a request object
2098  *
2099  * Check usb_ep_free_request() at "usb_gadget.h" for details
2100  */
2101 static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
2102 {
2103         struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
2104         struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
2105         unsigned long flags;
2106
2107         trace("%p, %p", ep, req);
2108
2109         if (ep == NULL || req == NULL) {
2110                 err("EINVAL");
2111                 return;
2112         } else if (!list_empty(&mReq->queue)) {
2113                 err("EBUSY");
2114                 return;
2115         }
2116
2117         spin_lock_irqsave(mEp->lock, flags);
2118
2119         if (mReq->ptr)
2120                 dma_pool_free(mEp->td_pool, mReq->ptr, mReq->dma);
2121         kfree(mReq);
2122
2123         dbg_event(_usb_addr(mEp), "FREE", 0);
2124
2125         spin_unlock_irqrestore(mEp->lock, flags);
2126 }
2127
2128 /**
2129  * ep_queue: queues (submits) an I/O request to an endpoint
2130  *
2131  * Check usb_ep_queue()* at usb_gadget.h" for details
2132  */
2133 static int ep_queue(struct usb_ep *ep, struct usb_request *req,
2134                     gfp_t __maybe_unused gfp_flags)
2135 {
2136         struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
2137         struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
2138         int retval = 0;
2139         unsigned long flags;
2140
2141         trace("%p, %p, %X", ep, req, gfp_flags);
2142
2143         if (ep == NULL || req == NULL || mEp->desc == NULL)
2144                 return -EINVAL;
2145
2146         spin_lock_irqsave(mEp->lock, flags);
2147
2148         if (mEp->type == USB_ENDPOINT_XFER_CONTROL &&
2149             !list_empty(&mEp->qh[mEp->dir].queue)) {
2150                 _ep_nuke(mEp);
2151                 retval = -EOVERFLOW;
2152                 warn("endpoint ctrl %X nuked", _usb_addr(mEp));
2153         }
2154
2155         /* first nuke then test link, e.g. previous status has not sent */
2156         if (!list_empty(&mReq->queue)) {
2157                 retval = -EBUSY;
2158                 err("request already in queue");
2159                 goto done;
2160         }
2161
2162         if (req->length > (4 * CI13XXX_PAGE_SIZE)) {
2163                 req->length = (4 * CI13XXX_PAGE_SIZE);
2164                 retval = -EMSGSIZE;
2165                 warn("request length truncated");
2166         }
2167
2168         dbg_queue(_usb_addr(mEp), req, retval);
2169
2170         /* push request */
2171         mReq->req.status = -EINPROGRESS;
2172         mReq->req.actual = 0;
2173         list_add_tail(&mReq->queue, &mEp->qh[mEp->dir].queue);
2174
2175         if (list_is_singular(&mEp->qh[mEp->dir].queue))
2176                 retval = _hardware_enqueue(mEp, mReq);
2177
2178         if (retval == -EALREADY) {
2179                 dbg_event(_usb_addr(mEp), "QUEUE", retval);
2180                 retval = 0;
2181         }
2182
2183  done:
2184         spin_unlock_irqrestore(mEp->lock, flags);
2185         return retval;
2186 }
2187
2188 /**
2189  * ep_dequeue: dequeues (cancels, unlinks) an I/O request from an endpoint
2190  *
2191  * Check usb_ep_dequeue() at "usb_gadget.h" for details
2192  */
2193 static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
2194 {
2195         struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
2196         struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
2197         unsigned long flags;
2198
2199         trace("%p, %p", ep, req);
2200
2201         if (ep == NULL || req == NULL || mEp->desc == NULL ||
2202             list_empty(&mReq->queue)  || list_empty(&mEp->qh[mEp->dir].queue))
2203                 return -EINVAL;
2204
2205         spin_lock_irqsave(mEp->lock, flags);
2206
2207         dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
2208
2209         if (mReq->req.status == -EALREADY)
2210                 _hardware_dequeue(mEp, mReq);
2211
2212         /* pop request */
2213         list_del_init(&mReq->queue);
2214         req->status = -ECONNRESET;
2215
2216         if (mReq->req.complete != NULL) {
2217                 spin_unlock(mEp->lock);
2218                 mReq->req.complete(&mEp->ep, &mReq->req);
2219                 spin_lock(mEp->lock);
2220         }
2221
2222         spin_unlock_irqrestore(mEp->lock, flags);
2223         return 0;
2224 }
2225
2226 /**
2227  * ep_set_halt: sets the endpoint halt feature
2228  *
2229  * Check usb_ep_set_halt() at "usb_gadget.h" for details
2230  */
2231 static int ep_set_halt(struct usb_ep *ep, int value)
2232 {
2233         struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2234         int direction, retval = 0;
2235         unsigned long flags;
2236
2237         trace("%p, %i", ep, value);
2238
2239         if (ep == NULL || mEp->desc == NULL)
2240                 return -EINVAL;
2241
2242         spin_lock_irqsave(mEp->lock, flags);
2243
2244 #ifndef STALL_IN
2245         /* g_file_storage MS compliant but g_zero fails chapter 9 compliance */
2246         if (value && mEp->type == USB_ENDPOINT_XFER_BULK && mEp->dir == TX &&
2247             !list_empty(&mEp->qh[mEp->dir].queue)) {
2248                 spin_unlock_irqrestore(mEp->lock, flags);
2249                 return -EAGAIN;
2250         }
2251 #endif
2252
2253         direction = mEp->dir;
2254         do {
2255                 dbg_event(_usb_addr(mEp), "HALT", value);
2256                 retval |= hw_ep_set_halt(mEp->num, mEp->dir, value);
2257
2258                 if (!value)
2259                         mEp->wedge = 0;
2260
2261                 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
2262                         mEp->dir = (mEp->dir == TX) ? RX : TX;
2263
2264         } while (mEp->dir != direction);
2265
2266         spin_unlock_irqrestore(mEp->lock, flags);
2267         return retval;
2268 }
2269
2270 /**
2271  * ep_set_wedge: sets the halt feature and ignores clear requests
2272  *
2273  * Check usb_ep_set_wedge() at "usb_gadget.h" for details
2274  */
2275 static int ep_set_wedge(struct usb_ep *ep)
2276 {
2277         struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2278         unsigned long flags;
2279
2280         trace("%p", ep);
2281
2282         if (ep == NULL || mEp->desc == NULL)
2283                 return -EINVAL;
2284
2285         spin_lock_irqsave(mEp->lock, flags);
2286
2287         dbg_event(_usb_addr(mEp), "WEDGE", 0);
2288         mEp->wedge = 1;
2289
2290         spin_unlock_irqrestore(mEp->lock, flags);
2291
2292         return usb_ep_set_halt(ep);
2293 }
2294
2295 /**
2296  * ep_fifo_flush: flushes contents of a fifo
2297  *
2298  * Check usb_ep_fifo_flush() at "usb_gadget.h" for details
2299  */
2300 static void ep_fifo_flush(struct usb_ep *ep)
2301 {
2302         struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
2303         unsigned long flags;
2304
2305         trace("%p", ep);
2306
2307         if (ep == NULL) {
2308                 err("%02X: -EINVAL", _usb_addr(mEp));
2309                 return;
2310         }
2311
2312         spin_lock_irqsave(mEp->lock, flags);
2313
2314         dbg_event(_usb_addr(mEp), "FFLUSH", 0);
2315         hw_ep_flush(mEp->num, mEp->dir);
2316
2317         spin_unlock_irqrestore(mEp->lock, flags);
2318 }
2319
2320 /**
2321  * Endpoint-specific part of the API to the USB controller hardware
2322  * Check "usb_gadget.h" for details
2323  */
2324 static const struct usb_ep_ops usb_ep_ops = {
2325         .enable        = ep_enable,
2326         .disable       = ep_disable,
2327         .alloc_request = ep_alloc_request,
2328         .free_request  = ep_free_request,
2329         .queue         = ep_queue,
2330         .dequeue       = ep_dequeue,
2331         .set_halt      = ep_set_halt,
2332         .set_wedge     = ep_set_wedge,
2333         .fifo_flush    = ep_fifo_flush,
2334 };
2335
2336 /******************************************************************************
2337  * GADGET block
2338  *****************************************************************************/
2339 static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
2340 {
2341         struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
2342         unsigned long flags;
2343         int gadget_ready = 0;
2344
2345         if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS))
2346                 return -EOPNOTSUPP;
2347
2348         spin_lock_irqsave(udc->lock, flags);
2349         udc->vbus_active = is_active;
2350         if (udc->driver)
2351                 gadget_ready = 1;
2352         spin_unlock_irqrestore(udc->lock, flags);
2353
2354         if (gadget_ready) {
2355                 if (is_active) {
2356                         pm_runtime_get_sync(&_gadget->dev);
2357                         hw_device_reset(udc);
2358                         hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
2359                 } else {
2360                         hw_device_state(0);
2361                         if (udc->udc_driver->notify_event)
2362                                 udc->udc_driver->notify_event(udc,
2363                                 CI13XXX_CONTROLLER_STOPPED_EVENT);
2364                         _gadget_stop_activity(&udc->gadget);
2365                         pm_runtime_put_sync(&_gadget->dev);
2366                 }
2367         }
2368
2369         return 0;
2370 }
2371
2372 /**
2373  * Device operations part of the API to the USB controller hardware,
2374  * which don't involve endpoints (or i/o)
2375  * Check  "usb_gadget.h" for details
2376  */
2377 static const struct usb_gadget_ops usb_gadget_ops = {
2378         .vbus_session   = ci13xxx_vbus_session,
2379 };
2380
2381 /**
2382  * usb_gadget_probe_driver: register a gadget driver
2383  * @driver: the driver being registered
2384  * @bind: the driver's bind callback
2385  *
2386  * Check usb_gadget_probe_driver() at <linux/usb/gadget.h> for details.
2387  * Interrupts are enabled here.
2388  */
2389 int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
2390                 int (*bind)(struct usb_gadget *))
2391 {
2392         struct ci13xxx *udc = _udc;
2393         unsigned long i, k, flags;
2394         int retval = -ENOMEM;
2395
2396         trace("%p", driver);
2397
2398         if (driver             == NULL ||
2399             bind               == NULL ||
2400             driver->setup      == NULL ||
2401             driver->disconnect == NULL ||
2402             driver->suspend    == NULL ||
2403             driver->resume     == NULL)
2404                 return -EINVAL;
2405         else if (udc         == NULL)
2406                 return -ENODEV;
2407         else if (udc->driver != NULL)
2408                 return -EBUSY;
2409
2410         /* alloc resources */
2411         udc->qh_pool = dma_pool_create("ci13xxx_qh", &udc->gadget.dev,
2412                                        sizeof(struct ci13xxx_qh),
2413                                        64, CI13XXX_PAGE_SIZE);
2414         if (udc->qh_pool == NULL)
2415                 return -ENOMEM;
2416
2417         udc->td_pool = dma_pool_create("ci13xxx_td", &udc->gadget.dev,
2418                                        sizeof(struct ci13xxx_td),
2419                                        64, CI13XXX_PAGE_SIZE);
2420         if (udc->td_pool == NULL) {
2421                 dma_pool_destroy(udc->qh_pool);
2422                 udc->qh_pool = NULL;
2423                 return -ENOMEM;
2424         }
2425
2426         spin_lock_irqsave(udc->lock, flags);
2427
2428         info("hw_ep_max = %d", hw_ep_max);
2429
2430         udc->driver = driver;
2431         udc->gadget.dev.driver = NULL;
2432
2433         retval = 0;
2434         for (i = 0; i < hw_ep_max; i++) {
2435                 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
2436
2437                 scnprintf(mEp->name, sizeof(mEp->name), "ep%i", (int)i);
2438
2439                 mEp->lock         = udc->lock;
2440                 mEp->device       = &udc->gadget.dev;
2441                 mEp->td_pool      = udc->td_pool;
2442
2443                 mEp->ep.name      = mEp->name;
2444                 mEp->ep.ops       = &usb_ep_ops;
2445                 mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
2446
2447                 /* this allocation cannot be random */
2448                 for (k = RX; k <= TX; k++) {
2449                         INIT_LIST_HEAD(&mEp->qh[k].queue);
2450                         spin_unlock_irqrestore(udc->lock, flags);
2451                         mEp->qh[k].ptr = dma_pool_alloc(udc->qh_pool,
2452                                                         GFP_KERNEL,
2453                                                         &mEp->qh[k].dma);
2454                         spin_lock_irqsave(udc->lock, flags);
2455                         if (mEp->qh[k].ptr == NULL)
2456                                 retval = -ENOMEM;
2457                         else
2458                                 memset(mEp->qh[k].ptr, 0,
2459                                        sizeof(*mEp->qh[k].ptr));
2460                 }
2461                 if (i == 0)
2462                         udc->gadget.ep0 = &mEp->ep;
2463                 else
2464                         list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list);
2465         }
2466         if (retval)
2467                 goto done;
2468
2469         /* bind gadget */
2470         driver->driver.bus     = NULL;
2471         udc->gadget.dev.driver = &driver->driver;
2472
2473         spin_unlock_irqrestore(udc->lock, flags);
2474         retval = bind(&udc->gadget);                /* MAY SLEEP */
2475         spin_lock_irqsave(udc->lock, flags);
2476
2477         if (retval) {
2478                 udc->gadget.dev.driver = NULL;
2479                 goto done;
2480         }
2481
2482         pm_runtime_get_sync(&udc->gadget.dev);
2483         if (udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) {
2484                 if (udc->vbus_active) {
2485                         if (udc->udc_driver->flags & CI13XXX_REGS_SHARED)
2486                                 hw_device_reset(udc);
2487                 } else {
2488                         pm_runtime_put_sync(&udc->gadget.dev);
2489                         goto done;
2490                 }
2491         }
2492
2493         retval = hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
2494         if (retval)
2495                 pm_runtime_put_sync(&udc->gadget.dev);
2496
2497  done:
2498         spin_unlock_irqrestore(udc->lock, flags);
2499         if (retval)
2500                 usb_gadget_unregister_driver(driver);
2501         return retval;
2502 }
2503 EXPORT_SYMBOL(usb_gadget_probe_driver);
2504
2505 /**
2506  * usb_gadget_unregister_driver: unregister a gadget driver
2507  *
2508  * Check usb_gadget_unregister_driver() at "usb_gadget.h" for details
2509  */
2510 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
2511 {
2512         struct ci13xxx *udc = _udc;
2513         unsigned long i, k, flags;
2514
2515         trace("%p", driver);
2516
2517         if (driver             == NULL ||
2518             driver->unbind     == NULL ||
2519             driver->setup      == NULL ||
2520             driver->disconnect == NULL ||
2521             driver->suspend    == NULL ||
2522             driver->resume     == NULL ||
2523             driver             != udc->driver)
2524                 return -EINVAL;
2525
2526         spin_lock_irqsave(udc->lock, flags);
2527
2528         if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) ||
2529                         udc->vbus_active) {
2530                 hw_device_state(0);
2531                 if (udc->udc_driver->notify_event)
2532                         udc->udc_driver->notify_event(udc,
2533                         CI13XXX_CONTROLLER_STOPPED_EVENT);
2534                 _gadget_stop_activity(&udc->gadget);
2535                 pm_runtime_put(&udc->gadget.dev);
2536         }
2537
2538         /* unbind gadget */
2539         spin_unlock_irqrestore(udc->lock, flags);
2540         driver->unbind(&udc->gadget);               /* MAY SLEEP */
2541         spin_lock_irqsave(udc->lock, flags);
2542
2543         udc->gadget.dev.driver = NULL;
2544
2545         /* free resources */
2546         for (i = 0; i < hw_ep_max; i++) {
2547                 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
2548
2549                 if (i == 0)
2550                         udc->gadget.ep0 = NULL;
2551                 else if (!list_empty(&mEp->ep.ep_list))
2552                         list_del_init(&mEp->ep.ep_list);
2553
2554                 for (k = RX; k <= TX; k++)
2555                         if (mEp->qh[k].ptr != NULL)
2556                                 dma_pool_free(udc->qh_pool,
2557                                               mEp->qh[k].ptr, mEp->qh[k].dma);
2558         }
2559
2560         udc->driver = NULL;
2561
2562         spin_unlock_irqrestore(udc->lock, flags);
2563
2564         if (udc->td_pool != NULL) {
2565                 dma_pool_destroy(udc->td_pool);
2566                 udc->td_pool = NULL;
2567         }
2568         if (udc->qh_pool != NULL) {
2569                 dma_pool_destroy(udc->qh_pool);
2570                 udc->qh_pool = NULL;
2571         }
2572
2573         return 0;
2574 }
2575 EXPORT_SYMBOL(usb_gadget_unregister_driver);
2576
2577 /******************************************************************************
2578  * BUS block
2579  *****************************************************************************/
2580 /**
2581  * udc_irq: global interrupt handler
2582  *
2583  * This function returns IRQ_HANDLED if the IRQ has been handled
2584  * It locks access to registers
2585  */
2586 static irqreturn_t udc_irq(void)
2587 {
2588         struct ci13xxx *udc = _udc;
2589         irqreturn_t retval;
2590         u32 intr;
2591
2592         trace();
2593
2594         if (udc == NULL) {
2595                 err("ENODEV");
2596                 return IRQ_HANDLED;
2597         }
2598
2599         spin_lock(udc->lock);
2600
2601         if (udc->udc_driver->flags & CI13XXX_REGS_SHARED) {
2602                 if (hw_cread(CAP_USBMODE, USBMODE_CM) !=
2603                                 USBMODE_CM_DEVICE) {
2604                         spin_unlock(udc->lock);
2605                         return IRQ_NONE;
2606                 }
2607         }
2608         intr = hw_test_and_clear_intr_active();
2609         if (intr) {
2610                 isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intr;
2611                 isr_statistics.hndl.idx &= ISR_MASK;
2612                 isr_statistics.hndl.cnt++;
2613
2614                 /* order defines priority - do NOT change it */
2615                 if (USBi_URI & intr) {
2616                         isr_statistics.uri++;
2617                         isr_reset_handler(udc);
2618                 }
2619                 if (USBi_PCI & intr) {
2620                         isr_statistics.pci++;
2621                         udc->gadget.speed = hw_port_is_high_speed() ?
2622                                 USB_SPEED_HIGH : USB_SPEED_FULL;
2623                 }
2624                 if (USBi_UEI & intr)
2625                         isr_statistics.uei++;
2626                 if (USBi_UI  & intr) {
2627                         isr_statistics.ui++;
2628                         isr_tr_complete_handler(udc);
2629                 }
2630                 if (USBi_SLI & intr)
2631                         isr_statistics.sli++;
2632                 retval = IRQ_HANDLED;
2633         } else {
2634                 isr_statistics.none++;
2635                 retval = IRQ_NONE;
2636         }
2637         spin_unlock(udc->lock);
2638
2639         return retval;
2640 }
2641
2642 /**
2643  * udc_release: driver release function
2644  * @dev: device
2645  *
2646  * Currently does nothing
2647  */
2648 static void udc_release(struct device *dev)
2649 {
2650         trace("%p", dev);
2651
2652         if (dev == NULL)
2653                 err("EINVAL");
2654 }
2655
2656 /**
2657  * udc_probe: parent probe must call this to initialize UDC
2658  * @dev:  parent device
2659  * @regs: registers base address
2660  * @name: driver name
2661  *
2662  * This function returns an error code
2663  * No interrupts active, the IRQ has not been requested yet
2664  * Kernel assumes 32-bit DMA operations by default, no need to dma_set_mask
2665  */
2666 static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
2667                 void __iomem *regs)
2668 {
2669         struct ci13xxx *udc;
2670         int retval = 0;
2671
2672         trace("%p, %p, %p", dev, regs, name);
2673
2674         if (dev == NULL || regs == NULL || driver == NULL ||
2675                         driver->name == NULL)
2676                 return -EINVAL;
2677
2678         udc = kzalloc(sizeof(struct ci13xxx), GFP_KERNEL);
2679         if (udc == NULL)
2680                 return -ENOMEM;
2681
2682         udc->lock = &udc_lock;
2683         udc->regs = regs;
2684         udc->udc_driver = driver;
2685
2686         udc->gadget.ops          = &usb_gadget_ops;
2687         udc->gadget.speed        = USB_SPEED_UNKNOWN;
2688         udc->gadget.is_dualspeed = 1;
2689         udc->gadget.is_otg       = 0;
2690         udc->gadget.name         = driver->name;
2691
2692         INIT_LIST_HEAD(&udc->gadget.ep_list);
2693         udc->gadget.ep0 = NULL;
2694
2695         dev_set_name(&udc->gadget.dev, "gadget");
2696         udc->gadget.dev.dma_mask = dev->dma_mask;
2697         udc->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
2698         udc->gadget.dev.parent   = dev;
2699         udc->gadget.dev.release  = udc_release;
2700
2701         retval = hw_device_init(regs);
2702         if (retval < 0)
2703                 goto free_udc;
2704
2705         udc->transceiver = otg_get_transceiver();
2706
2707         if (udc->udc_driver->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
2708                 if (udc->transceiver == NULL) {
2709                         retval = -ENODEV;
2710                         goto free_udc;
2711                 }
2712         }
2713
2714         if (!(udc->udc_driver->flags & CI13XXX_REGS_SHARED)) {
2715                 retval = hw_device_reset(udc);
2716                 if (retval)
2717                         goto put_transceiver;
2718         }
2719
2720         retval = device_register(&udc->gadget.dev);
2721         if (retval) {
2722                 put_device(&udc->gadget.dev);
2723                 goto put_transceiver;
2724         }
2725
2726 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2727         retval = dbg_create_files(&udc->gadget.dev);
2728 #endif
2729         if (retval)
2730                 goto unreg_device;
2731
2732         if (udc->transceiver) {
2733                 retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
2734                 if (retval)
2735                         goto remove_dbg;
2736         }
2737         pm_runtime_no_callbacks(&udc->gadget.dev);
2738         pm_runtime_enable(&udc->gadget.dev);
2739
2740         _udc = udc;
2741         return retval;
2742
2743         err("error = %i", retval);
2744 remove_dbg:
2745 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2746         dbg_remove_files(&udc->gadget.dev);
2747 #endif
2748 unreg_device:
2749         device_unregister(&udc->gadget.dev);
2750 put_transceiver:
2751         if (udc->transceiver)
2752                 otg_put_transceiver(udc->transceiver);
2753 free_udc:
2754         kfree(udc);
2755         _udc = NULL;
2756         return retval;
2757 }
2758
2759 /**
2760  * udc_remove: parent remove must call this to remove UDC
2761  *
2762  * No interrupts active, the IRQ has been released
2763  */
2764 static void udc_remove(void)
2765 {
2766         struct ci13xxx *udc = _udc;
2767
2768         if (udc == NULL) {
2769                 err("EINVAL");
2770                 return;
2771         }
2772
2773         if (udc->transceiver) {
2774                 otg_set_peripheral(udc->transceiver, &udc->gadget);
2775                 otg_put_transceiver(udc->transceiver);
2776         }
2777 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
2778         dbg_remove_files(&udc->gadget.dev);
2779 #endif
2780         device_unregister(&udc->gadget.dev);
2781
2782         kfree(udc);
2783         _udc = NULL;
2784 }