← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/ipxe/src/drivers/block/scsi.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/ipxe/src/drivers/block/scsi.c
 
1
/*
 
2
 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License as
 
6
 * published by the Free Software Foundation; either version 2 of the
 
7
 * License, or any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful, but
 
10
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
17
 * 02110-1301, USA.
 
18
 *
 
19
 * You can also choose to distribute this program under the terms of
 
20
 * the Unmodified Binary Distribution Licence (as given in the file
 
21
 * COPYING.UBDL), provided that you have satisfied its requirements.
 
22
 */
 
23
 
 
24
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
25
 
 
26
#include <stddef.h>
 
27
#include <stdlib.h>
 
28
#include <string.h>
 
29
#include <byteswap.h>
 
30
#include <errno.h>
 
31
#include <ipxe/list.h>
 
32
#include <ipxe/process.h>
 
33
#include <ipxe/xfer.h>
 
34
#include <ipxe/blockdev.h>
 
35
#include <ipxe/scsi.h>
 
36
 
 
37
/** @file
 
38
 *
 
39
 * SCSI block device
 
40
 *
 
41
 */
 
42
 
 
43
/** Maximum number of command retries */
 
44
#define SCSICMD_MAX_RETRIES 10
 
45
 
 
46
/* Error numbers generated by SCSI sense data */
 
47
#define EIO_NO_SENSE __einfo_error ( EINFO_EIO_NO_SENSE )
 
48
#define EINFO_EIO_NO_SENSE \
 
49
        __einfo_uniqify ( EINFO_EIO, 0x00, "No sense" )
 
50
#define EIO_RECOVERED_ERROR __einfo_error ( EINFO_EIO_RECOVERED_ERROR )
 
51
#define EINFO_EIO_RECOVERED_ERROR \
 
52
        __einfo_uniqify ( EINFO_EIO, 0x01, "Recovered error" )
 
53
#define EIO_NOT_READY __einfo_error ( EINFO_EIO_NOT_READY )
 
54
#define EINFO_EIO_NOT_READY \
 
55
        __einfo_uniqify ( EINFO_EIO, 0x02, "Not ready" )
 
56
#define EIO_MEDIUM_ERROR __einfo_error ( EINFO_EIO_MEDIUM_ERROR )
 
57
#define EINFO_EIO_MEDIUM_ERROR \
 
58
        __einfo_uniqify ( EINFO_EIO, 0x03, "Medium error" )
 
59
#define EIO_HARDWARE_ERROR __einfo_error ( EINFO_EIO_HARDWARE_ERROR )
 
60
#define EINFO_EIO_HARDWARE_ERROR \
 
61
        __einfo_uniqify ( EINFO_EIO, 0x04, "Hardware error" )
 
62
#define EIO_ILLEGAL_REQUEST __einfo_error ( EINFO_EIO_ILLEGAL_REQUEST )
 
63
#define EINFO_EIO_ILLEGAL_REQUEST \
 
64
        __einfo_uniqify ( EINFO_EIO, 0x05, "Illegal request" )
 
65
#define EIO_UNIT_ATTENTION __einfo_error ( EINFO_EIO_UNIT_ATTENTION )
 
66
#define EINFO_EIO_UNIT_ATTENTION \
 
67
        __einfo_uniqify ( EINFO_EIO, 0x06, "Unit attention" )
 
68
#define EIO_DATA_PROTECT __einfo_error ( EINFO_EIO_DATA_PROTECT )
 
69
#define EINFO_EIO_DATA_PROTECT \
 
70
        __einfo_uniqify ( EINFO_EIO, 0x07, "Data protect" )
 
71
#define EIO_BLANK_CHECK __einfo_error ( EINFO_EIO_BLANK_CHECK )
 
72
#define EINFO_EIO_BLANK_CHECK \
 
73
        __einfo_uniqify ( EINFO_EIO, 0x08, "Blank check" )
 
74
#define EIO_VENDOR_SPECIFIC __einfo_error ( EINFO_EIO_VENDOR_SPECIFIC )
 
75
#define EINFO_EIO_VENDOR_SPECIFIC \
 
76
        __einfo_uniqify ( EINFO_EIO, 0x09, "Vendor specific" )
 
77
#define EIO_COPY_ABORTED __einfo_error ( EINFO_EIO_COPY_ABORTED )
 
78
#define EINFO_EIO_COPY_ABORTED \
 
79
        __einfo_uniqify ( EINFO_EIO, 0x0a, "Copy aborted" )
 
80
#define EIO_ABORTED_COMMAND __einfo_error ( EINFO_EIO_ABORTED_COMMAND )
 
81
#define EINFO_EIO_ABORTED_COMMAND \
 
82
        __einfo_uniqify ( EINFO_EIO, 0x0b, "Aborted command" )
 
83
#define EIO_RESERVED __einfo_error ( EINFO_EIO_RESERVED )
 
84
#define EINFO_EIO_RESERVED \
 
85
        __einfo_uniqify ( EINFO_EIO, 0x0c, "Reserved" )
 
86
#define EIO_VOLUME_OVERFLOW __einfo_error ( EINFO_EIO_VOLUME_OVERFLOW )
 
87
#define EINFO_EIO_VOLUME_OVERFLOW \
 
88
        __einfo_uniqify ( EINFO_EIO, 0x0d, "Volume overflow" )
 
89
#define EIO_MISCOMPARE __einfo_error ( EINFO_EIO_MISCOMPARE )
 
90
#define EINFO_EIO_MISCOMPARE \
 
91
        __einfo_uniqify ( EINFO_EIO, 0x0e, "Miscompare" )
 
