source: mainline/uspace/lib/drv/generic/remote_ahci.c@ 3679f51a

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3679f51a was ae7d03c, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Selected ccheck-proposed comment fixes.
  • Property mode set to 100644
File size: 9.0 KB
Line 
1/*
2 * Copyright (c) 2012 Petr Jerman
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libdrv
30 * @{
31 */
32/** @file
33 */
34
35#include <as.h>
36#include <async.h>
37#include <devman.h>
38#include <errno.h>
39#include <stdio.h>
40#include <macros.h>
41#include <str.h>
42#include "ahci_iface.h"
43#include "ddf/driver.h"
44
45typedef enum {
46 IPC_M_AHCI_GET_SATA_DEVICE_NAME,
47 IPC_M_AHCI_GET_NUM_BLOCKS,
48 IPC_M_AHCI_GET_BLOCK_SIZE,
49 IPC_M_AHCI_READ_BLOCKS,
50 IPC_M_AHCI_WRITE_BLOCKS
51} ahci_iface_funcs_t;
52
53#define MAX_NAME_LENGTH 1024
54
55#define LO(ptr) \
56 ((uint32_t) (((uint64_t) ((uintptr_t) (ptr))) & 0xffffffff))
57
58#define HI(ptr) \
59 ((uint32_t) (((uint64_t) ((uintptr_t) (ptr))) >> 32))
60
61async_sess_t *ahci_get_sess(devman_handle_t funh, char **name)
62{
63 // FIXME: Use a better way than substring match
64
65 *name = NULL;
66
67 char devn[MAX_NAME_LENGTH];
68 errno_t rc = devman_fun_get_name(funh, devn, MAX_NAME_LENGTH);
69 if (rc != EOK)
70 return NULL;
71
72 size_t devn_size = str_size(devn);
73
74 if ((devn_size > 5) && (str_lcmp(devn, "ahci_", 5) == 0)) {
75 async_sess_t *sess = devman_device_connect(funh, IPC_FLAG_BLOCKING);
76
77 if (sess) {
78 *name = str_dup(devn);
79 return sess;
80 }
81 }
82
83 return NULL;
84}
85
86errno_t ahci_get_sata_device_name(async_sess_t *sess, size_t sata_dev_name_length,
87 char *sata_dev_name)
88{
89 async_exch_t *exch = async_exchange_begin(sess);
90 if (!exch)
91 return EINVAL;
92
93 aid_t req = async_send_2(exch, DEV_IFACE_ID(AHCI_DEV_IFACE),
94 IPC_M_AHCI_GET_SATA_DEVICE_NAME, sata_dev_name_length, NULL);
95
96 async_data_read_start(exch, sata_dev_name, sata_dev_name_length);
97
98 errno_t rc;
99 async_wait_for(req, &rc);
100
101 return rc;
102}
103
104errno_t ahci_get_num_blocks(async_sess_t *sess, uint64_t *blocks)
105{
106 async_exch_t *exch = async_exchange_begin(sess);
107 if (!exch)
108 return EINVAL;
109
110 sysarg_t blocks_hi;
111 sysarg_t blocks_lo;
112 errno_t rc = async_req_1_2(exch, DEV_IFACE_ID(AHCI_DEV_IFACE),
113 IPC_M_AHCI_GET_NUM_BLOCKS, &blocks_hi, &blocks_lo);
114
115 async_exchange_end(exch);
116
117 if (rc == EOK) {
118 *blocks = (((uint64_t) blocks_hi) << 32) |
119 (((uint64_t) blocks_lo) & 0xffffffff);
120 }
121
122 return rc;
123}
124
125errno_t ahci_get_block_size(async_sess_t *sess, size_t *blocks_size)
126{
127 async_exch_t *exch = async_exchange_begin(sess);
128 if (!exch)
129 return EINVAL;
130
131 sysarg_t bs;
132 errno_t rc = async_req_1_1(exch, DEV_IFACE_ID(AHCI_DEV_IFACE),
133 IPC_M_AHCI_GET_BLOCK_SIZE, &bs);
134
135 async_exchange_end(exch);
136
137 if (rc == EOK)
138 *blocks_size = (size_t) bs;
139
140 return rc;
141}
142
143errno_t ahci_read_blocks(async_sess_t *sess, uint64_t blocknum, size_t count,
144 void *buf)
145{
146 async_exch_t *exch = async_exchange_begin(sess);
147 if (!exch)
148 return EINVAL;
149
150 aid_t req;
151 req = async_send_4(exch, DEV_IFACE_ID(AHCI_DEV_IFACE),
152 IPC_M_AHCI_READ_BLOCKS, HI(blocknum), LO(blocknum), count, NULL);
153
154 async_share_out_start(exch, buf, AS_AREA_READ | AS_AREA_WRITE);
155
156 async_exchange_end(exch);
157
158 errno_t rc;
159 async_wait_for(req, &rc);
160
161 return rc;
162}
163
164errno_t ahci_write_blocks(async_sess_t *sess, uint64_t blocknum, size_t count,
165 void *buf)
166{
167 async_exch_t *exch = async_exchange_begin(sess);
168 if (!exch)
169 return EINVAL;
170
171 aid_t req = async_send_4(exch, DEV_IFACE_ID(AHCI_DEV_IFACE),
172 IPC_M_AHCI_WRITE_BLOCKS, HI(blocknum), LO(blocknum), count, NULL);
173
174 async_share_out_start(exch, buf, AS_AREA_READ | AS_AREA_WRITE);
175
176 async_exchange_end(exch);
177
178 errno_t rc;
179 async_wait_for(req, &rc);
180
181 return rc;
182}
183
184static void remote_ahci_get_sata_device_name(ddf_fun_t *, void *, cap_call_handle_t,
185 ipc_call_t *);
186static void remote_ahci_get_num_blocks(ddf_fun_t *, void *, cap_call_handle_t,
187 ipc_call_t *);
188static void remote_ahci_get_block_size(ddf_fun_t *, void *, cap_call_handle_t,
189 ipc_call_t *);
190static void remote_ahci_read_blocks(ddf_fun_t *, void *, cap_call_handle_t,
191 ipc_call_t *);
192static void remote_ahci_write_blocks(ddf_fun_t *, void *, cap_call_handle_t,
193 ipc_call_t *);
194
195/** Remote AHCI interface operations. */
196static const remote_iface_func_ptr_t remote_ahci_iface_ops [] = {
197 [IPC_M_AHCI_GET_SATA_DEVICE_NAME] = remote_ahci_get_sata_device_name,
198 [IPC_M_AHCI_GET_NUM_BLOCKS] = remote_ahci_get_num_blocks,
199 [IPC_M_AHCI_GET_BLOCK_SIZE] = remote_ahci_get_block_size,
200 [IPC_M_AHCI_READ_BLOCKS] = remote_ahci_read_blocks,
201 [IPC_M_AHCI_WRITE_BLOCKS] = remote_ahci_write_blocks
202};
203
204/** Remote AHCI interface structure.
205 */
206const remote_iface_t remote_ahci_iface = {
207 .method_count = ARRAY_SIZE(remote_ahci_iface_ops),
208 .methods = remote_ahci_iface_ops
209};
210
211void remote_ahci_get_sata_device_name(ddf_fun_t *fun, void *iface,
212 cap_call_handle_t chandle, ipc_call_t *call)
213{
214 const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
215
216 if (ahci_iface->get_sata_device_name == NULL) {
217 async_answer_0(chandle, ENOTSUP);
218 return;
219 }
220
221 const size_t sata_dev_name_length =
222 (size_t) DEV_IPC_GET_ARG1(*call);
223
224 char *sata_dev_name = malloc(sata_dev_name_length);
225 if (sata_dev_name == NULL) {
226 async_answer_0(chandle, ENOMEM);
227 return;
228 }
229
230 const errno_t ret = ahci_iface->get_sata_device_name(fun,
231 sata_dev_name_length, sata_dev_name);
232
233 size_t real_size;
234 cap_call_handle_t call_handle;
235 if ((async_data_read_receive(&call_handle, &real_size)) &&
236 (real_size == sata_dev_name_length))
237 async_data_read_finalize(call_handle, sata_dev_name,
238 sata_dev_name_length);
239
240 free(sata_dev_name);
241 async_answer_0(chandle, ret);
242}
243
244static void remote_ahci_get_num_blocks(ddf_fun_t *fun, void *iface,
245 cap_call_handle_t chandle, ipc_call_t *call)
246{
247 const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
248
249 if (ahci_iface->get_num_blocks == NULL) {
250 async_answer_0(chandle, ENOTSUP);
251 return;
252 }
253
254 uint64_t blocks;
255 const errno_t ret = ahci_iface->get_num_blocks(fun, &blocks);
256
257 if (ret != EOK)
258 async_answer_0(chandle, ret);
259 else
260 async_answer_2(chandle, EOK, HI(blocks), LO(blocks));
261}
262
263static void remote_ahci_get_block_size(ddf_fun_t *fun, void *iface,
264 cap_call_handle_t chandle, ipc_call_t *call)
265{
266 const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
267
268 if (ahci_iface->get_block_size == NULL) {
269 async_answer_0(chandle, ENOTSUP);
270 return;
271 }
272
273 size_t blocks;
274 const errno_t ret = ahci_iface->get_block_size(fun, &blocks);
275
276 if (ret != EOK)
277 async_answer_0(chandle, ret);
278 else
279 async_answer_1(chandle, EOK, blocks);
280}
281
282void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface,
283 cap_call_handle_t chandle, ipc_call_t *call)
284{
285 const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
286
287 if (ahci_iface->read_blocks == NULL) {
288 async_answer_0(chandle, ENOTSUP);
289 return;
290 }
291
292 size_t maxblock_size;
293 unsigned int flags;
294
295 cap_call_handle_t call_handle;
296 async_share_out_receive(&call_handle, &maxblock_size, &flags);
297
298 void *buf;
299 async_share_out_finalize(call_handle, &buf);
300
301 const uint64_t blocknum =
302 (((uint64_t) (DEV_IPC_GET_ARG1(*call))) << 32) |
303 (((uint64_t) (DEV_IPC_GET_ARG2(*call))) & 0xffffffff);
304 const size_t cnt = (size_t) DEV_IPC_GET_ARG3(*call);
305
306 const errno_t ret = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
307
308 async_answer_0(chandle, ret);
309}
310
311void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle,
312 ipc_call_t *call)
313{
314 const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
315
316 if (ahci_iface->read_blocks == NULL) {
317 async_answer_0(chandle, ENOTSUP);
318 return;
319 }
320
321 size_t maxblock_size;
322 unsigned int flags;
323
324 cap_call_handle_t call_handle;
325 async_share_out_receive(&call_handle, &maxblock_size, &flags);
326
327 void *buf;
328 async_share_out_finalize(call_handle, &buf);
329
330 const uint64_t blocknum =
331 (((uint64_t)(DEV_IPC_GET_ARG1(*call))) << 32) |
332 (((uint64_t)(DEV_IPC_GET_ARG2(*call))) & 0xffffffff);
333 const size_t cnt = (size_t) DEV_IPC_GET_ARG3(*call);
334
335 const errno_t ret = ahci_iface->write_blocks(fun, blocknum, cnt, buf);
336
337 async_answer_0(chandle, ret);
338}
339
340/**
341 * @}
342 */
Note: See TracBrowser for help on using the repository browser.