]>
Commit | Line | Data |
---|---|---|
a10e763b | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b98e66fa JB |
2 | /* |
3 | * Serial Attached SCSI (SAS) Expander discovery and configuration | |
4 | * | |
5 | * Copyright (C) 2007 James E.J. Bottomley | |
6 | * <James.Bottomley@HansenPartnership.com> | |
b98e66fa JB |
7 | */ |
8 | #include <linux/scatterlist.h> | |
9 | #include <linux/blkdev.h> | |
5a0e3ad6 | 10 | #include <linux/slab.h> |
09703660 | 11 | #include <linux/export.h> |
b98e66fa JB |
12 | |
13 | #include "sas_internal.h" | |
14 | ||
15 | #include <scsi/scsi_transport.h> | |
16 | #include <scsi/scsi_transport_sas.h> | |
e15f669c | 17 | #include "scsi_sas_internal.h" |
b98e66fa JB |
18 | |
19 | static void sas_host_smp_discover(struct sas_ha_struct *sas_ha, u8 *resp_data, | |
20 | u8 phy_id) | |
21 | { | |
22 | struct sas_phy *phy; | |
23 | struct sas_rphy *rphy; | |
24 | ||
25 | if (phy_id >= sas_ha->num_phys) { | |
26 | resp_data[2] = SMP_RESP_NO_PHY; | |
27 | return; | |
28 | } | |
29 | resp_data[2] = SMP_RESP_FUNC_ACC; | |
30 | ||
31 | phy = sas_ha->sas_phy[phy_id]->phy; | |
32 | resp_data[9] = phy_id; | |
33 | resp_data[13] = phy->negotiated_linkrate; | |
34 | memcpy(resp_data + 16, sas_ha->sas_addr, SAS_ADDR_SIZE); | |
35 | memcpy(resp_data + 24, sas_ha->sas_phy[phy_id]->attached_sas_addr, | |
36 | SAS_ADDR_SIZE); | |
37 | resp_data[40] = (phy->minimum_linkrate << 4) | | |
38 | phy->minimum_linkrate_hw; | |
39 | resp_data[41] = (phy->maximum_linkrate << 4) | | |
40 | phy->maximum_linkrate_hw; | |
41 | ||
42 | if (!sas_ha->sas_phy[phy_id]->port || | |
43 | !sas_ha->sas_phy[phy_id]->port->port_dev) | |
44 | return; | |
45 | ||
46 | rphy = sas_ha->sas_phy[phy_id]->port->port_dev->rphy; | |
47 | resp_data[12] = rphy->identify.device_type << 4; | |
48 | resp_data[14] = rphy->identify.initiator_port_protocols; | |
49 | resp_data[15] = rphy->identify.target_port_protocols; | |
50 | } | |
51 | ||
8ec6552f DW |
52 | /** |
53 | * to_sas_gpio_gp_bit - given the gpio frame data find the byte/bit position of 'od' | |
54 | * @od: od bit to find | |
55 | * @data: incoming bitstream (from frame) | |
56 | * @index: requested data register index (from frame) | |
57 | * @count: total number of registers in the bitstream (from frame) | |
58 | * @bit: bit position of 'od' in the returned byte | |
59 | * | |
60 | * returns NULL if 'od' is not in 'data' | |
61 | * | |
62 | * From SFF-8485 v0.7: | |
63 | * "In GPIO_TX[1], bit 0 of byte 3 contains the first bit (i.e., OD0.0) | |
64 | * and bit 7 of byte 0 contains the 32nd bit (i.e., OD10.1). | |
65 | * | |
66 | * In GPIO_TX[2], bit 0 of byte 3 contains the 33rd bit (i.e., OD10.2) | |
67 | * and bit 7 of byte 0 contains the 64th bit (i.e., OD21.0)." | |
68 | * | |
69 | * The general-purpose (raw-bitstream) RX registers have the same layout | |
70 | * although 'od' is renamed 'id' for 'input data'. | |
71 | * | |
72 | * SFF-8489 defines the behavior of the LEDs in response to the 'od' values. | |
73 | */ | |
74 | static u8 *to_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count, u8 *bit) | |
75 | { | |
76 | unsigned int reg; | |
77 | u8 byte; | |
78 | ||
79 | /* gp registers start at index 1 */ | |
80 | if (index == 0) | |
81 | return NULL; | |
82 | ||
83 | index--; /* make index 0-based */ | |
84 | if (od < index * 32) | |
85 | return NULL; | |
86 | ||
87 | od -= index * 32; | |
88 | reg = od >> 5; | |
89 | ||
90 | if (reg >= count) | |
91 | return NULL; | |
92 | ||
93 | od &= (1 << 5) - 1; | |
94 | byte = 3 - (od >> 3); | |
95 | *bit = od & ((1 << 3) - 1); | |
96 | ||
97 | return &data[reg * 4 + byte]; | |
98 | } | |
99 | ||
100 | int try_test_sas_gpio_gp_bit(unsigned int od, u8 *data, u8 index, u8 count) | |
101 | { | |
102 | u8 *byte; | |
103 | u8 bit; | |
104 | ||
105 | byte = to_sas_gpio_gp_bit(od, data, index, count, &bit); | |
106 | if (!byte) | |
107 | return -1; | |
108 | ||
109 | return (*byte >> bit) & 1; | |
110 | } | |
111 | EXPORT_SYMBOL(try_test_sas_gpio_gp_bit); | |
112 | ||
113 | static int sas_host_smp_write_gpio(struct sas_ha_struct *sas_ha, u8 *resp_data, | |
114 | u8 reg_type, u8 reg_index, u8 reg_count, | |
115 | u8 *req_data) | |
116 | { | |
117 | struct sas_internal *i = to_sas_internal(sas_ha->core.shost->transportt); | |
118 | int written; | |
119 | ||
120 | if (i->dft->lldd_write_gpio == NULL) { | |
121 | resp_data[2] = SMP_RESP_FUNC_UNK; | |
122 | return 0; | |
123 | } | |
124 | ||
125 | written = i->dft->lldd_write_gpio(sas_ha, reg_type, reg_index, | |
126 | reg_count, req_data); | |
127 | ||
128 | if (written < 0) { | |
129 | resp_data[2] = SMP_RESP_FUNC_FAILED; | |
130 | written = 0; | |
131 | } else | |
132 | resp_data[2] = SMP_RESP_FUNC_ACC; | |
133 | ||
134 | return written; | |
135 | } | |
136 | ||
b98e66fa JB |
137 | static void sas_report_phy_sata(struct sas_ha_struct *sas_ha, u8 *resp_data, |
138 | u8 phy_id) | |
139 | { | |
140 | struct sas_rphy *rphy; | |
141 | struct dev_to_host_fis *fis; | |
142 | int i; | |
143 | ||
144 | if (phy_id >= sas_ha->num_phys) { | |
145 | resp_data[2] = SMP_RESP_NO_PHY; | |
146 | return; | |
147 | } | |
148 | ||
149 | resp_data[2] = SMP_RESP_PHY_NO_SATA; | |
150 | ||
151 | if (!sas_ha->sas_phy[phy_id]->port) | |
152 | return; | |
153 | ||
154 | rphy = sas_ha->sas_phy[phy_id]->port->port_dev->rphy; | |
155 | fis = (struct dev_to_host_fis *) | |
156 | sas_ha->sas_phy[phy_id]->port->port_dev->frame_rcvd; | |
157 | if (rphy->identify.target_port_protocols != SAS_PROTOCOL_SATA) | |
158 | return; | |
159 | ||
160 | resp_data[2] = SMP_RESP_FUNC_ACC; | |
161 | resp_data[9] = phy_id; | |
162 | memcpy(resp_data + 16, sas_ha->sas_phy[phy_id]->attached_sas_addr, | |
163 | SAS_ADDR_SIZE); | |
164 | ||
165 | /* check to see if we have a valid d2h fis */ | |
166 | if (fis->fis_type != 0x34) | |
167 | return; | |
168 | ||
169 | /* the d2h fis is required by the standard to be in LE format */ | |
170 | for (i = 0; i < 20; i += 4) { | |
171 | u8 *dst = resp_data + 24 + i, *src = | |
172 | &sas_ha->sas_phy[phy_id]->port->port_dev->frame_rcvd[i]; | |
173 | dst[0] = src[3]; | |
174 | dst[1] = src[2]; | |
175 | dst[2] = src[1]; | |
176 | dst[3] = src[0]; | |
177 | } | |
178 | } | |
179 | ||
180 | static void sas_phy_control(struct sas_ha_struct *sas_ha, u8 phy_id, | |
181 | u8 phy_op, enum sas_linkrate min, | |
182 | enum sas_linkrate max, u8 *resp_data) | |
183 | { | |
184 | struct sas_internal *i = | |
185 | to_sas_internal(sas_ha->core.shost->transportt); | |
186 | struct sas_phy_linkrates rates; | |
ab526633 | 187 | struct asd_sas_phy *asd_phy; |
b98e66fa JB |
188 | |
189 | if (phy_id >= sas_ha->num_phys) { | |
190 | resp_data[2] = SMP_RESP_NO_PHY; | |
191 | return; | |
192 | } | |
ab526633 DW |
193 | |
194 | asd_phy = sas_ha->sas_phy[phy_id]; | |
b98e66fa JB |
195 | switch (phy_op) { |
196 | case PHY_FUNC_NOP: | |
197 | case PHY_FUNC_LINK_RESET: | |
198 | case PHY_FUNC_HARD_RESET: | |
199 | case PHY_FUNC_DISABLE: | |
200 | case PHY_FUNC_CLEAR_ERROR_LOG: | |
201 | case PHY_FUNC_CLEAR_AFFIL: | |
202 | case PHY_FUNC_TX_SATA_PS_SIGNAL: | |
203 | break; | |
204 | ||
205 | default: | |
206 | resp_data[2] = SMP_RESP_PHY_UNK_OP; | |
207 | return; | |
208 | } | |
209 | ||
210 | rates.minimum_linkrate = min; | |
211 | rates.maximum_linkrate = max; | |
212 | ||
ab526633 DW |
213 | /* filter reset requests through libata eh */ |
214 | if (phy_op == PHY_FUNC_LINK_RESET && sas_try_ata_reset(asd_phy) == 0) { | |
215 | resp_data[2] = SMP_RESP_FUNC_ACC; | |
216 | return; | |
217 | } | |
218 | ||
219 | if (i->dft->lldd_control_phy(asd_phy, phy_op, &rates)) | |
b98e66fa JB |
220 | resp_data[2] = SMP_RESP_FUNC_FAILED; |
221 | else | |
222 | resp_data[2] = SMP_RESP_FUNC_ACC; | |
223 | } | |
224 | ||
651a0136 | 225 | void sas_smp_host_handler(struct bsg_job *job, struct Scsi_Host *shost) |
b98e66fa | 226 | { |
b98e66fa | 227 | struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); |
651a0136 CH |
228 | u8 *req_data, *resp_data; |
229 | unsigned int reslen = 0; | |
c3a4d78c | 230 | int error = -EINVAL; |
b98e66fa JB |
231 | |
232 | /* eight is the minimum size for request and response frames */ | |
651a0136 CH |
233 | if (job->request_payload.payload_len < 8 || |
234 | job->reply_payload.payload_len < 8) | |
b98e66fa JB |
235 | goto out; |
236 | ||
651a0136 CH |
237 | error = -ENOMEM; |
238 | req_data = kzalloc(job->request_payload.payload_len, GFP_KERNEL); | |
239 | if (!req_data) | |
b98e66fa | 240 | goto out; |
651a0136 CH |
241 | sg_copy_to_buffer(job->request_payload.sg_list, |
242 | job->request_payload.sg_cnt, req_data, | |
243 | job->request_payload.payload_len); | |
b98e66fa JB |
244 | |
245 | /* make sure frame can always be built ... we copy | |
246 | * back only the requested length */ | |
651a0136 CH |
247 | resp_data = kzalloc(max(job->reply_payload.payload_len, 128U), |
248 | GFP_KERNEL); | |
249 | if (!resp_data) | |
250 | goto out_free_req; | |
b98e66fa | 251 | |
651a0136 | 252 | error = -EINVAL; |
b98e66fa | 253 | if (req_data[0] != SMP_REQUEST) |
651a0136 | 254 | goto out_free_resp; |
b98e66fa JB |
255 | |
256 | /* set up default don't know response */ | |
257 | resp_data[0] = SMP_RESPONSE; | |
258 | resp_data[1] = req_data[1]; | |
259 | resp_data[2] = SMP_RESP_FUNC_UNK; | |
260 | ||
261 | switch (req_data[1]) { | |
262 | case SMP_REPORT_GENERAL: | |
b98e66fa JB |
263 | resp_data[2] = SMP_RESP_FUNC_ACC; |
264 | resp_data[9] = sas_ha->num_phys; | |
651a0136 | 265 | reslen = 32; |
b98e66fa JB |
266 | break; |
267 | ||
268 | case SMP_REPORT_MANUF_INFO: | |
b98e66fa JB |
269 | resp_data[2] = SMP_RESP_FUNC_ACC; |
270 | memcpy(resp_data + 12, shost->hostt->name, | |
271 | SAS_EXPANDER_VENDOR_ID_LEN); | |
272 | memcpy(resp_data + 20, "libsas virt phy", | |
273 | SAS_EXPANDER_PRODUCT_ID_LEN); | |
651a0136 | 274 | reslen = 64; |
b98e66fa JB |
275 | break; |
276 | ||
277 | case SMP_READ_GPIO_REG: | |
278 | /* FIXME: need GPIO support in the transport class */ | |
279 | break; | |
280 | ||
281 | case SMP_DISCOVER: | |
651a0136 CH |
282 | if (job->request_payload.payload_len < 16) |
283 | goto out_free_resp; | |
b98e66fa | 284 | sas_host_smp_discover(sas_ha, resp_data, req_data[9]); |
651a0136 | 285 | reslen = 56; |
b98e66fa JB |
286 | break; |
287 | ||
288 | case SMP_REPORT_PHY_ERR_LOG: | |
289 | /* FIXME: could implement this with additional | |
290 | * libsas callbacks providing the HW supports it */ | |
291 | break; | |
292 | ||
293 | case SMP_REPORT_PHY_SATA: | |
651a0136 CH |
294 | if (job->request_payload.payload_len < 16) |
295 | goto out_free_resp; | |
b98e66fa | 296 | sas_report_phy_sata(sas_ha, resp_data, req_data[9]); |
651a0136 | 297 | reslen = 60; |
b98e66fa JB |
298 | break; |
299 | ||
300 | case SMP_REPORT_ROUTE_INFO: | |
301 | /* Can't implement; hosts have no routes */ | |
302 | break; | |
303 | ||
8ec6552f DW |
304 | case SMP_WRITE_GPIO_REG: { |
305 | /* SFF-8485 v0.7 */ | |
306 | const int base_frame_size = 11; | |
307 | int to_write = req_data[4]; | |
308 | ||
651a0136 CH |
309 | if (job->request_payload.payload_len < |
310 | base_frame_size + to_write * 4) { | |
8ec6552f DW |
311 | resp_data[2] = SMP_RESP_INV_FRM_LEN; |
312 | break; | |
313 | } | |
314 | ||
315 | to_write = sas_host_smp_write_gpio(sas_ha, resp_data, req_data[2], | |
316 | req_data[3], to_write, &req_data[8]); | |
651a0136 | 317 | reslen = 8; |
b98e66fa | 318 | break; |
8ec6552f | 319 | } |
b98e66fa JB |
320 | |
321 | case SMP_CONF_ROUTE_INFO: | |
322 | /* Can't implement; hosts have no routes */ | |
323 | break; | |
324 | ||
325 | case SMP_PHY_CONTROL: | |
651a0136 CH |
326 | if (job->request_payload.payload_len < 44) |
327 | goto out_free_resp; | |
b98e66fa JB |
328 | sas_phy_control(sas_ha, req_data[9], req_data[10], |
329 | req_data[32] >> 4, req_data[33] >> 4, | |
330 | resp_data); | |
651a0136 | 331 | reslen = 8; |
b98e66fa JB |
332 | break; |
333 | ||
334 | case SMP_PHY_TEST_FUNCTION: | |
335 | /* FIXME: should this be implemented? */ | |
336 | break; | |
337 | ||
338 | default: | |
339 | /* probably a 2.0 function */ | |
340 | break; | |
341 | } | |
342 | ||
651a0136 CH |
343 | sg_copy_from_buffer(job->reply_payload.sg_list, |
344 | job->reply_payload.sg_cnt, resp_data, | |
345 | job->reply_payload.payload_len); | |
b98e66fa | 346 | |
651a0136 CH |
347 | error = 0; |
348 | out_free_resp: | |
b98e66fa | 349 | kfree(resp_data); |
651a0136 CH |
350 | out_free_req: |
351 | kfree(req_data); | |
352 | out: | |
353 | bsg_job_done(job, error, reslen); | |
b98e66fa | 354 | } |