92
#define EIO_COMPLETED __einfo_error ( EINFO_EIO_COMPLETED )
 
93
#define EINFO_EIO_COMPLETED \
 
94
        __einfo_uniqify ( EINFO_EIO, 0x0f, "Completed" )
 
95
#define EIO_SENSE( key )                                                \
 
96
        EUNIQ ( EINFO_EIO, (key), EIO_NO_SENSE, EIO_RECOVERED_ERROR,    \
 
97
                EIO_NOT_READY, EIO_MEDIUM_ERROR, EIO_HARDWARE_ERROR,    \
 
98
                EIO_ILLEGAL_REQUEST, EIO_UNIT_ATTENTION,                \
 
99
                EIO_DATA_PROTECT, EIO_BLANK_CHECK, EIO_VENDOR_SPECIFIC, \
 
100
                EIO_COPY_ABORTED, EIO_ABORTED_COMMAND, EIO_RESERVED,    \
 
101
                EIO_VOLUME_OVERFLOW, EIO_MISCOMPARE, EIO_COMPLETED )
 
102
 
 
103
/******************************************************************************
 
104
 *
 
105
 * Utility functions
 
106
 *
 
107
 ******************************************************************************
 
108
 */
 
109
 
 
110
/**
 
111
 * Parse SCSI LUN
 
112
 *
 
113
 * @v lun_string        LUN string representation
 
114
 * @v lun               LUN to fill in
 
115
 * @ret rc              Return status code
 
116
 */
 
117
int scsi_parse_lun ( const char *lun_string, struct scsi_lun *lun ) {
 
118
        char *p;
 
119
        int i;
 
120
 
 
121
        memset ( lun, 0, sizeof ( *lun ) );
 
122
        if ( lun_string ) {
 
123
                p = ( char * ) lun_string;
 
124
                for ( i = 0 ; i < 4 ; i++ ) {
 
125
                        lun->u16[i] = htons ( strtoul ( p, &p, 16 ) );
 
126
                        if ( *p == '\0' )
 
127
                                break;
 
128
                        if ( *p != '-' )
 
129
                                return -EINVAL;
 
130
                        p++;
 
131
                }
 
132
                if ( *p )
 
133
                        return -EINVAL;
 
134
        }
 
135
 
 
136
        return 0;
 
137
}
 
138
 
 
139
/**
 
140
 * Parse SCSI sense data
 
141
 *
 
142
 * @v data              Raw sense data
 
143
 * @v len               Length of raw sense data
 
144
 * @v sense             Descriptor-format sense data to fill in
 
145
 */
 
146
void scsi_parse_sense ( const void *data, size_t len,
 
147
                        struct scsi_sns_descriptor *sense ) {
 
148
        const union scsi_sns *sns = data;
 
149
 
 
150
        /* Avoid returning uninitialised data */
 
151
        memset ( sense, 0, sizeof ( *sense ) );
 
152
 
 
153
        /* Copy, assuming descriptor-format data */
 
154
        if ( len < sizeof ( sns->desc ) )
 
155
                return;
 
156
        memcpy ( sense, &sns->desc, sizeof ( *sense ) );
 
157
 
 
158
        /* Convert fixed-format to descriptor-format, if applicable */
 
159
        if ( len < sizeof ( sns->fixed ) )
 
160
                return;
 
161
        if ( ! SCSI_SENSE_FIXED ( sns->code ) )
 
162
                return;
 
163
        sense->additional = sns->fixed.additional;
 
164
}
 
165
 
 
166
/******************************************************************************
 
167
 *
 
168
 * Interface methods
 
169
 *
 
170
 ******************************************************************************
 
171
 */
 
172
 
 
173
/**
 
174
 * Issue SCSI command
 
175
 *
 
176
 * @v control           SCSI control interface
 
177
 * @v data              SCSI data interface
 
178
 * @v command           SCSI command
 
179
 * @ret tag             Command tag, or negative error
 
180
 */
 
181
int scsi_command ( struct interface *control, struct interface *data,
 
182
                   struct scsi_cmd *command ) {
 
183
        struct interface *dest;
 
184
        scsi_command_TYPE ( void * ) *op =
 
185
                intf_get_dest_op ( control, scsi_command, &dest );
 
186
        void *object = intf_object ( dest );
 
187
        int tap;
 
188
 
 
189
        if ( op ) {
 
190
                tap = op ( object, data, command );
 
191
        } else {
 
192
                /* Default is to fail to issue the command */
 
193
                tap = -EOPNOTSUPP;
 
194
        }
 
195
 
 
196
        intf_put ( dest );
 
197
        return tap;
 
198
}
 
199
 
 
200
/**
 
201
 * Report SCSI response
 
202
 *
 
203
 * @v interface         SCSI command interface
 
204
 * @v response          SCSI response
 
205
 */
 
206
void scsi_response ( struct interface *intf, struct scsi_rsp *response ) {
 
207
        struct interface *dest;
 
208
        scsi_response_TYPE ( void * ) *op =
 
209
                intf_get_dest_op ( intf, scsi_response, &dest );
 
210
        void *object = intf_object ( dest );
 
211
 
 
212
        if ( op ) {
 
213
                op ( object, response );
 
214
        } else {
 
215
                /* Default is to ignore the response */
 
216
        }
 
217
 
 
218
        intf_put ( dest );
 
219
}
 
220
 
 
221
/******************************************************************************
 
222
 *
 
223
 * SCSI devices and commands
 
224
 *
 
225
 ******************************************************************************
 
226
 */
 
227
 
 
228
/** A SCSI device */
 
