1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #include <linux/usb.h> |
3 | #include <linux/usb/hcd.h> |
4 | #include "usb.h" |
5 | |
6 | static int uas_is_interface(struct usb_host_interface *intf) |
7 | { |
8 | return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE && |
9 | intf->desc.bInterfaceSubClass == USB_SC_SCSI && |
10 | intf->desc.bInterfaceProtocol == USB_PR_UAS); |
11 | } |
12 | |
13 | static struct usb_host_interface *uas_find_uas_alt_setting( |
14 | struct usb_interface *intf) |
15 | { |
16 | int i; |
17 | |
18 | for (i = 0; i < intf->num_altsetting; i++) { |
19 | struct usb_host_interface *alt = &intf->altsetting[i]; |
20 | |
21 | if (uas_is_interface(intf: alt)) |
22 | return alt; |
23 | } |
24 | |
25 | return NULL; |
26 | } |
27 | |
28 | static int uas_find_endpoints(struct usb_host_interface *alt, |
29 | struct usb_host_endpoint *eps[]) |
30 | { |
31 | struct usb_host_endpoint *endpoint = alt->endpoint; |
32 | unsigned i, n_endpoints = alt->desc.bNumEndpoints; |
33 | |
34 | for (i = 0; i < n_endpoints; i++) { |
35 | unsigned char * = endpoint[i].extra; |
36 | int len = endpoint[i].extralen; |
37 | while (len >= 3) { |
38 | if (extra[1] == USB_DT_PIPE_USAGE) { |
39 | unsigned pipe_id = extra[2]; |
40 | if (pipe_id > 0 && pipe_id < 5) |
41 | eps[pipe_id - 1] = &endpoint[i]; |
42 | break; |
43 | } |
44 | len -= extra[0]; |
45 | extra += extra[0]; |
46 | } |
47 | } |
48 | |
49 | if (!eps[0] || !eps[1] || !eps[2] || !eps[3]) |
50 | return -ENODEV; |
51 | |
52 | return 0; |
53 | } |
54 | |
55 | static int uas_use_uas_driver(struct usb_interface *intf, |
56 | const struct usb_device_id *id, |
57 | u64 *flags_ret) |
58 | { |
59 | struct usb_host_endpoint *eps[4] = { }; |
60 | struct usb_device *udev = interface_to_usbdev(intf); |
61 | struct usb_hcd *hcd = bus_to_hcd(bus: udev->bus); |
62 | u64 flags = id->driver_info; |
63 | struct usb_host_interface *alt; |
64 | int r; |
65 | |
66 | alt = uas_find_uas_alt_setting(intf); |
67 | if (!alt) |
68 | return 0; |
69 | |
70 | r = uas_find_endpoints(alt, eps); |
71 | if (r < 0) |
72 | return 0; |
73 | |
74 | /* |
75 | * ASMedia has a number of usb3 to sata bridge chips, at the time of |
76 | * this writing the following versions exist: |
77 | * ASM1051 - no uas support version |
78 | * ASM1051 - with broken (*) uas support |
79 | * ASM1053 - with working uas support, but problems with large xfers |
80 | * ASM1153 - with working uas support |
81 | * |
82 | * Devices with these chips re-use a number of device-ids over the |
83 | * entire line, so the device-id is useless to determine if we're |
84 | * dealing with an ASM1051 (which we want to avoid). |
85 | * |
86 | * The ASM1153 can be identified by config.MaxPower == 0, |
87 | * where as the ASM105x models have config.MaxPower == 36. |
88 | * |
89 | * Differentiating between the ASM1053 and ASM1051 is trickier, when |
90 | * connected over USB-3 we can look at the number of streams supported, |
91 | * ASM1051 supports 32 streams, where as early ASM1053 versions support |
92 | * 16 streams, newer ASM1053-s also support 32 streams, but have a |
93 | * different prod-id. |
94 | * |
95 | * (*) ASM1051 chips do work with UAS with some disks (with the |
96 | * US_FL_NO_REPORT_OPCODES quirk), but are broken with other disks |
97 | */ |
98 | if (le16_to_cpu(udev->descriptor.idVendor) == 0x174c && |
99 | (le16_to_cpu(udev->descriptor.idProduct) == 0x5106 || |
100 | le16_to_cpu(udev->descriptor.idProduct) == 0x55aa)) { |
101 | if (udev->actconfig->desc.bMaxPower == 0) { |
102 | /* ASM1153, do nothing */ |
103 | } else if (udev->speed < USB_SPEED_SUPER) { |
104 | /* No streams info, assume ASM1051 */ |
105 | flags |= US_FL_IGNORE_UAS; |
106 | } else if (usb_ss_max_streams(comp: &eps[1]->ss_ep_comp) == 32) { |
107 | /* Possibly an ASM1051, disable uas */ |
108 | flags |= US_FL_IGNORE_UAS; |
109 | } else { |
110 | /* ASM1053, these have issues with large transfers */ |
111 | flags |= US_FL_MAX_SECTORS_240; |
112 | } |
113 | } |
114 | |
115 | /* All Seagate disk enclosures have broken ATA pass-through support */ |
116 | if (le16_to_cpu(udev->descriptor.idVendor) == 0x0bc2) |
117 | flags |= US_FL_NO_ATA_1X; |
118 | |
119 | /* |
120 | * RTL9210-based enclosure from HIKSEMI, MD202 reportedly have issues |
121 | * with UAS. This isn't distinguishable with just idVendor and |
122 | * idProduct, use manufacturer and product too. |
123 | * |
124 | * Reported-by: Hongling Zeng <zenghongling@kylinos.cn> |
125 | */ |
126 | if (le16_to_cpu(udev->descriptor.idVendor) == 0x0bda && |
127 | le16_to_cpu(udev->descriptor.idProduct) == 0x9210 && |
128 | (udev->manufacturer && !strcmp(udev->manufacturer, "HIKSEMI" )) && |
129 | (udev->product && !strcmp(udev->product, "MD202" ))) |
130 | flags |= US_FL_IGNORE_UAS; |
131 | |
132 | usb_stor_adjust_quirks(dev: udev, fflags: &flags); |
133 | |
134 | if (flags & US_FL_IGNORE_UAS) { |
135 | dev_warn(&udev->dev, |
136 | "UAS is ignored for this device, using usb-storage instead\n" ); |
137 | return 0; |
138 | } |
139 | |
140 | if (udev->bus->sg_tablesize == 0) { |
141 | dev_warn(&udev->dev, |
142 | "The driver for the USB controller %s does not support scatter-gather which is\n" , |
143 | hcd->driver->description); |
144 | dev_warn(&udev->dev, |
145 | "required by the UAS driver. Please try an other USB controller if you wish to use UAS.\n" ); |
146 | return 0; |
147 | } |
148 | |
149 | if (udev->speed >= USB_SPEED_SUPER && !hcd->can_do_streams) { |
150 | dev_warn(&udev->dev, |
151 | "USB controller %s does not support streams, which are required by the UAS driver.\n" , |
152 | hcd_to_bus(hcd)->bus_name); |
153 | dev_warn(&udev->dev, |
154 | "Please try an other USB controller if you wish to use UAS.\n" ); |
155 | return 0; |
156 | } |
157 | |
158 | if (flags_ret) |
159 | *flags_ret = flags; |
160 | |
161 | return 1; |
162 | } |
163 | |