1e906e13c08d433dedfbf0e89b8d696a2ee208da
[people/mcb30/gpxe.git] / 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., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stddef.h>
20 #include <string.h>
21 #include <byteswap.h>
22 #include <gpxe/blockdev.h>
23 #include <gpxe/scsi.h>
24
25 /** @file
26  *
27  * SCSI block device
28  *
29  */
30
31 static inline __attribute__ (( always_inline )) struct scsi_device *
32 block_to_scsi ( struct block_device *blockdev ) {
33         return container_of ( blockdev, struct scsi_device, blockdev );
34 }
35
36 /**
37  * Issue SCSI command
38  *
39  * @v scsi              SCSI device
40  * @v command           SCSI command
41  * @ret rc              Return status code
42  */
43 static int scsi_command ( struct scsi_device *scsi,
44                           struct scsi_command *command ) {
45         return scsi->command ( scsi, command );
46 }
47
48 /**
49  * Read block from SCSI device
50  *
51  * @v blockdev          Block device
52  * @v block             LBA block number
53  * @v count             Block count
54  * @v buffer            Data buffer
55  * @ret rc              Return status code
56  */
57 static int scsi_read ( struct block_device *blockdev, uint64_t block,
58                        unsigned long count, userptr_t buffer ) {
59         struct scsi_device *scsi = block_to_scsi ( blockdev );
60         struct scsi_command command;
61         struct scsi_cdb_read_16 *cdb = &command.cdb.read16;
62
63         /* Issue READ (16) */
64         memset ( &command, 0, sizeof ( command ) );
65         cdb->opcode = SCSI_OPCODE_READ_16;
66         cdb->lba = cpu_to_be64 ( block );
67         cdb->len = cpu_to_be32 ( count );
68         command.data_in = buffer;
69         command.data_in_len = ( count * blockdev->blksize );
70         return scsi_command ( scsi, &command );
71 }
72
73 /**
74  * Write block to SCSI device
75  *
76  * @v blockdev          Block device
77  * @v block             LBA block number
78  * @v count             Block count
79  * @v buffer            Data buffer
80  * @ret rc              Return status code
81  */
82 static int scsi_write ( struct block_device *blockdev, uint64_t block,
83                         unsigned long count, userptr_t buffer ) {
84         struct scsi_device *scsi = block_to_scsi ( blockdev );
85         struct scsi_command command;
86         struct scsi_cdb_write_16 *cdb = &command.cdb.write16;
87
88         /* Issue WRITE (16) */
89         memset ( &command, 0, sizeof ( command ) );
90         cdb->opcode = SCSI_OPCODE_WRITE_16;
91         cdb->lba = cpu_to_be64 ( block );
92         cdb->len = cpu_to_be32 ( count );
93         command.data_out = buffer;
94         command.data_out_len = ( count * blockdev->blksize );
95         return scsi_command ( scsi, &command );
96 }
97
98 /**
99  * Read capacity of SCSI device via READ CAPACITY (10)
100  *
101  * @v blockdev          Block device
102  * @ret rc              Return status code
103  */
104 static int scsi_read_capacity_10 ( struct block_device *blockdev ) {
105         struct scsi_device *scsi = block_to_scsi ( blockdev );
106         struct scsi_command command;
107         struct scsi_cdb_read_capacity_10 *cdb = &command.cdb.readcap10;
108         struct scsi_capacity_10 capacity;
109         int rc;
110
111         /* Issue READ CAPACITY (10) */
112         memset ( &command, 0, sizeof ( command ) );
113         cdb->opcode = SCSI_OPCODE_READ_CAPACITY_10;
114         command.data_in = virt_to_user ( &capacity );
115         command.data_in_len = sizeof ( capacity );
116
117         if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
118                 return rc;
119
120         /* Fill in block device fields */
121         blockdev->blksize = be32_to_cpu ( capacity.blksize );
122         blockdev->blocks = ( be32_to_cpu ( capacity.lba ) + 1 );
123
124         return 0;
125 }
126
127 /**
128  * Read capacity of SCSI device via READ CAPACITY (16)
129  *
130  * @v blockdev          Block device
131  * @ret rc              Return status code
132  */
133 static int scsi_read_capacity_16 ( struct block_device *blockdev ) {
134         struct scsi_device *scsi = block_to_scsi ( blockdev );
135         struct scsi_command command;
136         struct scsi_cdb_read_capacity_16 *cdb = &command.cdb.readcap16;
137         struct scsi_capacity_16 capacity;
138         int rc;
139
140         /* Issue READ CAPACITY (16) */
141         memset ( &command, 0, sizeof ( command ) );
142         cdb->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
143         cdb->service_action = SCSI_SERVICE_ACTION_READ_CAPACITY_16;
144         cdb->len = cpu_to_be32 ( sizeof ( capacity ) );
145         command.data_in = virt_to_user ( &capacity );
146         command.data_in_len = sizeof ( capacity );
147
148         if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
149                 return rc;
150
151         /* Fill in block device fields */
152         blockdev->blksize = be32_to_cpu ( capacity.blksize );
153         blockdev->blocks = ( be64_to_cpu ( capacity.lba ) + 1 );
154         return 0;
155 }
156
157 /**
158  * Read capacity of SCSI device
159  *
160  * @v blockdev          Block device
161  * @ret rc              Return status code
162  */
163 static int scsi_read_capacity ( struct block_device *blockdev ) {
164         int rc;
165
166         /* Try READ CAPACITY (10), which is a mandatory command, first. */
167         if ( ( rc = scsi_read_capacity_10 ( blockdev ) ) != 0 )
168                 return rc;
169
170         /* If capacity range was exceeded (i.e. capacity.lba was
171          * 0xffffffff, meaning that blockdev->blocks is now zero), use
172          * READ CAPACITY (16) instead.  READ CAPACITY (16) is not
173          * mandatory, so we can't just use it straight off.
174          */
175         if ( blockdev->blocks == 0 ) {
176                 if ( ( rc = scsi_read_capacity_16 ( blockdev ) ) != 0 )
177                         return rc;
178         }
179
180         return 0;
181 }
182
183 /**
184  * Initialise SCSI device
185  *
186  * @v scsi              SCSI device
187  * @ret rc              Return status code
188  *
189  * Initialises a SCSI device.  The scsi_device::command and
190  * scsi_device::lun fields must already be filled in.  This function
191  * will configure scsi_device::blockdev, including issuing a READ
192  * CAPACITY call to determine the block size and total device size.
193  */
194 int init_scsidev ( struct scsi_device *scsi ) {
195         /** Fill in read and write methods, and get device capacity */
196         scsi->blockdev.read = scsi_read;
197         scsi->blockdev.write = scsi_write;
198         return scsi_read_capacity ( &scsi->blockdev );
199 }