229
struct scsi_device {
 
230
        /** Reference count */
 
231
        struct refcnt refcnt;
 
232
        /** Block control interface */
 
233
        struct interface block;
 
234
        /** SCSI control interface */
 
235
        struct interface scsi;
 
236
 
 
237
        /** SCSI LUN */
 
238
        struct scsi_lun lun;
 
239
        /** Flags */
 
240
        unsigned int flags;
 
241
 
 
242
        /** TEST UNIT READY interface */
 
243
        struct interface ready;
 
244
        /** TEST UNIT READY process */
 
245
        struct process process;
 
246
 
 
247
        /** List of commands */
 
248
        struct list_head cmds;
 
249
};
 
250
 
 
251
/** SCSI device flags */
 
252
enum scsi_device_flags {
 
253
        /** TEST UNIT READY has been issued */
 
254
        SCSIDEV_UNIT_TESTED = 0x0001,
 
255
        /** TEST UNIT READY has completed successfully */
 
256
        SCSIDEV_UNIT_READY = 0x0002,
 
257
};
 
258
 
 
259
/** A SCSI command */
 
260
struct scsi_command {
 
261
        /** Reference count */
 
262
        struct refcnt refcnt;
 
263
        /** SCSI device */
 
264
        struct scsi_device *scsidev;
 
265
        /** List of SCSI commands */
 
266
        struct list_head list;
 
267
 
 
268
        /** Block data interface */
 
269
        struct interface block;
 
270
        /** SCSI data interface */
 
271
        struct interface scsi;
 
272
 
 
273
        /** Command type */
 
274
        struct scsi_command_type *type;
 
275
        /** Starting logical block address */
 
276
        uint64_t lba;
 
277
        /** Number of blocks */
 
278
        unsigned int count;
 
279
        /** Data buffer */
 
280
        userptr_t buffer;
 
281
        /** Length of data buffer */
 
282
        size_t len;
 
283
        /** Command tag */
 
284
        uint32_t tag;
 
285
 
 
286
        /** Retry count */
 
287
        unsigned int retries;
 
288
 
 
289
        /** Private data */
 
290
        uint8_t priv[0];
 
291
};
 
292
 
 
293
/** A SCSI command type */
 
294
struct scsi_command_type {
 
295
        /** Name */
 
296
        const char *name;
 
297
        /** Additional working space */
 
298
        size_t priv_len;
 
299
        /**
 
300
         * Construct SCSI command IU
 
301
         *
 
302
         * @v scsicmd           SCSI command
 
303
         * @v command           SCSI command IU
 
304
         */
 
305
        void ( * cmd ) ( struct scsi_command *scsicmd,
 
306
                         struct scsi_cmd *command );
 
307
        /**
 
308
         * Handle SCSI command completion
 
309
         *
 
310
         * @v scsicmd           SCSI command
 
311
         * @v rc                Reason for completion
 
312
         */
 
313
        void ( * done ) ( struct scsi_command *scsicmd, int rc );
 
314
};
 
315
 
 
316
/**
 
317
 * Get reference to SCSI device
 
318
 *
 
319
 * @v scsidev           SCSI device
 
320
 * @ret scsidev         SCSI device
 
321
 */
 
322
static inline __attribute__ (( always_inline )) struct scsi_device *
 
323
scsidev_get ( struct scsi_device *scsidev ) {
 
324
        ref_get ( &scsidev->refcnt );
 
325
        return scsidev;
 
326
}
 
327
 
 
328
/**
 
329
 * Drop reference to SCSI device
 
330
 *
 
331
 * @v scsidev           SCSI device
 
332
 */
 
333
static inline __attribute__ (( always_inline )) void
 
334
scsidev_put ( struct scsi_device *scsidev ) {
 
335
        ref_put ( &scsidev->refcnt );
 
336
}
 
337
 
 
338
/**
 
339
 * Get reference to SCSI command
 
340
 *
 
341
 * @v scsicmd           SCSI command
 
342
 * @ret scsicmd         SCSI command
 
343
 */
 
344
static inline __attribute__ (( always_inline )) struct scsi_command *
 
345
scsicmd_get ( struct scsi_command *scsicmd ) {
 
346
        ref_get ( &scsicmd->refcnt );
 
347
        return scsicmd;
 
348
}
 
349
 
 
350
/**
 
351
 * Drop reference to SCSI command
 
352
 *
 
353
 * @v scsicmd           SCSI command
 
354
 */
 
355
static inline __attribute__ (( always_inline )) void
 
356
scsicmd_put ( struct scsi_command *scsicmd ) {
 
357
        ref_put ( &scsicmd->refcnt );
 
358
}
 
359
 
 
360
/**
 
361
 * Get SCSI command private data
 
362
 *
 
363
 * @v scsicmd           SCSI command
 
364
 * @ret priv            Private data
 
365
 */
 
366
static inline __attribute__ (( always_inline )) void *
 
367
scsicmd_priv ( struct scsi_command *scsicmd ) {
 
368
        return scsicmd->priv;
 
369
}
 
370
 
 
371
/**
 
372
 * Free SCSI command
 
373
 *
 
374
 * @v refcnt            Reference count
 
375
 */
 
376
static void scsicmd_free ( struct refcnt *refcnt ) {
 
377
        struct scsi_command *scsicmd =
 
378
                container_of ( refcnt, struct scsi_command, refcnt );
 
379
 
 
380
        /* Remove from list of commands */
 
381
        list_del ( &scsicmd->list );
 
382
        scsidev_put ( scsicmd->scsidev );
 
383
 
 
384
        /* Free command */
 
385
        free ( scsicmd );
 
386
}
 
387
 
 
388
/**
 
389
 * Close SCSI command
 
390
 *
 
391
 * @v scsicmd           SCSI command
 
392
 * @v rc                Reason for close
 
393
 */
 
