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
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 *net2272_probe_init(struct device *dev, unsigned int irq)
2219 {
2220         struct net2272 *ret;
2221
2222         if (!irq) {
2223                 dev_dbg(dev, "No IRQ!\n");
2224                 return ERR_PTR(-ENODEV);
2225         }
2226
2227         /* alloc, and start init */
2228         ret = kzalloc(sizeof(*ret), GFP_KERNEL);
2229         if (!ret)
2230                 return ERR_PTR(-ENOMEM);
2231
2232         spin_lock_init(&ret->lock);
2233         ret->irq = irq;
2234         ret->dev = dev;
2235         ret->gadget.ops = &net2272_ops;
2236         ret->gadget.max_speed = USB_SPEED_HIGH;
2237
2238         /* the "gadget" abstracts/virtualizes the controller */
2239         dev_set_name(&ret->gadget.dev, "gadget");
2240         ret->gadget.dev.parent = dev;
2241         ret->gadget.dev.dma_mask = dev->dma_mask;
2242         ret->gadget.dev.release = net2272_gadget_release;
2243         ret->gadget.name = driver_name;
2244
2245         return ret;
2246 }
2247
2248 static int
2249 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2250 {
2251         int ret;
2252
2253         /* See if there... */
2254         if (net2272_present(dev)) {
2255                 dev_warn(dev->dev, "2272 not found!\n");
2256                 ret = -ENODEV;
2257                 goto err;
2258         }
2259
2260         net2272_usb_reset(dev);
2261         net2272_usb_reinit(dev);
2262
2263         ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev);
2264         if (ret) {
2265                 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2266                 goto err;
2267         }
2268
2269         dev->chiprev = net2272_read(dev, CHIPREV_2272);
2270
2271         /* done */
2272         dev_info(dev->dev, "%s\n", driver_desc);
2273         dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2274                 dev->irq, dev->base_addr, dev->chiprev,
2275                 dma_mode_string());
2276         dev_info(dev->dev, "version: %s\n", driver_vers);
2277
2278         ret = device_register(&dev->gadget.dev);
2279         if (ret)
2280                 goto err_irq;
2281         ret = device_create_file(dev->dev, &dev_attr_registers);
2282         if (ret)
2283                 goto err_dev_reg;
2284
2285         ret = usb_add_gadget_udc(dev->dev, &dev->gadget);
2286         if (ret)
2287                 goto err_add_udc;
2288
2289         return 0;
2290
2291 err_add_udc:
2292         device_remove_file(dev->dev, &dev_attr_registers);
2293  err_dev_reg:
2294         device_unregister(&dev->gadget.dev);
2295  err_irq:
2296         free_irq(dev->irq, dev);
2297  err:
2298         return ret;
2299 }
2300
2301 #ifdef CONFIG_PCI
2302
2303 /*
2304  * wrap this driver around the specified device, but
2305  * don't respond over USB until a gadget driver binds to us
2306  */
2307
2308 static int
2309 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2310 {
2311         unsigned long resource, len, tmp;
2312         void __iomem *mem_mapped_addr[4];
2313         int ret, i;
2314
2315         /*
2316          * BAR 0 holds PLX 9054 config registers
2317          * BAR 1 is i/o memory; unused here
2318          * BAR 2 holds EPLD config registers
2319          * BAR 3 holds NET2272 registers
2320          */
2321
2322         /* Find and map all address spaces */
2323         for (i = 0; i < 4; ++i) {
2324                 if (i == 1)
2325                         continue;       /* BAR1 unused */
2326
2327                 resource = pci_resource_start(pdev, i);
2328                 len = pci_resource_len(pdev, i);
2329
2330                 if (!request_mem_region(resource, len, driver_name)) {
2331                         dev_dbg(dev->dev, "controller already in use\n");
2332                         ret = -EBUSY;
2333                         goto err;
2334                 }
2335
2336                 mem_mapped_addr[i] = ioremap_nocache(resource, len);
2337                 if (mem_mapped_addr[i] == NULL) {
2338                         release_mem_region(resource, len);
2339                         dev_dbg(dev->dev, "can't map memory\n");
2340                         ret = -EFAULT;
2341                         goto err;
2342                 }
2343         }
2344
2345         dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2346         dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2347         dev->base_addr = mem_mapped_addr[3];
2348
2349         /* Set PLX 9054 bus width (16 bits) */
2350         tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1);
2351         writel((tmp & ~(3 << MEMORY_SPACE_LOCAL_BUS_WIDTH)) | W16_BIT,
2352                         dev->rdk1.plx9054_base_addr + LBRD1);
2353
2354         /* Enable PLX 9054 Interrupts */
2355         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) |
2356                         (1 << PCI_INTERRUPT_ENABLE) |
2357                         (1 << LOCAL_INTERRUPT_INPUT_ENABLE),
2358                         dev->rdk1.plx9054_base_addr + INTCSR);
2359
2360         writeb((1 << CHANNEL_CLEAR_INTERRUPT | (0 << CHANNEL_ENABLE)),
2361                         dev->rdk1.plx9054_base_addr + DMACSR0);
2362
2363         /* reset */
2364         writeb((1 << EPLD_DMA_ENABLE) |
2365                 (1 << DMA_CTL_DACK) |
2366                 (1 << DMA_TIMEOUT_ENABLE) |
2367                 (1 << USER) |
2368                 (0 << MPX_MODE) |
2369                 (1 << BUSWIDTH) |
2370                 (1 << NET2272_RESET),
2371                 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2372
2373         mb();
2374         writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2375                 ~(1 << NET2272_RESET),
2376                 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2377         udelay(200);
2378
2379         return 0;
2380
2381  err:
2382         while (--i >= 0) {
2383                 iounmap(mem_mapped_addr[i]);
2384                 release_mem_region(pci_resource_start(pdev, i),
2385                         pci_resource_len(pdev, i));
2386         }
2387
2388         return ret;
2389 }
2390
2391 static int
2392 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2393 {
2394         unsigned long resource, len;
2395         void __iomem *mem_mapped_addr[2];
2396         int ret, i;
2397
2398         /*
2399          * BAR 0 holds FGPA config registers
2400          * BAR 1 holds NET2272 registers
2401          */
2402
2403         /* Find and map all address spaces, bar2-3 unused in rdk 2 */
2404         for (i = 0; i < 2; ++i) {
2405                 resource = pci_resource_start(pdev, i);
2406                 len = pci_resource_len(pdev, i);
2407
2408                 if (!request_mem_region(resource, len, driver_name)) {
2409                         dev_dbg(dev->dev, "controller already in use\n");
2410                         ret = -EBUSY;
2411                         goto err;
2412                 }
2413
2414                 mem_mapped_addr[i] = ioremap_nocache(resource, len);
2415                 if (mem_mapped_addr[i] == NULL) {
2416                         release_mem_region(resource, len);
2417                         dev_dbg(dev->dev, "can't map memory\n");
2418                         ret = -EFAULT;
2419                         goto err;
2420                 }
2421         }
2422
2423         dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2424         dev->base_addr = mem_mapped_addr[1];
2425
2426         mb();
2427         /* Set 2272 bus width (16 bits) and reset */
2428         writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2429         udelay(200);
2430         writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2431         /* Print fpga version number */
2432         dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2433                 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2434         /* Enable FPGA Interrupts */
2435         writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2436
2437         return 0;
2438
2439  err:
2440         while (--i >= 0) {
2441                 iounmap(mem_mapped_addr[i]);
2442                 release_mem_region(pci_resource_start(pdev, i),
2443                         pci_resource_len(pdev, i));
2444         }
2445
2446         return ret;
2447 }
2448
2449 static int
2450 net2272_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2451 {
2452         struct net2272 *dev;
2453         int ret;
2454
2455         dev = net2272_probe_init(&pdev->dev, pdev->irq);
2456         if (IS_ERR(dev))
2457                 return PTR_ERR(dev);
2458         dev->dev_id = pdev->device;
2459
2460         if (pci_enable_device(pdev) < 0) {
2461                 ret = -ENODEV;
2462                 goto err_free;
2463         }
2464
2465         pci_set_master(pdev);
2466
2467         switch (pdev->device) {
2468         case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2469         case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2470         default: BUG();
2471         }
2472         if (ret)
2473                 goto err_pci;
2474
2475         ret = net2272_probe_fin(dev, 0);
2476         if (ret)
2477                 goto err_pci;
2478
2479         pci_set_drvdata(pdev, dev);
2480
2481         return 0;
2482
2483  err_pci:
2484         pci_disable_device(pdev);
2485  err_free:
2486         kfree(dev);
2487
2488         return ret;
2489 }
2490
2491 static void
2492 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2493 {
2494         int i;
2495
2496         /* disable PLX 9054 interrupts */
2497         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2498                 ~(1 << PCI_INTERRUPT_ENABLE),
2499                 dev->rdk1.plx9054_base_addr + INTCSR);
2500
2501         /* clean up resources allocated during probe() */
2502         iounmap(dev->rdk1.plx9054_base_addr);
2503         iounmap(dev->rdk1.epld_base_addr);
2504
2505         for (i = 0; i < 4; ++i) {
2506                 if (i == 1)
2507                         continue;       /* BAR1 unused */
2508                 release_mem_region(pci_resource_start(pdev, i),
2509                         pci_resource_len(pdev, i));
2510         }
2511 }
2512
2513 static void
2514 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2515 {
2516         int i;
2517
2518         /* disable fpga interrupts
2519         writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2520                         ~(1 << PCI_INTERRUPT_ENABLE),
2521                         dev->rdk1.plx9054_base_addr + INTCSR);
2522         */
2523
2524         /* clean up resources allocated during probe() */
2525         iounmap(dev->rdk2.fpga_base_addr);
2526
2527         for (i = 0; i < 2; ++i)
2528                 release_mem_region(pci_resource_start(pdev, i),
2529                         pci_resource_len(pdev, i));
2530 }
2531
2532 static void
2533 net2272_pci_remove(struct pci_dev *pdev)
2534 {
2535         struct net2272 *dev = pci_get_drvdata(pdev);
2536
2537         net2272_remove(dev);
2538
2539         switch (pdev->device) {
2540         case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2541         case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2542         default: BUG();
2543         }
2544
2545         pci_disable_device(pdev);
2546
2547         kfree(dev);
2548 }
2549
2550 /* Table of matching PCI IDs */
2551 static struct pci_device_id pci_ids[] = {
2552         {       /* RDK 1 card */
2553                 .class       = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2554                 .class_mask  = 0,
2555                 .vendor      = PCI_VENDOR_ID_PLX,
2556                 .device      = PCI_DEVICE_ID_RDK1,
2557                 .subvendor   = PCI_ANY_ID,
2558                 .subdevice   = PCI_ANY_ID,
2559         },
2560         {       /* RDK 2 card */
2561                 .class       = ((PCI_CLASS_BRIDGE_OTHER << 8) | 0xfe),
2562                 .class_mask  = 0,
2563                 .vendor      = PCI_VENDOR_ID_PLX,
2564                 .device      = PCI_DEVICE_ID_RDK2,
2565                 .subvendor   = PCI_ANY_ID,
2566                 .subdevice   = PCI_ANY_ID,
2567         },
2568         { }
2569 };
2570 MODULE_DEVICE_TABLE(pci, pci_ids);
2571
2572 static struct pci_driver net2272_pci_driver = {
2573         .name     = driver_name,
2574         .id_table = pci_ids,
2575
2576         .probe    = net2272_pci_probe,
2577         .remove   = net2272_pci_remove,
2578 };
2579
2580 static int net2272_pci_register(void)
2581 {
2582         return pci_register_driver(&net2272_pci_driver);
2583 }
2584
2585 static void net2272_pci_unregister(void)
2586 {
2587         pci_unregister_driver(&net2272_pci_driver);
2588 }
2589
2590 #else
2591 static inline int net2272_pci_register(void) { return 0; }
2592 static inline void net2272_pci_unregister(void) { }
2593 #endif
2594
2595 /*---------------------------------------------------------------------------*/
2596
2597 static int
2598 net2272_plat_probe(struct platform_device *pdev)
2599 {
2600         struct net2272 *dev;
2601         int ret;
2602         unsigned int irqflags;
2603         resource_size_t base, len;
2604         struct resource *iomem, *iomem_bus, *irq_res;
2605
2606         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2607         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2608         iomem_bus = platform_get_resource(pdev, IORESOURCE_BUS, 0);
2609         if (!irq_res || !iomem) {
2610                 dev_err(&pdev->dev, "must provide irq/base addr");
2611                 return -EINVAL;
2612         }
2613
2614         dev = net2272_probe_init(&pdev->dev, irq_res->start);
2615         if (IS_ERR(dev))
2616                 return PTR_ERR(dev);
2617
2618         irqflags = 0;
2619         if (irq_res->flags & IORESOURCE_IRQ_HIGHEDGE)
2620                 irqflags |= IRQF_TRIGGER_RISING;
2621         if (irq_res->flags & IORESOURCE_IRQ_LOWEDGE)
2622                 irqflags |= IRQF_TRIGGER_FALLING;
2623         if (irq_res->flags & IORESOURCE_IRQ_HIGHLEVEL)
2624                 irqflags |= IRQF_TRIGGER_HIGH;
2625         if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
2626                 irqflags |= IRQF_TRIGGER_LOW;
2627
2628         base = iomem->start;
2629         len = resource_size(iomem);
2630         if (iomem_bus)
2631                 dev->base_shift = iomem_bus->start;
2632
2633         if (!request_mem_region(base, len, driver_name)) {
2634                 dev_dbg(dev->dev, "get request memory region!\n");
2635                 ret = -EBUSY;
2636                 goto err;
2637         }
2638         dev->base_addr = ioremap_nocache(base, len);
2639         if (!dev->base_addr) {
2640                 dev_dbg(dev->dev, "can't map memory\n");
2641                 ret = -EFAULT;
2642                 goto err_req;
2643         }
2644
2645         ret = net2272_probe_fin(dev, IRQF_TRIGGER_LOW);
2646         if (ret)
2647                 goto err_io;
2648
2649         platform_set_drvdata(pdev, dev);
2650         dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2651                 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2652
2653         return 0;
2654
2655  err_io:
2656         iounmap(dev->base_addr);
2657  err_req:
2658         release_mem_region(base, len);
2659  err:
2660         return ret;
2661 }
2662
2663 static int
2664 net2272_plat_remove(struct platform_device *pdev)
2665 {
2666         struct net2272 *dev = platform_get_drvdata(pdev);
2667
2668         net2272_remove(dev);
2669
2670         release_mem_region(pdev->resource[0].start,
2671                 resource_size(&pdev->resource[0]));
2672
2673         kfree(dev);
2674
2675         return 0;
2676 }
2677
2678 static struct platform_driver net2272_plat_driver = {
2679         .probe   = net2272_plat_probe,
2680         .remove  = net2272_plat_remove,
2681         .driver  = {
2682                 .name  = driver_name,
2683                 .owner = THIS_MODULE,
2684         },
2685         /* FIXME .suspend, .resume */
2686 };
2687 MODULE_ALIAS("platform:net2272");
2688
2689 static int __init net2272_init(void)
2690 {
2691         int ret;
2692
2693         ret = net2272_pci_register();
2694         if (ret)
2695                 return ret;
2696         ret = platform_driver_register(&net2272_plat_driver);
2697         if (ret)
2698                 goto err_pci;
2699         return ret;
2700
2701 err_pci:
2702         net2272_pci_unregister();
2703         return ret;
2704 }
2705 module_init(net2272_init);
2706
2707 static void __exit net2272_cleanup(void)
2708 {
2709         net2272_pci_unregister();
2710         platform_driver_unregister(&net2272_plat_driver);
2711 }
2712 module_exit(net2272_cleanup);
2713
2714 MODULE_DESCRIPTION(DRIVER_DESC);
2715 MODULE_AUTHOR("PLX Technology, Inc.");
2716 MODULE_LICENSE("GPL");