Lines Matching refs:dev
116 dev_dbg(ep->dev->dev, "%s %s %02x !NAK\n",
177 struct net2272 *dev;
187 dev = ep->dev;
188 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
193 spin_lock_irqsave(&dev->lock, flags);
210 if ((dev->gadget.speed == USB_SPEED_HIGH && max != 512) ||
211 (dev->gadget.speed == USB_SPEED_FULL && max > 64)) {
212 spin_unlock_irqrestore(&dev->lock, flags);
230 tmp = (1 << ep->num) | net2272_read(dev, IRQENB0);
231 net2272_write(dev, IRQENB0, tmp);
239 dev_dbg(dev->dev, "enabled %s (ep%d%s-%s) max %04x cfg %02x\n",
244 spin_unlock_irqrestore(&dev->lock, flags);
303 spin_lock_irqsave(&ep->dev->lock, flags);
307 dev_vdbg(ep->dev->dev, "disabled %s\n", _ep->name);
309 spin_unlock_irqrestore(&ep->dev->lock, flags);
348 struct net2272 *dev;
352 if (ep->dev->protocol_stall) {
366 dev = ep->dev;
368 usb_gadget_unmap_request(&dev->gadget, &req->req,
372 dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
378 spin_unlock(&dev->lock);
380 spin_lock(&dev->lock);
388 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
396 dev_vdbg(ep->dev->dev, "write packet %s req %p max %u len %u avail %u\n",
412 tmp = net2272_read(ep->dev, LOCCTL);
413 net2272_write(ep->dev, LOCCTL, tmp & ~(1 << DATA_WIDTH));
415 net2272_write(ep->dev, LOCCTL, tmp);
428 dev_vdbg(ep->dev->dev, "write_fifo %s actual %d len %d\n",
496 u16 __iomem *ep_data = net2272_reg_addr(ep->dev, EP_DATA);
502 dev_vdbg(ep->dev->dev, "read packet %s req %p len %u avail %u\n",
543 dev_vdbg(ep->dev->dev, "read_fifo %s actual %d len %d\n",
562 dev_err(ep->dev->dev,
623 net2272_request_dma(struct net2272 *dev, unsigned ep, u32 buf,
626 dev_vdbg(dev->dev, "request_dma ep %d buf %08x len %d dir %d\n",
630 if (dev->dma_busy)
639 dev->dma_busy = 1;
644 switch (dev->dev_id) {
656 dev->rdk1.plx9054_base_addr + DMAMODE0);
658 writel(0x100000, dev->rdk1.plx9054_base_addr + DMALADR0);
659 writel(buf, dev->rdk1.plx9054_base_addr + DMAPADR0);
660 writel(len, dev->rdk1.plx9054_base_addr + DMASIZ0);
663 dev->rdk1.plx9054_base_addr + DMADPR0);
665 readl(dev->rdk1.plx9054_base_addr + INTCSR),
666 dev->rdk1.plx9054_base_addr + INTCSR);
672 net2272_write(dev, DMAREQ,
676 (dev->dma_eot_polarity << EOT_POLARITY) |
677 (dev->dma_dack_polarity << DACK_POLARITY) |
678 (dev->dma_dreq_polarity << DREQ_POLARITY) |
681 (void) net2272_read(dev, SCRATCH);
687 net2272_start_dma(struct net2272 *dev)
691 switch (dev->dev_id) {
694 dev->rdk1.plx9054_base_addr + DMACSR0);
716 dev_vdbg(ep->dev->dev, "kick_dma %s req %p dma %08llx\n",
722 if (ep->dev->dma_busy)
734 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 0))
744 if (net2272_request_dma(ep->dev, ep->num, req->req.dma, size, 1))
763 net2272_write(ep->dev, DMAREQ,
767 (ep->dev->dma_eot_polarity << EOT_POLARITY) |
768 (ep->dev->dma_dack_polarity << DACK_POLARITY) |
769 (ep->dev->dma_dreq_polarity << DREQ_POLARITY) |
779 net2272_start_dma(ep->dev);
784 static void net2272_cancel_dma(struct net2272 *dev)
787 switch (dev->dev_id) {
789 writeb(0, dev->rdk1.plx9054_base_addr + DMACSR0);
790 writeb(1 << CHANNEL_ABORT, dev->rdk1.plx9054_base_addr + DMACSR0);
791 while (!(readb(dev->rdk1.plx9054_base_addr + DMACSR0) &
797 dev->rdk1.plx9054_base_addr + DMACSR0);
802 dev->dma_busy = 0;
812 struct net2272 *dev;
824 dev = ep->dev;
825 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
830 status = usb_gadget_map_request(&dev->gadget, _req,
836 dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n",
840 spin_lock_irqsave(&dev->lock, flags);
850 dev_vdbg(dev->dev, "%s status ack\n", ep->ep.name);
860 dev_dbg(dev->dev, "WARNING: returning ZLP short packet termination!\n");
902 spin_unlock_irqrestore(&dev->lock, flags);
937 spin_lock_irqsave(&ep->dev->lock, flags);
950 spin_unlock_irqrestore(&ep->dev->lock, flags);
956 dev_dbg(ep->dev->dev, "unlink (%s) pio\n", _ep->name);
961 spin_unlock_irqrestore(&ep->dev->lock, flags);
977 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
982 spin_lock_irqsave(&ep->dev->lock, flags);
988 dev_vdbg(ep->dev->dev, "%s %s %s\n", _ep->name,
994 ep->dev->protocol_stall = 1;
1004 spin_unlock_irqrestore(&ep->dev->lock, flags);
1032 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1052 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
1079 struct net2272 *dev;
1085 dev = container_of(_gadget, struct net2272, gadget);
1086 spin_lock_irqsave(&dev->lock, flags);
1088 ret = net2272_read(dev, FRAME1) << 8;
1089 ret |= net2272_read(dev, FRAME0);
1091 spin_unlock_irqrestore(&dev->lock, flags);
1098 struct net2272 *dev;
1104 dev = container_of(_gadget, struct net2272, gadget);
1106 spin_lock_irqsave(&dev->lock, flags);
1107 tmp = net2272_read(dev, USBCTL0);
1109 net2272_write(dev, USBCTL1, (1 << GENERATE_RESUME));
1111 spin_unlock_irqrestore(&dev->lock, flags);
1130 struct net2272 *dev;
1136 dev = container_of(_gadget, struct net2272, gadget);
1138 spin_lock_irqsave(&dev->lock, flags);
1139 tmp = net2272_read(dev, USBCTL0);
1140 dev->softconnect = (is_on != 0);
1145 net2272_write(dev, USBCTL0, tmp);
1146 spin_unlock_irqrestore(&dev->lock, flags);
1171 struct net2272 *dev;
1179 dev = dev_get_drvdata(_dev);
1182 spin_lock_irqsave(&dev->lock, flags);
1189 driver_name, driver_vers, dev->chiprev,
1190 net2272_read(dev, LOCCTL),
1191 net2272_read(dev, IRQENB0),
1192 net2272_read(dev, IRQENB1),
1193 net2272_read(dev, IRQSTAT0),
1194 net2272_read(dev, IRQSTAT1));
1199 t1 = net2272_read(dev, DMAREQ);
1210 t1 = net2272_read(dev, USBCTL1);
1214 else if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1222 net2272_read(dev, USBCTL0), t1,
1223 net2272_read(dev, OURADDR), s);
1231 ep = &dev->ep[i];
1284 spin_unlock_irqrestore(&dev->lock, flags);
1293 net2272_set_fifo_mode(struct net2272 *dev, int mode)
1297 tmp = net2272_read(dev, LOCCTL) & 0x3f;
1299 net2272_write(dev, LOCCTL, tmp);
1301 INIT_LIST_HEAD(&dev->gadget.ep_list);
1304 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list);
1308 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1309 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 512;
1312 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1313 dev->ep[1].fifo_size = 1024;
1314 dev->ep[2].fifo_size = 512;
1317 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1318 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024;
1321 dev->ep[1].fifo_size = 1024;
1326 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1327 dev->ep[3].fifo_size = 512;
1333 net2272_usb_reset(struct net2272 *dev)
1335 dev->gadget.speed = USB_SPEED_UNKNOWN;
1337 net2272_cancel_dma(dev);
1339 net2272_write(dev, IRQENB0, 0);
1340 net2272_write(dev, IRQENB1, 0);
1343 net2272_write(dev, IRQSTAT0, 0xff);
1344 net2272_write(dev, IRQSTAT1, ~(1 << SUSPEND_REQUEST_INTERRUPT));
1346 net2272_write(dev, DMAREQ,
1350 (dev->dma_eot_polarity << EOT_POLARITY) |
1351 (dev->dma_dack_polarity << DACK_POLARITY) |
1352 (dev->dma_dreq_polarity << DREQ_POLARITY) |
1355 net2272_cancel_dma(dev);
1356 net2272_set_fifo_mode(dev, (fifo_mode <= 3) ? fifo_mode : 0);
1362 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) | (1 << DATA_WIDTH));
1363 net2272_write(dev, LOCCTL1, (dma_mode << DMA_MODE));
1367 net2272_usb_reinit(struct net2272 *dev)
1373 struct net2272_ep *ep = &dev->ep[i];
1376 ep->dev = dev;
1400 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64);
1402 dev->gadget.ep0 = &dev->ep[0].ep;
1403 dev->ep[0].stopped = 0;
1404 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
1408 net2272_ep0_start(struct net2272 *dev)
1410 struct net2272_ep *ep0 = &dev->ep[0];
1418 net2272_write(dev, USBCTL0,
1419 (dev->softconnect << USB_DETECT_ENABLE) |
1422 net2272_write(dev, IRQENB0,
1426 net2272_write(dev, IRQENB1,
1441 struct net2272 *dev;
1448 dev = container_of(_gadget, struct net2272, gadget);
1451 dev->ep[i].irqs = 0;
1453 dev->softconnect = 1;
1454 dev->driver = driver;
1459 net2272_ep0_start(dev);
1465 stop_activity(struct net2272 *dev, struct usb_gadget_driver *driver)
1470 if (dev->gadget.speed == USB_SPEED_UNKNOWN)
1476 net2272_usb_reset(dev);
1478 net2272_dequeue_all(&dev->ep[i]);
1481 if (dev->async_callbacks && driver) {
1482 spin_unlock(&dev->lock);
1483 driver->disconnect(&dev->gadget);
1484 spin_lock(&dev->lock);
1487 net2272_usb_reinit(dev);
1492 struct net2272 *dev;
1495 dev = container_of(_gadget, struct net2272, gadget);
1497 spin_lock_irqsave(&dev->lock, flags);
1498 stop_activity(dev, NULL);
1499 spin_unlock_irqrestore(&dev->lock, flags);
1501 dev->driver = NULL;
1508 struct net2272 *dev = container_of(_gadget, struct net2272, gadget);
1510 spin_lock_irq(&dev->lock);
1511 dev->async_callbacks = enable;
1512 spin_unlock_irq(&dev->lock);
1530 dev_vdbg(ep->dev->dev, "handle_dma %s req %p\n", ep->ep.name, req);
1533 net2272_write(ep->dev, DMAREQ,
1537 | (ep->dev->dma_eot_polarity << EOT_POLARITY)
1538 | (ep->dev->dma_dack_polarity << DACK_POLARITY)
1539 | (ep->dev->dma_dreq_polarity << DREQ_POLARITY)
1542 ep->dev->dma_busy = 0;
1568 if (net2272_read(ep->dev, IRQSTAT0) &
1571 net2272_cancel_dma(ep->dev);
1612 dev_vdbg(ep->dev->dev, "%s ack ep_stat0 %02x, ep_stat1 %02x, req %p\n",
1632 net2272_get_ep_by_addr(struct net2272 *dev, u16 wIndex)
1637 return &dev->ep[0];
1639 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1672 net2272_set_test_mode(struct net2272 *dev, int mode)
1679 net2272_write(dev, IRQENB0, 0x00);
1680 net2272_write(dev, IRQENB1, 0x00);
1683 net2272_write(dev, XCVRDIAG, 1 << FORCE_HIGH_SPEED);
1685 net2272_write(dev, PAGESEL, 0);
1686 net2272_write(dev, EP_STAT0, 1 << DATA_PACKET_TRANSMITTED_INTERRUPT);
1687 net2272_write(dev, EP_RSPCLR,
1690 net2272_write(dev, EP_CFG, 1 << ENDPOINT_DIRECTION);
1691 net2272_write(dev, EP_STAT1, 1 << BUFFER_FLUSH);
1694 while (!(net2272_read(dev, EP_STAT0) &
1699 net2272_write(dev, USBTEST, mode);
1704 net2272_write(dev, LOCCTL, net2272_read(dev, LOCCTL) &
1708 net2272_write(dev, EP_DATA, net2272_test_packet[i]);
1711 net2272_write(dev, EP_TRANSFER0, 0);
1716 net2272_handle_stat0_irqs(struct net2272 *dev, u8 stat)
1730 if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
1731 if (net2272_read(dev, USBCTL1) & (1 << USB_HIGH_SPEED))
1732 dev->gadget.speed = USB_SPEED_HIGH;
1734 dev->gadget.speed = USB_SPEED_FULL;
1735 dev_dbg(dev->dev, "%s\n",
1736 usb_speed_string(dev->gadget.speed));
1739 ep = &dev->ep[0];
1751 dev->protocol_stall = 0;
1776 net2272_write(dev, PAGESEL, 0);
1777 net2272_write(dev, EP_TRANSFER2, 0xff);
1778 net2272_write(dev, EP_TRANSFER1, 0xff);
1779 net2272_write(dev, EP_TRANSFER0, 0xff);
1781 u.raw[0] = net2272_read(dev, SETUP0);
1782 u.raw[1] = net2272_read(dev, SETUP1);
1783 u.raw[2] = net2272_read(dev, SETUP2);
1784 u.raw[3] = net2272_read(dev, SETUP3);
1785 u.raw[4] = net2272_read(dev, SETUP4);
1786 u.raw[5] = net2272_read(dev, SETUP5);
1787 u.raw[6] = net2272_read(dev, SETUP6);
1788 u.raw[7] = net2272_read(dev, SETUP7);
1798 net2272_write(dev, IRQSTAT0, 1 << SETUP_PACKET_INTERRUPT);
1825 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1834 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1835 writew(status, net2272_reg_addr(dev, EP_DATA));
1836 set_fifo_bytecount(&dev->ep[0], 0);
1838 dev_vdbg(dev->dev, "%s stat %02x\n",
1844 if (dev->gadget.is_selfpowered)
1848 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1849 writew(status, net2272_reg_addr(dev, EP_DATA));
1850 set_fifo_bytecount(&dev->ep[0], 0);
1852 dev_vdbg(dev->dev, "device stat %02x\n", status);
1859 net2272_ep_write(&dev->ep[0], EP_IRQENB, 0);
1860 writew(status, net2272_reg_addr(dev, EP_DATA));
1861 set_fifo_bytecount(&dev->ep[0], 0);
1863 dev_vdbg(dev->dev, "interface status %02x\n", status);
1877 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1881 dev_vdbg(dev->dev, "%s wedged, halt not cleared\n",
1884 dev_vdbg(dev->dev, "%s clear halt\n", ep->ep.name);
1895 net2272_set_test_mode(dev, (u.r.wIndex >> 8));
1897 dev_vdbg(dev->dev, "test mode: %d\n", u.r.wIndex);
1904 e = net2272_get_ep_by_addr(dev, u.r.wIndex);
1909 dev_vdbg(dev->dev, "%s set halt\n", ep->ep.name);
1913 net2272_write(dev, OURADDR, u.r.wValue & 0xff);
1919 dev_vdbg(dev->dev, "setup %02x.%02x v%04x i%04x "
1924 if (dev->async_callbacks) {
1925 spin_unlock(&dev->lock);
1926 tmp = dev->driver->setup(&dev->gadget, &u.r);
1927 spin_lock(&dev->lock);
1934 dev_vdbg(dev->dev, "req %02x.%02x protocol STALL; stat %d\n",
1936 dev->protocol_stall = 1;
1940 net2272_cancel_dma(dev);
1941 net2272_write(dev, IRQSTAT0, 1 << DMA_DONE_INTERRUPT);
1943 num = (net2272_read(dev, DMAREQ) & (1 << DMA_ENDPOINT_SELECT))
1946 ep = &dev->ep[num];
1963 ep = &dev->ep[num];
1971 dev_dbg(dev->dev, "unhandled irqstat0 %02x\n", stat);
1975 net2272_handle_stat1_irqs(struct net2272 *dev, u8 stat)
1991 net2272_write(dev, IRQSTAT1, tmp);
1992 if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
1994 (net2272_read(dev, USBCTL1) &
1997 dev_dbg(dev->dev, "disconnect %s\n",
1998 dev->driver->driver.name);
2000 (net2272_read(dev, USBCTL1) & mask)
2003 dev_dbg(dev->dev, "reset %s\n",
2004 dev->driver->driver.name);
2008 stop_activity(dev, dev->driver);
2009 net2272_ep0_start(dev);
2010 if (dev->async_callbacks) {
2011 spin_unlock(&dev->lock);
2013 usb_gadget_udc_reset(&dev->gadget, dev->driver);
2015 (dev->driver->disconnect)(&dev->gadget);
2016 spin_lock(&dev->lock);
2029 net2272_write(dev, IRQSTAT1, tmp);
2031 if (dev->async_callbacks && dev->driver->suspend)
2032 dev->driver->suspend(&dev->gadget);
2035 dev_dbg(dev->dev, "Suspend disabled, ignoring\n");
2038 if (dev->async_callbacks && dev->driver->resume)
2039 dev->driver->resume(&dev->gadget);
2046 net2272_write(dev, IRQSTAT1, stat);
2055 dev_dbg(dev->dev, "unhandled irqstat1 %02x\n", stat);
2060 struct net2272 *dev = _dev;
2067 spin_lock(&dev->lock);
2069 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2073 dev->rdk1.plx9054_base_addr + INTCSR);
2074 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2075 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2076 intcsr = readl(dev->rdk1.plx9054_base_addr + INTCSR);
2078 dev->rdk1.plx9054_base_addr + INTCSR);
2082 dev->rdk1.plx9054_base_addr + DMACSR0);
2084 dmareq = net2272_read(dev, DMAREQ);
2086 net2272_handle_dma(&dev->ep[2]);
2088 net2272_handle_dma(&dev->ep[1]);
2093 intcsr = readl(dev->rdk2.fpga_base_addr + RDK2_IRQSTAT);
2095 spin_unlock(&dev->lock);
2102 net2272_handle_stat1_irqs(dev, net2272_read(dev, IRQSTAT1));
2103 net2272_handle_stat0_irqs(dev, net2272_read(dev, IRQSTAT0));
2105 spin_unlock(&dev->lock);
2110 static int net2272_present(struct net2272 *dev)
2125 refval = net2272_read(dev, SCRATCH);
2127 net2272_write(dev, SCRATCH, ii);
2128 val = net2272_read(dev, SCRATCH);
2130 dev_dbg(dev->dev,
2138 net2272_write(dev, SCRATCH, refval);
2141 refval = net2272_read(dev, CHIPREV_2272);
2143 net2272_write(dev, CHIPREV_2272, ii);
2144 val = net2272_read(dev, CHIPREV_2272);
2146 dev_dbg(dev->dev,
2161 val = net2272_read(dev, CHIPREV_LEGACY);
2167 dev_dbg(dev->dev,
2179 val = net2272_read(dev, CHIPREV_2272);
2186 dev_dbg(dev->dev,
2194 dev_dbg(dev->dev,
2212 struct net2272 *dev = container_of(_dev, struct net2272, gadget.dev);
2214 kfree(dev);
2220 net2272_remove(struct net2272 *dev)
2222 if (dev->added)
2223 usb_del_gadget(&dev->gadget);
2224 free_irq(dev->irq, dev);
2225 iounmap(dev->base_addr);
2226 device_remove_file(dev->dev, &dev_attr_registers);
2228 dev_info(dev->dev, "unbind\n");
2231 static struct net2272 *net2272_probe_init(struct device *dev, unsigned int irq)
2236 dev_dbg(dev, "No IRQ!\n");
2247 ret->dev = dev;
2253 usb_initialize_gadget(dev, &ret->gadget, net2272_gadget_release);
2259 net2272_probe_fin(struct net2272 *dev, unsigned int irqflags)
2264 if (net2272_present(dev)) {
2265 dev_warn(dev->dev, "2272 not found!\n");
2270 net2272_usb_reset(dev);
2271 net2272_usb_reinit(dev);
2273 ret = request_irq(dev->irq, net2272_irq, irqflags, driver_name, dev);
2275 dev_err(dev->dev, "request interrupt %i failed\n", dev->irq);
2279 dev->chiprev = net2272_read(dev, CHIPREV_2272);
2282 dev_info(dev->dev, "%s\n", driver_desc);
2283 dev_info(dev->dev, "irq %i, mem %p, chip rev %04x, dma %s\n",
2284 dev->irq, dev->base_addr, dev->chiprev,
2286 dev_info(dev->dev, "version: %s\n", driver_vers);
2288 ret = device_create_file(dev->dev, &dev_attr_registers);
2292 ret = usb_add_gadget(&dev->gadget);
2295 dev->added = 1;
2300 device_remove_file(dev->dev, &dev_attr_registers);
2302 free_irq(dev->irq, dev);
2315 net2272_rdk1_probe(struct pci_dev *pdev, struct net2272 *dev)
2337 dev_dbg(dev->dev, "controller already in use\n");
2345 dev_dbg(dev->dev, "can't map memory\n");
2351 dev->rdk1.plx9054_base_addr = mem_mapped_addr[0];
2352 dev->rdk1.epld_base_addr = mem_mapped_addr[2];
2353 dev->base_addr = mem_mapped_addr[3];
2356 tmp = readl(dev->rdk1.plx9054_base_addr + LBRD1);
2358 dev->rdk1.plx9054_base_addr + LBRD1);
2361 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) |
2364 dev->rdk1.plx9054_base_addr + INTCSR);
2367 dev->rdk1.plx9054_base_addr + DMACSR0);
2377 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2380 writeb(readb(dev->base_addr + EPLD_IO_CONTROL_REGISTER) &
2382 dev->base_addr + EPLD_IO_CONTROL_REGISTER);
2400 net2272_rdk2_probe(struct pci_dev *pdev, struct net2272 *dev)
2417 dev_dbg(dev->dev, "controller already in use\n");
2425 dev_dbg(dev->dev, "can't map memory\n");
2431 dev->rdk2.fpga_base_addr = mem_mapped_addr[0];
2432 dev->base_addr = mem_mapped_addr[1];
2436 writel((1 << CHIP_RESET), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2438 writel((1 << BUS_WIDTH), dev->rdk2.fpga_base_addr + RDK2_LOCCTLRDK);
2440 dev_info(dev->dev, "RDK2 FPGA version %08x\n",
2441 readl(dev->rdk2.fpga_base_addr + RDK2_FPGAREV));
2443 writel((1 << NET2272_PCI_IRQ), dev->rdk2.fpga_base_addr + RDK2_IRQENB);
2460 struct net2272 *dev;
2463 dev = net2272_probe_init(&pdev->dev, pdev->irq);
2464 if (IS_ERR(dev))
2465 return PTR_ERR(dev);
2466 dev->dev_id = pdev->device;
2476 case PCI_DEVICE_ID_RDK1: ret = net2272_rdk1_probe(pdev, dev); break;
2477 case PCI_DEVICE_ID_RDK2: ret = net2272_rdk2_probe(pdev, dev); break;
2483 ret = net2272_probe_fin(dev, 0);
2487 pci_set_drvdata(pdev, dev);
2494 usb_put_gadget(&dev->gadget);
2500 net2272_rdk1_remove(struct pci_dev *pdev, struct net2272 *dev)
2505 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2507 dev->rdk1.plx9054_base_addr + INTCSR);
2510 iounmap(dev->rdk1.plx9054_base_addr);
2511 iounmap(dev->rdk1.epld_base_addr);
2522 net2272_rdk2_remove(struct pci_dev *pdev, struct net2272 *dev)
2527 writel(readl(dev->rdk1.plx9054_base_addr + INTCSR) &
2529 dev->rdk1.plx9054_base_addr + INTCSR);
2533 iounmap(dev->rdk2.fpga_base_addr);
2543 struct net2272 *dev = pci_get_drvdata(pdev);
2545 net2272_remove(dev);
2548 case PCI_DEVICE_ID_RDK1: net2272_rdk1_remove(pdev, dev); break;
2549 case PCI_DEVICE_ID_RDK2: net2272_rdk2_remove(pdev, dev); break;
2555 usb_put_gadget(&dev->gadget);
2608 struct net2272 *dev;
2618 dev_err(&pdev->dev, "must provide irq/base addr");
2622 dev = net2272_probe_init(&pdev->dev, irq_res->start);
2623 if (IS_ERR(dev))
2624 return PTR_ERR(dev);
2639 dev->base_shift = iomem_bus->start;
2642 dev_dbg(dev->dev, "get request memory region!\n");
2646 dev->base_addr = ioremap(base, len);
2647 if (!dev->base_addr) {
2648 dev_dbg(dev->dev, "can't map memory\n");
2653 ret = net2272_probe_fin(dev, irqflags);
2657 platform_set_drvdata(pdev, dev);
2658 dev_info(&pdev->dev, "running in 16-bit, %sbyte swap local bus mode\n",
2659 (net2272_read(dev, LOCCTL) & (1 << BYTE_SWAP)) ? "" : "no ");
2664 iounmap(dev->base_addr);
2668 usb_put_gadget(&dev->gadget);
2676 struct net2272 *dev = platform_get_drvdata(pdev);
2678 net2272_remove(dev);
2683 usb_put_gadget(&dev->gadget);