394
static void scsicmd_close ( struct scsi_command *scsicmd, int rc ) {
 
395
        struct scsi_device *scsidev = scsicmd->scsidev;
 
396
 
 
397
        if ( rc != 0 ) {
 
398
                DBGC ( scsidev, "SCSI %p tag %08x closed: %s\n",
 
399
                       scsidev, scsicmd->tag, strerror ( rc ) );
 
400
        }
 
401
 
 
402
        /* Shut down interfaces */
 
403
        intf_shutdown ( &scsicmd->scsi, rc );
 
404
        intf_shutdown ( &scsicmd->block, rc );
 
405
}
 
406
 
 
407
/**
 
408
 * Construct and issue SCSI command
 
409
 *
 
410
 * @ret rc              Return status code
 
411
 */
 
412
static int scsicmd_command ( struct scsi_command *scsicmd ) {
 
413
        struct scsi_device *scsidev = scsicmd->scsidev;
 
414
        struct scsi_cmd command;
 
415
        int tag;
 
416
        int rc;
 
417
 
 
418
        /* Construct command */
 
419
        memset ( &command, 0, sizeof ( command ) );
 
420
        memcpy ( &command.lun, &scsidev->lun, sizeof ( command.lun ) );
 
421
        scsicmd->type->cmd ( scsicmd, &command );
 
422
 
 
423
        /* Issue command */
 
424
        if ( ( tag = scsi_command ( &scsidev->scsi, &scsicmd->scsi,
 
425
                                    &command ) ) < 0 ) {
 
426
                rc = tag;
 
427
                DBGC ( scsidev, "SCSI %p could not issue command: %s\n",
 
428
                       scsidev, strerror ( rc ) );
 
429
                return rc;
 
430
        }
 
431
 
 
432
        /* Record tag */
 
433
        if ( scsicmd->tag ) {
 
434
                DBGC ( scsidev, "SCSI %p tag %08x is now tag %08x\n",
 
435
                       scsidev, scsicmd->tag, tag );
 
436
        }
 
437
        scsicmd->tag = tag;
 
438
        DBGC2 ( scsidev, "SCSI %p tag %08x %s " SCSI_CDB_FORMAT "\n",
 
439
                scsidev, scsicmd->tag, scsicmd->type->name,
 
440
                SCSI_CDB_DATA ( command.cdb ) );
 
441
 
 
442
        return 0;
 
443
}
 
444
 
 
445
/**
 
446
 * Handle SCSI command completion
 
447
 *
 
448
 * @v scsicmd           SCSI command
 
449
 * @v rc                Reason for close
 
450
 */
 
451
static void scsicmd_done ( struct scsi_command *scsicmd, int rc ) {
 
452
        struct scsi_device *scsidev = scsicmd->scsidev;
 
453
 
 
454
        /* Restart SCSI interface */
 
455
        intf_restart ( &scsicmd->scsi, rc );
 
456
 
 
457
        /* SCSI targets have an annoying habit of returning occasional
 
458
         * pointless "error" messages such as "power-on occurred", so
 
459
         * we have to be prepared to retry commands.
 
460
         */
 
461
        if ( ( rc != 0 ) && ( scsicmd->retries++ < SCSICMD_MAX_RETRIES ) ) {
 
462
                /* Retry command */
 
463
                DBGC ( scsidev, "SCSI %p tag %08x failed: %s\n",
 
464
                       scsidev, scsicmd->tag, strerror ( rc ) );
 
465
                DBGC ( scsidev, "SCSI %p tag %08x retrying (retry %d)\n",
 
466
                       scsidev, scsicmd->tag, scsicmd->retries );
 
467
                if ( ( rc = scsicmd_command ( scsicmd ) ) == 0 )
 
468
                        return;
 
469
        }
 
470
 
 
471
        /* If we didn't (successfully) reissue the command, hand over
 
472
         * to the command completion handler.
 
473
         */
 
474
        scsicmd->type->done ( scsicmd, rc );
 
475
}
 
476
 
 
477
/**
 
478
 * Handle SCSI response
 
479
 *
 
480
 * @v scsicmd           SCSI command
 
481
 * @v response          SCSI response
 
482
 */
 
483
static void scsicmd_response ( struct scsi_command *scsicmd,
 
484
                               struct scsi_rsp *response ) {
 
485
        struct scsi_device *scsidev = scsicmd->scsidev;
 
486
        size_t overrun;
 
487
        size_t underrun;
 
488
        int rc;
 
489
 
 
490
        if ( response->status == 0 ) {
 
491
                scsicmd_done ( scsicmd, 0 );
 
492
        } else {
 
493
                DBGC ( scsidev, "SCSI %p tag %08x status %02x",
 
494
                       scsidev, scsicmd->tag, response->status );
 
495
                if ( response->overrun > 0 ) {
 
496
                        overrun = response->overrun;
 
497
                        DBGC ( scsidev, " overrun +%zd", overrun );
 
498
                } else if ( response->overrun < 0 ) {
 
499
                        underrun = -(response->overrun);
 
500
                        DBGC ( scsidev, " underrun -%zd", underrun );
 
501
                }
 
502
                DBGC ( scsidev, " sense %02x key %02x additional %04x\n",
 
503
                       ( response->sense.code & SCSI_SENSE_CODE_MASK ),
 
504
                       ( response->sense.key & SCSI_SENSE_KEY_MASK ),
 
505
                       ntohs ( response->sense.additional ) );
 
506
 
 
507
                /* Construct error number from sense data */
 
508
                rc = -EIO_SENSE ( response->sense.key & SCSI_SENSE_KEY_MASK );
 
509
                scsicmd_done ( scsicmd, rc );
 
510
        }
 
511
}
 
