drivers/usb/gadget/udc/net2272.c

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