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