512
 
 
513
/**
 
514
 * Construct SCSI READ command
 
515
 *
 
516
 * @v scsicmd           SCSI command
 
517
 * @v command           SCSI command IU
 
518
 */
 
519
static void scsicmd_read_cmd ( struct scsi_command *scsicmd,
 
520
                               struct scsi_cmd *command ) {
 
521
 
 
522
        if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
 
523
                /* Use READ (16) */
 
524
                command->cdb.read16.opcode = SCSI_OPCODE_READ_16;
 
525
                command->cdb.read16.lba = cpu_to_be64 ( scsicmd->lba );
 
526
                command->cdb.read16.len = cpu_to_be32 ( scsicmd->count );
 
527
        } else {
 
528
                /* Use READ (10) */
 
529
                command->cdb.read10.opcode = SCSI_OPCODE_READ_10;
 
530
                command->cdb.read10.lba = cpu_to_be32 ( scsicmd->lba );
 
531
                command->cdb.read10.len = cpu_to_be16 ( scsicmd->count );
 
532
        }
 
533
        command->data_in = scsicmd->buffer;
 
534
        command->data_in_len = scsicmd->len;
 
535
}
 
536
 
 
537
/** SCSI READ command type */
 
538
static struct scsi_command_type scsicmd_read = {
 
539
        .name = "READ",
 
540
        .cmd = scsicmd_read_cmd,
 
541
        .done = scsicmd_close,
 
542
};
 
543
 
 
544
/**
 
545
 * Construct SCSI WRITE command
 
546
 *
 
547
 * @v scsicmd           SCSI command
 
548
 * @v command           SCSI command IU
 
549
 */
 
550
static void scsicmd_write_cmd ( struct scsi_command *scsicmd,
 
551
                                struct scsi_cmd *command ) {
 
552
 
 
553
        if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
 
554
                /* Use WRITE (16) */
 
555
                command->cdb.write16.opcode = SCSI_OPCODE_WRITE_16;
 
556
                command->cdb.write16.lba = cpu_to_be64 ( scsicmd->lba );
 
557
                command->cdb.write16.len = cpu_to_be32 ( scsicmd->count );
 
558
        } else {
 
559
                /* Use WRITE (10) */
 
560
                command->cdb.write10.opcode = SCSI_OPCODE_WRITE_10;
 
561
                command->cdb.write10.lba = cpu_to_be32 ( scsicmd->lba );
 
562
                command->cdb.write10.len = cpu_to_be16 ( scsicmd->count );
 
563
        }
 
564
        command->data_out = scsicmd->buffer;
 
565
        command->data_out_len = scsicmd->len;
 
566
}
 
567
 
 
568
/** SCSI WRITE command type */
 
569
static struct scsi_command_type scsicmd_write = {
 
570
        .name = "WRITE",
 
571
        .cmd = scsicmd_write_cmd,
 
572
        .done = scsicmd_close,
 
573
};
 
574
 
 
575
/** SCSI READ CAPACITY private data */
 
576
struct scsi_read_capacity_private {
 
577
        /** Use READ CAPACITY (16) */
 
578
        int use16;
 
579
        /** Data buffer for READ CAPACITY commands */
 
580
        union {
 
581
                /** Data buffer for READ CAPACITY (10) */
 
582
                struct scsi_capacity_10 capacity10;
 
583
                /** Data buffer for READ CAPACITY (16) */
 
584
                struct scsi_capacity_16 capacity16;
 
585
        } capacity;
 
586
};
 
587
 
 
588
/**
 
589
 * Construct SCSI READ CAPACITY command
 
590
 *
 
591
 * @v scsicmd           SCSI command
 
592
 * @v command           SCSI command IU
 
593
 */
 
594
static void scsicmd_read_capacity_cmd ( struct scsi_command *scsicmd,
 
595
                                        struct scsi_cmd *command ) {
 
596
        struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
 
597
        struct scsi_cdb_read_capacity_16 *readcap16 = &command->cdb.readcap16;
 
598
        struct scsi_cdb_read_capacity_10 *readcap10 = &command->cdb.readcap10;
 
599
        struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
 
600
        struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
 
601
 
 
602
        if ( priv->use16 ) {
 
603
                /* Use READ CAPACITY (16) */
 
604
                readcap16->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
 
605
                readcap16->service_action =
 
606
                        SCSI_SERVICE_ACTION_READ_CAPACITY_16;
 
607
                readcap16->len = cpu_to_be32 ( sizeof ( *capacity16 ) );
 
608
                command->data_in = virt_to_user ( capacity16 );
 
609
                command->data_in_len = sizeof ( *capacity16 );
 
610
        } else {
 
611
                /* Use READ CAPACITY (10) */
 
612
                readcap10->opcode = SCSI_OPCODE_READ_CAPACITY_10;
 
613
                command->data_in = virt_to_user ( capacity10 );
 
614
                command->data_in_len = sizeof ( *capacity10 );
 
615
        }
 
616
}
 
617
 
 
618
/**
 
619
 * Handle SCSI READ CAPACITY command completion
 
620
 *
 
621
 * @v scsicmd           SCSI command
 
622
 * @v rc                Reason for completion
 
623
 */
 
