drivers/usb/gadget/udc/net2272.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for PLX NET2272 USB device controller
   4  *
   5  * Copyright (C) 2005-2006 PLX Technology, Inc.
   6  * Copyright (C) 2006-2011 Analog Devices, Inc.
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/device.h>
  11 #include <linux/errno.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/io.h>
  15 #include <linux/ioport.h>
  16 #include <linux/kernel.h>
  17 #include <linux/list.h>
  18 #include <linux/module.h>
  19 #include <linux/moduleparam.h>
  20 #include <linux/pci.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/prefetch.h>
  23 #include <linux/sched.h>
  24 #include <linux/slab.h>
  25 #include <linux/timer.h>
  26 #include <linux/usb.h>
  27 #include <linux/usb/ch9.h>
  28 #include <linux/usb/gadget.h>
  29
  30 #include <asm/byteorder.h>
  31 #include <asm/unaligned.h>
  32
  33 #include "net2272.h"
  34
  35 #define DRIVER_DESC "PLX NET2272 USB Peripheral Controller"
  36
  37 static const char driver_name[] = "net2272";
  38 static const char driver_vers[] = "2006 October 17/mainline";
  39 static const char driver_desc[] = DRIVER_DESC;
  40
  41 static const char ep0name[] = "ep0";
  42 static const char * const ep_name[] = {
  43         ep0name,
  44         "ep-a", "ep-b", "ep-c",
  45 };
  46
  47 #ifdef CONFIG_USB_NET2272_DMA
  48 /*
  49  * use_dma: the NET2272 can use an external DMA controller.
  50  * Note that since there is no generic DMA api, some functions,
  51  * notably request_dma, start_dma, and cancel_dma will need to be
  52  * modified for your platform's particular dma controller.
  53  *
  54  * If use_dma is disabled, pio will be used instead.
  55  */
  56 static bool use_dma = false;
  57 module_param(use_dma, bool, 0644);
  58
  59 /*
  60  * dma_ep: selects the endpoint for use with dma (1=ep-a, 2=ep-b)
  61  * The NET2272 can only use dma for a single endpoint at a time.
  62  * At some point this could be modified to allow either endpoint
  63  * to take control of dma as it becomes available.
  64  *
  65  * Note that DMA should not be used on OUT endpoints unless it can
  66  * be guaranteed that no short packets will arrive on an IN endpoint
  67  * while the DMA operation is pending.  Otherwise the OUT DMA will
  68  * terminate prematurely (See NET2272 Errata 630-0213-0101)
  69  */
  70 static ushort dma_ep = 1;
  71 module_param(dma_ep, ushort, 0644);
  72
  73 /*
  74  * dma_mode: net2272 dma mode setting (see LOCCTL1 definiton):
  75  *      mode 0 == Slow DREQ mode
  76  *      mode 1 == Fast DREQ mode
  77  *      mode 2 == Burst mode
  78  */
  79 static ushort dma_mode = 2;
  80 module_param(dma_mode, ushort, 0644);
  81 #else
  82 #define use_dma 0
  83 #define dma_ep 1
  84 #define dma_mode 2
  85 #endif
  86
  87 /*
  88  * fifo_mode: net2272 buffer configuration:
  89  *      mode 0 == ep-{a,b,c} 512db each
  90  *      mode 1 == ep-a 1k, ep-{b,c} 512db
  91  *      mode 2 == ep-a 1k, ep-b 1k, ep-c 512db
  92  *      mode 3 == ep-a 1k, ep-b disabled, ep-c 512db
  93  */
  94 static ushort fifo_mode = 0;
  95 module_param(fifo_mode, ushort, 0644);
  96
  97 /*
  98  * enable_suspend: When enabled, the driver will respond to
  99  * USB suspend requests by powering down the NET2272.  Otherwise,
 100  * USB suspend requests will be ignored.  This is acceptible for
 101  * self-powered devices.  For bus powered devices set this to 1.
 102  */
 103 static ushort enable_suspend = 0;
 104 module_param(enable_suspend, ushort, 0644);
 105
 106 static void assert_out_naking(struct net2272_ep *ep, const char *where)
 107 {
 108         u8 tmp;
 109
 110 #ifndef DEBUG
 111         return;
 112 #endif
 113
 114         tmp = net2272_ep_read(ep, EP_STAT0);
 115         if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
 116                 dev_dbg(ep->dev->dev, "%s %s %02x !NAK\n",
 117                         ep->ep.name, where, tmp);
 118                 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
 119         }
 120 }
 121 #define ASSERT_OUT_NAKING(ep) assert_out_naking(ep, __func__)
 122
 123 static void stop_out_naking(struct net2272_ep *ep)
 124 {
 125         u8 tmp = net2272_ep_read(ep, EP_STAT0);
 126
 127         if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
 128                 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
 129 }
 130
 131 #define PIPEDIR(bAddress) (usb_pipein(bAddress) ? "in" : "out")
 132
 133 static char *type_string(u8 bmAttributes)
 134 {
 135         switch ((bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) {
 136         case USB_ENDPOINT_XFER_BULK: return "bulk";
 137         case USB_ENDPOINT_XFER_ISOC: return "iso";
 138         case USB_ENDPOINT_XFER_INT:  return "intr";
 139         default:                     return "control";
 140         }
 141 }
 142
 143 static char *buf_state_string(unsigned state)
 144 {
 145         switch (state) {
 146         case BUFF_FREE:  return "free";
 147         case BUFF_VALID: return "valid";
 148         case BUFF_LCL:   return "local";
 149         case BUFF_USB:   return "usb";
 150         default:         return "unknown";
 151         }
 152 }
 153
 154 static char *dma_mode_string(void)
 155 {
 156         if (!use_dma)
 157                 return "PIO";
 158         switch (dma_mode) {
 159         case 0:  return "SLOW DREQ";
 160         case 1:  return "FAST DREQ";
 161         case 2:  return "BURST";
 162         default: return "invalid";
 163         }
 164 }
 165
 166 static void net2272_dequeue_all(struct net2272_ep *);
 167 static int net2272_kick_dma(struct net2272_ep *, struct net2272_request *);
 168 static int net2272_fifo_status(struct usb_ep *);
 169
 170 static const struct usb_ep_ops net2272_ep_ops;
 171
 172 /*---------------------------------------------------------------------------*/
 173
 174 static int
 175 net2272_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 176 {
 177         struct net2272 *dev;
 178         struct net2272_ep *ep;
 179         u32 max;
 180         u8 tmp;
 181         unsigned long flags;
 182
 183         ep = container_of(_ep, struct net2272_ep, ep);
 184         if (!_ep || !desc || ep->desc || _ep->name == ep0name
 185                         || desc->bDescriptorType != USB_DT_ENDPOINT)
 186                 return -EINVAL;
 187         dev = ep->dev;
 188         if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
 189                 return -ESHUTDOWN;
 190
 191         max = usb_endpoint_maxp(desc);
 192
 193         spin_lock_irqsave(&dev->lock, flags);
 194         _ep->maxpacket = max;
 195         ep->desc = desc;
 196
 197         /* net2272_ep_reset() has already been called */
 198         ep->stopped = 0;
 199         ep->wedged = 0;
 200
 201         /* set speed-dependent max packet */
 202         net2272_ep_write(ep, EP_MAXPKT0, max & 0xff);
 203         net2272_ep_write(ep, EP_MAXPKT1, (max & 0xff00) >> 8);
 204
 205         /* set type, direction, address; reset fifo counters */
 206         net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
 207         tmp = usb_endpoint_type(desc);
 208         if (usb_endpoint_xfer_bulk(desc)) {
 209                 /* catch some particularly blatant driver bugs */
 210                 if ((dev->gadget.speed == USB_SPEED_HIGH && max != 512) ||
 211                     (dev->gadget.speed == USB_SPEED_FULL && max > 64)) {
 212                         spin_unlock_irqrestore(&dev->lock, flags);
 213                         return -ERANGE;
 214                 }
 215         }
 216         ep->is_iso = usb_endpoint_xfer_isoc(desc) ? 1 : 0;
 217         tmp <<= ENDPOINT_TYPE;
 218         tmp |= ((desc->bEndpointAddress & 0x0f) << ENDPOINT_NUMBER);
 219         tmp |= usb_endpoint_dir_in(desc) << ENDPOINT_DIRECTION;
 220         tmp |= (1 << ENDPOINT_ENABLE);
 221
 222         /* for OUT transfers, block the rx fifo until a read is posted */
 223         ep->is_in = usb_endpoint_dir_in(desc);
 224         if (!ep->is_in)
 225                 net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
 226
 227         net2272_ep_write(ep, EP_CFG, tmp);
 228
 229         /* enable irqs */
 230         tmp = (1 << ep->num) | net2272_read(dev, IRQENB0);
 231         net2272_write(dev, IRQENB0, tmp);
 232
 233         tmp = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
 234                 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
 235                 | net2272_ep_read(ep, EP_IRQENB);
 236         net2272_ep_write(ep, EP_IRQENB, tmp);
 237
 238         tmp = desc->bEndpointAddress;
 239         dev_dbg(dev->dev, "enabled %s (ep%d%s-%s) max %04x cfg %02x\n",
 240                 _ep->name, tmp & 0x0f, PIPEDIR(tmp),
 241                 type_string(desc->bmAttributes), max,
 242                 net2272_ep_read(ep, EP_CFG));
 243
 244         spin_unlock_irqrestore(&dev->lock, flags);
 245         return 0;
 246 }
 247
 248 static void net2272_ep_reset(struct net2272_ep *ep)
 249 {
 250         u8 tmp;
 251
 252         ep->desc = NULL;
 253         INIT_LIST_HEAD(&ep->queue);
 254
 255         usb_ep_set_maxpacket_limit(&ep->ep, ~0);
 256         ep->ep.ops = &net2272_ep_ops;
 257
 258         /* disable irqs, endpoint */
 259         net2272_ep_write(ep, EP_IRQENB, 0);
 260
 261         /* init to our chosen defaults, notably so that we NAK OUT
 262          * packets until the driver queues a read.
 263          */
 264         tmp = (1 << NAK_OUT_PACKETS_MODE) | (1 << ALT_NAK_OUT_PACKETS);
 265         net2272_ep_write(ep, EP_RSPSET, tmp);
 266
 267         tmp = (1 << INTERRUPT_MODE) | (1 << HIDE_STATUS_PHASE);
 268         if (ep->num != 0)
 269                 tmp |= (1 << ENDPOINT_TOGGLE) | (1 << ENDPOINT_HALT);
 270
 271         net2272_ep_write(ep, EP_RSPCLR, tmp);
 272
 273         /* scrub most status bits, and flush any fifo state */
 274         net2272_ep_write(ep, EP_STAT0,
 275                           (1 << DATA_IN_TOKEN_INTERRUPT)
 276                         | (1 << DATA_OUT_TOKEN_INTERRUPT)
 277                         | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
 278                         | (1 << DATA_PACKET_RECEIVED_INTERRUPT)
 279                         | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
 280
 281         net2272_ep_write(ep, EP_STAT1,
 282                             (1 << TIMEOUT)
 283                           | (1 << USB_OUT_ACK_SENT)
 284                           | (1 << USB_OUT_NAK_SENT)
 285                           | (1 << USB_IN_ACK_RCVD)
 286                           | (1 << USB_IN_NAK_SENT)
 287                           | (1 << USB_STALL_SENT)
 288                           | (1 << LOCAL_OUT_ZLP)
 289                           | (1 << BUFFER_FLUSH));
 290
 291         /* fifo size is handled seperately */
 292 }
 293
 294 static int net2272_disable(struct usb_ep *_ep)
 295 {
 296         struct net2272_ep *ep;
 297         unsigned long flags;
 298
 299         ep = container_of(_ep, struct net2272_ep, ep);
 300         if (!_ep || !ep->desc || _ep->name == ep0name)
 301                 return -EINVAL;
 302
 303         spin_lock_irqsave(&ep->dev->lock, flags);
 304         net2272_dequeue_all(ep);
 305         net2272_ep_reset(ep);
 306
 307         dev_vdbg(ep->dev->dev, "disabled %s\n", _ep->name);
 308
 309         spin_unlock_irqrestore(&ep->dev->lock, flags);
 310         return 0;
 311 }
 312
 313 /*---------------------------------------------------------------------------*/
 314
 315 static struct usb_request *
 316 net2272_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
 317 {
 318         struct net2272_request *req;
 319
 320         if (!_ep)
 321                 return NULL;
 322
 323         req = kzalloc(sizeof(*req), gfp_flags);
 324         if (!req)
 325                 return NULL;
 326
 327         INIT_LIST_HEAD(&req->queue);
 328
 329         return &req->req;
 330 }
 331
 332 static void
 333 net2272_free_request(struct usb_ep *_ep, struct usb_request *_req)
 334 {
 335         struct net2272_request *req;
 336
 337         if (!_ep || !_req)
 338                 return;
 339
 340         req = container_of(_req, struct net2272_request, req);
 341         WARN_ON(!list_empty(&req->queue));
 342         kfree(req);
 343 }
 344
 345 static void
 346 net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
 347 {
 348         struct net2272 *dev;
 349         unsigned stopped = ep->stopped;
 350
 351         if (ep->num == 0) {
 352                 if (ep->dev->protocol_stall) {
 353                         ep->stopped = 1;
 354                         set_halt(ep);
 355                 }
 356                 allow_status(ep);
 357         }
 358
 359         list_del_init(&req->queue);
 360
 361         if (req->req.status == -EINPROGRESS)
 362                 req->req.status = status;
 363         else
 364                 status = req->req.status;
 365
 366         dev = ep->dev;
 367         if (use_dma && ep->dma)
 368                 usb_gadget_unmap_request(&dev->gadget, &req->req,
 369                                 ep->is_in);
 370
 371         if (status && status != -ESHUTDOWN)
 372                 dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
 373                         ep->ep.name, &req->req, status,
 374                         req->req.actual, req->req.length, req->req.buf);
 375
 376         /* don't modify queue heads during completion callback */
 377         ep->stopped = 1;
 378         spin_unlock(&dev->lock);
 379         usb_gadget_giveback_request(&ep->ep, &req->req);
 380         spin_lock(&dev->lock);
 381         ep->stopped = stopped;
 382 }
 383
 384 static int
 385 net2272_write_packet(struct net2272_ep *ep, u8 *buf,
 386         struct net2272_request *req, unsigned max)
 387 {
 388         u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
 389         u16 *bufp;
 390         unsigned length, count;
 391         u8 tmp;
 392
 393         length = min(req->req.length - req->req.actual, max);
 394         req->req.actual += length;
 395
 396         dev_vdbg(ep->dev->dev, "write packet %s req %p max %u len %u avail %u\n",
 397                 ep->ep.name, req, max, length,
 398                 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0));
 399
 400         count = length;
 401         bufp = (u16 *)buf;
 402
 403         while (likely(count >= 2)) {
 404                 /* no byte-swap required; chip endian set during init */
 405                 writew(*bufp++, ep_data);
 406                 count -= 2;
 407         }
 408         buf = (u8 *)bufp;
 409
 410         /* write final byte by placing the NET2272 into 8-bit mode */
 411         if (unlikely(count)) {
 412                 tmp = net2272_read(ep->dev, LOCCTL);
 413                 net2272_write(ep->dev, LOCCTL, tmp & ~(1 << DATA_WIDTH));
 414                 writeb(*buf, ep_data);
 415                 net2272_write(ep->dev, LOCCTL, tmp);
 416         }
 417         return length;
 418 }
 419
 420 /* returns: 0: still running, 1: completed, negative: errno */
 421 static int
 422 net2272_write_fifo(struct net2272_ep *ep, struct net2272_request *req)
 423 {
 424         u8 *buf;
 425         unsigned count, max;
 426         int status;
 427
 428         dev_vdbg(ep->dev->dev, "write_fifo %s actual %d len %d\n",
 429                 ep->ep.name, req->req.actual, req->req.length);
 430
 431         /*
 432          * Keep loading the endpoint until the final packet is loaded,
 433          * or the endpoint buffer is full.
 434          */
 435  top:
 436         /*
 437          * Clear interrupt status
 438          *  - Packet Transmitted interrupt will become set again when the
 439          *    host successfully takes another packet
 440          */
 441         net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT));
 442         while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_FULL))) {
 443                 buf = req->req.buf + req->req.actual;
 444                 prefetch(buf);
 445
 446                 /* force pagesel */
 447                 net2272_ep_read(ep, EP_STAT0);
 448
 449                 max = (net2272_ep_read(ep, EP_AVAIL1) << 8) |
 450                         (net2272_ep_read(ep, EP_AVAIL0));
 451
 452                 if (max < ep->ep.maxpacket)
 453                         max = (net2272_ep_read(ep, EP_AVAIL1) << 8)
 454                                 | (net2272_ep_read(ep, EP_AVAIL0));
 455
 456                 count = net2272_write_packet(ep, buf, req, max);
 457                 /* see if we are done */
 458                 if (req->req.length == req->req.actual) {
 459                         /* validate short or zlp packet */
 460                         if (count < ep->ep.maxpacket)
 461                                 set_fifo_bytecount(ep, 0);
 462                         net2272_done(ep, req, 0);
 463
 464                         if (!list_empty(&ep->queue)) {
 465                                 req = list_entry(ep->queue.next,
 466                                                 struct net2272_request,
 467                                                 queue);
 468                                 status = net2272_kick_dma(ep, req);
 469
 470                                 if (status < 0)
 471                                         if ((net2272_ep_read(ep, EP_STAT0)
 472                                                         & (1 << BUFFER_EMPTY)))
 473                                                 goto top;
 474                         }
 475                         return 1;
 476                 }
 477                 net2272_ep_write(ep, EP_STAT0, (1 << DATA_PACKET_TRANSMITTED_INTERRUPT));
 478         }
 479         return 0;
 480 }
 481
 482 static void
 483 net2272_out_flush(struct net2272_ep *ep)
 484 {
 485         ASSERT_OUT_NAKING(ep);
 486
 487         net2272_ep_write(ep, EP_STAT0, (1 << DATA_OUT_TOKEN_INTERRUPT)
 488                         | (1 << DATA_PACKET_RECEIVED_INTERRUPT));
 489         net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
 490 }
 491
 492 static int
 493 net2272_read_packet(struct net2272_ep *ep, u8 *buf,
 494         struct net2272_request *req, unsigned avail)
 495 {
 496         u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
 497         unsigned is_short;
 498         u16 *bufp;
 499
 500         req->req.actual += avail;
 501
 502         dev_vdbg(ep->dev->dev, "read packet %s req %p len %u avail %u\n",
 503                 ep->ep.name, req, avail,
 504                 (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0));
 505
 506         is_short = (avail < ep->ep.maxpacket);
 507
 508         if (unlikely(avail == 0)) {
 509                 /* remove any zlp from the buffer */
 510                 (void)readw(ep_data);
 511                 return is_short;
 512         }
 513
 514         /* Ensure we get the final byte */
 515         if (unlikely(avail % 2))
 516                 avail++;
 517         bufp = (u16 *)buf;
 518
 519         do {
 520                 *bufp++ = readw(ep_data);
 521                 avail -= 2;
 522         } while (avail);
 523
 524         /*
 525          * To avoid false endpoint available race condition must read
 526          * ep stat0 twice in the case of a short transfer
 527          */
 528         if (net2272_ep_read(ep, EP_STAT0) & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT))
 529                 net2272_ep_read(ep, EP_STAT0);
 530
 531         return is_short;
 532 }
 533
 534 static int
 535 net2272_read_fifo(struct net2272_ep *ep, struct net2272_request *req)
 536 {
 537         u8 *buf;
 538         unsigned is_short;
 539         int count;
 540         int tmp;
 541         int cleanup = 0;
 542         int status = -1;
 543
 544         dev_vdbg(ep->dev->dev, "read_fifo %s actual %d len %d\n",
 545                 ep->ep.name, req->req.actual, req->req.length);
 546
 547  top:
 548         do {
 549                 buf = req->req.buf + req->req.actual;
 550                 prefetchw(buf);
 551
 552                 count = (net2272_ep_read(ep, EP_AVAIL1) << 8)
 553                         | net2272_ep_read(ep, EP_AVAIL0);
 554
 555                 net2272_ep_write(ep, EP_STAT0,
 556                         (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT) |
 557                         (1 << DATA_PACKET_RECEIVED_INTERRUPT));
 558
 559                 tmp = req->req.length - req->req.actual;
 560
 561                 if (count > tmp) {
 562                         if ((tmp % ep->ep.maxpacket) != 0) {
 563                                 dev_err(ep->dev->dev,
 564                                         "%s out fifo %d bytes, expected %d\n",
 565                                         ep->ep.name, count, tmp);
 566                                 cleanup = 1;
 567                         }
 568                         count = (tmp > 0) ? tmp : 0;
 569                 }
 570
 571                 is_short = net2272_read_packet(ep, buf, req, count);
 572
 573                 /* completion */
 574                 if (unlikely(cleanup || is_short ||
 575                                 req->req.actual == req->req.length)) {
 576
 577                         if (cleanup) {
 578                                 net2272_out_flush(ep);
 579                                 net2272_done(ep, req, -EOVERFLOW);
 580                         } else
 581                                 net2272_done(ep, req, 0);
 582
 583                         /* re-initialize endpoint transfer registers
 584                          * otherwise they may result in erroneous pre-validation
 585                          * for subsequent control reads
 586                          */
 587                         if (unlikely(ep->num == 0)) {
 588                                 net2272_ep_write(ep, EP_TRANSFER2, 0);
 589                                 net2272_ep_write(ep, EP_TRANSFER1, 0);
 590                                 net2272_ep_write(ep, EP_TRANSFER0, 0);
 591                         }
 592
 593                         if (!list_empty(&ep->queue)) {
 594                                 req = list_entry(ep->queue.next,
 595                                         struct net2272_request, queue);
 596                                 status = net2272_kick_dma(ep, req);
 597                                 if ((status < 0) &&
 598                                     !(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY)))
 599                                         goto top;
 600                         }
 601                         return 1;
 602                 }
 603         } while (!(net2272_ep_read(ep, EP_STAT0) & (1 << BUFFER_EMPTY)));
 604
 605         return 0;
 606 }
 607
 608 static void
 609 net2272_pio_advance(struct net2272_ep *ep)
 610 {
 611         struct net2272_request *req;
 612
 613         if (unlikely(list_empty(&ep->queue)))
 614                 return;
 615
 616         req = list_entry(ep->queue.next, struct net2272_request, queue);
 617         (ep->is_in ? net2272_write_fifo : net2272_read_fifo)(ep, req);
 618 }
 619
 620 /* returns 0 on success, else negative errno */
 621 static int
 622 net2272_request_dma(struct net2272 *dev, unsigned ep, u32 buf,
 623         unsigned len, unsigned dir)
 624 {
 625         dev_vdbg(dev->dev, "request_dma ep %d buf %08x len %d dir %d\n",
 626                 ep, buf, len, dir);
 627
 628         /* The NET2272 only supports a single dma channel */
 629         if (dev->dma_busy)
 630                 return -EBUSY;
 631         /*
 632          * EP_TRANSFER (used to determine the number of bytes received
 633          * in an OUT transfer) is 24 bits wide; don't ask for more than that.
 634          */
 635         if ((dir == 1) && (len > 0x1000000))
 636                 return -EINVAL;
 637
 638         dev->dma_busy = 1;
 639
 640         /* initialize platform's dma */
 641 #ifdef CONFIG_USB_PCI
 642         /* NET2272 addr, buffer addr, length, etc. */
 643         switch (dev->dev_id) {
 644         case PCI_DEVICE_ID_RDK1:
 645                 /* Setup PLX 9054 DMA mode */
 646                 writel((1 << LOCAL_BUS_WIDTH) |
 647                         (1 << TA_READY_INPUT_ENABLE) |
 648                         (0 << LOCAL_BURST_ENABLE) |
 649                         (1 << DONE_INTERRUPT_ENABLE) |
 650                         (1 << LOCAL_ADDRESSING_MODE) |
 651                         (1 << DEMAND_MODE) |
 652                         (1 << DMA_EOT_ENABLE) |
 653                         (1 << FAST_SLOW_TERMINATE_MODE_SELECT) |
 654                         (1 << DMA_CHANNEL_INTERRUPT_SELECT),
 655                         dev->rdk1.plx9054_base_addr + DMAMODE0);
 656
 657                 writel(0x100000, dev->rdk1.plx9054_base_addr + DMALADR0);
 658                 writel(buf, dev->rdk1.plx9054_base_addr + DMAPADR0);
 659                 writel(len, dev->rdk1.plx9054_base_addr + DMASIZ0);
 660                 writel((dir << DIRECTION_OF_TRANSFER) |
 661                         (1 << INTERRUPT_AFTER_TERMINAL_COUNT),
 662                         dev->rdk1.plx9054_base_addr + DMADPR0);
 663                 writel((1 << LOCAL_DMA_CHANNEL_0_INTERRUPT_ENABLE) |
 664                         readl(dev->rdk1.plx9054_base_addr + INTCSR),
 665                         dev->rdk1.plx9054_base_addr + INTCSR);
 666
 667                 break;
 668         }
 669 #endif
 670
 671         net2272_write(dev, DMAREQ,
 672                 (0 << DMA_BUFFER_VALID) |
 673                 (1 << DMA_REQUEST_ENABLE) |
 674                 (1 << DMA_CONTROL_DACK) |
 675                 (dev->dma_eot_polarity << EOT_POLARITY) |
 676                 (dev->dma_dack_polarity << DACK_POLARITY) |
 677                 (dev->dma_dreq_polarity << DREQ_POLARITY) |
 678                 ((ep >> 1) << DMA_ENDPOINT_SELECT));
 679
 680         (void) net2272_read(dev, SCRATCH);
 681
 682         return 0;
 683 }
 684
 685 static void
 686 net2272_start_dma(struct net2272 *dev)
 687 {
 688         /* start platform's dma controller */
 689 #ifdef CONFIG_USB_PCI
 690         switch (dev->dev_id) {
 691         case PCI_DEVICE_ID_RDK1:
 692                 writeb((1 << CHANNEL_ENABLE) | (1 << CHANNEL_START),
 693                         dev->rdk1.plx9054_base_addr + DMACSR0);
 694                 break;
 695         }
 696 #endif
 697 }
 698
 699 /* returns 0 on success, else negative errno */
 700 static int
 701 net2272_kick_dma(struct net2272_ep *ep, struct net2272_request *req)
 702 {
 703         unsigned size;
 704         u8 tmp;
 705
 706         if (!use_dma || (ep->num < 1) || (ep->num > 2) || !ep->dma)
 707                 return -EINVAL;
 708
 709         /* don't use dma for odd-length transfers
 710          * otherwise, we'd need to deal with the last byte with pio
 711          */
 712         if (req->req.length & 1)
 713                 return -EINVAL;
 714
 715         dev_vdbg(ep->dev->dev, "kick_dma %s req %p dma %08llx\n",
 716                 ep->ep.name, req, (unsigned long long) req->req.dma);
 717
 718         net2272_ep_write(ep, EP_RSPSET, 1 << ALT_NAK_OUT_PACKETS);
 719
 720         /* The NET2272 can only use DMA on one endpoint at a time */
 721         if (ep->dev->dma_busy)
 722                 return -EBUSY;
 723
 724         /* Make sure we only DMA an even number of bytes (we'll use
 725          * pio to complete the transfer)
 726          */
 727         size = req->req.length;
 728         size &= ~1;
 729
 730         /* device-to-host transfer */
 731         if (ep->is_in) {
 732                 /* initialize platform's dma controller */
 733                 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 0))
 734                         /* unable to obtain DMA channel; return error and use pio mode */
 735                         return -EBUSY;
 736                 req->req.actual += size;
 737
 738         /* host-to-device transfer */
 739         } else {
 740                 tmp = net2272_ep_read(ep, EP_STAT0);
 741
 742                 /* initialize platform's dma controller */
 743                 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 1))
 744                         /* unable to obtain DMA channel; return error and use pio mode */
 745                         return -EBUSY;
 746
 747                 if (!(tmp & (1 << BUFFER_EMPTY)))
 748                         ep->not_empty = 1;
 749                 else
 750                         ep->not_empty = 0;
 751
 752
 753                 /* allow the endpoint's buffer to fill */
 754                 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
 755
 756                 /* this transfer completed and data's already in the fifo
 757                  * return error so pio gets used.
 758                  */
 759                 if (tmp & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)) {
 760
 761                         /* deassert dreq */
 762                         net2272_write(ep->dev, DMAREQ,
 763                                 (0 << DMA_BUFFER_VALID) |
 764                                 (0 << DMA_REQUEST_ENABLE) |
 765                                 (1 << DMA_CONTROL_DACK) |
 766                                 (ep->dev->dma_eot_polarity << EOT_POLARITY) |
 767                                 (ep->dev->dma_dack_polarity << DACK_POLARITY) |
 768                                 (ep->dev->dma_dreq_polarity << DREQ_POLARITY) |
 769                                 ((ep->num >> 1) << DMA_ENDPOINT_SELECT));
 770
 771                         return -EBUSY;
 772                 }
 773         }
 774
 775         /* Don't use per-packet interrupts: use dma interrupts only */
 776         net2272_ep_write(ep, EP_IRQENB, 0);
 777
 778         net2272_start_dma(ep->dev);
 779
 780         return 0;
 781 }
 782
 783 static void net2272_cancel_dma(struct net2272 *dev)
 784 {
 785 #ifdef CONFIG_USB_PCI
 786         switch (dev->dev_id) {
 787         case PCI_DEVICE_ID_RDK1:
 788                 writeb(0, dev->rdk1.plx9054_base_addr + DMACSR0);
 789                 writeb(1 << CHANNEL_ABORT, dev->rdk1.plx9054_base_addr + DMACSR0);
 790                 while (!(readb(dev->rdk1.plx9054_base_addr + DMACSR0) &
 791                          (1 << CHANNEL_DONE)))
 792                         continue;       /* wait for dma to stabalize */
 793
 794                 /* dma abort generates an interrupt */
 795                 writeb(1 << CHANNEL_CLEAR_INTERRUPT,
 796                         dev->rdk1.plx9054_base_addr + DMACSR0);
 797                 break;
 798         }
 799 #endif
 800
 801         dev->dma_busy = 0;
 802 }
 803
 804 /*---------------------------------------------------------------------------*/
 805
 806 static int
 807 net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 808 {
 809         struct net2272_request *req;
 810         struct net2272_ep *ep;
 811         struct net2272 *dev;
 812         unsigned long flags;
 813         int status = -1;
 814         u8 s;
 815
 816         req = container_of(_req, struct net2272_request, req);
 817         if (!_req || !_req->complete || !_req->buf
 818                         || !list_empty(&req->queue))
 819                 return -EINVAL;
 820         ep = container_of(_ep, struct net2272_ep, ep);
 821         if (!_ep || (!ep->desc && ep->num != 0))
 822                 return -EINVAL;
 823         dev = ep->dev;
 824         if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
 825                 return -ESHUTDOWN;
 826
 827         /* set up dma mapping in case the caller didn't */
 828         if (use_dma && ep->dma) {
 829                 status = usb_gadget_map_request(&dev->gadget, _req,
 830                                 ep->is_in);
 831                 if (status)
 832                         return status;
 833         }
 834
 835         dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n",
 836                 _ep->name, _req, _req->length, _req->buf,
 837                 (unsigned long long) _req->dma, _req->zero ? "zero" : "!zero");
 838
 839         spin_lock_irqsave(&dev->lock, flags);
 840
 841         _req->status = -EINPROGRESS;
 842         _req->actual = 0;
 843
 844         /* kickstart this i/o queue? */
 845         if (list_empty(&ep->queue) && !ep->stopped) {
 846                 /* maybe there's no control data, just status ack */
 847                 if (ep->num == 0 && _req->length == 0) {
 848                         net2272_done(ep, req, 0);
 849                         dev_vdbg(dev->dev, "%s status ack\n", ep->ep.name);
 850                         goto done;
 851                 }
 852
 853                 /* Return zlp, don't let it block subsequent packets */
 854                 s = net2272_ep_read(ep, EP_STAT0);
 855                 if (s & (1 << BUFFER_EMPTY)) {
 856                         /* Buffer is empty check for a blocking zlp, handle it */
 857                         if ((s & (1 << NAK_OUT_PACKETS)) &&
 858                             net2272_ep_read(ep, EP_STAT1) & (1 << LOCAL_OUT_ZLP)) {
 859                                 dev_dbg(dev->dev, "WARNING: returning ZLP short packet termination!\n");
 860                                 /*
 861                                  * Request is going to terminate with a short packet ...
 862                                  * hope the client is ready for it!
 863                                  */
 864                                 status = net2272_read_fifo(ep, req);
 865                                 /* clear short packet naking */
 866                                 net2272_ep_write(ep, EP_STAT0, (1 << NAK_OUT_PACKETS));
 867                                 goto done;
 868                         }
 869                 }
 870
 871                 /* try dma first */
 872                 status = net2272_kick_dma(ep, req);
 873
 874                 if (status < 0) {
 875                         /* dma failed (most likely in use by another endpoint)
 876                          * fallback to pio
 877                          */
 878                         status = 0;
 879
 880                         if (ep->is_in)
 881                                 status = net2272_write_fifo(ep, req);
 882                         else {
 883                                 s = net2272_ep_read(ep, EP_STAT0);
 884                                 if ((s & (1 << BUFFER_EMPTY)) == 0)
 885                                         status = net2272_read_fifo(ep, req);
 886                         }
 887
 888                         if (unlikely(status != 0)) {
 889                                 if (status > 0)
 890                                         status = 0;
 891                                 req = NULL;
 892                         }
 893                 }
 894         }
 895         if (likely(req))
 896                 list_add_tail(&req->queue, &ep->queue);
 897
 898         if (likely(!list_empty(&ep->queue)))
 899                 net2272_ep_write(ep, EP_RSPCLR, 1 << ALT_NAK_OUT_PACKETS);
 900  done:
 901         spin_unlock_irqrestore(&dev->lock, flags);
 902
 903         return 0;
 904 }
 905
 906 /* dequeue ALL requests */
 907 static void
 908 net2272_dequeue_all(struct net2272_ep *ep)
 909 {
 910         struct net2272_request *req;
 911
 912         /* called with spinlock held */
 913         ep->stopped = 1;
 914
 915         while (!list_empty(&ep->queue)) {
 916                 req = list_entry(ep->queue.next,
 917                                 struct net2272_request,
 918                                 queue);
 919                 net2272_done(ep, req, -ESHUTDOWN);
 920         }
 921 }
 922
 923 /* dequeue JUST ONE request */
 924 static int
 925 net2272_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 926 {
 927         struct net2272_ep *ep;
 928         struct net2272_request *req;
 929         unsigned long flags;
 930         int stopped;
 931
 932         ep = container_of(_ep, struct net2272_ep, ep);
 933         if (!_ep || (!ep->desc && ep->num != 0) || !_req)
 934                 return -EINVAL;
 935
 936         spin_lock_irqsave(&ep->dev->lock, flags);
 937         stopped = ep->stopped;
 938         ep->stopped = 1;
 939
 940         /* make sure it's still queued on this endpoint */
 941         list_for_each_entry(req, &ep->queue, queue) {
 942                 if (&req->req == _req)
 943                         break;
 944         }
 945         if (&req->req != _req) {
 946                 ep->stopped = stopped;
 947                 spin_unlock_irqrestore(&ep->dev->lock, flags);
 948                 return -EINVAL;
 949         }
 950
 951         /* queue head may be partially complete */
 952         if (ep->queue.next == &req->queue) {
 953                 dev_dbg(ep->dev->dev, "unlink (%s) pio\n", _ep->name);
 954                 net2272_done(ep, req, -ECONNRESET);
 955         }
 956         req = NULL;
 957         ep->stopped = stopped;
 958
 959         spin_unlock_irqrestore(&ep->dev->lock, flags);
 960         return 0;
 961 }
 962
 963 /*---------------------------------------------------------------------------*/
 964
 965 static int
 966 net2272_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
 967 {
 968         struct net2272_ep *ep;
 969         unsigned long flags;
 970         int ret = 0;
 971
 972         ep = container_of(_ep, struct net2272_ep, ep);
 973         if (!_ep || (!ep->desc && ep->num != 0))
 974                 return -EINVAL;
 975         if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
 976                 return -ESHUTDOWN;
 977         if (ep->desc /* not ep0 */ && usb_endpoint_xfer_isoc(ep->desc))
 978                 return -EINVAL;
 979
 980         spin_lock_irqsave(&ep->dev->lock, flags);
 981         if (!list_empty(&ep->queue))
 982                 ret = -EAGAIN;
 983         else if (ep->is_in && value && net2272_fifo_status(_ep) != 0)
 984                 ret = -EAGAIN;
 985         else {
 986                 dev_vdbg(ep->dev->dev, "%s %s %s\n", _ep->name,
 987                         value ? "set" : "clear",
 988                         wedged ? "wedge" : "halt");
 989                 /* set/clear */
 990                 if (value) {
 991                         if (ep->num == 0)
 992                                 ep->dev->protocol_stall = 1;
 993                         else
 994                                 set_halt(ep);
 995                         if (wedged)
 996                                 ep->wedged = 1;
 997                 } else {
 998                         clear_halt(ep);
 999                         ep->wedged = 0;
1000                 }
1001         }
1002         spin_unlock_irqrestore(&ep->dev->lock, flags);
1003
1004         return ret;
1005 }
1006
1007 static int
1008 net2272_set_halt(struct usb_ep *_ep, int value)
1009 {
1010         return net2272_set_halt_and_wedge(_ep, value, 0);
1011 }
1012
1013 static int
1014 net2272_set_wedge(struct usb_ep *_ep)
1015 {
1016         if (!_ep || _ep->name == ep0name)
1017                 return -EINVAL;
1018         return net2272_set_halt_and_wedge(_ep, 1, 1);
1019 }
1020
1021 static int
1022 net2272_fifo_status(struct usb_ep *_ep)
1023 {
1024         struct net2272_ep *ep;
1025         u16 avail;
1026
1027         ep = container_of(_ep, struct net2272_ep, ep);
1028         if (!_ep || (!ep->desc && ep->num != 0))
1029                 return -ENODEV;
1030         if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1031                 return -ESHUTDOWN;
1032
1033         avail = net2272_ep_read(ep, EP_AVAIL1) << 8;
1034         avail |= net2272_ep_read(ep, EP_AVAIL0);
1035         if (avail > ep->fifo_size)
1036                 return -EOVERFLOW;
1037         if (ep->is_in)
1038                 avail = ep->fifo_size - avail;
1039         return avail;
1040 }
1041
1042 static void
1043 net2272_fifo_flush(struct usb_ep *_ep)
1044 {
1045         struct net2272_ep *ep;
1046
1047         ep = container_of(_ep, struct net2272_ep, ep);
1048         if (!_ep || (!ep->desc && ep->num != 0))
1049                 return;
1050         if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1051                 return;
1052
1053         net2272_ep_write(ep, EP_STAT1, 1 << BUFFER_FLUSH);
1054 }
1055
1056 static const struct usb_ep_ops net2272_ep_ops = {
1057         .enable        = net2272_enable,
1058         .disable       = net2272_disable,
1059
1060         .alloc_request = net2272_alloc_request,
1061         .free_request  = net2272_free_request,
1062
1063         .queue         = net2272_queue,
1064         .dequeue       = net2272_dequeue,
1065
1066         .set_halt      = net2272_set_halt,
1067         .set_wedge     = net2272_set_wedge,
1068         .fifo_status   = net2272_fifo_status,
1069         .fifo_flush    = net2272_fifo_flush,
1070 };
1071
1072 /*---------------------------------------------------------------------------*/
1073
1074 static int
1075 net2272_get_frame(struct usb_gadget *_gadget)
1076 {
1077         struct net2272 *dev;
1078         unsigned long flags;
1079         u16 ret;
1080
1081         if (!_gadget)
1082                 return -ENODEV;
1083         dev = container_of(_gadget, struct net2272, gadget);
1084         spin_lock_irqsave(&dev->lock, flags);
1085
1086         ret = net2272_read(dev, FRAME1) << 8;
1087         ret |= net2272_read(dev, FRAME0);
1088
1089         spin_unlock_irqrestore(&dev->lock, flags);
1090         return ret;
1091 }
1092
1093 static int
1094 net2272_wakeup(struct usb_gadget *_gadget)
1095 {
1096         struct net2272 *dev;
1097         u8 tmp;
1098         unsigned long flags;
1099
1100         if (!_gadget)
1101                 return 0;
1102         dev = container_of(_gadget, struct net2272, gadget);
1103
1104         spin_lock_irqsave(&dev->lock, flags);
1105         tmp = net2272_read(dev, USBCTL0);
1106         if (tmp & (1 << IO_WAKEUP_ENABLE))
1107                 net2272_write(dev, USBCTL1, (1 << GENERATE_RESUME));
1108
1109         spin_unlock_irqrestore(&dev->lock, flags);
1110
1111         return 0;
1112 }
1113
1114 static int
1115 net2272_set_selfpowered(struct usb_gadget *_gadget, int value)
1116 {
1117         if (!_gadget)
1118                 return -ENODEV;
1119
1120         _gadget->is_selfpowered = (value != 0);
1121
1122         return 0;
1123 }
1124
1125 static int
1126 net2272_pullup(struct usb_gadget *_gadget, int is_on)
1127 {
1128         struct net2272 *dev;
1129         u8 tmp;
1130         unsigned long flags;
1131
1132         if (!_gadget)
1133                 return -ENODEV;
1134         dev = container_of(_gadget, struct net2272, gadget);
1135
1136         spin_lock_irqsave(&dev->lock, flags);
1137         tmp = net2272_read(dev, USBCTL0);
1138         dev->softconnect = (is_on != 0);
1139         if (is_on)
1140                 tmp |= (1 << USB_DETECT_ENABLE);
1141         else
1142                 tmp &= ~(1 << USB_DETECT_ENABLE);
1143         net2272_write(dev, USBCTL0, tmp);
1144         spin_unlock_irqrestore(&dev->lock, flags);
1145
1146         return 0;
1147 }
1148
1149 static int net2272_start(struct usb_gadget *_gadget,
1150                 struct usb_gadget_driver *driver);
1151 static int net2272_stop(struct usb_gadget *_gadget);
1152
1153 static const struct usb_gadget_ops net2272_ops = {
1154         .get_frame      = net2272_get_frame,
1155         .wakeup         = net2272_wakeup,
1156         .set_selfpowered = net2272_set_selfpowered,
1157         .pullup         = net2272_pullup,
1158         .udc_start      = net2272_start,
1159         .udc_stop       = net2272_stop,
1160 };
1161
1162 /*---------------------------------------------------------------------------*/
1163
1164 static ssize_t
1165 registers_show(struct device *_dev, struct device_attribute *attr, char *buf)
1166 {
1167         struct net2272 *dev;
1168         char *next;
1169         unsigned size, t;
1170         unsigned long flags;
1171         u8 t1, t2;
1172         int i;
1173         const char *s;
1174
1175         dev = dev_get_drvdata(_dev);
1176         next = buf;
1177         size = PAGE_SIZE;
1178         spin_lock_irqsave(&dev->lock, flags);
1179
1180         /* Main Control Registers */
1181         t = scnprintf(next, size, "%s version %s,"
1182                 "chiprev %02x, locctl %02x\n"
1183                 "irqenb0 %02x irqenb1 %02x "
1184                 "irqstat0 %02x irqstat1 %02x\n",
1185                 driver_name, driver_vers, dev->chiprev,
1186                 net2272_read(dev, LOCCTL),
1187                 net2272_read(dev, IRQENB0),
1188                 net2272_read(dev, IRQENB1),
1189                 net2272_read(dev, IRQSTAT0),
1190                 net2272_read(dev, IRQSTAT1));
1191         size -= t;
1192         next += t;
1193
1194         /* DMA */
1195         t1 = net2272_read(dev, DMAREQ);
1196         t = scnprintf(next, size, "\ndmareq %02x: %s %s%s%s%s\n",
1197                 t1, ep_name[(t1 & 0x01) + 1],
1198                 t1 & (1 << DMA_CONTROL_DACK) ? "dack " : "",
1199                 t1 & (1 << DMA_REQUEST_ENABLE) ? "reqenb " : "",
1200                 t1 & (1 << DMA_REQUEST) ? "req " : "",
1201                 t1 & (1 << DMA_BUFFER_VALID) ? "valid " : "");
1202         size -= t;
1203         next += t;
1204
1205         /* USB Control Registers */
1206         t1 = net2272_read(dev, USBCTL1);
1207         if (t1 & (1 << VBUS_PIN)) {
1208                 if (t1 & (1 << USB_HIGH_SPEED))
1209                         s = "high speed";
1210                 else if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1211                         s = "powered";
1212                 else
1213                         s = "full speed";
1214         } else
1215                 s = "not attached";
1216         t = scnprintf(next, size,
1217                 "usbctl0 %02x usbctl1 %02x addr 0x%02x (%s)\n",
1218                 net2272_read(dev, USBCTL0), t1,
1219                 net2272_read(dev, OURADDR), s);
1220         size -= t;
1221         next += t;
1222
1223         /* Endpoint Registers */
1224         for (i = 0; i < 4; ++i) {
1225                 struct net2272_ep *ep;
1226
1227                 ep = &dev->ep[i];
1228                 if (i && !ep->desc)
1229                         continue;
1230
1231                 t1 = net2272_ep_read(ep, EP_CFG);
1232                 t2 = net2272_ep_read(ep, EP_RSPSET);
1233                 t = scnprintf(next, size,
1234                         "\n%s\tcfg %02x rsp (%02x) %s%s%s%s%s%s%s%s"
1235                         "irqenb %02x\n",
1236                         ep->ep.name, t1, t2,
1237                         (t2 & (1 << ALT_NAK_OUT_PACKETS)) ? "NAK " : "",
1238                         (t2 & (1 << HIDE_STATUS_PHASE)) ? "hide " : "",
1239                         (t2 & (1 << AUTOVALIDATE)) ? "auto " : "",
1240                         (t2 & (1 << INTERRUPT_MODE)) ? "interrupt " : "",
1241                         (t2 & (1 << CONTROL_STATUS_PHASE_HANDSHAKE)) ? "status " : "",
1242                         (t2 & (1 << NAK_OUT_PACKETS_MODE)) ? "NAKmode " : "",
1243                         (t2 & (1 << ENDPOINT_TOGGLE)) ? "DATA1 " : "DATA0 ",
1244                         (t2 & (1 << ENDPOINT_HALT)) ? "HALT " : "",
1245                         net2272_ep_read(ep, EP_IRQENB));
1246                 size -= t;
1247                 next += t;
1248
1249                 t = scnprintf(next, size,
1250                         "\tstat0 %02x stat1 %02x avail %04x "
1251                         "(ep%d%s-%s)%s\n",
1252                         net2272_ep_read(ep, EP_STAT0),
1253                         net2272_ep_read(ep, EP_STAT1),
1254                         (net2272_ep_read(ep, EP_AVAIL1) << 8) | net2272_ep_read(ep, EP_AVAIL0),
1255                         t1 & 0x0f,
1256                         ep->is_in ? "in" : "out",
1257                         type_string(t1 >> 5),
1258                         ep->stopped ? "*" : "");
1259                 size -= t;
1260                 next += t;
1261
1262                 t = scnprintf(next, size,
1263                         "\tep_transfer %06x\n",
1264                         ((net2272_ep_read(ep, EP_TRANSFER2) & 0xff) << 16) |
1265                         ((net2272_ep_read(ep, EP_TRANSFER1) & 0xff) << 8) |
1266                         ((net2272_ep_read(ep, EP_TRANSFER0) & 0xff)));
1267                 size -= t;
1268                 next += t;
1269
1270                 t1 = net2272_ep_read(ep, EP_BUFF_STATES) & 0x03;
1271                 t2 = (net2272_ep_read(ep, EP_BUFF_STATES) >> 2) & 0x03;
1272                 t = scnprintf(next, size,
1273                         "\tbuf-a %s buf-b %s\n",
1274                         buf_state_string(t1),
1275                         buf_state_string(t2));
1276                 size -= t;
1277                 next += t;
1278         }
1279
1280         spin_unlock_irqrestore(&dev->lock, flags);
1281
1282         return PAGE_SIZE - size;
1283 }
1284 static DEVICE_ATTR_RO(registers);
1285
1286 /*---------------------------------------------------------------------------*/
1287
1288 static void
1289 net2272_set_fifo_mode(struct net2272 *dev, int mode)
1290 {
1291         u8 tmp;
1292
1293         tmp = net2272_read(dev, LOCCTL) & 0x3f;
1294         tmp |= (mode << 6);
1295         net2272_write(dev, LOCCTL, tmp);
1296
1297         INIT_LIST_HEAD(&dev->gadget.ep_list);
1298
1299         /* always ep-a, ep-c ... maybe not ep-b */
1300         list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list);
1301
1302         switch (mode) {
1303         case 0:
1304                 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1305                 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 512;
1306                 break;
1307         case 1:
1308                 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1309                 dev->ep[1].fifo_size = 1024;
1310                 dev->ep[2].fifo_size = 512;
1311                 break;
1312         case 2:
1313                 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1314                 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024;
1315                 break;
1316         case 3:
1317                 dev->ep[1].fifo_size = 1024;
1318                 break;
1319         }
1320
1321         /* ep-c is always 2 512 byte buffers */
1322         list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1323         dev->ep[3].fifo_size = 512;
1324 }
1325
1326 /*---------------------------------------------------------------------------*/
1327
1328 static void
1329 net2272_usb_reset(struct net2272 *dev)
1330 {
1331         dev->gadget.speed = USB_SPEED_UNKNOWN;
1332
1333         net2272_cancel_dma(dev);
1334
1335         net2272_write(dev, IRQENB0, 0);
1336         net2272_write(dev, IRQENB1, 0);
1337
1338         /* clear irq state */
1339         net2272_write(dev, IRQSTAT0, 0xff);
1340         net2272_write(dev, IRQSTAT1, ~(1 << SUSPEND_REQUEST_INTERRUPT));
1341
1342         net2272_write(dev, DMAREQ,
1343                 (0 << DMA_BUFFER_VALID) |
1344                 (0 << DMA_REQUEST_ENABLE) |
1345                 (1 << DMA_CONTROL_DACK) |
1346                 (dev->dma_eot_polarity << EOT_POLARITY) |
1347                 (dev->dma_dack_polarity << DACK_POLARITY) |
1348                 (dev->dma_dreq_polarity << DREQ_POLARITY) |
1349                 ((dma_ep >> 1) << DMA_ENDPOINT_SELECT));
1350
1351         net2272_cancel_dma(dev);
1352         net2272_set_fifo_mode(dev, (fifo_mode <= 3) ? fifo_mode : 0);
1353
1354         /* Set the NET2272 ep fifo data width to 16-bit mode and for correct byte swapping
1355          * note that the higher level gadget drivers are expected to convert data to little endian.
1356          * Enable byte swap for your local bus/cpu if needed by setting BYTE_SWAP in LOCCTL here
1357          */
1358         net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH));
1359         net2272_write(dev, LOCCTL1, (dma_mode << DMA_MODE));
1360 }
1361
1362 static void
1363 net2272_usb_reinit(struct net2272 *dev)
1364 {
1365         int i;
1366
1367         /* basic endpoint init */
1368         for (i = 0; i < 4; ++i) {
1369                 struct net2272_ep *ep = &dev->ep[i];
1370
1371                 ep->ep.name = ep_name[i];
1372                 ep->dev = dev;
1373                 ep->num = i;
1374                 ep->not_empty = 0;
1375
1376                 if (use_dma && ep->num == dma_ep)
1377                         ep->dma = 1;
1378
1379                 if (i > 0 && i <= 3)
1380                         ep->fifo_size = 512;
1381                 else
1382                         ep->fifo_size = 64;
1383                 net2272_ep_reset(ep);
1384
1385                 if (i == 0) {
1386                         ep->ep.caps.type_control = true;
1387                 } else {
1388                         ep->ep.caps.type_iso = true;
1389                         ep->ep.caps.type_bulk = true;
1390                         ep->ep.caps.type_int = true;
1391                 }
1392
1393                 ep->ep.caps.dir_in = true;
1394                 ep->ep.caps.dir_out = true;
1395         }
1396         usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64);
1397
1398         dev->gadget.ep0 = &dev->ep[0].ep;
1399         dev->ep[0].stopped = 0;
1400         INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
1401 }
1402
1403 static void
1404 net2272_ep0_start(struct net2272 *dev)
1405 {
1406         struct net2272_ep *ep0 = &dev->ep[0];
1407
1408         net2272_ep_write(ep0, EP_RSPSET,
1409                 (1 << NAK_OUT_PACKETS_MODE) |
1410                 (1 << ALT_NAK_OUT_PACKETS));
1411         net2272_ep_write(ep0, EP_RSPCLR,
1412                 (1 << HIDE_STATUS_PHASE) |
1413                 (1 << CONTROL_STATUS_PHASE_HANDSHAKE));
1414         net2272_write(dev, USBCTL0,
1415                 (dev->softconnect << USB_DETECT_ENABLE) |
1416                 (1 << USB_ROOT_PORT_WAKEUP_ENABLE) |
1417                 (1 << IO_WAKEUP_ENABLE));
1418         net2272_write(dev, IRQENB0,
1419                 (1 << SETUP_PACKET_INTERRUPT_ENABLE) |
1420                 (1 << ENDPOINT_0_INTERRUPT_ENABLE) |
1421                 (1 << DMA_DONE_INTERRUPT_ENABLE));
1422         net2272_write(dev, IRQENB1,
1423                 (1 << VBUS_INTERRUPT_ENABLE) |
1424                 (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE) |
1425                 (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE));
1426 }
1427
1428 /* when a driver is successfully registered, it will receive
1429  * control requests including set_configuration(), which enables
1430  * non-control requests.  then usb traffic follows until a
1431  * disconnect is reported.  then a host may connect again, or
1432  * the driver might get unbound.
1433  */
1434 static int net2272_start(struct usb_gadget *_gadget,
1435                 struct usb_gadget_driver *driver)
1436 {
1437         struct net2272 *dev;
1438         unsigned i;
1439
1440         if (!driver || !driver->setup ||
1441             driver->max_speed != USB_SPEED_HIGH)
1442                 return -EINVAL;
1443
1444         dev = container_of(_gadget, struct net2272, gadget);
1445
1446         for (i = 0; i < 4; ++i)
1447                 dev->ep[i].irqs = 0;
1448         /* hook up the driver ... */
1449         dev->softconnect = 1;
1450         driver->driver.bus = NULL;
1451         dev->driver = driver;
1452
1453         /* ... then enable host detection and ep0; and we're ready
1454          * for set_configuration as well as eventual disconnect.
1455          */
1456         net2272_ep0_start(dev);
1457
1458         return 0;
1459 }
1460
1461 static void
1462 stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver)
1463 {
1464         int i;
1465
1466         /* don't disconnect if it's not connected */
1467         if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1468                 driver = NULL;
1469
1470         /* stop hardware; prevent new request submissions;
1471          * and kill any outstanding requests.
1472          */
1473         net2272_usb_reset(dev);
1474         for (i = 0; i < 4; ++i)
1475                 net2272_dequeue_all(&dev->ep[i]);
1476
1477         /* report disconnect; the driver is already quiesced */
1478         if (driver) {
1479                 spin_unlock(&dev->lock);
1480                 driver->disconnect(&dev->gadget);
1481                 spin_lock(&dev->lock);
1482         }
1483
1484         net2272_usb_reinit(dev);
1485 }
1486
1487 static int net2272_stop(struct usb_gadget *_gadget)
1488 {
1489         struct net2272 *dev;
1490         unsigned long flags;
1491
1492         dev = container_of(_gadget, struct net2272, gadget);
1493
1494         spin_lock_irqsave(&dev->lock, flags);
1495         stop_activity(dev, NULL);
1496         spin_unlock_irqrestore(&dev->lock, flags);
1497
1498         dev->driver = NULL;
1499
1500         return 0;
1501 }
1502
1503 /*---------------------------------------------------------------------------*/
1504 /* handle ep-a/ep-b dma completions */
1505 static void
1506 net2272_handle_dma(struct net2272_ep *ep)
1507 {
1508         struct net2272_request *req;
1509         unsigned len;
1510         int status;
1511
1512         if (!list_empty(&ep->queue))
1513                 req = list_entry(ep->queue.next,
1514                                 struct net2272_request, queue);
1515         else
1516                 req = NULL;
1517
1518         dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req);
1519
1520         /* Ensure DREQ is de-asserted */
1521         net2272_write(ep->dev, DMAREQ,
1522                 (0 << DMA_BUFFER_VALID)
1523               | (0 << DMA_REQUEST_ENABLE)
1524               | (1 << DMA_CONTROL_DACK)
1525               | (ep->dev->dma_eot_polarity << EOT_POLARITY)
1526               | (ep->dev->dma_dack_polarity << DACK_POLARITY)
1527               | (ep->dev->dma_dreq_polarity << DREQ_POLARITY)
1528               | (ep->dma << DMA_ENDPOINT_SELECT));
1529
1530         ep->dev->dma_busy = 0;
1531
1532         net2272_ep_write(ep, EP_IRQENB,
1533                   (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1534                 | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1535                 | net2272_ep_read(ep, EP_IRQENB));
1536
1537         /* device-to-host transfer completed */
1538         if (ep->is_in) {
1539                 /* validate a short packet or zlp if necessary */
1540                 if ((req->req.length % ep->ep.maxpacket != 0) ||
1541                                 req->req.zero)
1542                         set_fifo_bytecount(ep, 0);
1543
1544                 net2272_done(ep, req, 0);
1545                 if (!list_empty(&ep->queue)) {
1546                         req = list_entry(ep->queue.next,
1547                                         struct net2272_request, queue);
1548                         status = net2272_kick_dma(ep, req);
1549                         if (status < 0)
1550                                 net2272_pio_advance(ep);
1551                 }
1552
1553         /* host-to-device transfer completed */
1554         } else {
1555                 /* terminated with a short packet? */
1556                 if (net2272_read(ep->dev, IRQSTAT0) &
1557                                 (1 << DMA_DONE_INTERRUPT)) {
1558                         /* abort system dma */
1559                         net2272_cancel_dma(ep->dev);
1560                 }
1561
1562                 /* EP_TRANSFER will contain the number of bytes
1563                  * actually received.
1564                  * NOTE: There is no overflow detection on EP_TRANSFER:
1565                  * We can't deal with transfers larger than 2^24 bytes!
1566                  */
1567                 len = (net2272_ep_read(ep, EP_TRANSFER2) << 16)
1568                         | (net2272_ep_read(ep, EP_TRANSFER1) << 8)
1569                         | (net2272_ep_read(ep, EP_TRANSFER0));
1570
1571                 if (ep->not_empty)
1572                         len += 4;
1573
1574                 req->req.actual += len;
1575
1576                 /* get any remaining data */
1577                 net2272_pio_advance(ep);
1578         }
1579 }
1580
1581 /*---------------------------------------------------------------------------*/
1582
1583 static void
1584 net2272_handle_ep(struct net2272_ep *ep)
1585 {
1586         struct net2272_request *req;
1587         u8 stat0, stat1;
1588
1589         if (!list_empty(&ep->queue))
1590                 req = list_entry(ep->queue.next,
1591                         struct net2272_request, queue);
1592         else
1593                 req = NULL;
1594
1595         /* ack all, and handle what we care about */
1596         stat0 = net2272_ep_read(ep, EP_STAT0);
1597         stat1 = net2272_ep_read(ep, EP_STAT1);
1598         ep->irqs++;
1599
1600         dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n",
1601                 ep->ep.name, stat0, stat1, req ? &req->req : NULL);
1602
1603         net2272_ep_write(ep, EP_STAT0, stat0 &
1604                 ~((1 << NAK_OUT_PACKETS)
1605                 | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)));
1606         net2272_ep_write(ep, EP_STAT1, stat1);
1607
1608         /* data packet(s) received (in the fifo, OUT)
1609          * direction must be validated, otherwise control read status phase
1610          * could be interpreted as a valid packet
1611          */
1612         if (!ep->is_in && (stat0 & (1 << DATA_PACKET_RECEIVED_INTERRUPT)))
1613                 net2272_pio_advance(ep);
1614         /* data packet(s) transmitted (IN) */
1615         else if (stat0 & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))
1616                 net2272_pio_advance(ep);
1617 }
1618
1619 static struct net2272_ep *
1620 net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex)
1621 {
1622         struct net2272_ep *ep;
1623
1624         if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
1625                 return &dev->ep[0];
1626
1627         list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1628                 u8 bEndpointAddress;
1629
1630                 if (!ep->desc)
1631                         continue;
1632                 bEndpointAddress = ep->desc->bEndpointAddress;
1633                 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
1634                         continue;
1635                 if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f))
1636                         return ep;
1637         }
1638         return NULL;
1639 }
1640
1641 /*
1642  * USB Test Packet:
1643  * JKJKJKJK * 9
1644  * JJKKJJKK * 8
1645  * JJJJKKKK * 8
1646  * JJJJJJJKKKKKKK * 8
1647  * JJJJJJJK * 8
1648  * {JKKKKKKK * 10}, JK
1649  */
1650 static const u8 net2272_test_packet[] = {
1651         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1652         0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
1653         0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
1654         0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1655         0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
1656         0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFD, 0x7E
1657 };
1658
1659 static void
1660 net2272_set_test_mode(struct net2272 *dev, int mode)
1661 {
1662         int i;
1663
1664         /* Disable all net2272 interrupts:
1665          * Nothing but a power cycle should stop the test.
1666          */
1667         net2272_write(dev, IRQENB0, 0x00);
1668         net2272_write(dev, IRQENB1, 0x00);
1669
1670         /* Force tranceiver to high-speed */
1671         net2272_write(dev, XCVRDIAG, 1 << FORCE_HIGH_SPEED);
1672
1673         net2272_write(dev, PAGESEL, 0);
1674         net2272_write(dev, EP_STAT0, 1 << DATA_PACKET_TRANSMITTED_INTERRUPT);
1675         net2272_write(dev, EP_RSPCLR,
1676                           (1 << CONTROL_STATUS_PHASE_HANDSHAKE)
1677                         | (1 << HIDE_STATUS_PHASE));
1678         net2272_write(dev, EP_CFG, 1 << ENDPOINT_DIRECTION);
1679         net2272_write(dev, EP_STAT1, 1 << BUFFER_FLUSH);
1680
1681         /* wait for status phase to complete */
1682         while (!(net2272_read(dev, EP_STAT0) &
1683                                 (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)))
1684                 ;
1685
1686         /* Enable test mode */
1687         net2272_write(dev, USBTEST, mode);
1688
1689         /* load test packet */
1690         if (mode == USB_TEST_PACKET) {
1691                 /* switch to 8 bit mode */
1692                 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) &
1693                                 ~(1 << DATA_WIDTH));
1694
1695                 for (i = 0; i < sizeof(net2272_test_packet); ++i)
1696                         net2272_write(dev, EP_DATA, net2272_test_packet[i]);
1697
1698                 /* Validate test packet */
1699                 net2272_write(dev, EP_TRANSFER0, 0);
1700         }
1701 }
1702
1703 static void
1704 net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat)
1705 {
1706         struct net2272_ep *ep;
1707         u8 num, scratch;
1708
1709         /* starting a control request? */
1710         if (unlikely(stat & (1 << SETUP_PACKET_INTERRUPT))) {
1711                 union {
1712                         u8 raw[8];
1713                         struct usb_ctrlrequest  r;
1714                 } u;
1715                 int tmp = 0;
1716                 struct net2272_request *req;
1717
1718                 if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
1719                         if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED))
1720                                 dev->gadget.speed = USB_SPEED_HIGH;
1721                         else
1722                                 dev->gadget.speed = USB_SPEED_FULL;
1723                         dev_dbg(dev->dev, "%s\n",
1724                                 usb_speed_string(dev->gadget.speed));
1725                 }
1726
1727                 ep = &dev->ep[0];
1728                 ep->irqs++;
1729
1730                 /* make sure any leftover interrupt state is cleared */
1731                 stat &= ~(1 << ENDPOINT_0_INTERRUPT);
1732                 while (!list_empty(&ep->queue)) {
1733                         req = list_entry(ep->queue.next,
1734                                 struct net2272_request, queue);
1735                         net2272_done(ep, req,
1736                                 (req->req.actual == req->req.length) ? 0 : -EPROTO);
1737                 }
1738                 ep->stopped = 0;
1739                 dev->protocol_stall = 0;
1740                 net2272_ep_write(ep, EP_STAT0,
1741                             (1 << DATA_IN_TOKEN_INTERRUPT)
1742                           | (1 << DATA_OUT_TOKEN_INTERRUPT)
1743                           | (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
1744                           | (1 << DATA_PACKET_RECEIVED_INTERRUPT)
1745                           | (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT));
1746                 net2272_ep_write(ep, EP_STAT1,
1747                             (1 << TIMEOUT)
1748                           | (1 << USB_OUT_ACK_SENT)
1749                           | (1 << USB_OUT_NAK_SENT)
1750                           | (1 << USB_IN_ACK_RCVD)
1751                           | (1 << USB_IN_NAK_SENT)
1752                           | (1 << USB_STALL_SENT)
1753                           | (1 << LOCAL_OUT_ZLP));
1754
1755                 /*
1756                  * Ensure Control Read pre-validation setting is beyond maximum size
1757                  *  - Control Writes can leave non-zero values in EP_TRANSFER. If
1758                  *    an EP0 transfer following the Control Write is a Control Read,
1759                  *    the NET2272 sees the non-zero EP_TRANSFER as an unexpected
1760                  *    pre-validation count.
1761                  *  - Setting EP_TRANSFER beyond the maximum EP0 transfer size ensures
1762                  *    the pre-validation count cannot cause an unexpected validatation
1763                  */
1764                 net2272_write(dev, PAGESEL, 0);
1765                 net2272_write(dev, EP_TRANSFER2, 0xff);
1766                 net2272_write(dev, EP_TRANSFER1, 0xff);
1767                 net2272_write(dev, EP_TRANSFER0, 0xff);
1768
1769                 u.raw[0] = net2272_read(dev, SETUP0);
1770                 u.raw[1] = net2272_read(dev, SETUP1);
1771                 u.raw[2] = net2272_read(dev, SETUP2);
1772                 u.raw[3] = net2272_read(dev, SETUP3);
1773                 u.raw[4] = net2272_read(dev, SETUP4);
1774                 u.raw[5] = net2272_read(dev, SETUP5);
1775                 u.raw[6] = net2272_read(dev, SETUP6);
1776                 u.raw[7] = net2272_read(dev, SETUP7);
1777                 /*
1778                  * If you have a big endian cpu make sure le16_to_cpus
1779                  * performs the proper byte swapping here...
1780                  */
1781                 le16_to_cpus(&u.r.wValue);
1782                 le16_to_cpus(&u.r.wIndex);
1783                 le16_to_cpus(&u.r.wLength);
1784
1785                 /* ack the irq */
1786                 net2272_write(dev, IRQSTAT0, 1 << SETUP_PACKET_INTERRUPT);
1787                 stat ^= (1 << SETUP_PACKET_INTERRUPT);
1788
1789                 /* watch control traffic at the token level, and force
1790                  * synchronization before letting the status phase happen.
1791                  */
1792                 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
1793                 if (ep->is_in) {
1794                         scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
1795                                 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1796                                 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1797                         stop_out_naking(ep);
1798                 } else
1799                         scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
1800                                 | (1 << DATA_OUT_TOKEN_INTERRUPT_ENABLE)
1801                                 | (1 << DATA_IN_TOKEN_INTERRUPT_ENABLE);
1802                 net2272_ep_write(ep, EP_IRQENB, scratch);
1803
1804                 if ((u.r.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD)
1805                         goto delegate;
1806                 switch (u.r.bRequest) {
1807                 case USB_REQ_GET_STATUS: {
1808                         struct net2272_ep *e;
1809                         u16 status = 0;
1810
1811                         switch (u.r.bRequestType & USB_RECIP_MASK) {
1812                         case USB_RECIP_ENDPOINT:
1813                                 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1814                                 if (!e || u.r.wLength > 2)
1815                                         goto do_stall;
1816                                 if (net2272_ep_read(e, EP_RSPSET) & (1 << ENDPOINT_HALT))
1817                                         status = cpu_to_le16(1);
1818                                 else
1819                                         status = cpu_to_le16(0);
1820
1821                                 /* don't bother with a request object! */
1822                                 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1823                                 writew(status, net2272_reg_addr(dev, EP_DATA));
1824                                 set_fifo_bytecount(&dev->ep[0], 0);
1825                                 allow_status(ep);
1826                                 dev_vdbg(dev->dev, "%s stat %02x\n",
1827                                         ep->ep.name, status);
1828                                 goto next_endpoints;
1829                         case USB_RECIP_DEVICE:
1830                                 if (u.r.wLength > 2)
1831                                         goto do_stall;
1832                                 if (dev->gadget.is_selfpowered)
1833                                         status = (1 << USB_DEVICE_SELF_POWERED);
1834
1835                                 /* don't bother with a request object! */
1836                                 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1837                                 writew(status, net2272_reg_addr(dev, EP_DATA));
1838                                 set_fifo_bytecount(&dev->ep[0], 0);
1839                                 allow_status(ep);
1840                                 dev_vdbg(dev->dev, "device stat %02x\n", status);
1841                                 goto next_endpoints;
1842                         case USB_RECIP_INTERFACE:
1843                                 if (u.r.wLength > 2)
1844                                         goto do_stall;
1845
1846                                 /* don't bother with a request object! */
1847                                 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1848                                 writew(status, net2272_reg_addr(dev, EP_DATA));
1849                                 set_fifo_bytecount(&dev->ep[0], 0);
1850                                 allow_status(ep);
1851                                 dev_vdbg(dev->dev, "interface status %02x\n", status);
1852                                 goto next_endpoints;
1853                         }
1854
1855                         break;
1856                 }
1857                 case USB_REQ_CLEAR_FEATURE: {
1858                         struct net2272_ep *e;
1859
1860                         if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1861                                 goto delegate;
1862                         if (u.r.wValue != USB_ENDPOINT_HALT ||
1863                             u.r.wLength != 0)
1864                                 goto do_stall;
1865                         e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1866                         if (!e)
1867                                 goto do_stall;
1868                         if (e->wedged) {
1869                                 dev_vdbg(dev->dev, "%s wedged, halt not cleared\n",
1870                                         ep->ep.name);
1871                         } else {
1872                                 dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name);
1873                                 clear_halt(e);
1874                         }
1875                         allow_status(ep);
1876                         goto next_endpoints;
1877                 }
1878                 case USB_REQ_SET_FEATURE: {
1879                         struct net2272_ep *e;
1880
1881                         if (u.r.bRequestType == USB_RECIP_DEVICE) {
1882                                 if (u.r.wIndex != NORMAL_OPERATION)
1883                                         net2272_set_test_mode(dev, (u.r.wIndex >> 8));
1884                                 allow_status(ep);
1885                                 dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex);
1886                                 goto next_endpoints;
1887                         } else if (u.r.bRequestType != USB_RECIP_ENDPOINT)
1888                                 goto delegate;
1889                         if (u.r.wValue != USB_ENDPOINT_HALT ||
1890                             u.r.wLength != 0)
1891                                 goto do_stall;
1892                         e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1893                         if (!e)
1894                                 goto do_stall;
1895                         set_halt(e);
1896                         allow_status(ep);
1897                         dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name);
1898                         goto next_endpoints;
1899                 }
1900                 case USB_REQ_SET_ADDRESS: {
1901                         net2272_write(dev, OURADDR, u.r.wValue & 0xff);
1902                         allow_status(ep);
1903                         break;
1904                 }
1905                 default:
1906  delegate:
1907                         dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x "
1908                                 "ep_cfg %08x\n",
1909                                 u.r.bRequestType, u.r.bRequest,
1910                                 u.r.wValue, u.r.wIndex,
1911                                 net2272_ep_read(ep, EP_CFG));
1912                         spin_unlock(&dev->lock);
1913                         tmp = dev->driver->setup(&dev->gadget, &u.r);
1914                         spin_lock(&dev->lock);
1915                 }
1916
1917                 /* stall ep0 on error */
1918                 if (tmp < 0) {
1919  do_stall:
1920                         dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n",
1921                                 u.r.bRequestType, u.r.bRequest, tmp);
1922                         dev->protocol_stall = 1;
1923                 }
1924         /* endpoint dma irq? */
1925         } else if (stat & (1 << DMA_DONE_INTERRUPT)) {
1926                 net2272_cancel_dma(dev);
1927                 net2272_write(dev, IRQSTAT0, 1 << DMA_DONE_INTERRUPT);
1928                 stat &= ~(1 << DMA_DONE_INTERRUPT);
1929                 num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT))
1930                         ? 2 : 1;
1931
1932                 ep = &dev->ep[num];
1933                 net2272_handle_dma(ep);
1934         }
1935
1936  next_endpoints:
1937         /* endpoint data irq? */
1938         scratch = stat & 0x0f;
1939         stat &= ~0x0f;
1940         for (num = 0; scratch; num++) {
1941                 u8 t;
1942
1943                 /* does this endpoint's FIFO and queue need tending? */
1944                 t = 1 << num;
1945                 if ((scratch & t) == 0)
1946                         continue;
1947                 scratch ^= t;
1948
1949                 ep = &dev->ep[num];
1950                 net2272_handle_ep(ep);
1951         }
1952
1953         /* some interrupts we can just ignore */
1954         stat &= ~(1 << SOF_INTERRUPT);
1955
1956         if (stat)
1957                 dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat);
1958 }
1959
1960 static void
1961 net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat)
1962 {
1963         u8 tmp, mask;
1964
1965         /* after disconnect there's nothing else to do! */
1966         tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT);
1967         mask = (1 << USB_HIGH_SPEED) | (1 << USB_FULL_SPEED);
1968
1969         if (stat & tmp) {
1970                 bool    reset = false;
1971                 bool    disconnect = false;
1972
1973                 /*
1974                  * Ignore disconnects and resets if the speed hasn't been set.
1975                  * VBUS can bounce and there's always an initial reset.
1976                  */
1977                 net2272_write(dev, IRQSTAT1, tmp);
1978                 if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
1979                         if ((stat & (1 << VBUS_INTERRUPT)) &&
1980                                         (net2272_read(dev, USBCTL1) &
1981                                                 (1 << VBUS_PIN)) == 0) {
1982                                 disconnect = true;
1983                                 dev_dbg(dev->dev, "disconnect %s\n",
1984                                         dev->driver->driver.name);
1985                         } else if ((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) &&
1986                                         (net2272_read(dev, USBCTL1) & mask)
1987                                                 == 0) {
1988                                 reset = true;
1989                                 dev_dbg(dev->dev, "reset %s\n",
1990                                         dev->driver->driver.name);
1991                         }
1992
1993                         if (disconnect || reset) {
1994                                 stop_activity(dev, dev->driver);
1995                                 net2272_ep0_start(dev);
1996                                 spin_unlock(&dev->lock);
1997                                 if (reset)
1998                                         usb_gadget_udc_reset
1999                                                 (&dev->gadget, dev->driver);
2000                                 else
2001                                         (dev->driver->disconnect)
2002                                                 (&dev->gadget);
2003                                 spin_lock(&dev->lock);
2004                                 return;
2005                         }
2006                 }
2007                 stat &= ~tmp;
2008
2009                 if (!stat)
2010                         return;
2011         }
2012
2013         tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT);
2014         if (stat & tmp) {
2015                 net2272_write(dev, IRQSTAT1, tmp);
2016                 if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) {
2017                         if (dev->driver->suspend)
2018                                 dev->driver->suspend(&dev->gadget);
2019                         if (!enable_suspend) {
2020                                 stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
2021                                 dev_dbg(dev->dev, "Suspend disabled, ignoring\n");
2022                         }
2023                 } else {
2024                         if (dev->driver->resume)
2025                                 dev->driver->resume(&dev->gadget);
2026                 }
2027                 stat &= ~tmp;
2028         }
2029
2030         /* clear any other status/irqs */
2031         if (stat)
2032                 net2272_write(dev, IRQSTAT1, stat);
2033
2034         /* some status we can just ignore */
2035         stat &= ~((1 << CONTROL_STATUS_INTERRUPT)
2036                         | (1 << SUSPEND_REQUEST_INTERRUPT)
2037                         | (1 << RESUME_INTERRUPT));
2038         if (!stat)
2039                 return;
2040         else
2041                 dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat);
2042 }
2043
2044 static irqreturn_t net2272_irq(int irq, void *_dev)
2045 {
2046         struct net2272 *dev = _dev;
2047 #if defined(PLX_PCI_RDK) || defined(PLX_PCI_RDK2)
2048         u32 intcsr;
2049 #endif
2050 #if defined(PLX_PCI_RDK)
2051         u8 dmareq;
2052 #endif
2053         spin_lock(&dev->lock);
2054 #if defined(PLX_PCI_RDK)
2055         intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2056
2057         if ((intcsr & LOCAL_INTERRUPT_TEST) == LOCAL_INTERRUPT_TEST) {
2058                 writel(intcsr & ~(1 << PCI_INTERRUPT_ENABLE),
2059                                 dev->rdk1.plx9054_base_addr + INTCSR);
2060                 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2061                 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2062                 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2063                 writel(intcsr | (1 << PCI_INTERRUPT_ENABLE),
2064                         dev->rdk1.plx9054_base_addr + INTCSR);
2065         }
2066         if ((intcsr & DMA_CHANNEL_0_TEST) == DMA_CHANNEL_0_TEST) {
2067                 writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2068                                 dev->rdk1.plx9054_base_addr + DMACSR0);
2069
2070                 dmareq = net2272_read(dev, DMAREQ);
2071                 if (dmareq & 0x01)
2072                         net2272_handle_dma(&dev->ep[2]);
2073                 else
2074                         net2272_handle_dma(&dev->ep[1]);
2075         }
2076 #endif
2077 #if defined(PLX_PCI_RDK2)
2078         /* see if PCI int for us by checking irqstat */
2079         intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT);
2080         if (!(intcsr & (1 << NET2272_PCI_IRQ))) {
2081                 spin_unlock(&dev->lock);
2082                 return IRQ_NONE;
2083         }
2084         /* check dma interrupts */
2085 #endif
2086         /* Platform/devcice interrupt handler */
2087 #if !defined(PLX_PCI_RDK)
2088         net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2089         net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2090 #endif
2091         spin_unlock(&dev->lock);
2092
2093         return IRQ_HANDLED;
2094 }
2095
2096 static int net2272_present(struct net2272 *dev)
2097 {
2098         /*
2099          * Quick test to see if CPU can communicate properly with the NET2272.
2100          * Verifies connection using writes and reads to write/read and
2101          * read-only registers.
2102          *
2103          * This routine is strongly recommended especially during early bring-up
2104          * of new hardware, however for designs that do not apply Power On System
2105          * Tests (POST) it may discarded (or perhaps minimized).
2106          */
2107         unsigned int ii;
2108         u8 val, refval;
2109
2110         /* Verify NET2272 write/read SCRATCH register can write and read */
2111         refval = net2272_read(dev, SCRATCH);
2112         for (ii = 0; ii < 0x100; ii += 7) {
2113                 net2272_write(dev, SCRATCH, ii);
2114                 val = net2272_read(dev, SCRATCH);
2115                 if (val != ii) {
2116                         dev_dbg(dev->dev,
2117                                 "%s: write/read SCRATCH register test failed: "
2118                                 "wrote:0x%2.2x, read:0x%2.2x\n",
2119                                 __func__, ii, val);
2120                         return -EINVAL;
2121                 }
2122         }
2123         /* To be nice, we write the original SCRATCH value back: */
2124         net2272_write(dev, SCRATCH, refval);
2125
2126         /* Verify NET2272 CHIPREV register is read-only: */
2127         refval = net2272_read(dev, CHIPREV_2272);
2128         for (ii = 0; ii < 0x100; ii += 7) {
2129                 net2272_write(dev, CHIPREV_2272, ii);
2130                 val = net2272_read(dev, CHIPREV_2272);
2131                 if (val != refval) {
2132                         dev_dbg(dev->dev,
2133                                 "%s: write/read CHIPREV register test failed: "
2134                                 "wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n",
2135                                 __func__, ii, val, refval);
2136                         return -EINVAL;
2137                 }
2138         }
2139
2140         /*
2141          * Verify NET2272's "NET2270 legacy revision" register
2142          *  - NET2272 has two revision registers. The NET2270 legacy revision
2143          *    register should read the same value, regardless of the NET2272
2144          *    silicon revision.  The legacy register applies to NET2270
2145          *    firmware being applied to the NET2272.
2146          */
2147         val = net2272_read(dev, CHIPREV_LEGACY);
2148         if (val != NET2270_LEGACY_REV) {
2149                 /*
2150                  * Unexpected legacy revision value
2151                  * - Perhaps the chip is a NET2270?
2152                  */
2153                 dev_dbg(dev->dev,
2154                         "%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n"
2155                         " - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n",
2156                         __func__, NET2270_LEGACY_REV, val);
2157                 return -EINVAL;
2158         }
2159
2160         /*
2161          * Verify NET2272 silicon revision
2162          *  - This revision register is appropriate for the silicon version
2163          *    of the NET2272
2164          */
2165         val = net2272_read(dev, CHIPREV_2272);
2166         switch (val) {
2167         case CHIPREV_NET2272_R1:
2168                 /*
2169                  * NET2272 Rev 1 has DMA related errata:
2170                  *  - Newer silicon (Rev 1A or better) required
2171                  */
2172                 dev_dbg(dev->dev,
2173                         "%s: Rev 1 detected: newer silicon recommended for DMA support\n",
2174                         __func__);
2175                 break;
2176         case CHIPREV_NET2272_R1A:
2177                 break;
2178         default:
2179                 /* NET2272 silicon version *may* not work with this firmware */
2180                 dev_dbg(dev->dev,
2181                         "%s: unexpected silicon revision register value: "
2182                         " CHIPREV_2272: 0x%2.2x\n",
2183                         __func__, val);
2184                 /*
2185                  * Return Success, even though the chip rev is not an expected value
2186                  *  - Older, pre-built firmware can attempt to operate on newer silicon
2187                  *  - Often, new silicon is perfectly compatible
2188                  */
2189         }
2190
2191         /* Success: NET2272 checks out OK */
2192         return 0;
2193 }
2194
2195 static void
2196 net2272_gadget_release(struct device *_dev)
2197 {
2198         struct net2272 *dev = container_of(_dev, struct net2272, gadget.dev);
2199
2200         kfree(dev);
2201 }
2202
2203 /*---------------------------------------------------------------------------*/
2204
2205 static void
2206 net2272_remove(struct net2272 *dev)
2207 {
2208         if (dev->added)
2209                 usb_del_gadget(&dev->gadget);
2210         free_irq(dev->irq, dev);
2211         iounmap(dev->base_addr);
2212         device_remove_file(dev->dev, &dev_attr_registers);
2213
2214         dev_info(dev->dev, "unbind\n");
2215 }
2216
2217 static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq)
2218 {
2219         struct net2272 *ret;
2220
2221         if (!irq) {
2222                 dev_dbg(dev, "No IRQ!\n");
2223                 return ERR_PTR(-ENODEV);
2224         }
2225
2226         /* alloc, and start init */
2227         ret = kzalloc(sizeof(*ret), GFP_KERNEL);
2228         if (!ret)
2229                 return ERR_PTR(-ENOMEM);
2230
2231         spin_lock_init(&ret->lock);
2232         ret->irq = irq;
2233         ret->dev = dev;
2234         ret->gadget.ops = &net2272_ops;
2235         ret->gadget.max_speed = USB_SPEED_HIGH;
2236
2237         /* the "gadget" abstracts/virtualizes the controller */
2238         ret->gadget.name = driver_name;
2239         usb_initialize_gadget(dev, &ret->gadget, net2272_gadget_release);
2240
2241         return ret;
2242 }
2243
2244 static int
2245 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2246 {
2247         int ret;
2248
2249         /* See if there... */
2250         if (net2272_present(dev)) {
2251                 dev_warn(dev->dev, "2272 not found!\n");
2252                 ret = -ENODEV;
2253                 goto err;
2254         }
2255
2256         net2272_usb_reset(dev);
2257         net2272_usb_reinit(dev);
2258
2259         ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev);
2260         if (ret) {
2261                 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2262                 goto err;
2263         }
2264
2265         dev->chiprev = net2272_read(dev, CHIPREV_2272);
2266
2267         /* done */
2268         dev_info(dev->dev, "%s\n", driver_desc);
2269         dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2270                 dev->irq, dev->base_addr, dev->chiprev,
2271                 dma_mode_string());
2272         dev_info(dev->dev, "version: %s\n", driver_vers);
2273
2274         ret = device_create_file(dev->dev, &dev_attr_registers);
2275         if (ret)
2276                 goto err_irq;
2277
2278         ret = usb_add_gadget(&dev->gadget);
2279         if (ret)
2280                 goto err_add_udc;
2281         dev->added = 1;
2282
2283         return 0;
2284
2285 err_add_udc:
2286         device_remove_file(dev->dev, &dev_attr_registers);
2287  err_irq:
2288         free_irq(dev->irq, dev);
2289  err:
2290         return ret;
2291 }
2292
2293 #ifdef CONFIG_USB_PCI
2294
2295 /*
2296  * wrap this driver around the specified device, but
2297  * don't respond over USB until a gadget driver binds to us
2298  */
2299
2300 static int
2301 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2302 {
2303         unsigned long resource, len, tmp;
2304         void __iomem *mem_mapped_addr[4];
2305         int ret, i;
2306
2307         /*
2308          * BAR 0 holds PLX 9054 config registers
2309          * BAR 1 is i/o memory; unused here
2310          * BAR 2 holds EPLD config registers
2311          * BAR 3 holds NET2272 registers
2312          */
2313
2314         /* Find and map all address spaces */
2315         for (i = 0; i < 4; ++i) {
2316                 if (i == 1)
2317                         continue;       /* BAR1 unused */
2318
2319                 resource = pci_resource_start(pdev, i);
2320                 len = pci_resource_len(pdev, i);
2321
2322                 if (!request_mem_region(resource, len, driver_name)) {
2323                         dev_dbg(dev->dev, "controller already in use\n");
2324                         ret = -EBUSY;
2325                         goto err;
2326                 }
2327
2328                 mem_mapped_addr[i] = ioremap(resource, len);
2329                 if (mem_mapped_addr[i] == NULL) {
2330                         release_mem_region(resource, len);
2331                         dev_dbg(dev->dev, "can't map memory\n");
2332                         ret = -EFAULT;
2333                         goto err;
2334                 }
2335         }
2336
2337         dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2338         dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2339         dev->base_addr = mem_mapped_addr[3];
2340
2341         /* Set PLX 9054 bus width (16 bits) */
2342         tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1);
2343         writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT,
2344                         dev->rdk1.plx9054_base_addr + LBRD1);
2345
2346         /* Enable PLX 9054 Interrupts */
2347         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) |
2348                         (1 << PCI_INTERRUPT_ENABLE) |
2349                         (1 << LOCAL_INTERRUPT_INPUT_ENABLE),
2350                         dev->rdk1.plx9054_base_addr + INTCSR);
2351
2352         writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2353                         dev->rdk1.plx9054_base_addr + DMACSR0);
2354
2355         /* reset */
2356         writeb((1 << EPLD_DMA_ENABLE) |
2357                 (1 << DMA_CTL_DACK) |
2358                 (1 << DMA_TIMEOUT_ENABLE) |
2359                 (1 << USER) |
2360                 (0 << MPX_MODE) |
2361                 (1 << BUSWIDTH) |
2362                 (1 << NET2272_RESET),
2363                 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2364
2365         mb();
2366         writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2367                 ~(1 << NET2272_RESET),
2368                 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2369         udelay(200);
2370
2371         return 0;
2372
2373  err:
2374         while (--i >= 0) {
2375                 if (i == 1)
2376                         continue;       /* BAR1 unused */
2377                 iounmap(mem_mapped_addr[i]);
2378                 release_mem_region(pci_resource_start(pdev, i),
2379                         pci_resource_len(pdev, i));
2380         }
2381
2382         return ret;
2383 }
2384
2385 static int
2386 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2387 {
2388         unsigned long resource, len;
2389         void __iomem *mem_mapped_addr[2];
2390         int ret, i;
2391
2392         /*
2393          * BAR 0 holds FGPA config registers
2394          * BAR 1 holds NET2272 registers
2395          */
2396
2397         /* Find and map all address spaces, bar2-3 unused in rdk 2 */
2398         for (i = 0; i < 2; ++i) {
2399                 resource = pci_resource_start(pdev, i);
2400                 len = pci_resource_len(pdev, i);
2401
2402                 if (!request_mem_region(resource, len, driver_name)) {
2403                         dev_dbg(dev->dev, "controller already in use\n");
2404                         ret = -EBUSY;
2405                         goto err;
2406                 }
2407
2408                 mem_mapped_addr[i] = ioremap(resource, len);
2409                 if (mem_mapped_addr[i] == NULL) {
2410                         release_mem_region(resource, len);
2411                         dev_dbg(dev->dev, "can't map memory\n");
2412                         ret = -EFAULT;
2413                         goto err;
2414                 }
2415         }
2416
2417         dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2418         dev->base_addr = mem_mapped_addr[1];
2419
2420         mb();
2421         /* Set 2272 bus width (16 bits) and reset */
2422         writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2423         udelay(200);
2424         writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2425         /* Print fpga version number */
2426         dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2427                 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2428         /* Enable FPGA Interrupts */
2429         writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2430
2431         return 0;
2432
2433  err:
2434         while (--i >= 0) {
2435                 iounmap(mem_mapped_addr[i]);
2436                 release_mem_region(pci_resource_start(pdev, i),
2437                         pci_resource_len(pdev, i));
2438         }
2439
2440         return ret;
2441 }
2442
2443 static int
2444 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2445 {
2446         struct net2272 *dev;
2447         int ret;
2448
2449         dev = net2272_probe_init(&pdev->dev, pdev->irq);
2450         if (IS_ERR(dev))
2451                 return PTR_ERR(dev);
2452         dev->dev_id = pdev->device;
2453
2454         if (pci_enable_device(pdev) < 0) {
2455                 ret = -ENODEV;
2456                 goto err_put;
2457         }
2458
2459         pci_set_master(pdev);
2460
2461         switch (pdev->device) {
2462         case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2463         case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2464         default: BUG();
2465         }
2466         if (ret)
2467                 goto err_pci;
2468
2469         ret = net2272_probe_fin(dev, 0);
2470         if (ret)
2471                 goto err_pci;
2472
2473         pci_set_drvdata(pdev, dev);
2474
2475         return 0;
2476
2477  err_pci:
2478         pci_disable_device(pdev);
2479  err_put:
2480         usb_put_gadget(&dev->gadget);
2481
2482         return ret;
2483 }
2484
2485 static void
2486 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2487 {
2488         int i;
2489
2490         /* disable PLX 9054 interrupts */
2491         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2492                 ~(1 << PCI_INTERRUPT_ENABLE),
2493                 dev->rdk1.plx9054_base_addr + INTCSR);
2494
2495         /* clean up resources allocated during probe() */
2496         iounmap(dev->rdk1.plx9054_base_addr);
2497         iounmap(dev->rdk1.epld_base_addr);
2498
2499         for (i = 0; i < 4; ++i) {
2500                 if (i == 1)
2501                         continue;       /* BAR1 unused */
2502                 release_mem_region(pci_resource_start(pdev, i),
2503                         pci_resource_len(pdev, i));
2504         }
2505 }
2506
2507 static void
2508 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2509 {
2510         int i;
2511
2512         /* disable fpga interrupts
2513         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2514                         ~(1 << PCI_INTERRUPT_ENABLE),
2515                         dev->rdk1.plx9054_base_addr + INTCSR);
2516         */
2517
2518         /* clean up resources allocated during probe() */
2519         iounmap(dev->rdk2.fpga_base_addr);
2520
2521         for (i = 0; i < 2; ++i)
2522                 release_mem_region(pci_resource_start(pdev, i),
2523                         pci_resource_len(pdev, i));
2524 }
2525
2526 static void
2527 net2272_pci_remove(struct pci_dev *pdev)
2528 {
2529         struct net2272 *dev = pci_get_drvdata(pdev);
2530
2531         net2272_remove(dev);
2532
2533         switch (pdev->device) {
2534         case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2535         case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2536         default: BUG();
2537         }
2538
2539         pci_disable_device(pdev);
2540
2541         usb_put_gadget(&dev->gadget);
2542 }
2543
2544 /* Table of matching PCI IDs */
2545 static struct pci_device_id pci_ids[] = {
2546         {       /* RDK 1 card */
2547                 .class       = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2548                 .class_mask  = 0,
2549                 .vendor      = PCI_VENDOR_ID_PLX,
2550                 .device      = PCI_DEVICE_ID_RDK1,
2551                 .subvendor   = PCI_ANY_ID,
2552                 .subdevice   = PCI_ANY_ID,
2553         },
2554         {       /* RDK 2 card */
2555                 .class       = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2556                 .class_mask  = 0,
2557                 .vendor      = PCI_VENDOR_ID_PLX,
2558                 .device      = PCI_DEVICE_ID_RDK2,
2559                 .subvendor   = PCI_ANY_ID,
2560                 .subdevice   = PCI_ANY_ID,
2561         },
2562         { }
2563 };
2564 MODULE_DEVICE_TABLE(pci, pci_ids);
2565
2566 static struct pci_driver net2272_pci_driver = {
2567         .name     = driver_name,
2568         .id_table = pci_ids,
2569
2570         .probe    = net2272_pci_probe,
2571         .remove   = net2272_pci_remove,
2572 };
2573
2574 static int net2272_pci_register(void)
2575 {
2576         return pci_register_driver(&net2272_pci_driver);
2577 }
2578
2579 static void net2272_pci_unregister(void)
2580 {
2581         pci_unregister_driver(&net2272_pci_driver);
2582 }
2583
2584 #else
2585 static inline int net2272_pci_register(void) { return 0; }
2586 static inline void net2272_pci_unregister(void) { }
2587 #endif
2588
2589 /*---------------------------------------------------------------------------*/
2590
2591 static int
2592 net2272_plat_probe(struct platform_device *pdev)
2593 {
2594         struct net2272 *dev;
2595         int ret;
2596         unsigned int irqflags;
2597         resource_size_t base, len;
2598         struct resource *iomem, *iomem_bus, *irq_res;
2599
2600         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2601         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2602         iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0);
2603         if (!irq_res || !iomem) {
2604                 dev_err(&pdev->dev, "must provide irq/base addr");
2605                 return -EINVAL;
2606         }
2607
2608         dev = net2272_probe_init(&pdev->dev, irq_res->start);
2609         if (IS_ERR(dev))
2610                 return PTR_ERR(dev);
2611
2612         irqflags = 0;
2613         if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2614                 irqflags |= IRQF_TRIGGER_RISING;
2615         if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2616                 irqflags |= IRQF_TRIGGER_FALLING;
2617         if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2618                 irqflags |= IRQF_TRIGGER_HIGH;
2619         if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2620                 irqflags |= IRQF_TRIGGER_LOW;
2621
2622         base = iomem->start;
2623         len = resource_size(iomem);
2624         if (iomem_bus)
2625                 dev->base_shift = iomem_bus->start;
2626
2627         if (!request_mem_region(base, len, driver_name)) {
2628                 dev_dbg(dev->dev, "get request memory region!\n");
2629                 ret = -EBUSY;
2630                 goto err;
2631         }
2632         dev->base_addr = ioremap(base, len);
2633         if (!dev->base_addr) {
2634                 dev_dbg(dev->dev, "can't map memory\n");
2635                 ret = -EFAULT;
2636                 goto err_req;
2637         }
2638
2639         ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW);
2640         if (ret)
2641                 goto err_io;
2642
2643         platform_set_drvdata(pdev, dev);
2644         dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2645                 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2646
2647         return 0;
2648
2649  err_io:
2650         iounmap(dev->base_addr);
2651  err_req:
2652         release_mem_region(base, len);
2653  err:
2654         usb_put_gadget(&dev->gadget);
2655
2656         return ret;
2657 }
2658
2659 static int
2660 net2272_plat_remove(struct platform_device *pdev)
2661 {
2662         struct net2272 *dev = platform_get_drvdata(pdev);
2663
2664         net2272_remove(dev);
2665
2666         release_mem_region(pdev->resource[0].start,
2667                 resource_size(&pdev->resource[0]));
2668
2669         usb_put_gadget(&dev->gadget);
2670
2671         return 0;
2672 }
2673
2674 static struct platform_driver net2272_plat_driver = {
2675         .probe   = net2272_plat_probe,
2676         .remove  = net2272_plat_remove,
2677         .driver  = {
2678                 .name  = driver_name,
2679         },
2680         /* FIXME .suspend, .resume */
2681 };
2682 MODULE_ALIAS("platform:net2272");
2683
2684 static int __init net2272_init(void)
2685 {
2686         int ret;
2687
2688         ret = net2272_pci_register();
2689         if (ret)
2690                 return ret;
2691         ret = platform_driver_register(&net2272_plat_driver);
2692         if (ret)
2693                 goto err_pci;
2694         return ret;
2695
2696 err_pci:
2697         net2272_pci_unregister();
2698         return ret;
2699 }
2700 module_init(net2272_init);
2701
2702 static void __exit net2272_cleanup(void)
2703 {
2704         net2272_pci_unregister();
2705         platform_driver_unregister(&net2272_plat_driver);
2706 }
2707 module_exit(net2272_cleanup);
2708
2709 MODULE_DESCRIPTION(DRIVER_DESC);
2710 MODULE_AUTHOR("PLX Technology, Inc.");
2711 MODULE_LICENSE("GPL");