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