blob: 94144ed50a6bd2cd6def54983ccf08b52ada97fd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Garzikaf36d7f2005-08-28 20:18:39 -04002 * libata-scsi.c - helper library for ATA
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware documentation available from
31 * - http://www.t10.org/
32 * - http://www.t13.org/
33 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 */
35
36#include <linux/kernel.h>
37#include <linux/blkdev.h>
38#include <linux/spinlock.h>
39#include <scsi/scsi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <scsi/scsi_host.h>
Christoph Hellwigbeb40482006-06-10 18:01:03 +020041#include <scsi/scsi_cmnd.h>
Mike Christie85837eb2005-11-11 16:38:53 -060042#include <scsi/scsi_eh.h>
Jeff Garzik005a5a02005-10-30 23:31:48 -050043#include <scsi/scsi_device.h>
Tejun Heoa6e6ce82006-05-15 21:03:48 +090044#include <scsi/scsi_tcq.h>
Tejun Heo30afc842006-03-18 18:40:14 +090045#include <scsi/scsi_transport.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/libata.h>
Jeff Garzikb0955182005-05-12 15:45:22 -040047#include <linux/hdreg.h>
Jeff Garzik2dcb4072007-10-19 06:42:56 -040048#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#include "libata.h"
51
Jeff Garzikb0955182005-05-12 15:45:22 -040052#define SECTOR_SIZE 512
53
Tejun Heoad706992006-12-17 10:45:57 +090054typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
Tejun Heoab5b3a52006-05-31 18:27:34 +090055
Jeff Garzik2dcb4072007-10-19 06:42:56 -040056static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
Tejun Heoab5b3a52006-05-31 18:27:34 +090057 const struct scsi_device *scsidev);
Jeff Garzik2dcb4072007-10-19 06:42:56 -040058static struct ata_device *ata_scsi_find_dev(struct ata_port *ap,
Tejun Heoab5b3a52006-05-31 18:27:34 +090059 const struct scsi_device *scsidev);
Tejun Heo83c47bc2006-05-31 18:28:07 +090060static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
61 unsigned int id, unsigned int lun);
Tejun Heoab5b3a52006-05-31 18:27:34 +090062
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Douglas Gilbert00ac37f2005-10-28 15:58:28 -040064#define RW_RECOVERY_MPAGE 0x1
65#define RW_RECOVERY_MPAGE_LEN 12
66#define CACHE_MPAGE 0x8
67#define CACHE_MPAGE_LEN 20
68#define CONTROL_MPAGE 0xa
69#define CONTROL_MPAGE_LEN 12
70#define ALL_MPAGES 0x3f
71#define ALL_SUB_MPAGES 0xff
72
73
Jeff Garzik24f75682007-09-21 07:54:49 -040074static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
Douglas Gilbert00ac37f2005-10-28 15:58:28 -040075 RW_RECOVERY_MPAGE,
76 RW_RECOVERY_MPAGE_LEN - 2,
Jeff Garzik24f75682007-09-21 07:54:49 -040077 (1 << 7), /* AWRE */
Douglas Gilbert00ac37f2005-10-28 15:58:28 -040078 0, /* read retry count */
79 0, 0, 0, 0,
80 0, /* write retry count */
81 0, 0, 0
82};
83
84static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
85 CACHE_MPAGE,
86 CACHE_MPAGE_LEN - 2,
87 0, /* contains WCE, needs to be 0 for logic */
88 0, 0, 0, 0, 0, 0, 0, 0, 0,
89 0, /* contains DRA, needs to be 0 for logic */
90 0, 0, 0, 0, 0, 0, 0
91};
92
93static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
94 CONTROL_MPAGE,
95 CONTROL_MPAGE_LEN - 2,
96 2, /* DSENSE=0, GLTSD=1 */
97 0, /* [QAM+QERR may be 1, see 05-359r1] */
98 0, 0, 0, 0, 0xff, 0xff,
99 0, 30 /* extended self test time, see 05-359r1 */
100};
101
Tejun Heo30afc842006-03-18 18:40:14 +0900102/*
103 * libata transport template. libata doesn't do real transport stuff.
104 * It just needs the eh_timed_out hook.
105 */
Tejun Heof3187192007-04-17 23:44:07 +0900106static struct scsi_transport_template ata_scsi_transport_template = {
Christoph Hellwig9227c332006-04-01 19:21:04 +0200107 .eh_strategy_handler = ata_scsi_error,
Tejun Heo30afc842006-03-18 18:40:14 +0900108 .eh_timed_out = ata_scsi_timed_out,
Tejun Heoccf68c32006-05-31 18:28:09 +0900109 .user_scan = ata_scsi_user_scan,
Tejun Heo30afc842006-03-18 18:40:14 +0900110};
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Kristen Carlson Accardica773292007-10-25 00:58:59 -0400113static const struct {
114 enum link_pm value;
115 const char *name;
116} link_pm_policy[] = {
117 { NOT_AVAILABLE, "max_performance" },
118 { MIN_POWER, "min_power" },
119 { MAX_PERFORMANCE, "max_performance" },
120 { MEDIUM_POWER, "medium_power" },
121};
122
Adrian Bunka2d6ed12007-10-31 00:50:23 +0100123static const char *ata_scsi_lpm_get(enum link_pm policy)
Kristen Carlson Accardica773292007-10-25 00:58:59 -0400124{
125 int i;
126
127 for (i = 0; i < ARRAY_SIZE(link_pm_policy); i++)
128 if (link_pm_policy[i].value == policy)
129 return link_pm_policy[i].name;
130
131 return NULL;
132}
133
134static ssize_t ata_scsi_lpm_put(struct class_device *class_dev,
135 const char *buf, size_t count)
136{
137 struct Scsi_Host *shost = class_to_shost(class_dev);
138 struct ata_port *ap = ata_shost_to_port(shost);
139 enum link_pm policy = 0;
140 int i;
141
142 /*
143 * we are skipping array location 0 on purpose - this
144 * is because a value of NOT_AVAILABLE is displayed
145 * to the user as max_performance, but when the user
146 * writes "max_performance", they actually want the
147 * value to match MAX_PERFORMANCE.
148 */
149 for (i = 1; i < ARRAY_SIZE(link_pm_policy); i++) {
150 const int len = strlen(link_pm_policy[i].name);
151 if (strncmp(link_pm_policy[i].name, buf, len) == 0 &&
152 buf[len] == '\n') {
153 policy = link_pm_policy[i].value;
154 break;
155 }
156 }
157 if (!policy)
158 return -EINVAL;
159
160 ata_lpm_schedule(ap, policy);
161 return count;
162}
163
164static ssize_t
165ata_scsi_lpm_show(struct class_device *class_dev, char *buf)
166{
167 struct Scsi_Host *shost = class_to_shost(class_dev);
168 struct ata_port *ap = ata_shost_to_port(shost);
169 const char *policy =
170 ata_scsi_lpm_get(ap->pm_policy);
171
172 if (!policy)
173 return -EINVAL;
174
175 return snprintf(buf, 23, "%s\n", policy);
176}
177CLASS_DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
178 ata_scsi_lpm_show, ata_scsi_lpm_put);
179EXPORT_SYMBOL_GPL(class_device_attr_link_power_management_policy);
180
Douglas Gilbertae006512005-10-09 09:09:35 -0400181static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
182 void (*done)(struct scsi_cmnd *))
183{
184 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
185 /* "Invalid field in cbd" */
186 done(cmd);
187}
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189/**
190 * ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
191 * @sdev: SCSI device for which BIOS geometry is to be determined
192 * @bdev: block device associated with @sdev
193 * @capacity: capacity of SCSI device
194 * @geom: location to which geometry will be output
195 *
196 * Generic bios head/sector/cylinder calculator
197 * used by sd. Most BIOSes nowadays expect a XXX/255/16 (CHS)
198 * mapping. Some situations may arise where the disk is not
199 * bootable if this is not used.
200 *
201 * LOCKING:
202 * Defined by the SCSI layer. We don't really care.
203 *
204 * RETURNS:
205 * Zero.
206 */
207int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
208 sector_t capacity, int geom[])
209{
210 geom[0] = 255;
211 geom[1] = 63;
212 sector_div(capacity, 255*63);
213 geom[2] = capacity;
214
215 return 0;
216}
217
Jeff Garzikb0955182005-05-12 15:45:22 -0400218/**
Tejun Heo5924b742007-01-02 20:20:07 +0900219 * ata_get_identity - Handler for HDIO_GET_IDENTITY ioctl
220 * @sdev: SCSI device to get identify data for
221 * @arg: User buffer area for identify data
222 *
223 * LOCKING:
224 * Defined by the SCSI layer. We don't really care.
225 *
226 * RETURNS:
227 * Zero on success, negative errno on error.
228 */
229static int ata_get_identity(struct scsi_device *sdev, void __user *arg)
230{
231 struct ata_port *ap = ata_shost_to_port(sdev->host);
232 struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
233 u16 __user *dst = arg;
234 char buf[40];
235
236 if (!dev)
237 return -ENOMSG;
238
239 if (copy_to_user(dst, dev->id, ATA_ID_WORDS * sizeof(u16)))
240 return -EFAULT;
241
242 ata_id_string(dev->id, buf, ATA_ID_PROD, ATA_ID_PROD_LEN);
243 if (copy_to_user(dst + ATA_ID_PROD, buf, ATA_ID_PROD_LEN))
244 return -EFAULT;
245
246 ata_id_string(dev->id, buf, ATA_ID_FW_REV, ATA_ID_FW_REV_LEN);
247 if (copy_to_user(dst + ATA_ID_FW_REV, buf, ATA_ID_FW_REV_LEN))
248 return -EFAULT;
249
250 ata_id_string(dev->id, buf, ATA_ID_SERNO, ATA_ID_SERNO_LEN);
251 if (copy_to_user(dst + ATA_ID_SERNO, buf, ATA_ID_SERNO_LEN))
252 return -EFAULT;
253
254 return 0;
255}
256
257/**
Jeff Garzikb0955182005-05-12 15:45:22 -0400258 * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
Randy Dunlap8e8b77d2005-11-01 21:29:27 -0800259 * @scsidev: Device to which we are issuing command
Jeff Garzikb0955182005-05-12 15:45:22 -0400260 * @arg: User provided data for issuing command
261 *
262 * LOCKING:
263 * Defined by the SCSI layer. We don't really care.
264 *
265 * RETURNS:
266 * Zero on success, negative errno on error.
267 */
Jeff Garzikb0955182005-05-12 15:45:22 -0400268int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
269{
270 int rc = 0;
271 u8 scsi_cmd[MAX_COMMAND_SIZE];
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700272 u8 args[4], *argbuf = NULL, *sensebuf = NULL;
Jeff Garzikb0955182005-05-12 15:45:22 -0400273 int argsize = 0;
Mike Christie85837eb2005-11-11 16:38:53 -0600274 enum dma_data_direction data_dir;
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700275 int cmd_result;
Jeff Garzikb0955182005-05-12 15:45:22 -0400276
Randy Dunlapc893a3a2006-01-28 13:15:32 -0500277 if (arg == NULL)
Jeff Garzikb0955182005-05-12 15:45:22 -0400278 return -EINVAL;
279
280 if (copy_from_user(args, arg, sizeof(args)))
281 return -EFAULT;
282
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700283 sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
284 if (!sensebuf)
285 return -ENOMEM;
286
Jeff Garzikb0955182005-05-12 15:45:22 -0400287 memset(scsi_cmd, 0, sizeof(scsi_cmd));
288
289 if (args[3]) {
290 argsize = SECTOR_SIZE * args[3];
291 argbuf = kmalloc(argsize, GFP_KERNEL);
Jeff Raubitschek54dac832005-10-04 10:21:19 -0400292 if (argbuf == NULL) {
293 rc = -ENOMEM;
294 goto error;
295 }
Jeff Garzikb0955182005-05-12 15:45:22 -0400296
297 scsi_cmd[1] = (4 << 1); /* PIO Data-in */
298 scsi_cmd[2] = 0x0e; /* no off.line or cc, read from dev,
Jeff Garzik2dcb4072007-10-19 06:42:56 -0400299 block count in sector count field */
Mike Christie85837eb2005-11-11 16:38:53 -0600300 data_dir = DMA_FROM_DEVICE;
Jeff Garzikb0955182005-05-12 15:45:22 -0400301 } else {
302 scsi_cmd[1] = (3 << 1); /* Non-data */
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700303 scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
Mike Christie85837eb2005-11-11 16:38:53 -0600304 data_dir = DMA_NONE;
Jeff Garzikb0955182005-05-12 15:45:22 -0400305 }
306
307 scsi_cmd[0] = ATA_16;
308
309 scsi_cmd[4] = args[2];
310 if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
311 scsi_cmd[6] = args[3];
312 scsi_cmd[8] = args[1];
313 scsi_cmd[10] = 0x4f;
314 scsi_cmd[12] = 0xc2;
315 } else {
316 scsi_cmd[6] = args[1];
317 }
318 scsi_cmd[14] = args[0];
319
320 /* Good values for timeout and retries? Values below
321 from scsi_ioctl_send_command() for default case... */
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700322 cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
Jeff Garzik2dcb4072007-10-19 06:42:56 -0400323 sensebuf, (10*HZ), 5, 0);
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700324
325 if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
326 u8 *desc = sensebuf + 8;
327 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
328
329 /* If we set cc then ATA pass-through will cause a
330 * check condition even if no error. Filter that. */
331 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
332 struct scsi_sense_hdr sshdr;
333 scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
Jeff Garzik2dcb4072007-10-19 06:42:56 -0400334 &sshdr);
335 if (sshdr.sense_key == 0 &&
336 sshdr.asc == 0 && sshdr.ascq == 0)
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700337 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
338 }
339
340 /* Send userspace a few ATA registers (same as drivers/ide) */
Jeff Garzik2dcb4072007-10-19 06:42:56 -0400341 if (sensebuf[0] == 0x72 && /* format is "descriptor" */
342 desc[0] == 0x09) { /* code is "ATA Descriptor" */
343 args[0] = desc[13]; /* status */
344 args[1] = desc[3]; /* error */
345 args[2] = desc[5]; /* sector count (0:7) */
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700346 if (copy_to_user(arg, args, sizeof(args)))
347 rc = -EFAULT;
348 }
349 }
350
351
352 if (cmd_result) {
Jeff Garzikb0955182005-05-12 15:45:22 -0400353 rc = -EIO;
354 goto error;
355 }
356
Jeff Garzikb0955182005-05-12 15:45:22 -0400357 if ((argbuf)
Randy Dunlapc893a3a2006-01-28 13:15:32 -0500358 && copy_to_user(arg + sizeof(args), argbuf, argsize))
Jeff Garzikb0955182005-05-12 15:45:22 -0400359 rc = -EFAULT;
360error:
Eran Tromerbbe1fe72006-10-10 14:29:25 -0700361 kfree(sensebuf);
Jesper Juhl8f760782006-06-27 02:55:06 -0700362 kfree(argbuf);
Jeff Garzikb0955182005-05-12 15:45:22 -0400363 return rc;
364}
365
366/**
367 * ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
Randy Dunlap8e8b77d2005-11-01 21:29:27 -0800368 * @scsidev: Device to which we are issuing command
Jeff Garzikb0955182005-05-12 15:45:22 -0400369 * @arg: User provided data for issuing command
370 *
371 * LOCKING:
372 * Defined by the SCSI layer. We don't really care.
373 *
374 * RETURNS:
375 * Zero on success, negative errno on error.
376 */
377int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
378{
379 int rc = 0;
380 u8 scsi_cmd[MAX_COMMAND_SIZE];
David Milburnaf068bd2007-01-30 00:59:15 -0800381 u8 args[7], *sensebuf = NULL;
382 int cmd_result;
Jeff Garzikb0955182005-05-12 15:45:22 -0400383
Randy Dunlapc893a3a2006-01-28 13:15:32 -0500384 if (arg == NULL)
Jeff Garzikb0955182005-05-12 15:45:22 -0400385 return -EINVAL;
386
387 if (copy_from_user(args, arg, sizeof(args)))
388 return -EFAULT;
389
David Milburnaf068bd2007-01-30 00:59:15 -0800390 sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
391 if (!sensebuf)
392 return -ENOMEM;
393
Jeff Garzikb0955182005-05-12 15:45:22 -0400394 memset(scsi_cmd, 0, sizeof(scsi_cmd));
395 scsi_cmd[0] = ATA_16;
396 scsi_cmd[1] = (3 << 1); /* Non-data */
David Milburnaf068bd2007-01-30 00:59:15 -0800397 scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
Jeff Garzikb0955182005-05-12 15:45:22 -0400398 scsi_cmd[4] = args[1];
399 scsi_cmd[6] = args[2];
400 scsi_cmd[8] = args[3];
401 scsi_cmd[10] = args[4];
402 scsi_cmd[12] = args[5];
Mark Lord277239f2007-03-30 17:45:52 -0400403 scsi_cmd[13] = args[6] & 0x4f;
Jeff Garzikb0955182005-05-12 15:45:22 -0400404 scsi_cmd[14] = args[0];
405
Jeff Garzikb0955182005-05-12 15:45:22 -0400406 /* Good values for timeout and retries? Values below
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500407 from scsi_ioctl_send_command() for default case... */
David Milburnaf068bd2007-01-30 00:59:15 -0800408 cmd_result = scsi_execute(scsidev, scsi_cmd, DMA_NONE, NULL, 0,
409 sensebuf, (10*HZ), 5, 0);
Jeff Garzikb0955182005-05-12 15:45:22 -0400410
David Milburnaf068bd2007-01-30 00:59:15 -0800411 if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
412 u8 *desc = sensebuf + 8;
413 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
414
415 /* If we set cc then ATA pass-through will cause a
416 * check condition even if no error. Filter that. */
417 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
418 struct scsi_sense_hdr sshdr;
419 scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
420 &sshdr);
Jeff Garzik2dcb4072007-10-19 06:42:56 -0400421 if (sshdr.sense_key == 0 &&
422 sshdr.asc == 0 && sshdr.ascq == 0)
David Milburnaf068bd2007-01-30 00:59:15 -0800423 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
424 }
425
426 /* Send userspace ATA registers */
427 if (sensebuf[0] == 0x72 && /* format is "descriptor" */
428 desc[0] == 0x09) {/* code is "ATA Descriptor" */
429 args[0] = desc[13]; /* status */
430 args[1] = desc[3]; /* error */
431 args[2] = desc[5]; /* sector count (0:7) */
432 args[3] = desc[7]; /* lbal */
433 args[4] = desc[9]; /* lbam */
434 args[5] = desc[11]; /* lbah */
435 args[6] = desc[12]; /* select */
436 if (copy_to_user(arg, args, sizeof(args)))
437 rc = -EFAULT;
438 }
439 }
440
441 if (cmd_result) {
442 rc = -EIO;
443 goto error;
444 }
445
446 error:
447 kfree(sensebuf);
Jeff Garzikb0955182005-05-12 15:45:22 -0400448 return rc;
449}
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
452{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 int val = -EINVAL, rc = -EINVAL;
454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 switch (cmd) {
456 case ATA_IOC_GET_IO32:
457 val = 0;
458 if (copy_to_user(arg, &val, 1))
459 return -EFAULT;
460 return 0;
461
462 case ATA_IOC_SET_IO32:
463 val = (unsigned long) arg;
464 if (val != 0)
465 return -EINVAL;
466 return 0;
467
Tejun Heo5924b742007-01-02 20:20:07 +0900468 case HDIO_GET_IDENTITY:
469 return ata_get_identity(scsidev, arg);
470
Jeff Garzikb0955182005-05-12 15:45:22 -0400471 case HDIO_DRIVE_CMD:
472 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
473 return -EACCES;
474 return ata_cmd_ioctl(scsidev, arg);
475
476 case HDIO_DRIVE_TASK:
477 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
478 return -EACCES;
479 return ata_task_ioctl(scsidev, arg);
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 default:
482 rc = -ENOTTY;
483 break;
484 }
485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return rc;
487}
488
489/**
490 * ata_scsi_qc_new - acquire new ata_queued_cmd reference
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 * @dev: ATA device to which the new command is attached
492 * @cmd: SCSI command that originated this ATA command
493 * @done: SCSI command completion function
494 *
495 * Obtain a reference to an unused ata_queued_cmd structure,
496 * which is the basic libata structure representing a single
497 * ATA command sent to the hardware.
498 *
499 * If a command was available, fill in the SCSI-specific
500 * portions of the structure with information on the
501 * current command.
502 *
503 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400504 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 *
506 * RETURNS:
507 * Command allocated, or %NULL if none available.
508 */
Adrian Bunk7102d232007-01-04 00:09:36 +0100509static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
510 struct scsi_cmnd *cmd,
511 void (*done)(struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 struct ata_queued_cmd *qc;
514
Tejun Heo3373efd2006-05-15 20:57:53 +0900515 qc = ata_qc_new_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 if (qc) {
517 qc->scsicmd = cmd;
518 qc->scsidone = done;
519
Boaz Harrosh71201652007-09-18 17:48:50 +0200520 qc->__sg = scsi_sglist(cmd);
521 qc->n_elem = scsi_sg_count(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 } else {
523 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
524 done(cmd);
525 }
526
527 return qc;
528}
529
530/**
Jeff Garzikb0955182005-05-12 15:45:22 -0400531 * ata_dump_status - user friendly display of error info
532 * @id: id of the port in question
533 * @tf: ptr to filled out taskfile
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 *
Jeff Garzikb0955182005-05-12 15:45:22 -0400535 * Decode and dump the ATA error/status registers for the user so
536 * that they have some idea what really happened at the non
537 * make-believe layer.
538 *
539 * LOCKING:
540 * inherited from caller
541 */
Adrian Bunk7102d232007-01-04 00:09:36 +0100542static void ata_dump_status(unsigned id, struct ata_taskfile *tf)
Jeff Garzikb0955182005-05-12 15:45:22 -0400543{
544 u8 stat = tf->command, err = tf->feature;
545
546 printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
547 if (stat & ATA_BUSY) {
548 printk("Busy }\n"); /* Data is not valid in this case */
549 } else {
550 if (stat & 0x40) printk("DriveReady ");
551 if (stat & 0x20) printk("DeviceFault ");
552 if (stat & 0x10) printk("SeekComplete ");
553 if (stat & 0x08) printk("DataRequest ");
554 if (stat & 0x04) printk("CorrectedError ");
555 if (stat & 0x02) printk("Index ");
556 if (stat & 0x01) printk("Error ");
557 printk("}\n");
558
559 if (err) {
560 printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
561 if (err & 0x04) printk("DriveStatusError ");
562 if (err & 0x80) {
563 if (err & 0x04) printk("BadCRC ");
564 else printk("Sector ");
565 }
566 if (err & 0x40) printk("UncorrectableError ");
567 if (err & 0x10) printk("SectorIdNotFound ");
568 if (err & 0x02) printk("TrackZeroNotFound ");
569 if (err & 0x01) printk("AddrMarkNotFound ");
570 printk("}\n");
571 }
572 }
573}
574
575/**
576 * ata_to_sense_error - convert ATA error to SCSI error
Randy Dunlap8e8b77d2005-11-01 21:29:27 -0800577 * @id: ATA device number
Jeff Garzikb0955182005-05-12 15:45:22 -0400578 * @drv_stat: value contained in ATA status register
579 * @drv_err: value contained in ATA error register
580 * @sk: the sense key we'll fill out
581 * @asc: the additional sense code we'll fill out
582 * @ascq: the additional sense code qualifier we'll fill out
Tejun Heo246619d2006-05-15 20:58:16 +0900583 * @verbose: be verbose
Jeff Garzikb0955182005-05-12 15:45:22 -0400584 *
585 * Converts an ATA error into a SCSI error. Fill out pointers to
586 * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
587 * format sense blocks.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 *
589 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400590 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 */
Adrian Bunk7102d232007-01-04 00:09:36 +0100592static void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk,
593 u8 *asc, u8 *ascq, int verbose)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Jeff Garzikb0955182005-05-12 15:45:22 -0400595 int i;
Jeff Garzikffe75ef2005-10-09 10:40:44 -0400596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 /* Based on the 3ware driver translation table */
Arjan van de Ven98ac62d2005-11-28 10:06:23 +0100598 static const unsigned char sense_table[][4] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 /* BBD|ECC|ID|MAR */
600 {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
601 /* BBD|ECC|ID */
602 {0xd0, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
603 /* ECC|MC|MARK */
604 {0x61, HARDWARE_ERROR, 0x00, 0x00}, // Device fault Hardware error
605 /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
606 {0x84, ABORTED_COMMAND, 0x47, 0x00}, // Data CRC error SCSI parity error
607 /* MC|ID|ABRT|TRK0|MARK */
608 {0x37, NOT_READY, 0x04, 0x00}, // Unit offline Not ready
609 /* MCR|MARK */
610 {0x09, NOT_READY, 0x04, 0x00}, // Unrecovered disk error Not ready
611 /* Bad address mark */
612 {0x01, MEDIUM_ERROR, 0x13, 0x00}, // Address mark not found Address mark not found for data field
613 /* TRK0 */
614 {0x02, HARDWARE_ERROR, 0x00, 0x00}, // Track 0 not found Hardware error
615 /* Abort & !ICRC */
616 {0x04, ABORTED_COMMAND, 0x00, 0x00}, // Aborted command Aborted command
617 /* Media change request */
618 {0x08, NOT_READY, 0x04, 0x00}, // Media change request FIXME: faking offline
619 /* SRV */
620 {0x10, ABORTED_COMMAND, 0x14, 0x00}, // ID not found Recorded entity not found
621 /* Media change */
622 {0x08, NOT_READY, 0x04, 0x00}, // Media change FIXME: faking offline
623 /* ECC */
624 {0x40, MEDIUM_ERROR, 0x11, 0x04}, // Uncorrectable ECC error Unrecovered read error
625 /* BBD - block marked bad */
626 {0x80, MEDIUM_ERROR, 0x11, 0x04}, // Block marked bad Medium error, unrecovered read error
627 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
628 };
Arjan van de Ven98ac62d2005-11-28 10:06:23 +0100629 static const unsigned char stat_table[][4] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 /* Must be first because BUSY means no other bits valid */
631 {0x80, ABORTED_COMMAND, 0x47, 0x00}, // Busy, fake parity for now
632 {0x20, HARDWARE_ERROR, 0x00, 0x00}, // Device fault
633 {0x08, ABORTED_COMMAND, 0x47, 0x00}, // Timed out in xfer, fake parity for now
634 {0x04, RECOVERED_ERROR, 0x11, 0x00}, // Recovered ECC error Medium error, recovered
635 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
636 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 /*
639 * Is this an error we can process/parse
640 */
Jeff Garzikb0955182005-05-12 15:45:22 -0400641 if (drv_stat & ATA_BUSY) {
642 drv_err = 0; /* Ignore the err bits, they're invalid */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Jeff Garzikb0955182005-05-12 15:45:22 -0400645 if (drv_err) {
646 /* Look for drv_err */
647 for (i = 0; sense_table[i][0] != 0xFF; i++) {
648 /* Look for best matches first */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -0500649 if ((sense_table[i][0] & drv_err) ==
Jeff Garzikb0955182005-05-12 15:45:22 -0400650 sense_table[i][0]) {
651 *sk = sense_table[i][1];
652 *asc = sense_table[i][2];
653 *ascq = sense_table[i][3];
654 goto translate_done;
655 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 }
Jeff Garzikb0955182005-05-12 15:45:22 -0400657 /* No immediate match */
Tejun Heo246619d2006-05-15 20:58:16 +0900658 if (verbose)
659 printk(KERN_WARNING "ata%u: no sense translation for "
660 "error 0x%02x\n", id, drv_err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 }
662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 /* Fall back to interpreting status bits */
Jeff Garzikb0955182005-05-12 15:45:22 -0400664 for (i = 0; stat_table[i][0] != 0xFF; i++) {
665 if (stat_table[i][0] & drv_stat) {
666 *sk = stat_table[i][1];
667 *asc = stat_table[i][2];
668 *ascq = stat_table[i][3];
669 goto translate_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 }
Jeff Garzikb0955182005-05-12 15:45:22 -0400672 /* No error? Undecoded? */
Tejun Heo246619d2006-05-15 20:58:16 +0900673 if (verbose)
674 printk(KERN_WARNING "ata%u: no sense translation for "
675 "status: 0x%02x\n", id, drv_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Alan Cox2d202022006-03-21 15:53:46 +0000677 /* We need a sensible error return here, which is tricky, and one
678 that won't cause people to do things like return a disk wrongly */
679 *sk = ABORTED_COMMAND;
680 *asc = 0x00;
681 *ascq = 0x00;
Jeff Garzikb0955182005-05-12 15:45:22 -0400682
683 translate_done:
Tejun Heo246619d2006-05-15 20:58:16 +0900684 if (verbose)
685 printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x "
686 "to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
687 id, drv_stat, drv_err, *sk, *asc, *ascq);
Jeff Garzikb0955182005-05-12 15:45:22 -0400688 return;
689}
690
691/*
Tejun Heo750426a2006-11-14 22:37:35 +0900692 * ata_gen_passthru_sense - Generate check condition sense block.
Jeff Garzikb0955182005-05-12 15:45:22 -0400693 * @qc: Command that completed.
694 *
695 * This function is specific to the ATA descriptor format sense
696 * block specified for the ATA pass through commands. Regardless
697 * of whether the command errored or not, return a sense
698 * block. Copy all controller registers into the sense
699 * block. Clear sense key, ASC & ASCQ if there is no error.
700 *
701 * LOCKING:
Tejun Heo750426a2006-11-14 22:37:35 +0900702 * None.
Jeff Garzikb0955182005-05-12 15:45:22 -0400703 */
Tejun Heo750426a2006-11-14 22:37:35 +0900704static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
Jeff Garzikb0955182005-05-12 15:45:22 -0400705{
706 struct scsi_cmnd *cmd = qc->scsicmd;
Tejun Heoe61e0672006-05-15 20:57:40 +0900707 struct ata_taskfile *tf = &qc->result_tf;
Jeff Garzikb0955182005-05-12 15:45:22 -0400708 unsigned char *sb = cmd->sense_buffer;
709 unsigned char *desc = sb + 8;
Tejun Heo246619d2006-05-15 20:58:16 +0900710 int verbose = qc->ap->ops->error_handler == NULL;
Jeff Garzikb0955182005-05-12 15:45:22 -0400711
712 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
713
Jeff Garzik0e5dec42005-10-06 09:40:20 -0400714 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
Jeff Garzikb0955182005-05-12 15:45:22 -0400715
716 /*
Jeff Garzikb0955182005-05-12 15:45:22 -0400717 * Use ata_to_sense_error() to map status register bits
718 * onto sense key, asc & ascq.
719 */
Tejun Heo058e55e2006-04-02 18:51:53 +0900720 if (qc->err_mask ||
721 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
Tejun Heo44877b42007-02-21 01:06:51 +0900722 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
Tejun Heo246619d2006-05-15 20:58:16 +0900723 &sb[1], &sb[2], &sb[3], verbose);
Jeff Garzikb0955182005-05-12 15:45:22 -0400724 sb[1] &= 0x0f;
725 }
726
727 /*
728 * Sense data is current and format is descriptor.
729 */
730 sb[0] = 0x72;
731
732 desc[0] = 0x09;
733
Tejun Heof38621b2006-11-14 22:37:35 +0900734 /* set length of additional sense data */
735 sb[7] = 14;
736 desc[1] = 12;
Jeff Garzikb0955182005-05-12 15:45:22 -0400737
738 /*
739 * Copy registers into sense buffer.
740 */
741 desc[2] = 0x00;
742 desc[3] = tf->feature; /* == error reg */
743 desc[5] = tf->nsect;
744 desc[7] = tf->lbal;
745 desc[9] = tf->lbam;
746 desc[11] = tf->lbah;
747 desc[12] = tf->device;
748 desc[13] = tf->command; /* == status reg */
749
750 /*
751 * Fill in Extend bit, and the high order bytes
752 * if applicable.
753 */
754 if (tf->flags & ATA_TFLAG_LBA48) {
755 desc[2] |= 0x01;
756 desc[4] = tf->hob_nsect;
757 desc[6] = tf->hob_lbal;
758 desc[8] = tf->hob_lbam;
759 desc[10] = tf->hob_lbah;
760 }
761}
762
763/**
Tejun Heo750426a2006-11-14 22:37:35 +0900764 * ata_gen_ata_sense - generate a SCSI fixed sense block
Jeff Garzikb0955182005-05-12 15:45:22 -0400765 * @qc: Command that we are erroring out
766 *
Tejun Heod25614b2006-11-14 22:37:35 +0900767 * Generate sense block for a failed ATA command @qc. Descriptor
768 * format is used to accomodate LBA48 block address.
Jeff Garzikb0955182005-05-12 15:45:22 -0400769 *
770 * LOCKING:
Tejun Heo750426a2006-11-14 22:37:35 +0900771 * None.
Jeff Garzikb0955182005-05-12 15:45:22 -0400772 */
Tejun Heo750426a2006-11-14 22:37:35 +0900773static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
Jeff Garzikb0955182005-05-12 15:45:22 -0400774{
Tejun Heod25614b2006-11-14 22:37:35 +0900775 struct ata_device *dev = qc->dev;
Jeff Garzikb0955182005-05-12 15:45:22 -0400776 struct scsi_cmnd *cmd = qc->scsicmd;
Tejun Heoe61e0672006-05-15 20:57:40 +0900777 struct ata_taskfile *tf = &qc->result_tf;
Jeff Garzikb0955182005-05-12 15:45:22 -0400778 unsigned char *sb = cmd->sense_buffer;
Tejun Heod25614b2006-11-14 22:37:35 +0900779 unsigned char *desc = sb + 8;
Tejun Heo246619d2006-05-15 20:58:16 +0900780 int verbose = qc->ap->ops->error_handler == NULL;
Tejun Heod25614b2006-11-14 22:37:35 +0900781 u64 block;
Jeff Garzikb0955182005-05-12 15:45:22 -0400782
783 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
784
Jeff Garzik0e5dec42005-10-06 09:40:20 -0400785 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
Jeff Garzikb0955182005-05-12 15:45:22 -0400786
Tejun Heod25614b2006-11-14 22:37:35 +0900787 /* sense data is current and format is descriptor */
788 sb[0] = 0x72;
789
790 /* Use ata_to_sense_error() to map status register bits
Jeff Garzikb0955182005-05-12 15:45:22 -0400791 * onto sense key, asc & ascq.
792 */
Tejun Heo058e55e2006-04-02 18:51:53 +0900793 if (qc->err_mask ||
794 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
Tejun Heo44877b42007-02-21 01:06:51 +0900795 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
Tejun Heod25614b2006-11-14 22:37:35 +0900796 &sb[1], &sb[2], &sb[3], verbose);
797 sb[1] &= 0x0f;
Jeff Garzikb0955182005-05-12 15:45:22 -0400798 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
Tejun Heod25614b2006-11-14 22:37:35 +0900800 block = ata_tf_read_block(&qc->result_tf, dev);
Jeff Garzik0274aa22005-06-22 13:50:56 -0400801
Tejun Heod25614b2006-11-14 22:37:35 +0900802 /* information sense data descriptor */
803 sb[7] = 12;
804 desc[0] = 0x00;
805 desc[1] = 10;
Jeff Garzika7dac442005-10-30 04:44:42 -0500806
Tejun Heod25614b2006-11-14 22:37:35 +0900807 desc[2] |= 0x80; /* valid */
808 desc[6] = block >> 40;
809 desc[7] = block >> 32;
810 desc[8] = block >> 24;
811 desc[9] = block >> 16;
812 desc[10] = block >> 8;
813 desc[11] = block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814}
815
Brian Kinga6cce2a2006-03-17 17:04:15 -0600816static void ata_scsi_sdev_config(struct scsi_device *sdev)
817{
818 sdev->use_10_for_rw = 1;
819 sdev->use_10_for_ms = 1;
Tejun Heo31cc23b2007-09-23 13:14:12 +0900820
821 /* Schedule policy is determined by ->qc_defer() callback and
822 * it needs to see every deferred qc. Set dev_blocked to 1 to
823 * prevent SCSI midlayer from automatically deferring
824 * requests.
825 */
826 sdev->max_device_blocked = 1;
Brian Kinga6cce2a2006-03-17 17:04:15 -0600827}
828
829static void ata_scsi_dev_config(struct scsi_device *sdev,
830 struct ata_device *dev)
831{
Tejun Heo914ed352006-11-01 18:39:55 +0900832 /* configure max sectors */
833 blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
Brian Kinga6cce2a2006-03-17 17:04:15 -0600834
Tejun Heo914ed352006-11-01 18:39:55 +0900835 /* SATA DMA transfers must be multiples of 4 byte, so
Brian Kinga6cce2a2006-03-17 17:04:15 -0600836 * we need to pad ATAPI transfers using an extra sg.
837 * Decrement max hw segments accordingly.
838 */
839 if (dev->class == ATA_DEV_ATAPI) {
Jens Axboe165125e2007-07-24 09:28:11 +0200840 struct request_queue *q = sdev->request_queue;
Brian Kinga6cce2a2006-03-17 17:04:15 -0600841 blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
842 }
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900843
Jeff Garzikf26792d2007-10-29 17:18:39 -0400844 if (dev->flags & ATA_DFLAG_AN)
845 set_bit(SDEV_EVT_MEDIA_CHANGE, sdev->supported_events);
846
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900847 if (dev->flags & ATA_DFLAG_NCQ) {
848 int depth;
849
850 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
851 depth = min(ATA_MAX_QUEUE - 1, depth);
852 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
853 }
Brian Kinga6cce2a2006-03-17 17:04:15 -0600854}
855
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856/**
857 * ata_scsi_slave_config - Set SCSI device attributes
858 * @sdev: SCSI device to examine
859 *
860 * This is called before we actually start reading
861 * and writing to the device, to configure certain
862 * SCSI mid-layer behaviors.
863 *
864 * LOCKING:
865 * Defined by SCSI layer. We don't really care.
866 */
867
868int ata_scsi_slave_config(struct scsi_device *sdev)
869{
Tejun Heo31534362006-05-31 18:27:36 +0900870 struct ata_port *ap = ata_shost_to_port(sdev->host);
871 struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
872
Brian Kinga6cce2a2006-03-17 17:04:15 -0600873 ata_scsi_sdev_config(sdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Tejun Heo9666f402007-05-04 21:27:47 +0200875 sdev->manage_start_stop = 1;
876
Tejun Heo31534362006-05-31 18:27:36 +0900877 if (dev)
Brian Kinga6cce2a2006-03-17 17:04:15 -0600878 ata_scsi_dev_config(sdev, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880 return 0; /* scsi layer doesn't check return value, sigh */
881}
882
883/**
Tejun Heo83c47bc2006-05-31 18:28:07 +0900884 * ata_scsi_slave_destroy - SCSI device is about to be destroyed
885 * @sdev: SCSI device to be destroyed
886 *
887 * @sdev is about to be destroyed for hot/warm unplugging. If
888 * this unplugging was initiated by libata as indicated by NULL
889 * dev->sdev, this function doesn't have to do anything.
890 * Otherwise, SCSI layer initiated warm-unplug is in progress.
891 * Clear dev->sdev, schedule the device for ATA detach and invoke
892 * EH.
893 *
894 * LOCKING:
895 * Defined by SCSI layer. We don't really care.
896 */
897void ata_scsi_slave_destroy(struct scsi_device *sdev)
898{
899 struct ata_port *ap = ata_shost_to_port(sdev->host);
900 unsigned long flags;
901 struct ata_device *dev;
902
903 if (!ap->ops->error_handler)
904 return;
905
Jeff Garzikba6a1302006-06-22 23:46:10 -0400906 spin_lock_irqsave(ap->lock, flags);
Tejun Heo83c47bc2006-05-31 18:28:07 +0900907 dev = __ata_scsi_find_dev(ap, sdev);
908 if (dev && dev->sdev) {
909 /* SCSI device already in CANCEL state, no need to offline it */
910 dev->sdev = NULL;
911 dev->flags |= ATA_DFLAG_DETACH;
912 ata_port_schedule_eh(ap);
913 }
Jeff Garzikba6a1302006-06-22 23:46:10 -0400914 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo83c47bc2006-05-31 18:28:07 +0900915}
916
917/**
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900918 * ata_scsi_change_queue_depth - SCSI callback for queue depth config
919 * @sdev: SCSI device to configure queue depth for
920 * @queue_depth: new queue depth
921 *
922 * This is libata standard hostt->change_queue_depth callback.
923 * SCSI will call into this callback when user tries to set queue
924 * depth via sysfs.
925 *
926 * LOCKING:
927 * SCSI layer (we don't care)
928 *
929 * RETURNS:
930 * Newly configured queue depth.
931 */
932int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
933{
934 struct ata_port *ap = ata_shost_to_port(sdev->host);
935 struct ata_device *dev;
Tejun Heo360f6542006-09-30 19:45:00 +0900936 unsigned long flags;
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900937
Tejun Heoc3c70c42007-02-20 23:31:22 +0900938 if (queue_depth < 1 || queue_depth == sdev->queue_depth)
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900939 return sdev->queue_depth;
940
941 dev = ata_scsi_find_dev(ap, sdev);
942 if (!dev || !ata_dev_enabled(dev))
943 return sdev->queue_depth;
944
Tejun Heoc3c70c42007-02-20 23:31:22 +0900945 /* NCQ enabled? */
Tejun Heo360f6542006-09-30 19:45:00 +0900946 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc3c70c42007-02-20 23:31:22 +0900947 dev->flags &= ~ATA_DFLAG_NCQ_OFF;
948 if (queue_depth == 1 || !ata_ncq_enabled(dev)) {
Tejun Heo360f6542006-09-30 19:45:00 +0900949 dev->flags |= ATA_DFLAG_NCQ_OFF;
Tejun Heoc3c70c42007-02-20 23:31:22 +0900950 queue_depth = 1;
951 }
Tejun Heo360f6542006-09-30 19:45:00 +0900952 spin_unlock_irqrestore(ap->lock, flags);
953
Tejun Heoc3c70c42007-02-20 23:31:22 +0900954 /* limit and apply queue depth */
955 queue_depth = min(queue_depth, sdev->host->can_queue);
956 queue_depth = min(queue_depth, ata_id_queue_depth(dev->id));
957 queue_depth = min(queue_depth, ATA_MAX_QUEUE - 1);
958
959 if (sdev->queue_depth == queue_depth)
960 return -EINVAL;
961
962 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900963 return queue_depth;
964}
965
Tejun Heod9aca222007-05-17 16:43:26 +0200966/* XXX: for spindown warning */
Tejun Heoda071b42007-05-14 17:26:18 +0200967static void ata_delayed_done_timerfn(unsigned long arg)
968{
969 struct scsi_cmnd *scmd = (void *)arg;
970
971 scmd->scsi_done(scmd);
972}
973
Tejun Heod9aca222007-05-17 16:43:26 +0200974/* XXX: for spindown warning */
Tejun Heoda071b42007-05-14 17:26:18 +0200975static void ata_delayed_done(struct scsi_cmnd *scmd)
976{
977 static struct timer_list timer;
978
979 setup_timer(&timer, ata_delayed_done_timerfn, (unsigned long)scmd);
980 mod_timer(&timer, jiffies + 5 * HZ);
981}
982
Tejun Heoa6e6ce82006-05-15 21:03:48 +0900983/**
Douglas Gilbert972dcaf2005-08-11 03:35:53 -0400984 * ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
985 * @qc: Storage for translated ATA taskfile
Douglas Gilbert972dcaf2005-08-11 03:35:53 -0400986 *
987 * Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
988 * (to start). Perhaps these commands should be preceded by
989 * CHECK POWER MODE to see what power mode the device is already in.
990 * [See SAT revision 5 at www.t10.org]
991 *
992 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400993 * spin_lock_irqsave(host lock)
Douglas Gilbert972dcaf2005-08-11 03:35:53 -0400994 *
995 * RETURNS:
996 * Zero on success, non-zero on error.
997 */
Tejun Heoad706992006-12-17 10:45:57 +0900998static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
Douglas Gilbert972dcaf2005-08-11 03:35:53 -0400999{
Tejun Heo542b1442006-12-17 10:45:08 +09001000 struct scsi_cmnd *scmd = qc->scsicmd;
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001001 struct ata_taskfile *tf = &qc->tf;
Tejun Heoad706992006-12-17 10:45:57 +09001002 const u8 *cdb = scmd->cmnd;
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001003
Tejun Heo2e5704f2006-12-17 10:46:33 +09001004 if (scmd->cmd_len < 5)
1005 goto invalid_fld;
1006
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001007 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1008 tf->protocol = ATA_PROT_NODATA;
Tejun Heo542b1442006-12-17 10:45:08 +09001009 if (cdb[1] & 0x1) {
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001010 ; /* ignore IMMED bit, violates sat-r05 */
1011 }
Tejun Heo542b1442006-12-17 10:45:08 +09001012 if (cdb[4] & 0x2)
Douglas Gilbertae006512005-10-09 09:09:35 -04001013 goto invalid_fld; /* LOEJ bit set not supported */
Tejun Heo542b1442006-12-17 10:45:08 +09001014 if (((cdb[4] >> 4) & 0xf) != 0)
Douglas Gilbertae006512005-10-09 09:09:35 -04001015 goto invalid_fld; /* power conditions not supported */
Tejun Heoe31e85312007-09-23 13:14:13 +09001016
1017 if (qc->dev->horkage & ATA_HORKAGE_SKIP_PM) {
1018 /* the device lacks PM support, finish without doing anything */
1019 scmd->result = SAM_STAT_GOOD;
1020 return 1;
1021 }
1022
Tejun Heo542b1442006-12-17 10:45:08 +09001023 if (cdb[4] & 0x1) {
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001024 tf->nsect = 1; /* 1 sector, lba=0 */
Albert Lee9d5b1302005-10-04 08:48:17 -04001025
1026 if (qc->dev->flags & ATA_DFLAG_LBA) {
Tejun Heoc44078c2006-05-15 20:57:21 +09001027 tf->flags |= ATA_TFLAG_LBA;
Albert Lee9d5b1302005-10-04 08:48:17 -04001028
1029 tf->lbah = 0x0;
1030 tf->lbam = 0x0;
1031 tf->lbal = 0x0;
1032 tf->device |= ATA_LBA;
1033 } else {
1034 /* CHS */
1035 tf->lbal = 0x1; /* sect */
1036 tf->lbam = 0x0; /* cyl low */
1037 tf->lbah = 0x0; /* cyl high */
1038 }
1039
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001040 tf->command = ATA_CMD_VERIFY; /* READ VERIFY */
Tejun Heo920a4b12007-05-04 21:28:48 +02001041 } else {
1042 /* XXX: This is for backward compatibility, will be
1043 * removed. Read Documentation/feature-removal-schedule.txt
1044 * for more info.
1045 */
Tejun Heod9aca222007-05-17 16:43:26 +02001046 if ((qc->dev->flags & ATA_DFLAG_SPUNDOWN) &&
Tejun Heo920a4b12007-05-04 21:28:48 +02001047 (system_state == SYSTEM_HALT ||
1048 system_state == SYSTEM_POWER_OFF)) {
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001049 static unsigned long warned;
Tejun Heo920a4b12007-05-04 21:28:48 +02001050
Tejun Heoda071b42007-05-14 17:26:18 +02001051 if (!test_and_set_bit(0, &warned)) {
Tejun Heo920a4b12007-05-04 21:28:48 +02001052 ata_dev_printk(qc->dev, KERN_WARNING,
1053 "DISK MIGHT NOT BE SPUN DOWN PROPERLY. "
1054 "UPDATE SHUTDOWN UTILITY\n");
1055 ata_dev_printk(qc->dev, KERN_WARNING,
1056 "For more info, visit "
1057 "http://linux-ata.org/shutdown.html\n");
Tejun Heoda071b42007-05-14 17:26:18 +02001058
1059 /* ->scsi_done is not used, use it for
1060 * delayed completion.
1061 */
1062 scmd->scsi_done = qc->scsidone;
1063 qc->scsidone = ata_delayed_done;
Tejun Heo920a4b12007-05-04 21:28:48 +02001064 }
1065 scmd->result = SAM_STAT_GOOD;
1066 return 1;
1067 }
1068
Robert Hancock78981a72007-01-30 00:59:18 -08001069 /* Issue ATA STANDBY IMMEDIATE command */
1070 tf->command = ATA_CMD_STANDBYNOW1;
Tejun Heo920a4b12007-05-04 21:28:48 +02001071 }
Robert Hancock78981a72007-01-30 00:59:18 -08001072
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001073 /*
1074 * Standby and Idle condition timers could be implemented but that
1075 * would require libata to implement the Power condition mode page
1076 * and allow the user to change it. Changing mode pages requires
1077 * MODE SELECT to be implemented.
1078 */
1079
1080 return 0;
Douglas Gilbertae006512005-10-09 09:09:35 -04001081
1082invalid_fld:
Tejun Heo542b1442006-12-17 10:45:08 +09001083 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
Douglas Gilbertae006512005-10-09 09:09:35 -04001084 /* "Invalid field in cbd" */
1085 return 1;
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04001086}
1087
1088
1089/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
1091 * @qc: Storage for translated ATA taskfile
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 *
1093 * Sets up an ATA taskfile to issue FLUSH CACHE or
1094 * FLUSH CACHE EXT.
1095 *
1096 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001097 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 *
1099 * RETURNS:
1100 * Zero on success, non-zero on error.
1101 */
Tejun Heoad706992006-12-17 10:45:57 +09001102static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103{
1104 struct ata_taskfile *tf = &qc->tf;
1105
1106 tf->flags |= ATA_TFLAG_DEVICE;
1107 tf->protocol = ATA_PROT_NODATA;
1108
Tejun Heo6fc49ad2006-11-11 20:10:45 +09001109 if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 tf->command = ATA_CMD_FLUSH_EXT;
1111 else
1112 tf->command = ATA_CMD_FLUSH;
1113
Tejun Heob666da32007-10-26 15:53:59 +09001114 /* flush is critical for IO integrity, consider it an IO command */
1115 qc->flags |= ATA_QCFLAG_IO;
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 return 0;
1118}
1119
1120/**
Albert Lee3aef5232005-10-04 08:47:43 -04001121 * scsi_6_lba_len - Get LBA and transfer length
Tejun Heo542b1442006-12-17 10:45:08 +09001122 * @cdb: SCSI command to translate
Albert Lee3aef5232005-10-04 08:47:43 -04001123 *
1124 * Calculate LBA and transfer length for 6-byte commands.
1125 *
1126 * RETURNS:
1127 * @plba: the LBA
1128 * @plen: the transfer length
1129 */
Tejun Heo542b1442006-12-17 10:45:08 +09001130static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
Albert Lee3aef5232005-10-04 08:47:43 -04001131{
1132 u64 lba = 0;
Jeff Garzik6c7b7d22007-05-25 04:39:39 -04001133 u32 len;
Albert Lee3aef5232005-10-04 08:47:43 -04001134
1135 VPRINTK("six-byte command\n");
1136
Jeff Garzik6c7b7d22007-05-25 04:39:39 -04001137 lba |= ((u64)(cdb[1] & 0x1f)) << 16;
Tejun Heo542b1442006-12-17 10:45:08 +09001138 lba |= ((u64)cdb[2]) << 8;
1139 lba |= ((u64)cdb[3]);
Albert Lee3aef5232005-10-04 08:47:43 -04001140
Jeff Garzik6c7b7d22007-05-25 04:39:39 -04001141 len = cdb[4];
Albert Lee3aef5232005-10-04 08:47:43 -04001142
1143 *plba = lba;
1144 *plen = len;
1145}
1146
1147/**
1148 * scsi_10_lba_len - Get LBA and transfer length
Tejun Heo542b1442006-12-17 10:45:08 +09001149 * @cdb: SCSI command to translate
Albert Lee3aef5232005-10-04 08:47:43 -04001150 *
1151 * Calculate LBA and transfer length for 10-byte commands.
1152 *
1153 * RETURNS:
1154 * @plba: the LBA
1155 * @plen: the transfer length
1156 */
Tejun Heo542b1442006-12-17 10:45:08 +09001157static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
Albert Lee3aef5232005-10-04 08:47:43 -04001158{
1159 u64 lba = 0;
1160 u32 len = 0;
1161
1162 VPRINTK("ten-byte command\n");
1163
Tejun Heo542b1442006-12-17 10:45:08 +09001164 lba |= ((u64)cdb[2]) << 24;
1165 lba |= ((u64)cdb[3]) << 16;
1166 lba |= ((u64)cdb[4]) << 8;
1167 lba |= ((u64)cdb[5]);
Albert Lee3aef5232005-10-04 08:47:43 -04001168
Tejun Heo542b1442006-12-17 10:45:08 +09001169 len |= ((u32)cdb[7]) << 8;
1170 len |= ((u32)cdb[8]);
Albert Lee3aef5232005-10-04 08:47:43 -04001171
1172 *plba = lba;
1173 *plen = len;
1174}
1175
1176/**
1177 * scsi_16_lba_len - Get LBA and transfer length
Tejun Heo542b1442006-12-17 10:45:08 +09001178 * @cdb: SCSI command to translate
Albert Lee3aef5232005-10-04 08:47:43 -04001179 *
1180 * Calculate LBA and transfer length for 16-byte commands.
1181 *
1182 * RETURNS:
1183 * @plba: the LBA
1184 * @plen: the transfer length
1185 */
Tejun Heo542b1442006-12-17 10:45:08 +09001186static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
Albert Lee3aef5232005-10-04 08:47:43 -04001187{
1188 u64 lba = 0;
1189 u32 len = 0;
1190
1191 VPRINTK("sixteen-byte command\n");
1192
Tejun Heo542b1442006-12-17 10:45:08 +09001193 lba |= ((u64)cdb[2]) << 56;
1194 lba |= ((u64)cdb[3]) << 48;
1195 lba |= ((u64)cdb[4]) << 40;
1196 lba |= ((u64)cdb[5]) << 32;
1197 lba |= ((u64)cdb[6]) << 24;
1198 lba |= ((u64)cdb[7]) << 16;
1199 lba |= ((u64)cdb[8]) << 8;
1200 lba |= ((u64)cdb[9]);
Albert Lee3aef5232005-10-04 08:47:43 -04001201
Tejun Heo542b1442006-12-17 10:45:08 +09001202 len |= ((u32)cdb[10]) << 24;
1203 len |= ((u32)cdb[11]) << 16;
1204 len |= ((u32)cdb[12]) << 8;
1205 len |= ((u32)cdb[13]);
Albert Lee3aef5232005-10-04 08:47:43 -04001206
1207 *plba = lba;
1208 *plen = len;
1209}
1210
1211/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1213 * @qc: Storage for translated ATA taskfile
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 *
1215 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
1216 *
1217 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001218 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 *
1220 * RETURNS:
1221 * Zero on success, non-zero on error.
1222 */
Tejun Heoad706992006-12-17 10:45:57 +09001223static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224{
Tejun Heo542b1442006-12-17 10:45:08 +09001225 struct scsi_cmnd *scmd = qc->scsicmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 struct ata_taskfile *tf = &qc->tf;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001227 struct ata_device *dev = qc->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 u64 dev_sectors = qc->dev->n_sectors;
Tejun Heoad706992006-12-17 10:45:57 +09001229 const u8 *cdb = scmd->cmnd;
Albert Lee3aef5232005-10-04 08:47:43 -04001230 u64 block;
1231 u32 n_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1234 tf->protocol = ATA_PROT_NODATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Tejun Heo2e5704f2006-12-17 10:46:33 +09001236 if (cdb[0] == VERIFY) {
1237 if (scmd->cmd_len < 10)
1238 goto invalid_fld;
Tejun Heo542b1442006-12-17 10:45:08 +09001239 scsi_10_lba_len(cdb, &block, &n_block);
Tejun Heo2e5704f2006-12-17 10:46:33 +09001240 } else if (cdb[0] == VERIFY_16) {
1241 if (scmd->cmd_len < 16)
1242 goto invalid_fld;
Tejun Heo542b1442006-12-17 10:45:08 +09001243 scsi_16_lba_len(cdb, &block, &n_block);
Tejun Heo2e5704f2006-12-17 10:46:33 +09001244 } else
Douglas Gilbertae006512005-10-09 09:09:35 -04001245 goto invalid_fld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
Albert Lee8bf62ece2005-05-12 15:29:42 -04001247 if (!n_block)
Douglas Gilbertae006512005-10-09 09:09:35 -04001248 goto nothing_to_do;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001249 if (block >= dev_sectors)
Douglas Gilbertae006512005-10-09 09:09:35 -04001250 goto out_of_range;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001251 if ((block + n_block) > dev_sectors)
Douglas Gilbertae006512005-10-09 09:09:35 -04001252 goto out_of_range;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
Albert Lee07506692005-10-12 15:04:18 +08001254 if (dev->flags & ATA_DFLAG_LBA) {
1255 tf->flags |= ATA_TFLAG_LBA;
1256
Albert Leec6a33e22005-10-12 15:12:26 +08001257 if (lba_28_ok(block, n_block)) {
1258 /* use LBA28 */
1259 tf->command = ATA_CMD_VERIFY;
1260 tf->device |= (block >> 24) & 0xf;
1261 } else if (lba_48_ok(block, n_block)) {
1262 if (!(dev->flags & ATA_DFLAG_LBA48))
1263 goto out_of_range;
Albert Lee07506692005-10-12 15:04:18 +08001264
1265 /* use LBA48 */
1266 tf->flags |= ATA_TFLAG_LBA48;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001267 tf->command = ATA_CMD_VERIFY_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
Albert Lee8bf62ece2005-05-12 15:29:42 -04001269 tf->hob_nsect = (n_block >> 8) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
Albert Lee8bf62ece2005-05-12 15:29:42 -04001271 tf->hob_lbah = (block >> 40) & 0xff;
1272 tf->hob_lbam = (block >> 32) & 0xff;
1273 tf->hob_lbal = (block >> 24) & 0xff;
Albert Leec6a33e22005-10-12 15:12:26 +08001274 } else
1275 /* request too large even for LBA48 */
1276 goto out_of_range;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001277
1278 tf->nsect = n_block & 0xff;
1279
1280 tf->lbah = (block >> 16) & 0xff;
1281 tf->lbam = (block >> 8) & 0xff;
1282 tf->lbal = block & 0xff;
1283
1284 tf->device |= ATA_LBA;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 } else {
Albert Lee8bf62ece2005-05-12 15:29:42 -04001286 /* CHS */
1287 u32 sect, head, cyl, track;
1288
Albert Leec6a33e22005-10-12 15:12:26 +08001289 if (!lba_28_ok(block, n_block))
1290 goto out_of_range;
Albert Lee07506692005-10-12 15:04:18 +08001291
Albert Lee8bf62ece2005-05-12 15:29:42 -04001292 /* Convert LBA to CHS */
1293 track = (u32)block / dev->sectors;
1294 cyl = track / dev->heads;
1295 head = track % dev->heads;
1296 sect = (u32)block % dev->sectors + 1;
1297
Albert Leec187c4b2005-10-04 08:46:51 -04001298 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1299 (u32)block, track, cyl, head, sect);
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001300
1301 /* Check whether the converted CHS can fit.
1302 Cylinder: 0-65535
Albert Lee8bf62ece2005-05-12 15:29:42 -04001303 Head: 0-15
1304 Sector: 1-255*/
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001305 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
Douglas Gilbertae006512005-10-09 09:09:35 -04001306 goto out_of_range;
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001307
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 tf->command = ATA_CMD_VERIFY;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001309 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
1310 tf->lbal = sect;
1311 tf->lbam = cyl;
1312 tf->lbah = cyl >> 8;
1313 tf->device |= head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 return 0;
Douglas Gilbertae006512005-10-09 09:09:35 -04001317
1318invalid_fld:
Tejun Heo542b1442006-12-17 10:45:08 +09001319 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
Douglas Gilbertae006512005-10-09 09:09:35 -04001320 /* "Invalid field in cbd" */
1321 return 1;
1322
1323out_of_range:
Tejun Heo542b1442006-12-17 10:45:08 +09001324 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
Douglas Gilbertae006512005-10-09 09:09:35 -04001325 /* "Logical Block Address out of range" */
1326 return 1;
1327
1328nothing_to_do:
Tejun Heo542b1442006-12-17 10:45:08 +09001329 scmd->result = SAM_STAT_GOOD;
Douglas Gilbertae006512005-10-09 09:09:35 -04001330 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331}
1332
1333/**
1334 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1335 * @qc: Storage for translated ATA taskfile
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 *
1337 * Converts any of six SCSI read/write commands into the
1338 * ATA counterpart, including starting sector (LBA),
1339 * sector count, and taking into account the device's LBA48
1340 * support.
1341 *
1342 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1343 * %WRITE_16 are currently supported.
1344 *
1345 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001346 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 *
1348 * RETURNS:
1349 * Zero on success, non-zero on error.
1350 */
Tejun Heoad706992006-12-17 10:45:57 +09001351static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352{
Tejun Heo542b1442006-12-17 10:45:08 +09001353 struct scsi_cmnd *scmd = qc->scsicmd;
Tejun Heoad706992006-12-17 10:45:57 +09001354 const u8 *cdb = scmd->cmnd;
Tejun Heobd056d72006-11-14 22:47:10 +09001355 unsigned int tf_flags = 0;
Albert Lee3aef5232005-10-04 08:47:43 -04001356 u64 block;
1357 u32 n_block;
Tejun Heobd056d72006-11-14 22:47:10 +09001358 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
Tejun Heo542b1442006-12-17 10:45:08 +09001360 if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
Tejun Heobd056d72006-11-14 22:47:10 +09001361 tf_flags |= ATA_TFLAG_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
Tejun Heo9a3dccc2006-01-06 09:56:18 +01001363 /* Calculate the SCSI LBA, transfer length and FUA. */
Tejun Heo542b1442006-12-17 10:45:08 +09001364 switch (cdb[0]) {
Albert Lee3aef5232005-10-04 08:47:43 -04001365 case READ_10:
1366 case WRITE_10:
Tejun Heo2e5704f2006-12-17 10:46:33 +09001367 if (unlikely(scmd->cmd_len < 10))
1368 goto invalid_fld;
Tejun Heo542b1442006-12-17 10:45:08 +09001369 scsi_10_lba_len(cdb, &block, &n_block);
1370 if (unlikely(cdb[1] & (1 << 3)))
Tejun Heobd056d72006-11-14 22:47:10 +09001371 tf_flags |= ATA_TFLAG_FUA;
Albert Lee3aef5232005-10-04 08:47:43 -04001372 break;
1373 case READ_6:
1374 case WRITE_6:
Tejun Heo2e5704f2006-12-17 10:46:33 +09001375 if (unlikely(scmd->cmd_len < 6))
1376 goto invalid_fld;
Tejun Heo542b1442006-12-17 10:45:08 +09001377 scsi_6_lba_len(cdb, &block, &n_block);
Albert Leec187c4b2005-10-04 08:46:51 -04001378
1379 /* for 6-byte r/w commands, transfer length 0
1380 * means 256 blocks of data, not 0 block.
1381 */
Jeff Garzik76b2bf92005-08-29 19:24:43 -04001382 if (!n_block)
1383 n_block = 256;
Albert Lee3aef5232005-10-04 08:47:43 -04001384 break;
1385 case READ_16:
1386 case WRITE_16:
Tejun Heo2e5704f2006-12-17 10:46:33 +09001387 if (unlikely(scmd->cmd_len < 16))
1388 goto invalid_fld;
Tejun Heo542b1442006-12-17 10:45:08 +09001389 scsi_16_lba_len(cdb, &block, &n_block);
1390 if (unlikely(cdb[1] & (1 << 3)))
Tejun Heobd056d72006-11-14 22:47:10 +09001391 tf_flags |= ATA_TFLAG_FUA;
Albert Lee3aef5232005-10-04 08:47:43 -04001392 break;
1393 default:
Albert Lee8bf62ece2005-05-12 15:29:42 -04001394 DPRINTK("no-byte command\n");
Douglas Gilbertae006512005-10-09 09:09:35 -04001395 goto invalid_fld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 }
1397
Albert Lee8bf62ece2005-05-12 15:29:42 -04001398 /* Check and compose ATA command */
1399 if (!n_block)
Albert Leec187c4b2005-10-04 08:46:51 -04001400 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1401 * length 0 means transfer 0 block of data.
1402 * However, for ATA R/W commands, sector count 0 means
1403 * 256 or 65536 sectors, not 0 sectors as in SCSI.
Alan Coxf51750d2005-11-07 17:06:33 +00001404 *
1405 * WARNING: one or two older ATA drives treat 0 as 0...
Albert Leec187c4b2005-10-04 08:46:51 -04001406 */
Douglas Gilbertae006512005-10-09 09:09:35 -04001407 goto nothing_to_do;
Albert Lee8bf62ece2005-05-12 15:29:42 -04001408
Tejun Heobd056d72006-11-14 22:47:10 +09001409 qc->flags |= ATA_QCFLAG_IO;
Tejun Heo726f0782007-01-03 17:30:39 +09001410 qc->nbytes = n_block * ATA_SECT_SIZE;
Tejun Heo3dc1d882006-05-15 21:03:45 +09001411
Tejun Heobd056d72006-11-14 22:47:10 +09001412 rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1413 qc->tag);
1414 if (likely(rc == 0))
1415 return 0;
Tejun Heo3dc1d882006-05-15 21:03:45 +09001416
Tejun Heobd056d72006-11-14 22:47:10 +09001417 if (rc == -ERANGE)
1418 goto out_of_range;
1419 /* treat all other errors as -EINVAL, fall through */
Douglas Gilbertae006512005-10-09 09:09:35 -04001420invalid_fld:
Tejun Heo542b1442006-12-17 10:45:08 +09001421 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
Douglas Gilbertae006512005-10-09 09:09:35 -04001422 /* "Invalid field in cbd" */
1423 return 1;
1424
1425out_of_range:
Tejun Heo542b1442006-12-17 10:45:08 +09001426 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
Douglas Gilbertae006512005-10-09 09:09:35 -04001427 /* "Logical Block Address out of range" */
1428 return 1;
1429
1430nothing_to_do:
Tejun Heo542b1442006-12-17 10:45:08 +09001431 scmd->result = SAM_STAT_GOOD;
Douglas Gilbertae006512005-10-09 09:09:35 -04001432 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433}
1434
Tejun Heo77853bf2006-01-23 13:09:36 +09001435static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436{
Tejun Heoc31f5712006-11-22 12:39:43 +09001437 struct ata_port *ap = qc->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 struct scsi_cmnd *cmd = qc->scsicmd;
Jeff Garzika7dac442005-10-30 04:44:42 -05001439 u8 *cdb = cmd->cmnd;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001440 int need_sense = (qc->err_mask != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
Jeff Garzikb0955182005-05-12 15:45:22 -04001442 /* For ATA pass thru (SAT) commands, generate a sense block if
1443 * user mandated it or if there's an error. Note that if we
1444 * generate because the user forced us to, a check condition
1445 * is generated and the ATA register values are returned
1446 * whether the command completed successfully or not. If there
1447 * was no error, SK, ASC and ASCQ will all be zero.
1448 */
Jeff Garzika7dac442005-10-30 04:44:42 -05001449 if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001450 ((cdb[2] & 0x20) || need_sense)) {
Tejun Heo750426a2006-11-14 22:37:35 +09001451 ata_gen_passthru_sense(qc);
Jeff Garzikb0955182005-05-12 15:45:22 -04001452 } else {
1453 if (!need_sense) {
1454 cmd->result = SAM_STAT_GOOD;
1455 } else {
1456 /* TODO: decide which descriptor format to use
1457 * for 48b LBA devices and call that here
1458 * instead of the fixed desc, which is only
1459 * good for smaller LBA (and maybe CHS?)
1460 * devices.
1461 */
Tejun Heo750426a2006-11-14 22:37:35 +09001462 ata_gen_ata_sense(qc);
Jeff Garzikb0955182005-05-12 15:45:22 -04001463 }
1464 }
1465
Tejun Heod9aca222007-05-17 16:43:26 +02001466 /* XXX: track spindown state for spindown skipping and warning */
Tejun Heo13b8d092007-05-15 12:29:22 +02001467 if (unlikely(qc->tf.command == ATA_CMD_STANDBY ||
1468 qc->tf.command == ATA_CMD_STANDBYNOW1))
1469 qc->dev->flags |= ATA_DFLAG_SPUNDOWN;
1470 else if (likely(system_state != SYSTEM_HALT &&
1471 system_state != SYSTEM_POWER_OFF))
1472 qc->dev->flags &= ~ATA_DFLAG_SPUNDOWN;
1473
Tejun Heoc31f5712006-11-22 12:39:43 +09001474 if (need_sense && !ap->ops->error_handler)
Tejun Heo44877b42007-02-21 01:06:51 +09001475 ata_dump_status(ap->print_id, &qc->result_tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
1477 qc->scsidone(cmd);
1478
Tejun Heo77853bf2006-01-23 13:09:36 +09001479 ata_qc_free(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480}
1481
1482/**
1483 * ata_scsi_translate - Translate then issue SCSI command to ATA device
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 * @dev: ATA device to which the command is addressed
1485 * @cmd: SCSI command to execute
1486 * @done: SCSI command completion function
1487 * @xlat_func: Actor which translates @cmd to an ATA taskfile
1488 *
1489 * Our ->queuecommand() function has decided that the SCSI
1490 * command issued can be directly translated into an ATA
1491 * command, rather than handled internally.
1492 *
1493 * This function sets up an ata_queued_cmd structure for the
1494 * SCSI command, and sends that ata_queued_cmd to the hardware.
1495 *
Douglas Gilbertae006512005-10-09 09:09:35 -04001496 * The xlat_func argument (actor) returns 0 if ready to execute
1497 * ATA command, else 1 to finish translation. If 1 is returned
1498 * then cmd->result (and possibly cmd->sense_buffer) are assumed
1499 * to be set reflecting an error condition or clean (early)
1500 * termination.
1501 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001503 * spin_lock_irqsave(host lock)
Tejun Heo2115ea92006-05-15 21:03:39 +09001504 *
1505 * RETURNS:
1506 * 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1507 * needs to be deferred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 */
Tejun Heo2115ea92006-05-15 21:03:39 +09001509static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1510 void (*done)(struct scsi_cmnd *),
1511 ata_xlat_func_t xlat_func)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512{
Tejun Heo31cc23b2007-09-23 13:14:12 +09001513 struct ata_port *ap = dev->link->ap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 struct ata_queued_cmd *qc;
Tejun Heo31cc23b2007-09-23 13:14:12 +09001515 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
1517 VPRINTK("ENTER\n");
1518
Tejun Heo3373efd2006-05-15 20:57:53 +09001519 qc = ata_scsi_qc_new(dev, cmd, done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 if (!qc)
Douglas Gilbertae006512005-10-09 09:09:35 -04001521 goto err_mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522
1523 /* data is present; dma-map it */
be7db052005-04-17 15:26:13 -05001524 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1525 cmd->sc_data_direction == DMA_TO_DEVICE) {
Boaz Harrosh71201652007-09-18 17:48:50 +02001526 if (unlikely(scsi_bufflen(cmd) < 1)) {
Tejun Heof15a1da2006-05-15 20:57:56 +09001527 ata_dev_printk(dev, KERN_WARNING,
1528 "WARNING: zero len r/w req\n");
Douglas Gilbertae006512005-10-09 09:09:35 -04001529 goto err_did;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 }
1531
Boaz Harrosh71201652007-09-18 17:48:50 +02001532 ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533
1534 qc->dma_dir = cmd->sc_data_direction;
1535 }
1536
1537 qc->complete_fn = ata_scsi_qc_complete;
1538
Tejun Heoad706992006-12-17 10:45:57 +09001539 if (xlat_func(qc))
Douglas Gilbertae006512005-10-09 09:09:35 -04001540 goto early_finish;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
Tejun Heo31cc23b2007-09-23 13:14:12 +09001542 if (ap->ops->qc_defer) {
1543 if ((rc = ap->ops->qc_defer(qc)))
1544 goto defer;
1545 }
1546
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 /* select device, send command to hardware */
Tejun Heo8e0e6942006-03-31 20:41:11 +09001548 ata_qc_issue(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549
1550 VPRINTK("EXIT\n");
Tejun Heo2115ea92006-05-15 21:03:39 +09001551 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
Douglas Gilbertae006512005-10-09 09:09:35 -04001553early_finish:
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001554 ata_qc_free(qc);
Tejun Heoda071b42007-05-14 17:26:18 +02001555 qc->scsidone(cmd);
Douglas Gilbertae006512005-10-09 09:09:35 -04001556 DPRINTK("EXIT - early finish (good or error)\n");
Tejun Heo2115ea92006-05-15 21:03:39 +09001557 return 0;
Douglas Gilbertae006512005-10-09 09:09:35 -04001558
1559err_did:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 ata_qc_free(qc);
Douglas Gilbertae006512005-10-09 09:09:35 -04001561 cmd->result = (DID_ERROR << 16);
Tejun Heoda071b42007-05-14 17:26:18 +02001562 qc->scsidone(cmd);
Darrick J. Wong253b92e2006-11-14 09:55:41 -05001563err_mem:
Douglas Gilbertae006512005-10-09 09:09:35 -04001564 DPRINTK("EXIT - internal\n");
Tejun Heo2115ea92006-05-15 21:03:39 +09001565 return 0;
Tejun Heo3dc1d882006-05-15 21:03:45 +09001566
1567defer:
Tejun Heo31cc23b2007-09-23 13:14:12 +09001568 ata_qc_free(qc);
Tejun Heo3dc1d882006-05-15 21:03:45 +09001569 DPRINTK("EXIT - defer\n");
Tejun Heo31cc23b2007-09-23 13:14:12 +09001570 if (rc == ATA_DEFER_LINK)
1571 return SCSI_MLQUEUE_DEVICE_BUSY;
1572 else
1573 return SCSI_MLQUEUE_HOST_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574}
1575
1576/**
1577 * ata_scsi_rbuf_get - Map response buffer.
1578 * @cmd: SCSI command containing buffer to be mapped.
1579 * @buf_out: Pointer to mapped area.
1580 *
1581 * Maps buffer contained within SCSI command @cmd.
1582 *
1583 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001584 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 *
1586 * RETURNS:
1587 * Length of response buffer.
1588 */
1589
1590static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1591{
1592 u8 *buf;
1593 unsigned int buflen;
1594
Boaz Harrosh71201652007-09-18 17:48:50 +02001595 struct scatterlist *sg = scsi_sglist(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
Boaz Harroshe10b8c32007-09-18 17:46:12 +02001597 if (sg) {
Jens Axboe45711f12007-10-22 21:19:53 +02001598 buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 buflen = sg->length;
1600 } else {
Boaz Harroshe10b8c32007-09-18 17:46:12 +02001601 buf = NULL;
1602 buflen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 }
1604
1605 *buf_out = buf;
1606 return buflen;
1607}
1608
1609/**
1610 * ata_scsi_rbuf_put - Unmap response buffer.
1611 * @cmd: SCSI command containing buffer to be unmapped.
1612 * @buf: buffer to unmap
1613 *
1614 * Unmaps response buffer contained within @cmd.
1615 *
1616 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001617 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 */
1619
1620static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1621{
Boaz Harrosh71201652007-09-18 17:48:50 +02001622 struct scatterlist *sg = scsi_sglist(cmd);
Boaz Harroshe10b8c32007-09-18 17:46:12 +02001623 if (sg)
Jeff Garzikda02d2a2006-12-11 11:05:53 -05001624 kunmap_atomic(buf - sg->offset, KM_IRQ0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625}
1626
1627/**
1628 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1629 * @args: device IDENTIFY data / SCSI command of interest.
1630 * @actor: Callback hook for desired SCSI command simulator
1631 *
1632 * Takes care of the hard work of simulating a SCSI command...
1633 * Mapping the response buffer, calling the command's handler,
1634 * and handling the handler's return value. This return value
1635 * indicates whether the handler wishes the SCSI command to be
Douglas Gilbertae006512005-10-09 09:09:35 -04001636 * completed successfully (0), or not (in which case cmd->result
1637 * and sense buffer are assumed to be set).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 *
1639 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001640 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 */
1642
1643void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001644 unsigned int (*actor) (struct ata_scsi_args *args,
1645 u8 *rbuf, unsigned int buflen))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646{
1647 u8 *rbuf;
1648 unsigned int buflen, rc;
1649 struct scsi_cmnd *cmd = args->cmd;
1650
1651 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1652 memset(rbuf, 0, buflen);
1653 rc = actor(args, rbuf, buflen);
1654 ata_scsi_rbuf_put(cmd, rbuf);
1655
Douglas Gilbertae006512005-10-09 09:09:35 -04001656 if (rc == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 cmd->result = SAM_STAT_GOOD;
Douglas Gilbertae006512005-10-09 09:09:35 -04001658 args->done(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659}
1660
1661/**
Tejun Heo6a362612006-11-20 11:15:47 +09001662 * ATA_SCSI_RBUF_SET - helper to set values in SCSI response buffer
1663 * @idx: byte index into SCSI response buffer
1664 * @val: value to set
1665 *
1666 * To be used by SCSI command simulator functions. This macros
1667 * expects two local variables, u8 *rbuf and unsigned int buflen,
1668 * are in scope.
1669 *
1670 * LOCKING:
1671 * None.
1672 */
1673#define ATA_SCSI_RBUF_SET(idx, val) do { \
1674 if ((idx) < buflen) rbuf[(idx)] = (u8)(val); \
1675 } while (0)
1676
1677/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 * ata_scsiop_inq_std - Simulate INQUIRY command
1679 * @args: device IDENTIFY data / SCSI command of interest.
1680 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1681 * @buflen: Response buffer length.
1682 *
1683 * Returns standard device identification data associated
Jeff Garzikb142eb62006-03-21 20:37:47 -05001684 * with non-VPD INQUIRY command output.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 *
1686 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001687 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 */
1689
1690unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1691 unsigned int buflen)
1692{
1693 u8 hdr[] = {
1694 TYPE_DISK,
1695 0,
1696 0x5, /* claim SPC-3 version compatibility */
1697 2,
1698 95 - 4
1699 };
1700
1701 /* set scsi removeable (RMB) bit per ata bit */
1702 if (ata_id_removeable(args->id))
1703 hdr[1] |= (1 << 7);
1704
1705 VPRINTK("ENTER\n");
1706
1707 memcpy(rbuf, hdr, sizeof(hdr));
1708
1709 if (buflen > 35) {
1710 memcpy(&rbuf[8], "ATA ", 8);
Tejun Heoa0cf7332007-01-02 20:18:49 +09001711 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
1712 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 if (rbuf[32] == 0 || rbuf[32] == ' ')
1714 memcpy(&rbuf[32], "n/a ", 4);
1715 }
1716
1717 if (buflen > 63) {
1718 const u8 versions[] = {
1719 0x60, /* SAM-3 (no version claimed) */
1720
1721 0x03,
1722 0x20, /* SBC-2 (no version claimed) */
1723
1724 0x02,
1725 0x60 /* SPC-3 (no version claimed) */
1726 };
1727
1728 memcpy(rbuf + 59, versions, sizeof(versions));
1729 }
1730
1731 return 0;
1732}
1733
1734/**
Jeff Garzikb142eb62006-03-21 20:37:47 -05001735 * ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 * @args: device IDENTIFY data / SCSI command of interest.
1737 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1738 * @buflen: Response buffer length.
1739 *
Jeff Garzikb142eb62006-03-21 20:37:47 -05001740 * Returns list of inquiry VPD pages available.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 *
1742 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001743 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 */
1745
1746unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1747 unsigned int buflen)
1748{
1749 const u8 pages[] = {
1750 0x00, /* page 0x00, this page */
1751 0x80, /* page 0x80, unit serial no page */
1752 0x83 /* page 0x83, device ident page */
1753 };
Jeff Garzikb142eb62006-03-21 20:37:47 -05001754 rbuf[3] = sizeof(pages); /* number of supported VPD pages */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755
1756 if (buflen > 6)
1757 memcpy(rbuf + 4, pages, sizeof(pages));
1758
1759 return 0;
1760}
1761
1762/**
Jeff Garzikb142eb62006-03-21 20:37:47 -05001763 * ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 * @args: device IDENTIFY data / SCSI command of interest.
1765 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1766 * @buflen: Response buffer length.
1767 *
1768 * Returns ATA device serial number.
1769 *
1770 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001771 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 */
1773
1774unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1775 unsigned int buflen)
1776{
1777 const u8 hdr[] = {
1778 0,
1779 0x80, /* this page code */
1780 0,
Tejun Heoa0cf7332007-01-02 20:18:49 +09001781 ATA_ID_SERNO_LEN, /* page len */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 };
1783 memcpy(rbuf, hdr, sizeof(hdr));
1784
Tejun Heoa0cf7332007-01-02 20:18:49 +09001785 if (buflen > (ATA_ID_SERNO_LEN + 4 - 1))
Tejun Heo6a62a042006-02-13 10:02:46 +09001786 ata_id_string(args->id, (unsigned char *) &rbuf[4],
Tejun Heoa0cf7332007-01-02 20:18:49 +09001787 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788
1789 return 0;
1790}
1791
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792/**
Jeff Garzikb142eb62006-03-21 20:37:47 -05001793 * ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 * @args: device IDENTIFY data / SCSI command of interest.
1795 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1796 * @buflen: Response buffer length.
1797 *
Jeff Garzikb142eb62006-03-21 20:37:47 -05001798 * Yields two logical unit device identification designators:
1799 * - vendor specific ASCII containing the ATA serial number
1800 * - SAT defined "t10 vendor id based" containing ASCII vendor
1801 * name ("ATA "), model and serial numbers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 *
1803 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001804 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 */
1806
1807unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1808 unsigned int buflen)
1809{
Jeff Garzikb142eb62006-03-21 20:37:47 -05001810 int num;
1811 const int sat_model_serial_desc_len = 68;
Jeff Garzikb142eb62006-03-21 20:37:47 -05001812
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 rbuf[1] = 0x83; /* this page code */
Jeff Garzikb142eb62006-03-21 20:37:47 -05001814 num = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
Tejun Heoa0cf7332007-01-02 20:18:49 +09001816 if (buflen > (ATA_ID_SERNO_LEN + num + 3)) {
Jeff Garzikb142eb62006-03-21 20:37:47 -05001817 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001818 rbuf[num + 0] = 2;
Tejun Heoa0cf7332007-01-02 20:18:49 +09001819 rbuf[num + 3] = ATA_ID_SERNO_LEN;
Jeff Garzikb142eb62006-03-21 20:37:47 -05001820 num += 4;
1821 ata_id_string(args->id, (unsigned char *) rbuf + num,
Tejun Heoa0cf7332007-01-02 20:18:49 +09001822 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1823 num += ATA_ID_SERNO_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 }
Jeff Garzikb142eb62006-03-21 20:37:47 -05001825 if (buflen > (sat_model_serial_desc_len + num + 3)) {
1826 /* SAT defined lu model and serial numbers descriptor */
1827 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
Jeff Garzik2e9edbf2006-03-24 09:56:57 -05001828 rbuf[num + 0] = 2;
1829 rbuf[num + 1] = 1;
Jeff Garzikb142eb62006-03-21 20:37:47 -05001830 rbuf[num + 3] = sat_model_serial_desc_len;
1831 num += 4;
1832 memcpy(rbuf + num, "ATA ", 8);
1833 num += 8;
1834 ata_id_string(args->id, (unsigned char *) rbuf + num,
Tejun Heoa0cf7332007-01-02 20:18:49 +09001835 ATA_ID_PROD, ATA_ID_PROD_LEN);
1836 num += ATA_ID_PROD_LEN;
Jeff Garzikb142eb62006-03-21 20:37:47 -05001837 ata_id_string(args->id, (unsigned char *) rbuf + num,
Tejun Heoa0cf7332007-01-02 20:18:49 +09001838 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1839 num += ATA_ID_SERNO_LEN;
Jeff Garzikb142eb62006-03-21 20:37:47 -05001840 }
1841 rbuf[3] = num - 4; /* page len (assume less than 256 bytes) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 return 0;
1843}
1844
1845/**
Jeff Garzikad355b42007-09-21 20:38:03 -04001846 * ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
1847 * @args: device IDENTIFY data / SCSI command of interest.
1848 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1849 * @buflen: Response buffer length.
1850 *
1851 * Yields SAT-specified ATA VPD page.
1852 *
1853 * LOCKING:
1854 * spin_lock_irqsave(host lock)
1855 */
1856
1857unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf,
1858 unsigned int buflen)
1859{
1860 u8 pbuf[60];
1861 struct ata_taskfile tf;
1862 unsigned int i;
1863
1864 if (!buflen)
1865 return 0;
1866
1867 memset(&pbuf, 0, sizeof(pbuf));
1868 memset(&tf, 0, sizeof(tf));
1869
1870 pbuf[1] = 0x89; /* our page code */
1871 pbuf[2] = (0x238 >> 8); /* page size fixed at 238h */
1872 pbuf[3] = (0x238 & 0xff);
1873
Jeff Garzikc78968b2007-09-21 21:03:28 -04001874 memcpy(&pbuf[8], "linux ", 8);
1875 memcpy(&pbuf[16], "libata ", 16);
1876 memcpy(&pbuf[32], DRV_VERSION, 4);
Jeff Garzikad355b42007-09-21 20:38:03 -04001877 ata_id_string(args->id, &pbuf[32], ATA_ID_FW_REV, 4);
1878
1879 /* we don't store the ATA device signature, so we fake it */
1880
1881 tf.command = ATA_DRDY; /* really, this is Status reg */
1882 tf.lbal = 0x1;
1883 tf.nsect = 0x1;
1884
1885 ata_tf_to_fis(&tf, 0, 1, &pbuf[36]); /* TODO: PMP? */
1886 pbuf[36] = 0x34; /* force D2H Reg FIS (34h) */
1887
1888 pbuf[56] = ATA_CMD_ID_ATA;
1889
1890 i = min(buflen, 60U);
1891 memcpy(rbuf, &pbuf[0], i);
1892 buflen -= i;
1893
1894 if (!buflen)
1895 return 0;
1896
1897 memcpy(&rbuf[60], &args->id[0], min(buflen, 512U));
1898 return 0;
1899}
1900
1901/**
Jeff Garzik0cba6322005-05-30 19:49:12 -04001902 * ata_scsiop_noop - Command handler that simply returns success.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 * @args: device IDENTIFY data / SCSI command of interest.
1904 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1905 * @buflen: Response buffer length.
1906 *
1907 * No operation. Simply returns success to caller, to indicate
1908 * that the caller should successfully complete this SCSI command.
1909 *
1910 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001911 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 */
1913
1914unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1915 unsigned int buflen)
1916{
1917 VPRINTK("ENTER\n");
1918 return 0;
1919}
1920
1921/**
1922 * ata_msense_push - Push data onto MODE SENSE data output buffer
1923 * @ptr_io: (input/output) Location to store more output data
1924 * @last: End of output data buffer
1925 * @buf: Pointer to BLOB being added to output buffer
1926 * @buflen: Length of BLOB
1927 *
1928 * Store MODE SENSE data on an output buffer.
1929 *
1930 * LOCKING:
1931 * None.
1932 */
1933
1934static void ata_msense_push(u8 **ptr_io, const u8 *last,
1935 const u8 *buf, unsigned int buflen)
1936{
1937 u8 *ptr = *ptr_io;
1938
1939 if ((ptr + buflen - 1) > last)
1940 return;
1941
1942 memcpy(ptr, buf, buflen);
1943
1944 ptr += buflen;
1945
1946 *ptr_io = ptr;
1947}
1948
1949/**
1950 * ata_msense_caching - Simulate MODE SENSE caching info page
1951 * @id: device IDENTIFY data
1952 * @ptr_io: (input/output) Location to store more output data
1953 * @last: End of output data buffer
1954 *
1955 * Generate a caching info page, which conditionally indicates
1956 * write caching to the SCSI layer, depending on device
1957 * capabilities.
1958 *
1959 * LOCKING:
1960 * None.
1961 */
1962
1963static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1964 const u8 *last)
1965{
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04001966 u8 page[CACHE_MPAGE_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04001968 memcpy(page, def_cache_mpage, sizeof(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 if (ata_id_wcache_enabled(id))
1970 page[2] |= (1 << 2); /* write cache enable */
1971 if (!ata_id_rahead_enabled(id))
1972 page[12] |= (1 << 5); /* disable read ahead */
1973
1974 ata_msense_push(ptr_io, last, page, sizeof(page));
1975 return sizeof(page);
1976}
1977
1978/**
1979 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1980 * @dev: Device associated with this MODE SENSE command
1981 * @ptr_io: (input/output) Location to store more output data
1982 * @last: End of output data buffer
1983 *
1984 * Generate a generic MODE SENSE control mode page.
1985 *
1986 * LOCKING:
1987 * None.
1988 */
1989
1990static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1991{
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04001992 ata_msense_push(ptr_io, last, def_control_mpage,
1993 sizeof(def_control_mpage));
1994 return sizeof(def_control_mpage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995}
1996
1997/**
1998 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1999 * @dev: Device associated with this MODE SENSE command
2000 * @ptr_io: (input/output) Location to store more output data
2001 * @last: End of output data buffer
2002 *
2003 * Generate a generic MODE SENSE r/w error recovery page.
2004 *
2005 * LOCKING:
2006 * None.
2007 */
2008
2009static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
2010{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002012 ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
2013 sizeof(def_rw_recovery_mpage));
2014 return sizeof(def_rw_recovery_mpage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015}
2016
Jens Axboe48bdc8e2006-01-30 16:09:35 +01002017/*
2018 * We can turn this into a real blacklist if it's needed, for now just
2019 * blacklist any Maxtor BANC1G10 revision firmware
2020 */
2021static int ata_dev_supports_fua(u16 *id)
2022{
Tejun Heoa0cf7332007-01-02 20:18:49 +09002023 unsigned char model[ATA_ID_PROD_LEN + 1], fw[ATA_ID_FW_REV_LEN + 1];
Jens Axboe48bdc8e2006-01-30 16:09:35 +01002024
Jeff Garzikc3c013a2006-02-27 22:31:19 -05002025 if (!libata_fua)
2026 return 0;
Jens Axboe48bdc8e2006-01-30 16:09:35 +01002027 if (!ata_id_has_fua(id))
2028 return 0;
2029
Tejun Heoa0cf7332007-01-02 20:18:49 +09002030 ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
2031 ata_id_c_string(id, fw, ATA_ID_FW_REV, sizeof(fw));
Jens Axboe48bdc8e2006-01-30 16:09:35 +01002032
Tejun Heo2e026712006-02-12 22:47:04 +09002033 if (strcmp(model, "Maxtor"))
Jens Axboe48bdc8e2006-01-30 16:09:35 +01002034 return 1;
Tejun Heo2e026712006-02-12 22:47:04 +09002035 if (strcmp(fw, "BANC1G10"))
Jens Axboe48bdc8e2006-01-30 16:09:35 +01002036 return 1;
2037
2038 return 0; /* blacklisted */
2039}
2040
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041/**
2042 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
2043 * @args: device IDENTIFY data / SCSI command of interest.
2044 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2045 * @buflen: Response buffer length.
2046 *
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002047 * Simulate MODE SENSE commands. Assume this is invoked for direct
2048 * access devices (e.g. disks) only. There should be no block
2049 * descriptor for other device types.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 *
2051 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002052 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 */
2054
2055unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
2056 unsigned int buflen)
2057{
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002058 struct ata_device *dev = args->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 u8 *scsicmd = args->cmd->cmnd, *p, *last;
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002060 const u8 sat_blk_desc[] = {
2061 0, 0, 0, 0, /* number of blocks: sat unspecified */
2062 0,
2063 0, 0x2, 0x0 /* block length: 512 bytes */
2064 };
2065 u8 pg, spg;
2066 unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002067 u8 dpofua;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068
2069 VPRINTK("ENTER\n");
2070
2071 six_byte = (scsicmd[0] == MODE_SENSE);
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002072 ebd = !(scsicmd[1] & 0x8); /* dbd bit inverted == edb */
2073 /*
2074 * LLBA bit in msense(10) ignored (compliant)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 */
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002076
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 page_control = scsicmd[2] >> 6;
Douglas Gilbertae006512005-10-09 09:09:35 -04002078 switch (page_control) {
2079 case 0: /* current */
2080 break; /* supported */
2081 case 3: /* saved */
2082 goto saving_not_supp;
2083 case 1: /* changeable */
2084 case 2: /* defaults */
2085 default:
2086 goto invalid_fld;
2087 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002089 if (six_byte) {
2090 output_len = 4 + (ebd ? 8 : 0);
2091 alloc_len = scsicmd[4];
2092 } else {
2093 output_len = 8 + (ebd ? 8 : 0);
2094 alloc_len = (scsicmd[7] << 8) + scsicmd[8];
2095 }
2096 minlen = (alloc_len < buflen) ? alloc_len : buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097
2098 p = rbuf + output_len;
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002099 last = rbuf + minlen - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002101 pg = scsicmd[2] & 0x3f;
2102 spg = scsicmd[3];
2103 /*
2104 * No mode subpages supported (yet) but asking for _all_
2105 * subpages may be valid
2106 */
2107 if (spg && (spg != ALL_SUB_MPAGES))
2108 goto invalid_fld;
2109
2110 switch(pg) {
2111 case RW_RECOVERY_MPAGE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 output_len += ata_msense_rw_recovery(&p, last);
2113 break;
2114
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002115 case CACHE_MPAGE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 output_len += ata_msense_caching(args->id, &p, last);
2117 break;
2118
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002119 case CONTROL_MPAGE: {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 output_len += ata_msense_ctl_mode(&p, last);
2121 break;
2122 }
2123
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002124 case ALL_MPAGES:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 output_len += ata_msense_rw_recovery(&p, last);
2126 output_len += ata_msense_caching(args->id, &p, last);
2127 output_len += ata_msense_ctl_mode(&p, last);
2128 break;
2129
2130 default: /* invalid page code */
Douglas Gilbertae006512005-10-09 09:09:35 -04002131 goto invalid_fld;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 }
2133
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002134 if (minlen < 1)
2135 return 0;
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002136
2137 dpofua = 0;
Alan Coxf79d4092006-05-22 16:55:11 +01002138 if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002139 (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2140 dpofua = 1 << 4;
2141
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 if (six_byte) {
2143 output_len--;
2144 rbuf[0] = output_len;
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002145 if (minlen > 2)
2146 rbuf[2] |= dpofua;
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002147 if (ebd) {
2148 if (minlen > 3)
2149 rbuf[3] = sizeof(sat_blk_desc);
2150 if (minlen > 11)
2151 memcpy(rbuf + 4, sat_blk_desc,
2152 sizeof(sat_blk_desc));
2153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 } else {
2155 output_len -= 2;
2156 rbuf[0] = output_len >> 8;
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002157 if (minlen > 1)
2158 rbuf[1] = output_len;
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002159 if (minlen > 3)
2160 rbuf[3] |= dpofua;
Douglas Gilbert00ac37f2005-10-28 15:58:28 -04002161 if (ebd) {
2162 if (minlen > 7)
2163 rbuf[7] = sizeof(sat_blk_desc);
2164 if (minlen > 15)
2165 memcpy(rbuf + 8, sat_blk_desc,
2166 sizeof(sat_blk_desc));
2167 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 return 0;
Douglas Gilbertae006512005-10-09 09:09:35 -04002170
2171invalid_fld:
2172 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
2173 /* "Invalid field in cbd" */
2174 return 1;
2175
2176saving_not_supp:
2177 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2178 /* "Saving parameters not supported" */
2179 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180}
2181
2182/**
2183 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2184 * @args: device IDENTIFY data / SCSI command of interest.
2185 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2186 * @buflen: Response buffer length.
2187 *
2188 * Simulate READ CAPACITY commands.
2189 *
2190 * LOCKING:
Tejun Heo6a362612006-11-20 11:15:47 +09002191 * None.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002194 unsigned int buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195{
Tejun Heo6a362612006-11-20 11:15:47 +09002196 u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
2198 VPRINTK("ENTER\n");
2199
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 if (args->cmd->cmnd[0] == READ_CAPACITY) {
Tejun Heo6a362612006-11-20 11:15:47 +09002201 if (last_lba >= 0xffffffffULL)
2202 last_lba = 0xffffffff;
Philip Pokorny0c144d02005-05-28 01:24:47 -07002203
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 /* sector count, 32-bit */
Tejun Heo6a362612006-11-20 11:15:47 +09002205 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 3));
2206 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 2));
2207 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 1));
2208 ATA_SCSI_RBUF_SET(3, last_lba);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
2210 /* sector size */
Tejun Heo6a362612006-11-20 11:15:47 +09002211 ATA_SCSI_RBUF_SET(6, ATA_SECT_SIZE >> 8);
2212 ATA_SCSI_RBUF_SET(7, ATA_SECT_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 } else {
2214 /* sector count, 64-bit */
Tejun Heo6a362612006-11-20 11:15:47 +09002215 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 7));
2216 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 6));
2217 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 5));
2218 ATA_SCSI_RBUF_SET(3, last_lba >> (8 * 4));
2219 ATA_SCSI_RBUF_SET(4, last_lba >> (8 * 3));
2220 ATA_SCSI_RBUF_SET(5, last_lba >> (8 * 2));
2221 ATA_SCSI_RBUF_SET(6, last_lba >> (8 * 1));
2222 ATA_SCSI_RBUF_SET(7, last_lba);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223
2224 /* sector size */
Tejun Heo6a362612006-11-20 11:15:47 +09002225 ATA_SCSI_RBUF_SET(10, ATA_SECT_SIZE >> 8);
2226 ATA_SCSI_RBUF_SET(11, ATA_SECT_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 }
2228
2229 return 0;
2230}
2231
2232/**
2233 * ata_scsiop_report_luns - Simulate REPORT LUNS command
2234 * @args: device IDENTIFY data / SCSI command of interest.
2235 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2236 * @buflen: Response buffer length.
2237 *
2238 * Simulate REPORT LUNS command.
2239 *
2240 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002241 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 */
2243
2244unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
2245 unsigned int buflen)
2246{
2247 VPRINTK("ENTER\n");
2248 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
2249
2250 return 0;
2251}
2252
2253/**
Douglas Gilbert845c5832005-10-09 08:55:41 -04002254 * ata_scsi_set_sense - Set SCSI sense data and status
2255 * @cmd: SCSI request to be handled
2256 * @sk: SCSI-defined sense key
2257 * @asc: SCSI-defined additional sense code
2258 * @ascq: SCSI-defined additional sense code qualifier
2259 *
2260 * Helper function that builds a valid fixed format, current
2261 * response code and the given sense key (sk), additional sense
2262 * code (asc) and additional sense code qualifier (ascq) with
2263 * a SCSI command status of %SAM_STAT_CHECK_CONDITION and
2264 * DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
2265 *
2266 * LOCKING:
2267 * Not required
2268 */
2269
2270void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
2271{
2272 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
2273
2274 cmd->sense_buffer[0] = 0x70; /* fixed format, current */
2275 cmd->sense_buffer[2] = sk;
2276 cmd->sense_buffer[7] = 18 - 8; /* additional sense length */
2277 cmd->sense_buffer[12] = asc;
2278 cmd->sense_buffer[13] = ascq;
2279}
2280
2281/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 * ata_scsi_badcmd - End a SCSI request with an error
2283 * @cmd: SCSI request to be handled
2284 * @done: SCSI command completion function
2285 * @asc: SCSI-defined additional sense code
2286 * @ascq: SCSI-defined additional sense code qualifier
2287 *
2288 * Helper function that completes a SCSI command with
2289 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
2290 * and the specified additional sense codes.
2291 *
2292 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002293 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 */
2295
2296void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
2297{
2298 DPRINTK("ENTER\n");
Douglas Gilbertae006512005-10-09 09:09:35 -04002299 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
2301 done(cmd);
2302}
2303
Tejun Heo77853bf2006-01-23 13:09:36 +09002304static void atapi_sense_complete(struct ata_queued_cmd *qc)
Jeff Garzika939c962005-10-05 17:09:16 -04002305{
Tejun Heo74e6c8c2006-04-02 18:51:53 +09002306 if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002307 /* FIXME: not quite right; we don't want the
2308 * translation of taskfile registers into
2309 * a sense descriptors, since that's only
2310 * correct for ATA, not ATAPI
2311 */
Tejun Heo750426a2006-11-14 22:37:35 +09002312 ata_gen_passthru_sense(qc);
Tejun Heo74e6c8c2006-04-02 18:51:53 +09002313 }
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002314
2315 qc->scsidone(qc->scsicmd);
Tejun Heo77853bf2006-01-23 13:09:36 +09002316 ata_qc_free(qc);
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002317}
2318
2319/* is it pointless to prefer PIO for "safety reasons"? */
2320static inline int ata_pio_use_silly(struct ata_port *ap)
2321{
2322 return (ap->flags & ATA_FLAG_PIO_DMA);
2323}
2324
2325static void atapi_request_sense(struct ata_queued_cmd *qc)
2326{
2327 struct ata_port *ap = qc->ap;
2328 struct scsi_cmnd *cmd = qc->scsicmd;
Jeff Garzika939c962005-10-05 17:09:16 -04002329
2330 DPRINTK("ATAPI request sense\n");
2331
Jeff Garzika939c962005-10-05 17:09:16 -04002332 /* FIXME: is this needed? */
2333 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2334
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002335 ap->ops->tf_read(ap, &qc->tf);
2336
2337 /* fill these in, for the case where they are -not- overwritten */
2338 cmd->sense_buffer[0] = 0x70;
2339 cmd->sense_buffer[2] = qc->tf.feature >> 4;
2340
2341 ata_qc_reinit(qc);
2342
Jeff Garzika939c962005-10-05 17:09:16 -04002343 ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2344 qc->dma_dir = DMA_FROM_DEVICE;
2345
Tejun Heo6e7846e2006-02-12 23:32:58 +09002346 memset(&qc->cdb, 0, qc->dev->cdb_len);
Jeff Garzika939c962005-10-05 17:09:16 -04002347 qc->cdb[0] = REQUEST_SENSE;
2348 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2349
2350 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2351 qc->tf.command = ATA_CMD_PACKET;
2352
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002353 if (ata_pio_use_silly(ap)) {
2354 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2355 qc->tf.feature |= ATAPI_PKT_DMA;
2356 } else {
2357 qc->tf.protocol = ATA_PROT_ATAPI;
Alan Cox2db78dd2007-10-02 13:53:04 -07002358 qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
2359 qc->tf.lbah = 0;
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002360 }
Jeff Garzika939c962005-10-05 17:09:16 -04002361 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2362
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002363 qc->complete_fn = atapi_sense_complete;
Jeff Garzika939c962005-10-05 17:09:16 -04002364
Tejun Heo8e0e6942006-03-31 20:41:11 +09002365 ata_qc_issue(qc);
Jeff Garzika939c962005-10-05 17:09:16 -04002366
2367 DPRINTK("EXIT\n");
2368}
2369
Tejun Heo77853bf2006-01-23 13:09:36 +09002370static void atapi_qc_complete(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371{
2372 struct scsi_cmnd *cmd = qc->scsicmd;
Albert Leea22e2eb2005-12-05 15:38:02 +08002373 unsigned int err_mask = qc->err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374
Jeff Garzika7dac442005-10-30 04:44:42 -05002375 VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
Jeff Garzike12669e2005-10-05 18:39:23 -04002376
Tejun Heo246619d2006-05-15 20:58:16 +09002377 /* handle completion from new EH */
2378 if (unlikely(qc->ap->ops->error_handler &&
2379 (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2380
2381 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2382 /* FIXME: not quite right; we don't want the
2383 * translation of taskfile registers into a
2384 * sense descriptors, since that's only
2385 * correct for ATA, not ATAPI
2386 */
Tejun Heo750426a2006-11-14 22:37:35 +09002387 ata_gen_passthru_sense(qc);
Tejun Heo246619d2006-05-15 20:58:16 +09002388 }
2389
Tejun Heo22aac082006-08-08 14:08:59 +09002390 /* SCSI EH automatically locks door if sdev->locked is
2391 * set. Sometimes door lock request continues to
2392 * fail, for example, when no media is present. This
2393 * creates a loop - SCSI EH issues door lock which
2394 * fails and gets invoked again to acquire sense data
2395 * for the failed command.
2396 *
2397 * If door lock fails, always clear sdev->locked to
2398 * avoid this infinite loop.
2399 */
2400 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
2401 qc->dev->sdev->locked = 0;
2402
Tejun Heo246619d2006-05-15 20:58:16 +09002403 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2404 qc->scsidone(cmd);
2405 ata_qc_free(qc);
2406 return;
2407 }
2408
2409 /* successful completion or old EH failure path */
Jeff Garzika7dac442005-10-30 04:44:42 -05002410 if (unlikely(err_mask & AC_ERR_DEV)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 cmd->result = SAM_STAT_CHECK_CONDITION;
Jeff Garzikc6e6e6662005-11-14 14:50:05 -05002412 atapi_request_sense(qc);
Tejun Heo77853bf2006-01-23 13:09:36 +09002413 return;
Tejun Heo74e6c8c2006-04-02 18:51:53 +09002414 } else if (unlikely(err_mask)) {
Jeff Garzika7dac442005-10-30 04:44:42 -05002415 /* FIXME: not quite right; we don't want the
2416 * translation of taskfile registers into
2417 * a sense descriptors, since that's only
2418 * correct for ATA, not ATAPI
2419 */
Tejun Heo750426a2006-11-14 22:37:35 +09002420 ata_gen_passthru_sense(qc);
Tejun Heo74e6c8c2006-04-02 18:51:53 +09002421 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 u8 *scsicmd = cmd->cmnd;
2423
Tony Battersbyfd71da42005-12-21 16:35:44 -05002424 if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 u8 *buf = NULL;
2426 unsigned int buflen;
2427
2428 buflen = ata_scsi_rbuf_get(cmd, &buf);
Jeff Garzika15dbeb2005-10-05 15:02:14 -04002429
2430 /* ATAPI devices typically report zero for their SCSI version,
2431 * and sometimes deviate from the spec WRT response data
2432 * format. If SCSI version is reported as zero like normal,
2433 * then we make the following fixups: 1) Fake MMC-5 version,
2434 * to indicate to the Linux scsi midlayer this is a modern
2435 * device. 2) Ensure response data format / ATAPI information
2436 * are always correct.
2437 */
Jeff Garzika15dbeb2005-10-05 15:02:14 -04002438 if (buf[2] == 0) {
2439 buf[2] = 0x5;
2440 buf[3] = 0x32;
2441 }
2442
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 ata_scsi_rbuf_put(cmd, buf);
2444 }
Jeff Garzika15dbeb2005-10-05 15:02:14 -04002445
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 cmd->result = SAM_STAT_GOOD;
2447 }
2448
2449 qc->scsidone(cmd);
Tejun Heo77853bf2006-01-23 13:09:36 +09002450 ata_qc_free(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451}
2452/**
2453 * atapi_xlat - Initialize PACKET taskfile
2454 * @qc: command structure to be initialized
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 *
2456 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002457 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 *
2459 * RETURNS:
2460 * Zero on success, non-zero on failure.
2461 */
Tejun Heoad706992006-12-17 10:45:57 +09002462static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463{
Tejun Heo542b1442006-12-17 10:45:08 +09002464 struct scsi_cmnd *scmd = qc->scsicmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 struct ata_device *dev = qc->dev;
2466 int using_pio = (dev->flags & ATA_DFLAG_PIO);
Tejun Heo542b1442006-12-17 10:45:08 +09002467 int nodata = (scmd->sc_data_direction == DMA_NONE);
Alan Cox2db78dd2007-10-02 13:53:04 -07002468 unsigned int nbytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469
Tejun Heo2e5704f2006-12-17 10:46:33 +09002470 memset(qc->cdb, 0, dev->cdb_len);
2471 memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472
2473 qc->complete_fn = atapi_qc_complete;
2474
2475 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
Tejun Heo542b1442006-12-17 10:45:08 +09002476 if (scmd->sc_data_direction == DMA_TO_DEVICE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 qc->tf.flags |= ATA_TFLAG_WRITE;
2478 DPRINTK("direction: write\n");
2479 }
2480
2481 qc->tf.command = ATA_CMD_PACKET;
Boaz Harrosh71201652007-09-18 17:48:50 +02002482 qc->nbytes = scsi_bufflen(scmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483
Tejun Heoe00f1ff2007-06-27 02:47:35 +09002484 /* check whether ATAPI DMA is safe */
2485 if (!using_pio && ata_check_atapi_dma(qc))
2486 using_pio = 1;
2487
Alan Cox2db78dd2007-10-02 13:53:04 -07002488 /* Some controller variants snoop this value for Packet transfers
2489 to do state machine and FIFO management. Thus we want to set it
2490 properly, and for DMA where it is effectively meaningless */
2491 nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
2492
2493 qc->tf.lbam = (nbytes & 0xFF);
2494 qc->tf.lbah = (nbytes >> 8);
2495
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 if (using_pio || nodata) {
Tejun Heoe00f1ff2007-06-27 02:47:35 +09002497 /* no data, or PIO data xfer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 if (nodata)
2499 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
2500 else
2501 qc->tf.protocol = ATA_PROT_ATAPI;
Tejun Heoe00f1ff2007-06-27 02:47:35 +09002502 } else {
2503 /* DMA data xfer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2505 qc->tf.feature |= ATAPI_PKT_DMA;
2506
Tejun Heo542b1442006-12-17 10:45:08 +09002507 if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
Albert Lee95de7192006-04-04 10:57:18 +08002508 /* some SATA bridges need us to indicate data xfer direction */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 qc->tf.feature |= ATAPI_DMADIR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510 }
2511
Alan Cox2db78dd2007-10-02 13:53:04 -07002512
2513 /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
2514 as ATAPI tape drives don't get this right otherwise */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 return 0;
2516}
2517
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002518static struct ata_device *ata_find_dev(struct ata_port *ap, int devno)
Tejun Heoab5b3a52006-05-31 18:27:34 +09002519{
Tejun Heo41bda9c2007-08-06 18:36:24 +09002520 if (ap->nr_pmp_links == 0) {
2521 if (likely(devno < ata_link_max_devices(&ap->link)))
2522 return &ap->link.device[devno];
2523 } else {
2524 if (likely(devno < ap->nr_pmp_links))
2525 return &ap->pmp_link[devno].device[0];
2526 }
2527
Tejun Heoab5b3a52006-05-31 18:27:34 +09002528 return NULL;
2529}
2530
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002531static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
2532 const struct scsi_device *scsidev)
Tejun Heoab5b3a52006-05-31 18:27:34 +09002533{
Tejun Heo41bda9c2007-08-06 18:36:24 +09002534 int devno;
Tejun Heoab5b3a52006-05-31 18:27:34 +09002535
Tejun Heo41bda9c2007-08-06 18:36:24 +09002536 /* skip commands not addressed to targets we simulate */
2537 if (ap->nr_pmp_links == 0) {
2538 if (unlikely(scsidev->channel || scsidev->lun))
2539 return NULL;
2540 devno = scsidev->id;
2541 } else {
2542 if (unlikely(scsidev->id || scsidev->lun))
2543 return NULL;
2544 devno = scsidev->channel;
2545 }
2546
2547 return ata_find_dev(ap, devno);
Tejun Heoab5b3a52006-05-31 18:27:34 +09002548}
2549
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550/**
Brian King99ba9e02006-06-12 14:54:17 -05002551 * ata_scsi_dev_enabled - determine if device is enabled
2552 * @dev: ATA device
2553 *
2554 * Determine if commands should be sent to the specified device.
2555 *
2556 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002557 * spin_lock_irqsave(host lock)
Brian King99ba9e02006-06-12 14:54:17 -05002558 *
2559 * RETURNS:
2560 * 0 if commands are not allowed / 1 if commands are allowed
2561 */
2562
2563static int ata_scsi_dev_enabled(struct ata_device *dev)
2564{
2565 if (unlikely(!ata_dev_enabled(dev)))
2566 return 0;
2567
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002568 if (!atapi_enabled || (dev->link->ap->flags & ATA_FLAG_NO_ATAPI)) {
Brian King99ba9e02006-06-12 14:54:17 -05002569 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
2570 ata_dev_printk(dev, KERN_WARNING,
2571 "WARNING: ATAPI is %s, device ignored.\n",
2572 atapi_enabled ? "not supported with this driver" : "disabled");
2573 return 0;
2574 }
2575 }
2576
2577 return 1;
2578}
2579
2580/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2582 * @ap: ATA port to which the device is attached
2583 * @scsidev: SCSI device from which we derive the ATA device
2584 *
2585 * Given various information provided in struct scsi_cmnd,
2586 * map that onto an ATA bus, and using that mapping
2587 * determine which ata_device is associated with the
2588 * SCSI command to be sent.
2589 *
2590 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002591 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 *
2593 * RETURNS:
2594 * Associated ATA device, or %NULL if not found.
2595 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596static struct ata_device *
Jeff Garzik057ace52005-10-22 14:27:05 -04002597ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598{
Tejun Heoab5b3a52006-05-31 18:27:34 +09002599 struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600
Brian King99ba9e02006-06-12 14:54:17 -05002601 if (unlikely(!dev || !ata_scsi_dev_enabled(dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602 return NULL;
2603
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 return dev;
2605}
2606
Jeff Garzikb0955182005-05-12 15:45:22 -04002607/*
2608 * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2609 * @byte1: Byte 1 from pass-thru CDB.
2610 *
2611 * RETURNS:
2612 * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2613 */
2614static u8
2615ata_scsi_map_proto(u8 byte1)
2616{
2617 switch((byte1 & 0x1e) >> 1) {
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002618 case 3: /* Non-data */
2619 return ATA_PROT_NODATA;
Jeff Garzikb0955182005-05-12 15:45:22 -04002620
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002621 case 6: /* DMA */
2622 case 10: /* UDMA Data-in */
2623 case 11: /* UDMA Data-Out */
2624 return ATA_PROT_DMA;
Jeff Garzikb0955182005-05-12 15:45:22 -04002625
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002626 case 4: /* PIO Data-in */
2627 case 5: /* PIO Data-out */
2628 return ATA_PROT_PIO;
Jeff Garzikb0955182005-05-12 15:45:22 -04002629
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002630 case 0: /* Hard Reset */
2631 case 1: /* SRST */
2632 case 8: /* Device Diagnostic */
2633 case 9: /* Device Reset */
2634 case 7: /* DMA Queued */
2635 case 12: /* FPDMA */
2636 case 15: /* Return Response Info */
2637 default: /* Reserved */
2638 break;
Jeff Garzikb0955182005-05-12 15:45:22 -04002639 }
2640
2641 return ATA_PROT_UNKNOWN;
2642}
2643
2644/**
2645 * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2646 * @qc: command structure to be initialized
Jeff Garzikb0955182005-05-12 15:45:22 -04002647 *
2648 * Handles either 12 or 16-byte versions of the CDB.
2649 *
2650 * RETURNS:
2651 * Zero on success, non-zero on failure.
2652 */
Tejun Heoad706992006-12-17 10:45:57 +09002653static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
Jeff Garzikb0955182005-05-12 15:45:22 -04002654{
2655 struct ata_taskfile *tf = &(qc->tf);
Tejun Heo542b1442006-12-17 10:45:08 +09002656 struct scsi_cmnd *scmd = qc->scsicmd;
Alan Coxf79d4092006-05-22 16:55:11 +01002657 struct ata_device *dev = qc->dev;
Tejun Heoad706992006-12-17 10:45:57 +09002658 const u8 *cdb = scmd->cmnd;
Jeff Garzikb0955182005-05-12 15:45:22 -04002659
Tejun Heo542b1442006-12-17 10:45:08 +09002660 if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
Tejun Heo9a405252005-12-02 11:49:11 +09002661 goto invalid_fld;
Jeff Garzik8190bdb2006-05-24 01:53:39 -04002662
Alan Coxf79d4092006-05-22 16:55:11 +01002663 /* We may not issue DMA commands if no DMA mode is set */
2664 if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
2665 goto invalid_fld;
Jeff Garzikb0955182005-05-12 15:45:22 -04002666
2667 /*
2668 * 12 and 16 byte CDBs use different offsets to
2669 * provide the various register values.
2670 */
Tejun Heo542b1442006-12-17 10:45:08 +09002671 if (cdb[0] == ATA_16) {
Jeff Garzikb0955182005-05-12 15:45:22 -04002672 /*
2673 * 16-byte CDB - may contain extended commands.
2674 *
2675 * If that is the case, copy the upper byte register values.
2676 */
Tejun Heo542b1442006-12-17 10:45:08 +09002677 if (cdb[1] & 0x01) {
2678 tf->hob_feature = cdb[3];
2679 tf->hob_nsect = cdb[5];
2680 tf->hob_lbal = cdb[7];
2681 tf->hob_lbam = cdb[9];
2682 tf->hob_lbah = cdb[11];
Jeff Garzikb0955182005-05-12 15:45:22 -04002683 tf->flags |= ATA_TFLAG_LBA48;
2684 } else
2685 tf->flags &= ~ATA_TFLAG_LBA48;
2686
2687 /*
2688 * Always copy low byte, device and command registers.
2689 */
Tejun Heo542b1442006-12-17 10:45:08 +09002690 tf->feature = cdb[4];
2691 tf->nsect = cdb[6];
2692 tf->lbal = cdb[8];
2693 tf->lbam = cdb[10];
2694 tf->lbah = cdb[12];
2695 tf->device = cdb[13];
2696 tf->command = cdb[14];
Jeff Garzikb0955182005-05-12 15:45:22 -04002697 } else {
2698 /*
2699 * 12-byte CDB - incapable of extended commands.
2700 */
2701 tf->flags &= ~ATA_TFLAG_LBA48;
2702
Tejun Heo542b1442006-12-17 10:45:08 +09002703 tf->feature = cdb[3];
2704 tf->nsect = cdb[4];
2705 tf->lbal = cdb[5];
2706 tf->lbam = cdb[6];
2707 tf->lbah = cdb[7];
2708 tf->device = cdb[8];
2709 tf->command = cdb[9];
Jeff Garzikb0955182005-05-12 15:45:22 -04002710 }
Albert Leefa4453c2007-06-07 15:52:07 +08002711
2712 /* enforce correct master/slave bit */
2713 tf->device = dev->devno ?
2714 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
Jeff Garzikb0955182005-05-12 15:45:22 -04002715
Albert Lee1dce5892007-06-07 15:49:22 +08002716 /* sanity check for pio multi commands */
2717 if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
2718 goto invalid_fld;
2719
2720 if (is_multi_taskfile(tf)) {
2721 unsigned int multi_count = 1 << (cdb[1] >> 5);
2722
2723 /* compare the passed through multi_count
2724 * with the cached multi_count of libata
2725 */
2726 if (multi_count != dev->multi_count)
2727 ata_dev_printk(dev, KERN_WARNING,
2728 "invalid multi_count %u ignored\n",
2729 multi_count);
Alan Coxd26fc952007-07-06 19:13:52 -04002730 }
Albert Lee1dce5892007-06-07 15:49:22 +08002731
Mark Lord5a5dbd12007-03-16 10:22:26 -04002732 /* READ/WRITE LONG use a non-standard sect_size */
2733 qc->sect_size = ATA_SECT_SIZE;
2734 switch (tf->command) {
2735 case ATA_CMD_READ_LONG:
2736 case ATA_CMD_READ_LONG_ONCE:
2737 case ATA_CMD_WRITE_LONG:
2738 case ATA_CMD_WRITE_LONG_ONCE:
2739 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
2740 goto invalid_fld;
Boaz Harrosh71201652007-09-18 17:48:50 +02002741 qc->sect_size = scsi_bufflen(scmd);
Mark Lord5a5dbd12007-03-16 10:22:26 -04002742 }
2743
Jeff Garzikb0955182005-05-12 15:45:22 -04002744 /*
2745 * Filter SET_FEATURES - XFER MODE command -- otherwise,
2746 * SET_FEATURES - XFER MODE must be preceded/succeeded
2747 * by an update to hardware-specific registers for each
2748 * controller (i.e. the reason for ->set_piomode(),
2749 * ->set_dmamode(), and ->post_set_mode() hooks).
2750 */
2751 if ((tf->command == ATA_CMD_SET_FEATURES)
2752 && (tf->feature == SETFEATURES_XFER))
Tejun Heo9a405252005-12-02 11:49:11 +09002753 goto invalid_fld;
Jeff Garzikb0955182005-05-12 15:45:22 -04002754
2755 /*
2756 * Set flags so that all registers will be written,
2757 * and pass on write indication (used for PIO/DMA
2758 * setup.)
2759 */
2760 tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
2761
Tejun Heo542b1442006-12-17 10:45:08 +09002762 if (scmd->sc_data_direction == DMA_TO_DEVICE)
Jeff Garzikb0955182005-05-12 15:45:22 -04002763 tf->flags |= ATA_TFLAG_WRITE;
2764
2765 /*
2766 * Set transfer length.
2767 *
2768 * TODO: find out if we need to do more here to
2769 * cover scatter/gather case.
2770 */
Boaz Harrosh71201652007-09-18 17:48:50 +02002771 qc->nbytes = scsi_bufflen(scmd);
Jeff Garzikb0955182005-05-12 15:45:22 -04002772
Tejun Heoe027bd32007-10-26 16:19:26 +09002773 /* request result TF and be quiet about device error */
2774 qc->flags |= ATA_QCFLAG_RESULT_TF | ATA_QCFLAG_QUIET;
Tejun Heoe61e0672006-05-15 20:57:40 +09002775
Jeff Garzikb0955182005-05-12 15:45:22 -04002776 return 0;
Tejun Heo9a405252005-12-02 11:49:11 +09002777
2778 invalid_fld:
Tejun Heo542b1442006-12-17 10:45:08 +09002779 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
Tejun Heo9a405252005-12-02 11:49:11 +09002780 /* "Invalid field in cdb" */
2781 return 1;
Jeff Garzikb0955182005-05-12 15:45:22 -04002782}
2783
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784/**
2785 * ata_get_xlat_func - check if SCSI to ATA translation is possible
2786 * @dev: ATA device
2787 * @cmd: SCSI command opcode to consider
2788 *
2789 * Look up the SCSI command given, and determine whether the
2790 * SCSI command is to be translated or simulated.
2791 *
2792 * RETURNS:
2793 * Pointer to translation function if possible, %NULL if not.
2794 */
2795
2796static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
2797{
2798 switch (cmd) {
2799 case READ_6:
2800 case READ_10:
2801 case READ_16:
2802
2803 case WRITE_6:
2804 case WRITE_10:
2805 case WRITE_16:
2806 return ata_scsi_rw_xlat;
2807
2808 case SYNCHRONIZE_CACHE:
2809 if (ata_try_flush_cache(dev))
2810 return ata_scsi_flush_xlat;
2811 break;
2812
2813 case VERIFY:
2814 case VERIFY_16:
2815 return ata_scsi_verify_xlat;
Jeff Garzikb0955182005-05-12 15:45:22 -04002816
2817 case ATA_12:
2818 case ATA_16:
2819 return ata_scsi_pass_thru;
Jeff Garzikda613962005-08-29 19:01:43 -04002820
Douglas Gilbert972dcaf2005-08-11 03:35:53 -04002821 case START_STOP:
2822 return ata_scsi_start_stop_xlat;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 }
2824
2825 return NULL;
2826}
2827
2828/**
2829 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
2830 * @ap: ATA port to which the command was being sent
2831 * @cmd: SCSI command to dump
2832 *
2833 * Prints the contents of a SCSI command via printk().
2834 */
2835
2836static inline void ata_scsi_dump_cdb(struct ata_port *ap,
2837 struct scsi_cmnd *cmd)
2838{
2839#ifdef ATA_DEBUG
2840 struct scsi_device *scsidev = cmd->device;
2841 u8 *scsicmd = cmd->cmnd;
2842
2843 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
Tejun Heo44877b42007-02-21 01:06:51 +09002844 ap->print_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845 scsidev->channel, scsidev->id, scsidev->lun,
2846 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
2847 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
2848 scsicmd[8]);
2849#endif
2850}
2851
Tejun Heo542b1442006-12-17 10:45:08 +09002852static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
Tejun Heo2115ea92006-05-15 21:03:39 +09002853 void (*done)(struct scsi_cmnd *),
2854 struct ata_device *dev)
Brian Kingeb3f0f92006-03-23 17:30:02 -06002855{
Mark Lordbaf4fdf2007-08-08 01:08:45 +09002856 u8 scsi_op = scmd->cmnd[0];
2857 ata_xlat_func_t xlat_func;
Tejun Heo2115ea92006-05-15 21:03:39 +09002858 int rc = 0;
2859
Mark Lordbaf4fdf2007-08-08 01:08:45 +09002860 if (dev->class == ATA_DEV_ATA) {
2861 if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
2862 goto bad_cdb_len;
2863
2864 xlat_func = ata_get_xlat_func(dev, scsi_op);
2865 } else {
2866 if (unlikely(!scmd->cmd_len))
2867 goto bad_cdb_len;
2868
2869 xlat_func = NULL;
2870 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
2871 /* relay SCSI command to ATAPI device */
2872 if (unlikely(scmd->cmd_len > dev->cdb_len))
2873 goto bad_cdb_len;
2874
2875 xlat_func = atapi_xlat;
2876 } else {
2877 /* ATA_16 passthru, treat as an ATA command */
2878 if (unlikely(scmd->cmd_len > 16))
2879 goto bad_cdb_len;
2880
2881 xlat_func = ata_get_xlat_func(dev, scsi_op);
2882 }
Tejun Heo2e5704f2006-12-17 10:46:33 +09002883 }
2884
Mark Lordbaf4fdf2007-08-08 01:08:45 +09002885 if (xlat_func)
2886 rc = ata_scsi_translate(dev, scmd, done, xlat_func);
2887 else
2888 ata_scsi_simulate(dev, scmd, done);
Tejun Heo2115ea92006-05-15 21:03:39 +09002889
2890 return rc;
Mark Lordbaf4fdf2007-08-08 01:08:45 +09002891
2892 bad_cdb_len:
2893 DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
2894 scmd->cmd_len, scsi_op, dev->cdb_len);
2895 scmd->result = DID_ERROR << 16;
2896 done(scmd);
2897 return 0;
Brian Kingeb3f0f92006-03-23 17:30:02 -06002898}
2899
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900/**
2901 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
2902 * @cmd: SCSI command to be sent
2903 * @done: Completion function, called when command is complete
2904 *
2905 * In some cases, this function translates SCSI commands into
2906 * ATA taskfiles, and queues the taskfiles to be sent to
2907 * hardware. In other cases, this function simulates a
2908 * SCSI device by evaluating and responding to certain
2909 * SCSI commands. This creates the overall effect of
2910 * ATA and ATAPI devices appearing as SCSI devices.
2911 *
2912 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002913 * Releases scsi-layer-held lock, and obtains host lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914 *
2915 * RETURNS:
Tejun Heo2115ea92006-05-15 21:03:39 +09002916 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
2917 * 0 otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
2920{
2921 struct ata_port *ap;
2922 struct ata_device *dev;
2923 struct scsi_device *scsidev = cmd->device;
Jeff Garzik005a5a02005-10-30 23:31:48 -05002924 struct Scsi_Host *shost = scsidev->host;
Tejun Heo2115ea92006-05-15 21:03:39 +09002925 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926
Jeff Garzik35bb94b2006-04-11 13:12:34 -04002927 ap = ata_shost_to_port(shost);
Jeff Garzik005a5a02005-10-30 23:31:48 -05002928
2929 spin_unlock(shost->host_lock);
Jeff Garzikba6a1302006-06-22 23:46:10 -04002930 spin_lock(ap->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931
2932 ata_scsi_dump_cdb(ap, cmd);
2933
2934 dev = ata_scsi_find_dev(ap, scsidev);
Brian Kingeb3f0f92006-03-23 17:30:02 -06002935 if (likely(dev))
Tejun Heo2115ea92006-05-15 21:03:39 +09002936 rc = __ata_scsi_queuecmd(cmd, done, dev);
Brian Kingeb3f0f92006-03-23 17:30:02 -06002937 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 cmd->result = (DID_BAD_TARGET << 16);
2939 done(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 }
2941
Jeff Garzikba6a1302006-06-22 23:46:10 -04002942 spin_unlock(ap->lock);
Jeff Garzik005a5a02005-10-30 23:31:48 -05002943 spin_lock(shost->host_lock);
Tejun Heo2115ea92006-05-15 21:03:39 +09002944 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945}
2946
2947/**
2948 * ata_scsi_simulate - simulate SCSI command on ATA device
Randy Dunlapc893a3a2006-01-28 13:15:32 -05002949 * @dev: the target device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950 * @cmd: SCSI command being sent to device.
2951 * @done: SCSI command completion function.
2952 *
2953 * Interprets and directly executes a select list of SCSI commands
2954 * that can be handled internally.
2955 *
2956 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002957 * spin_lock_irqsave(host lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 */
2959
Tejun Heo3373efd2006-05-15 20:57:53 +09002960void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 void (*done)(struct scsi_cmnd *))
2962{
2963 struct ata_scsi_args args;
Jeff Garzik057ace52005-10-22 14:27:05 -04002964 const u8 *scsicmd = cmd->cmnd;
Jeff Garzik45394142007-09-21 06:23:42 -04002965 u8 tmp8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966
Tejun Heo9a3dccc2006-01-06 09:56:18 +01002967 args.dev = dev;
2968 args.id = dev->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969 args.cmd = cmd;
2970 args.done = done;
2971
2972 switch(scsicmd[0]) {
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002973 /* TODO: worth improving? */
2974 case FORMAT_UNIT:
2975 ata_scsi_invalid_field(cmd, done);
2976 break;
2977
2978 case INQUIRY:
2979 if (scsicmd[1] & 2) /* is CmdDt set? */
Jeff Garzik00bd0202007-09-21 07:26:08 -04002980 ata_scsi_invalid_field(cmd, done);
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002981 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
2982 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2983 else switch (scsicmd[2]) {
2984 case 0x00:
2985 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 break;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002987 case 0x80:
2988 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 break;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002990 case 0x83:
2991 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 break;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002993 case 0x89:
2994 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 default:
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002997 ata_scsi_invalid_field(cmd, done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 break;
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002999 }
3000 break;
3001
3002 case MODE_SENSE:
3003 case MODE_SENSE_10:
3004 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
3005 break;
3006
3007 case MODE_SELECT: /* unconditionally return */
3008 case MODE_SELECT_10: /* bad-field-in-cdb */
3009 ata_scsi_invalid_field(cmd, done);
3010 break;
3011
3012 case READ_CAPACITY:
3013 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3014 break;
3015
3016 case SERVICE_ACTION_IN:
3017 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
3018 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3019 else
3020 ata_scsi_invalid_field(cmd, done);
3021 break;
3022
3023 case REPORT_LUNS:
3024 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
3025 break;
3026
3027 case REQUEST_SENSE:
3028 ata_scsi_set_sense(cmd, 0, 0, 0);
3029 cmd->result = (DRIVER_SENSE << 24);
3030 done(cmd);
3031 break;
3032
3033 /* if we reach this, then writeback caching is disabled,
3034 * turning this into a no-op.
3035 */
3036 case SYNCHRONIZE_CACHE:
3037 /* fall through */
3038
3039 /* no-op's, complete with success */
3040 case REZERO_UNIT:
3041 case SEEK_6:
3042 case SEEK_10:
3043 case TEST_UNIT_READY:
3044 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3045 break;
3046
3047 case SEND_DIAGNOSTIC:
3048 tmp8 = scsicmd[1] & ~(1 << 3);
3049 if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
3050 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3051 else
3052 ata_scsi_invalid_field(cmd, done);
3053 break;
3054
3055 /* all other commands */
3056 default:
3057 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
3058 /* "Invalid command operation code" */
3059 done(cmd);
3060 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061 }
3062}
3063
Tejun Heof3187192007-04-17 23:44:07 +09003064int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
3065{
3066 int i, rc;
3067
3068 for (i = 0; i < host->n_ports; i++) {
3069 struct ata_port *ap = host->ports[i];
3070 struct Scsi_Host *shost;
3071
3072 rc = -ENOMEM;
3073 shost = scsi_host_alloc(sht, sizeof(struct ata_port *));
3074 if (!shost)
3075 goto err_alloc;
3076
3077 *(struct ata_port **)&shost->hostdata[0] = ap;
3078 ap->scsi_host = shost;
3079
3080 shost->transportt = &ata_scsi_transport_template;
3081 shost->unique_id = ap->print_id;
3082 shost->max_id = 16;
3083 shost->max_lun = 1;
3084 shost->max_channel = 1;
3085 shost->max_cmd_len = 16;
3086
Tejun Heo31cc23b2007-09-23 13:14:12 +09003087 /* Schedule policy is determined by ->qc_defer()
3088 * callback and it needs to see every deferred qc.
3089 * Set host_blocked to 1 to prevent SCSI midlayer from
3090 * automatically deferring requests.
3091 */
3092 shost->max_host_blocked = 1;
3093
Tejun Heof3187192007-04-17 23:44:07 +09003094 rc = scsi_add_host(ap->scsi_host, ap->host->dev);
3095 if (rc)
3096 goto err_add;
3097 }
3098
3099 return 0;
3100
3101 err_add:
3102 scsi_host_put(host->ports[i]->scsi_host);
3103 err_alloc:
3104 while (--i >= 0) {
3105 struct Scsi_Host *shost = host->ports[i]->scsi_host;
3106
3107 scsi_remove_host(shost);
3108 scsi_host_put(shost);
3109 }
3110 return rc;
3111}
3112
Tejun Heo1ae46312007-07-16 14:29:40 +09003113void ata_scsi_scan_host(struct ata_port *ap, int sync)
Jeff Garzik644dd0c2005-10-03 15:55:19 -04003114{
Tejun Heo1ae46312007-07-16 14:29:40 +09003115 int tries = 5;
3116 struct ata_device *last_failed_dev = NULL;
Tejun Heo41bda9c2007-08-06 18:36:24 +09003117 struct ata_link *link;
Tejun Heo1ae46312007-07-16 14:29:40 +09003118 struct ata_device *dev;
Jeff Garzik644dd0c2005-10-03 15:55:19 -04003119
Tejun Heo198e0fe2006-04-02 18:51:52 +09003120 if (ap->flags & ATA_FLAG_DISABLED)
Jeff Garzik644dd0c2005-10-03 15:55:19 -04003121 return;
3122
Tejun Heo1ae46312007-07-16 14:29:40 +09003123 repeat:
Tejun Heo41bda9c2007-08-06 18:36:24 +09003124 ata_port_for_each_link(link, ap) {
3125 ata_link_for_each_dev(dev, link) {
3126 struct scsi_device *sdev;
3127 int channel = 0, id = 0;
Jeff Garzik3f19ee82005-10-03 21:36:41 -04003128
Tejun Heo41bda9c2007-08-06 18:36:24 +09003129 if (!ata_dev_enabled(dev) || dev->sdev)
3130 continue;
Tejun Heo3edebac2006-05-31 18:27:40 +09003131
Tejun Heo41bda9c2007-08-06 18:36:24 +09003132 if (ata_is_host_link(link))
3133 id = dev->devno;
3134 else
3135 channel = link->pmp;
3136
3137 sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
3138 NULL);
3139 if (!IS_ERR(sdev)) {
3140 dev->sdev = sdev;
3141 scsi_device_put(sdev);
3142 }
Tejun Heo3edebac2006-05-31 18:27:40 +09003143 }
Jeff Garzik3f19ee82005-10-03 21:36:41 -04003144 }
Tejun Heo1ae46312007-07-16 14:29:40 +09003145
3146 /* If we scanned while EH was in progress or allocation
3147 * failure occurred, scan would have failed silently. Check
3148 * whether all devices are attached.
3149 */
Tejun Heo41bda9c2007-08-06 18:36:24 +09003150 ata_port_for_each_link(link, ap) {
3151 ata_link_for_each_dev(dev, link) {
3152 if (ata_dev_enabled(dev) && !dev->sdev)
3153 goto exit_loop;
3154 }
Tejun Heo1ae46312007-07-16 14:29:40 +09003155 }
Tejun Heo41bda9c2007-08-06 18:36:24 +09003156 exit_loop:
3157 if (!link)
Tejun Heo1ae46312007-07-16 14:29:40 +09003158 return;
3159
3160 /* we're missing some SCSI devices */
3161 if (sync) {
3162 /* If caller requested synchrnous scan && we've made
3163 * any progress, sleep briefly and repeat.
3164 */
3165 if (dev != last_failed_dev) {
3166 msleep(100);
3167 last_failed_dev = dev;
3168 goto repeat;
3169 }
3170
3171 /* We might be failing to detect boot device, give it
3172 * a few more chances.
3173 */
3174 if (--tries) {
3175 msleep(100);
3176 goto repeat;
3177 }
3178
3179 ata_port_printk(ap, KERN_ERR, "WARNING: synchronous SCSI scan "
3180 "failed without making any progress,\n"
3181 " switching to async\n");
3182 }
3183
3184 queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
3185 round_jiffies_relative(HZ));
Jeff Garzik644dd0c2005-10-03 15:55:19 -04003186}
Tejun Heo0ea035a2006-05-31 18:28:01 +09003187
3188/**
3189 * ata_scsi_offline_dev - offline attached SCSI device
3190 * @dev: ATA device to offline attached SCSI device for
3191 *
3192 * This function is called from ata_eh_hotplug() and responsible
3193 * for taking the SCSI device attached to @dev offline. This
Jeff Garzikcca39742006-08-24 03:19:22 -04003194 * function is called with host lock which protects dev->sdev
Tejun Heo0ea035a2006-05-31 18:28:01 +09003195 * against clearing.
3196 *
3197 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04003198 * spin_lock_irqsave(host lock)
Tejun Heo0ea035a2006-05-31 18:28:01 +09003199 *
3200 * RETURNS:
3201 * 1 if attached SCSI device exists, 0 otherwise.
3202 */
3203int ata_scsi_offline_dev(struct ata_device *dev)
3204{
3205 if (dev->sdev) {
3206 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
3207 return 1;
3208 }
3209 return 0;
3210}
Tejun Heo580b21022006-05-31 18:28:05 +09003211
3212/**
3213 * ata_scsi_remove_dev - remove attached SCSI device
3214 * @dev: ATA device to remove attached SCSI device for
3215 *
3216 * This function is called from ata_eh_scsi_hotplug() and
3217 * responsible for removing the SCSI device attached to @dev.
3218 *
3219 * LOCKING:
3220 * Kernel thread context (may sleep).
3221 */
3222static void ata_scsi_remove_dev(struct ata_device *dev)
3223{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003224 struct ata_port *ap = dev->link->ap;
Tejun Heo580b21022006-05-31 18:28:05 +09003225 struct scsi_device *sdev;
3226 unsigned long flags;
3227
3228 /* Alas, we need to grab scan_mutex to ensure SCSI device
3229 * state doesn't change underneath us and thus
3230 * scsi_device_get() always succeeds. The mutex locking can
3231 * be removed if there is __scsi_device_get() interface which
3232 * increments reference counts regardless of device state.
3233 */
Jeff Garzikcca39742006-08-24 03:19:22 -04003234 mutex_lock(&ap->scsi_host->scan_mutex);
Jeff Garzikba6a1302006-06-22 23:46:10 -04003235 spin_lock_irqsave(ap->lock, flags);
Tejun Heo580b21022006-05-31 18:28:05 +09003236
Jeff Garzikcca39742006-08-24 03:19:22 -04003237 /* clearing dev->sdev is protected by host lock */
Tejun Heo580b21022006-05-31 18:28:05 +09003238 sdev = dev->sdev;
3239 dev->sdev = NULL;
3240
3241 if (sdev) {
3242 /* If user initiated unplug races with us, sdev can go
Jeff Garzikcca39742006-08-24 03:19:22 -04003243 * away underneath us after the host lock and
Tejun Heo580b21022006-05-31 18:28:05 +09003244 * scan_mutex are released. Hold onto it.
3245 */
3246 if (scsi_device_get(sdev) == 0) {
3247 /* The following ensures the attached sdev is
3248 * offline on return from ata_scsi_offline_dev()
3249 * regardless it wins or loses the race
3250 * against this function.
3251 */
3252 scsi_device_set_state(sdev, SDEV_OFFLINE);
3253 } else {
3254 WARN_ON(1);
3255 sdev = NULL;
3256 }
3257 }
3258
Jeff Garzikba6a1302006-06-22 23:46:10 -04003259 spin_unlock_irqrestore(ap->lock, flags);
Jeff Garzikcca39742006-08-24 03:19:22 -04003260 mutex_unlock(&ap->scsi_host->scan_mutex);
Tejun Heo580b21022006-05-31 18:28:05 +09003261
3262 if (sdev) {
3263 ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
3264 sdev->sdev_gendev.bus_id);
3265
3266 scsi_remove_device(sdev);
3267 scsi_device_put(sdev);
3268 }
3269}
3270
Tejun Heo41bda9c2007-08-06 18:36:24 +09003271static void ata_scsi_handle_link_detach(struct ata_link *link)
3272{
3273 struct ata_port *ap = link->ap;
3274 struct ata_device *dev;
3275
3276 ata_link_for_each_dev(dev, link) {
3277 unsigned long flags;
3278
3279 if (!(dev->flags & ATA_DFLAG_DETACHED))
3280 continue;
3281
3282 spin_lock_irqsave(ap->lock, flags);
3283 dev->flags &= ~ATA_DFLAG_DETACHED;
3284 spin_unlock_irqrestore(ap->lock, flags);
3285
3286 ata_scsi_remove_dev(dev);
3287 }
3288}
3289
Tejun Heo580b21022006-05-31 18:28:05 +09003290/**
Kristen Carlson Accardi2f294962007-08-15 04:11:25 -04003291 * ata_scsi_media_change_notify - send media change event
Randy Dunlapc5d0e6a2007-10-15 17:29:46 -07003292 * @dev: Pointer to the disk device with media change event
Kristen Carlson Accardi2f294962007-08-15 04:11:25 -04003293 *
3294 * Tell the block layer to send a media change notification
3295 * event.
3296 *
3297 * LOCKING:
Tejun Heo854c73a2007-09-23 13:14:11 +09003298 * spin_lock_irqsave(host lock)
Kristen Carlson Accardi2f294962007-08-15 04:11:25 -04003299 */
Tejun Heo854c73a2007-09-23 13:14:11 +09003300void ata_scsi_media_change_notify(struct ata_device *dev)
Kristen Carlson Accardi2f294962007-08-15 04:11:25 -04003301{
Tejun Heo854c73a2007-09-23 13:14:11 +09003302 if (dev->sdev)
Jeff Garzikf26792d2007-10-29 17:18:39 -04003303 sdev_evt_send_simple(dev->sdev, SDEV_EVT_MEDIA_CHANGE,
3304 GFP_ATOMIC);
Kristen Carlson Accardi2f294962007-08-15 04:11:25 -04003305}
Kristen Carlson Accardi2f294962007-08-15 04:11:25 -04003306
3307/**
Tejun Heo580b21022006-05-31 18:28:05 +09003308 * ata_scsi_hotplug - SCSI part of hotplug
David Howells65f27f32006-11-22 14:55:48 +00003309 * @work: Pointer to ATA port to perform SCSI hotplug on
Tejun Heo580b21022006-05-31 18:28:05 +09003310 *
3311 * Perform SCSI part of hotplug. It's executed from a separate
3312 * workqueue after EH completes. This is necessary because SCSI
3313 * hot plugging requires working EH and hot unplugging is
3314 * synchronized with hot plugging with a mutex.
3315 *
3316 * LOCKING:
3317 * Kernel thread context (may sleep).
3318 */
David Howells65f27f32006-11-22 14:55:48 +00003319void ata_scsi_hotplug(struct work_struct *work)
Tejun Heo580b21022006-05-31 18:28:05 +09003320{
David Howells65f27f32006-11-22 14:55:48 +00003321 struct ata_port *ap =
3322 container_of(work, struct ata_port, hotplug_task.work);
Tejun Heo41bda9c2007-08-06 18:36:24 +09003323 int i;
Tejun Heo580b21022006-05-31 18:28:05 +09003324
Tejun Heob51e9e52006-06-29 01:29:30 +09003325 if (ap->pflags & ATA_PFLAG_UNLOADING) {
Tejun Heo580b21022006-05-31 18:28:05 +09003326 DPRINTK("ENTER/EXIT - unloading\n");
3327 return;
3328 }
3329
3330 DPRINTK("ENTER\n");
3331
Tejun Heo41bda9c2007-08-06 18:36:24 +09003332 /* Unplug detached devices. We cannot use link iterator here
3333 * because PMP links have to be scanned even if PMP is
3334 * currently not attached. Iterate manually.
3335 */
3336 ata_scsi_handle_link_detach(&ap->link);
3337 if (ap->pmp_link)
3338 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
3339 ata_scsi_handle_link_detach(&ap->pmp_link[i]);
Tejun Heo580b21022006-05-31 18:28:05 +09003340
3341 /* scan for new ones */
Tejun Heo1ae46312007-07-16 14:29:40 +09003342 ata_scsi_scan_host(ap, 0);
Tejun Heo580b21022006-05-31 18:28:05 +09003343
3344 DPRINTK("EXIT\n");
3345}
Tejun Heo83c47bc2006-05-31 18:28:07 +09003346
3347/**
3348 * ata_scsi_user_scan - indication for user-initiated bus scan
3349 * @shost: SCSI host to scan
3350 * @channel: Channel to scan
3351 * @id: ID to scan
3352 * @lun: LUN to scan
3353 *
3354 * This function is called when user explicitly requests bus
3355 * scan. Set probe pending flag and invoke EH.
3356 *
3357 * LOCKING:
3358 * SCSI layer (we don't care)
3359 *
3360 * RETURNS:
3361 * Zero.
3362 */
3363static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
3364 unsigned int id, unsigned int lun)
3365{
3366 struct ata_port *ap = ata_shost_to_port(shost);
3367 unsigned long flags;
Tejun Heo41bda9c2007-08-06 18:36:24 +09003368 int devno, rc = 0;
Tejun Heo83c47bc2006-05-31 18:28:07 +09003369
3370 if (!ap->ops->error_handler)
3371 return -EOPNOTSUPP;
3372
Tejun Heo41bda9c2007-08-06 18:36:24 +09003373 if (lun != SCAN_WILD_CARD && lun)
Tejun Heo83c47bc2006-05-31 18:28:07 +09003374 return -EINVAL;
3375
Tejun Heo41bda9c2007-08-06 18:36:24 +09003376 if (ap->nr_pmp_links == 0) {
3377 if (channel != SCAN_WILD_CARD && channel)
3378 return -EINVAL;
3379 devno = id;
3380 } else {
3381 if (id != SCAN_WILD_CARD && id)
3382 return -EINVAL;
3383 devno = channel;
3384 }
3385
Jeff Garzikba6a1302006-06-22 23:46:10 -04003386 spin_lock_irqsave(ap->lock, flags);
Tejun Heo83c47bc2006-05-31 18:28:07 +09003387
Tejun Heo41bda9c2007-08-06 18:36:24 +09003388 if (devno == SCAN_WILD_CARD) {
3389 struct ata_link *link;
3390
3391 ata_port_for_each_link(link, ap) {
3392 struct ata_eh_info *ehi = &link->eh_info;
3393 ehi->probe_mask |= (1 << ata_link_max_devices(link)) - 1;
3394 ehi->action |= ATA_EH_SOFTRESET;
3395 }
Tejun Heo83c47bc2006-05-31 18:28:07 +09003396 } else {
Tejun Heo41bda9c2007-08-06 18:36:24 +09003397 struct ata_device *dev = ata_find_dev(ap, devno);
Tejun Heo83c47bc2006-05-31 18:28:07 +09003398
3399 if (dev) {
Tejun Heo41bda9c2007-08-06 18:36:24 +09003400 struct ata_eh_info *ehi = &dev->link->eh_info;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003401 ehi->probe_mask |= 1 << dev->devno;
3402 ehi->action |= ATA_EH_SOFTRESET;
3403 ehi->flags |= ATA_EHI_RESUME_LINK;
Tejun Heo83c47bc2006-05-31 18:28:07 +09003404 } else
3405 rc = -EINVAL;
3406 }
3407
Tejun Heo309afcb2006-09-30 18:07:17 +09003408 if (rc == 0) {
Tejun Heo83c47bc2006-05-31 18:28:07 +09003409 ata_port_schedule_eh(ap);
Tejun Heo309afcb2006-09-30 18:07:17 +09003410 spin_unlock_irqrestore(ap->lock, flags);
3411 ata_port_wait_eh(ap);
3412 } else
3413 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo83c47bc2006-05-31 18:28:07 +09003414
3415 return rc;
3416}
zhao, forrest3057ac32006-06-12 12:01:34 +08003417
3418/**
Tejun Heod0171262006-06-12 22:51:14 +09003419 * ata_scsi_dev_rescan - initiate scsi_rescan_device()
David Howells65f27f32006-11-22 14:55:48 +00003420 * @work: Pointer to ATA port to perform scsi_rescan_device()
zhao, forrest3057ac32006-06-12 12:01:34 +08003421 *
Tejun Heod0171262006-06-12 22:51:14 +09003422 * After ATA pass thru (SAT) commands are executed successfully,
3423 * libata need to propagate the changes to SCSI layer. This
3424 * function must be executed from ata_aux_wq such that sdev
3425 * attach/detach don't race with rescan.
zhao, forrest3057ac32006-06-12 12:01:34 +08003426 *
Tejun Heod0171262006-06-12 22:51:14 +09003427 * LOCKING:
3428 * Kernel thread context (may sleep).
zhao, forrest3057ac32006-06-12 12:01:34 +08003429 */
David Howells65f27f32006-11-22 14:55:48 +00003430void ata_scsi_dev_rescan(struct work_struct *work)
zhao, forrest3057ac32006-06-12 12:01:34 +08003431{
David Howells65f27f32006-11-22 14:55:48 +00003432 struct ata_port *ap =
3433 container_of(work, struct ata_port, scsi_rescan_task);
Tejun Heo41bda9c2007-08-06 18:36:24 +09003434 struct ata_link *link;
Tejun Heof58229f2007-08-06 18:36:23 +09003435 struct ata_device *dev;
Tejun Heof84e7e42006-11-22 11:21:31 +09003436 unsigned long flags;
zhao, forrest3057ac32006-06-12 12:01:34 +08003437
Tejun Heof84e7e42006-11-22 11:21:31 +09003438 spin_lock_irqsave(ap->lock, flags);
zhao, forrest3057ac32006-06-12 12:01:34 +08003439
Tejun Heo41bda9c2007-08-06 18:36:24 +09003440 ata_port_for_each_link(link, ap) {
3441 ata_link_for_each_dev(dev, link) {
3442 struct scsi_device *sdev = dev->sdev;
Tejun Heof84e7e42006-11-22 11:21:31 +09003443
Tejun Heo41bda9c2007-08-06 18:36:24 +09003444 if (!ata_dev_enabled(dev) || !sdev)
3445 continue;
3446 if (scsi_device_get(sdev))
3447 continue;
Tejun Heof84e7e42006-11-22 11:21:31 +09003448
Tejun Heo41bda9c2007-08-06 18:36:24 +09003449 spin_unlock_irqrestore(ap->lock, flags);
3450 scsi_rescan_device(&(sdev->sdev_gendev));
3451 scsi_device_put(sdev);
3452 spin_lock_irqsave(ap->lock, flags);
3453 }
zhao, forrest3057ac32006-06-12 12:01:34 +08003454 }
Tejun Heof84e7e42006-11-22 11:21:31 +09003455
3456 spin_unlock_irqrestore(ap->lock, flags);
zhao, forrest3057ac32006-06-12 12:01:34 +08003457}
Brian King80289162006-08-07 14:27:31 -05003458
3459/**
3460 * ata_sas_port_alloc - Allocate port for a SAS attached SATA device
Jeff Garzik4f931372006-09-29 05:07:25 -04003461 * @host: ATA host container for all SAS ports
Brian King80289162006-08-07 14:27:31 -05003462 * @port_info: Information from low-level host driver
Jeff Garzikcca39742006-08-24 03:19:22 -04003463 * @shost: SCSI host that the scsi device is attached to
Brian King80289162006-08-07 14:27:31 -05003464 *
3465 * LOCKING:
3466 * PCI/etc. bus probe sem.
3467 *
3468 * RETURNS:
3469 * ata_port pointer on success / NULL on failure.
3470 */
3471
Jeff Garzikcca39742006-08-24 03:19:22 -04003472struct ata_port *ata_sas_port_alloc(struct ata_host *host,
Brian King80289162006-08-07 14:27:31 -05003473 struct ata_port_info *port_info,
Jeff Garzikcca39742006-08-24 03:19:22 -04003474 struct Scsi_Host *shost)
Brian King80289162006-08-07 14:27:31 -05003475{
Tejun Heof3187192007-04-17 23:44:07 +09003476 struct ata_port *ap;
Brian King80289162006-08-07 14:27:31 -05003477
Tejun Heof3187192007-04-17 23:44:07 +09003478 ap = ata_port_alloc(host);
Brian King80289162006-08-07 14:27:31 -05003479 if (!ap)
3480 return NULL;
3481
Tejun Heof3187192007-04-17 23:44:07 +09003482 ap->port_no = 0;
Jeff Garzikcca39742006-08-24 03:19:22 -04003483 ap->lock = shost->host_lock;
Tejun Heof3187192007-04-17 23:44:07 +09003484 ap->pio_mask = port_info->pio_mask;
3485 ap->mwdma_mask = port_info->mwdma_mask;
3486 ap->udma_mask = port_info->udma_mask;
3487 ap->flags |= port_info->flags;
3488 ap->ops = port_info->port_ops;
3489 ap->cbl = ATA_CBL_SATA;
3490
Brian King80289162006-08-07 14:27:31 -05003491 return ap;
3492}
3493EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
3494
3495/**
3496 * ata_sas_port_start - Set port up for dma.
3497 * @ap: Port to initialize
3498 *
3499 * Called just after data structures for each port are
3500 * initialized. Allocates DMA pad.
3501 *
3502 * May be used as the port_start() entry in ata_port_operations.
3503 *
3504 * LOCKING:
3505 * Inherited from caller.
3506 */
3507int ata_sas_port_start(struct ata_port *ap)
3508{
3509 return ata_pad_alloc(ap, ap->dev);
3510}
3511EXPORT_SYMBOL_GPL(ata_sas_port_start);
3512
3513/**
3514 * ata_port_stop - Undo ata_sas_port_start()
3515 * @ap: Port to shut down
3516 *
3517 * Frees the DMA pad.
3518 *
3519 * May be used as the port_stop() entry in ata_port_operations.
3520 *
3521 * LOCKING:
3522 * Inherited from caller.
3523 */
3524
3525void ata_sas_port_stop(struct ata_port *ap)
3526{
3527 ata_pad_free(ap, ap->dev);
3528}
3529EXPORT_SYMBOL_GPL(ata_sas_port_stop);
3530
3531/**
3532 * ata_sas_port_init - Initialize a SATA device
3533 * @ap: SATA port to initialize
3534 *
3535 * LOCKING:
3536 * PCI/etc. bus probe sem.
3537 *
3538 * RETURNS:
3539 * Zero on success, non-zero on error.
3540 */
3541
3542int ata_sas_port_init(struct ata_port *ap)
3543{
3544 int rc = ap->ops->port_start(ap);
3545
Tejun Heof3187192007-04-17 23:44:07 +09003546 if (!rc) {
3547 ap->print_id = ata_print_id++;
Brian King80289162006-08-07 14:27:31 -05003548 rc = ata_bus_probe(ap);
Tejun Heof3187192007-04-17 23:44:07 +09003549 }
Brian King80289162006-08-07 14:27:31 -05003550
3551 return rc;
3552}
3553EXPORT_SYMBOL_GPL(ata_sas_port_init);
3554
3555/**
3556 * ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
3557 * @ap: SATA port to destroy
3558 *
3559 */
3560
3561void ata_sas_port_destroy(struct ata_port *ap)
3562{
Tejun Heof0d36ef2007-01-20 16:00:28 +09003563 if (ap->ops->port_stop)
3564 ap->ops->port_stop(ap);
Brian King80289162006-08-07 14:27:31 -05003565 kfree(ap);
3566}
3567EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
3568
3569/**
3570 * ata_sas_slave_configure - Default slave_config routine for libata devices
3571 * @sdev: SCSI device to configure
3572 * @ap: ATA port to which SCSI device is attached
3573 *
3574 * RETURNS:
3575 * Zero.
3576 */
3577
3578int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
3579{
3580 ata_scsi_sdev_config(sdev);
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003581 ata_scsi_dev_config(sdev, ap->link.device);
Brian King80289162006-08-07 14:27:31 -05003582 return 0;
3583}
3584EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
3585
3586/**
3587 * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
3588 * @cmd: SCSI command to be sent
3589 * @done: Completion function, called when command is complete
3590 * @ap: ATA port to which the command is being sent
3591 *
3592 * RETURNS:
Brian King08475a12006-11-20 13:51:56 -06003593 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
3594 * 0 otherwise.
Brian King80289162006-08-07 14:27:31 -05003595 */
3596
3597int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
3598 struct ata_port *ap)
3599{
Brian King08475a12006-11-20 13:51:56 -06003600 int rc = 0;
3601
Brian King80289162006-08-07 14:27:31 -05003602 ata_scsi_dump_cdb(ap, cmd);
3603
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003604 if (likely(ata_scsi_dev_enabled(ap->link.device)))
3605 rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
Brian King80289162006-08-07 14:27:31 -05003606 else {
3607 cmd->result = (DID_BAD_TARGET << 16);
3608 done(cmd);
3609 }
Brian King08475a12006-11-20 13:51:56 -06003610 return rc;
Brian King80289162006-08-07 14:27:31 -05003611}
3612EXPORT_SYMBOL_GPL(ata_sas_queuecmd);