Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...

diff --git a/drivers/uwb/hwa-rc.c b/drivers/uwb/hwa-rc.c
index e7eeb63fab23a11632a1b94176def00e28bc9d27..b409c228f254bea253b4430be38f5419627afe5d 100644 (file)
--- a/drivers/uwb/hwa-rc.c
+++ b/drivers/uwb/hwa-rc.c
@@ -891,7 +891,7 @@ static int hwarc_post_reset(struct usb_interface *iface)
 }
 
 /** USB device ID's that we handle */
-static struct usb_device_id hwarc_id_table[] = {
+static const struct usb_device_id hwarc_id_table[] = {
        /* D-Link DUB-1210 */
        { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3d02, 0xe0, 0x01, 0x02),
          .driver_info = WUSB_QUIRK_WHCI_CMD_EVT },

diff --git a/drivers/uwb/i1480/dfu/usb.c b/drivers/uwb/i1480/dfu/usb.c
index 0bb665a0c02454e41745d55a129c35bb65f40b84..a6a93755627e4eddb7997b5d183560526026f12f 100644 (file)
--- a/drivers/uwb/i1480/dfu/usb.c
+++ b/drivers/uwb/i1480/dfu/usb.c
@@ -413,6 +413,10 @@ error:
        return result;
 }
 
