1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <sys/types.h>
28 #include <sys/dkio.h>
29 #include <sys/cdio.h>
30 #include <sys/file.h>
31
32 #include "ata_common.h"
33 #include "ata_disk.h"
34
35 /*
36 * this typedef really should be in dktp/cmpkt.h
37 */
38 typedef struct cmpkt cmpkt_t;
39
40
41 /*
42 * DADA entry points
43 */
44
45 static int ata_disk_abort(opaque_t ctl_data, cmpkt_t *pktp);
46 static int ata_disk_reset(opaque_t ctl_data, int level);
47 static int ata_disk_ioctl(opaque_t ctl_data, int cmd, intptr_t a, int flag);
48 static cmpkt_t *ata_disk_pktalloc(opaque_t ctl_data, int (*callback)(caddr_t),
49 caddr_t arg);
50 static void ata_disk_pktfree(opaque_t ctl_data, cmpkt_t *pktp);
51 static cmpkt_t *ata_disk_memsetup(opaque_t ctl_data, cmpkt_t *pktp,
52 struct buf *bp, int (*callback)(caddr_t), caddr_t arg);
53 static void ata_disk_memfree(opaque_t ctl_data, cmpkt_t *pktp);
54 static cmpkt_t *ata_disk_iosetup(opaque_t ctl_data, cmpkt_t *pktp);
55 static int ata_disk_transport(opaque_t ctl_data, cmpkt_t *pktp);
56
57 /*
58 * DADA packet callbacks
59 */
60
61 static void ata_disk_complete(ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp,
62 int do_callback);
63 static int ata_disk_intr(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
64 ata_pkt_t *ata_pktp);
65 static int ata_disk_intr_dma(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
66 ata_pkt_t *ata_pktp);
67 static int ata_disk_intr_pio_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
68 ata_pkt_t *ata_pktp);
69 static int ata_disk_intr_pio_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
70 ata_pkt_t *ata_pktp);
71 static int ata_disk_start(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
72 ata_pkt_t *ata_pktp);
73 static int ata_disk_start_dma_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
74 ata_pkt_t *ata_pktp);
75 static int ata_disk_start_dma_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
76 ata_pkt_t *ata_pktp);
77 static int ata_disk_start_pio_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
78 ata_pkt_t *ata_pktp);
79 static int ata_disk_start_pio_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
80 ata_pkt_t *ata_pktp);
81
82 /*
83 * Local Function prototypes
84 */
85
86 static int ata_disk_eject(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
87 ata_pkt_t *ata_pktp);
88 static void ata_disk_fake_inquiry(ata_drv_t *ata_drvp);
89 static void ata_disk_get_resid(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
90 ata_pkt_t *ata_pktp);
91 static int ata_disk_initialize_device_parameters(ata_ctl_t *ata_ctlp,
92 ata_drv_t *ata_drvp);
93 static int ata_disk_lock(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
94 ata_pkt_t *ata_pktp);
95 static int ata_disk_set_multiple(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp);
96 static void ata_disk_pio_xfer_data_in(ata_ctl_t *ata_ctlp, ata_pkt_t *ata_pktp);
97 static void ata_disk_pio_xfer_data_out(ata_ctl_t *ata_ctlp,
98 ata_pkt_t *ata_pktp);
99 static void ata_disk_set_standby_timer(ata_ctl_t *ata_ctlp,
100 ata_drv_t *ata_drvp);
101 static int ata_disk_recalibrate(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
102 ata_pkt_t *ata_pktp);
103 static int ata_disk_standby(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
104 ata_pkt_t *ata_pktp);
105 static int ata_disk_start_common(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
106 ata_pkt_t *ata_pktp);
107 static int ata_disk_state(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
108 ata_pkt_t *ata_pktp);
109 static int ata_disk_unlock(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
110 ata_pkt_t *ata_pktp);
111 static int ata_get_capacity(ata_drv_t *ata_drvp, uint64_t *capacity);
112 static void ata_fix_large_disk_geometry(ata_drv_t *ata_drvp);
113 static uint64_t ata_calculate_28bits_capacity(ata_drv_t *ata_drvp);
114 static uint64_t ata_calculate_48bits_capacity(ata_drv_t *ata_drvp);
115 static int ata_copy_dk_ioc_string(intptr_t arg, char *source, int length,
116 int flag);
117 static void ata_set_write_cache(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp);
118 static int ata_disk_update_fw(gtgt_t *gtgtp, ata_ctl_t *ata_ctlp,
119 ata_drv_t *ata_drvp, caddr_t fwfile, uint_t size,
120 uint8_t type, int flag);
121 static int ata_disk_set_feature_spinup(ata_ctl_t *ata_ctlp,
122 ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp);
123 static int ata_disk_id_update(ata_ctl_t *ata_ctlp,
124 ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp);
125
126
127 /*
128 * Local static data
129 */
130
131 uint_t ata_disk_init_dev_parm_wait = 4 * 1000000;
132 uint_t ata_disk_set_mult_wait = 4 * 1000000;
133 int ata_disk_do_standby_timer = TRUE;
134
135 /* timeout value for device update firmware */
136 int ata_disk_updatefw_time = 60;
137
138 /*
139 * ata_write_cache == 1 force write cache on.
140 * ata_write_cache == 0 do not modify write cache. firmware defaults kept.
141 * ata_write_cache == -1 force write cache off.
142 */
143 int ata_write_cache = 1;
144
145
146 static struct ctl_objops ata_disk_objops = {
147 ata_disk_pktalloc,
148 ata_disk_pktfree,
149 ata_disk_memsetup,
150 ata_disk_memfree,
151 ata_disk_iosetup,
152 ata_disk_transport,
153 ata_disk_reset,
154 ata_disk_abort,
155 nulldev,
156 nulldev,
157 ata_disk_ioctl,
158 0, 0
159 };
160
161
162
163 /*
164 *
165 * initialize the ata_disk sub-system
166 *
167 */
168
169 /*ARGSUSED*/
170 int
ata_disk_attach(ata_ctl_t * ata_ctlp)171 ata_disk_attach(
172 ata_ctl_t *ata_ctlp)
173 {
174 ADBG_TRACE(("ata_disk_init entered\n"));
175 return (TRUE);
176 }
177
178
179
180 /*
181 *
182 * destroy the ata_disk sub-system
183 *
184 */
185
186 /*ARGSUSED*/
187 void
ata_disk_detach(ata_ctl_t * ata_ctlp)188 ata_disk_detach(
189 ata_ctl_t *ata_ctlp)
190 {
191 ADBG_TRACE(("ata_disk_destroy entered\n"));
192 }
193
194
195 /*
196 * Test whether the disk can support Logical Block Addressing
197 */
198
199 int
ata_test_lba_support(struct ata_id * aidp)200 ata_test_lba_support(struct ata_id *aidp)
201 {
202 #ifdef __old_version__
203 /*
204 * determine if the drive supports LBA mode
205 */
206 if (aidp->ai_cap & ATAC_LBA_SUPPORT)
207 return (TRUE);
208 #else
209 /*
210 * Determine if the drive supports LBA mode
211 * LBA mode is mandatory on ATA-3 (or newer) drives but is
212 * optional on ATA-2 (or older) drives. On ATA-2 drives
213 * the ai_majorversion word should be 0xffff or 0x0000
214 * (version not reported).
215 */
216 if (aidp->ai_majorversion != 0xffff &&
217 aidp->ai_majorversion >= (1 << 3)) {
218 /* ATA-3 or better */
219 return (TRUE);
220 } else if (aidp->ai_cap & ATAC_LBA_SUPPORT) {
221 /* ATA-2 LBA capability bit set */
222 return (TRUE);
223 } else {
224 return (FALSE);
225 }
226 #endif
227 }
228
229 /*
230 * ATA-6 drives do not provide geometry information, so words
231 * ai_heads, ai_sectors and ai_fixcyls may not be valid
232 */
233 static void
ata_fixup_ata6_geometry(struct ata_id * aidp)234 ata_fixup_ata6_geometry(struct ata_id *aidp)
235 {
236 /* check cylinders, heads, and sectors for valid values */
237 if (aidp->ai_heads != 0 && aidp->ai_heads != 0xffff &&
238 aidp->ai_sectors != 0 && aidp->ai_sectors != 0xffff &&
239 aidp->ai_fixcyls != 0)
240 return; /* assume valid geometry - do nothing */
241
242 /*
243 * Pre-set standard geometry values - they are not necessarily
244 * optimal for a given capacity
245 */
246 aidp->ai_heads = 0x10;
247 aidp->ai_sectors = 0x3f;
248 aidp->ai_fixcyls = 1;
249 /*
250 * The fixcyls value will get fixed up later in
251 * ata_fix_large_disk_geometry.
252 */
253 }
254
255 /*
256 *
257 * initialize the soft-structure for an ATA (non-PACKET) drive and
258 * then configure the drive with the correct modes and options.
259 *
260 */
261
262 int
ata_disk_init_drive(ata_drv_t * ata_drvp)263 ata_disk_init_drive(
264 ata_drv_t *ata_drvp)
265 {
266 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp;
267 struct ata_id *aidp = &ata_drvp->ad_id;
268 struct ctl_obj *ctlobjp;
269 struct scsi_device *devp;
270 int len;
271 int val;
272 int mode;
273 short *chs;
274 char buf[80];
275
276 ADBG_TRACE(("ata_disk_init_drive entered\n"));
277
278 /* ATA disks don't support LUNs */
279
280 if (ata_drvp->ad_lun != 0)
281 return (FALSE);
282
283 /*
284 * set up drive structure
285 * ATA-6 drives do not provide geometry information, so words
286 * ai_heads, ai_sectors and ai_fixcyls may not be valid - they
287 * will be fixed later
288 */
289
290 ata_drvp->ad_phhd = aidp->ai_heads;
291 ata_drvp->ad_phsec = aidp->ai_sectors;
292 ata_drvp->ad_drvrhd = aidp->ai_heads;
293 ata_drvp->ad_drvrsec = aidp->ai_sectors;
294 ata_drvp->ad_drvrcyl = aidp->ai_fixcyls;
295 ata_drvp->ad_acyl = 0;
296
297 if (ata_test_lba_support(&ata_drvp->ad_id))
298 ata_drvp->ad_drive_bits |= ATDH_LBA;
299
300 /* Get capacity and check for 48-bit mode */
301 mode = ata_get_capacity(ata_drvp, &ata_drvp->ad_capacity);
302 if (mode == AD_EXT48) {
303 ata_drvp->ad_flags |= AD_EXT48;
304 }
305
306 /* straighten out the geometry */
307 (void) sprintf(buf, "SUNW-ata-%p-d%d-chs", (void *) ata_ctlp->ac_data,
308 ata_drvp->ad_targ+1);
309 if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), 0,
310 buf, (caddr_t)&chs, &len) == DDI_PROP_SUCCESS) {
311 /*
312 * if the number of sectors and heads in bios matches the
313 * physical geometry, then so should the number of cylinders
314 * this is to prevent the 1023 limit in the older bios's
315 * causing loss of space.
316 */
317 if (chs[1] == (ata_drvp->ad_drvrhd - 1) &&
318 chs[2] == ata_drvp->ad_drvrsec) {
319 /* Set chs[0] to zero-based number of cylinders. */
320 chs[0] = aidp->ai_fixcyls - 1;
321 } else if (!(ata_drvp->ad_drive_bits & ATDH_LBA)) {
322 /*
323 * if the the sector/heads do not match that of the
324 * bios and the drive does not support LBA. We go ahead
325 * and advertise the bios geometry but use the physical
326 * geometry for sector translation.
327 */
328 cmn_err(CE_WARN, "!Disk 0x%p,%d: BIOS geometry "
329 "different from physical, and no LBA support.",
330 (void *)ata_ctlp->ac_data, ata_drvp->ad_targ);
331 }
332
333 /*
334 * chs[0,1] are zero-based; make them one-based.
335 */
336 ata_drvp->ad_drvrcyl = chs[0] + 1;
337 ata_drvp->ad_drvrhd = chs[1] + 1;
338 ata_drvp->ad_drvrsec = chs[2];
339 kmem_free(chs, len);
340 } else {
341 /*
342 * Property not present; this means that boot.bin has
343 * determined that the drive supports Int13 LBA. Note
344 * this, but just return a geometry with a large
345 * cylinder count; this will be the signal for dadk to
346 * fail DKIOCG_VIRTGEOM.
347 * ad_drvr* are already set; just recalculate ad_drvrcyl
348 * from capacity.
349 */
350
351 ata_drvp->ad_flags |= AD_INT13LBA;
352 if (ata_drvp->ad_capacity != 0) {
353 ata_drvp->ad_drvrcyl = ata_drvp->ad_capacity /
354 (ata_drvp->ad_drvrhd * ata_drvp->ad_drvrsec);
355 } else {
356 /*
357 * Something's wrong; return something sure to
358 * fail the "cyls < 1024" test. This will
359 * never make it out of the DKIOCG_VIRTGEOM
360 * call, so its total bogosity won't matter.
361 */
362 ata_drvp->ad_drvrcyl = 1025;
363 ata_drvp->ad_drvrhd = 1;
364 ata_drvp->ad_drvrsec = 1;
365 }
366 }
367
368 /* fix geometry for disks > 31GB, if needed */
369 ata_fix_large_disk_geometry(ata_drvp);
370
371 /*
372 * set up the scsi_device and ctl_obj structures
373 */
374 devp = kmem_zalloc(scsi_device_size(), KM_SLEEP);
375 ata_drvp->ad_device = devp;
376 ctlobjp = &ata_drvp->ad_ctl_obj;
377
378 devp->sd_inq = &ata_drvp->ad_inquiry;
379 devp->sd_address.a_hba_tran = (scsi_hba_tran_t *)ctlobjp;
380 devp->sd_address.a_target = (ushort_t)ata_drvp->ad_targ;
381 devp->sd_address.a_lun = (uchar_t)ata_drvp->ad_lun;
382 mutex_init(&devp->sd_mutex, NULL, MUTEX_DRIVER, NULL);
383 ata_drvp->ad_flags |= AD_MUTEX_INIT;
384
385 /*
386 * DADA ops vectors and cookie
387 */
388 ctlobjp->c_ops = (struct ctl_objops *)&ata_disk_objops;
389
390 /*
391 * this is filled in with gtgtp by ata_disk_bus_ctl(INITCHILD)
392 */
393 ctlobjp->c_data = NULL;
394
395 ctlobjp->c_ext = &(ctlobjp->c_extblk);
396 ctlobjp->c_extblk.c_ctldip = ata_ctlp->ac_dip;
397 ctlobjp->c_extblk.c_targ = ata_drvp->ad_targ;
398 ctlobjp->c_extblk.c_blksz = NBPSCTR;
399
400 /*
401 * Get highest block factor supported by the drive.
402 * Some drives report 0 if read/write multiple not supported,
403 * adjust their blocking factor to 1.
404 */
405 ata_drvp->ad_block_factor = aidp->ai_mult1 & 0xff;
406
407 /*
408 * If a block factor property exists, use the smaller of the
409 * property value and the highest value the drive can support.
410 */
411 (void) sprintf(buf, "drive%d_block_factor", ata_drvp->ad_targ);
412 val = ddi_prop_get_int(DDI_DEV_T_ANY, ata_ctlp->ac_dip, 0, buf,
413 ata_drvp->ad_block_factor);
414
415 ata_drvp->ad_block_factor = (short)min(val, ata_drvp->ad_block_factor);
416
417 if (ata_drvp->ad_block_factor == 0)
418 ata_drvp->ad_block_factor = 1;
419
420 if (!ata_disk_setup_parms(ata_ctlp, ata_drvp)) {
421 ata_drvp->ad_device = NULL;
422 kmem_free(devp, scsi_device_size());
423 return (FALSE);
424 }
425
426 ata_disk_fake_inquiry(ata_drvp);
427
428 return (TRUE);
429 }
430
431 /*
432 * Test if a disk supports 48-bit (extended mode) addressing and
433 * get disk capacity.
434 * Return value:
435 * AD_EXT48 if 48-bit mode is available, 0 otherwise,
436 * capacity in sectors.
437 * There are several indicators for 48-bit addressing. If any of
438 * them is missing, assume 28-bit (non-extended) addressing.
439 */
440
441 static int
ata_get_capacity(ata_drv_t * ata_drvp,uint64_t * capacity)442 ata_get_capacity(ata_drv_t *ata_drvp, uint64_t *capacity)
443 {
444 struct ata_id *aidp = &ata_drvp->ad_id;
445 uint64_t cap28; /* capacity in 28-bit mode */
446 uint64_t cap48; /* capacity in 48-bit mode */
447
448 /*
449 * First compute capacity in 28-bit mode, using 28-bit capacity
450 * words in IDENTIFY DEVICE response words
451 */
452 cap28 = ata_calculate_28bits_capacity(ata_drvp);
453 *capacity = cap28;
454
455 if (!IS_ATA_VERSION_SUPPORTED(aidp, 6) &&
456 !(ata_drvp->ad_flags & AD_BLLBA48))
457 return (0);
458
459 /* Check that 48 bit addressing is supported & enabled */
460 /* words 83 and 86 */
461 if (!(aidp->ai_cmdset83 & ATACS_EXT48))
462 return (0);
463 if (!(aidp->ai_features86 & ATACS_EXT48))
464 return (0);
465
466 /*
467 * Drive supports ATA-6. Since ATA-6 drives may not provide
468 * geometry info, pre-set standard geometry values
469 */
470 ata_fixup_ata6_geometry(aidp);
471
472 /* Compute 48-bit capacity */
473 cap48 = ata_calculate_48bits_capacity(ata_drvp);
474
475 /*
476 * If capacity is smaller then the maximum capacity addressable
477 * in 28-bit mode, just use 28-bit capacity value.
478 * We will use 28-bit addressing read/write commands.
479 */
480 if (cap48 <= MAX_28BIT_CAPACITY)
481 return (0);
482
483 /*
484 * Capacity is too big for 28-bits addressing. But, to make
485 * sure that the drive implements ATA-6 correctly, the
486 * final check: cap28 should be MAX for 28-bit addressing.
487 * If it's not, we shouldn't use 48-bit mode, so return
488 * the capacity reported in 28-bit capacity words.
489 */
490 if (cap28 != MAX_28BIT_CAPACITY)
491 return (0); /* not max, use 28-bit value */
492
493 /*
494 * All is well so return 48-bit capacity indicator
495 */
496 ADBG_INIT(("ATA: using 48-bit mode for capacity %llx blocks\n",
497 (unsigned long long)cap48));
498
499 *capacity = cap48;
500 return (AD_EXT48);
501 }
502
503 /*
504 * With the advent of disks that hold more than 31 GB, we run into a
505 * limitation in the sizes of the fields that describe the geometry.
506 * The cylinders, heads, and sectors-per-track are each described by a
507 * 16-bit number -- both in the structure returned from IDENTIFY
508 * DEVICE and in the structure returned from the DIOCTL_GETGEOM or
509 * DIOCTL_GETPHYGEOM ioctl.
510 *
511 * The typical disk has 32 heads per cylinder and 63 sectors per
512 * track. A 16 bit field can contain up to 65535. So the largest
513 * disk that can be described in these fields is 65535 * 32 * 63 * 512
514 * (bytes/sector), or about 31.5 GB. The cylinder count gets truncated
515 * when stored in a narrow field, so a 40GB disk appears to have only
516 * 8 GB!
517 *
518 * The solution (for the time being at least) is to lie about the
519 * geometry. If the number of cylinders is too large to fit in 16
520 * bits, we will halve the cylinders and double the heads, repeating
521 * until we can fit the geometry into 3 shorts.
522 * FUTURE ENHANCEMENT: If this ever isn't enough, we could
523 * add another step to double sectors/track as well.
524 */
525
526 static void
ata_fix_large_disk_geometry(ata_drv_t * ata_drvp)527 ata_fix_large_disk_geometry(
528 ata_drv_t *ata_drvp)
529 {
530 struct ata_id *aidp = &ata_drvp->ad_id;
531
532 /* no hope for large disks if LBA not supported */
533 if (!(ata_drvp->ad_drive_bits & ATDH_LBA))
534 return;
535
536 /*
537 * Fix up the geometry to be returned by DIOCTL_GETGEOM.
538 * If number of cylinders > USHRT_MAX, double heads and
539 * halve cylinders until everything fits.
540 */
541 while (ata_drvp->ad_drvrcyl > USHRT_MAX) {
542 int tempheads;
543
544 /* is there room in 16 bits to double the heads? */
545 tempheads = 2 * ata_drvp->ad_drvrhd;
546 if (tempheads > USHRT_MAX) {
547 /*
548 * No room to double the heads.
549 * I give up, there's no way to represent this.
550 * Limit disk size.
551 */
552 cmn_err(CE_WARN, "Disk is too large: "
553 "Model %s, Serial# %s Approximating...\n",
554 aidp->ai_model, aidp->ai_drvser);
555 ata_drvp->ad_drvrcyl = USHRT_MAX;
556 break;
557 }
558
559 /* OK, so double the heads and halve the cylinders */
560 ata_drvp->ad_drvrcyl /= 2;
561 ata_drvp->ad_drvrhd *= 2;
562 }
563 }
564
565 /*
566 * Calculate capacity using 28-bit capacity words from IDENTIFY DEVICE
567 * return words
568 */
569 uint64_t
ata_calculate_28bits_capacity(ata_drv_t * ata_drvp)570 ata_calculate_28bits_capacity(ata_drv_t *ata_drvp)
571 {
572 /*
573 * Asked x3t13 for advice; this implements Hale Landis'
574 * response, minus the "use ATA_INIT_DEVPARMS".
575 * See "capacity.notes".
576 */
577
578 /* some local shorthand/renaming to clarify the meaning */
579
580 ushort_t curcyls_w54, curhds_w55, cursect_w56;
581 uint32_t curcap_w57_58;
582
583 if ((ata_drvp->ad_drive_bits & ATDH_LBA) != 0) {
584 return ((uint64_t)(ata_drvp->ad_id.ai_addrsec[0] +
585 ata_drvp->ad_id.ai_addrsec[1] * 0x10000));
586 }
587
588 /*
589 * If we're not LBA, then first try to validate "current" values.
590 */
591
592 curcyls_w54 = ata_drvp->ad_id.ai_curcyls;
593 curhds_w55 = ata_drvp->ad_id.ai_curheads;
594 cursect_w56 = ata_drvp->ad_id.ai_cursectrk;
595 curcap_w57_58 = ata_drvp->ad_id.ai_cursccp[0] +
596 ata_drvp->ad_id.ai_cursccp[1] * 0x10000;
597
598 if (((ata_drvp->ad_id.ai_validinfo & 1) == 1) &&
599 (curhds_w55 >= 1) && (curhds_w55 <= 16) &&
600 (cursect_w56 >= 1) && (cursect_w56 <= 63) &&
601 (curcap_w57_58 == curcyls_w54 * curhds_w55 * cursect_w56)) {
602 return ((uint64_t)curcap_w57_58);
603 }
604
605 /*
606 * At this point, Hale recommends ATA_INIT_DEVPARMS.
607 * I don't want to do that, so simply use 1/3/6 as
608 * a final fallback, and continue to assume the BIOS
609 * has done whatever INIT_DEVPARMS are necessary.
610 */
611
612 return ((uint64_t)(ata_drvp->ad_id.ai_fixcyls *
613 ata_drvp->ad_id.ai_heads * ata_drvp->ad_id.ai_sectors));
614 }
615
616 /*
617 * Calculate capacity using 48-bits capacity words from IDENTIFY DEVICE
618 * return words
619 */
620 uint64_t
ata_calculate_48bits_capacity(ata_drv_t * ata_drvp)621 ata_calculate_48bits_capacity(ata_drv_t *ata_drvp)
622 {
623 uint64_t cap48 = 0;
624 int i;
625
626 for (i = 3; i >= 0; --i) {
627 cap48 <<= 16;
628 cap48 += ata_drvp->ad_id.ai_addrsecxt[i];
629 }
630 return (cap48);
631 }
632
633
634 /*
635 *
636 * Setup the drives Read/Write Multiple Blocking factor and the
637 * current translation geometry. Necessary during attach and after
638 * Software Resets.
639 *
640 */
641
642 int
ata_disk_setup_parms(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp)643 ata_disk_setup_parms(
644 ata_ctl_t *ata_ctlp,
645 ata_drv_t *ata_drvp)
646 {
647
648 /*
649 * program geometry info back to the drive
650 */
651 if (!ata_disk_initialize_device_parameters(ata_ctlp, ata_drvp)) {
652 return (FALSE);
653 }
654
655 /*
656 * Determine the blocking factor
657 */
658 if (ata_drvp->ad_block_factor > 1) {
659 /*
660 * Program the block factor into the drive. If this
661 * fails, then go back to using a block size of 1.
662 */
663 if (!ata_disk_set_multiple(ata_ctlp, ata_drvp))
664 ata_drvp->ad_block_factor = 1;
665 }
666
667
668 if (ata_drvp->ad_block_factor > 1) {
669 ata_drvp->ad_rd_cmd = ATC_RDMULT;
670 ata_drvp->ad_wr_cmd = ATC_WRMULT;
671 } else {
672 ata_drvp->ad_rd_cmd = ATC_RDSEC;
673 ata_drvp->ad_wr_cmd = ATC_WRSEC;
674 }
675
676 ata_drvp->ad_bytes_per_block = ata_drvp->ad_block_factor << SCTRSHFT;
677
678 ADBG_INIT(("set block factor for drive %d to %d\n",
679 ata_drvp->ad_targ, ata_drvp->ad_block_factor));
680
681 if (ata_disk_do_standby_timer)
682 ata_disk_set_standby_timer(ata_ctlp, ata_drvp);
683
684 ata_set_write_cache(ata_ctlp, ata_drvp);
685
686 return (TRUE);
687 }
688
689
690 /*
691 * Take the timeout value specified in the "standby" property
692 * and convert from seconds to the magic parm expected by the
693 * the drive. Then issue the IDLE command to set the drive's
694 * internal standby timer.
695 */
696
697 static void
ata_disk_set_standby_timer(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp)698 ata_disk_set_standby_timer(
699 ata_ctl_t *ata_ctlp,
700 ata_drv_t *ata_drvp)
701 {
702 uchar_t parm;
703 int timeout = ata_ctlp->ac_standby_time;
704
705 /*
706 * take the timeout value, specificed in seconds, and
707 * encode it into the proper command parm
708 */
709
710 /*
711 * don't change it if no property specified or if
712 * the specified value is out of range
713 */
714 if (timeout < 0 || timeout > (12 * 60 * 60))
715 return;
716
717 /* 1 to 1200 seconds (20 minutes) == N * 5 seconds */
718 if (timeout <= (240 * 5))
719 parm = (timeout + 4) / 5;
720
721 /* 20 to 21 minutes == 21 minutes */
722 else if (timeout <= (21 * 60))
723 parm = 252;
724
725 /* 21 minutes to 21 minutes 15 seconds == 21:15 */
726 else if (timeout <= ((21 * 60) + 15))
727 parm = 255;
728
729 /* 21:15 to 330 minutes == N * 30 minutes */
730 else if (timeout <= (11 * 30 * 60))
731 parm = 240 + ((timeout + (30 * 60) - 1)/ (30 * 60));
732
733 /* > 330 minutes == 8 to 12 hours */
734 else
735 parm = 253;
736
737 (void) ata_command(ata_ctlp, ata_drvp, TRUE, FALSE, 5 * 1000000,
738 ATC_IDLE, 0, parm, 0, 0, 0, 0);
739 }
740
741
742
743 /*
744 *
745 * destroy an ata disk drive
746 *
747 */
748
749 void
ata_disk_uninit_drive(ata_drv_t * ata_drvp)750 ata_disk_uninit_drive(
751 ata_drv_t *ata_drvp)
752 {
753 struct scsi_device *devp = ata_drvp->ad_device;
754
755 ADBG_TRACE(("ata_disk_uninit_drive entered\n"));
756
757 if (devp) {
758 if (ata_drvp->ad_flags & AD_MUTEX_INIT)
759 mutex_destroy(&devp->sd_mutex);
760 ata_drvp->ad_device = NULL;
761 kmem_free(devp, scsi_device_size());
762 }
763 }
764
765
766
767
768 /*
769 *
770 * DADA compliant bus_ctl entry point
771 *
772 */
773
774 /*ARGSUSED*/
775 int
ata_disk_bus_ctl(dev_info_t * d,dev_info_t * r,ddi_ctl_enum_t o,void * a,void * v)776 ata_disk_bus_ctl(dev_info_t *d, dev_info_t *r, ddi_ctl_enum_t o,
777 void *a, void *v)
778 {
779 ADBG_TRACE(("ata_disk_bus_ctl entered\n"));
780
781 switch (o) {
782
783 case DDI_CTLOPS_REPORTDEV:
784 {
785 int targ;
786
787 targ = ddi_prop_get_int(DDI_DEV_T_ANY, r, DDI_PROP_DONTPASS,
788 "target", 0);
789 cmn_err(CE_CONT, "?%s%d at %s%d target %d lun %d\n",
790 ddi_driver_name(r), ddi_get_instance(r),
791 ddi_driver_name(d), ddi_get_instance(d), targ, 0);
792 return (DDI_SUCCESS);
793 }
794 case DDI_CTLOPS_INITCHILD:
795 {
796 dev_info_t *cdip = (dev_info_t *)a;
797 ata_drv_t *ata_drvp;
798 ata_ctl_t *ata_ctlp;
799 ata_tgt_t *ata_tgtp;
800 struct scsi_device *devp;
801 struct ctl_obj *ctlobjp;
802 gtgt_t *gtgtp;
803 char name[MAXNAMELEN];
804
805 /*
806 * save time by picking up ptr to drive struct left
807 * by ata_bus_ctl - isn't that convenient.
808 */
809 ata_drvp = ddi_get_driver_private(cdip);
810 ata_ctlp = ata_drvp->ad_ctlp;
811
812 /* set up pointers to child dip */
813
814 devp = ata_drvp->ad_device;
815 /*
816 * If sd_dev is set, it means that the target has already
817 * being initialized. The cdip is a duplicate node from
818 * reexpansion of driver.conf. Fail INITCHILD here.
819 */
820 if ((devp == NULL) || (devp->sd_dev != NULL)) {
821 return (DDI_FAILURE);
822 }
823 devp->sd_dev = cdip;
824
825 ctlobjp = &ata_drvp->ad_ctl_obj;
826 ctlobjp->c_extblk.c_devdip = cdip;
827
828 /*
829 * Create the "ata" property for use by the target driver
830 */
831 if (!ata_prop_create(cdip, ata_drvp, "ata")) {
832 return (DDI_FAILURE);
833 }
834
835 gtgtp = ghd_target_init(d, cdip, &ata_ctlp->ac_ccc,
836 sizeof (ata_tgt_t), ata_ctlp,
837 ata_drvp->ad_targ, ata_drvp->ad_lun);
838
839 /* gt_tgt_private points to ata_tgt_t */
840 ata_tgtp = GTGTP2ATATGTP(gtgtp);
841 ata_tgtp->at_drvp = ata_drvp;
842 ata_tgtp->at_dma_attr = ata_pciide_dma_attr;
843 ata_tgtp->at_dma_attr.dma_attr_maxxfer =
844 ata_ctlp->ac_max_transfer << SCTRSHFT;
845
846 /* gtgtp is the opaque arg to all my entry points */
847 ctlobjp->c_data = gtgtp;
848
849 /* create device name */
850
851 (void) sprintf(name, "%x,%x", ata_drvp->ad_targ,
852 ata_drvp->ad_lun);
853 ddi_set_name_addr(cdip, name);
854 ddi_set_driver_private(cdip, devp);
855
856 return (DDI_SUCCESS);
857 }
858
859 case DDI_CTLOPS_UNINITCHILD:
860 {
861 dev_info_t *cdip = (dev_info_t *)a;
862 struct scsi_device *devp;
863 struct ctl_obj *ctlobjp;
864 gtgt_t *gtgtp;
865
866 devp = ddi_get_driver_private(cdip);
867 ctlobjp = (struct ctl_obj *)devp->sd_address.a_hba_tran;
868 gtgtp = ctlobjp->c_data;
869
870 ghd_target_free(d, cdip, >GTP2ATAP(gtgtp)->ac_ccc, gtgtp);
871
872 ddi_set_driver_private(cdip, NULL);
873 ddi_set_name_addr(cdip, NULL);
874 return (DDI_SUCCESS);
875 }
876
877 default:
878 return (DDI_FAILURE);
879 }
880 }
881
882
883 /*
884 *
885 * DADA abort entry point - not currently used by dadk
886 *
887 */
888
889 /* ARGSUSED */
890 static int
ata_disk_abort(opaque_t ctl_data,cmpkt_t * pktp)891 ata_disk_abort(opaque_t ctl_data, cmpkt_t *pktp)
892 {
893 ADBG_TRACE(("ata_disk_abort entered\n"));
894
895 /* XXX - Note that this interface is currently not used by dadk */
896
897 /*
898 * GHD abort functions take a pointer to a scsi_address
899 * and so they're unusable here. The ata driver used to
900 * return DDI_SUCCESS here without doing anything. Its
901 * seems that DDI_FAILURE is more appropriate.
902 */
903
904 return (DDI_FAILURE);
905 }
906
907
908
909 /*
910 *
911 * DADA reset entry point - not currently used by dadk
912 * (except in debug versions of driver)
913 *
914 */
915
916 /* ARGSUSED */
917 static int
ata_disk_reset(opaque_t ctl_data,int level)918 ata_disk_reset(opaque_t ctl_data, int level)
919 {
920 gtgt_t *gtgtp = (gtgt_t *)ctl_data;
921 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp);
922 int rc;
923
924 ADBG_TRACE(("ata_disk_reset entered\n"));
925
926 /* XXX - Note that this interface is currently not used by dadk */
927
928 switch (level) {
929 case RESET_TARGET:
930 rc = ghd_tran_reset_target(&ata_drvp->ad_ctlp->ac_ccc, gtgtp,
931 NULL);
932 break;
933 case RESET_ALL:
934 rc = ghd_tran_reset_bus(&ata_drvp->ad_ctlp->ac_ccc, gtgtp,
935 NULL);
936 break;
937 default:
938 rc = 0;
939 }
940
941 return (rc ? DDI_SUCCESS : DDI_FAILURE);
942 }
943
944
945
946 /*
947 *
948 * DADA ioctl entry point
949 *
950 */
951
952 /* ARGSUSED */
953 static int
ata_disk_ioctl(opaque_t ctl_data,int cmd,intptr_t arg,int flag)954 ata_disk_ioctl(opaque_t ctl_data, int cmd, intptr_t arg, int flag)
955 {
956 gtgt_t *gtgtp = (gtgt_t *)ctl_data;
957 ata_ctl_t *ata_ctlp = GTGTP2ATAP(gtgtp);
958 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp);
959 int rc, rc2;
960 struct tgdk_geom tgdk;
961 int wce;
962 struct ata_id *aidp = &ata_drvp->ad_id;
963 dk_updatefw_t updatefw;
964 #ifdef _MULTI_DATAMODEL
965 dk_updatefw_32_t updatefw32;
966 #endif
967 dk_disk_id_t dk_disk_id;
968 char buf[80];
969 int i;
970
971
972 ADBG_TRACE(("ata_disk_ioctl entered, cmd = %d\n", cmd));
973
974 switch (cmd) {
975
976 case DIOCTL_GETGEOM:
977 case DIOCTL_GETPHYGEOM:
978 tgdk.g_cyl = ata_drvp->ad_drvrcyl;
979 tgdk.g_head = ata_drvp->ad_drvrhd;
980 tgdk.g_sec = ata_drvp->ad_drvrsec;
981 tgdk.g_acyl = ata_drvp->ad_acyl;
982 tgdk.g_secsiz = 512;
983 tgdk.g_cap = (diskaddr_t)tgdk.g_cyl * tgdk.g_head * tgdk.g_sec;
984 if (ddi_copyout(&tgdk, (caddr_t)arg, sizeof (tgdk), flag))
985 return (EFAULT);
986 return (0);
987
988 case DCMD_UPDATE_GEOM:
989 /*
990 * ??? fix this to issue IDENTIFY DEVICE ???
991 * might not be necessary since I don't know of any ATA/IDE that
992 * can change its geometry. On the other hand, ATAPI devices like the
993 * LS-120 or PD/CD can change their geometry when new media is inserted
994 */
995 return (0);
996
997 /* copy the model number into the caller's buffer */
998 case DIOCTL_GETMODEL:
999 rc = ata_copy_dk_ioc_string(arg, aidp->ai_model,
1000 sizeof (aidp->ai_model), flag);
1001 return (rc);
1002
1003 /* copy the serial number into the caller's buffer */
1004 case DIOCTL_GETSERIAL:
1005 rc = ata_copy_dk_ioc_string(arg, aidp->ai_drvser,
1006 sizeof (aidp->ai_drvser), flag);
1007 return (rc);
1008
1009 case DIOCTL_GETWCE:
1010 /*
1011 * WCE is only supported in ATAPI-4 or higher, for
1012 * lower rev devices, must assume write cache is
1013 * enabled.
1014 * NOTE: Since there is currently no Solaris mechanism
1015 * to change the state of the Write Cache Enable feature,
1016 * this code just checks the value of the WCE bit
1017 * obtained at device init time. If a mechanism
1018 * is added to the driver to change WCE, this code
1019 * must be updated appropriately.
1020 */
1021 wce = (aidp->ai_majorversion == 0xffff) ||
1022 ((aidp->ai_majorversion & ATAC_MAJVER_4) == 0) ||
1023 (aidp->ai_features85 & ATAC_FEATURES85_WCE) != 0;
1024
1025 if (ddi_copyout(&wce, (caddr_t)arg, sizeof (wce), flag) != 0)
1026 return (EFAULT);
1027
1028 return (0);
1029
1030 case DCMD_GET_STATE:
1031 rc = ata_queue_cmd(ata_disk_state, NULL, ata_ctlp, ata_drvp,
1032 gtgtp);
1033 break;
1034
1035 case DCMD_LOCK:
1036 case DKIOCLOCK:
1037 rc = ata_queue_cmd(ata_disk_lock, NULL, ata_ctlp, ata_drvp,
1038 gtgtp);
1039 break;
1040
1041 case DCMD_UNLOCK:
1042 case DKIOCUNLOCK:
1043 rc = ata_queue_cmd(ata_disk_unlock, NULL, ata_ctlp, ata_drvp,
1044 gtgtp);
1045 break;
1046
1047 case DCMD_START_MOTOR:
1048 case CDROMSTART:
1049 rc = ata_queue_cmd(ata_disk_recalibrate, NULL, ata_ctlp,
1050 ata_drvp, gtgtp);
1051 break;
1052
1053 case DCMD_STOP_MOTOR:
1054 case CDROMSTOP:
1055 rc = ata_queue_cmd(ata_disk_standby, NULL, ata_ctlp, ata_drvp,
1056 gtgtp);
1057 break;
1058
1059 case DKIOCEJECT:
1060 case CDROMEJECT:
1061 rc = ata_queue_cmd(ata_disk_eject, NULL, ata_ctlp, ata_drvp,
1062 gtgtp);
1063 break;
1064
1065 case DKIOC_UPDATEFW:
1066
1067 /*
1068 * Call DOWNLOAD MICROCODE command to update device
1069 * firmware.
1070 *
1071 * return value:
1072 * normal 0 Download microcode success
1073 * error EFAULT Bad address
1074 * ENXIO No such device or address
1075 * EINVAL Invalid argument
1076 * ENOMEM Not enough core
1077 * ENOTSUP Operation not supported
1078 * EIO I/O error
1079 * EPERM Not owner
1080 */
1081
1082 /*
1083 * The following code deals with handling 32-bit request
1084 * in 64-bit kernel.
1085 */
1086 #ifdef _MULTI_DATAMODEL
1087 if (ddi_model_convert_from(flag & FMODELS) ==
1088 DDI_MODEL_ILP32) {
1089 if (ddi_copyin((void *)arg, &updatefw32,
1090 sizeof (dk_updatefw_32_t), flag))
1091 return (EFAULT);
1092
1093 updatefw.dku_ptrbuf =
1094 (caddr_t)(uintptr_t)updatefw32.dku_ptrbuf;
1095 updatefw.dku_size = updatefw32.dku_size;
1096 updatefw.dku_type = updatefw32.dku_type;
1097 } else {
1098 if (ddi_copyin((void *)arg, &updatefw,
1099 sizeof (dk_updatefw_t), flag))
1100 return (EFAULT);
1101 }
1102 #else
1103 if (ddi_copyin((void *)arg, &updatefw,
1104 sizeof (dk_updatefw_t), flag))
1105 return (EFAULT);
1106 #endif
1107 rc = ata_disk_update_fw(gtgtp, ata_ctlp, ata_drvp,
1108 updatefw.dku_ptrbuf, updatefw.dku_size,
1109 updatefw.dku_type, flag);
1110
1111 /*
1112 * According to ATA8-ACS spec, the new microcode should
1113 * become effective immediately after the transfer of the
1114 * last data segment has completed, so here we will call
1115 * IDENTIFY DEVICE command immediately to update
1116 * ata_id content when success.
1117 */
1118 if (rc == 0) {
1119 rc2 = ata_queue_cmd(ata_disk_id_update, NULL,
1120 ata_ctlp, ata_drvp, gtgtp);
1121 if (rc2 != TRUE) {
1122 return (ENXIO);
1123 } else {
1124 /*
1125 * Check whether the content of the IDENTIFY
1126 * DEVICE data is incomplete, if yes, it's
1127 * because the device supports the Power-up
1128 * in Standby feature set, and we will first
1129 * check word 2, and then decide whether need
1130 * to call set feature to spin-up the device,
1131 * and then call IDENTIFY DEVICE command again.
1132 */
1133 aidp = &ata_drvp->ad_id;
1134 if (aidp->ai_config & ATA_ID_INCMPT) {
1135 if (aidp->ai_resv0 == 0x37c8 ||
1136 aidp->ai_resv0 == 0x738c) {
1137 /* Spin-up the device */
1138 (void) ata_queue_cmd(
1139 ata_disk_set_feature_spinup,
1140 NULL,
1141 ata_ctlp,
1142 ata_drvp,
1143 gtgtp);
1144 }
1145
1146 /* Try to update ata_id again */
1147 rc2 = ata_queue_cmd(
1148 ata_disk_id_update,
1149 NULL,
1150 ata_ctlp,
1151 ata_drvp,
1152 gtgtp);
1153 if (rc2 != TRUE) {
1154 return (ENXIO);
1155 } else {
1156 aidp = &ata_drvp->ad_id;
1157 if (aidp->ai_config &
1158 ATA_ID_INCMPT)
1159 return (ENXIO);
1160 }
1161 }
1162
1163 /*
1164 * Dump the drive information.
1165 */
1166 ATAPRT(("?\tUpdate firmware of %s device at "
1167 "targ %d, lun %d lastlun 0x%x\n",
1168 (ATAPIDRV(ata_drvp) ? "ATAPI":"IDE"),
1169 ata_drvp->ad_targ, ata_drvp->ad_lun,
1170 aidp->ai_lastlun));
1171
1172 (void) strncpy(buf, aidp->ai_model,
1173 sizeof (aidp->ai_model));
1174 buf[sizeof (aidp->ai_model)] = '\0';
1175 for (i = sizeof (aidp->ai_model) - 1;
1176 buf[i] == ' '; i--)
1177 buf[i] = '\0';
1178 ATAPRT(("?\tmodel %s\n", buf));
1179
1180 (void) strncpy(buf, aidp->ai_fw,
1181 sizeof (aidp->ai_fw));
1182 buf[sizeof (aidp->ai_fw)] = '\0';
1183 for (i = sizeof (aidp->ai_fw) - 1;
1184 buf[i] == ' '; i--)
1185 buf[i] = '\0';
1186 ATAPRT(("?\tfw %s\n", buf));
1187 }
1188 }
1189 return (rc);
1190
1191 case DKIOC_GETDISKID:
1192 bzero(&dk_disk_id, sizeof (dk_disk_id_t));
1193
1194 dk_disk_id.dkd_dtype = DKD_ATA_TYPE;
1195
1196 /* Get the model number */
1197 (void) strncpy(dk_disk_id.disk_id.ata_disk_id.dkd_amodel,
1198 aidp->ai_model, sizeof (aidp->ai_model));
1199
1200 /* Get the firmware revision */
1201 (void) strncpy(dk_disk_id.disk_id.ata_disk_id.dkd_afwver,
1202 aidp->ai_fw, sizeof (aidp->ai_fw));
1203
1204 /* Get the serial number */
1205 (void) strncpy(dk_disk_id.disk_id.ata_disk_id.dkd_aserial,
1206 aidp->ai_drvser, sizeof (aidp->ai_drvser));
1207
1208 if (ddi_copyout(&dk_disk_id, (void *)arg,
1209 sizeof (dk_disk_id_t), flag))
1210 return (EFAULT);
1211 else
1212 return (0);
1213
1214 default:
1215 ADBG_WARN(("ata_disk_ioctl: unsupported cmd 0x%x\n", cmd));
1216 return (ENOTTY);
1217 }
1218
1219 if (rc)
1220 return (0);
1221 return (ENXIO);
1222
1223 }
1224
1225
1226 #ifdef ___not___used___
1227 /*
1228 * Issue an ATA command to the drive using the packet already
1229 * allocated by the target driver
1230 */
1231
1232 int
ata_disk_do_ioctl(int (* func)(ata_ctl_t *,ata_drv_t *,ata_pkt_t *),void * arg,ata_ctl_t * ata_ctlp,gtgt_t * gtgtp,cmpkt_t * pktp)1233 ata_disk_do_ioctl(int (*func)(ata_ctl_t *, ata_drv_t *, ata_pkt_t *),
1234 void *arg, ata_ctl_t *ata_ctlp, gtgt_t *gtgtp, cmpkt_t *pktp)
1235 {
1236 gcmd_t *gcmdp = CPKT2GCMD(pktp);
1237 ata_pkt_t *ata_pktp = GCMD2APKT(gcmdp);
1238 int rc;
1239
1240 ata_pktp->ap_start = func;
1241 ata_pktp->ap_intr = NULL;
1242 ata_pktp->ap_complete = NULL;
1243 ata_pktp->ap_v_addr = (caddr_t)arg;
1244
1245 /*
1246 * add it to the queue, when it gets to the front the
1247 * ap_start function is called.
1248 */
1249 rc = ghd_transport(&ata_ctlp->ac_ccc, gcmdp, gcmdp->cmd_gtgtp,
1250 0, TRUE, NULL);
1251
1252 if (rc != TRAN_ACCEPT) {
1253 /* this should never, ever happen */
1254 return (ENXIO);
1255 }
1256
1257 if (ata_pktp->ap_flags & AP_ERROR)
1258 return (ENXIO);
1259 return (0);
1260 }
1261 #endif
1262
1263
1264
1265 /*
1266 *
1267 * DADA pktalloc entry point
1268 *
1269 */
1270
1271 /* ARGSUSED */
1272 static cmpkt_t *
ata_disk_pktalloc(opaque_t ctl_data,int (* callback)(caddr_t),caddr_t arg)1273 ata_disk_pktalloc(opaque_t ctl_data, int (*callback)(caddr_t), caddr_t arg)
1274 {
1275 gtgt_t *gtgtp = (gtgt_t *)ctl_data;
1276 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp);
1277 cmpkt_t *pktp;
1278 ata_pkt_t *ata_pktp;
1279 gcmd_t *gcmdp;
1280
1281 ADBG_TRACE(("ata_disk_pktalloc entered\n"));
1282
1283 /*
1284 * Allocate and init the GHD gcmd_t structure and the
1285 * DADA cmpkt and the ata_pkt
1286 */
1287 if ((gcmdp = ghd_gcmd_alloc(gtgtp,
1288 (sizeof (cmpkt_t) + sizeof (ata_pkt_t)),
1289 (callback == DDI_DMA_SLEEP))) == NULL) {
1290 return ((cmpkt_t *)NULL);
1291 }
1292 ASSERT(gcmdp != NULL);
1293
1294 ata_pktp = GCMD2APKT(gcmdp);
1295 ASSERT(ata_pktp != NULL);
1296
1297 pktp = (cmpkt_t *)(ata_pktp + 1);
1298
1299 pktp->cp_ctl_private = (void *)gcmdp;
1300 ata_pktp->ap_gcmdp = gcmdp;
1301 gcmdp->cmd_pktp = (void *)pktp;
1302
1303 /*
1304 * At this point the structures are linked like this:
1305 *
1306 * (struct cmpkt) <--> (struct gcmd) <--> (struct ata_pkt)
1307 */
1308
1309 /* callback functions */
1310
1311 ata_pktp->ap_start = ata_disk_start;
1312 ata_pktp->ap_intr = ata_disk_intr;
1313 ata_pktp->ap_complete = ata_disk_complete;
1314
1315 /* other ata_pkt setup */
1316
1317 ata_pktp->ap_bytes_per_block = ata_drvp->ad_bytes_per_block;
1318
1319 /* cmpkt setup */
1320
1321 pktp->cp_cdblen = 1;
1322 pktp->cp_cdbp = (opaque_t)&ata_pktp->ap_cdb;
1323 pktp->cp_scbp = (opaque_t)&ata_pktp->ap_scb;
1324 pktp->cp_scblen = 1;
1325
1326 return (pktp);
1327 }
1328
1329
1330
1331 /*
1332 *
1333 * DADA pktfree entry point
1334 *
1335 */
1336
1337 /* ARGSUSED */
1338 static void
ata_disk_pktfree(opaque_t ctl_data,cmpkt_t * pktp)1339 ata_disk_pktfree(opaque_t ctl_data, cmpkt_t *pktp)
1340 {
1341 ata_pkt_t *ata_pktp = CPKT2APKT(pktp);
1342
1343 ADBG_TRACE(("ata_disk_pktfree entered\n"));
1344
1345 /* check not free already */
1346
1347 ASSERT(!(ata_pktp->ap_flags & AP_FREE));
1348 ata_pktp->ap_flags = AP_FREE;
1349
1350 ghd_gcmd_free(CPKT2GCMD(pktp));
1351 }
1352
1353
1354 /*
1355 *
1356 * DADA memsetup entry point
1357 *
1358 */
1359
1360 /* ARGSUSED */
1361 static cmpkt_t *
ata_disk_memsetup(opaque_t ctl_data,cmpkt_t * pktp,struct buf * bp,int (* callback)(caddr_t),caddr_t arg)1362 ata_disk_memsetup(
1363 opaque_t ctl_data,
1364 cmpkt_t *pktp,
1365 struct buf *bp,
1366 int (*callback)(caddr_t),
1367 caddr_t arg)
1368 {
1369 gtgt_t *gtgtp = (gtgt_t *)ctl_data;
1370 ata_pkt_t *ata_pktp = CPKT2APKT(pktp);
1371 gcmd_t *gcmdp = APKT2GCMD(ata_pktp);
1372 int flags;
1373
1374 ADBG_TRACE(("ata_disk_memsetup entered\n"));
1375
1376 ata_pktp->ap_sg_cnt = 0;
1377
1378 if (bp->b_bcount == 0) {
1379 ata_pktp->ap_v_addr = NULL;
1380 return (pktp);
1381 }
1382
1383 if (GTGTP2ATADRVP(gtgtp)->ad_pciide_dma != ATA_DMA_ON)
1384 goto skip_dma_setup;
1385
1386 if (ata_dma_disabled)
1387 goto skip_dma_setup;
1388
1389 /*
1390 * The PCI-IDE DMA engine is brain-damaged and can't
1391 * DMA non-aligned buffers.
1392 */
1393 if (!(bp->b_flags & B_PAGEIO) &&
1394 ((uintptr_t)bp->b_un.b_addr) & PCIIDE_PRDE_ADDR_MASK) {
1395 goto skip_dma_setup;
1396 }
1397
1398 /*
1399 * It also insists that the byte count must be even.
1400 */
1401 if (bp->b_bcount & 1)
1402 goto skip_dma_setup;
1403
1404 /* check direction for data transfer */
1405 if (bp->b_flags & B_READ) {
1406 flags = DDI_DMA_READ | DDI_DMA_PARTIAL;
1407 } else {
1408 flags = DDI_DMA_WRITE | DDI_DMA_PARTIAL;
1409 }
1410
1411 /*
1412 * Bind the DMA handle to the buf
1413 */
1414 if (ghd_dma_buf_bind_attr(>GTP2ATAP(gtgtp)->ac_ccc, gcmdp, bp, flags,
1415 callback, arg, >GTP2ATATGTP(gtgtp)->at_dma_attr)) {
1416 ata_pktp->ap_v_addr = 0;
1417 return (pktp);
1418 }
1419
1420 skip_dma_setup:
1421 bp_mapin(bp);
1422 ata_pktp->ap_v_addr = bp->b_un.b_addr;
1423 return (pktp);
1424 }
1425
1426
1427
1428 /*
1429 *
1430 * DADA memfree entry point
1431 *
1432 */
1433
1434 /*
1435 * 1157317 sez that drivers shouldn't call bp_mapout(), as either
1436 * biodone() or biowait() will end up doing it, but after they
1437 * call bp->b_iodone(), which is a necessary sequence for
1438 * Online Disk Suite. However, the DDI group wants to rethink
1439 * bp_mapin()/bp_mapout() and how they should behave in the
1440 * presence of layered drivers, etc. For the moment, fix
1441 * the OLDS problem by removing the bp_mapout() call.
1442 */
1443
1444 #define BUG_1157317
1445
1446 /* ARGSUSED */
1447 static void
ata_disk_memfree(opaque_t ctl_data,cmpkt_t * pktp)1448 ata_disk_memfree(opaque_t ctl_data, cmpkt_t *pktp)
1449 {
1450 gcmd_t *gcmdp = CPKT2GCMD(pktp);
1451
1452 ADBG_TRACE(("ata_disk_memfree entered\n"));
1453
1454 if (gcmdp->cmd_dma_handle)
1455 ghd_dmafree_attr(gcmdp);
1456 #if !defined(BUG_1157317)
1457 else
1458 bp_mapout(pktp->cp_bp);
1459 #endif
1460 }
1461
1462
1463
1464 /*
1465 *
1466 * DADA iosetup entry point
1467 *
1468 */
1469
1470 static cmpkt_t *
ata_disk_iosetup(opaque_t ctl_data,cmpkt_t * pktp)1471 ata_disk_iosetup(opaque_t ctl_data, cmpkt_t *pktp)
1472 {
1473 gtgt_t *gtgtp = (gtgt_t *)ctl_data;
1474 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp);
1475 ata_pkt_t *ata_pktp = CPKT2APKT(pktp);
1476 gcmd_t *gcmdp = APKT2GCMD(ata_pktp);
1477 uint_t sec_count;
1478 daddr_t start_sec;
1479 uint_t byte_count;
1480
1481 ADBG_TRACE(("ata_disk_iosetup entered\n"));
1482
1483 /*
1484 * Check for DCMD_FLUSH_CACHE (which does no I/O) and
1485 * just do basic setup.
1486 */
1487 if (pktp->cp_passthru == NULL &&
1488 ata_pktp->ap_cdb == DCMD_FLUSH_CACHE) {
1489 ata_pktp->ap_cmd = ATC_FLUSH_CACHE;
1490 ata_pktp->ap_flags = 0;
1491 ata_pktp->ap_count = 0;
1492 ata_pktp->ap_startsec = 0;
1493 ata_pktp->ap_sg_cnt = 0;
1494 ata_pktp->ap_pciide_dma = FALSE;
1495 return (pktp);
1496 }
1497
1498 /* check for error retry */
1499 if (ata_pktp->ap_flags & AP_ERROR) {
1500 /*
1501 * this is a temporary work-around for dadk calling
1502 * iosetup for retry. The correct
1503 * solution is changing dadk to not to call iosetup
1504 * for a retry.
1505 * We do not apply the work-around for pio mode since
1506 * that does not involve moving dma windows and reducing the
1507 * sector count would work for pio mode on a retry
1508 * for now.
1509 */
1510 if (gcmdp->cmd_dma_handle != NULL) {
1511 ata_pktp->ap_flags = 0;
1512 return (NULL);
1513 }
1514
1515 ata_pktp->ap_bytes_per_block = NBPSCTR;
1516 sec_count = 1;
1517
1518 /*
1519 * Since we are retrying the last read or write operation,
1520 * restore the old values of the ap_v_addr and ap_resid.
1521 * This assumes CTL_IOSETUP is called again on retry; if not,
1522 * this needs to be done in CTL_TRANSPORT.
1523 */
1524 if (ata_pktp->ap_flags & (AP_READ | AP_WRITE)) {
1525 ata_pktp->ap_v_addr = ata_pktp->ap_v_addr_sav;
1526 ata_pktp->ap_resid = ata_pktp->ap_resid_sav;
1527 }
1528 } else {
1529 /*
1530 * Limit request to ac_max_transfer sectors.
1531 * The value is specified by the user in the
1532 * max_transfer property. It must be in the range 1 to 256.
1533 * When max_transfer is 0x100 it is bigger than 8 bits.
1534 * The spec says 0 represents 256 so it should be OK.
1535 */
1536 sec_count = min((pktp->cp_bytexfer >> SCTRSHFT),
1537 ata_drvp->ad_ctlp->ac_max_transfer);
1538 /*
1539 * Save the current values of ap_v_addr and ap_resid
1540 * in case a retry operation happens. During a retry
1541 * operation we need to restore these values.
1542 */
1543 ata_pktp->ap_v_addr_sav = ata_pktp->ap_v_addr;
1544 ata_pktp->ap_resid_sav = ata_pktp->ap_resid;
1545 }
1546
1547 /* reset flags */
1548 ata_pktp->ap_flags = 0;
1549
1550 #ifdef DADKIO_RWCMD_READ
1551 start_sec = pktp->cp_passthru ? RWCMDP(pktp)->blkaddr : pktp->cp_srtsec;
1552 #else
1553 start_sec = pktp->cp_srtsec;
1554 #endif
1555
1556 /*
1557 * Setup the PCIDE Bus Master Scatter/Gather list
1558 */
1559 ata_pktp->ap_sg_cnt = 0;
1560 ata_pktp->ap_pciide_dma = FALSE;
1561 if (gcmdp->cmd_dma_handle != NULL && sec_count != 0) {
1562 byte_count = sec_count << SCTRSHFT;
1563 if ((ghd_dmaget_attr(>GTP2ATAP(gtgtp)->ac_ccc, gcmdp,
1564 byte_count, ATA_DMA_NSEGS, &byte_count) == FALSE) ||
1565 (byte_count == 0)) {
1566 ADBG_ERROR(("ata_disk_iosetup: byte count zero\n"));
1567 return (NULL);
1568 }
1569 sec_count = byte_count >> SCTRSHFT;
1570 }
1571
1572 /*
1573 * In the non-48-bit mode addressing (CHS and LBA28) the sector
1574 * count is a 8-bit value and the sector count 0 represents 256
1575 * sectors.
1576 * In the extended addressing (LBA48) the sector count is a 16-bit
1577 * value, so max_transfer 0x100 cannot be truncated to 8-bits
1578 * because this would represent a zero sector count.
1579 */
1580 ata_pktp->ap_count = (ushort_t)sec_count;
1581 if (!(ata_drvp->ad_flags & AD_EXT48)) {
1582 ata_pktp->ap_count &= 0xff;
1583 }
1584 ata_pktp->ap_startsec = start_sec;
1585
1586 #ifdef DADKIO_RWCMD_READ
1587 if (pktp->cp_passthru) {
1588 switch (RWCMDP(pktp)->cmd) {
1589 case DADKIO_RWCMD_READ:
1590 if (ata_pktp->ap_sg_cnt) {
1591 ata_pktp->ap_cmd = ATC_READ_DMA;
1592 ata_pktp->ap_pciide_dma = TRUE;
1593 ata_pktp->ap_start = ata_disk_start_dma_in;
1594 ata_pktp->ap_intr = ata_disk_intr_dma;
1595 } else {
1596 ata_pktp->ap_cmd = ATC_RDSEC;
1597 ata_pktp->ap_start = ata_disk_start_pio_in;
1598 ata_pktp->ap_intr = ata_disk_intr_pio_in;
1599 }
1600 ata_pktp->ap_flags |= AP_READ;
1601 break;
1602 case DADKIO_RWCMD_WRITE:
1603 if (ata_pktp->ap_sg_cnt) {
1604 ata_pktp->ap_cmd = ATC_WRITE_DMA;
1605 ata_pktp->ap_pciide_dma = TRUE;
1606 ata_pktp->ap_start = ata_disk_start_dma_out;
1607 ata_pktp->ap_intr = ata_disk_intr_dma;
1608 } else {
1609 ata_pktp->ap_cmd = ATC_WRSEC;
1610 ata_pktp->ap_start = ata_disk_start_pio_out;
1611 ata_pktp->ap_intr = ata_disk_intr_pio_out;
1612 }
1613 ata_pktp->ap_flags |= AP_WRITE;
1614 break;
1615 }
1616
1617 byte_count = RWCMDP(pktp)->buflen;
1618 pktp->cp_bytexfer = byte_count;
1619 pktp->cp_resid = byte_count;
1620 ata_pktp->ap_resid = byte_count;
1621
1622 /*
1623 * since we're not using READ/WRITE MULTIPLE, we
1624 * should set bytes_per_block to one sector
1625 * XXX- why wasn't this in the old driver??
1626 */
1627 ata_pktp->ap_bytes_per_block = NBPSCTR;
1628 } else
1629 #endif
1630 {
1631 byte_count = sec_count << SCTRSHFT;
1632 pktp->cp_bytexfer = byte_count;
1633 pktp->cp_resid = byte_count;
1634 ata_pktp->ap_resid = byte_count;
1635
1636 /* setup the task file registers */
1637
1638 switch (ata_pktp->ap_cdb) {
1639 case DCMD_READ:
1640 if (ata_pktp->ap_sg_cnt) {
1641 ata_pktp->ap_cmd = ATC_READ_DMA;
1642 ata_pktp->ap_pciide_dma = TRUE;
1643 ata_pktp->ap_start = ata_disk_start_dma_in;
1644 ata_pktp->ap_intr = ata_disk_intr_dma;
1645 } else {
1646 ata_pktp->ap_cmd = ata_drvp->ad_rd_cmd;
1647 ata_pktp->ap_start = ata_disk_start_pio_in;
1648 ata_pktp->ap_intr = ata_disk_intr_pio_in;
1649 }
1650 ata_pktp->ap_flags |= AP_READ;
1651 break;
1652
1653 case DCMD_WRITE:
1654 if (ata_pktp->ap_sg_cnt) {
1655 ata_pktp->ap_cmd = ATC_WRITE_DMA;
1656 ata_pktp->ap_pciide_dma = TRUE;
1657 ata_pktp->ap_start = ata_disk_start_dma_out;
1658 ata_pktp->ap_intr = ata_disk_intr_dma;
1659 } else {
1660 ata_pktp->ap_cmd = ata_drvp->ad_wr_cmd;
1661 ata_pktp->ap_start = ata_disk_start_pio_out;
1662 ata_pktp->ap_intr = ata_disk_intr_pio_out;
1663 }
1664 ata_pktp->ap_flags |= AP_WRITE;
1665 break;
1666
1667 default:
1668 ADBG_WARN(("ata_disk_iosetup: unknown command 0x%x\n",
1669 ata_pktp->ap_cdb));
1670 pktp = NULL;
1671 break;
1672 }
1673 }
1674
1675 /* If 48-bit mode is used, convert command to 48-bit mode cmd */
1676 if (pktp != NULL && ata_drvp->ad_flags & AD_EXT48) {
1677 switch (ata_pktp->ap_cmd) {
1678 case ATC_RDSEC:
1679 ata_pktp->ap_cmd = ATC_RDSEC_EXT;
1680 break;
1681 case ATC_WRSEC:
1682 ata_pktp->ap_cmd = ATC_WRSEC_EXT;
1683 break;
1684 case ATC_RDMULT:
1685 ata_pktp->ap_cmd = ATC_RDMULT_EXT;
1686 break;
1687 case ATC_WRMULT:
1688 ata_pktp->ap_cmd = ATC_WRMULT_EXT;
1689 break;
1690 case ATC_READ_DMA:
1691 ata_pktp->ap_cmd = ATC_RDDMA_EXT;
1692 break;
1693 case ATC_WRITE_DMA:
1694 ata_pktp->ap_cmd = ATC_WRDMA_EXT;
1695 break;
1696 }
1697 }
1698
1699 return (pktp);
1700 }
1701
1702
1703
1704 /*
1705 *
1706 * DADA transport entry point
1707 *
1708 */
1709
1710 static int
ata_disk_transport(opaque_t ctl_data,cmpkt_t * pktp)1711 ata_disk_transport(opaque_t ctl_data, cmpkt_t *pktp)
1712 {
1713 gtgt_t *gtgtp = (gtgt_t *)ctl_data;
1714 ata_drv_t *ata_drvp = GTGTP2ATADRVP(gtgtp);
1715 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp;
1716 ata_pkt_t *ata_pktp = CPKT2APKT(pktp);
1717 int rc;
1718 int polled = FALSE;
1719
1720 ADBG_TRACE(("ata_disk_transport entered\n"));
1721
1722 /* check for polling pkt */
1723
1724 if (pktp->cp_flags & CPF_NOINTR) {
1725 polled = TRUE;
1726 }
1727
1728 /* call ghd transport routine */
1729
1730 rc = ghd_transport(&ata_ctlp->ac_ccc, APKT2GCMD(ata_pktp),
1731 gtgtp, pktp->cp_time, polled, NULL);
1732
1733 /* see if pkt was not accepted */
1734
1735 if (rc == TRAN_BUSY)
1736 return (CTL_SEND_BUSY);
1737
1738 if (rc == TRAN_ACCEPT)
1739 return (CTL_SEND_SUCCESS);
1740
1741 return (CTL_SEND_FAILURE);
1742 }
1743
1744
1745 /*
1746 *
1747 * routines to load the cylinder/head/sector/count
1748 * task file registers.
1749 *
1750 */
1751 static void
ata_disk_load_regs_lba28(ata_pkt_t * ata_pktp,ata_drv_t * ata_drvp)1752 ata_disk_load_regs_lba28(ata_pkt_t *ata_pktp, ata_drv_t *ata_drvp)
1753 {
1754 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp;
1755 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
1756 uint_t lba; /* LBA of first sector */
1757
1758 lba = ata_pktp->ap_startsec;
1759
1760 ddi_put8(io_hdl1, ata_ctlp->ac_count, ata_pktp->ap_count);
1761 ddi_put8(io_hdl1, ata_ctlp->ac_sect, lba);
1762 lba >>= 8;
1763 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, lba);
1764 lba >>= 8;
1765 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, lba);
1766 lba >>= 8;
1767 /*
1768 * dev/head register can use only 4 bits
1769 * must also include drive selector.
1770 */
1771 lba = (lba & 0xf) | ata_drvp->ad_drive_bits;
1772 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, lba);
1773 }
1774
1775 /*
1776 * In 48-bit extended mode, the sector count is 16 bits wide, and the
1777 * LBA is 48 bits wide, as follows:
1778 * register most recent previous
1779 * name value value
1780 * -------- ---------- ---------
1781 * sector cnt count(7:0) count(15:8)
1782 * sector num lba(7:0) lba(31:24)
1783 * cyl low lba(15:8) lba(39:32)
1784 * cyl hi lba(23:16) lba(47:40)
1785 * device/head 111D0000 N/A
1786 * ^ ^
1787 * | |
1788 * | +-- drive number
1789 * |
1790 * +-- indicates LBA
1791 * The other two 1 bits are historical and are not used in 48bit
1792 * extended mode.
1793 */
1794 /*
1795 * WARNING:
1796 * dada framework passes starting sector as daddr_t type, thus
1797 * limiting reachable disk space in 32-bit x86 architecture to 1 terabyte.
1798 * Therefore high 16 bits of the 48-bits address can be and
1799 * are currently ignored.
1800 */
1801 static void
ata_disk_load_regs_lba48(ata_pkt_t * ata_pktp,ata_drv_t * ata_drvp)1802 ata_disk_load_regs_lba48(ata_pkt_t *ata_pktp, ata_drv_t *ata_drvp)
1803 {
1804 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp;
1805 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
1806 uint16_t seccnt; /* 16-bit sector count */
1807 uint_t lbalow; /* low-order 24 bits of LBA */
1808 uint_t lbahi; /* high-order 24 bits of LBA */
1809
1810 seccnt = ata_pktp->ap_count;
1811 /* high-order 8 bits of lbalow never get used */
1812 lbalow = ata_pktp->ap_startsec;
1813 lbahi = ata_pktp->ap_startsec >> 24;
1814
1815 ddi_put8(io_hdl1, ata_ctlp->ac_count, seccnt >> 8);
1816 ddi_put8(io_hdl1, ata_ctlp->ac_count, seccnt);
1817 /* Send the high-order half first */
1818 ddi_put8(io_hdl1, ata_ctlp->ac_sect, lbahi);
1819 lbahi >>= 8;
1820 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, lbahi);
1821 lbahi >>= 8;
1822 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, lbahi);
1823 /* Send the low-order half */
1824 ddi_put8(io_hdl1, ata_ctlp->ac_sect, lbalow);
1825 lbalow >>= 8;
1826 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, lbalow);
1827 lbalow >>= 8;
1828 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, lbalow);
1829 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, ata_drvp->ad_drive_bits);
1830 }
1831
1832 static void
ata_disk_load_regs_chs(ata_pkt_t * ata_pktp,ata_drv_t * ata_drvp)1833 ata_disk_load_regs_chs(ata_pkt_t *ata_pktp, ata_drv_t *ata_drvp)
1834 {
1835 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp;
1836 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
1837 uint_t resid;
1838 uint_t cyl;
1839 uchar_t head;
1840 uchar_t drvheads;
1841 uchar_t drvsectors;
1842
1843 drvheads = ata_drvp->ad_phhd;
1844 drvsectors = ata_drvp->ad_phsec;
1845
1846 resid = ata_pktp->ap_startsec / drvsectors;
1847 head = (resid % drvheads) & 0xf;
1848 cyl = resid / drvheads;
1849 /* automatically truncate to char */
1850 ddi_put8(io_hdl1, ata_ctlp->ac_sect,
1851 (ata_pktp->ap_startsec % drvsectors) + 1);
1852 ddi_put8(io_hdl1, ata_ctlp->ac_count, ata_pktp->ap_count);
1853 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl, (cyl >> 8));
1854 /* lcyl gets truncated to 8 bits */
1855 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, cyl);
1856 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, ata_drvp->ad_drive_bits | head);
1857 }
1858
1859
1860 /*
1861 *
1862 * packet start callback routines
1863 *
1864 */
1865
1866 /* ARGSUSED */
1867 static int
ata_disk_start_common(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)1868 ata_disk_start_common(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
1869 ata_pkt_t *ata_pktp)
1870 {
1871 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
1872 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
1873
1874 ADBG_TRACE(("ata_disk_start_common entered\n"));
1875
1876 ADBG_TRANSPORT(("ata_disk_start:\tpkt = 0x%p, pkt flags = 0x%x\n",
1877 ata_pktp, ata_pktp->ap_flags));
1878 ADBG_TRANSPORT(("\tcommand=0x%x, sect=0x%lx\n",
1879 ata_pktp->ap_cmd, ata_pktp->ap_startsec));
1880 ADBG_TRANSPORT(("\tcount=0x%x, drvhd = 0x%x\n",
1881 ata_pktp->ap_count, ata_drvp->ad_drive_bits));
1882
1883 /*
1884 * If AC_BSY_WAIT is set, wait for controller to not be busy,
1885 * before issuing a command. If AC_BSY_WAIT is not set,
1886 * skip the wait. This is important for laptops that do
1887 * suspend/resume but do not correctly wait for the busy bit to
1888 * drop after a resume.
1889 *
1890 * NOTE: this test for ATS_BSY is also needed if/when we
1891 * implement the overlapped/queued command protocols. Currently,
1892 * the overlap/queued feature is not supported so the test is
1893 * conditional.
1894 */
1895 if (ata_ctlp->ac_timing_flags & AC_BSY_WAIT) {
1896 if (!ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2,
1897 0, ATS_BSY, 5000000)) {
1898 ADBG_ERROR(("ata_disk_start: BUSY\n"));
1899 return (FALSE);
1900 }
1901 }
1902
1903 ddi_put8(io_hdl1, ata_ctlp->ac_drvhd, ata_drvp->ad_drive_bits);
1904 ata_nsecwait(400);
1905
1906 /*
1907 * make certain the drive selected
1908 */
1909 if (!ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2,
1910 ATS_DRDY, ATS_BSY, 5 * 1000000)) {
1911 ADBG_ERROR(("ata_disk_start: select failed\n"));
1912 return (FALSE);
1913 }
1914
1915 if (ata_pktp->ap_cmd == ATC_LOAD_FW) {
1916
1917 /* the sector count is 16 bits wide */
1918 ddi_put8(io_hdl1, ata_ctlp->ac_count, ata_pktp->ap_count);
1919 ddi_put8(io_hdl1, ata_ctlp->ac_sect, ata_pktp->ap_count >> 8);
1920 ddi_put8(io_hdl1, ata_ctlp->ac_lcyl, ata_pktp->ap_startsec);
1921 ddi_put8(io_hdl1, ata_ctlp->ac_hcyl,
1922 ata_pktp->ap_startsec >> 8);
1923
1924 /* put subcommand for DOWNLOAD MICROCODE */
1925 ddi_put8(io_hdl1, ata_ctlp->ac_feature, ata_pktp->ap_bcount);
1926 } else {
1927
1928 /*
1929 * We use different methods for loading the task file
1930 * registers, depending on whether the disk
1931 * uses LBA or CHS addressing and whether 48-bit
1932 * extended addressing is to be used.
1933 */
1934 if (!(ata_drvp->ad_drive_bits & ATDH_LBA))
1935 ata_disk_load_regs_chs(ata_pktp, ata_drvp);
1936 else if (ata_drvp->ad_flags & AD_EXT48)
1937 ata_disk_load_regs_lba48(ata_pktp, ata_drvp);
1938 else
1939 ata_disk_load_regs_lba28(ata_pktp, ata_drvp);
1940 ddi_put8(io_hdl1, ata_ctlp->ac_feature, 0);
1941 }
1942
1943 /*
1944 * Always make certain interrupts are enabled. It's been reported
1945 * (but not confirmed) that some notebook computers don't
1946 * clear the interrupt disable bit after being resumed. The
1947 * easiest way to fix this is to always clear the disable bit
1948 * before every command.
1949 */
1950 ddi_put8(io_hdl2, ata_ctlp->ac_devctl, ATDC_D3);
1951 return (TRUE);
1952 }
1953
1954
1955 /*
1956 *
1957 * Start a non-data ATA command (not DMA and not PIO):
1958 *
1959 */
1960
1961 static int
ata_disk_start(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)1962 ata_disk_start(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
1963 ata_pkt_t *ata_pktp)
1964 {
1965 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
1966 int rc;
1967
1968 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp);
1969
1970 if (!rc)
1971 return (ATA_FSM_RC_BUSY);
1972
1973 /*
1974 * This next one sets the controller in motion
1975 */
1976 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd);
1977
1978 /* wait for the busy bit to settle */
1979 ata_nsecwait(400);
1980
1981 return (ATA_FSM_RC_OKAY);
1982 }
1983
1984
1985
1986 static int
ata_disk_start_dma_in(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)1987 ata_disk_start_dma_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
1988 ata_pkt_t *ata_pktp)
1989 {
1990 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
1991 int rc;
1992
1993 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp);
1994
1995 if (!rc)
1996 return (ATA_FSM_RC_BUSY);
1997
1998 /*
1999 * Copy the Scatter/Gather list to the controller's
2000 * Physical Region Descriptor Table
2001 */
2002 ata_pciide_dma_setup(ata_ctlp, ata_pktp->ap_sg_list,
2003 ata_pktp->ap_sg_cnt);
2004
2005 /*
2006 * reset the PCIIDE Controller's interrupt and error status bits
2007 */
2008 (void) ata_pciide_status_clear(ata_ctlp);
2009
2010 /*
2011 * This next one sets the drive in motion
2012 */
2013 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd);
2014
2015 /* wait for the drive's busy bit to settle */
2016 ata_nsecwait(400);
2017
2018 ata_pciide_dma_start(ata_ctlp, PCIIDE_BMICX_RWCON_WRITE_TO_MEMORY);
2019
2020 return (ATA_FSM_RC_OKAY);
2021 }
2022
2023
2024
2025 static int
ata_disk_start_dma_out(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2026 ata_disk_start_dma_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2027 ata_pkt_t *ata_pktp)
2028 {
2029 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2030 int rc;
2031
2032 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp);
2033
2034 if (!rc)
2035 return (ATA_FSM_RC_BUSY);
2036
2037 /*
2038 * Copy the Scatter/Gather list to the controller's
2039 * Physical Region Descriptor Table
2040 */
2041 ata_pciide_dma_setup(ata_ctlp, ata_pktp->ap_sg_list,
2042 ata_pktp->ap_sg_cnt);
2043
2044 /*
2045 * reset the PCIIDE Controller's interrupt and error status bits
2046 */
2047 (void) ata_pciide_status_clear(ata_ctlp);
2048
2049 /*
2050 * This next one sets the drive in motion
2051 */
2052 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd);
2053
2054 /* wait for the drive's busy bit to settle */
2055 ata_nsecwait(400);
2056
2057 ata_pciide_dma_start(ata_ctlp, PCIIDE_BMICX_RWCON_READ_FROM_MEMORY);
2058
2059 return (ATA_FSM_RC_OKAY);
2060 }
2061
2062
2063
2064
2065
2066 /*
2067 *
2068 * Start a PIO data-in ATA command:
2069 *
2070 */
2071
2072 static int
ata_disk_start_pio_in(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2073 ata_disk_start_pio_in(
2074 ata_ctl_t *ata_ctlp,
2075 ata_drv_t *ata_drvp,
2076 ata_pkt_t *ata_pktp)
2077 {
2078 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2079 int rc;
2080
2081 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp);
2082
2083 if (!rc)
2084 return (ATA_FSM_RC_BUSY);
2085 /*
2086 * This next one sets the controller in motion
2087 */
2088 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd);
2089
2090 /* wait for the busy bit to settle */
2091 ata_nsecwait(400);
2092
2093 return (ATA_FSM_RC_OKAY);
2094 }
2095
2096
2097
2098
2099 /*
2100 *
2101 * Start a PIO data-out ATA command:
2102 *
2103 */
2104
2105 static int
ata_disk_start_pio_out(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2106 ata_disk_start_pio_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2107 ata_pkt_t *ata_pktp)
2108 {
2109 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2110 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
2111 int rc;
2112
2113 ata_pktp->ap_wrt_count = 0;
2114
2115 rc = ata_disk_start_common(ata_ctlp, ata_drvp, ata_pktp);
2116
2117 if (!rc)
2118 return (ATA_FSM_RC_BUSY);
2119 /*
2120 * This next one sets the controller in motion
2121 */
2122 ddi_put8(io_hdl1, ata_ctlp->ac_cmd, ata_pktp->ap_cmd);
2123
2124 /* wait for the busy bit to settle */
2125 ata_nsecwait(400);
2126
2127 /*
2128 * Wait for the drive to assert DRQ to send the first chunk
2129 * of data. Have to busy wait because there's no interrupt for
2130 * the first chunk. This sucks (a lot of cycles) if the
2131 * drive responds too slowly or if the wait loop granularity
2132 * is too large. It's really bad if the drive is defective and
2133 * the loop times out.
2134 */
2135
2136 if (!ata_wait3(io_hdl2, ata_ctlp->ac_ioaddr2,
2137 ATS_DRQ, ATS_BSY, /* okay */
2138 ATS_ERR, ATS_BSY, /* cmd failed */
2139 ATS_DF, ATS_BSY, /* drive failed */
2140 4000000)) {
2141 ADBG_WARN(("ata_disk_start_pio_out: no DRQ\n"));
2142 ata_pktp->ap_flags |= AP_ERROR;
2143 return (ATA_FSM_RC_INTR);
2144 }
2145
2146 /*
2147 * Tell the upper layer to fake a hardware interrupt which
2148 * actually causes the first segment to be written to the drive.
2149 */
2150 return (ATA_FSM_RC_INTR);
2151 }
2152
2153
2154
2155 /*
2156 *
2157 * packet complete callback routine
2158 *
2159 */
2160
2161 static void
ata_disk_complete(ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp,int do_callback)2162 ata_disk_complete(ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp, int do_callback)
2163 {
2164 struct ata_id *aidp = &ata_drvp->ad_id;
2165 cmpkt_t *pktp;
2166
2167 ADBG_TRACE(("ata_disk_complete entered\n"));
2168 ADBG_TRANSPORT(("ata_disk_complete: pkt = 0x%p\n", ata_pktp));
2169
2170 pktp = APKT2CPKT(ata_pktp);
2171
2172 /* update resid */
2173
2174 pktp->cp_resid = ata_pktp->ap_resid;
2175
2176 if (ata_pktp->ap_flags & AP_ERROR) {
2177
2178 pktp->cp_reason = CPS_CHKERR;
2179
2180 if (ata_pktp->ap_error & ATE_BBK_ICRC) {
2181 if (IS_ATA_VERSION_GE(aidp, 4))
2182 ata_pktp->ap_scb = DERR_ICRC;
2183 else
2184 ata_pktp->ap_scb = DERR_BBK;
2185 } else if (ata_pktp->ap_error & ATE_UNC)
2186 ata_pktp->ap_scb = DERR_UNC;
2187 else if (ata_pktp->ap_error & ATE_IDNF)
2188 ata_pktp->ap_scb = DERR_IDNF;
2189 else if (ata_pktp->ap_error & ATE_TKONF)
2190 ata_pktp->ap_scb = DERR_TKONF;
2191 else if (ata_pktp->ap_error & ATE_AMNF)
2192 ata_pktp->ap_scb = DERR_AMNF;
2193 else if (ata_pktp->ap_status & ATS_BSY)
2194 ata_pktp->ap_scb = DERR_BUSY;
2195 else if (ata_pktp->ap_status & ATS_DF)
2196 ata_pktp->ap_scb = DERR_DWF;
2197 else /* any unknown error */
2198 ata_pktp->ap_scb = DERR_ABORT;
2199 } else if (ata_pktp->ap_flags & (AP_ABORT|AP_TIMEOUT|AP_BUS_RESET)) {
2200
2201 pktp->cp_reason = CPS_CHKERR;
2202 ata_pktp->ap_scb = DERR_ABORT;
2203 } else {
2204 pktp->cp_reason = CPS_SUCCESS;
2205 ata_pktp->ap_scb = DERR_SUCCESS;
2206 }
2207
2208 /* callback */
2209 if (do_callback)
2210 (*pktp->cp_callback)(pktp);
2211 }
2212
2213
2214 /*
2215 *
2216 * Interrupt callbacks
2217 *
2218 */
2219
2220
2221 /*
2222 *
2223 * ATA command, no data
2224 *
2225 */
2226
2227 /* ARGSUSED */
2228 static int
ata_disk_intr(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2229 ata_disk_intr(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2230 ata_pkt_t *ata_pktp)
2231 {
2232 uchar_t status;
2233
2234 ADBG_TRACE(("ata_disk_intr entered\n"));
2235 ADBG_TRANSPORT(("ata_disk_intr: pkt = 0x%p\n", ata_pktp));
2236
2237 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp);
2238
2239 ASSERT((status & (ATS_BSY | ATS_DRQ)) == 0);
2240
2241 /*
2242 * check for errors
2243 */
2244
2245 if (status & (ATS_DF | ATS_ERR)) {
2246 ADBG_WARN(("ata_disk_intr: status 0x%x error 0x%x\n", status,
2247 ddi_get8(ata_ctlp->ac_iohandle1, ata_ctlp->ac_error)));
2248 ata_pktp->ap_flags |= AP_ERROR;
2249 }
2250
2251 if (ata_pktp->ap_flags & AP_ERROR) {
2252 ata_pktp->ap_status = ddi_get8(ata_ctlp->ac_iohandle2,
2253 ata_ctlp->ac_altstatus);
2254 ata_pktp->ap_error = ddi_get8(ata_ctlp->ac_iohandle1,
2255 ata_ctlp->ac_error);
2256 }
2257
2258 /* tell the upper layer this request is complete */
2259 return (ATA_FSM_RC_FINI);
2260 }
2261
2262
2263 /*
2264 *
2265 * ATA command, PIO data in
2266 *
2267 */
2268
2269 /* ARGSUSED */
2270 static int
ata_disk_intr_pio_in(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2271 ata_disk_intr_pio_in(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2272 ata_pkt_t *ata_pktp)
2273 {
2274 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2275 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
2276 uchar_t status;
2277
2278 ADBG_TRACE(("ata_disk_pio_in entered\n"));
2279 ADBG_TRANSPORT(("ata_disk_pio_in: pkt = 0x%p\n", ata_pktp));
2280
2281 /*
2282 * first make certain DRQ is asserted (and no errors)
2283 */
2284 (void) ata_wait3(io_hdl2, ata_ctlp->ac_ioaddr2,
2285 ATS_DRQ, ATS_BSY, ATS_ERR, ATS_BSY, ATS_DF, ATS_BSY, 4000000);
2286
2287 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp);
2288
2289 if (status & ATS_BSY) {
2290 ADBG_WARN(("ata_disk_pio_in: BUSY\n"));
2291 ata_pktp->ap_flags |= AP_ERROR;
2292 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2293 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2294 return (ATA_FSM_RC_BUSY);
2295 }
2296
2297 /*
2298 * record any errors
2299 */
2300 if ((status & (ATS_DRQ | ATS_DF | ATS_ERR)) != ATS_DRQ) {
2301 ADBG_WARN(("ata_disk_pio_in: status 0x%x error 0x%x\n",
2302 status, ddi_get8(io_hdl1, ata_ctlp->ac_error)));
2303 ata_pktp->ap_flags |= AP_ERROR;
2304 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2305 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2306 }
2307
2308 /*
2309 * read the next chunk of data (if any)
2310 */
2311 if (status & ATS_DRQ) {
2312 ata_disk_pio_xfer_data_in(ata_ctlp, ata_pktp);
2313 }
2314
2315 /*
2316 * If that was the last chunk, wait for the device to clear DRQ
2317 */
2318 if (ata_pktp->ap_resid == 0) {
2319 if (ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2,
2320 0, (ATS_DRQ | ATS_BSY), 4000000)) {
2321 /* tell the upper layer this request is complete */
2322 return (ATA_FSM_RC_FINI);
2323 }
2324
2325 ADBG_WARN(("ata_disk_pio_in: DRQ stuck\n"));
2326 ata_pktp->ap_flags |= AP_ERROR;
2327 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2328 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2329 }
2330
2331 /*
2332 * check for errors
2333 */
2334 if (ata_pktp->ap_flags & AP_ERROR) {
2335 return (ATA_FSM_RC_FINI);
2336 }
2337
2338 /*
2339 * If the read command isn't done yet,
2340 * wait for the next interrupt.
2341 */
2342 ADBG_TRACE(("ata_disk_pio_in: partial\n"));
2343 return (ATA_FSM_RC_OKAY);
2344 }
2345
2346
2347
2348 /*
2349 *
2350 * ATA command, PIO data out
2351 *
2352 */
2353
2354 /* ARGSUSED */
2355 static int
ata_disk_intr_pio_out(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2356 ata_disk_intr_pio_out(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2357 ata_pkt_t *ata_pktp)
2358 {
2359 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2360 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
2361 int tmp_count = ata_pktp->ap_wrt_count;
2362 uchar_t status;
2363
2364 /*
2365 * clear the IRQ
2366 */
2367 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp);
2368
2369 ADBG_TRACE(("ata_disk_intr_pio_out entered\n"));
2370 ADBG_TRANSPORT(("ata_disk_intr_pio_out: pkt = 0x%p\n", ata_pktp));
2371
2372 ASSERT(!(status & ATS_BSY));
2373
2374
2375 /*
2376 * check for errors
2377 */
2378
2379 if (status & (ATS_DF | ATS_ERR)) {
2380 ADBG_WARN(("ata_disk_intr_pio_out: status 0x%x error 0x%x\n",
2381 status, ddi_get8(io_hdl1, ata_ctlp->ac_error)));
2382 ata_pktp->ap_flags |= AP_ERROR;
2383 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2384 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2385 /* tell the upper layer this request is complete */
2386 return (ATA_FSM_RC_FINI);
2387 }
2388
2389
2390 /*
2391 * last write was okay, bump the ptr and
2392 * decr the resid count
2393 */
2394 ata_pktp->ap_v_addr += tmp_count;
2395 ata_pktp->ap_resid -= tmp_count;
2396
2397 /*
2398 * check for final interrupt on write command
2399 */
2400 if (ata_pktp->ap_resid == 0) {
2401 /* tell the upper layer this request is complete */
2402 return (ATA_FSM_RC_FINI);
2403 }
2404
2405 /*
2406 * Perform the next data transfer
2407 *
2408 * First make certain DRQ is asserted and no error status.
2409 * (I'm not certain but I think some drives might deassert BSY
2410 * before asserting DRQ. This extra ata_wait3() will
2411 * compensate for such drives).
2412 *
2413 */
2414 (void) ata_wait3(io_hdl2, ata_ctlp->ac_ioaddr2,
2415 ATS_DRQ, ATS_BSY, ATS_ERR, ATS_BSY, ATS_DF, ATS_BSY, 4000000);
2416
2417 status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2418
2419 if (status & ATS_BSY) {
2420 /* this should never happen */
2421 ADBG_WARN(("ata_disk_intr_pio_out: BUSY\n"));
2422 ata_pktp->ap_flags |= AP_ERROR;
2423 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2424 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2425 return (ATA_FSM_RC_BUSY);
2426 }
2427
2428 /*
2429 * bailout if any errors
2430 */
2431 if ((status & (ATS_DRQ | ATS_DF | ATS_ERR)) != ATS_DRQ) {
2432 ADBG_WARN(("ata_disk_pio_out: status 0x%x error 0x%x\n",
2433 status, ddi_get8(io_hdl1, ata_ctlp->ac_error)));
2434 ata_pktp->ap_flags |= AP_ERROR;
2435 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2436 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2437 return (ATA_FSM_RC_FINI);
2438 }
2439
2440 /*
2441 * write the next chunk of data
2442 */
2443 ADBG_TRACE(("ata_disk_intr_pio_out: write xfer\n"));
2444 ata_disk_pio_xfer_data_out(ata_ctlp, ata_pktp);
2445
2446 /*
2447 * Wait for the next interrupt before checking the transfer
2448 * status and adjusting the transfer count.
2449 *
2450 */
2451 return (ATA_FSM_RC_OKAY);
2452 }
2453
2454
2455 /*
2456 *
2457 * ATA command, DMA data in/out
2458 *
2459 */
2460
2461 static int
ata_disk_intr_dma(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2462 ata_disk_intr_dma(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp, ata_pkt_t *ata_pktp)
2463 {
2464 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2465 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
2466 uchar_t status;
2467
2468 ADBG_TRACE(("ata_disk_intr_dma entered\n"));
2469 ADBG_TRANSPORT(("ata_disk_intr_dma: pkt = 0x%p\n", ata_pktp));
2470
2471 /*
2472 * halt the DMA engine
2473 */
2474 ata_pciide_dma_stop(ata_ctlp);
2475
2476 /*
2477 * wait for the device to clear DRQ
2478 */
2479 if (!ata_wait(io_hdl2, ata_ctlp->ac_ioaddr2,
2480 0, (ATS_DRQ | ATS_BSY), 4000000)) {
2481 ADBG_WARN(("ata_disk_intr_dma: DRQ stuck\n"));
2482 ata_pktp->ap_flags |= AP_ERROR;
2483 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2484 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2485 return (ATA_FSM_RC_BUSY);
2486 }
2487
2488 /*
2489 * get the status and clear the IRQ, and check for DMA error
2490 */
2491 status = ata_get_status_clear_intr(ata_ctlp, ata_pktp);
2492
2493 /*
2494 * check for drive errors
2495 */
2496
2497 if (status & (ATS_DF | ATS_ERR)) {
2498 ADBG_WARN(("ata_disk_intr_dma: status 0x%x error 0x%x\n",
2499 status, ddi_get8(io_hdl1, ata_ctlp->ac_error)));
2500 ata_pktp->ap_flags |= AP_ERROR;
2501 ata_pktp->ap_status = ddi_get8(io_hdl2, ata_ctlp->ac_altstatus);
2502 ata_pktp->ap_error = ddi_get8(io_hdl1, ata_ctlp->ac_error);
2503 }
2504
2505 /*
2506 * If there was a drive or DMA error, compute a resid count
2507 */
2508 if (ata_pktp->ap_flags & AP_ERROR) {
2509 /*
2510 * grab the last sector address from the drive regs
2511 * and use that to compute the resid
2512 */
2513 ata_disk_get_resid(ata_ctlp, ata_drvp, ata_pktp);
2514 } else {
2515 ata_pktp->ap_resid = 0;
2516 }
2517
2518 /* tell the upper layer this request is complete */
2519 return (ATA_FSM_RC_FINI);
2520 }
2521
2522
2523 /*
2524 *
2525 * Low level PIO routine that transfers data from the drive
2526 *
2527 */
2528
2529 static void
ata_disk_pio_xfer_data_in(ata_ctl_t * ata_ctlp,ata_pkt_t * ata_pktp)2530 ata_disk_pio_xfer_data_in(ata_ctl_t *ata_ctlp, ata_pkt_t *ata_pktp)
2531 {
2532 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2533 int count;
2534
2535 count = min(ata_pktp->ap_resid, ata_pktp->ap_bytes_per_block);
2536
2537 ADBG_TRANSPORT(("ata_disk_pio_xfer_data_in: 0x%x bytes, addr = 0x%p\n",
2538 count, ata_pktp->ap_v_addr));
2539
2540 /*
2541 * read count bytes
2542 */
2543
2544 ASSERT(count != 0);
2545
2546 ddi_rep_get16(io_hdl1, (ushort_t *)ata_pktp->ap_v_addr,
2547 ata_ctlp->ac_data, (count >> 1), DDI_DEV_NO_AUTOINCR);
2548
2549 /* wait for the busy bit to settle */
2550 ata_nsecwait(400);
2551
2552 /*
2553 * this read command completed okay, bump the ptr and
2554 * decr the resid count now.
2555 */
2556 ata_pktp->ap_v_addr += count;
2557 ata_pktp->ap_resid -= count;
2558 }
2559
2560
2561 /*
2562 *
2563 * Low level PIO routine that transfers data to the drive
2564 *
2565 */
2566
2567 static void
ata_disk_pio_xfer_data_out(ata_ctl_t * ata_ctlp,ata_pkt_t * ata_pktp)2568 ata_disk_pio_xfer_data_out(ata_ctl_t *ata_ctlp, ata_pkt_t *ata_pktp)
2569 {
2570 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2571 int count;
2572
2573 count = min(ata_pktp->ap_resid, ata_pktp->ap_bytes_per_block);
2574
2575 ADBG_TRANSPORT(("ata_disk_pio_xfer_data_out: 0x%x bytes, addr = 0x%p\n",
2576 count, ata_pktp->ap_v_addr));
2577
2578 /*
2579 * read or write count bytes
2580 */
2581
2582 ASSERT(count != 0);
2583
2584 ddi_rep_put16(io_hdl1, (ushort_t *)ata_pktp->ap_v_addr,
2585 ata_ctlp->ac_data, (count >> 1), DDI_DEV_NO_AUTOINCR);
2586
2587 /* wait for the busy bit to settle */
2588 ata_nsecwait(400);
2589
2590 /*
2591 * save the count here so I can correctly adjust
2592 * the ap_v_addr and ap_resid values at the next
2593 * interrupt.
2594 */
2595 ata_pktp->ap_wrt_count = count;
2596 }
2597
2598
2599 /*
2600 *
2601 * ATA Initialize Device Parameters (aka Set Params) command
2602 *
2603 * If the drive was put in some sort of CHS extended/logical geometry
2604 * mode by the BIOS, this function will reset it to its "native"
2605 * CHS geometry. This ensures that we don't run into any sort of
2606 * 1024 cylinder (or 65535 cylinder) limitation that may have been
2607 * created by a BIOS (or users) that chooses a bogus translated geometry.
2608 */
2609
2610 static int
ata_disk_initialize_device_parameters(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp)2611 ata_disk_initialize_device_parameters(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp)
2612 {
2613 int rc;
2614
2615 rc = ata_command(ata_ctlp, ata_drvp, FALSE, FALSE,
2616 ata_disk_init_dev_parm_wait,
2617 ATC_SETPARAM,
2618 0, /* feature n/a */
2619 ata_drvp->ad_phsec, /* max sector (1-based) */
2620 0, /* sector n/a */
2621 (ata_drvp->ad_phhd -1), /* max head (0-based) */
2622 0, /* cyl_low n/a */
2623 0); /* cyl_hi n/a */
2624
2625 if (rc)
2626 return (TRUE);
2627
2628 ADBG_ERROR(("ata_init_dev_parms: failed\n"));
2629 return (FALSE);
2630 }
2631
2632
2633
2634 /*
2635 *
2636 * create fake inquiry data for DADA interface
2637 *
2638 */
2639
2640 static void
ata_disk_fake_inquiry(ata_drv_t * ata_drvp)2641 ata_disk_fake_inquiry(ata_drv_t *ata_drvp)
2642 {
2643 struct ata_id *ata_idp = &ata_drvp->ad_id;
2644 struct scsi_inquiry *inqp = &ata_drvp->ad_inquiry;
2645
2646 ADBG_TRACE(("ata_disk_fake_inquiry entered\n"));
2647
2648 if (ata_idp->ai_config & ATA_ID_REM_DRV) /* ide removable bit */
2649 inqp->inq_rmb = 1; /* scsi removable bit */
2650
2651 (void) strncpy(inqp->inq_vid, "Gen-ATA ", sizeof (inqp->inq_vid));
2652 inqp->inq_dtype = DTYPE_DIRECT;
2653 inqp->inq_qual = DPQ_POSSIBLE;
2654
2655 (void) strncpy(inqp->inq_pid, ata_idp->ai_model,
2656 sizeof (inqp->inq_pid));
2657 (void) strncpy(inqp->inq_revision, ata_idp->ai_fw,
2658 sizeof (inqp->inq_revision));
2659 }
2660
2661 #define LOOP_COUNT 10000
2662
2663
2664 /*
2665 *
2666 * ATA Set Multiple Mode
2667 *
2668 */
2669
2670 static int
ata_disk_set_multiple(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp)2671 ata_disk_set_multiple(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp)
2672 {
2673 int rc;
2674
2675 rc = ata_command(ata_ctlp, ata_drvp, TRUE, FALSE,
2676 ata_disk_set_mult_wait,
2677 ATC_SETMULT,
2678 0, /* feature n/a */
2679 ata_drvp->ad_block_factor, /* count */
2680 0, /* sector n/a */
2681 0, /* head n/a */
2682 0, /* cyl_low n/a */
2683 0); /* cyl_hi n/a */
2684
2685 if (rc) {
2686 return (TRUE);
2687 }
2688
2689 ADBG_ERROR(("ata_disk_set_multiple: failed\n"));
2690 return (FALSE);
2691 }
2692
2693
2694 /*
2695 *
2696 * ATA Identify Device command
2697 *
2698 */
2699
2700 int
ata_disk_id(ddi_acc_handle_t io_hdl1,caddr_t ioaddr1,ddi_acc_handle_t io_hdl2,caddr_t ioaddr2,struct ata_id * ata_idp)2701 ata_disk_id(ddi_acc_handle_t io_hdl1, caddr_t ioaddr1, ddi_acc_handle_t io_hdl2,
2702 caddr_t ioaddr2, struct ata_id *ata_idp)
2703 {
2704 int rc;
2705
2706 ADBG_TRACE(("ata_disk_id entered\n"));
2707
2708 rc = ata_id_common(ATC_ID_DEVICE, TRUE, io_hdl1, ioaddr1, io_hdl2,
2709 ioaddr2, ata_idp);
2710
2711 if (!rc)
2712 return (FALSE);
2713
2714 /*
2715 * If the disk is a CF/Microdrive that works under ATA mode
2716 * through CF<->ATA adapters, identify it as an ATA device
2717 * and a non removable media.
2718 */
2719 if (ata_idp->ai_config == ATA_ID_COMPACT_FLASH) {
2720 ata_idp->ai_config = ATA_ID_CF_TO_ATA;
2721 }
2722
2723 if ((ata_idp->ai_config & ATAC_ATA_TYPE_MASK) != ATAC_ATA_TYPE)
2724 return (FALSE);
2725
2726 if (ata_idp->ai_heads == 0 || ata_idp->ai_sectors == 0) {
2727 return (FALSE);
2728 }
2729
2730 return (TRUE);
2731 }
2732
2733 static daddr_t
ata_last_block_xferred_chs(ata_drv_t * ata_drvp)2734 ata_last_block_xferred_chs(ata_drv_t *ata_drvp)
2735 {
2736 ata_ctl_t *ata_ctlp = ata_drvp->ad_ctlp;
2737 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2738 uchar_t drvheads = ata_drvp->ad_phhd;
2739 uchar_t drvsectors = ata_drvp->ad_phsec;
2740 uchar_t sector;
2741 uchar_t head;
2742 uchar_t low_cyl;
2743 uchar_t hi_cyl;
2744 daddr_t lbastop;
2745
2746 sector = ddi_get8(io_hdl1, ata_ctlp->ac_sect);
2747 head = ddi_get8(io_hdl1, ata_ctlp->ac_drvhd) & 0xf;
2748 low_cyl = ddi_get8(io_hdl1, ata_ctlp->ac_lcyl);
2749 hi_cyl = ddi_get8(io_hdl1, ata_ctlp->ac_hcyl);
2750
2751 lbastop = low_cyl;
2752 lbastop |= (uint_t)hi_cyl << 8;
2753 lbastop *= (uint_t)drvheads;
2754 lbastop += (uint_t)head;
2755 lbastop *= (uint_t)drvsectors;
2756 lbastop += (uint_t)sector - 1;
2757 return (lbastop);
2758 }
2759
2760 static daddr_t
ata_last_block_xferred_lba28(ata_ctl_t * ata_ctlp)2761 ata_last_block_xferred_lba28(ata_ctl_t *ata_ctlp)
2762 {
2763 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2764 daddr_t lbastop;
2765
2766 lbastop = ddi_get8(io_hdl1, ata_ctlp->ac_drvhd) & 0xf;
2767 lbastop <<= 8;
2768 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_hcyl);
2769 lbastop <<= 8;
2770 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_lcyl);
2771 lbastop <<= 8;
2772 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_sect);
2773 return (lbastop);
2774 }
2775
2776 static daddr_t
ata_last_block_xferred_lba48(ata_ctl_t * ata_ctlp)2777 ata_last_block_xferred_lba48(ata_ctl_t *ata_ctlp)
2778 {
2779 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
2780 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
2781 daddr_t lbastop;
2782
2783 /* turn on HOB and read the high-order 24 bits */
2784 ddi_put8(io_hdl2, ata_ctlp->ac_devctl, (ATDC_D3 | ATDC_HOB));
2785 lbastop = ddi_get8(io_hdl1, ata_ctlp->ac_hcyl);
2786 lbastop <<= 8;
2787 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_lcyl);
2788 lbastop <<= 8;
2789 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_sect);
2790 lbastop <<= 8;
2791
2792 /* Turn off HOB and read the low-order 24-bits */
2793 ddi_put8(io_hdl2, ata_ctlp->ac_devctl, (ATDC_D3));
2794 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_hcyl);
2795 lbastop <<= 8;
2796 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_lcyl);
2797 lbastop <<= 8;
2798 lbastop += ddi_get8(io_hdl1, ata_ctlp->ac_sect);
2799 return (lbastop);
2800 }
2801
2802
2803 /*
2804 *
2805 * Need to compute a value for ap_resid so that cp_resid can
2806 * be set by ata_disk_complete(). The cp_resid var is actually
2807 * misnamed. It's actually the offset to the block in which the
2808 * error occurred not the number of bytes transferred to the device.
2809 * At least that's how dadk actually uses the cp_resid when reporting
2810 * an error. In other words the sector that had the error and the
2811 * number of bytes transferred don't always indicate the same offset.
2812 * On top of that, when doing DMA transfers there's actually no
2813 * way to determine how many bytes have been transferred by the DMA
2814 * engine. On the other hand, the drive will report which sector
2815 * it faulted on. Using that address this routine computes the
2816 * number of residual bytes beyond that point which probably weren't
2817 * written to the drive (the drive is allowed to re-order sector
2818 * writes but on an ATA disk there's no way to deal with that
2819 * complication; in other words, the resid value calculated by
2820 * this routine is as good as we can manage).
2821 */
2822
2823 static void
ata_disk_get_resid(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2824 ata_disk_get_resid(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2825 ata_pkt_t *ata_pktp)
2826 {
2827 uint_t lba_start;
2828 uint_t lba_stop;
2829 uint_t resid_bytes;
2830 uint_t resid_sectors;
2831
2832 lba_start = ata_pktp->ap_startsec;
2833
2834 if (ata_drvp->ad_flags & AD_EXT48)
2835 lba_stop = ata_last_block_xferred_lba48(ata_ctlp);
2836 else if (ata_drvp->ad_drive_bits & ATDH_LBA)
2837 lba_stop = ata_last_block_xferred_lba28(ata_ctlp);
2838 else /* CHS mode */
2839 lba_stop = ata_last_block_xferred_chs(ata_drvp);
2840
2841 resid_sectors = lba_start + ata_pktp->ap_count - lba_stop;
2842 resid_bytes = resid_sectors << SCTRSHFT;
2843
2844 ADBG_TRACE(("ata_disk_get_resid start 0x%x cnt 0x%x stop 0x%x\n",
2845 lba_start, ata_pktp->ap_count, lba_stop));
2846 ata_pktp->ap_resid = resid_bytes;
2847 }
2848
2849
2850
2851 /*
2852 * Removable media commands *
2853 */
2854
2855
2856
2857 /*
2858 * get the media status
2859 *
2860 * NOTE: the error handling case probably isn't correct but it
2861 * will have to do until someone gives me a drive to test this on.
2862 */
2863 static int
ata_disk_state(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2864 ata_disk_state(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2865 ata_pkt_t *ata_pktp)
2866 {
2867 int *statep = (int *)ata_pktp->ap_v_addr;
2868 uchar_t err;
2869
2870 ADBG_TRACE(("ata_disk_state\n"));
2871 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000,
2872 ATC_DOOR_LOCK, 0, 0, 0, 0, 0, 0)) {
2873 *statep = DKIO_INSERTED;
2874 return (ATA_FSM_RC_FINI);
2875 }
2876
2877 err = ddi_get8(ata_ctlp->ac_iohandle1, ata_ctlp->ac_error);
2878 if (err & ATE_NM)
2879 *statep = DKIO_EJECTED;
2880 else
2881 *statep = DKIO_NONE;
2882
2883 return (ATA_FSM_RC_FINI);
2884 }
2885
2886 /*
2887 * eject the media
2888 */
2889
2890 static int
ata_disk_eject(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2891 ata_disk_eject(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2892 ata_pkt_t *ata_pktp)
2893 {
2894 ADBG_TRACE(("ata_disk_eject\n"));
2895 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000,
2896 ATC_EJECT, 0, 0, 0, 0, 0, 0)) {
2897 return (ATA_FSM_RC_FINI);
2898 }
2899 ata_pktp->ap_flags |= AP_ERROR;
2900 return (ATA_FSM_RC_FINI);
2901 }
2902
2903 /*
2904 * lock the drive
2905 *
2906 */
2907 static int
ata_disk_lock(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2908 ata_disk_lock(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2909 ata_pkt_t *ata_pktp)
2910 {
2911 ADBG_TRACE(("ata_disk_lock\n"));
2912 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000,
2913 ATC_DOOR_LOCK, 0, 0, 0, 0, 0, 0)) {
2914 return (ATA_FSM_RC_FINI);
2915 }
2916 ata_pktp->ap_flags |= AP_ERROR;
2917 return (ATA_FSM_RC_FINI);
2918 }
2919
2920
2921 /*
2922 * unlock the drive
2923 *
2924 */
2925 static int
ata_disk_unlock(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2926 ata_disk_unlock(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2927 ata_pkt_t *ata_pktp)
2928 {
2929 ADBG_TRACE(("ata_disk_unlock\n"));
2930 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000,
2931 ATC_DOOR_UNLOCK, 0, 0, 0, 0, 0, 0)) {
2932 return (ATA_FSM_RC_FINI);
2933 }
2934 ata_pktp->ap_flags |= AP_ERROR;
2935 return (ATA_FSM_RC_FINI);
2936 }
2937
2938
2939 /*
2940 * put the drive into standby mode
2941 */
2942 static int
ata_disk_standby(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2943 ata_disk_standby(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2944 ata_pkt_t *ata_pktp)
2945 {
2946 ADBG_TRACE(("ata_disk_standby\n"));
2947 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 5 * 1000000,
2948 ATC_STANDBY_IM, 0, 0, 0, 0, 0, 0)) {
2949 return (ATA_FSM_RC_FINI);
2950 }
2951 ata_pktp->ap_flags |= AP_ERROR;
2952 return (ATA_FSM_RC_FINI);
2953 }
2954
2955
2956 /*
2957 * Recalibrate
2958 *
2959 * Note the extra long timeout value. This is necessary in case
2960 * the drive was in standby mode and needs to spin up the media.
2961 *
2962 */
2963 static int
ata_disk_recalibrate(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)2964 ata_disk_recalibrate(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp,
2965 ata_pkt_t *ata_pktp)
2966 {
2967 ADBG_TRACE(("ata_disk_recalibrate\n"));
2968 if (ata_command(ata_ctlp, ata_drvp, TRUE, TRUE, 31 * 1000000,
2969 ATC_RECAL, 0, 0, 0, 0, 0, 0)) {
2970 return (ATA_FSM_RC_FINI);
2971 }
2972 ata_pktp->ap_flags |= AP_ERROR;
2973 return (ATA_FSM_RC_FINI);
2974 }
2975
2976 /*
2977 * Copy a string of bytes that were obtained by Identify Device into a
2978 * string buffer provided by the caller.
2979 *
2980 * 1. Determine the amount to copy. This is the lesser of the
2981 * length of the source string or the space available in the user's
2982 * buffer.
2983 * 2. The true length of the source string is always returned to the
2984 * caller in the size field of the argument.
2985 * 3. Copy the string, add a terminating NUL character at the end.
2986 */
2987
2988 static int
ata_copy_dk_ioc_string(intptr_t arg,char * source,int length,int flag)2989 ata_copy_dk_ioc_string(intptr_t arg, char *source, int length, int flag)
2990 {
2991 STRUCT_DECL(dadk_ioc_string, ds_arg);
2992 int destsize;
2993 char nulchar;
2994 caddr_t outp;
2995
2996 /*
2997 * The ioctls that use this routine are only available to
2998 * the kernel.
2999 */
3000 if ((flag & FKIOCTL) == 0)
3001 return (EFAULT);
3002
3003 STRUCT_INIT(ds_arg, flag & FMODELS);
3004
3005 /* 1. determine size of user's buffer */
3006 if (ddi_copyin((caddr_t)arg, STRUCT_BUF(ds_arg), STRUCT_SIZE(ds_arg),
3007 flag))
3008 return (EFAULT);
3009 destsize = STRUCT_FGET(ds_arg, is_size);
3010 if (destsize > length + 1)
3011 destsize = length + 1;
3012
3013 /*
3014 * 2. Return the copied length to the caller. Note: for
3015 * convenience, we actually copy the entire structure back out, not
3016 * just the length. We don't change the is_buf field, so this
3017 * shouldn't break anything.
3018 */
3019 STRUCT_FSET(ds_arg, is_size, length);
3020 if (ddi_copyout(STRUCT_BUF(ds_arg), (caddr_t)arg, STRUCT_SIZE(ds_arg),
3021 flag))
3022 return (EFAULT);
3023
3024 /* 3. copy the string and add a NULL terminator */
3025 outp = STRUCT_FGETP(ds_arg, is_buf);
3026 if (ddi_copyout(source, outp, destsize - 1, flag))
3027 return (EFAULT);
3028 nulchar = '\0';
3029 if (ddi_copyout(&nulchar, outp + (destsize - 1), 1, flag))
3030 return (EFAULT);
3031 return (0);
3032 }
3033
3034 /*
3035 * Sun branded drives are shipped write cache disabled. The default is to
3036 * force write write caching on.
3037 */
3038 static void
ata_set_write_cache(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp)3039 ata_set_write_cache(ata_ctl_t *ata_ctlp, ata_drv_t *ata_drvp)
3040 {
3041 char *path;
3042
3043 if (!(IS_WRITE_CACHE_SUPPORTED(ata_drvp->ad_id)))
3044 return;
3045
3046 if (ata_write_cache == 1) {
3047 if (ata_set_feature(ata_ctlp, ata_drvp, FC_WRITE_CACHE_ON, 0)
3048 == FALSE) {
3049 path = kmem_alloc(MAXPATHLEN + 1, KM_NOSLEEP);
3050 if (path != NULL) {
3051 cmn_err(CE_WARN,
3052 "%s unable to enable write cache targ=%d",
3053 ddi_pathname(ata_ctlp->ac_dip, path),
3054 ata_drvp->ad_targ);
3055 kmem_free(path, MAXPATHLEN + 1);
3056 }
3057 }
3058 } else if (ata_write_cache == -1) {
3059 if (ata_set_feature(ata_ctlp, ata_drvp, FC_WRITE_CACHE_OFF, 0)
3060 == FALSE) {
3061 path = kmem_alloc(MAXPATHLEN + 1, KM_NOSLEEP);
3062 if (path != NULL) {
3063 cmn_err(CE_WARN,
3064 "%s unable to disable write cache targ=%d",
3065 ddi_pathname(ata_ctlp->ac_dip, path),
3066 ata_drvp->ad_targ);
3067 kmem_free(path, MAXPATHLEN + 1);
3068 }
3069 }
3070 }
3071 }
3072
3073 /*
3074 * Call set feature to spin-up the device.
3075 */
3076 static int
ata_disk_set_feature_spinup(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)3077 ata_disk_set_feature_spinup(
3078 ata_ctl_t *ata_ctlp,
3079 ata_drv_t *ata_drvp,
3080 ata_pkt_t *ata_pktp)
3081 {
3082 int rc;
3083
3084 ADBG_TRACE(("ata_disk_set_feature_spinup entered\n"));
3085
3086 rc = ata_set_feature(ata_ctlp, ata_drvp, 0x07, 0);
3087 if (!rc)
3088 ata_pktp->ap_flags |= AP_ERROR;
3089
3090 return (ATA_FSM_RC_FINI);
3091 }
3092
3093 /*
3094 * Update device ata_id content - IDENTIFY DEVICE command.
3095 */
3096 static int
ata_disk_id_update(ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,ata_pkt_t * ata_pktp)3097 ata_disk_id_update(
3098 ata_ctl_t *ata_ctlp,
3099 ata_drv_t *ata_drvp,
3100 ata_pkt_t *ata_pktp)
3101 {
3102 ddi_acc_handle_t io_hdl1 = ata_ctlp->ac_iohandle1;
3103 caddr_t ioaddr1 = ata_ctlp->ac_ioaddr1;
3104 ddi_acc_handle_t io_hdl2 = ata_ctlp->ac_iohandle2;
3105 caddr_t ioaddr2 = ata_ctlp->ac_ioaddr2;
3106 struct ata_id *aidp = &ata_drvp->ad_id;
3107 int rc;
3108
3109 ADBG_TRACE(("ata_disk_id_update entered\n"));
3110
3111 /*
3112 * select the appropriate drive and LUN
3113 */
3114 ddi_put8(io_hdl1, (uchar_t *)ioaddr1 + AT_DRVHD,
3115 ata_drvp->ad_drive_bits);
3116 ata_nsecwait(400);
3117
3118 /*
3119 * make certain the drive is selected, and wait for not busy
3120 */
3121 if (!ata_wait(io_hdl2, ioaddr2, ATS_DRDY, ATS_BSY, 5 * 1000000)) {
3122 ADBG_ERROR(("ata_disk_id_update: select failed\n"));
3123 ata_pktp->ap_flags |= AP_ERROR;
3124 return (ATA_FSM_RC_FINI);
3125 }
3126
3127 rc = ata_disk_id(io_hdl1, ioaddr1, io_hdl2, ioaddr2, aidp);
3128
3129 if (!rc) {
3130 ata_pktp->ap_flags |= AP_ERROR;
3131 } else {
3132 swab(aidp->ai_drvser, aidp->ai_drvser,
3133 sizeof (aidp->ai_drvser));
3134 swab(aidp->ai_fw, aidp->ai_fw,
3135 sizeof (aidp->ai_fw));
3136 swab(aidp->ai_model, aidp->ai_model,
3137 sizeof (aidp->ai_model));
3138 }
3139
3140 return (ATA_FSM_RC_FINI);
3141 }
3142
3143 /*
3144 * Update device firmware.
3145 */
3146 static int
ata_disk_update_fw(gtgt_t * gtgtp,ata_ctl_t * ata_ctlp,ata_drv_t * ata_drvp,caddr_t fwfile,uint_t size,uint8_t type,int flag)3147 ata_disk_update_fw(gtgt_t *gtgtp, ata_ctl_t *ata_ctlp,
3148 ata_drv_t *ata_drvp, caddr_t fwfile,
3149 uint_t size, uint8_t type, int flag)
3150 {
3151 ata_pkt_t *ata_pktp;
3152 gcmd_t *gcmdp = NULL;
3153 caddr_t fwfile_memp = NULL, tmp_fwfile_memp;
3154 uint_t total_sec_count, sec_count, start_sec = 0;
3155 uint8_t cmd_type;
3156 int rc;
3157
3158 /*
3159 * First check whether DOWNLOAD MICROCODE command is supported
3160 */
3161 if (!(ata_drvp->ad_id.ai_cmdset83 & 0x1)) {
3162 ADBG_ERROR(("drive doesn't support download "
3163 "microcode command\n"));
3164 return (ENOTSUP);
3165 }
3166
3167 switch (type) {
3168 case FW_TYPE_TEMP:
3169 cmd_type = ATCM_FW_TEMP;
3170 break;
3171
3172 case FW_TYPE_PERM:
3173 cmd_type = ATCM_FW_PERM;
3174 break;
3175
3176 default:
3177 return (EINVAL);
3178 }
3179
3180 /* Temporary subcommand is obsolete in ATA/ATAPI-8 version */
3181 if (cmd_type == ATCM_FW_TEMP) {
3182 if (ata_drvp->ad_id.ai_majorversion & ATAC_MAJVER_8) {
3183 ADBG_ERROR(("Temporary use is obsolete in "
3184 "ATA/ATAPI-8 version\n"));
3185 return (ENOTSUP);
3186 }
3187 }
3188
3189 total_sec_count = size >> SCTRSHFT;
3190 if (total_sec_count > MAX_FWFILE_SIZE_ONECMD) {
3191 if (cmd_type == ATCM_FW_TEMP) {
3192 ADBG_ERROR(("firmware size: %x sectors is too large\n",
3193 total_sec_count));
3194 return (EINVAL);
3195 } else {
3196 ADBG_WARN(("firmware size: %x sectors is larger than"
3197 " one command, need to use the multicommand"
3198 " subcommand\n", total_sec_count));
3199
3200 cmd_type = ATCM_FW_MULTICMD;
3201 if (!(ata_drvp->ad_id.ai_padding2[15] & 0x10)) {
3202 ADBG_ERROR(("This drive doesn't support "
3203 "the multicommand subcommand\n"));
3204 return (ENOTSUP);
3205 }
3206 }
3207 }
3208
3209 fwfile_memp = kmem_zalloc(size, KM_SLEEP);
3210
3211 if (ddi_copyin(fwfile, fwfile_memp, size, flag)) {
3212 ADBG_ERROR(("ata_disk_update_fw copyin failed\n"));
3213 rc = EFAULT;
3214 goto done;
3215 }
3216
3217 tmp_fwfile_memp = fwfile_memp;
3218
3219 for (; total_sec_count > 0; ) {
3220 if ((gcmdp == NULL) && !(gcmdp =
3221 ghd_gcmd_alloc(gtgtp, sizeof (*ata_pktp), TRUE))) {
3222 ADBG_ERROR(("ata_disk_update_fw alloc failed\n"));
3223 rc = ENOMEM;
3224 goto done;
3225 }
3226
3227 /* set the back ptr from the ata_pkt to the gcmd_t */
3228 ata_pktp = GCMD2APKT(gcmdp);
3229 ata_pktp->ap_gcmdp = gcmdp;
3230 ata_pktp->ap_hd = ata_drvp->ad_drive_bits;
3231 ata_pktp->ap_bytes_per_block = ata_drvp->ad_bytes_per_block;
3232
3233 /* use PIO mode to update disk firmware */
3234 ata_pktp->ap_start = ata_disk_start_pio_out;
3235 ata_pktp->ap_intr = ata_disk_intr_pio_out;
3236 ata_pktp->ap_complete = NULL;
3237
3238 ata_pktp->ap_cmd = ATC_LOAD_FW;
3239 /* use ap_bcount to set subcommand code */
3240 ata_pktp->ap_bcount = (size_t)cmd_type;
3241 ata_pktp->ap_pciide_dma = FALSE;
3242 ata_pktp->ap_sg_cnt = 0;
3243
3244 sec_count = min(total_sec_count, MAX_FWFILE_SIZE_ONECMD);
3245 ata_pktp->ap_flags = 0;
3246
3247 ata_pktp->ap_count = (ushort_t)sec_count;
3248 ata_pktp->ap_startsec = start_sec;
3249 ata_pktp->ap_v_addr = tmp_fwfile_memp;
3250 ata_pktp->ap_resid = sec_count << SCTRSHFT;
3251
3252 /* add it to the queue, and use POLL mode */
3253 rc = ghd_transport(&ata_ctlp->ac_ccc, gcmdp, gcmdp->cmd_gtgtp,
3254 ata_disk_updatefw_time, TRUE, NULL);
3255
3256 if (rc != TRAN_ACCEPT) {
3257 /* this should never, ever happen */
3258 rc = ENOTSUP;
3259 goto done;
3260 }
3261
3262 if (ata_pktp->ap_flags & AP_ERROR) {
3263 if (ata_pktp->ap_error & ATE_ABORT) {
3264 rc = ENOTSUP;
3265 } else
3266 rc = EIO;
3267 goto done;
3268
3269 } else {
3270 total_sec_count -= sec_count;
3271 tmp_fwfile_memp += sec_count << SCTRSHFT;
3272 start_sec += sec_count;
3273 }
3274 }
3275
3276 rc = 0;
3277 done:
3278 if (gcmdp != NULL)
3279 ghd_gcmd_free(gcmdp);
3280
3281 kmem_free(fwfile_memp, size);
3282
3283 return (rc);
3284 }
3285