1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 1999 Jonathan Lemon
5 * Copyright (c) 1999 Michael Smith
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD$");
33
34/*
35 * Disk driver for Mylex DAC960 RAID adapters.
36 */
37
38#include <sys/param.h>
39#include <sys/systm.h>
40#include <sys/bio.h>
41#include <sys/kernel.h>
42#include <sys/lock.h>
43#include <sys/module.h>
44#include <sys/sx.h>
45
46#include <sys/bus.h>
47#include <sys/conf.h>
48
49#include <machine/bus.h>
50#include <sys/rman.h>
51
52#include <geom/geom_disk.h>
53
54#include <dev/mlx/mlxio.h>
55#include <dev/mlx/mlxvar.h>
56#include <dev/mlx/mlxreg.h>
57
58/* prototypes */
59static int mlxd_probe(device_t dev);
60static int mlxd_attach(device_t dev);
61static int mlxd_detach(device_t dev);
62
63devclass_t		mlxd_devclass;
64
65static device_method_t mlxd_methods[] = {
66    DEVMETHOD(device_probe,	mlxd_probe),
67    DEVMETHOD(device_attach,	mlxd_attach),
68    DEVMETHOD(device_detach,	mlxd_detach),
69    { 0, 0 }
70};
71
72static driver_t mlxd_driver = {
73    "mlxd",
74    mlxd_methods,
75    sizeof(struct mlxd_softc)
76};
77
78DRIVER_MODULE(mlxd, mlx, mlxd_driver, mlxd_devclass, 0, 0);
79
80static int
81mlxd_open(struct disk *dp)
82{
83    struct mlxd_softc	*sc = (struct mlxd_softc *)dp->d_drv1;
84
85    debug_called(1);
86
87    if (sc == NULL)
88	return (ENXIO);
89
90    /* controller not active? */
91    MLX_CONFIG_LOCK(sc->mlxd_controller);
92    MLX_IO_LOCK(sc->mlxd_controller);
93    if (sc->mlxd_controller->mlx_state & MLX_STATE_SHUTDOWN) {
94	MLX_IO_UNLOCK(sc->mlxd_controller);
95	MLX_CONFIG_UNLOCK(sc->mlxd_controller);
96	return(ENXIO);
97    }
98
99    sc->mlxd_flags |= MLXD_OPEN;
100    MLX_IO_UNLOCK(sc->mlxd_controller);
101    MLX_CONFIG_UNLOCK(sc->mlxd_controller);
102    return (0);
103}
104
105static int
106mlxd_close(struct disk *dp)
107{
108    struct mlxd_softc	*sc = (struct mlxd_softc *)dp->d_drv1;
109
110    debug_called(1);
111
112    if (sc == NULL)
113	return (ENXIO);
114    MLX_CONFIG_LOCK(sc->mlxd_controller);
115    MLX_IO_LOCK(sc->mlxd_controller);
116    sc->mlxd_flags &= ~MLXD_OPEN;
117    MLX_IO_UNLOCK(sc->mlxd_controller);
118    MLX_CONFIG_UNLOCK(sc->mlxd_controller);
119    return (0);
120}
121
122static int
123mlxd_ioctl(struct disk *dp, u_long cmd, void *addr, int flag, struct thread *td)
124{
125    struct mlxd_softc	*sc = (struct mlxd_softc *)dp->d_drv1;
126    int error;
127
128    debug_called(1);
129
130    if (sc == NULL)
131	return (ENXIO);
132
133    if ((error = mlx_submit_ioctl(sc->mlxd_controller, sc->mlxd_drive, cmd, addr, flag, td)) != ENOIOCTL) {
134	debug(0, "mlx_submit_ioctl returned %d\n", error);
135	return(error);
136    }
137    return (ENOTTY);
138}
139
140/*
141 * Read/write routine for a buffer.  Finds the proper unit, range checks
142 * arguments, and schedules the transfer.  Does not wait for the transfer
143 * to complete.  Multi-page transfers are supported.  All I/O requests must
144 * be a multiple of a sector in length.
145 */
146static void
147mlxd_strategy(struct bio *bp)
148{
149    struct mlxd_softc	*sc = bp->bio_disk->d_drv1;
150
151    debug_called(1);
152
153    /* bogus disk? */
154    if (sc == NULL) {
155	bp->bio_error = EINVAL;
156	bp->bio_flags |= BIO_ERROR;
157	goto bad;
158    }
159
160    if ((bp->bio_cmd != BIO_READ) && (bp->bio_cmd != BIO_WRITE)) {
161	bp->bio_error = EOPNOTSUPP;
162	goto bad;
163    }
164
165    /* XXX may only be temporarily offline - sleep? */
166    MLX_IO_LOCK(sc->mlxd_controller);
167    if (sc->mlxd_drive->ms_state == MLX_SYSD_OFFLINE) {
168	MLX_IO_UNLOCK(sc->mlxd_controller);
169	bp->bio_error = ENXIO;
170	bp->bio_flags |= BIO_ERROR;
171	goto bad;
172    }
173
174    mlx_submit_buf(sc->mlxd_controller, bp);
175    MLX_IO_UNLOCK(sc->mlxd_controller);
176    return;
177
178 bad:
179    /*
180     * Correctly set the bio to indicate a failed transfer.
181     */
182    bp->bio_resid = bp->bio_bcount;
183    biodone(bp);
184    return;
185}
186
187void
188mlxd_intr(struct bio *bp)
189{
190
191    debug_called(1);
192
193    if (bp->bio_flags & BIO_ERROR)
194	bp->bio_error = EIO;
195    else
196	bp->bio_resid = 0;
197
198    biodone(bp);
199}
200
201static int
202mlxd_probe(device_t dev)
203{
204
205    debug_called(1);
206
207    device_set_desc(dev, "Mylex System Drive");
208    return (0);
209}
210
211static int
212mlxd_attach(device_t dev)
213{
214    struct mlxd_softc	*sc = (struct mlxd_softc *)device_get_softc(dev);
215    device_t		parent;
216    char		*state;
217    int			s1, s2;
218
219    debug_called(1);
220
221    parent = device_get_parent(dev);
222    sc->mlxd_controller = (struct mlx_softc *)device_get_softc(parent);
223    sc->mlxd_unit = device_get_unit(dev);
224    sc->mlxd_drive = device_get_ivars(dev);
225    sc->mlxd_dev = dev;
226
227    switch(sc->mlxd_drive->ms_state) {
228    case MLX_SYSD_ONLINE:
229	state = "online";
230	break;
231    case MLX_SYSD_CRITICAL:
232	state = "critical";
233	break;
234    case MLX_SYSD_OFFLINE:
235	state = "offline";
236	break;
237    default:
238	state = "unknown state";
239    }
240
241    device_printf(dev, "%uMB (%u sectors) RAID %d (%s)\n",
242		  sc->mlxd_drive->ms_size / ((1024 * 1024) / MLX_BLKSIZE),
243		  sc->mlxd_drive->ms_size, sc->mlxd_drive->ms_raidlevel, state);
244
245    sc->mlxd_disk = disk_alloc();
246    sc->mlxd_disk->d_open = mlxd_open;
247    sc->mlxd_disk->d_close = mlxd_close;
248    sc->mlxd_disk->d_ioctl = mlxd_ioctl;
249    sc->mlxd_disk->d_strategy = mlxd_strategy;
250    sc->mlxd_disk->d_name = "mlxd";
251    sc->mlxd_disk->d_unit = sc->mlxd_unit;
252    sc->mlxd_disk->d_drv1 = sc;
253    sc->mlxd_disk->d_sectorsize = MLX_BLKSIZE;
254    sc->mlxd_disk->d_mediasize = MLX_BLKSIZE * (off_t)sc->mlxd_drive->ms_size;
255    sc->mlxd_disk->d_fwsectors = sc->mlxd_drive->ms_sectors;
256    sc->mlxd_disk->d_fwheads = sc->mlxd_drive->ms_heads;
257
258    /*
259     * Set maximum I/O size to the lesser of the recommended maximum and the practical
260     * maximum except on v2 cards where the maximum is set to 8 pages.
261     */
262    if (sc->mlxd_controller->mlx_iftype == MLX_IFTYPE_2)
263	sc->mlxd_disk->d_maxsize = 8 * MLX_PAGE_SIZE;
264    else {
265	s1 = sc->mlxd_controller->mlx_enq2->me_maxblk * MLX_BLKSIZE;
266	s2 = (sc->mlxd_controller->mlx_enq2->me_max_sg - 1) * MLX_PAGE_SIZE;
267	sc->mlxd_disk->d_maxsize = imin(s1, s2);
268    }
269
270    disk_create(sc->mlxd_disk, DISK_VERSION);
271
272    return (0);
273}
274
275static int
276mlxd_detach(device_t dev)
277{
278    struct mlxd_softc *sc = (struct mlxd_softc *)device_get_softc(dev);
279
280    debug_called(1);
281
282    disk_destroy(sc->mlxd_disk);
283
284    return(0);
285}
286
287