1e3026534SToomas Soome /*
2199767f8SToomas Soome * Copyright (c) 2010 Marcel Moolenaar
3199767f8SToomas Soome * All rights reserved.
4199767f8SToomas Soome *
5199767f8SToomas Soome * Redistribution and use in source and binary forms, with or without
6199767f8SToomas Soome * modification, are permitted provided that the following conditions
7199767f8SToomas Soome * are met:
8199767f8SToomas Soome * 1. Redistributions of source code must retain the above copyright
9199767f8SToomas Soome * notice, this list of conditions and the following disclaimer.
10199767f8SToomas Soome * 2. Redistributions in binary form must reproduce the above copyright
11199767f8SToomas Soome * notice, this list of conditions and the following disclaimer in the
12199767f8SToomas Soome * documentation and/or other materials provided with the distribution.
13199767f8SToomas Soome *
14199767f8SToomas Soome * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15199767f8SToomas Soome * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16199767f8SToomas Soome * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17199767f8SToomas Soome * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18199767f8SToomas Soome * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19199767f8SToomas Soome * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20199767f8SToomas Soome * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21199767f8SToomas Soome * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22199767f8SToomas Soome * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23199767f8SToomas Soome * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24199767f8SToomas Soome * SUCH DAMAGE.
25199767f8SToomas Soome */
26199767f8SToomas Soome
27199767f8SToomas Soome #include <sys/cdefs.h>
28199767f8SToomas Soome
29edb35047SToomas Soome #include <sys/disk.h>
30199767f8SToomas Soome #include <sys/param.h>
31199767f8SToomas Soome #include <sys/time.h>
32dbacaf56SToomas Soome #include <sys/queue.h>
33199767f8SToomas Soome #include <stddef.h>
34199767f8SToomas Soome #include <stdarg.h>
35199767f8SToomas Soome
36199767f8SToomas Soome #include <bootstrap.h>
37199767f8SToomas Soome
38199767f8SToomas Soome #include <efi.h>
39199767f8SToomas Soome #include <efilib.h>
401f54f0bbSToomas Soome #include <efichar.h>
41*f334afcfSToomas Soome #include <efidevp.h>
42*f334afcfSToomas Soome #include <Protocol/BlockIo.h>
43*f334afcfSToomas Soome #include <Protocol/BlockIo2.h>
44dbacaf56SToomas Soome #include <disk.h>
45199767f8SToomas Soome
46*f334afcfSToomas Soome EFI_GUID gEfiBlockIoProtocolGuid = EFI_BLOCK_IO_PROTOCOL_GUID;
47*f334afcfSToomas Soome EFI_GUID gEfiBlockIo2ProtocolGuid = EFI_BLOCK_IO2_PROTOCOL_GUID;
48199767f8SToomas Soome
49c54162e4SToomas Soome typedef bool (*pd_test_cb_t)(pdinfo_t *, pdinfo_t *);
50dbacaf56SToomas Soome static int efipart_initfd(void);
51dbacaf56SToomas Soome static int efipart_initcd(void);
52dbacaf56SToomas Soome static int efipart_inithd(void);
53c54162e4SToomas Soome static void efipart_cdinfo_add(pdinfo_t *);
54dbacaf56SToomas Soome
5538dea910SToomas Soome static int efipart_strategy(void *, int, daddr_t, size_t, char *, size_t *);
5638dea910SToomas Soome static int efipart_realstrategy(void *, int, daddr_t, size_t, char *, size_t *);
57dbacaf56SToomas Soome
58199767f8SToomas Soome static int efipart_open(struct open_file *, ...);
59199767f8SToomas Soome static int efipart_close(struct open_file *);
600f2f3e99SToomas Soome static int efipart_ioctl(struct open_file *, unsigned long, void *);
61199767f8SToomas Soome
62dbacaf56SToomas Soome static int efipart_printfd(int);
63dbacaf56SToomas Soome static int efipart_printcd(int);
64dbacaf56SToomas Soome static int efipart_printhd(int);
65dbacaf56SToomas Soome
66dbacaf56SToomas Soome /* EISA PNP ID's for floppy controllers */
67dbacaf56SToomas Soome #define PNP0604 0x604
68dbacaf56SToomas Soome #define PNP0700 0x700
69dbacaf56SToomas Soome #define PNP0701 0x701
70dbacaf56SToomas Soome
712b292e00SToomas Soome /* Bounce buffer max size */
722b292e00SToomas Soome #define BIO_BUFFER_SIZE 0x4000
732b292e00SToomas Soome
74dbacaf56SToomas Soome struct devsw efipart_fddev = {
75dbacaf56SToomas Soome .dv_name = "fd",
76dbacaf56SToomas Soome .dv_type = DEVT_FD,
77dbacaf56SToomas Soome .dv_init = efipart_initfd,
78dbacaf56SToomas Soome .dv_strategy = efipart_strategy,
79dbacaf56SToomas Soome .dv_open = efipart_open,
80dbacaf56SToomas Soome .dv_close = efipart_close,
81dbacaf56SToomas Soome .dv_ioctl = efipart_ioctl,
82dbacaf56SToomas Soome .dv_print = efipart_printfd,
83dbacaf56SToomas Soome .dv_cleanup = NULL
84dbacaf56SToomas Soome };
85dbacaf56SToomas Soome
86dbacaf56SToomas Soome struct devsw efipart_cddev = {
87dbacaf56SToomas Soome .dv_name = "cd",
88dbacaf56SToomas Soome .dv_type = DEVT_CD,
89dbacaf56SToomas Soome .dv_init = efipart_initcd,
90dbacaf56SToomas Soome .dv_strategy = efipart_strategy,
91dbacaf56SToomas Soome .dv_open = efipart_open,
92dbacaf56SToomas Soome .dv_close = efipart_close,
93dbacaf56SToomas Soome .dv_ioctl = efipart_ioctl,
94dbacaf56SToomas Soome .dv_print = efipart_printcd,
95dbacaf56SToomas Soome .dv_cleanup = NULL
96dbacaf56SToomas Soome };
97dbacaf56SToomas Soome
98dbacaf56SToomas Soome struct devsw efipart_hddev = {
99dbacaf56SToomas Soome .dv_name = "disk",
100199767f8SToomas Soome .dv_type = DEVT_DISK,
101dbacaf56SToomas Soome .dv_init = efipart_inithd,
102199767f8SToomas Soome .dv_strategy = efipart_strategy,
103199767f8SToomas Soome .dv_open = efipart_open,
104199767f8SToomas Soome .dv_close = efipart_close,
105edb35047SToomas Soome .dv_ioctl = efipart_ioctl,
106dbacaf56SToomas Soome .dv_print = efipart_printhd,
107199767f8SToomas Soome .dv_cleanup = NULL
108199767f8SToomas Soome };
109199767f8SToomas Soome
1100f2f3e99SToomas Soome static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
1110f2f3e99SToomas Soome static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
1120f2f3e99SToomas Soome static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
113dbacaf56SToomas Soome
1140f2f3e99SToomas Soome /*
1150f2f3e99SToomas Soome * efipart_inithandles() is used to build up the pdinfo list from
1160f2f3e99SToomas Soome * block device handles. Then each devsw init callback is used to
1170f2f3e99SToomas Soome * pick items from pdinfo and move to proper device list.
1180f2f3e99SToomas Soome * In ideal world, we should end up with empty pdinfo once all
1190f2f3e99SToomas Soome * devsw initializers are called.
1200f2f3e99SToomas Soome */
1210f2f3e99SToomas Soome static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
122dbacaf56SToomas Soome
123eea30b26SToomas Soome pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw * dev)124eea30b26SToomas Soome efiblk_get_pdinfo_list(struct devsw *dev)
125199767f8SToomas Soome {
126eea30b26SToomas Soome if (dev->dv_type == DEVT_DISK)
127eea30b26SToomas Soome return (&hdinfo);
128eea30b26SToomas Soome if (dev->dv_type == DEVT_CD)
129eea30b26SToomas Soome return (&cdinfo);
130eea30b26SToomas Soome if (dev->dv_type == DEVT_FD)
131eea30b26SToomas Soome return (&fdinfo);
132eea30b26SToomas Soome return (NULL);
133eea30b26SToomas Soome }
134eea30b26SToomas Soome
135e3026534SToomas Soome /* XXX this gets called way way too often, investigate */
136eea30b26SToomas Soome pdinfo_t *
efiblk_get_pdinfo(struct devdesc * dev)137eea30b26SToomas Soome efiblk_get_pdinfo(struct devdesc *dev)
138eea30b26SToomas Soome {
139eea30b26SToomas Soome pdinfo_list_t *pdi;
140eea30b26SToomas Soome pdinfo_t *pd = NULL;
141eea30b26SToomas Soome
142eea30b26SToomas Soome pdi = efiblk_get_pdinfo_list(dev->d_dev);
143eea30b26SToomas Soome if (pdi == NULL)
144eea30b26SToomas Soome return (pd);
145199767f8SToomas Soome
146dbacaf56SToomas Soome STAILQ_FOREACH(pd, pdi, pd_link) {
147eea30b26SToomas Soome if (pd->pd_unit == dev->d_unit)
148dbacaf56SToomas Soome return (pd);
149dbacaf56SToomas Soome }
150eea30b26SToomas Soome return (pd);
151dbacaf56SToomas Soome }
152199767f8SToomas Soome
153e3026534SToomas Soome static bool
same_handle(pdinfo_t * pd,EFI_HANDLE h)154e3026534SToomas Soome same_handle(pdinfo_t *pd, EFI_HANDLE h)
155e3026534SToomas Soome {
156e3026534SToomas Soome
157e3026534SToomas Soome return (pd->pd_handle == h || pd->pd_alias == h);
158e3026534SToomas Soome }
159e3026534SToomas Soome
160e3026534SToomas Soome pdinfo_t *
efiblk_get_pdinfo_by_handle(EFI_HANDLE h)161e3026534SToomas Soome efiblk_get_pdinfo_by_handle(EFI_HANDLE h)
162e3026534SToomas Soome {
163e3026534SToomas Soome pdinfo_t *dp, *pp;
164e3026534SToomas Soome
165e3026534SToomas Soome /*
166e3026534SToomas Soome * Check hard disks, then cd, then floppy
167e3026534SToomas Soome */
168e3026534SToomas Soome STAILQ_FOREACH(dp, &hdinfo, pd_link) {
169e3026534SToomas Soome if (same_handle(dp, h))
170e3026534SToomas Soome return (dp);
171e3026534SToomas Soome STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
172e3026534SToomas Soome if (same_handle(pp, h))
173e3026534SToomas Soome return (pp);
174e3026534SToomas Soome }
175e3026534SToomas Soome }
176e3026534SToomas Soome STAILQ_FOREACH(dp, &cdinfo, pd_link) {
177e3026534SToomas Soome if (same_handle(dp, h))
178e3026534SToomas Soome return (dp);
1790f2f3e99SToomas Soome STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
1800f2f3e99SToomas Soome if (same_handle(pp, h))
1810f2f3e99SToomas Soome return (pp);
1820f2f3e99SToomas Soome }
183e3026534SToomas Soome }
184e3026534SToomas Soome STAILQ_FOREACH(dp, &fdinfo, pd_link) {
185e3026534SToomas Soome if (same_handle(dp, h))
186e3026534SToomas Soome return (dp);
187e3026534SToomas Soome }
188e3026534SToomas Soome return (NULL);
189e3026534SToomas Soome }
190e3026534SToomas Soome
191199767f8SToomas Soome static int
efiblk_pdinfo_count(pdinfo_list_t * pdi)192dbacaf56SToomas Soome efiblk_pdinfo_count(pdinfo_list_t *pdi)
193dbacaf56SToomas Soome {
194dbacaf56SToomas Soome pdinfo_t *pd;
195dbacaf56SToomas Soome int i = 0;
196dbacaf56SToomas Soome
197dbacaf56SToomas Soome STAILQ_FOREACH(pd, pdi, pd_link) {
198dbacaf56SToomas Soome i++;
199dbacaf56SToomas Soome }
200dbacaf56SToomas Soome return (i);
201dbacaf56SToomas Soome }
202dbacaf56SToomas Soome
203c54162e4SToomas Soome static pdinfo_t *
efipart_find_parent(pdinfo_list_t * pdi,EFI_DEVICE_PATH * devpath)204c54162e4SToomas Soome efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
205c54162e4SToomas Soome {
206c54162e4SToomas Soome pdinfo_t *pd;
207c54162e4SToomas Soome EFI_DEVICE_PATH *parent;
208c54162e4SToomas Soome
209c54162e4SToomas Soome /* We want to find direct parent */
210c54162e4SToomas Soome parent = efi_devpath_trim(devpath);
211c54162e4SToomas Soome /* We should not get out of memory here but be careful. */
212c54162e4SToomas Soome if (parent == NULL)
213c54162e4SToomas Soome return (NULL);
214c54162e4SToomas Soome
215c54162e4SToomas Soome STAILQ_FOREACH(pd, pdi, pd_link) {
216c54162e4SToomas Soome /* We must have exact match. */
217c54162e4SToomas Soome if (efi_devpath_match(pd->pd_devpath, parent))
218c54162e4SToomas Soome break;
219c54162e4SToomas Soome }
220c54162e4SToomas Soome free(parent);
221c54162e4SToomas Soome return (pd);
222c54162e4SToomas Soome }
223c54162e4SToomas Soome
224c54162e4SToomas Soome /*
225c54162e4SToomas Soome * Return true when we should ignore this device.
226c54162e4SToomas Soome */
227c54162e4SToomas Soome static bool
efipart_ignore_device(EFI_HANDLE h,EFI_BLOCK_IO * blkio,EFI_DEVICE_PATH * devpath)228c54162e4SToomas Soome efipart_ignore_device(EFI_HANDLE h, EFI_BLOCK_IO *blkio,
229c54162e4SToomas Soome EFI_DEVICE_PATH *devpath)
230c54162e4SToomas Soome {
231c54162e4SToomas Soome EFI_DEVICE_PATH *node, *parent;
232c54162e4SToomas Soome
233c54162e4SToomas Soome /*
234c54162e4SToomas Soome * We assume the block size 512 or greater power of 2.
235c54162e4SToomas Soome * Also skip devices with block size > 64k (16 is max
236c54162e4SToomas Soome * ashift supported by zfs).
237c54162e4SToomas Soome * iPXE is known to insert stub BLOCK IO device with
238c54162e4SToomas Soome * BlockSize 1.
239c54162e4SToomas Soome */
240c54162e4SToomas Soome if (blkio->Media->BlockSize < 512 ||
241c54162e4SToomas Soome blkio->Media->BlockSize > (1 << 16) ||
242c54162e4SToomas Soome !powerof2(blkio->Media->BlockSize)) {
243c54162e4SToomas Soome efi_close_devpath(h);
244c54162e4SToomas Soome return (true);
245c54162e4SToomas Soome }
246c54162e4SToomas Soome
247c54162e4SToomas Soome /* Allowed values are 0, 1 and power of 2. */
248c54162e4SToomas Soome if (blkio->Media->IoAlign > 1 &&
249c54162e4SToomas Soome !powerof2(blkio->Media->IoAlign)) {
250c54162e4SToomas Soome efi_close_devpath(h);
251c54162e4SToomas Soome return (true);
252c54162e4SToomas Soome }
253c54162e4SToomas Soome
254c54162e4SToomas Soome /*
255c54162e4SToomas Soome * With device tree setup:
256c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)
257c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x1)
258c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x2)
259c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x3)
260c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x3)/CDROM..
261c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x3)/CDROM..
262c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x4)
263c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x5)
264c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x6)
265c54162e4SToomas Soome * PciRoot(0x0)/Pci(0x14,0x0)/USB(0x5,0)/USB(0x2,0x0)/Unit(0x7)
266c54162e4SToomas Soome *
267c54162e4SToomas Soome * In above exmple only Unit(0x3) has media, all other nodes are
268c54162e4SToomas Soome * missing media and should not be used.
269c54162e4SToomas Soome *
270c54162e4SToomas Soome * No media does not always mean there is no device, but in above
271c54162e4SToomas Soome * case, we can not really assume there is any device.
272c54162e4SToomas Soome * Therefore, if this node is USB, or this node is Unit (LUN) and
273c54162e4SToomas Soome * direct parent is USB and we have no media, we will ignore this
274c54162e4SToomas Soome * device.
2759d0a7db0SToomas Soome *
2769d0a7db0SToomas Soome * Variation of the same situation, but with SCSI devices:
2779d0a7db0SToomas Soome * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x1)
2789d0a7db0SToomas Soome * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x2)
2799d0a7db0SToomas Soome * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x3)
2809d0a7db0SToomas Soome * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x3)/CD..
2819d0a7db0SToomas Soome * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x3)/CD..
2829d0a7db0SToomas Soome * PciRoot(0x0)/Pci(0x1a,0x0)/USB(0x1,0)/USB(0x3,0x0)/SCSI(0x0,0x4)
2839d0a7db0SToomas Soome *
2849d0a7db0SToomas Soome * Here above the SCSI luns 1,2 and 4 have no media.
285c54162e4SToomas Soome */
286c54162e4SToomas Soome
287c54162e4SToomas Soome /* Do not ignore device with media. */
288c54162e4SToomas Soome if (blkio->Media->MediaPresent)
289c54162e4SToomas Soome return (false);
290c54162e4SToomas Soome
291c54162e4SToomas Soome node = efi_devpath_last_node(devpath);
292c54162e4SToomas Soome if (node == NULL)
293c54162e4SToomas Soome return (false);
294c54162e4SToomas Soome
295c54162e4SToomas Soome /* USB without media present */
296c54162e4SToomas Soome if (DevicePathType(node) == MESSAGING_DEVICE_PATH &&
297c54162e4SToomas Soome DevicePathSubType(node) == MSG_USB_DP) {
298c54162e4SToomas Soome efi_close_devpath(h);
299c54162e4SToomas Soome return (true);
300c54162e4SToomas Soome }
301c54162e4SToomas Soome
302c54162e4SToomas Soome parent = efi_devpath_trim(devpath);
303c54162e4SToomas Soome if (parent != NULL) {
304c54162e4SToomas Soome bool parent_is_usb = false;
305c54162e4SToomas Soome
306c54162e4SToomas Soome node = efi_devpath_last_node(parent);
307c54162e4SToomas Soome if (node == NULL) {
308c54162e4SToomas Soome free(parent);
309c54162e4SToomas Soome return (false);
310c54162e4SToomas Soome }
311c54162e4SToomas Soome if (DevicePathType(node) == MESSAGING_DEVICE_PATH &&
312c54162e4SToomas Soome DevicePathSubType(node) == MSG_USB_DP)
313c54162e4SToomas Soome parent_is_usb = true;
314c54162e4SToomas Soome free(parent);
315c54162e4SToomas Soome
316c54162e4SToomas Soome node = efi_devpath_last_node(devpath);
317c54162e4SToomas Soome if (node == NULL)
318c54162e4SToomas Soome return (false);
319c54162e4SToomas Soome if (parent_is_usb &&
3209d0a7db0SToomas Soome DevicePathType(node) == MESSAGING_DEVICE_PATH) {
3219d0a7db0SToomas Soome /*
3229d0a7db0SToomas Soome * no media, parent is USB and devicepath is
3239d0a7db0SToomas Soome * LUN or SCSI.
3249d0a7db0SToomas Soome */
3259d0a7db0SToomas Soome if (DevicePathSubType(node) ==
3269d0a7db0SToomas Soome MSG_DEVICE_LOGICAL_UNIT_DP ||
3279d0a7db0SToomas Soome DevicePathSubType(node) == MSG_SCSI_DP) {
3289d0a7db0SToomas Soome efi_close_devpath(h);
3299d0a7db0SToomas Soome return (true);
3309d0a7db0SToomas Soome }
331c54162e4SToomas Soome }
332c54162e4SToomas Soome }
333c54162e4SToomas Soome return (false);
334c54162e4SToomas Soome }
335c54162e4SToomas Soome
336c00b6c91SToomas Soome int
efipart_inithandles(void)337dbacaf56SToomas Soome efipart_inithandles(void)
338199767f8SToomas Soome {
33969764de3SToomas Soome uint_t i, nin;
340dbacaf56SToomas Soome EFI_HANDLE *hin;
3410f2f3e99SToomas Soome EFI_DEVICE_PATH *devpath;
3420f2f3e99SToomas Soome EFI_BLOCK_IO *blkio;
343dbacaf56SToomas Soome EFI_STATUS status;
3440f2f3e99SToomas Soome pdinfo_t *pd;
345dbacaf56SToomas Soome
3460f2f3e99SToomas Soome if (!STAILQ_EMPTY(&pdinfo))
3470f2f3e99SToomas Soome return (0);
348199767f8SToomas Soome
349*f334afcfSToomas Soome status = efi_get_protocol_handles(&gEfiBlockIoProtocolGuid, &nin, &hin);
350199767f8SToomas Soome if (EFI_ERROR(status))
351199767f8SToomas Soome return (efi_status_to_errno(status));
352199767f8SToomas Soome
353c00b6c91SToomas Soome #ifdef EFIPART_DEBUG
3540f2f3e99SToomas Soome printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
355c00b6c91SToomas Soome #endif
356dbacaf56SToomas Soome
357f58b22cfSToomas Soome for (i = 0; i < nin; i++) {
358f58b22cfSToomas Soome /*
3590f2f3e99SToomas Soome * Get devpath and open protocol.
3600f2f3e99SToomas Soome * We should not get errors here
361f58b22cfSToomas Soome */
3620f2f3e99SToomas Soome if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
3630f2f3e99SToomas Soome continue;
364f58b22cfSToomas Soome
365*f334afcfSToomas Soome status = OpenProtocolByHandle(hin[i], &gEfiBlockIoProtocolGuid,
366bf693dc9SToomas Soome (void **)&blkio);
3670f2f3e99SToomas Soome if (EFI_ERROR(status)) {
368*f334afcfSToomas Soome printf("error %lu\n", DECODE_ERROR(status));
3690f2f3e99SToomas Soome continue;
370f58b22cfSToomas Soome }
3716c6e04f2SToomas Soome
372c54162e4SToomas Soome if (efipart_ignore_device(hin[i], blkio, devpath))
3730f2f3e99SToomas Soome continue;
3742b292e00SToomas Soome
3750f2f3e99SToomas Soome /* This is bad. */
3760f2f3e99SToomas Soome if ((pd = calloc(1, sizeof (*pd))) == NULL) {
3770f2f3e99SToomas Soome printf("efipart_inithandles: Out of memory.\n");
3780f2f3e99SToomas Soome free(hin);
3790f2f3e99SToomas Soome return (ENOMEM);
3800f2f3e99SToomas Soome }
3810f2f3e99SToomas Soome STAILQ_INIT(&pd->pd_part);
382199767f8SToomas Soome
3830f2f3e99SToomas Soome pd->pd_handle = hin[i];
3840f2f3e99SToomas Soome pd->pd_devpath = devpath;
3850f2f3e99SToomas Soome pd->pd_blkio = blkio;
3860f2f3e99SToomas Soome STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
387dbacaf56SToomas Soome }
3880f2f3e99SToomas Soome
389c54162e4SToomas Soome /*
390c54162e4SToomas Soome * Walk pdinfo and set parents based on device path.
391c54162e4SToomas Soome */
392c54162e4SToomas Soome STAILQ_FOREACH(pd, &pdinfo, pd_link) {
393c54162e4SToomas Soome pd->pd_parent = efipart_find_parent(&pdinfo, pd->pd_devpath);
394c54162e4SToomas Soome }
3950f2f3e99SToomas Soome free(hin);
396dbacaf56SToomas Soome return (0);
397dbacaf56SToomas Soome }
398199767f8SToomas Soome
399c54162e4SToomas Soome /*
400c54162e4SToomas Soome * Get node identified by pd_test() from plist.
401c54162e4SToomas Soome */
402c54162e4SToomas Soome static pdinfo_t *
efipart_get_pd(pdinfo_list_t * plist,pd_test_cb_t pd_test,pdinfo_t * data)403c54162e4SToomas Soome efipart_get_pd(pdinfo_list_t *plist, pd_test_cb_t pd_test, pdinfo_t *data)
404c54162e4SToomas Soome {
405c54162e4SToomas Soome pdinfo_t *pd;
406c54162e4SToomas Soome
407c54162e4SToomas Soome STAILQ_FOREACH(pd, plist, pd_link) {
408c54162e4SToomas Soome if (pd_test(pd, data))
409c54162e4SToomas Soome break;
410c54162e4SToomas Soome }
411c54162e4SToomas Soome
412c54162e4SToomas Soome return (pd);
413c54162e4SToomas Soome }
414c54162e4SToomas Soome
4150f2f3e99SToomas Soome static ACPI_HID_DEVICE_PATH *
efipart_floppy(EFI_DEVICE_PATH * node)4160f2f3e99SToomas Soome efipart_floppy(EFI_DEVICE_PATH *node)
417dbacaf56SToomas Soome {
418dbacaf56SToomas Soome ACPI_HID_DEVICE_PATH *acpi;
419dbacaf56SToomas Soome
4200f2f3e99SToomas Soome if (DevicePathType(node) == ACPI_DEVICE_PATH &&
4210f2f3e99SToomas Soome DevicePathSubType(node) == ACPI_DP) {
4220f2f3e99SToomas Soome acpi = (ACPI_HID_DEVICE_PATH *) node;
4230f2f3e99SToomas Soome if (acpi->HID == EISA_PNP_ID(PNP0604) ||
4240f2f3e99SToomas Soome acpi->HID == EISA_PNP_ID(PNP0700) ||
4250f2f3e99SToomas Soome acpi->HID == EISA_PNP_ID(PNP0701)) {
4260f2f3e99SToomas Soome return (acpi);
427199767f8SToomas Soome }
428dbacaf56SToomas Soome }
4290f2f3e99SToomas Soome return (NULL);
4300f2f3e99SToomas Soome }
4310f2f3e99SToomas Soome
432c54162e4SToomas Soome static bool
efipart_testfd(pdinfo_t * fd,pdinfo_t * data __unused)433c54162e4SToomas Soome efipart_testfd(pdinfo_t *fd, pdinfo_t *data __unused)
4340f2f3e99SToomas Soome {
435c54162e4SToomas Soome EFI_DEVICE_PATH *node;
4360f2f3e99SToomas Soome
437c54162e4SToomas Soome node = efi_devpath_last_node(fd->pd_devpath);
438c54162e4SToomas Soome if (node == NULL)
439c54162e4SToomas Soome return (false);
440c54162e4SToomas Soome
441c54162e4SToomas Soome if (efipart_floppy(node) != NULL)
442c54162e4SToomas Soome return (true);
443c54162e4SToomas Soome
444c54162e4SToomas Soome return (false);
445dbacaf56SToomas Soome }
446199767f8SToomas Soome
447dbacaf56SToomas Soome static int
efipart_initfd(void)448dbacaf56SToomas Soome efipart_initfd(void)
449dbacaf56SToomas Soome {
4500f2f3e99SToomas Soome EFI_DEVICE_PATH *node;
4510f2f3e99SToomas Soome ACPI_HID_DEVICE_PATH *acpi;
4520f2f3e99SToomas Soome pdinfo_t *parent, *fd;
453dbacaf56SToomas Soome
454c54162e4SToomas Soome while ((fd = efipart_get_pd(&pdinfo, efipart_testfd, NULL)) != NULL) {
4550f2f3e99SToomas Soome if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
4560f2f3e99SToomas Soome continue;
457dbacaf56SToomas Soome
4580f2f3e99SToomas Soome if ((acpi = efipart_floppy(node)) == NULL)
4590f2f3e99SToomas Soome continue;
4600f2f3e99SToomas Soome
4610f2f3e99SToomas Soome STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
462c54162e4SToomas Soome parent = fd->pd_parent;
4630f2f3e99SToomas Soome if (parent != NULL) {
4640f2f3e99SToomas Soome STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
4650f2f3e99SToomas Soome parent->pd_alias = fd->pd_handle;
4660f2f3e99SToomas Soome parent->pd_unit = acpi->UID;
4670f2f3e99SToomas Soome free(fd);
4680f2f3e99SToomas Soome fd = parent;
4690f2f3e99SToomas Soome } else {
4700f2f3e99SToomas Soome fd->pd_unit = acpi->UID;
4710f2f3e99SToomas Soome }
4720f2f3e99SToomas Soome fd->pd_devsw = &efipart_fddev;
4730f2f3e99SToomas Soome STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
4740f2f3e99SToomas Soome }
475dbacaf56SToomas Soome
476dbacaf56SToomas Soome bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
477dbacaf56SToomas Soome return (0);
478dbacaf56SToomas Soome }
479dbacaf56SToomas Soome
480dbacaf56SToomas Soome /*
481dbacaf56SToomas Soome * Add or update entries with new handle data.
482dbacaf56SToomas Soome */
4830f2f3e99SToomas Soome static void
efipart_cdinfo_add(pdinfo_t * cd)4840f2f3e99SToomas Soome efipart_cdinfo_add(pdinfo_t *cd)
485dbacaf56SToomas Soome {
486c54162e4SToomas Soome pdinfo_t *parent, *pd, *last;
487c54162e4SToomas Soome
488c54162e4SToomas Soome if (cd == NULL)
489c54162e4SToomas Soome return;
490c54162e4SToomas Soome
491c54162e4SToomas Soome parent = cd->pd_parent;
492c54162e4SToomas Soome /* Make sure we have parent added */
493c54162e4SToomas Soome efipart_cdinfo_add(parent);
494c54162e4SToomas Soome
495c54162e4SToomas Soome STAILQ_FOREACH(pd, &pdinfo, pd_link) {
496c54162e4SToomas Soome if (efi_devpath_match(pd->pd_devpath, cd->pd_devpath)) {
497c54162e4SToomas Soome STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
498c54162e4SToomas Soome break;
499dbacaf56SToomas Soome }
500dbacaf56SToomas Soome }
501c54162e4SToomas Soome if (pd == NULL) {
502c54162e4SToomas Soome /* This device is already added. */
503c54162e4SToomas Soome return;
504c54162e4SToomas Soome }
505c54162e4SToomas Soome
506c54162e4SToomas Soome if (parent != NULL) {
507c54162e4SToomas Soome last = STAILQ_LAST(&parent->pd_part, pdinfo, pd_link);
508c54162e4SToomas Soome if (last != NULL)
509c54162e4SToomas Soome cd->pd_unit = last->pd_unit + 1;
510c54162e4SToomas Soome else
511c54162e4SToomas Soome cd->pd_unit = 0;
512c54162e4SToomas Soome cd->pd_devsw = &efipart_cddev;
513c54162e4SToomas Soome STAILQ_INSERT_TAIL(&parent->pd_part, cd, pd_link);
514c54162e4SToomas Soome return;
515c54162e4SToomas Soome }
516dbacaf56SToomas Soome
5170f2f3e99SToomas Soome last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
5180f2f3e99SToomas Soome if (last != NULL)
5190f2f3e99SToomas Soome cd->pd_unit = last->pd_unit + 1;
5200f2f3e99SToomas Soome else
5210f2f3e99SToomas Soome cd->pd_unit = 0;
522dbacaf56SToomas Soome
523e3026534SToomas Soome cd->pd_devsw = &efipart_cddev;
524dbacaf56SToomas Soome STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
5250f2f3e99SToomas Soome }
5260f2f3e99SToomas Soome
5270f2f3e99SToomas Soome static bool
efipart_testcd(pdinfo_t * cd,pdinfo_t * data __unused)528c54162e4SToomas Soome efipart_testcd(pdinfo_t *cd, pdinfo_t *data __unused)
5290f2f3e99SToomas Soome {
530c54162e4SToomas Soome EFI_DEVICE_PATH *node;
531c54162e4SToomas Soome
532c54162e4SToomas Soome node = efi_devpath_last_node(cd->pd_devpath);
533c54162e4SToomas Soome if (node == NULL)
534c54162e4SToomas Soome return (false);
535c54162e4SToomas Soome
536c54162e4SToomas Soome if (efipart_floppy(node) != NULL)
537c54162e4SToomas Soome return (false);
538c54162e4SToomas Soome
5390f2f3e99SToomas Soome if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
5400f2f3e99SToomas Soome DevicePathSubType(node) == MEDIA_CDROM_DP) {
5410f2f3e99SToomas Soome return (true);
5420f2f3e99SToomas Soome }
5430f2f3e99SToomas Soome
5440f2f3e99SToomas Soome /* cd drive without the media. */
545c54162e4SToomas Soome if (cd->pd_blkio->Media->RemovableMedia &&
546c54162e4SToomas Soome !cd->pd_blkio->Media->MediaPresent) {
5470f2f3e99SToomas Soome return (true);
5480f2f3e99SToomas Soome }
5490f2f3e99SToomas Soome
5500f2f3e99SToomas Soome return (false);
551dbacaf56SToomas Soome }
552dbacaf56SToomas Soome
553c54162e4SToomas Soome /*
554c54162e4SToomas Soome * Test if pd is parent for device.
555c54162e4SToomas Soome */
556c54162e4SToomas Soome static bool
efipart_testchild(pdinfo_t * dev,pdinfo_t * pd)557c54162e4SToomas Soome efipart_testchild(pdinfo_t *dev, pdinfo_t *pd)
558dbacaf56SToomas Soome {
559c54162e4SToomas Soome /* device with no parent. */
560c54162e4SToomas Soome if (dev->pd_parent == NULL)
561c54162e4SToomas Soome return (false);
562dbacaf56SToomas Soome
563c54162e4SToomas Soome if (efi_devpath_match(dev->pd_parent->pd_devpath, pd->pd_devpath)) {
564c54162e4SToomas Soome return (true);
565dbacaf56SToomas Soome }
566c54162e4SToomas Soome return (false);
567199767f8SToomas Soome }
568199767f8SToomas Soome
569199767f8SToomas Soome static int
efipart_initcd(void)570dbacaf56SToomas Soome efipart_initcd(void)
571199767f8SToomas Soome {
572c54162e4SToomas Soome pdinfo_t *cd;
573c54162e4SToomas Soome
574c54162e4SToomas Soome while ((cd = efipart_get_pd(&pdinfo, efipart_testcd, NULL)) != NULL)
575c54162e4SToomas Soome efipart_cdinfo_add(cd);
576dbacaf56SToomas Soome
577c54162e4SToomas Soome /* Find all children of CD devices we did add above. */
578c54162e4SToomas Soome STAILQ_FOREACH(cd, &cdinfo, pd_link) {
579c54162e4SToomas Soome pdinfo_t *child;
580c54162e4SToomas Soome
581c54162e4SToomas Soome for (child = efipart_get_pd(&pdinfo, efipart_testchild, cd);
582c54162e4SToomas Soome child != NULL;
583c54162e4SToomas Soome child = efipart_get_pd(&pdinfo, efipart_testchild, cd))
584c54162e4SToomas Soome efipart_cdinfo_add(child);
585c54162e4SToomas Soome }
586dbacaf56SToomas Soome bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
587dbacaf56SToomas Soome return (0);
588dbacaf56SToomas Soome }
589dbacaf56SToomas Soome
590c54162e4SToomas Soome static void
efipart_hdinfo_add_node(pdinfo_t * hd,EFI_DEVICE_PATH * node)59193d2b6f2SToomas Soome efipart_hdinfo_add_node(pdinfo_t *hd, EFI_DEVICE_PATH *node)
592dbacaf56SToomas Soome {
593c54162e4SToomas Soome pdinfo_t *parent, *ptr;
59493d2b6f2SToomas Soome
59593d2b6f2SToomas Soome if (node == NULL)
596c54162e4SToomas Soome return;
59793d2b6f2SToomas Soome
598c54162e4SToomas Soome parent = hd->pd_parent;
599c54162e4SToomas Soome /*
600c54162e4SToomas Soome * If the node is not MEDIA_HARDDRIVE_DP, it is sub-partition.
601c54162e4SToomas Soome * This can happen with Vendor nodes, and since we do not know
602c54162e4SToomas Soome * the more about those nodes, we just count them.
603c54162e4SToomas Soome */
60493d2b6f2SToomas Soome if (DevicePathSubType(node) != MEDIA_HARDDRIVE_DP) {
605c54162e4SToomas Soome ptr = STAILQ_LAST(&parent->pd_part, pdinfo, pd_link);
60693d2b6f2SToomas Soome if (ptr != NULL)
60793d2b6f2SToomas Soome hd->pd_unit = ptr->pd_unit + 1;
60893d2b6f2SToomas Soome else
60993d2b6f2SToomas Soome hd->pd_unit = 0;
61093d2b6f2SToomas Soome } else {
61193d2b6f2SToomas Soome hd->pd_unit = ((HARDDRIVE_DEVICE_PATH *)node)->PartitionNumber;
612dbacaf56SToomas Soome }
613dbacaf56SToomas Soome
614e3026534SToomas Soome hd->pd_devsw = &efipart_hddev;
615c54162e4SToomas Soome STAILQ_INSERT_TAIL(&parent->pd_part, hd, pd_link);
616dbacaf56SToomas Soome }
617dbacaf56SToomas Soome
618dbacaf56SToomas Soome /*
619dbacaf56SToomas Soome * The MEDIA_FILEPATH_DP has device name.
620dbacaf56SToomas Soome * From U-Boot sources it looks like names are in the form
621dbacaf56SToomas Soome * of typeN:M, where type is interface type, N is disk id
622dbacaf56SToomas Soome * and M is partition id.
623dbacaf56SToomas Soome */
6240f2f3e99SToomas Soome static void
efipart_hdinfo_add_filepath(pdinfo_t * hd,FILEPATH_DEVICE_PATH * node)6250f2f3e99SToomas Soome efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
626dbacaf56SToomas Soome {
627dbacaf56SToomas Soome char *pathname, *p;
6280f2f3e99SToomas Soome int len;
6290f2f3e99SToomas Soome pdinfo_t *last;
630dbacaf56SToomas Soome
631dbacaf56SToomas Soome last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
632dbacaf56SToomas Soome if (last != NULL)
6330f2f3e99SToomas Soome hd->pd_unit = last->pd_unit + 1;
634dbacaf56SToomas Soome else
6350f2f3e99SToomas Soome hd->pd_unit = 0;
636dbacaf56SToomas Soome
637dbacaf56SToomas Soome /* FILEPATH_DEVICE_PATH has 0 terminated string */
6381f54f0bbSToomas Soome len = ucs2len(node->PathName);
639dbacaf56SToomas Soome if ((pathname = malloc(len + 1)) == NULL) {
640dbacaf56SToomas Soome printf("Failed to add disk, out of memory\n");
6410f2f3e99SToomas Soome free(hd);
6420f2f3e99SToomas Soome return;
643dbacaf56SToomas Soome }
644dbacaf56SToomas Soome cpy16to8(node->PathName, pathname, len + 1);
645dbacaf56SToomas Soome p = strchr(pathname, ':');
646dbacaf56SToomas Soome
647dbacaf56SToomas Soome /*
648dbacaf56SToomas Soome * Assume we are receiving handles in order, first disk handle,
649dbacaf56SToomas Soome * then partitions for this disk. If this assumption proves
650dbacaf56SToomas Soome * false, this code would need update.
651dbacaf56SToomas Soome */
652dbacaf56SToomas Soome if (p == NULL) { /* no colon, add the disk */
6530f2f3e99SToomas Soome hd->pd_devsw = &efipart_hddev;
6540f2f3e99SToomas Soome STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
655dbacaf56SToomas Soome free(pathname);
6560f2f3e99SToomas Soome return;
657dbacaf56SToomas Soome }
658dbacaf56SToomas Soome p++; /* skip the colon */
659dbacaf56SToomas Soome errno = 0;
6600f2f3e99SToomas Soome hd->pd_unit = (int)strtol(p, NULL, 0);
661dbacaf56SToomas Soome if (errno != 0) {
662dbacaf56SToomas Soome printf("Bad unit number for partition \"%s\"\n", pathname);
663dbacaf56SToomas Soome free(pathname);
6640f2f3e99SToomas Soome free(hd);
6650f2f3e99SToomas Soome return;
666dbacaf56SToomas Soome }
667dbacaf56SToomas Soome
668dbacaf56SToomas Soome /*
669dbacaf56SToomas Soome * We should have disk registered, if not, we are receiving
670dbacaf56SToomas Soome * handles out of order, and this code should be reworked
671dbacaf56SToomas Soome * to create "blank" disk for partition, and to find the
672dbacaf56SToomas Soome * disk based on PathName compares.
673dbacaf56SToomas Soome */
674dbacaf56SToomas Soome if (last == NULL) {
675dbacaf56SToomas Soome printf("BUG: No disk for partition \"%s\"\n", pathname);
676dbacaf56SToomas Soome free(pathname);
6770f2f3e99SToomas Soome free(hd);
6780f2f3e99SToomas Soome return;
679dbacaf56SToomas Soome }
680dbacaf56SToomas Soome /* Add the partition. */
6810f2f3e99SToomas Soome hd->pd_parent = last;
6820f2f3e99SToomas Soome hd->pd_devsw = &efipart_hddev;
6830f2f3e99SToomas Soome STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
684dbacaf56SToomas Soome free(pathname);
685dbacaf56SToomas Soome }
686dbacaf56SToomas Soome
687dbacaf56SToomas Soome static void
efipart_hdinfo_add(pdinfo_t * hd)688c54162e4SToomas Soome efipart_hdinfo_add(pdinfo_t *hd)
689dbacaf56SToomas Soome {
690c54162e4SToomas Soome pdinfo_t *parent, *pd, *last;
691c54162e4SToomas Soome EFI_DEVICE_PATH *node;
692dbacaf56SToomas Soome
693c54162e4SToomas Soome if (hd == NULL)
694c54162e4SToomas Soome return;
695f58b22cfSToomas Soome
696c54162e4SToomas Soome parent = hd->pd_parent;
697c54162e4SToomas Soome /* Make sure we have parent added */
698c54162e4SToomas Soome efipart_hdinfo_add(parent);
699dbacaf56SToomas Soome
700c54162e4SToomas Soome STAILQ_FOREACH(pd, &pdinfo, pd_link) {
701c54162e4SToomas Soome if (efi_devpath_match(pd->pd_devpath, hd->pd_devpath)) {
7020f2f3e99SToomas Soome STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
703c54162e4SToomas Soome break;
7040f2f3e99SToomas Soome }
705c54162e4SToomas Soome }
706c54162e4SToomas Soome if (pd == NULL) {
707c54162e4SToomas Soome /* This device is already added. */
708c54162e4SToomas Soome return;
709c54162e4SToomas Soome }
710dbacaf56SToomas Soome
711c54162e4SToomas Soome if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
712c54162e4SToomas Soome return;
7130f2f3e99SToomas Soome
714c54162e4SToomas Soome if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
715c54162e4SToomas Soome DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
716c54162e4SToomas Soome efipart_hdinfo_add_filepath(hd,
717c54162e4SToomas Soome (FILEPATH_DEVICE_PATH *)node);
718c54162e4SToomas Soome return;
719c54162e4SToomas Soome }
720f58b22cfSToomas Soome
721c54162e4SToomas Soome if (parent != NULL) {
722c54162e4SToomas Soome efipart_hdinfo_add_node(hd, node);
723c54162e4SToomas Soome return;
724c54162e4SToomas Soome }
725f58b22cfSToomas Soome
726c54162e4SToomas Soome last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
727c54162e4SToomas Soome if (last != NULL)
728c54162e4SToomas Soome hd->pd_unit = last->pd_unit + 1;
729c54162e4SToomas Soome else
730c54162e4SToomas Soome hd->pd_unit = 0;
731f58b22cfSToomas Soome
732c54162e4SToomas Soome /* Add the disk. */
733c54162e4SToomas Soome hd->pd_devsw = &efipart_hddev;
734c54162e4SToomas Soome STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
735c54162e4SToomas Soome }
7360f2f3e99SToomas Soome
737c54162e4SToomas Soome static bool
efipart_testhd(pdinfo_t * hd,pdinfo_t * data __unused)738c54162e4SToomas Soome efipart_testhd(pdinfo_t *hd, pdinfo_t *data __unused)
739c54162e4SToomas Soome {
740c54162e4SToomas Soome if (efipart_testfd(hd, NULL))
741c54162e4SToomas Soome return (false);
7420f2f3e99SToomas Soome
743c54162e4SToomas Soome if (efipart_testcd(hd, NULL))
744c54162e4SToomas Soome return (false);
745dbacaf56SToomas Soome
746c54162e4SToomas Soome /* Anything else must be HD. */
747c54162e4SToomas Soome return (true);
748dbacaf56SToomas Soome }
749dbacaf56SToomas Soome
750dbacaf56SToomas Soome static int
efipart_inithd(void)751dbacaf56SToomas Soome efipart_inithd(void)
752dbacaf56SToomas Soome {
753c54162e4SToomas Soome pdinfo_t *hd;
754dbacaf56SToomas Soome
755c54162e4SToomas Soome while ((hd = efipart_get_pd(&pdinfo, efipart_testhd, NULL)) != NULL)
756c54162e4SToomas Soome efipart_hdinfo_add(hd);
757dbacaf56SToomas Soome
758dbacaf56SToomas Soome bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
759dbacaf56SToomas Soome return (0);
760dbacaf56SToomas Soome }
761dbacaf56SToomas Soome
762dbacaf56SToomas Soome static int
efipart_print_common(struct devsw * dev,pdinfo_list_t * pdlist,int verbose)763dbacaf56SToomas Soome efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
764dbacaf56SToomas Soome {
765199767f8SToomas Soome int ret = 0;
766dbacaf56SToomas Soome EFI_BLOCK_IO *blkio;
767dbacaf56SToomas Soome EFI_STATUS status;
768dbacaf56SToomas Soome EFI_HANDLE h;
769dbacaf56SToomas Soome pdinfo_t *pd;
770dbacaf56SToomas Soome CHAR16 *text;
771dbacaf56SToomas Soome struct disk_devdesc pd_dev;
772dbacaf56SToomas Soome char line[80];
773dbacaf56SToomas Soome
774dbacaf56SToomas Soome if (STAILQ_EMPTY(pdlist))
775dbacaf56SToomas Soome return (0);
776199767f8SToomas Soome
777dbacaf56SToomas Soome printf("%s devices:", dev->dv_name);
778502b33a5SToomas Soome if ((ret = pager_output("\n")) != 0)
779502b33a5SToomas Soome return (ret);
780502b33a5SToomas Soome
781dbacaf56SToomas Soome STAILQ_FOREACH(pd, pdlist, pd_link) {
782dbacaf56SToomas Soome h = pd->pd_handle;
783dbacaf56SToomas Soome if (verbose) { /* Output the device path. */
784dbacaf56SToomas Soome text = efi_devpath_name(efi_lookup_devpath(h));
785dbacaf56SToomas Soome if (text != NULL) {
786dbacaf56SToomas Soome printf(" %S", text);
787dbacaf56SToomas Soome efi_free_devpath_name(text);
788dbacaf56SToomas Soome if ((ret = pager_output("\n")) != 0)
789dbacaf56SToomas Soome break;
790dbacaf56SToomas Soome }
791dbacaf56SToomas Soome }
7920f2f3e99SToomas Soome snprintf(line, sizeof (line),
793dbacaf56SToomas Soome " %s%d", dev->dv_name, pd->pd_unit);
794dbacaf56SToomas Soome printf("%s:", line);
795*f334afcfSToomas Soome status = OpenProtocolByHandle(h, &gEfiBlockIoProtocolGuid,
796*f334afcfSToomas Soome (void **)&blkio);
797199767f8SToomas Soome if (!EFI_ERROR(status)) {
798dbacaf56SToomas Soome printf(" %llu",
799dbacaf56SToomas Soome blkio->Media->LastBlock == 0? 0:
800dbacaf56SToomas Soome (unsigned long long) (blkio->Media->LastBlock + 1));
801dbacaf56SToomas Soome if (blkio->Media->LastBlock != 0) {
802dbacaf56SToomas Soome printf(" X %u", blkio->Media->BlockSize);
803dbacaf56SToomas Soome }
804dbacaf56SToomas Soome printf(" blocks");
805dbacaf56SToomas Soome if (blkio->Media->MediaPresent) {
806dbacaf56SToomas Soome if (blkio->Media->RemovableMedia)
807dbacaf56SToomas Soome printf(" (removable)");
808dbacaf56SToomas Soome } else {
809dbacaf56SToomas Soome printf(" (no media)");
810dbacaf56SToomas Soome }
811dbacaf56SToomas Soome if ((ret = pager_output("\n")) != 0)
812dbacaf56SToomas Soome break;
813dbacaf56SToomas Soome if (!blkio->Media->MediaPresent)
814dbacaf56SToomas Soome continue;
815dbacaf56SToomas Soome
816dbacaf56SToomas Soome pd->pd_blkio = blkio;
81776b35943SToomas Soome pd_dev.dd.d_dev = dev;
81876b35943SToomas Soome pd_dev.dd.d_unit = pd->pd_unit;
8199a34674dSToomas Soome pd_dev.d_slice = D_SLICENONE;
8209a34674dSToomas Soome pd_dev.d_partition = D_PARTNONE;
821dbacaf56SToomas Soome ret = disk_open(&pd_dev, blkio->Media->BlockSize *
822dbacaf56SToomas Soome (blkio->Media->LastBlock + 1),
823dbacaf56SToomas Soome blkio->Media->BlockSize);
824dbacaf56SToomas Soome if (ret == 0) {
825dbacaf56SToomas Soome ret = disk_print(&pd_dev, line, verbose);
826dbacaf56SToomas Soome disk_close(&pd_dev);
827dbacaf56SToomas Soome if (ret != 0)
828dbacaf56SToomas Soome return (ret);
829dbacaf56SToomas Soome } else {
830dbacaf56SToomas Soome /* Do not fail from disk_open() */
831dbacaf56SToomas Soome ret = 0;
832dbacaf56SToomas Soome }
833dbacaf56SToomas Soome } else {
834dbacaf56SToomas Soome if ((ret = pager_output("\n")) != 0)
835dbacaf56SToomas Soome break;
836199767f8SToomas Soome }
837199767f8SToomas Soome }
838199767f8SToomas Soome return (ret);
839199767f8SToomas Soome }
840199767f8SToomas Soome
841dbacaf56SToomas Soome static int
efipart_printfd(int verbose)842dbacaf56SToomas Soome efipart_printfd(int verbose)
843dbacaf56SToomas Soome {
844dbacaf56SToomas Soome return (efipart_print_common(&efipart_fddev, &fdinfo, verbose));
845dbacaf56SToomas Soome }
846dbacaf56SToomas Soome
847dbacaf56SToomas Soome static int
efipart_printcd(int verbose)848dbacaf56SToomas Soome efipart_printcd(int verbose)
849dbacaf56SToomas Soome {
850dbacaf56SToomas Soome return (efipart_print_common(&efipart_cddev, &cdinfo, verbose));
851dbacaf56SToomas Soome }
852dbacaf56SToomas Soome
853dbacaf56SToomas Soome static int
efipart_printhd(int verbose)854dbacaf56SToomas Soome efipart_printhd(int verbose)
855dbacaf56SToomas Soome {
856dbacaf56SToomas Soome return (efipart_print_common(&efipart_hddev, &hdinfo, verbose));
857dbacaf56SToomas Soome }
858dbacaf56SToomas Soome
859199767f8SToomas Soome static int
efipart_open(struct open_file * f,...)860199767f8SToomas Soome efipart_open(struct open_file *f, ...)
861199767f8SToomas Soome {
862199767f8SToomas Soome va_list args;
863dbacaf56SToomas Soome struct disk_devdesc *dev;
864dbacaf56SToomas Soome pdinfo_t *pd;
865199767f8SToomas Soome EFI_BLOCK_IO *blkio;
866199767f8SToomas Soome EFI_STATUS status;
867199767f8SToomas Soome
868199767f8SToomas Soome va_start(args, f);
8690f2f3e99SToomas Soome dev = va_arg(args, struct disk_devdesc *);
870199767f8SToomas Soome va_end(args);
871dbacaf56SToomas Soome if (dev == NULL)
872dbacaf56SToomas Soome return (EINVAL);
873199767f8SToomas Soome
874eea30b26SToomas Soome pd = efiblk_get_pdinfo((struct devdesc *)dev);
875dbacaf56SToomas Soome if (pd == NULL)
8760f2f3e99SToomas Soome return (EIO);
877dbacaf56SToomas Soome
878dbacaf56SToomas Soome if (pd->pd_blkio == NULL) {
879*f334afcfSToomas Soome status = OpenProtocolByHandle(pd->pd_handle,
880*f334afcfSToomas Soome &gEfiBlockIoProtocolGuid,
881dbacaf56SToomas Soome (void **)&pd->pd_blkio);
882dbacaf56SToomas Soome if (EFI_ERROR(status))
883dbacaf56SToomas Soome return (efi_status_to_errno(status));
884dbacaf56SToomas Soome }
885199767f8SToomas Soome
886dbacaf56SToomas Soome blkio = pd->pd_blkio;
887199767f8SToomas Soome if (!blkio->Media->MediaPresent)
888199767f8SToomas Soome return (EAGAIN);
889199767f8SToomas Soome
890dbacaf56SToomas Soome pd->pd_open++;
891dbacaf56SToomas Soome if (pd->pd_bcache == NULL)
892dbacaf56SToomas Soome pd->pd_bcache = bcache_allocate();
893dbacaf56SToomas Soome
89476b35943SToomas Soome if (dev->dd.d_dev->dv_type == DEVT_DISK) {
895dbacaf56SToomas Soome int rc;
896dbacaf56SToomas Soome
897dbacaf56SToomas Soome rc = disk_open(dev,
898dbacaf56SToomas Soome blkio->Media->BlockSize * (blkio->Media->LastBlock + 1),
899dbacaf56SToomas Soome blkio->Media->BlockSize);
900dbacaf56SToomas Soome if (rc != 0) {
901dbacaf56SToomas Soome pd->pd_open--;
902dbacaf56SToomas Soome if (pd->pd_open == 0) {
903dbacaf56SToomas Soome pd->pd_blkio = NULL;
904dbacaf56SToomas Soome bcache_free(pd->pd_bcache);
905dbacaf56SToomas Soome pd->pd_bcache = NULL;
906dbacaf56SToomas Soome }
907dbacaf56SToomas Soome }
908dbacaf56SToomas Soome return (rc);
909dbacaf56SToomas Soome }
910199767f8SToomas Soome return (0);
911199767f8SToomas Soome }
912199767f8SToomas Soome
913199767f8SToomas Soome static int
efipart_close(struct open_file * f)914199767f8SToomas Soome efipart_close(struct open_file *f)
915199767f8SToomas Soome {
916dbacaf56SToomas Soome struct disk_devdesc *dev;
917dbacaf56SToomas Soome pdinfo_t *pd;
918199767f8SToomas Soome
919dbacaf56SToomas Soome dev = (struct disk_devdesc *)(f->f_devdata);
920dbacaf56SToomas Soome if (dev == NULL)
921dbacaf56SToomas Soome return (EINVAL);
922dbacaf56SToomas Soome
923eea30b26SToomas Soome pd = efiblk_get_pdinfo((struct devdesc *)dev);
924dbacaf56SToomas Soome if (pd == NULL)
925199767f8SToomas Soome return (EINVAL);
926199767f8SToomas Soome
927dbacaf56SToomas Soome pd->pd_open--;
928dbacaf56SToomas Soome if (pd->pd_open == 0) {
929dbacaf56SToomas Soome pd->pd_blkio = NULL;
930dbacaf56SToomas Soome bcache_free(pd->pd_bcache);
931dbacaf56SToomas Soome pd->pd_bcache = NULL;
932199767f8SToomas Soome }
93376b35943SToomas Soome if (dev->dd.d_dev->dv_type == DEVT_DISK)
934dbacaf56SToomas Soome return (disk_close(dev));
935199767f8SToomas Soome return (0);
936199767f8SToomas Soome }
937199767f8SToomas Soome
938edb35047SToomas Soome static int
efipart_ioctl(struct open_file * f,unsigned long cmd,void * data)9390f2f3e99SToomas Soome efipart_ioctl(struct open_file *f, unsigned long cmd, void *data)
940edb35047SToomas Soome {
941dbacaf56SToomas Soome struct disk_devdesc *dev;
942dbacaf56SToomas Soome pdinfo_t *pd;
943dbacaf56SToomas Soome int rc;
944edb35047SToomas Soome
945dbacaf56SToomas Soome dev = (struct disk_devdesc *)(f->f_devdata);
946dbacaf56SToomas Soome if (dev == NULL)
947edb35047SToomas Soome return (EINVAL);
948dbacaf56SToomas Soome
949eea30b26SToomas Soome pd = efiblk_get_pdinfo((struct devdesc *)dev);
950dbacaf56SToomas Soome if (pd == NULL)
951dbacaf56SToomas Soome return (EINVAL);
952dbacaf56SToomas Soome
95376b35943SToomas Soome if (dev->dd.d_dev->dv_type == DEVT_DISK) {
954dbacaf56SToomas Soome rc = disk_ioctl(dev, cmd, data);
955dbacaf56SToomas Soome if (rc != ENOTTY)
956dbacaf56SToomas Soome return (rc);
957dbacaf56SToomas Soome }
958edb35047SToomas Soome
959edb35047SToomas Soome switch (cmd) {
960edb35047SToomas Soome case DIOCGSECTORSIZE:
9610f2f3e99SToomas Soome *(uint_t *)data = pd->pd_blkio->Media->BlockSize;
962edb35047SToomas Soome break;
963edb35047SToomas Soome case DIOCGMEDIASIZE:
964dbacaf56SToomas Soome *(uint64_t *)data = pd->pd_blkio->Media->BlockSize *
965dbacaf56SToomas Soome (pd->pd_blkio->Media->LastBlock + 1);
966edb35047SToomas Soome break;
967edb35047SToomas Soome default:
968edb35047SToomas Soome return (ENOTTY);
969edb35047SToomas Soome }
970edb35047SToomas Soome
971edb35047SToomas Soome return (0);
972edb35047SToomas Soome }
973edb35047SToomas Soome
974199767f8SToomas Soome /*
975199767f8SToomas Soome * efipart_readwrite()
976199767f8SToomas Soome * Internal equivalent of efipart_strategy(), which operates on the
977199767f8SToomas Soome * media-native block size. This function expects all I/O requests
978199767f8SToomas Soome * to be within the media size and returns an error if such is not
979199767f8SToomas Soome * the case.
980199767f8SToomas Soome */
981199767f8SToomas Soome static int
efipart_readwrite(EFI_BLOCK_IO * blkio,int rw,daddr_t blk,daddr_t nblks,char * buf)982199767f8SToomas Soome efipart_readwrite(EFI_BLOCK_IO *blkio, int rw, daddr_t blk, daddr_t nblks,
983199767f8SToomas Soome char *buf)
984199767f8SToomas Soome {
985199767f8SToomas Soome EFI_STATUS status;
986199767f8SToomas Soome
987199767f8SToomas Soome if (blkio == NULL)
988199767f8SToomas Soome return (ENXIO);
989199767f8SToomas Soome if (blk < 0 || blk > blkio->Media->LastBlock)
990199767f8SToomas Soome return (EIO);
991199767f8SToomas Soome if ((blk + nblks - 1) > blkio->Media->LastBlock)
992199767f8SToomas Soome return (EIO);
993199767f8SToomas Soome
9943dab2501SToomas Soome switch (rw & F_MASK) {
995199767f8SToomas Soome case F_READ:
996199767f8SToomas Soome status = blkio->ReadBlocks(blkio, blkio->Media->MediaId, blk,
997199767f8SToomas Soome nblks * blkio->Media->BlockSize, buf);
998199767f8SToomas Soome break;
999199767f8SToomas Soome case F_WRITE:
1000199767f8SToomas Soome if (blkio->Media->ReadOnly)
1001199767f8SToomas Soome return (EROFS);
1002199767f8SToomas Soome status = blkio->WriteBlocks(blkio, blkio->Media->MediaId, blk,
1003199767f8SToomas Soome nblks * blkio->Media->BlockSize, buf);
1004199767f8SToomas Soome break;
1005199767f8SToomas Soome default:
1006199767f8SToomas Soome return (ENOSYS);
1007199767f8SToomas Soome }
1008199767f8SToomas Soome
1009dbacaf56SToomas Soome if (EFI_ERROR(status)) {
1010dbacaf56SToomas Soome printf("%s: rw=%d, blk=%ju size=%ju status=%lu\n", __func__, rw,
1011*f334afcfSToomas Soome blk, nblks, DECODE_ERROR(status));
1012dbacaf56SToomas Soome }
1013199767f8SToomas Soome return (efi_status_to_errno(status));
1014199767f8SToomas Soome }
1015199767f8SToomas Soome
1016199767f8SToomas Soome static int
efipart_strategy(void * devdata,int rw,daddr_t blk,size_t size,char * buf,size_t * rsize)101738dea910SToomas Soome efipart_strategy(void *devdata, int rw, daddr_t blk, size_t size,
101838dea910SToomas Soome char *buf, size_t *rsize)
1019199767f8SToomas Soome {
1020199767f8SToomas Soome struct bcache_devdata bcd;
1021dbacaf56SToomas Soome struct disk_devdesc *dev;
1022dbacaf56SToomas Soome pdinfo_t *pd;
1023dbacaf56SToomas Soome
1024dbacaf56SToomas Soome dev = (struct disk_devdesc *)devdata;
1025dbacaf56SToomas Soome if (dev == NULL)
1026dbacaf56SToomas Soome return (EINVAL);
1027dbacaf56SToomas Soome
1028eea30b26SToomas Soome pd = efiblk_get_pdinfo((struct devdesc *)dev);
1029dbacaf56SToomas Soome if (pd == NULL)
1030dbacaf56SToomas Soome return (EINVAL);
1031dbacaf56SToomas Soome
1032dbacaf56SToomas Soome if (pd->pd_blkio->Media->RemovableMedia &&
1033dbacaf56SToomas Soome !pd->pd_blkio->Media->MediaPresent)
1034dbacaf56SToomas Soome return (ENXIO);
1035199767f8SToomas Soome
1036199767f8SToomas Soome bcd.dv_strategy = efipart_realstrategy;
1037199767f8SToomas Soome bcd.dv_devdata = devdata;
1038dbacaf56SToomas Soome bcd.dv_cache = pd->pd_bcache;
1039dbacaf56SToomas Soome
104076b35943SToomas Soome if (dev->dd.d_dev->dv_type == DEVT_DISK) {
1041da5223b9SToomas Soome daddr_t offset;
1042da5223b9SToomas Soome
1043da5223b9SToomas Soome offset = dev->d_offset * pd->pd_blkio->Media->BlockSize;
1044da5223b9SToomas Soome offset /= 512;
1045da5223b9SToomas Soome return (bcache_strategy(&bcd, rw, blk + offset,
1046dbacaf56SToomas Soome size, buf, rsize));
1047dbacaf56SToomas Soome }
104838dea910SToomas Soome return (bcache_strategy(&bcd, rw, blk, size, buf, rsize));
1049199767f8SToomas Soome }
1050199767f8SToomas Soome
1051199767f8SToomas Soome static int
efipart_realstrategy(void * devdata,int rw,daddr_t blk,size_t size,char * buf,size_t * rsize)105238dea910SToomas Soome efipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
105338dea910SToomas Soome char *buf, size_t *rsize)
1054199767f8SToomas Soome {
1055dbacaf56SToomas Soome struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
1056dbacaf56SToomas Soome pdinfo_t *pd;
1057199767f8SToomas Soome EFI_BLOCK_IO *blkio;
1058dbacaf56SToomas Soome uint64_t off, disk_blocks, d_offset = 0;
1059199767f8SToomas Soome char *blkbuf;
10602b292e00SToomas Soome size_t blkoff, blksz, bio_size;
10612b292e00SToomas Soome unsigned ioalign;
10622b292e00SToomas Soome bool need_buf;
10632b292e00SToomas Soome int rc;
1064dbacaf56SToomas Soome uint64_t diskend, readstart;
1065199767f8SToomas Soome
1066199767f8SToomas Soome if (dev == NULL || blk < 0)
1067199767f8SToomas Soome return (EINVAL);
1068199767f8SToomas Soome
1069eea30b26SToomas Soome pd = efiblk_get_pdinfo((struct devdesc *)dev);
1070dbacaf56SToomas Soome if (pd == NULL)
1071dbacaf56SToomas Soome return (EINVAL);
1072dbacaf56SToomas Soome
1073dbacaf56SToomas Soome blkio = pd->pd_blkio;
1074199767f8SToomas Soome if (blkio == NULL)
1075199767f8SToomas Soome return (ENXIO);
1076199767f8SToomas Soome
1077199767f8SToomas Soome if (size == 0 || (size % 512) != 0)
1078199767f8SToomas Soome return (EIO);
1079199767f8SToomas Soome
1080199767f8SToomas Soome off = blk * 512;
1081dbacaf56SToomas Soome /*
1082dbacaf56SToomas Soome * Get disk blocks, this value is either for whole disk or for
1083dbacaf56SToomas Soome * partition.
1084dbacaf56SToomas Soome */
1085dbacaf56SToomas Soome disk_blocks = 0;
108676b35943SToomas Soome if (dev->dd.d_dev->dv_type == DEVT_DISK) {
1087dbacaf56SToomas Soome if (disk_ioctl(dev, DIOCGMEDIASIZE, &disk_blocks) == 0) {
1088dbacaf56SToomas Soome /* DIOCGMEDIASIZE does return bytes. */
1089dbacaf56SToomas Soome disk_blocks /= blkio->Media->BlockSize;
1090dbacaf56SToomas Soome }
1091dbacaf56SToomas Soome d_offset = dev->d_offset;
1092dbacaf56SToomas Soome }
1093dbacaf56SToomas Soome if (disk_blocks == 0)
1094dbacaf56SToomas Soome disk_blocks = blkio->Media->LastBlock + 1 - d_offset;
1095dbacaf56SToomas Soome
1096199767f8SToomas Soome /* make sure we don't read past disk end */
1097dbacaf56SToomas Soome if ((off + size) / blkio->Media->BlockSize > d_offset + disk_blocks) {
1098dbacaf56SToomas Soome diskend = d_offset + disk_blocks;
1099dbacaf56SToomas Soome readstart = off / blkio->Media->BlockSize;
1100dbacaf56SToomas Soome
1101dbacaf56SToomas Soome if (diskend <= readstart) {
1102dbacaf56SToomas Soome if (rsize != NULL)
1103dbacaf56SToomas Soome *rsize = 0;
1104dbacaf56SToomas Soome
1105dbacaf56SToomas Soome return (EIO);
1106dbacaf56SToomas Soome }
1107dbacaf56SToomas Soome size = diskend - readstart;
1108199767f8SToomas Soome size = size * blkio->Media->BlockSize;
1109199767f8SToomas Soome }
1110199767f8SToomas Soome
11112b292e00SToomas Soome need_buf = true;
11122b292e00SToomas Soome /* Do we need bounce buffer? */
1113a5f66292SToomas Soome if ((size % blkio->Media->BlockSize == 0) &&
1114a5f66292SToomas Soome (off % blkio->Media->BlockSize == 0))
11152b292e00SToomas Soome need_buf = false;
11162b292e00SToomas Soome
11172b292e00SToomas Soome /* Do we have IO alignment requirement? */
11182b292e00SToomas Soome ioalign = blkio->Media->IoAlign;
11192b292e00SToomas Soome if (ioalign == 0)
11202b292e00SToomas Soome ioalign++;
11212b292e00SToomas Soome
11222b292e00SToomas Soome if (ioalign > 1 && (uintptr_t)buf != roundup2((uintptr_t)buf, ioalign))
11232b292e00SToomas Soome need_buf = true;
11242b292e00SToomas Soome
11252b292e00SToomas Soome if (need_buf) {
11262b292e00SToomas Soome for (bio_size = BIO_BUFFER_SIZE; bio_size > 0;
11272b292e00SToomas Soome bio_size -= blkio->Media->BlockSize) {
11282b292e00SToomas Soome blkbuf = memalign(ioalign, bio_size);
11292b292e00SToomas Soome if (blkbuf != NULL)
11302b292e00SToomas Soome break;
11312b292e00SToomas Soome }
11322b292e00SToomas Soome } else {
11332b292e00SToomas Soome blkbuf = buf;
11342b292e00SToomas Soome bio_size = size;
11352b292e00SToomas Soome }
1136199767f8SToomas Soome
1137199767f8SToomas Soome if (blkbuf == NULL)
1138199767f8SToomas Soome return (ENOMEM);
1139199767f8SToomas Soome
11402b292e00SToomas Soome if (rsize != NULL)
11412b292e00SToomas Soome *rsize = size;
11422b292e00SToomas Soome
11432b292e00SToomas Soome rc = 0;
1144199767f8SToomas Soome blk = off / blkio->Media->BlockSize;
1145199767f8SToomas Soome blkoff = off % blkio->Media->BlockSize;
11462b292e00SToomas Soome
1147199767f8SToomas Soome while (size > 0) {
11482b292e00SToomas Soome size_t x = min(size, bio_size);
11492b292e00SToomas Soome
11502b292e00SToomas Soome if (x < blkio->Media->BlockSize)
11512b292e00SToomas Soome x = 1;
11522b292e00SToomas Soome else
11532b292e00SToomas Soome x /= blkio->Media->BlockSize;
11542b292e00SToomas Soome
11552b292e00SToomas Soome switch (rw & F_MASK) {
11562b292e00SToomas Soome case F_READ:
11572b292e00SToomas Soome blksz = blkio->Media->BlockSize * x - blkoff;
11582b292e00SToomas Soome if (size < blksz)
11592b292e00SToomas Soome blksz = size;
11602b292e00SToomas Soome
11612b292e00SToomas Soome rc = efipart_readwrite(blkio, rw, blk, x, blkbuf);
11622b292e00SToomas Soome if (rc != 0)
11632b292e00SToomas Soome goto error;
11642b292e00SToomas Soome
11652b292e00SToomas Soome if (need_buf)
11662b292e00SToomas Soome bcopy(blkbuf + blkoff, buf, blksz);
1167199767f8SToomas Soome break;
11682b292e00SToomas Soome case F_WRITE:
11692b292e00SToomas Soome rc = 0;
11702b292e00SToomas Soome if (blkoff != 0) {
11712b292e00SToomas Soome /*
11722b292e00SToomas Soome * We got offset to sector, read 1 sector to
11732b292e00SToomas Soome * blkbuf.
11742b292e00SToomas Soome */
11752b292e00SToomas Soome x = 1;
11762b292e00SToomas Soome blksz = blkio->Media->BlockSize - blkoff;
11772b292e00SToomas Soome blksz = min(blksz, size);
11782b292e00SToomas Soome rc = efipart_readwrite(blkio, F_READ, blk, x,
11792b292e00SToomas Soome blkbuf);
11802b292e00SToomas Soome } else if (size < blkio->Media->BlockSize) {
11812b292e00SToomas Soome /*
11822b292e00SToomas Soome * The remaining block is not full
11832b292e00SToomas Soome * sector. Read 1 sector to blkbuf.
11842b292e00SToomas Soome */
11852b292e00SToomas Soome x = 1;
11862b292e00SToomas Soome blksz = size;
11872b292e00SToomas Soome rc = efipart_readwrite(blkio, F_READ, blk, x,
11882b292e00SToomas Soome blkbuf);
11892b292e00SToomas Soome } else {
11902b292e00SToomas Soome /* We can write full sector(s). */
11912b292e00SToomas Soome blksz = blkio->Media->BlockSize * x;
11922b292e00SToomas Soome }
11932b292e00SToomas Soome
11942b292e00SToomas Soome if (rc != 0)
11952b292e00SToomas Soome goto error;
11962b292e00SToomas Soome /*
11972b292e00SToomas Soome * Put your Data In, Put your Data out,
11982b292e00SToomas Soome * Put your Data In, and shake it all about
11992b292e00SToomas Soome */
12002b292e00SToomas Soome if (need_buf)
12012b292e00SToomas Soome bcopy(buf, blkbuf + blkoff, blksz);
12022b292e00SToomas Soome rc = efipart_readwrite(blkio, F_WRITE, blk, x, blkbuf);
12032b292e00SToomas Soome if (rc != 0)
12042b292e00SToomas Soome goto error;
12052b292e00SToomas Soome break;
12062b292e00SToomas Soome default:
12072b292e00SToomas Soome /* DO NOTHING */
12082b292e00SToomas Soome rc = EROFS;
12092b292e00SToomas Soome goto error;
12102b292e00SToomas Soome }
12112b292e00SToomas Soome
12122b292e00SToomas Soome blkoff = 0;
1213199767f8SToomas Soome buf += blksz;
1214199767f8SToomas Soome size -= blksz;
12152b292e00SToomas Soome blk += x;
1216199767f8SToomas Soome }
1217199767f8SToomas Soome
12182b292e00SToomas Soome error:
12192b292e00SToomas Soome if (rsize != NULL)
12202b292e00SToomas Soome *rsize -= size;
12212b292e00SToomas Soome
12222b292e00SToomas Soome if (need_buf)
12232b292e00SToomas Soome free(blkbuf);
12242b292e00SToomas Soome return (rc);
1225199767f8SToomas Soome }
1226