Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 
0003 /*
0004  * Linux device driver for USB based Prism54
0005  *
0006  * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
0007  *
0008  * Based on the islsm (softmac prism54) driver, which is:
0009  * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
0010  */
0011 
0012 #include <linux/usb.h>
0013 #include <linux/pci.h>
0014 #include <linux/slab.h>
0015 #include <linux/firmware.h>
0016 #include <linux/etherdevice.h>
0017 #include <linux/delay.h>
0018 #include <linux/crc32.h>
0019 #include <linux/module.h>
0020 #include <net/mac80211.h>
0021 
0022 #include "p54.h"
0023 #include "lmac.h"
0024 #include "p54usb.h"
0025 
0026 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
0027 MODULE_DESCRIPTION("Prism54 USB wireless driver");
0028 MODULE_LICENSE("GPL");
0029 MODULE_ALIAS("prism54usb");
0030 MODULE_FIRMWARE("isl3886usb");
0031 MODULE_FIRMWARE("isl3887usb");
0032 
0033 static struct usb_driver p54u_driver;
0034 
0035 /*
0036  * Note:
0037  *
0038  * Always update our wiki's device list (located at:
0039  * http://wireless.wiki.kernel.org/en/users/Drivers/p54/devices ),
0040  * whenever you add a new device.
0041  */
0042 
0043 static const struct usb_device_id p54u_table[] = {
0044     /* Version 1 devices (pci chip + net2280) */
0045     {USB_DEVICE(0x0411, 0x0050)},   /* Buffalo WLI2-USB2-G54 */
0046     {USB_DEVICE(0x045e, 0x00c2)},   /* Microsoft MN-710 */
0047     {USB_DEVICE(0x0506, 0x0a11)},   /* 3COM 3CRWE254G72 */
0048     {USB_DEVICE(0x0675, 0x0530)},   /* DrayTek Vigor 530 */
0049     {USB_DEVICE(0x06b9, 0x0120)},   /* Thomson SpeedTouch 120g */
0050     {USB_DEVICE(0x0707, 0xee06)},   /* SMC 2862W-G */
0051     {USB_DEVICE(0x07aa, 0x001c)},   /* Corega CG-WLUSB2GT */
0052     {USB_DEVICE(0x083a, 0x4501)},   /* Accton 802.11g WN4501 USB */
0053     {USB_DEVICE(0x083a, 0x4502)},   /* Siemens Gigaset USB Adapter */
0054     {USB_DEVICE(0x083a, 0x5501)},   /* Phillips CPWUA054 */
0055     {USB_DEVICE(0x0846, 0x4200)},   /* Netgear WG121 */
0056     {USB_DEVICE(0x0846, 0x4210)},   /* Netgear WG121 the second ? */
0057     {USB_DEVICE(0x0846, 0x4220)},   /* Netgear WG111 */
0058     {USB_DEVICE(0x09aa, 0x1000)},   /* Spinnaker Proto board */
0059     {USB_DEVICE(0x0bf8, 0x1007)},   /* Fujitsu E-5400 USB */
0060     {USB_DEVICE(0x0cde, 0x0006)},   /* Medion 40900, Roper Europe */
0061     {USB_DEVICE(0x0db0, 0x6826)},   /* MSI UB54G (MS-6826) */
0062     {USB_DEVICE(0x107b, 0x55f2)},   /* Gateway WGU-210 (Gemtek) */
0063     {USB_DEVICE(0x124a, 0x4023)},   /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
0064     {USB_DEVICE(0x124a, 0x4026)},   /* AirVasT USB wireless device */
0065     {USB_DEVICE(0x1435, 0x0210)},   /* Inventel UR054G */
0066     {USB_DEVICE(0x15a9, 0x0002)},   /* Gemtek WUBI-100GW 802.11g */
0067     {USB_DEVICE(0x1630, 0x0005)},   /* 2Wire 802.11g USB (v1) / Z-Com */
0068     {USB_DEVICE(0x182d, 0x096b)},   /* Sitecom WL-107 */
0069     {USB_DEVICE(0x1915, 0x2234)},   /* Linksys WUSB54G OEM */
0070     {USB_DEVICE(0x1915, 0x2235)},   /* Linksys WUSB54G Portable OEM */
0071     {USB_DEVICE(0x2001, 0x3701)},   /* DLink DWL-G120 Spinnaker */
0072     {USB_DEVICE(0x2001, 0x3703)},   /* DLink DWL-G122 */
0073     {USB_DEVICE(0x2001, 0x3762)},   /* Conceptronic C54U */
0074     {USB_DEVICE(0x5041, 0x2234)},   /* Linksys WUSB54G */
0075     {USB_DEVICE(0x5041, 0x2235)},   /* Linksys WUSB54G Portable */
0076 
0077     /* Version 2 devices (3887) */
0078     {USB_DEVICE(0x0471, 0x1230)},   /* Philips CPWUA054/00 */
0079     {USB_DEVICE(0x050d, 0x7050)},   /* Belkin F5D7050 ver 1000 */
0080     {USB_DEVICE(0x0572, 0x2000)},   /* Cohiba Proto board */
0081     {USB_DEVICE(0x0572, 0x2002)},   /* Cohiba Proto board */
0082     {USB_DEVICE(0x06a9, 0x000e)},   /* Westell 802.11g USB (A90-211WG-01) */
0083     {USB_DEVICE(0x06b9, 0x0121)},   /* Thomson SpeedTouch 121g */
0084     {USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
0085     {USB_DEVICE(0x07aa, 0x0020)},   /* Corega WLUSB2GTST USB */
0086     {USB_DEVICE(0x0803, 0x4310)},   /* Zoom 4410a */
0087     {USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
0088     {USB_DEVICE(0x083a, 0x4531)},   /* T-Com Sinus 154 data II */
0089     {USB_DEVICE(0x083a, 0xc501)},   /* Zoom Wireless-G 4410 */
0090     {USB_DEVICE(0x083a, 0xf503)},   /* Accton FD7050E ver 1010ec  */
0091     {USB_DEVICE(0x0846, 0x4240)},   /* Netgear WG111 (v2) */
0092     {USB_DEVICE(0x0915, 0x2000)},   /* Cohiba Proto board */
0093     {USB_DEVICE(0x0915, 0x2002)},   /* Cohiba Proto board */
0094     {USB_DEVICE(0x0baf, 0x0118)},   /* U.S. Robotics U5 802.11g Adapter*/
0095     {USB_DEVICE(0x0bf8, 0x1009)},   /* FUJITSU E-5400 USB D1700*/
0096     /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
0097                      * just noting it here for clarity */
0098     {USB_DEVICE(0x0cde, 0x0008)},   /* Sagem XG703A */
0099     {USB_DEVICE(0x0cde, 0x0015)},   /* Zcomax XG-705A */
0100     {USB_DEVICE(0x0d8e, 0x3762)},   /* DLink DWL-G120 Cohiba */
0101     {USB_DEVICE(0x124a, 0x4025)},   /* IOGear GWU513 (GW3887IK chip) */
0102     {USB_DEVICE(0x1260, 0xee22)},   /* SMC 2862W-G version 2 */
0103     {USB_DEVICE(0x13b1, 0x000a)},   /* Linksys WUSB54G ver 2 */
0104     {USB_DEVICE(0x13B1, 0x000C)},   /* Linksys WUSB54AG */
0105     {USB_DEVICE(0x1413, 0x5400)},   /* Telsey 802.11g USB2.0 Adapter */
0106     {USB_DEVICE(0x1435, 0x0427)},   /* Inventel UR054G */
0107     /* {USB_DEVICE(0x15a9, 0x0002)}, * Also SparkLAN WL-682 with 3887 */
0108     {USB_DEVICE(0x1668, 0x1050)},   /* Actiontec 802UIG-1 */
0109     {USB_DEVICE(0x1740, 0x1000)},   /* Senao NUB-350 */
0110     {USB_DEVICE(0x2001, 0x3704)},   /* DLink DWL-G122 rev A2 */
0111     {USB_DEVICE(0x2001, 0x3705)},   /* D-Link DWL-G120 rev C1 */
0112     {USB_DEVICE(0x413c, 0x5513)},   /* Dell WLA3310 USB Wireless Adapter */
0113     {USB_DEVICE(0x413c, 0x8102)},   /* Spinnaker DUT */
0114     {USB_DEVICE(0x413c, 0x8104)},   /* Cohiba Proto board */
0115     {}
0116 };
0117 
0118 MODULE_DEVICE_TABLE(usb, p54u_table);
0119 
0120 static const struct {
0121     u32 intf;
0122     enum p54u_hw_type type;
0123     const char *fw;
0124     char hw[20];
0125 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
0126     {
0127         .type = P54U_NET2280,
0128         .intf = FW_LM86,
0129         .fw = "isl3886usb",
0130         .hw = "ISL3886 + net2280",
0131     },
0132     {
0133         .type = P54U_3887,
0134         .intf = FW_LM87,
0135         .fw = "isl3887usb",
0136         .hw = "ISL3887",
0137     },
0138 };
0139 
0140 static void p54u_rx_cb(struct urb *urb)
0141 {
0142     struct sk_buff *skb = (struct sk_buff *) urb->context;
0143     struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
0144     struct ieee80211_hw *dev = info->dev;
0145     struct p54u_priv *priv = dev->priv;
0146 
0147     skb_unlink(skb, &priv->rx_queue);
0148 
0149     if (unlikely(urb->status)) {
0150         dev_kfree_skb_irq(skb);
0151         return;
0152     }
0153 
0154     skb_put(skb, urb->actual_length);
0155 
0156     if (priv->hw_type == P54U_NET2280)
0157         skb_pull(skb, priv->common.tx_hdr_len);
0158     if (priv->common.fw_interface == FW_LM87) {
0159         skb_pull(skb, 4);
0160         skb_put(skb, 4);
0161     }
0162 
0163     if (p54_rx(dev, skb)) {
0164         skb = dev_alloc_skb(priv->common.rx_mtu + 32);
0165         if (unlikely(!skb)) {
0166             /* TODO check rx queue length and refill *somewhere* */
0167             return;
0168         }
0169 
0170         info = (struct p54u_rx_info *) skb->cb;
0171         info->urb = urb;
0172         info->dev = dev;
0173         urb->transfer_buffer = skb_tail_pointer(skb);
0174         urb->context = skb;
0175     } else {
0176         if (priv->hw_type == P54U_NET2280)
0177             skb_push(skb, priv->common.tx_hdr_len);
0178         if (priv->common.fw_interface == FW_LM87) {
0179             skb_push(skb, 4);
0180             skb_put(skb, 4);
0181         }
0182         skb_reset_tail_pointer(skb);
0183         skb_trim(skb, 0);
0184         urb->transfer_buffer = skb_tail_pointer(skb);
0185     }
0186     skb_queue_tail(&priv->rx_queue, skb);
0187     usb_anchor_urb(urb, &priv->submitted);
0188     if (usb_submit_urb(urb, GFP_ATOMIC)) {
0189         skb_unlink(skb, &priv->rx_queue);
0190         usb_unanchor_urb(urb);
0191         dev_kfree_skb_irq(skb);
0192     }
0193 }
0194 
0195 static void p54u_tx_cb(struct urb *urb)
0196 {
0197     struct sk_buff *skb = urb->context;
0198     struct ieee80211_hw *dev =
0199         usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
0200 
0201     p54_free_skb(dev, skb);
0202 }
0203 
0204 static void p54u_tx_dummy_cb(struct urb *urb) { }
0205 
0206 static void p54u_free_urbs(struct ieee80211_hw *dev)
0207 {
0208     struct p54u_priv *priv = dev->priv;
0209     usb_kill_anchored_urbs(&priv->submitted);
0210 }
0211 
0212 static void p54u_stop(struct ieee80211_hw *dev)
0213 {
0214     /*
0215      * TODO: figure out how to reliably stop the 3887 and net2280 so
0216      * the hardware is still usable next time we want to start it.
0217      * until then, we just stop listening to the hardware..
0218      */
0219     p54u_free_urbs(dev);
0220 }
0221 
0222 static int p54u_init_urbs(struct ieee80211_hw *dev)
0223 {
0224     struct p54u_priv *priv = dev->priv;
0225     struct urb *entry = NULL;
0226     struct sk_buff *skb;
0227     struct p54u_rx_info *info;
0228     int ret = 0;
0229 
0230     while (skb_queue_len(&priv->rx_queue) < 32) {
0231         skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
0232         if (!skb) {
0233             ret = -ENOMEM;
0234             goto err;
0235         }
0236         entry = usb_alloc_urb(0, GFP_KERNEL);
0237         if (!entry) {
0238             ret = -ENOMEM;
0239             goto err;
0240         }
0241 
0242         usb_fill_bulk_urb(entry, priv->udev,
0243                   usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
0244                   skb_tail_pointer(skb),
0245                   priv->common.rx_mtu + 32, p54u_rx_cb, skb);
0246         info = (struct p54u_rx_info *) skb->cb;
0247         info->urb = entry;
0248         info->dev = dev;
0249         skb_queue_tail(&priv->rx_queue, skb);
0250 
0251         usb_anchor_urb(entry, &priv->submitted);
0252         ret = usb_submit_urb(entry, GFP_KERNEL);
0253         if (ret) {
0254             skb_unlink(skb, &priv->rx_queue);
0255             usb_unanchor_urb(entry);
0256             goto err;
0257         }
0258         usb_free_urb(entry);
0259         entry = NULL;
0260     }
0261 
0262     return 0;
0263 
0264  err:
0265     usb_free_urb(entry);
0266     kfree_skb(skb);
0267     p54u_free_urbs(dev);
0268     return ret;
0269 }
0270 
0271 static int p54u_open(struct ieee80211_hw *dev)
0272 {
0273     /*
0274      * TODO: Because we don't know how to reliably stop the 3887 and
0275      * the isl3886+net2280, other than brutally cut off all
0276      * communications. We have to reinitialize the urbs on every start.
0277      */
0278     return p54u_init_urbs(dev);
0279 }
0280 
0281 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
0282 {
0283     u32 chk = 0;
0284 
0285     length >>= 2;
0286     while (length--) {
0287         chk ^= le32_to_cpu(*data++);
0288         chk = (chk >> 5) ^ (chk << 3);
0289     }
0290 
0291     return cpu_to_le32(chk);
0292 }
0293 
0294 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
0295 {
0296     struct p54u_priv *priv = dev->priv;
0297     struct urb *data_urb;
0298     struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
0299 
0300     data_urb = usb_alloc_urb(0, GFP_ATOMIC);
0301     if (!data_urb) {
0302         p54_free_skb(dev, skb);
0303         return;
0304     }
0305 
0306     hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
0307     hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
0308 
0309     usb_fill_bulk_urb(data_urb, priv->udev,
0310               usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
0311               hdr, skb->len + sizeof(*hdr),  FREE_AFTER_TX(skb) ?
0312               p54u_tx_cb : p54u_tx_dummy_cb, skb);
0313     data_urb->transfer_flags |= URB_ZERO_PACKET;
0314 
0315     usb_anchor_urb(data_urb, &priv->submitted);
0316     if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
0317         usb_unanchor_urb(data_urb);
0318         p54_free_skb(dev, skb);
0319     }
0320     usb_free_urb(data_urb);
0321 }
0322 
0323 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
0324 {
0325     struct p54u_priv *priv = dev->priv;
0326     struct urb *int_urb = NULL, *data_urb = NULL;
0327     struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
0328     struct net2280_reg_write *reg = NULL;
0329     int err = -ENOMEM;
0330 
0331     reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
0332     if (!reg)
0333         goto out;
0334 
0335     int_urb = usb_alloc_urb(0, GFP_ATOMIC);
0336     if (!int_urb)
0337         goto out;
0338 
0339     data_urb = usb_alloc_urb(0, GFP_ATOMIC);
0340     if (!data_urb)
0341         goto out;
0342 
0343     reg->port = cpu_to_le16(NET2280_DEV_U32);
0344     reg->addr = cpu_to_le32(P54U_DEV_BASE);
0345     reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
0346 
0347     memset(hdr, 0, sizeof(*hdr));
0348     hdr->len = cpu_to_le16(skb->len);
0349     hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
0350 
0351     usb_fill_bulk_urb(int_urb, priv->udev,
0352         usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
0353         p54u_tx_dummy_cb, dev);
0354 
0355     /*
0356      * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
0357      * free what is inside the transfer_buffer after the last reference to
0358      * the int_urb is dropped.
0359      */
0360     int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
0361     reg = NULL;
0362 
0363     usb_fill_bulk_urb(data_urb, priv->udev,
0364               usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
0365               hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
0366               p54u_tx_cb : p54u_tx_dummy_cb, skb);
0367     data_urb->transfer_flags |= URB_ZERO_PACKET;
0368 
0369     usb_anchor_urb(int_urb, &priv->submitted);
0370     err = usb_submit_urb(int_urb, GFP_ATOMIC);
0371     if (err) {
0372         usb_unanchor_urb(int_urb);
0373         goto out;
0374     }
0375 
0376     usb_anchor_urb(data_urb, &priv->submitted);
0377     err = usb_submit_urb(data_urb, GFP_ATOMIC);
0378     if (err) {
0379         usb_unanchor_urb(data_urb);
0380         goto out;
0381     }
0382 out:
0383     usb_free_urb(int_urb);
0384     usb_free_urb(data_urb);
0385 
0386     if (err) {
0387         kfree(reg);
0388         p54_free_skb(dev, skb);
0389     }
0390 }
0391 
0392 static int p54u_write(struct p54u_priv *priv,
0393               struct net2280_reg_write *buf,
0394               enum net2280_op_type type,
0395               __le32 addr, __le32 val)
0396 {
0397     unsigned int ep;
0398     int alen;
0399 
0400     if (type & 0x0800)
0401         ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
0402     else
0403         ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
0404 
0405     buf->port = cpu_to_le16(type);
0406     buf->addr = addr;
0407     buf->val = val;
0408 
0409     return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
0410 }
0411 
0412 static int p54u_read(struct p54u_priv *priv, void *buf,
0413              enum net2280_op_type type,
0414              __le32 addr, __le32 *val)
0415 {
0416     struct net2280_reg_read *read = buf;
0417     __le32 *reg = buf;
0418     unsigned int ep;
0419     int alen, err;
0420 
0421     if (type & 0x0800)
0422         ep = P54U_PIPE_DEV;
0423     else
0424         ep = P54U_PIPE_BRG;
0425 
0426     read->port = cpu_to_le16(type);
0427     read->addr = addr;
0428 
0429     err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
0430                read, sizeof(*read), &alen, 1000);
0431     if (err)
0432         return err;
0433 
0434     err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
0435                reg, sizeof(*reg), &alen, 1000);
0436     if (err)
0437         return err;
0438 
0439     *val = *reg;
0440     return 0;
0441 }
0442 
0443 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
0444              void *data, size_t len)
0445 {
0446     int alen;
0447     return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
0448                 data, len, &alen, 2000);
0449 }
0450 
0451 static int p54u_device_reset(struct ieee80211_hw *dev)
0452 {
0453     struct p54u_priv *priv = dev->priv;
0454     int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
0455 
0456     if (lock) {
0457         ret = usb_lock_device_for_reset(priv->udev, priv->intf);
0458         if (ret < 0) {
0459             dev_err(&priv->udev->dev, "(p54usb) unable to lock "
0460                 "device for reset (%d)!\n", ret);
0461             return ret;
0462         }
0463     }
0464 
0465     ret = usb_reset_device(priv->udev);
0466     if (lock)
0467         usb_unlock_device(priv->udev);
0468 
0469     if (ret)
0470         dev_err(&priv->udev->dev, "(p54usb) unable to reset "
0471             "device (%d)!\n", ret);
0472 
0473     return ret;
0474 }
0475 
0476 static const char p54u_romboot_3887[] = "~~~~";
0477 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
0478 {
0479     struct p54u_priv *priv = dev->priv;
0480     u8 *buf;
0481     int ret;
0482 
0483     buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
0484     if (!buf)
0485         return -ENOMEM;
0486     ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
0487                 buf, 4);
0488     kfree(buf);
0489     if (ret)
0490         dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
0491             "boot ROM (%d)!\n", ret);
0492 
0493     return ret;
0494 }
0495 
0496 static const char p54u_firmware_upload_3887[] = "<\r";
0497 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
0498 {
0499     struct p54u_priv *priv = dev->priv;
0500     int err, alen;
0501     u8 carry = 0;
0502     u8 *buf, *tmp;
0503     const u8 *data;
0504     unsigned int left, remains, block_size;
0505     struct x2_header *hdr;
0506     unsigned long timeout;
0507 
0508     err = p54u_firmware_reset_3887(dev);
0509     if (err)
0510         return err;
0511 
0512     tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
0513     if (!buf)
0514         return -ENOMEM;
0515 
0516     left = block_size = min_t(size_t, P54U_FW_BLOCK, priv->fw->size);
0517     strcpy(buf, p54u_firmware_upload_3887);
0518     left -= strlen(p54u_firmware_upload_3887);
0519     tmp += strlen(p54u_firmware_upload_3887);
0520 
0521     data = priv->fw->data;
0522     remains = priv->fw->size;
0523 
0524     hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
0525     memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
0526     hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
0527     hdr->fw_length = cpu_to_le32(priv->fw->size);
0528     hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
0529                      sizeof(u32)*2));
0530     left -= sizeof(*hdr);
0531     tmp += sizeof(*hdr);
0532 
0533     while (remains) {
0534         while (left--) {
0535             if (carry) {
0536                 *tmp++ = carry;
0537                 carry = 0;
0538                 remains--;
0539                 continue;
0540             }
0541             switch (*data) {
0542             case '~':
0543                 *tmp++ = '}';
0544                 carry = '^';
0545                 break;
0546             case '}':
0547                 *tmp++ = '}';
0548                 carry = ']';
0549                 break;
0550             default:
0551                 *tmp++ = *data;
0552                 remains--;
0553                 break;
0554             }
0555             data++;
0556         }
0557 
0558         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
0559         if (err) {
0560             dev_err(&priv->udev->dev, "(p54usb) firmware "
0561                           "upload failed!\n");
0562             goto err_upload_failed;
0563         }
0564 
0565         tmp = buf;
0566         left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
0567     }
0568 
0569     *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
0570                          priv->fw->size));
0571     err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
0572     if (err) {
0573         dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
0574         goto err_upload_failed;
0575     }
0576     timeout = jiffies + msecs_to_jiffies(1000);
0577     while (!(err = usb_bulk_msg(priv->udev,
0578         usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
0579         if (alen > 2 && !memcmp(buf, "OK", 2))
0580             break;
0581 
0582         if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
0583             err = -EINVAL;
0584             break;
0585         }
0586 
0587         if (time_after(jiffies, timeout)) {
0588             dev_err(&priv->udev->dev, "(p54usb) firmware boot "
0589                           "timed out!\n");
0590             err = -ETIMEDOUT;
0591             break;
0592         }
0593     }
0594     if (err) {
0595         dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
0596         goto err_upload_failed;
0597     }
0598 
0599     buf[0] = 'g';
0600     buf[1] = '\r';
0601     err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
0602     if (err) {
0603         dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
0604         goto err_upload_failed;
0605     }
0606 
0607     timeout = jiffies + msecs_to_jiffies(1000);
0608     while (!(err = usb_bulk_msg(priv->udev,
0609         usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
0610         if (alen > 0 && buf[0] == 'g')
0611             break;
0612 
0613         if (time_after(jiffies, timeout)) {
0614             err = -ETIMEDOUT;
0615             break;
0616         }
0617     }
0618     if (err)
0619         goto err_upload_failed;
0620 
0621 err_upload_failed:
0622     kfree(buf);
0623     return err;
0624 }
0625 
0626 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
0627 {
0628     struct p54u_priv *priv = dev->priv;
0629     const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
0630     int err, alen;
0631     void *buf;
0632     __le32 reg;
0633     unsigned int remains, offset;
0634     const u8 *data;
0635 
0636     buf = kmalloc(512, GFP_KERNEL);
0637     if (!buf)
0638         return -ENOMEM;
0639 
0640 #define P54U_WRITE(type, addr, data) \
0641     do {\
0642         err = p54u_write(priv, buf, type,\
0643                  cpu_to_le32((u32)(unsigned long)addr), data);\
0644         if (err) \
0645             goto fail;\
0646     } while (0)
0647 
0648 #define P54U_READ(type, addr) \
0649     do {\
0650         err = p54u_read(priv, buf, type,\
0651                 cpu_to_le32((u32)(unsigned long)addr), &reg);\
0652         if (err)\
0653             goto fail;\
0654     } while (0)
0655 
0656     /* power down net2280 bridge */
0657     P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
0658     reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
0659     reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
0660     P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
0661 
0662     mdelay(100);
0663 
0664     /* power up bridge */
0665     reg |= cpu_to_le32(P54U_BRG_POWER_UP);
0666     reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
0667     P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
0668 
0669     mdelay(100);
0670 
0671     P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
0672            cpu_to_le32(NET2280_CLK_30Mhz |
0673                    NET2280_PCI_ENABLE |
0674                    NET2280_PCI_SOFT_RESET));
0675 
0676     mdelay(20);
0677 
0678     P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
0679            cpu_to_le32(PCI_COMMAND_MEMORY |
0680                    PCI_COMMAND_MASTER));
0681 
0682     P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
0683            cpu_to_le32(NET2280_BASE));
0684 
0685     P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
0686     reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
0687     P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
0688 
0689     // TODO: we really need this?
0690     P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
0691 
0692     P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
0693            cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
0694     P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
0695            cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
0696 
0697     P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
0698            cpu_to_le32(NET2280_BASE2));
0699 
0700     /* finally done setting up the bridge */
0701 
0702     P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
0703            cpu_to_le32(PCI_COMMAND_MEMORY |
0704                    PCI_COMMAND_MASTER));
0705 
0706     P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
0707     P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
0708            cpu_to_le32(P54U_DEV_BASE));
0709 
0710     P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
0711     P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
0712            cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
0713 
0714     /* do romboot */
0715     P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
0716 
0717     P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
0718     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
0719     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
0720     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
0721     P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
0722 
0723     mdelay(20);
0724 
0725     reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
0726     P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
0727 
0728     mdelay(20);
0729 
0730     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
0731     P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
0732 
0733     mdelay(100);
0734 
0735     P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
0736     P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
0737 
0738     /* finally, we can upload firmware now! */
0739     remains = priv->fw->size;
0740     data = priv->fw->data;
0741     offset = ISL38XX_DEV_FIRMWARE_ADDR;
0742 
0743     while (remains) {
0744         unsigned int block_len = min(remains, (unsigned int)512);
0745         memcpy(buf, data, block_len);
0746 
0747         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
0748         if (err) {
0749             dev_err(&priv->udev->dev, "(p54usb) firmware block "
0750                           "upload failed\n");
0751             goto fail;
0752         }
0753 
0754         P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
0755                cpu_to_le32(0xc0000f00));
0756 
0757         P54U_WRITE(NET2280_DEV_U32,
0758                0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
0759         P54U_WRITE(NET2280_DEV_U32,
0760                0x0020 | (unsigned long)&devreg->direct_mem_win,
0761                cpu_to_le32(1));
0762 
0763         P54U_WRITE(NET2280_DEV_U32,
0764                0x0024 | (unsigned long)&devreg->direct_mem_win,
0765                cpu_to_le32(block_len));
0766         P54U_WRITE(NET2280_DEV_U32,
0767                0x0028 | (unsigned long)&devreg->direct_mem_win,
0768                cpu_to_le32(offset));
0769 
0770         P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
0771                cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
0772         P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
0773                cpu_to_le32(block_len >> 2));
0774         P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
0775                cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
0776 
0777         mdelay(10);
0778 
0779         P54U_READ(NET2280_DEV_U32,
0780               0x002C | (unsigned long)&devreg->direct_mem_win);
0781         if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
0782             !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
0783             dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
0784                           "transfer failed\n");
0785             goto fail;
0786         }
0787 
0788         P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
0789                cpu_to_le32(NET2280_FIFO_FLUSH));
0790 
0791         remains -= block_len;
0792         data += block_len;
0793         offset += block_len;
0794     }
0795 
0796     /* do ramboot */
0797     P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
0798     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
0799     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
0800     reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
0801     P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
0802 
0803     mdelay(20);
0804 
0805     reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
0806     P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
0807 
0808     reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
0809     P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
0810 
0811     mdelay(100);
0812 
0813     P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
0814     P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
0815 
0816     /* start up the firmware */
0817     P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
0818            cpu_to_le32(ISL38XX_INT_IDENT_INIT));
0819 
0820     P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
0821            cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
0822 
0823     P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
0824            cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
0825                    NET2280_USB_INTERRUPT_ENABLE));
0826 
0827     P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
0828            cpu_to_le32(ISL38XX_DEV_INT_RESET));
0829 
0830     err = usb_interrupt_msg(priv->udev,
0831                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
0832                 buf, sizeof(__le32), &alen, 1000);
0833     if (err || alen != sizeof(__le32))
0834         goto fail;
0835 
0836     P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
0837     P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
0838 
0839     if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
0840         err = -EINVAL;
0841 
0842     P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
0843     P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
0844            cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
0845 
0846 #undef P54U_WRITE
0847 #undef P54U_READ
0848 
0849 fail:
0850     kfree(buf);
0851     return err;
0852 }
0853 
0854 static int p54_find_type(struct p54u_priv *priv)
0855 {
0856     int i;
0857 
0858     for (i = 0; i < __NUM_P54U_HWTYPES; i++)
0859         if (p54u_fwlist[i].type == priv->hw_type)
0860             break;
0861     if (i == __NUM_P54U_HWTYPES)
0862         return -EOPNOTSUPP;
0863 
0864     return i;
0865 }
0866 
0867 static int p54u_start_ops(struct p54u_priv *priv)
0868 {
0869     struct ieee80211_hw *dev = priv->common.hw;
0870     int ret;
0871 
0872     ret = p54_parse_firmware(dev, priv->fw);
0873     if (ret)
0874         goto err_out;
0875 
0876     ret = p54_find_type(priv);
0877     if (ret < 0)
0878         goto err_out;
0879 
0880     if (priv->common.fw_interface != p54u_fwlist[ret].intf) {
0881         dev_err(&priv->udev->dev, "wrong firmware, please get "
0882             "a firmware for \"%s\" and try again.\n",
0883             p54u_fwlist[ret].hw);
0884         ret = -ENODEV;
0885         goto err_out;
0886     }
0887 
0888     ret = priv->upload_fw(dev);
0889     if (ret)
0890         goto err_out;
0891 
0892     ret = p54u_open(dev);
0893     if (ret)
0894         goto err_out;
0895 
0896     ret = p54_read_eeprom(dev);
0897     if (ret)
0898         goto err_stop;
0899 
0900     p54u_stop(dev);
0901 
0902     ret = p54_register_common(dev, &priv->udev->dev);
0903     if (ret)
0904         goto err_stop;
0905 
0906     return 0;
0907 
0908 err_stop:
0909     p54u_stop(dev);
0910 
0911 err_out:
0912     /*
0913      * p54u_disconnect will do the rest of the
0914      * cleanup
0915      */
0916     return ret;
0917 }
0918 
0919 static void p54u_load_firmware_cb(const struct firmware *firmware,
0920                   void *context)
0921 {
0922     struct p54u_priv *priv = context;
0923     struct usb_device *udev = priv->udev;
0924     struct usb_interface *intf = priv->intf;
0925     int err;
0926 
0927     if (firmware) {
0928         priv->fw = firmware;
0929         err = p54u_start_ops(priv);
0930     } else {
0931         err = -ENOENT;
0932         dev_err(&udev->dev, "Firmware not found.\n");
0933     }
0934 
0935     complete(&priv->fw_wait_load);
0936     /*
0937      * At this point p54u_disconnect may have already freed
0938      * the "priv" context. Do not use it anymore!
0939      */
0940     priv = NULL;
0941 
0942     if (err) {
0943         dev_err(&intf->dev, "failed to initialize device (%d)\n", err);
0944 
0945         usb_lock_device(udev);
0946         usb_driver_release_interface(&p54u_driver, intf);
0947         usb_unlock_device(udev);
0948     }
0949 
0950     usb_put_intf(intf);
0951 }
0952 
0953 static int p54u_load_firmware(struct ieee80211_hw *dev,
0954                   struct usb_interface *intf)
0955 {
0956     struct usb_device *udev = interface_to_usbdev(intf);
0957     struct p54u_priv *priv = dev->priv;
0958     struct device *device = &udev->dev;
0959     int err, i;
0960 
0961     BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
0962 
0963     init_completion(&priv->fw_wait_load);
0964     i = p54_find_type(priv);
0965     if (i < 0)
0966         return i;
0967 
0968     dev_info(&priv->udev->dev, "Loading firmware file %s\n",
0969            p54u_fwlist[i].fw);
0970 
0971     usb_get_intf(intf);
0972     err = request_firmware_nowait(THIS_MODULE, 1, p54u_fwlist[i].fw,
0973                       device, GFP_KERNEL, priv,
0974                       p54u_load_firmware_cb);
0975     if (err) {
0976         dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
0977                       "(%d)!\n", p54u_fwlist[i].fw, err);
0978         usb_put_intf(intf);
0979     }
0980 
0981     return err;
0982 }
0983 
0984 static int p54u_probe(struct usb_interface *intf,
0985                 const struct usb_device_id *id)
0986 {
0987     struct usb_device *udev = interface_to_usbdev(intf);
0988     struct ieee80211_hw *dev;
0989     struct p54u_priv *priv;
0990     int err;
0991     unsigned int i, recognized_pipes;
0992 
0993     dev = p54_init_common(sizeof(*priv));
0994 
0995     if (!dev) {
0996         dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
0997         return -ENOMEM;
0998     }
0999 
1000     priv = dev->priv;
1001     priv->hw_type = P54U_INVALID_HW;
1002 
1003     SET_IEEE80211_DEV(dev, &intf->dev);
1004     usb_set_intfdata(intf, dev);
1005     priv->udev = udev;
1006     priv->intf = intf;
1007     skb_queue_head_init(&priv->rx_queue);
1008     init_usb_anchor(&priv->submitted);
1009 
1010     /* really lazy and simple way of figuring out if we're a 3887 */
1011     /* TODO: should just stick the identification in the device table */
1012     i = intf->altsetting->desc.bNumEndpoints;
1013     recognized_pipes = 0;
1014     while (i--) {
1015         switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
1016         case P54U_PIPE_DATA:
1017         case P54U_PIPE_MGMT:
1018         case P54U_PIPE_BRG:
1019         case P54U_PIPE_DEV:
1020         case P54U_PIPE_DATA | USB_DIR_IN:
1021         case P54U_PIPE_MGMT | USB_DIR_IN:
1022         case P54U_PIPE_BRG | USB_DIR_IN:
1023         case P54U_PIPE_DEV | USB_DIR_IN:
1024         case P54U_PIPE_INT | USB_DIR_IN:
1025             recognized_pipes++;
1026         }
1027     }
1028     priv->common.open = p54u_open;
1029     priv->common.stop = p54u_stop;
1030     if (recognized_pipes < P54U_PIPE_NUMBER) {
1031 #ifdef CONFIG_PM
1032         /* ISL3887 needs a full reset on resume */
1033         udev->reset_resume = 1;
1034 #endif /* CONFIG_PM */
1035         err = p54u_device_reset(dev);
1036 
1037         priv->hw_type = P54U_3887;
1038         dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
1039         priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
1040         priv->common.tx = p54u_tx_lm87;
1041         priv->upload_fw = p54u_upload_firmware_3887;
1042     } else {
1043         priv->hw_type = P54U_NET2280;
1044         dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
1045         priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
1046         priv->common.tx = p54u_tx_net2280;
1047         priv->upload_fw = p54u_upload_firmware_net2280;
1048     }
1049     err = p54u_load_firmware(dev, intf);
1050     if (err)
1051         p54_free_common(dev);
1052     return err;
1053 }
1054 
1055 static void p54u_disconnect(struct usb_interface *intf)
1056 {
1057     struct ieee80211_hw *dev = usb_get_intfdata(intf);
1058     struct p54u_priv *priv;
1059 
1060     if (!dev)
1061         return;
1062 
1063     priv = dev->priv;
1064     wait_for_completion(&priv->fw_wait_load);
1065     p54_unregister_common(dev);
1066 
1067     release_firmware(priv->fw);
1068     p54_free_common(dev);
1069 }
1070 
1071 static int p54u_pre_reset(struct usb_interface *intf)
1072 {
1073     struct ieee80211_hw *dev = usb_get_intfdata(intf);
1074 
1075     if (!dev)
1076         return -ENODEV;
1077 
1078     p54u_stop(dev);
1079     return 0;
1080 }
1081 
1082 static int p54u_resume(struct usb_interface *intf)
1083 {
1084     struct ieee80211_hw *dev = usb_get_intfdata(intf);
1085     struct p54u_priv *priv;
1086 
1087     if (!dev)
1088         return -ENODEV;
1089 
1090     priv = dev->priv;
1091     if (unlikely(!(priv->upload_fw && priv->fw)))
1092         return 0;
1093 
1094     return priv->upload_fw(dev);
1095 }
1096 
1097 static int p54u_post_reset(struct usb_interface *intf)
1098 {
1099     struct ieee80211_hw *dev = usb_get_intfdata(intf);
1100     struct p54u_priv *priv;
1101     int err;
1102 
1103     err = p54u_resume(intf);
1104     if (err)
1105         return err;
1106 
1107     /* reinitialize old device state */
1108     priv = dev->priv;
1109     if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1110         ieee80211_restart_hw(dev);
1111 
1112     return 0;
1113 }
1114 
1115 #ifdef CONFIG_PM
1116 
1117 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1118 {
1119     return p54u_pre_reset(intf);
1120 }
1121 
1122 #endif /* CONFIG_PM */
1123 
1124 static struct usb_driver p54u_driver = {
1125     .name   = "p54usb",
1126     .id_table = p54u_table,
1127     .probe = p54u_probe,
1128     .disconnect = p54u_disconnect,
1129     .pre_reset = p54u_pre_reset,
1130     .post_reset = p54u_post_reset,
1131 #ifdef CONFIG_PM
1132     .suspend = p54u_suspend,
1133     .resume = p54u_resume,
1134     .reset_resume = p54u_resume,
1135 #endif /* CONFIG_PM */
1136     .soft_unbind = 1,
1137     .disable_hub_initiated_lpm = 1,
1138 };
1139 
1140 module_usb_driver(p54u_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!