624
static void scsicmd_read_capacity_done ( struct scsi_command *scsicmd,
 
625
                                         int rc ) {
 
626
        struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
 
627
        struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
 
628
        struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
 
629
        struct block_device_capacity capacity;
 
630
 
 
631
        /* Close if command failed */
 
632
        if ( rc != 0 ) {
 
633
                scsicmd_close ( scsicmd, rc );
 
634
                return;
 
635
        }
 
636
 
 
637
        /* Extract capacity */
 
638
        if ( priv->use16 ) {
 
639
                capacity.blocks = ( be64_to_cpu ( capacity16->lba ) + 1 );
 
640
                capacity.blksize = be32_to_cpu ( capacity16->blksize );
 
641
        } else {
 
642
                capacity.blocks = ( be32_to_cpu ( capacity10->lba ) + 1 );
 
643
                capacity.blksize = be32_to_cpu ( capacity10->blksize );
 
644
 
 
645
                /* If capacity range was exceeded (i.e. capacity.lba
 
646
                 * was 0xffffffff, meaning that blockdev->blocks is
 
647
                 * now zero), use READ CAPACITY (16) instead.  READ
 
648
                 * CAPACITY (16) is not mandatory, so we can't just
 
649
                 * use it straight off.
 
650
                 */
 
651
                if ( capacity.blocks == 0 ) {
 
652
                        priv->use16 = 1;
 
653
                        if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 ) {
 
654
                                scsicmd_close ( scsicmd, rc );
 
655
                                return;
 
656
                        }
 
657
                        return;
 
658
                }
 
659
        }
 
660
        capacity.max_count = -1U;
 
661
 
 
662
        /* Return capacity to caller */
 
663
        block_capacity ( &scsicmd->block, &capacity );
 
664
 
 
665
        /* Close command */
 
666
        scsicmd_close ( scsicmd, 0 );
 
667
}
 
668
 
 
669
/** SCSI READ CAPACITY command type */
 
670
static struct scsi_command_type scsicmd_read_capacity = {
 
671
        .name = "READ CAPACITY",
 
672
        .priv_len = sizeof ( struct scsi_read_capacity_private ),
 
673
        .cmd = scsicmd_read_capacity_cmd,
 
674
        .done = scsicmd_read_capacity_done,
 
675
};
 
676
 
 
677
/**
 
678
 * Construct SCSI TEST UNIT READY command
 
679
 *
 
680
 * @v scsicmd           SCSI command
 
681
 * @v command           SCSI command IU
 
682
 */
 
683
static void scsicmd_test_unit_ready_cmd ( struct scsi_command *scsicmd __unused,
 
684
                                          struct scsi_cmd *command ) {
 
685
        struct scsi_cdb_test_unit_ready *testready = &command->cdb.testready;
 
686
 
 
687
        testready->opcode = SCSI_OPCODE_TEST_UNIT_READY;
 
688
}
 
689
 
 
690
/** SCSI TEST UNIT READY command type */
 
691
static struct scsi_command_type scsicmd_test_unit_ready = {
 
692
        .name = "TEST UNIT READY",
 
693
        .cmd = scsicmd_test_unit_ready_cmd,
 
694
        .done = scsicmd_close,
 
695
};
 
696
 
 
697
/** SCSI command block interface operations */
 
698
static struct interface_operation scsicmd_block_op[] = {
 
699
        INTF_OP ( intf_close, struct scsi_command *, scsicmd_close ),
 
700
};
 
701
 
 
702
/** SCSI command block interface descriptor */
 
703
static struct interface_descriptor scsicmd_block_desc =
 
704
        INTF_DESC_PASSTHRU ( struct scsi_command, block,
 
705
                             scsicmd_block_op, scsi );
 
706
 
 
707
/** SCSI command SCSI interface operations */
 
708
static struct interface_operation scsicmd_scsi_op[] = {
 
709
        INTF_OP ( intf_close, struct scsi_command *, scsicmd_done ),
 
710
        INTF_OP ( scsi_response, struct scsi_command *, scsicmd_response ),
 
711
};
 
712
 
 
713
/** SCSI command SCSI interface descriptor */
 
714
static struct interface_descriptor scsicmd_scsi_desc =
 
715
        INTF_DESC_PASSTHRU ( struct scsi_command, scsi,
 
716
                             scsicmd_scsi_op, block );
 
717
 
 
718
/**
 
719
 * Create SCSI command
 
720
 *
 
721
 * @v scsidev           SCSI device
 
722
 * @v block             Block data interface
 
723
 * @v type              SCSI command type
 
724
 * @v lba               Starting logical block address
 
725
 * @v count             Number of blocks to transfer
 
726
 * @v buffer            Data buffer
 
727
 * @v len               Length of data buffer
 
728
 * @ret rc              Return status code
 
729
 */
 
730
static int scsidev_command ( struct scsi_device *scsidev,
 
731
                             struct interface *block,
 
732
                             struct scsi_command_type *type,
 
733
                             uint64_t lba, unsigned int count,
 
734
                             userptr_t buffer, size_t len ) {
 
735
        struct scsi_command *scsicmd;
 
736
        int rc;
 
737
 
 
738
        /* Allocate and initialise structure */
 
739
        scsicmd = zalloc ( sizeof ( *scsicmd ) + type->priv_len );
 
740
        if ( ! scsicmd ) {
 
741
                rc = -ENOMEM;
 
742
                goto err_zalloc;
 
743
        }
 
744
        ref_init ( &scsicmd->refcnt, scsicmd_free );
 
745
        intf_init ( &scsicmd->block, &scsicmd_block_desc, &scsicmd->refcnt );
 
746
        intf_init ( &scsicmd->scsi, &scsicmd_scsi_desc,
 
747
                    &scsicmd->refcnt );
 
748
        scsicmd->scsidev = scsidev_get ( scsidev );
 
749
        list_add ( &scsicmd->list, &scsidev->cmds );
 
750
        scsicmd->type = type;
 
751
        scsicmd->lba = lba;
 
752
        scsicmd->count = count;
 
753
        scsicmd->buffer = buffer;
 
754
        scsicmd->len = len;
 
755
 
 
756
        /* Issue SCSI command */
 
757
        if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 )
 
