FreeBSD/Linux Kernel Cross Reference
sys/dev/ahci/ahciem.c
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2012 Alexander Motin <mav@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer,
12 * without modification, immediately at the beginning of the file.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/module.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/bus.h>
37 #include <sys/conf.h>
38 #include <sys/endian.h>
39 #include <sys/malloc.h>
40 #include <sys/lock.h>
41 #include <sys/mutex.h>
42 #include <machine/stdarg.h>
43 #include <machine/resource.h>
44 #include <machine/bus.h>
45 #include <sys/rman.h>
46 #include <dev/led/led.h>
47 #include <dev/pci/pcivar.h>
48 #include <dev/pci/pcireg.h>
49 #include "ahci.h"
50
51 #include <cam/cam.h>
52 #include <cam/cam_ccb.h>
53 #include <cam/cam_sim.h>
54 #include <cam/cam_xpt_sim.h>
55 #include <cam/cam_debug.h>
56 #include <cam/scsi/scsi_ses.h>
57
58 /* local prototypes */
59 static void ahciemaction(struct cam_sim *sim, union ccb *ccb);
60 static void ahciempoll(struct cam_sim *sim);
61 static int ahci_em_reset(device_t dev);
62 static void ahci_em_led(void *priv, int onoff);
63 static void ahci_em_setleds(device_t dev, int c);
64
65 static int
66 ahci_em_probe(device_t dev)
67 {
68
69 device_set_desc_copy(dev, "AHCI enclosure management bridge");
70 return (BUS_PROBE_DEFAULT);
71 }
72
73 static int
74 ahci_em_attach(device_t dev)
75 {
76 device_t parent = device_get_parent(dev);
77 struct ahci_controller *ctlr = device_get_softc(parent);
78 struct ahci_enclosure *enc = device_get_softc(dev);
79 struct cam_devq *devq;
80 int i, c, rid, error;
81 char buf[32];
82
83 enc->dev = dev;
84 enc->quirks = ctlr->quirks;
85 enc->channels = ctlr->channels;
86 enc->ichannels = ctlr->ichannels;
87 mtx_init(&enc->mtx, "AHCI enclosure lock", NULL, MTX_DEF);
88 rid = 0;
89 if (!(enc->r_memc = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
90 &rid, RF_ACTIVE))) {
91 mtx_destroy(&enc->mtx);
92 return (ENXIO);
93 }
94 enc->capsem = ATA_INL(enc->r_memc, 0);
95 rid = 1;
96 if (!(enc->r_memt = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
97 &rid, RF_ACTIVE))) {
98 error = ENXIO;
99 goto err0;
100 }
101 if ((enc->capsem & (AHCI_EM_XMT | AHCI_EM_SMB)) == 0) {
102 rid = 2;
103 if (!(enc->r_memr = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
104 &rid, RF_ACTIVE))) {
105 error = ENXIO;
106 goto err0;
107 }
108 } else
109 enc->r_memr = NULL;
110 mtx_lock(&enc->mtx);
111 if (ahci_em_reset(dev) != 0) {
112 error = ENXIO;
113 goto err1;
114 }
115 rid = ATA_IRQ_RID;
116 /* Create the device queue for our SIM. */
117 devq = cam_simq_alloc(1);
118 if (devq == NULL) {
119 device_printf(dev, "Unable to allocate SIM queue\n");
120 error = ENOMEM;
121 goto err1;
122 }
123 /* Construct SIM entry */
124 enc->sim = cam_sim_alloc(ahciemaction, ahciempoll, "ahciem", enc,
125 device_get_unit(dev), &enc->mtx,
126 1, 0, devq);
127 if (enc->sim == NULL) {
128 cam_simq_free(devq);
129 device_printf(dev, "Unable to allocate SIM\n");
130 error = ENOMEM;
131 goto err1;
132 }
133 if (xpt_bus_register(enc->sim, dev, 0) != CAM_SUCCESS) {
134 device_printf(dev, "unable to register xpt bus\n");
135 error = ENXIO;
136 goto err2;
137 }
138 if (xpt_create_path(&enc->path, /*periph*/NULL, cam_sim_path(enc->sim),
139 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
140 device_printf(dev, "Unable to create path\n");
141 error = ENXIO;
142 goto err3;
143 }
144 mtx_unlock(&enc->mtx);
145 if (bootverbose) {
146 device_printf(dev, "Caps:%s%s%s%s%s%s%s%s\n",
147 (enc->capsem & AHCI_EM_PM) ? " PM":"",
148 (enc->capsem & AHCI_EM_ALHD) ? " ALHD":"",
149 (enc->capsem & AHCI_EM_XMT) ? " XMT":"",
150 (enc->capsem & AHCI_EM_SMB) ? " SMB":"",
151 (enc->capsem & AHCI_EM_SGPIO) ? " SGPIO":"",
152 (enc->capsem & AHCI_EM_SES2) ? " SES-2":"",
153 (enc->capsem & AHCI_EM_SAFTE) ? " SAF-TE":"",
154 (enc->capsem & AHCI_EM_LED) ? " LED":"");
155 }
156 if ((enc->capsem & AHCI_EM_LED)) {
157 for (c = 0; c < enc->channels; c++) {
158 if ((enc->ichannels & (1 << c)) == 0)
159 continue;
160 for (i = 0; i < AHCI_NUM_LEDS; i++) {
161 enc->leds[c * AHCI_NUM_LEDS + i].dev = dev;
162 enc->leds[c * AHCI_NUM_LEDS + i].num =
163 c * AHCI_NUM_LEDS + i;
164 }
165 if ((enc->capsem & AHCI_EM_ALHD) == 0) {
166 snprintf(buf, sizeof(buf), "%s.%d.act",
167 device_get_nameunit(parent), c);
168 enc->leds[c * AHCI_NUM_LEDS + 0].led =
169 led_create(ahci_em_led,
170 &enc->leds[c * AHCI_NUM_LEDS + 0], buf);
171 }
172 snprintf(buf, sizeof(buf), "%s.%d.locate",
173 device_get_nameunit(parent), c);
174 enc->leds[c * AHCI_NUM_LEDS + 1].led =
175 led_create(ahci_em_led,
176 &enc->leds[c * AHCI_NUM_LEDS + 1], buf);
177 snprintf(buf, sizeof(buf), "%s.%d.fault",
178 device_get_nameunit(parent), c);
179 enc->leds[c * AHCI_NUM_LEDS + 2].led =
180 led_create(ahci_em_led,
181 &enc->leds[c * AHCI_NUM_LEDS + 2], buf);
182 }
183 }
184 return (0);
185
186 err3:
187 xpt_bus_deregister(cam_sim_path(enc->sim));
188 err2:
189 cam_sim_free(enc->sim, /*free_devq*/TRUE);
190 err1:
191 mtx_unlock(&enc->mtx);
192 if (enc->r_memr)
193 bus_release_resource(dev, SYS_RES_MEMORY, 2, enc->r_memr);
194 err0:
195 if (enc->r_memt)
196 bus_release_resource(dev, SYS_RES_MEMORY, 1, enc->r_memt);
197 bus_release_resource(dev, SYS_RES_MEMORY, 0, enc->r_memc);
198 mtx_destroy(&enc->mtx);
199 return (error);
200 }
201
202 static int
203 ahci_em_detach(device_t dev)
204 {
205 struct ahci_enclosure *enc = device_get_softc(dev);
206 int i;
207
208 for (i = 0; i < enc->channels * AHCI_NUM_LEDS; i++) {
209 if (enc->leds[i].led)
210 led_destroy(enc->leds[i].led);
211 }
212 mtx_lock(&enc->mtx);
213 xpt_async(AC_LOST_DEVICE, enc->path, NULL);
214 xpt_free_path(enc->path);
215 xpt_bus_deregister(cam_sim_path(enc->sim));
216 cam_sim_free(enc->sim, /*free_devq*/TRUE);
217 mtx_unlock(&enc->mtx);
218
219 bus_release_resource(dev, SYS_RES_MEMORY, 0, enc->r_memc);
220 bus_release_resource(dev, SYS_RES_MEMORY, 1, enc->r_memt);
221 if (enc->r_memr)
222 bus_release_resource(dev, SYS_RES_MEMORY, 2, enc->r_memr);
223 mtx_destroy(&enc->mtx);
224 return (0);
225 }
226
227 static int
228 ahci_em_reset(device_t dev)
229 {
230 struct ahci_enclosure *enc;
231 int i, timeout;
232
233 enc = device_get_softc(dev);
234 ATA_OUTL(enc->r_memc, 0, AHCI_EM_RST);
235 timeout = 1000;
236 while ((ATA_INL(enc->r_memc, 0) & AHCI_EM_RST) &&
237 --timeout > 0)
238 DELAY(1000);
239 if (timeout == 0) {
240 device_printf(dev, "EM timeout\n");
241 return (1);
242 }
243 for (i = 0; i < enc->channels; i++)
244 ahci_em_setleds(dev, i);
245 return (0);
246 }
247
248 static int
249 ahci_em_suspend(device_t dev)
250 {
251 struct ahci_enclosure *enc = device_get_softc(dev);
252
253 mtx_lock(&enc->mtx);
254 xpt_freeze_simq(enc->sim, 1);
255 mtx_unlock(&enc->mtx);
256 return (0);
257 }
258
259 static int
260 ahci_em_resume(device_t dev)
261 {
262 struct ahci_enclosure *enc = device_get_softc(dev);
263
264 mtx_lock(&enc->mtx);
265 ahci_em_reset(dev);
266 xpt_release_simq(enc->sim, TRUE);
267 mtx_unlock(&enc->mtx);
268 return (0);
269 }
270
271 devclass_t ahciem_devclass;
272 static device_method_t ahciem_methods[] = {
273 DEVMETHOD(device_probe, ahci_em_probe),
274 DEVMETHOD(device_attach, ahci_em_attach),
275 DEVMETHOD(device_detach, ahci_em_detach),
276 DEVMETHOD(device_suspend, ahci_em_suspend),
277 DEVMETHOD(device_resume, ahci_em_resume),
278 DEVMETHOD_END
279 };
280 static driver_t ahciem_driver = {
281 "ahciem",
282 ahciem_methods,
283 sizeof(struct ahci_enclosure)
284 };
285 DRIVER_MODULE(ahciem, ahci, ahciem_driver, ahciem_devclass, NULL, NULL);
286
287 static void
288 ahci_em_setleds(device_t dev, int c)
289 {
290 struct ahci_enclosure *enc;
291 int timeout;
292 int16_t val;
293
294 enc = device_get_softc(dev);
295
296 val = 0;
297 if (enc->status[c][2] & SESCTL_RQSACT) /* Activity */
298 val |= (1 << 0);
299 if (enc->status[c][1] & SESCTL_RQSRR) /* Rebuild */
300 val |= (1 << 6) | (1 << 3);
301 else if (enc->status[c][2] & SESCTL_RQSID) /* Identification */
302 val |= (1 << 3);
303 else if (enc->status[c][3] & SESCTL_RQSFLT) /* Fault */
304 val |= (1 << 6);
305
306 timeout = 10000;
307 while (ATA_INL(enc->r_memc, 0) & (AHCI_EM_TM | AHCI_EM_RST) &&
308 --timeout > 0)
309 DELAY(100);
310 if (timeout == 0)
311 device_printf(dev, "Transmit timeout\n");
312 ATA_OUTL(enc->r_memt, 0, (1 << 8) | (0 << 16) | (0 << 24));
313 ATA_OUTL(enc->r_memt, 4, c | (0 << 8) | (val << 16));
314 ATA_OUTL(enc->r_memc, 0, AHCI_EM_TM);
315 }
316
317 static void
318 ahci_em_led(void *priv, int onoff)
319 {
320 struct ahci_led *led;
321 struct ahci_enclosure *enc;
322 int c, l;
323
324 led = (struct ahci_led *)priv;
325 enc = device_get_softc(led->dev);
326 c = led->num / AHCI_NUM_LEDS;
327 l = led->num % AHCI_NUM_LEDS;
328
329 if (l == 0) {
330 if (onoff)
331 enc->status[c][2] |= 0x80;
332 else
333 enc->status[c][2] &= ~0x80;
334 } else if (l == 1) {
335 if (onoff)
336 enc->status[c][2] |= SESCTL_RQSID;
337 else
338 enc->status[c][2] &= ~SESCTL_RQSID;
339 } else if (l == 2) {
340 if (onoff)
341 enc->status[c][3] |= SESCTL_RQSFLT;
342 else
343 enc->status[c][3] &= SESCTL_RQSFLT;
344 }
345 ahci_em_setleds(led->dev, c);
346 }
347
348 static int
349 ahci_check_ids(union ccb *ccb)
350 {
351
352 if (ccb->ccb_h.target_id != 0) {
353 ccb->ccb_h.status = CAM_TID_INVALID;
354 xpt_done(ccb);
355 return (-1);
356 }
357 if (ccb->ccb_h.target_lun != 0) {
358 ccb->ccb_h.status = CAM_LUN_INVALID;
359 xpt_done(ccb);
360 return (-1);
361 }
362 return (0);
363 }
364
365 static void
366 ahci_em_emulate_ses_on_led(device_t dev, union ccb *ccb)
367 {
368 struct ahci_enclosure *enc;
369 struct ahci_channel *ch;
370 struct ses_status_page *page;
371 struct ses_status_array_dev_slot *ads, *ads0;
372 struct ses_elm_desc_hdr *elmd;
373 struct ses_elm_addlstatus_eip_hdr *elma;
374 struct ses_elm_ata_hdr *elmb;
375 uint8_t *buf;
376 int i;
377
378 enc = device_get_softc(dev);
379 buf = ccb->ataio.data_ptr;
380
381 /* General request validation. */
382 if (ccb->ataio.cmd.command != ATA_SEP_ATTN ||
383 ccb->ataio.dxfer_len < ccb->ataio.cmd.sector_count * 4) {
384 ccb->ccb_h.status = CAM_REQ_INVALID;
385 goto out;
386 }
387
388 /* SEMB IDENTIFY */
389 if (ccb->ataio.cmd.features == 0xEC &&
390 ccb->ataio.cmd.sector_count >= 16) {
391 bzero(buf, ccb->ataio.dxfer_len);
392 buf[0] = 64; /* Valid bytes. */
393 buf[2] = 0x30; /* NAA Locally Assigned. */
394 strncpy(&buf[3], device_get_nameunit(dev), 7);
395 strncpy(&buf[10], "AHCI ", SID_VENDOR_SIZE);
396 strncpy(&buf[18], "SGPIO Enclosure ", SID_PRODUCT_SIZE);
397 strncpy(&buf[34], "2.00", SID_REVISION_SIZE);
398 strncpy(&buf[39], "0001", 4);
399 strncpy(&buf[43], "S-E-S ", 6);
400 strncpy(&buf[49], "2.00", 4);
401 ccb->ccb_h.status = CAM_REQ_CMP;
402 goto out;
403 }
404
405 /* SEMB RECEIVE DIAGNOSTIC RESULT (0) */
406 page = (struct ses_status_page *)buf;
407 if (ccb->ataio.cmd.lba_low == 0x02 &&
408 ccb->ataio.cmd.features == 0x00 &&
409 ccb->ataio.cmd.sector_count >= 3) {
410 bzero(buf, ccb->ataio.dxfer_len);
411 page->hdr.page_code = 0;
412 scsi_ulto2b(5, page->hdr.length);
413 buf[4] = 0x00;
414 buf[5] = 0x01;
415 buf[6] = 0x02;
416 buf[7] = 0x07;
417 buf[8] = 0x0a;
418 ccb->ccb_h.status = CAM_REQ_CMP;
419 goto out;
420 }
421
422 /* SEMB RECEIVE DIAGNOSTIC RESULT (1) */
423 if (ccb->ataio.cmd.lba_low == 0x02 &&
424 ccb->ataio.cmd.features == 0x01 &&
425 ccb->ataio.cmd.sector_count >= 16) {
426 struct ses_enc_desc *ed;
427 struct ses_elm_type_desc *td;
428
429 bzero(buf, ccb->ataio.dxfer_len);
430 page->hdr.page_code = 0x01;
431 scsi_ulto2b(4 + sizeof(*ed) + sizeof(*td) + 11,
432 page->hdr.length);
433 ed = (struct ses_enc_desc *)&buf[8];
434 ed->byte0 = 0x11;
435 ed->subenc_id = 0;
436 ed->num_types = 1;
437 ed->length = 36;
438 ed->logical_id[0] = 0x30; /* NAA Locally Assigned. */
439 strncpy(&ed->logical_id[1], device_get_nameunit(dev), 7);
440 strncpy(ed->vendor_id, "AHCI ", SID_VENDOR_SIZE);
441 strncpy(ed->product_id, "SGPIO Enclosure ", SID_PRODUCT_SIZE);
442 strncpy(ed->product_rev, "2.00", SID_REVISION_SIZE);
443 td = (struct ses_elm_type_desc *)ses_enc_desc_next(ed);
444 td->etype_elm_type = 0x17;
445 td->etype_maxelt = enc->channels;
446 td->etype_subenc = 0;
447 td->etype_txt_len = 11;
448 snprintf((char *)(td + 1), 12, "Drive Slots");
449 ccb->ccb_h.status = CAM_REQ_CMP;
450 goto out;
451 }
452
453 /* SEMB RECEIVE DIAGNOSTIC RESULT (2) */
454 if (ccb->ataio.cmd.lba_low == 0x02 &&
455 ccb->ataio.cmd.features == 0x02 &&
456 ccb->ataio.cmd.sector_count >= (3 + enc->channels)) {
457 bzero(buf, ccb->ataio.dxfer_len);
458 page->hdr.page_code = 0x02;
459 scsi_ulto2b(4 + 4 * (1 + enc->channels),
460 page->hdr.length);
461 for (i = 0; i < enc->channels; i++) {
462 ads = &page->elements[i + 1].array_dev_slot;
463 memcpy(ads, enc->status[i], 4);
464 ch = ahci_getch(device_get_parent(dev), i);
465 if (ch == NULL) {
466 ads->common.bytes[0] |= SES_OBJSTAT_UNKNOWN;
467 continue;
468 }
469 if (ch->pm_present)
470 ads->common.bytes[0] |= SES_OBJSTAT_UNKNOWN;
471 else if (ch->devices)
472 ads->common.bytes[0] |= SES_OBJSTAT_OK;
473 else if (ch->disablephy)
474 ads->common.bytes[0] |= SES_OBJSTAT_NOTAVAIL;
475 else
476 ads->common.bytes[0] |= SES_OBJSTAT_NOTINSTALLED;
477 if (ch->disablephy)
478 ads->common.bytes[3] |= SESCTL_DEVOFF;
479 ahci_putch(ch);
480 }
481 ccb->ccb_h.status = CAM_REQ_CMP;
482 goto out;
483 }
484
485 /* SEMB SEND DIAGNOSTIC (2) */
486 if (ccb->ataio.cmd.lba_low == 0x82 &&
487 ccb->ataio.cmd.features == 0x02 &&
488 ccb->ataio.cmd.sector_count >= (3 + enc->channels)) {
489 ads0 = &page->elements[0].array_dev_slot;
490 for (i = 0; i < enc->channels; i++) {
491 ads = &page->elements[i + 1].array_dev_slot;
492 if (ads->common.bytes[0] & SESCTL_CSEL) {
493 enc->status[i][0] = 0;
494 enc->status[i][1] = ads->bytes[0] &
495 SESCTL_RQSRR;
496 enc->status[i][2] = ads->bytes[1] &
497 (SESCTL_RQSACT | SESCTL_RQSID);
498 enc->status[i][3] = ads->bytes[2] &
499 SESCTL_RQSFLT;
500 ahci_em_setleds(dev, i);
501 } else if (ads0->common.bytes[0] & SESCTL_CSEL) {
502 enc->status[i][0] = 0;
503 enc->status[i][1] = ads0->bytes[0] &
504 SESCTL_RQSRR;
505 enc->status[i][2] = ads0->bytes[1] &
506 (SESCTL_RQSACT | SESCTL_RQSID);
507 enc->status[i][3] = ads0->bytes[2] &
508 SESCTL_RQSFLT;
509 ahci_em_setleds(dev, i);
510 }
511 }
512 ccb->ccb_h.status = CAM_REQ_CMP;
513 goto out;
514 }
515
516 /* SEMB RECEIVE DIAGNOSTIC RESULT (7) */
517 if (ccb->ataio.cmd.lba_low == 0x02 &&
518 ccb->ataio.cmd.features == 0x07 &&
519 ccb->ataio.cmd.sector_count >= (6 + 3 * enc->channels)) {
520 bzero(buf, ccb->ataio.dxfer_len);
521 page->hdr.page_code = 0x07;
522 scsi_ulto2b(4 + 15 + 11 * enc->channels, page->hdr.length);
523 elmd = (struct ses_elm_desc_hdr *)&buf[8];
524 scsi_ulto2b(11, elmd->length);
525 snprintf((char *)(elmd + 1), 12, "Drive Slots");
526 for (i = 0; i < enc->channels; i++) {
527 elmd = (struct ses_elm_desc_hdr *)&buf[8 + 15 + 11 * i];
528 scsi_ulto2b(7, elmd->length);
529 snprintf((char *)(elmd + 1), 8, "Slot %02d", i);
530 }
531 ccb->ccb_h.status = CAM_REQ_CMP;
532 goto out;
533 }
534
535 /* SEMB RECEIVE DIAGNOSTIC RESULT (a) */
536 if (ccb->ataio.cmd.lba_low == 0x02 &&
537 ccb->ataio.cmd.features == 0x0a &&
538 ccb->ataio.cmd.sector_count >= (2 + 3 * enc->channels)) {
539 bzero(buf, ccb->ataio.dxfer_len);
540 page->hdr.page_code = 0x0a;
541 scsi_ulto2b(4 + (sizeof(*elma) + sizeof(*elmb)) * enc->channels,
542 page->hdr.length);
543 for (i = 0; i < enc->channels; i++) {
544 elma = (struct ses_elm_addlstatus_eip_hdr *)&buf[
545 8 + (sizeof(*elma) + sizeof(*elmb)) * i];
546 elma->base.byte0 = 0x10 | SPSP_PROTO_ATA;
547 elma->base.length = 2 + sizeof(*elmb);
548 elma->byte2 = 0x01;
549 elma->element_index = 1 + i;
550 ch = ahci_getch(device_get_parent(dev), i);
551 if (ch == NULL) {
552 elma->base.byte0 |= 0x80;
553 continue;
554 }
555 if (ch->devices == 0 || ch->pm_present)
556 elma->base.byte0 |= 0x80;
557 elmb = (struct ses_elm_ata_hdr *)(elma + 1);
558 scsi_ulto4b(cam_sim_path(ch->sim), elmb->bus);
559 scsi_ulto4b(0, elmb->target);
560 ahci_putch(ch);
561 }
562 ccb->ccb_h.status = CAM_REQ_CMP;
563 goto out;
564 }
565
566 ccb->ccb_h.status = CAM_REQ_INVALID;
567 out:
568 xpt_done(ccb);
569 }
570
571 static void
572 ahci_em_begin_transaction(device_t dev, union ccb *ccb)
573 {
574 struct ahci_enclosure *enc;
575 struct ata_res *res;
576
577 enc = device_get_softc(dev);
578 res = &ccb->ataio.res;
579 bzero(res, sizeof(*res));
580 if ((ccb->ataio.cmd.flags & CAM_ATAIO_CONTROL) &&
581 (ccb->ataio.cmd.control & ATA_A_RESET)) {
582 res->lba_high = 0xc3;
583 res->lba_mid = 0x3c;
584 ccb->ccb_h.status = CAM_REQ_CMP;
585 xpt_done(ccb);
586 return;
587 }
588
589 if (enc->capsem & AHCI_EM_LED) {
590 ahci_em_emulate_ses_on_led(dev, ccb);
591 return;
592 } else
593 device_printf(dev, "Unsupported enclosure interface\n");
594
595 ccb->ccb_h.status = CAM_REQ_INVALID;
596 xpt_done(ccb);
597 }
598
599 static void
600 ahciemaction(struct cam_sim *sim, union ccb *ccb)
601 {
602 device_t dev, parent;
603 struct ahci_enclosure *enc;
604
605 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE,
606 ("ahciemaction func_code=%x\n", ccb->ccb_h.func_code));
607
608 enc = cam_sim_softc(sim);
609 dev = enc->dev;
610 switch (ccb->ccb_h.func_code) {
611 case XPT_ATA_IO: /* Execute the requested I/O operation */
612 if (ahci_check_ids(ccb))
613 return;
614 ahci_em_begin_transaction(dev, ccb);
615 return;
616 case XPT_RESET_BUS: /* Reset the specified bus */
617 case XPT_RESET_DEV: /* Bus Device Reset the specified device */
618 ahci_em_reset(dev);
619 ccb->ccb_h.status = CAM_REQ_CMP;
620 break;
621 case XPT_PATH_INQ: /* Path routing inquiry */
622 {
623 struct ccb_pathinq *cpi = &ccb->cpi;
624
625 parent = device_get_parent(dev);
626 cpi->version_num = 1; /* XXX??? */
627 cpi->hba_inquiry = PI_SDTR_ABLE;
628 cpi->target_sprt = 0;
629 cpi->hba_misc = PIM_SEQSCAN;
630 cpi->hba_eng_cnt = 0;
631 cpi->max_target = 0;
632 cpi->max_lun = 0;
633 cpi->initiator_id = 0;
634 cpi->bus_id = cam_sim_bus(sim);
635 cpi->base_transfer_speed = 150000;
636 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
637 strlcpy(cpi->hba_vid, "AHCI", HBA_IDLEN);
638 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
639 cpi->unit_number = cam_sim_unit(sim);
640 cpi->transport = XPORT_SATA;
641 cpi->transport_version = XPORT_VERSION_UNSPECIFIED;
642 cpi->protocol = PROTO_ATA;
643 cpi->protocol_version = PROTO_VERSION_UNSPECIFIED;
644 cpi->maxio = MAXPHYS;
645 cpi->hba_vendor = pci_get_vendor(parent);
646 cpi->hba_device = pci_get_device(parent);
647 cpi->hba_subvendor = pci_get_subvendor(parent);
648 cpi->hba_subdevice = pci_get_subdevice(parent);
649 cpi->ccb_h.status = CAM_REQ_CMP;
650 break;
651 }
652 default:
653 ccb->ccb_h.status = CAM_REQ_INVALID;
654 break;
655 }
656 xpt_done(ccb);
657 }
658
659 static void
660 ahciempoll(struct cam_sim *sim)
661 {
662
663 }
Cache object: 7070faab26b47d556fdfa6f3739d0966
|