+MODULE_FIRMWARE("i1480-pre-phy-0.0.bin");
+MODULE_FIRMWARE("i1480-usb-0.0.bin");
+MODULE_FIRMWARE("i1480-phy-0.0.bin");
+
 #define i1480_USB_DEV(v, p)                            \
 {                                                      \
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE       \
@@ -430,7 +434,7 @@ error:
 
 
 /** USB device ID's that we handle */
-static struct usb_device_id i1480_usb_id_table[] = {
+static const struct usb_device_id i1480_usb_id_table[] = {
        i1480_USB_DEV(0x8086, 0xdf3b),
        i1480_USB_DEV(0x15a9, 0x0005),
        i1480_USB_DEV(0x07d1, 0x3802),

diff --git a/drivers/uwb/wlp/messages.c b/drivers/uwb/wlp/messages.c
index aa42fcee4c4f8e052a2e25b24d1c8aaa75a3ac9a..75164866c2d867c6a1b5b9451600784e55a3cc58 100644 (file)
--- a/drivers/uwb/wlp/messages.c
+++ b/drivers/uwb/wlp/messages.c
@@ -259,6 +259,63 @@ out:
 }
 
 
+static ssize_t wlp_get_attribute(struct wlp *wlp, u16 type_code,
+       struct wlp_attr_hdr *attr_hdr, void *value, ssize_t value_len,
+       ssize_t buflen)
+{
+       struct device *dev = &wlp->rc->uwb_dev.dev;
+       ssize_t attr_len = sizeof(*attr_hdr) + value_len;
+       if (buflen < 0)
+               return -EINVAL;
+       if (buflen < attr_len) {
+               dev_err(dev, "WLP: Not enough space in buffer to parse"
+                       " attribute field. Need %d, received %zu\n",
+                       (int)attr_len, buflen);
+               return -EIO;
+       }
+       if (wlp_check_attr_hdr(wlp, attr_hdr, type_code, value_len) < 0) {
+               dev_err(dev, "WLP: Header verification failed. \n");
+               return -EINVAL;
+       }
+       memcpy(value, (void *)attr_hdr + sizeof(*attr_hdr), value_len);
+       return attr_len;
+}
+
+static ssize_t wlp_vget_attribute(struct wlp *wlp, u16 type_code,
+       struct wlp_attr_hdr *attr_hdr, void *value, ssize_t max_value_len,
+       ssize_t buflen)
+{
+       struct device *dev = &wlp->rc->uwb_dev.dev;
+       size_t len;
+       if (buflen < 0)
+               return -EINVAL;
+       if (buflen < sizeof(*attr_hdr)) {
+               dev_err(dev, "WLP: Not enough space in buffer to parse"
+                       " header.\n");
+               return -EIO;
+       }
+       if (le16_to_cpu(attr_hdr->type) != type_code) {
+               dev_err(dev, "WLP: Unexpected attribute type. Got %u, "
+                       "expected %u.\n", le16_to_cpu(attr_hdr->type),
+                       type_code);
+               return -EINVAL;
+       }
+       len = le16_to_cpu(attr_hdr->length);
+       if (len > max_value_len) {
+               dev_err(dev, "WLP: Attribute larger than maximum "
+                       "allowed. Received %zu, max is %d.\n", len,
+                       (int)max_value_len);
+               return -EFBIG;
+       }
+       if (buflen < sizeof(*attr_hdr) + len) {
+               dev_err(dev, "WLP: Not enough space in buffer to parse "
+                       "variable data.\n");
+               return -EIO;
+       }
+       memcpy(value, (void *)attr_hdr + sizeof(*attr_hdr), len);
+       return sizeof(*attr_hdr) + len;
+}
+
 /**
  * Get value of attribute from fixed size attribute field.
  *
@@ -274,22 +331,8 @@ out:
 ssize_t wlp_get_##name(struct wlp *wlp, struct wlp_attr_##name *attr,  \
                      type *value, ssize_t buflen)                      \
 {                                                                      \
-       struct device *dev = &wlp->rc->uwb_dev.dev;                     \
-       if (buflen < 0)                                                 \
-               return -EINVAL;                                         \
-       if (buflen < sizeof(*attr)) {                                   \
-               dev_err(dev, "WLP: Not enough space in buffer to parse" \
-                       " attribute field. Need %d, received %zu\n",    \
-                       (int)sizeof(*attr), buflen);                    \
-               return -EIO;                                            \
-       }                                                               \
-       if (wlp_check_attr_hdr(wlp, &attr->hdr, type_code,              \
-                              sizeof(attr->name)) < 0) {               \
-               dev_err(dev, "WLP: Header verification failed. \n");    \
-               return -EINVAL;                                         \
-       }                                                               \
-       *value = attr->name;                                            \
-       return sizeof(*attr);                                           \
+       return wlp_get_attribute(wlp, (type_code), &attr->hdr,          \
+                                value, sizeof(*value), buflen);        \
 }
 
 #define wlp_get_sparse(type, type_code, name) \
@@ -313,35 +356,8 @@ static ssize_t wlp_get_##name(struct wlp *wlp,                             \
                              struct wlp_attr_##name *attr,             \
                              type_val *value, ssize_t buflen)          \
 {                                                                      \
-       struct device *dev = &wlp->rc->uwb_dev.dev;                     \
-       size_t len;                                                     \
-       if (buflen < 0)                                                 \
-               return -EINVAL;                                         \
-       if (buflen < sizeof(*attr)) {                                   \
-               dev_err(dev, "WLP: Not enough space in buffer to parse" \
-                       " header.\n");                                  \
-               return -EIO;                                            \
-       }                                                               \
-       if (le16_to_cpu(attr->hdr.type) != type_code) {                 \
-               dev_err(dev, "WLP: Unexpected attribute type. Got %u, " \
-                       "expected %u.\n", le16_to_cpu(attr->hdr.type),  \
-                       type_code);                                     \
-               return -EINVAL;                                         \
-       }                                                               \
-       len = le16_to_cpu(attr->hdr.length);                            \
-       if (len > max) {                                                \
-               dev_err(dev, "WLP: Attribute larger than maximum "      \
-                       "allowed. Received %zu, max is %d.\n", len,     \
-                       (int)max);                                      \
-               return -EFBIG;                                          \
-       }                                                               \
-       if (buflen < sizeof(*attr) + len) {                             \
-               dev_err(dev, "WLP: Not enough space in buffer to parse "\
-                       "variable data.\n");                            \
-               return -EIO;                                            \
-       }                                                               \
-       memcpy(value, (void *) attr + sizeof(*attr), len);              \
-       return sizeof(*attr) + len;                                     \
+       return wlp_vget_attribute(wlp, (type_code), &attr->hdr,         \
+                             value, (max), buflen);                    \
 }
 
 wlp_get(u8, WLP_ATTR_WLP_VER, version)