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                 spin_unlock(&dev->lock);
2074                 return IRQ_NONE;
2075         }
2076         /* check dma interrupts */
2077 #endif
2078         /* Platform/devcice interrupt handler */
2079 #if !defined(PLX_PCI_RDK)
2080         net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2081         net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2082 #endif
2083         spin_unlock(&dev->lock);
2084
2085         return IRQ_HANDLED;
2086 }
2087
2088 static int net2272_present(struct net2272 *dev)
2089 {
2090         /*
2091          * Quick test to see if CPU can communicate properly with the NET2272.
2092          * Verifies connection using writes and reads to write/read and
2093          * read-only registers.
2094          *
2095          * This routine is strongly recommended especially during early bring-up
2096          * of new hardware, however for designs that do not apply Power On System
2097          * Tests (POST) it may discarded (or perhaps minimized).
2098          */
2099         unsigned int ii;
2100         u8 val, refval;
2101
2102         /* Verify NET2272 write/read SCRATCH register can write and read */
2103         refval = net2272_read(dev, SCRATCH);
2104         for (ii = 0; ii < 0x100; ii += 7) {
2105                 net2272_write(dev, SCRATCH, ii);
2106                 val = net2272_read(dev, SCRATCH);
2107                 if (val != ii) {
2108                         dev_dbg(dev->dev,
2109                                 "%s: write/read SCRATCH register test failed: "
2110                                 "wrote:0x%2.2x, read:0x%2.2x\n",
2111                                 __func__, ii, val);
2112                         return -EINVAL;
2113                 }
2114         }
2115         /* To be nice, we write the original SCRATCH value back: */
2116         net2272_write(dev, SCRATCH, refval);
2117
2118         /* Verify NET2272 CHIPREV register is read-only: */
2119         refval = net2272_read(dev, CHIPREV_2272);
2120         for (ii = 0; ii < 0x100; ii += 7) {
2121                 net2272_write(dev, CHIPREV_2272, ii);
2122                 val = net2272_read(dev, CHIPREV_2272);
2123                 if (val != refval) {
2124                         dev_dbg(dev->dev,
2125                                 "%s: write/read CHIPREV register test failed: "
2126                                 "wrote 0x%2.2x, read:0x%2.2x expected:0x%2.2x\n",
2127                                 __func__, ii, val, refval);
2128                         return -EINVAL;
2129                 }
2130         }
2131
2132         /*
2133          * Verify NET2272's "NET2270 legacy revision" register
2134          *  - NET2272 has two revision registers. The NET2270 legacy revision
2135          *    register should read the same value, regardless of the NET2272
2136          *    silicon revision.  The legacy register applies to NET2270
2137          *    firmware being applied to the NET2272.
2138          */
2139         val = net2272_read(dev, CHIPREV_LEGACY);
2140         if (val != NET2270_LEGACY_REV) {
2141                 /*
2142                  * Unexpected legacy revision value
2143                  * - Perhaps the chip is a NET2270?
2144                  */
2145                 dev_dbg(dev->dev,
2146                         "%s: WARNING: UNEXPECTED NET2272 LEGACY REGISTER VALUE:\n"
2147                         " - CHIPREV_LEGACY: expected 0x%2.2x, got:0x%2.2x. (Not NET2272?)\n",
2148                         __func__, NET2270_LEGACY_REV, val);
2149                 return -EINVAL;
2150         }
2151
2152         /*
2153          * Verify NET2272 silicon revision
2154          *  - This revision register is appropriate for the silicon version
2155          *    of the NET2272
2156          */
2157         val = net2272_read(dev, CHIPREV_2272);
2158         switch (val) {
2159         case CHIPREV_NET2272_R1:
2160                 /*
2161                  * NET2272 Rev 1 has DMA related errata:
2162                  *  - Newer silicon (Rev 1A or better) required
2163                  */
2164                 dev_dbg(dev->dev,
2165                         "%s: Rev 1 detected: newer silicon recommended for DMA support\n",
2166                         __func__);
2167                 break;
2168         case CHIPREV_NET2272_R1A:
2169                 break;
2170         default:
2171                 /* NET2272 silicon version *may* not work with this firmware */
2172                 dev_dbg(dev->dev,
2173                         "%s: unexpected silicon revision register value: "
2174                         " CHIPREV_2272: 0x%2.2x\n",
2175                         __func__, val);
2176                 /*
2177                  * Return Success, even though the chip rev is not an expected value
2178                  *  - Older, pre-built firmware can attempt to operate on newer silicon
2179                  *  - Often, new silicon is perfectly compatible
2180                  */
2181         }
2182
2183         /* Success: NET2272 checks out OK */
2184         return 0;
2185 }
2186
2187 static void
2188 net2272_gadget_release(struct device *_dev)
2189 {
2190         struct net2272 *dev = dev_get_drvdata(_dev);
2191         kfree(dev);
2192 }
2193
2194 /*---------------------------------------------------------------------------*/
2195
2196 static void __devexit
2197 net2272_remove(struct net2272 *dev)
2198 {
2199         usb_del_gadget_udc(&dev->gadget);
2200
2201         /* start with the driver above us */
2202         if (dev->driver) {
2203                 /* should have been done already by driver model core */
2204                 dev_warn(dev->dev, "pci remove, driver '%s' is still registered\n",
2205                         dev->driver->driver.name);
2206                 usb_gadget_unregister_driver(dev->driver);
2207         }
2208
2209         free_irq(dev->irq, dev);
2210         iounmap(dev->base_addr);
2211
2212         device_unregister(&dev->gadget.dev);
2213         device_remove_file(dev->dev, &dev_attr_registers);
2214
2215         dev_info(dev->dev, "unbind\n");
2216 }
2217
2218 static struct net2272 * __devinit
2219 net2272_probe_init(struct device *dev, unsigned int irq)
2220 {
2221         struct net2272 *ret;
2222
2223         if (!irq) {
2224                 dev_dbg(dev, "No IRQ!\n");
2225                 return ERR_PTR(-ENODEV);
2226         }
2227
2228         /* alloc, and start init */
2229         ret = kzalloc(sizeof(*ret), GFP_KERNEL);
2230         if (!ret)
2231                 return ERR_PTR(-ENOMEM);
2232
2233         spin_lock_init(&ret->lock);
2234         ret->irq = irq;
2235         ret->dev = dev;
2236         ret->gadget.ops = &net2272_ops;
2237         ret->gadget.max_speed = USB_SPEED_HIGH;
2238
2239         /* the "gadget" abstracts/virtualizes the controller */
2240         dev_set_name(&ret->gadget.dev, "gadget");
2241         ret->gadget.dev.parent = dev;
2242         ret->gadget.dev.dma_mask = dev->dma_mask;
2243         ret->gadget.dev.release = net2272_gadget_release;
2244         ret->gadget.name = driver_name;
2245
2246         return ret;
2247 }
2248
2249 static int __devinit
2250 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2251 {
2252         int ret;
2253
2254         /* See if there... */
2255         if (net2272_present(dev)) {
2256                 dev_warn(dev->dev, "2272 not found!\n");
2257                 ret = -ENODEV;
2258                 goto err;
2259         }
2260
2261         net2272_usb_reset(dev);
2262         net2272_usb_reinit(dev);
2263
2264         ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev);
2265         if (ret) {
2266                 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2267                 goto err;
2268         }
2269
2270         dev->chiprev = net2272_read(dev, CHIPREV_2272);
2271
2272         /* done */
2273         dev_info(dev->dev, "%s\n", driver_desc);
2274         dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2275                 dev->irq, dev->base_addr, dev->chiprev,
2276                 dma_mode_string());
2277         dev_info(dev->dev, "version: %s\n", driver_vers);
2278
2279         ret = device_register(&dev->gadget.dev);
2280         if (ret)
2281                 goto err_irq;
2282         ret = device_create_file(dev->dev, &dev_attr_registers);
2283         if (ret)
2284                 goto err_dev_reg;
2285
2286         ret = usb_add_gadget_udc(dev->dev, &dev->gadget);
2287         if (ret)
2288                 goto err_add_udc;
2289
2290         return 0;
2291
2292 err_add_udc:
2293         device_remove_file(dev->dev, &dev_attr_registers);
2294  err_dev_reg:
2295         device_unregister(&dev->gadget.dev);
2296  err_irq:
2297         free_irq(dev->irq, dev);
2298  err:
2299         return ret;
2300 }
2301
2302 #ifdef CONFIG_PCI
2303
2304 /*
2305  * wrap this driver around the specified device, but
2306  * don't respond over USB until a gadget driver binds to us
2307  */
2308
2309 static int __devinit
2310 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2311 {
2312         unsigned long resource, len, tmp;
2313         void __iomem *mem_mapped_addr[4];
2314         int ret, i;
2315
2316         /*
2317          * BAR 0 holds PLX 9054 config registers
2318          * BAR 1 is i/o memory; unused here
2319          * BAR 2 holds EPLD config registers
2320          * BAR 3 holds NET2272 registers
2321          */
2322
2323         /* Find and map all address spaces */
2324         for (i = 0; i < 4; ++i) {
2325                 if (i == 1)
2326                         continue;       /* BAR1 unused */
2327
2328                 resource = pci_resource_start(pdev, i);
2329                 len = pci_resource_len(pdev, i);
2330
2331                 if (!request_mem_region(resource, len, driver_name)) {
2332                         dev_dbg(dev->dev, "controller already in use\n");
2333                         ret = -EBUSY;
2334                         goto err;
2335                 }
2336
2337                 mem_mapped_addr[i] = ioremap_nocache(resource, len);
2338                 if (mem_mapped_addr[i] == NULL) {
2339                         release_mem_region(resource, len);
2340                         dev_dbg(dev->dev, "can't map memory\n");
2341                         ret = -EFAULT;
2342                         goto err;
2343                 }
2344         }
2345
2346         dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2347         dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2348         dev->base_addr = mem_mapped_addr[3];
2349
2350         /* Set PLX 9054 bus width (16 bits) */
2351         tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1);
2352         writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT,
2353                         dev->rdk1.plx9054_base_addr + LBRD1);
2354
2355         /* Enable PLX 9054 Interrupts */
2356         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) |
2357                         (1 << PCI_INTERRUPT_ENABLE) |
2358                         (1 << LOCAL_INTERRUPT_INPUT_ENABLE),
2359                         dev->rdk1.plx9054_base_addr + INTCSR);
2360
2361         writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2362                         dev->rdk1.plx9054_base_addr + DMACSR0);
2363
2364         /* reset */
2365         writeb((1 << EPLD_DMA_ENABLE) |
2366                 (1 << DMA_CTL_DACK) |
2367                 (1 << DMA_TIMEOUT_ENABLE) |
2368                 (1 << USER) |
2369                 (0 << MPX_MODE) |
2370                 (1 << BUSWIDTH) |
2371                 (1 << NET2272_RESET),
2372                 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2373
2374         mb();
2375         writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2376                 ~(1 << NET2272_RESET),
2377                 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2378         udelay(200);
2379
2380         return 0;
2381
2382  err:
2383         while (--i >= 0) {
2384                 iounmap(mem_mapped_addr[i]);
2385                 release_mem_region(pci_resource_start(pdev, i),
2386                         pci_resource_len(pdev, i));
2387         }
2388
2389         return ret;
2390 }
2391
2392 static int __devinit
2393 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2394 {
2395         unsigned long resource, len;
2396         void __iomem *mem_mapped_addr[2];
2397         int ret, i;
2398
2399         /*
2400          * BAR 0 holds FGPA config registers
2401          * BAR 1 holds NET2272 registers
2402          */
2403
2404         /* Find and map all address spaces, bar2-3 unused in rdk 2 */
2405         for (i = 0; i < 2; ++i) {
2406                 resource = pci_resource_start(pdev, i);
2407                 len = pci_resource_len(pdev, i);
2408
2409                 if (!request_mem_region(resource, len, driver_name)) {
2410                         dev_dbg(dev->dev, "controller already in use\n");
2411                         ret = -EBUSY;
2412                         goto err;
2413                 }
2414
2415                 mem_mapped_addr[i] = ioremap_nocache(resource, len);
2416                 if (mem_mapped_addr[i] == NULL) {
2417                         release_mem_region(resource, len);
2418                         dev_dbg(dev->dev, "can't map memory\n");
2419                         ret = -EFAULT;
2420                         goto err;
2421                 }
2422         }
2423
2424         dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2425         dev->base_addr = mem_mapped_addr[1];
2426
2427         mb();
2428         /* Set 2272 bus width (16 bits) and reset */
2429         writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2430         udelay(200);
2431         writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2432         /* Print fpga version number */
2433         dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2434                 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2435         /* Enable FPGA Interrupts */
2436         writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2437
2438         return 0;
2439
2440  err:
2441         while (--i >= 0) {
2442                 iounmap(mem_mapped_addr[i]);
2443                 release_mem_region(pci_resource_start(pdev, i),
2444                         pci_resource_len(pdev, i));
2445         }
2446
2447         return ret;
2448 }
2449
2450 static int __devinit
2451 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2452 {
2453         struct net2272 *dev;
2454         int ret;
2455
2456         dev = net2272_probe_init(&pdev->dev, pdev->irq);
2457         if (IS_ERR(dev))
2458                 return PTR_ERR(dev);
2459         dev->dev_id = pdev->device;
2460
2461         if (pci_enable_device(pdev) < 0) {
2462                 ret = -ENODEV;
2463                 goto err_free;
2464         }
2465
2466         pci_set_master(pdev);
2467
2468         switch (pdev->device) {
2469         case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2470         case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2471         default: BUG();
2472         }
2473         if (ret)
2474                 goto err_pci;
2475
2476         ret = net2272_probe_fin(dev, 0);
2477         if (ret)
2478                 goto err_pci;
2479
2480         pci_set_drvdata(pdev, dev);
2481
2482         return 0;
2483
2484  err_pci:
2485         pci_disable_device(pdev);
2486  err_free:
2487         kfree(dev);
2488
2489         return ret;
2490 }
2491
2492 static void __devexit
2493 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2494 {
2495         int i;
2496
2497         /* disable PLX 9054 interrupts */
2498         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2499                 ~(1 << PCI_INTERRUPT_ENABLE),
2500                 dev->rdk1.plx9054_base_addr + INTCSR);
2501
2502         /* clean up resources allocated during probe() */
2503         iounmap(dev->rdk1.plx9054_base_addr);
2504         iounmap(dev->rdk1.epld_base_addr);
2505
2506         for (i = 0; i < 4; ++i) {
2507                 if (i == 1)
2508                         continue;       /* BAR1 unused */
2509                 release_mem_region(pci_resource_start(pdev, i),
2510                         pci_resource_len(pdev, i));
2511         }
2512 }
2513
2514 static void __devexit
2515 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2516 {
2517         int i;
2518
2519         /* disable fpga interrupts
2520         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2521                         ~(1 << PCI_INTERRUPT_ENABLE),
2522                         dev->rdk1.plx9054_base_addr + INTCSR);
2523         */
2524
2525         /* clean up resources allocated during probe() */
2526         iounmap(dev->rdk2.fpga_base_addr);
2527
2528         for (i = 0; i < 2; ++i)
2529                 release_mem_region(pci_resource_start(pdev, i),
2530                         pci_resource_len(pdev, i));
2531 }
2532
2533 static void __devexit
2534 net2272_pci_remove(struct pci_dev *pdev)
2535 {
2536         struct net2272 *dev = pci_get_drvdata(pdev);
2537
2538         net2272_remove(dev);
2539
2540         switch (pdev->device) {
2541         case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2542         case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2543         default: BUG();
2544         }
2545
2546         pci_disable_device(pdev);
2547
2548         kfree(dev);
2549 }
2550
2551 /* Table of matching PCI IDs */
2552 static struct pci_device_id __devinitdata pci_ids[] = {
2553         {       /* RDK 1 card */
2554                 .class       = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2555                 .class_mask  = 0,
2556                 .vendor      = PCI_VENDOR_ID_PLX,
2557                 .device      = PCI_DEVICE_ID_RDK1,
2558                 .subvendor   = PCI_ANY_ID,
2559                 .subdevice   = PCI_ANY_ID,
2560         },
2561         {       /* RDK 2 card */
2562                 .class       = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2563                 .class_mask  = 0,
2564                 .vendor      = PCI_VENDOR_ID_PLX,
2565                 .device      = PCI_DEVICE_ID_RDK2,
2566                 .subvendor   = PCI_ANY_ID,
2567                 .subdevice   = PCI_ANY_ID,
2568         },
2569         { }
2570 };
2571 MODULE_DEVICE_TABLE(pci, pci_ids);
2572
2573 static struct pci_driver net2272_pci_driver = {
2574         .name     = driver_name,
2575         .id_table = pci_ids,
2576
2577         .probe    = net2272_pci_probe,
2578         .remove   = __devexit_p(net2272_pci_remove),
2579 };
2580
2581 static int net2272_pci_register(void)
2582 {
2583         return pci_register_driver(&net2272_pci_driver);
2584 }
2585
2586 static void net2272_pci_unregister(void)
2587 {
2588         pci_unregister_driver(&net2272_pci_driver);
2589 }
2590
2591 #else
2592 static inline int net2272_pci_register(void) { return 0; }
2593 static inline void net2272_pci_unregister(void) { }
2594 #endif
2595
2596 /*---------------------------------------------------------------------------*/
2597
2598 static int __devinit
2599 net2272_plat_probe(struct platform_device *pdev)
2600 {
2601         struct net2272 *dev;
2602         int ret;
2603         unsigned int irqflags;
2604         resource_size_t base, len;
2605         struct resource *iomem, *iomem_bus, *irq_res;
2606
2607         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2608         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2609         iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0);
2610         if (!irq_res || !iomem) {
2611                 dev_err(&pdev->dev, "must provide irq/base addr");
2612                 return -EINVAL;
2613         }
2614
2615         dev = net2272_probe_init(&pdev->dev, irq_res->start);
2616         if (IS_ERR(dev))
2617                 return PTR_ERR(dev);
2618
2619         irqflags = 0;
2620         if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2621                 irqflags |= IRQF_TRIGGER_RISING;
2622         if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2623                 irqflags |= IRQF_TRIGGER_FALLING;
2624         if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2625                 irqflags |= IRQF_TRIGGER_HIGH;
2626         if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2627                 irqflags |= IRQF_TRIGGER_LOW;
2628
2629         base = iomem->start;
2630         len = resource_size(iomem);
2631         if (iomem_bus)
2632                 dev->base_shift = iomem_bus->start;
2633
2634         if (!request_mem_region(base, len, driver_name)) {
2635                 dev_dbg(dev->dev, "get request memory region!\n");
2636                 ret = -EBUSY;
2637                 goto err;
2638         }
2639         dev->base_addr = ioremap_nocache(base, len);
2640         if (!dev->base_addr) {
2641                 dev_dbg(dev->dev, "can't map memory\n");
2642                 ret = -EFAULT;
2643                 goto err_req;
2644         }
2645
2646         ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW);
2647         if (ret)
2648                 goto err_io;
2649
2650         platform_set_drvdata(pdev, dev);
2651         dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2652                 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2653
2654         return 0;
2655
2656  err_io:
2657         iounmap(dev->base_addr);
2658  err_req:
2659         release_mem_region(base, len);
2660  err:
2661         return ret;
2662 }
2663
2664 static int __devexit
2665 net2272_plat_remove(struct platform_device *pdev)
2666 {
2667         struct net2272 *dev = platform_get_drvdata(pdev);
2668
2669         net2272_remove(dev);
2670
2671         release_mem_region(pdev->resource[0].start,
2672                 resource_size(&pdev->resource[0]));
2673
2674         kfree(dev);
2675
2676         return 0;
2677 }
2678
2679 static struct platform_driver net2272_plat_driver = {
2680         .probe   = net2272_plat_probe,
2681         .remove  = __devexit_p(net2272_plat_remove),
2682         .driver  = {
2683                 .name  = driver_name,
2684                 .owner = THIS_MODULE,
2685         },
2686         /* FIXME .suspend, .resume */
2687 };
2688 MODULE_ALIAS("platform:net2272");
2689
2690 static int __init net2272_init(void)
2691 {
2692         int ret;
2693
2694         ret = net2272_pci_register();
2695         if (ret)
2696                 return ret;
2697         ret = platform_driver_register(&net2272_plat_driver);
2698         if (ret)
2699                 goto err_pci;
2700         return ret;
2701
2702 err_pci:
2703         net2272_pci_unregister();
2704         return ret;
2705 }
2706 module_init(net2272_init);
2707
2708 static void __exit net2272_cleanup(void)
2709 {
2710         net2272_pci_unregister();
2711         platform_driver_unregister(&net2272_plat_driver);
2712 }
2713 module_exit(net2272_cleanup);
2714
2715 MODULE_DESCRIPTION(DRIVER_DESC);
2716 MODULE_AUTHOR("PLX Technology, Inc.");
2717 MODULE_LICENSE("GPL");