tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

USB: at91 udc, support at91sam926x addresses

This is an update to the AT91 USB Device (Gadget) driver.

The base I/O address provided in the platform_device resources is now
ioremap()'ed instead of using a statically mapped memory area. This
helps portability to the newer AT91sam926x processors.

The major change is that we now have to pass a 'struct at91_udc'
parameter to at91_udp_read() and at91_udp_write().

Signed-off-by: Andrew Victor <andrew@sanpeople.com>
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

authored by

Andrew Victor and committed by
Greg Kroah-Hartman ffd3326b 5151d040

+84 -86
+83 -86
drivers/usb/gadget/at91_udc.c
··· 43 43 #include <linux/usb_gadget.h> 44 44 45 45 #include <asm/byteorder.h> 46 + #include <asm/hardware.h> 46 47 #include <asm/io.h> 47 48 #include <asm/irq.h> 48 49 #include <asm/system.h> 49 50 #include <asm/mach-types.h> 50 51 51 - #include <asm/arch/hardware.h> 52 52 #include <asm/arch/gpio.h> 53 53 #include <asm/arch/board.h> 54 54 ··· 78 78 static const char driver_name [] = "at91_udc"; 79 79 static const char ep0name[] = "ep0"; 80 80 81 - /*-------------------------------------------------------------------------*/ 82 81 83 - /* 84 - * Read from a UDP register. 85 - */ 86 - static inline unsigned long at91_udp_read(unsigned int reg) 87 - { 88 - void __iomem *udp_base = (void __iomem *)AT91_VA_BASE_UDP; 89 - 90 - return __raw_readl(udp_base + reg); 91 - } 92 - 93 - /* 94 - * Write to a UDP register. 95 - */ 96 - static inline void at91_udp_write(unsigned int reg, unsigned long value) 97 - { 98 - void __iomem *udp_base = (void __iomem *)AT91_VA_BASE_UDP; 99 - 100 - __raw_writel(value, udp_base + reg); 101 - } 82 + #define at91_udp_read(dev, reg) \ 83 + __raw_readl((dev)->udp_baseaddr + (reg)) 84 + #define at91_udp_write(dev, reg, val) \ 85 + __raw_writel((val), (dev)->udp_baseaddr + (reg)) 102 86 103 87 /*-------------------------------------------------------------------------*/ 104 88 ··· 194 210 return 0; 195 211 } 196 212 197 - tmp = at91_udp_read(AT91_UDP_FRM_NUM); 213 + tmp = at91_udp_read(udc, AT91_UDP_FRM_NUM); 198 214 seq_printf(s, "frame %05x:%s%s frame=%d\n", tmp, 199 215 (tmp & AT91_UDP_FRM_OK) ? " ok" : "", 200 216 (tmp & AT91_UDP_FRM_ERR) ? " err" : "", 201 217 (tmp & AT91_UDP_NUM)); 202 218 203 - tmp = at91_udp_read(AT91_UDP_GLB_STAT); 219 + tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); 204 220 seq_printf(s, "glbstate %02x:%s" FOURBITS "\n", tmp, 205 221 (tmp & AT91_UDP_RMWUPE) ? " rmwupe" : "", 206 222 (tmp & AT91_UDP_RSMINPR) ? " rsminpr" : "", ··· 208 224 (tmp & AT91_UDP_CONFG) ? " confg" : "", 209 225 (tmp & AT91_UDP_FADDEN) ? " fadden" : ""); 210 226 211 - tmp = at91_udp_read(AT91_UDP_FADDR); 227 + tmp = at91_udp_read(udc, AT91_UDP_FADDR); 212 228 seq_printf(s, "faddr %03x:%s fadd=%d\n", tmp, 213 229 (tmp & AT91_UDP_FEN) ? " fen" : "", 214 230 (tmp & AT91_UDP_FADD)); 215 231 216 - proc_irq_show(s, "imr ", at91_udp_read(AT91_UDP_IMR)); 217 - proc_irq_show(s, "isr ", at91_udp_read(AT91_UDP_ISR)); 232 + proc_irq_show(s, "imr ", at91_udp_read(udc, AT91_UDP_IMR)); 233 + proc_irq_show(s, "isr ", at91_udp_read(udc, AT91_UDP_ISR)); 218 234 219 235 if (udc->enabled && udc->vbus) { 220 236 proc_ep_show(s, &udc->ep[0]); ··· 270 286 static void done(struct at91_ep *ep, struct at91_request *req, int status) 271 287 { 272 288 unsigned stopped = ep->stopped; 289 + struct at91_udc *udc = ep->udc; 273 290 274 291 list_del_init(&req->queue); 275 292 if (req->req.status == -EINPROGRESS) ··· 286 301 287 302 /* ep0 is always ready; other endpoints need a non-empty queue */ 288 303 if (list_empty(&ep->queue) && ep->int_mask != (1 << 0)) 289 - at91_udp_write(AT91_UDP_IDR, ep->int_mask); 304 + at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask); 290 305 } 291 306 292 307 /*-------------------------------------------------------------------------*/ ··· 539 554 * reset/init endpoint fifo. NOTE: leaves fifo_bank alone, 540 555 * since endpoint resets don't reset hw pingpong state. 541 556 */ 542 - at91_udp_write(AT91_UDP_RST_EP, ep->int_mask); 543 - at91_udp_write(AT91_UDP_RST_EP, 0); 557 + at91_udp_write(dev, AT91_UDP_RST_EP, ep->int_mask); 558 + at91_udp_write(dev, AT91_UDP_RST_EP, 0); 544 559 545 560 local_irq_restore(flags); 546 561 return 0; ··· 549 564 static int at91_ep_disable (struct usb_ep * _ep) 550 565 { 551 566 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep); 567 + struct at91_udc *udc = ep->udc; 552 568 unsigned long flags; 553 569 554 570 if (ep == &ep->udc->ep[0]) ··· 565 579 566 580 /* reset fifos and endpoint */ 567 581 if (ep->udc->clocked) { 568 - at91_udp_write(AT91_UDP_RST_EP, ep->int_mask); 569 - at91_udp_write(AT91_UDP_RST_EP, 0); 582 + at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); 583 + at91_udp_write(udc, AT91_UDP_RST_EP, 0); 570 584 __raw_writel(0, ep->creg); 571 585 } 572 586 ··· 681 695 * reconfigures the endpoints. 682 696 */ 683 697 if (dev->wait_for_config_ack) { 684 - tmp = at91_udp_read(AT91_UDP_GLB_STAT); 698 + tmp = at91_udp_read(dev, AT91_UDP_GLB_STAT); 685 699 tmp ^= AT91_UDP_CONFG; 686 700 VDBG("toggle config\n"); 687 - at91_udp_write(AT91_UDP_GLB_STAT, tmp); 701 + at91_udp_write(dev, AT91_UDP_GLB_STAT, tmp); 688 702 } 689 703 if (req->req.length == 0) { 690 704 ep0_in_status: ··· 713 727 714 728 if (req && !status) { 715 729 list_add_tail (&req->queue, &ep->queue); 716 - at91_udp_write(AT91_UDP_IER, ep->int_mask); 730 + at91_udp_write(dev, AT91_UDP_IER, ep->int_mask); 717 731 } 718 732 done: 719 733 local_irq_restore(flags); ··· 744 758 static int at91_ep_set_halt(struct usb_ep *_ep, int value) 745 759 { 746 760 struct at91_ep *ep = container_of(_ep, struct at91_ep, ep); 761 + struct at91_udc *udc = ep->udc; 747 762 u32 __iomem *creg; 748 763 u32 csr; 749 764 unsigned long flags; ··· 772 785 csr |= AT91_UDP_FORCESTALL; 773 786 VDBG("halt %s\n", ep->ep.name); 774 787 } else { 775 - at91_udp_write(AT91_UDP_RST_EP, ep->int_mask); 776 - at91_udp_write(AT91_UDP_RST_EP, 0); 788 + at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); 789 + at91_udp_write(udc, AT91_UDP_RST_EP, 0); 777 790 csr &= ~AT91_UDP_FORCESTALL; 778 791 } 779 792 __raw_writel(csr, creg); ··· 800 813 801 814 static int at91_get_frame(struct usb_gadget *gadget) 802 815 { 816 + struct at91_udc *udc = to_udc(gadget); 817 + 803 818 if (!to_udc(gadget)->clocked) 804 819 return -EINVAL; 805 - return at91_udp_read(AT91_UDP_FRM_NUM) & AT91_UDP_NUM; 820 + return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM; 806 821 } 807 822 808 823 static int at91_wakeup(struct usb_gadget *gadget) ··· 822 833 823 834 /* NOTE: some "early versions" handle ESR differently ... */ 824 835 825 - glbstate = at91_udp_read(AT91_UDP_GLB_STAT); 836 + glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT); 826 837 if (!(glbstate & AT91_UDP_ESR)) 827 838 goto done; 828 839 glbstate |= AT91_UDP_ESR; 829 - at91_udp_write(AT91_UDP_GLB_STAT, glbstate); 840 + at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate); 830 841 831 842 done: 832 843 local_irq_restore(flags); ··· 850 861 ep->stopped = 0; 851 862 ep->fifo_bank = 0; 852 863 ep->ep.maxpacket = ep->maxpacket; 864 + ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i); 853 865 // initialiser une queue par endpoint 854 866 INIT_LIST_HEAD(&ep->queue); 855 867 } ··· 905 915 if (!udc->enabled || !udc->vbus) 906 916 is_on = 0; 907 917 DBG("%sactive\n", is_on ? "" : "in"); 918 + 908 919 if (is_on) { 909 920 clk_on(udc); 910 - at91_udp_write(AT91_UDP_TXVC, 0); 921 + at91_udp_write(udc, AT91_UDP_TXVC, 0); 911 922 at91_set_gpio_value(udc->board.pullup_pin, 1); 912 - } else { 923 + } else { 913 924 stop_activity(udc); 914 - at91_udp_write(AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); 925 + at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); 915 926 at91_set_gpio_value(udc->board.pullup_pin, 0); 916 927 clk_off(udc); 917 928 } ··· 1077 1086 1078 1087 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) 1079 1088 | USB_REQ_SET_CONFIGURATION: 1080 - tmp = at91_udp_read(AT91_UDP_GLB_STAT) & AT91_UDP_CONFG; 1089 + tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG; 1081 1090 if (pkt.r.wValue) 1082 1091 udc->wait_for_config_ack = (tmp == 0); 1083 1092 else ··· 1094 1103 case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) 1095 1104 | USB_REQ_GET_STATUS: 1096 1105 tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED); 1097 - if (at91_udp_read(AT91_UDP_GLB_STAT) & AT91_UDP_ESR) 1106 + if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR) 1098 1107 tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP); 1099 1108 PACKET("get device status\n"); 1100 1109 __raw_writeb(tmp, dreg); ··· 1105 1114 | USB_REQ_SET_FEATURE: 1106 1115 if (w_value != USB_DEVICE_REMOTE_WAKEUP) 1107 1116 goto stall; 1108 - tmp = at91_udp_read(AT91_UDP_GLB_STAT); 1117 + tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); 1109 1118 tmp |= AT91_UDP_ESR; 1110 - at91_udp_write(AT91_UDP_GLB_STAT, tmp); 1119 + at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); 1111 1120 goto succeed; 1112 1121 case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8) 1113 1122 | USB_REQ_CLEAR_FEATURE: 1114 1123 if (w_value != USB_DEVICE_REMOTE_WAKEUP) 1115 1124 goto stall; 1116 - tmp = at91_udp_read(AT91_UDP_GLB_STAT); 1125 + tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); 1117 1126 tmp &= ~AT91_UDP_ESR; 1118 - at91_udp_write(AT91_UDP_GLB_STAT, tmp); 1127 + at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); 1119 1128 goto succeed; 1120 1129 1121 1130 /* ··· 1197 1206 } else if (ep->is_in) 1198 1207 goto stall; 1199 1208 1200 - at91_udp_write(AT91_UDP_RST_EP, ep->int_mask); 1201 - at91_udp_write(AT91_UDP_RST_EP, 0); 1209 + at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask); 1210 + at91_udp_write(udc, AT91_UDP_RST_EP, 0); 1202 1211 tmp = __raw_readl(ep->creg); 1203 1212 tmp |= CLR_FX; 1204 1213 tmp &= ~(SET_FX | AT91_UDP_FORCESTALL); ··· 1291 1300 if (udc->wait_for_addr_ack) { 1292 1301 u32 tmp; 1293 1302 1294 - at91_udp_write(AT91_UDP_FADDR, 1303 + at91_udp_write(udc, AT91_UDP_FADDR, 1295 1304 AT91_UDP_FEN | udc->addr); 1296 - tmp = at91_udp_read(AT91_UDP_GLB_STAT); 1305 + tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT); 1297 1306 tmp &= ~AT91_UDP_FADDEN; 1298 1307 if (udc->addr) 1299 1308 tmp |= AT91_UDP_FADDEN; 1300 - at91_udp_write(AT91_UDP_GLB_STAT, tmp); 1309 + at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp); 1301 1310 1302 1311 udc->wait_for_addr_ack = 0; 1303 1312 VDBG("address %d\n", udc->addr); ··· 1365 1374 while (rescans--) { 1366 1375 u32 status; 1367 1376 1368 - status = at91_udp_read(AT91_UDP_ISR) 1369 - & at91_udp_read(AT91_UDP_IMR); 1377 + status = at91_udp_read(udc, AT91_UDP_ISR) 1378 + & at91_udp_read(udc, AT91_UDP_IMR); 1370 1379 if (!status) 1371 1380 break; 1372 1381 1373 1382 /* USB reset irq: not maskable */ 1374 1383 if (status & AT91_UDP_ENDBUSRES) { 1375 - at91_udp_write(AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS); 1376 - at91_udp_write(AT91_UDP_IER, MINIMUS_INTERRUPTUS); 1384 + at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS); 1385 + at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS); 1377 1386 /* Atmel code clears this irq twice */ 1378 - at91_udp_write(AT91_UDP_ICR, AT91_UDP_ENDBUSRES); 1379 - at91_udp_write(AT91_UDP_ICR, AT91_UDP_ENDBUSRES); 1387 + at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES); 1388 + at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES); 1380 1389 VDBG("end bus reset\n"); 1381 1390 udc->addr = 0; 1382 1391 stop_activity(udc); 1383 1392 1384 1393 /* enable ep0 */ 1385 - at91_udp_write(AT91_UDP_CSR(0), 1394 + at91_udp_write(udc, AT91_UDP_CSR(0), 1386 1395 AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL); 1387 1396 udc->gadget.speed = USB_SPEED_FULL; 1388 1397 udc->suspended = 0; 1389 - at91_udp_write(AT91_UDP_IER, AT91_UDP_EP(0)); 1398 + at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0)); 1390 1399 1391 1400 /* 1392 1401 * NOTE: this driver keeps clocks off unless the ··· 1397 1406 1398 1407 /* host initiated suspend (3+ms bus idle) */ 1399 1408 } else if (status & AT91_UDP_RXSUSP) { 1400 - at91_udp_write(AT91_UDP_IDR, AT91_UDP_RXSUSP); 1401 - at91_udp_write(AT91_UDP_IER, AT91_UDP_RXRSM); 1402 - at91_udp_write(AT91_UDP_ICR, AT91_UDP_RXSUSP); 1409 + at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP); 1410 + at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM); 1411 + at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP); 1403 1412 // VDBG("bus suspend\n"); 1404 1413 if (udc->suspended) 1405 1414 continue; ··· 1416 1425 1417 1426 /* host initiated resume */ 1418 1427 } else if (status & AT91_UDP_RXRSM) { 1419 - at91_udp_write(AT91_UDP_IDR, AT91_UDP_RXRSM); 1420 - at91_udp_write(AT91_UDP_IER, AT91_UDP_RXSUSP); 1421 - at91_udp_write(AT91_UDP_ICR, AT91_UDP_RXRSM); 1428 + at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM); 1429 + at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP); 1430 + at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM); 1422 1431 // VDBG("bus resume\n"); 1423 1432 if (!udc->suspended) 1424 1433 continue; ··· 1476 1485 }, 1477 1486 .udc = &controller, 1478 1487 .maxpacket = 8, 1479 - .creg = (void __iomem *)(AT91_VA_BASE_UDP 1480 - + AT91_UDP_CSR(0)), 1481 1488 .int_mask = 1 << 0, 1482 1489 }, 1483 1490 .ep[1] = { ··· 1486 1497 .udc = &controller, 1487 1498 .is_pingpong = 1, 1488 1499 .maxpacket = 64, 1489 - .creg = (void __iomem *)(AT91_VA_BASE_UDP 1490 - + AT91_UDP_CSR(1)), 1491 1500 .int_mask = 1 << 1, 1492 1501 }, 1493 1502 .ep[2] = { ··· 1496 1509 .udc = &controller, 1497 1510 .is_pingpong = 1, 1498 1511 .maxpacket = 64, 1499 - .creg = (void __iomem *)(AT91_VA_BASE_UDP 1500 - + AT91_UDP_CSR(2)), 1501 1512 .int_mask = 1 << 2, 1502 1513 }, 1503 1514 .ep[3] = { ··· 1506 1521 }, 1507 1522 .udc = &controller, 1508 1523 .maxpacket = 8, 1509 - .creg = (void __iomem *)(AT91_VA_BASE_UDP 1510 - + AT91_UDP_CSR(3)), 1511 1524 .int_mask = 1 << 3, 1512 1525 }, 1513 1526 .ep[4] = { ··· 1516 1533 .udc = &controller, 1517 1534 .is_pingpong = 1, 1518 1535 .maxpacket = 256, 1519 - .creg = (void __iomem *)(AT91_VA_BASE_UDP 1520 - + AT91_UDP_CSR(4)), 1521 1536 .int_mask = 1 << 4, 1522 1537 }, 1523 1538 .ep[5] = { ··· 1526 1545 .udc = &controller, 1527 1546 .is_pingpong = 1, 1528 1547 .maxpacket = 256, 1529 - .creg = (void __iomem *)(AT91_VA_BASE_UDP 1530 - + AT91_UDP_CSR(5)), 1531 1548 .int_mask = 1 << 5, 1532 1549 }, 1533 1550 /* ep6 and ep7 are also reserved (custom silicon might use them) */ ··· 1594 1615 1595 1616 local_irq_disable(); 1596 1617 udc->enabled = 0; 1597 - at91_udp_write(AT91_UDP_IDR, ~0); 1618 + at91_udp_write(udc, AT91_UDP_IDR, ~0); 1598 1619 pullup(udc, 0); 1599 1620 local_irq_enable(); 1600 1621 ··· 1619 1640 struct device *dev = &pdev->dev; 1620 1641 struct at91_udc *udc; 1621 1642 int retval; 1643 + struct resource *res; 1622 1644 1623 1645 if (!dev->platform_data) { 1624 1646 /* small (so we copy it) but critical! */ ··· 1637 1657 return -ENODEV; 1638 1658 } 1639 1659 1640 - if (!request_mem_region(AT91RM9200_BASE_UDP, SZ_16K, driver_name)) { 1660 + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1661 + if (!res) 1662 + return -ENXIO; 1663 + 1664 + if (!request_mem_region(res->start, 1665 + res->end - res->start + 1, 1666 + driver_name)) { 1641 1667 DBG("someone's using UDC memory\n"); 1642 1668 return -EBUSY; 1643 1669 } ··· 1653 1667 udc->gadget.dev.parent = dev; 1654 1668 udc->board = *(struct at91_udc_data *) dev->platform_data; 1655 1669 udc->pdev = pdev; 1656 - udc_reinit(udc); 1657 1670 udc->enabled = 0; 1671 + 1672 + udc->udp_baseaddr = ioremap(res->start, res->end - res->start + 1); 1673 + if (!udc->udp_baseaddr) { 1674 + release_mem_region(res->start, res->end - res->start + 1); 1675 + return -ENOMEM; 1676 + } 1677 + 1678 + udc_reinit(udc); 1658 1679 1659 1680 /* get interface and function clocks */ 1660 1681 udc->iclk = clk_get(dev, "udc_clk"); ··· 1677 1684 1678 1685 /* don't do anything until we have both gadget driver and VBUS */ 1679 1686 clk_enable(udc->iclk); 1680 - at91_udp_write(AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); 1681 - at91_udp_write(AT91_UDP_IDR, 0xffffffff); 1687 + at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS); 1688 + at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff); 1682 1689 clk_disable(udc->iclk); 1683 1690 1684 1691 /* request UDC and maybe VBUS irqs */ ··· 1712 1719 fail1: 1713 1720 device_unregister(&udc->gadget.dev); 1714 1721 fail0: 1715 - release_mem_region(AT91RM9200_BASE_UDP, SZ_16K); 1722 + release_mem_region(res->start, res->end - res->start + 1); 1716 1723 DBG("%s probe failed, %d\n", driver_name, retval); 1717 1724 return retval; 1718 1725 } ··· 1720 1727 static int __devexit at91udc_remove(struct platform_device *pdev) 1721 1728 { 1722 1729 struct at91_udc *udc = platform_get_drvdata(pdev); 1730 + struct resource *res; 1723 1731 1724 1732 DBG("remove\n"); 1725 1733 ··· 1735 1741 free_irq(udc->board.vbus_pin, udc); 1736 1742 free_irq(udc->udp_irq, udc); 1737 1743 device_unregister(&udc->gadget.dev); 1738 - release_mem_region(AT91RM9200_BASE_UDP, SZ_16K); 1744 + 1745 + iounmap(udc->udp_baseaddr); 1746 + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1747 + release_mem_region(res->start, res->end - res->start + 1); 1739 1748 1740 1749 clk_put(udc->iclk); 1741 1750 clk_put(udc->fclk);
+1
drivers/usb/gadget/at91_udc.h
··· 141 141 struct clk *iclk, *fclk; 142 142 struct platform_device *pdev; 143 143 struct proc_dir_entry *pde; 144 + void __iomem *udp_baseaddr; 144 145 int udp_irq; 145 146 }; 146 147