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