758
                goto err_command;
 
759
 
 
760
        /* Attach to parent interface, mortalise self, and return */
 
761
        intf_plug_plug ( &scsicmd->block, block );
 
762
        ref_put ( &scsicmd->refcnt );
 
763
        return 0;
 
764
 
 
765
 err_command:
 
766
        scsicmd_close ( scsicmd, rc );
 
767
        ref_put ( &scsicmd->refcnt );
 
768
 err_zalloc:
 
769
        return rc;
 
770
}
 
771
 
 
772
/**
 
773
 * Issue SCSI block read
 
774
 *
 
775
 * @v scsidev           SCSI device
 
776
 * @v block             Block data interface
 
777
 * @v lba               Starting logical block address
 
778
 * @v count             Number of blocks to transfer
 
779
 * @v buffer            Data buffer
 
780
 * @v len               Length of data buffer
 
781
 * @ret rc              Return status code
 
782
 
 
783
 */
 
784
static int scsidev_read ( struct scsi_device *scsidev,
 
785
                          struct interface *block,
 
786
                          uint64_t lba, unsigned int count,
 
787
                          userptr_t buffer, size_t len ) {
 
788
        return scsidev_command ( scsidev, block, &scsicmd_read,
 
789
                                 lba, count, buffer, len );
 
790
}
 
791
 
 
792
/**
 
793
 * Issue SCSI block write
 
794
 *
 
795
 * @v scsidev           SCSI device
 
796
 * @v block             Block data interface
 
797
 * @v lba               Starting logical block address
 
798
 * @v count             Number of blocks to transfer
 
799
 * @v buffer            Data buffer
 
800
 * @v len               Length of data buffer
 
801
 * @ret rc              Return status code
 
802
 */
 
803
static int scsidev_write ( struct scsi_device *scsidev,
 
804
                           struct interface *block,
 
805
                           uint64_t lba, unsigned int count,
 
806
                           userptr_t buffer, size_t len ) {
 
807
        return scsidev_command ( scsidev, block, &scsicmd_write,
 
808
                                 lba, count, buffer, len );
 
809
}
 
810
 
 
811
/**
 
812
 * Read SCSI device capacity
 
813
 *
 
814
 * @v scsidev           SCSI device
 
815
 * @v block             Block data interface
 
816
 * @ret rc              Return status code
 
817
 */
 
818
static int scsidev_read_capacity ( struct scsi_device *scsidev,
 
819
                                   struct interface *block ) {
 
820
        return scsidev_command ( scsidev, block, &scsicmd_read_capacity,
 
821
                                 0, 0, UNULL, 0 );
 
822
}
 
823
 
 
824
/**
 
825
 * Test to see if SCSI device is ready
 
826
 *
 
827
 * @v scsidev           SCSI device
 
828
 * @v block             Block data interface
 
829
 * @ret rc              Return status code
 
830
 */
 
831
static int scsidev_test_unit_ready ( struct scsi_device *scsidev,
 
832
                                     struct interface *block ) {
 
833
        return scsidev_command ( scsidev, block, &scsicmd_test_unit_ready,
 
834
                                 0, 0, UNULL, 0 );
 
835
}
 
836
 
 
837
/**
 
838
 * Check SCSI device flow-control window
 
839
 *
 
840
 * @v scsidev           SCSI device
 
841
 * @ret len             Length of window
 
842
 */
 
843
static size_t scsidev_window ( struct scsi_device *scsidev ) {
 
844
 
 
845
        /* Refuse commands until unit is confirmed ready */
 
846
        if ( ! ( scsidev->flags & SCSIDEV_UNIT_READY ) )
 
847
                return 0;
 
848
 
 
849
        return xfer_window ( &scsidev->scsi );
 
850
}
 
851
 
 
852
/**
 
853
 * Close SCSI device
 
854
 *
 
855
 * @v scsidev           SCSI device
 
856
 * @v rc                Reason for close
 
857
 */
 
858
static void scsidev_close ( struct scsi_device *scsidev, int rc ) {
 
859
        struct scsi_command *scsicmd;
 
860
        struct scsi_command *tmp;
 
861
 
 
862
        /* Stop process */
 
863
        process_del ( &scsidev->process );
 
864
 
 
865
        /* Shut down interfaces */
 
866
        intf_shutdown ( &scsidev->block, rc );
 
867
        intf_shutdown ( &scsidev->scsi, rc );
 
868
        intf_shutdown ( &scsidev->ready, rc );
 
869
 
 
870
        /* Shut down any remaining commands */
 
871
        list_for_each_entry_safe ( scsicmd, tmp, &scsidev->cmds, list ) {
 
872
                scsicmd_get ( scsicmd );
 
873
                scsicmd_close ( scsicmd, rc );
 
874
                scsicmd_put ( scsicmd );
 
875
        }
 
876
}
 
877
 
 
878
/** SCSI device block interface operations */
 
879
static struct interface_operation scsidev_block_op[] = {
 
880
        INTF_OP ( xfer_window, struct scsi_device *, scsidev_window ),
 
881
        INTF_OP ( block_read, struct scsi_device *, scsidev_read ),
 
882
        INTF_OP ( block_write, struct scsi_device *, scsidev_write ),
 
883
        INTF_OP ( block_read_capacity, struct scsi_device *,
 
884
                  scsidev_read_capacity ),
 
885
        INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
 
886
};
 
887
 
 
888
/** SCSI device block interface descriptor */
 
