drivers/usb/gadget/net2272.c

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