drivers/usb/gadget/udc/net2272.c

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