889
static struct interface_descriptor scsidev_block_desc =
 
890
        INTF_DESC_PASSTHRU ( struct scsi_device, block,
 
891
                             scsidev_block_op, scsi );
 
892
 
 
893
/**
 
894
 * Handle SCSI TEST UNIT READY response
 
895
 *
 
896
 * @v scsidev           SCSI device
 
897
 * @v rc                Reason for close
 
898
 */
 
899
static void scsidev_ready ( struct scsi_device *scsidev, int rc ) {
 
900
 
 
901
        /* Shut down interface */
 
902
        intf_shutdown ( &scsidev->ready, rc );
 
903
 
 
904
        /* Close device on failure */
 
905
        if ( rc != 0 ) {
 
906
                DBGC ( scsidev, "SCSI %p not ready: %s\n",
 
907
                       scsidev, strerror ( rc ) );
 
908
                scsidev_close ( scsidev, rc );
 
909
                return;
 
910
        }
 
911
 
 
912
        /* Mark device as ready */
 
913
        scsidev->flags |= SCSIDEV_UNIT_READY;
 
914
        xfer_window_changed ( &scsidev->block );
 
915
        DBGC ( scsidev, "SCSI %p unit is ready\n", scsidev );
 
916
}
 
917
 
 
918
/** SCSI device TEST UNIT READY interface operations */
 
919
static struct interface_operation scsidev_ready_op[] = {
 
920
        INTF_OP ( intf_close, struct scsi_device *, scsidev_ready ),
 
921
};
 
922
 
 
923
/** SCSI device TEST UNIT READY interface descriptor */
 
924
static struct interface_descriptor scsidev_ready_desc =
 
925
        INTF_DESC ( struct scsi_device, ready, scsidev_ready_op );
 
926
 
 
927
/**
 
928
 * SCSI TEST UNIT READY process
 
929
 *
 
930
 * @v scsidev           SCSI device
 
931
 */
 
932
static void scsidev_step ( struct scsi_device *scsidev ) {
 
933
        int rc;
 
934
 
 
935
        /* Do nothing if we have already issued TEST UNIT READY */
 
936
        if ( scsidev->flags & SCSIDEV_UNIT_TESTED )
 
937
                return;
 
938
 
 
939
        /* Wait until underlying SCSI device is ready */
 
940
        if ( xfer_window ( &scsidev->scsi ) == 0 )
 
941
                return;
 
942
 
 
943
        DBGC ( scsidev, "SCSI %p waiting for unit to become ready\n",
 
944
               scsidev );
 
945
 
 
946
        /* Mark TEST UNIT READY as sent */
 
947
        scsidev->flags |= SCSIDEV_UNIT_TESTED;
 
948
 
 
949
        /* Issue TEST UNIT READY command */
 
950
        if ( ( rc = scsidev_test_unit_ready ( scsidev, &scsidev->ready )) !=0){
 
951
                scsidev_close ( scsidev, rc );
 
952
                return;
 
953
        }
 
954
}
 
955
 
 
956
/** SCSI device SCSI interface operations */
 
957
static struct interface_operation scsidev_scsi_op[] = {
 
958
        INTF_OP ( xfer_window_changed, struct scsi_device *, scsidev_step ),
 
959
        INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
 
960
};
 
961
 
 
962
/** SCSI device SCSI interface descriptor */
 
963
static struct interface_descriptor scsidev_scsi_desc =
 
964
        INTF_DESC_PASSTHRU ( struct scsi_device, scsi,
 
965
                             scsidev_scsi_op, block );
 
966
 
 
967
/** SCSI device process descriptor */
 
968
static struct process_descriptor scsidev_process_desc =
 
969
        PROC_DESC_ONCE ( struct scsi_device, process, scsidev_step );
 
970
 
 
971
/**
 
972
 * Open SCSI device
 
973
 *
 
974
 * @v block             Block control interface
 
975
 * @v scsi              SCSI control interface
 
976
 * @v lun               SCSI LUN
 
977
 * @ret rc              Return status code
 
978
 */
 
979
int scsi_open ( struct interface *block, struct interface *scsi,
 
980
                struct scsi_lun *lun ) {
 
981
        struct scsi_device *scsidev;
 
982
 
 
983
        /* Allocate and initialise structure */
 
984
        scsidev = zalloc ( sizeof ( *scsidev ) );
 
985
        if ( ! scsidev )
 
986
                return -ENOMEM;
 
987
        ref_init ( &scsidev->refcnt, NULL );
 
988
        intf_init ( &scsidev->block, &scsidev_block_desc, &scsidev->refcnt );
 
989
        intf_init ( &scsidev->scsi, &scsidev_scsi_desc, &scsidev->refcnt );
 
990
        intf_init ( &scsidev->ready, &scsidev_ready_desc, &scsidev->refcnt );
 
991
        process_init ( &scsidev->process, &scsidev_process_desc,
 
992
                       &scsidev->refcnt );
 
993
        INIT_LIST_HEAD ( &scsidev->cmds );
 
994
        memcpy ( &scsidev->lun, lun, sizeof ( scsidev->lun ) );
 
995
        DBGC ( scsidev, "SCSI %p created for LUN " SCSI_LUN_FORMAT "\n",
 
996
               scsidev, SCSI_LUN_DATA ( scsidev->lun ) );
 
997
 
 
998
        /* Attach to SCSI and parent interfaces, mortalise self, and return */
 
999
        intf_plug_plug ( &scsidev->scsi, scsi );
 
1000
        intf_plug_plug ( &scsidev->block, block );
 
1001
        ref_put ( &scsidev->refcnt );
 
1002
        return 0;
 
1003
}