FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/ld_cac.c
1 /* $NetBSD: ld_cac.c,v 1.22.4.2 2009/03/24 20:48:14 snj Exp $ */
2
3 /*-
4 * Copyright (c) 2000, 2006 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Compaq array controller front-end for ld(4) driver.
34 */
35
36 #include <sys/cdefs.h>
37 __KERNEL_RCSID(0, "$NetBSD: ld_cac.c,v 1.22.4.2 2009/03/24 20:48:14 snj Exp $");
38
39 #include "rnd.h"
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
44 #include <sys/device.h>
45 #include <sys/buf.h>
46 #include <sys/bufq.h>
47 #include <sys/endian.h>
48 #include <sys/dkio.h>
49 #include <sys/disk.h>
50 #if NRND > 0
51 #include <sys/rnd.h>
52 #endif
53
54 #include <sys/bus.h>
55
56 #include <dev/ldvar.h>
57
58 #include <dev/ic/cacreg.h>
59 #include <dev/ic/cacvar.h>
60
61 struct ld_cac_softc {
62 struct ld_softc sc_ld;
63 kmutex_t *sc_mutex;
64 int sc_hwunit;
65 int sc_serrcnt;
66 struct timeval sc_serrtm;
67 };
68
69 void ld_cac_attach(device_t, device_t, void *);
70 void ld_cac_done(device_t, void *, int);
71 int ld_cac_dump(struct ld_softc *, void *, int, int);
72 int ld_cac_match(device_t, cfdata_t, void *);
73 int ld_cac_start(struct ld_softc *, struct buf *);
74
75 static const struct timeval ld_cac_serrintvl = { 60, 0 };
76
77 CFATTACH_DECL_NEW(ld_cac, sizeof(struct ld_cac_softc),
78 ld_cac_match, ld_cac_attach, NULL, NULL);
79
80 int
81 ld_cac_match(device_t parent, cfdata_t match, void *aux)
82 {
83
84 return (1);
85 }
86
87 void
88 ld_cac_attach(device_t parent, device_t self, void *aux)
89 {
90 struct cac_drive_info dinfo;
91 struct cac_attach_args *caca;
92 struct ld_cac_softc *sc = device_private(self);
93 struct cac_softc *cac = device_private(parent);
94 struct ld_softc *ld = &sc->sc_ld;
95 const char *type;
96
97 caca = aux;
98 ld->sc_dv = self;
99 sc->sc_mutex = &cac->sc_mutex;
100 sc->sc_hwunit = caca->caca_unit;
101
102 if (cac_cmd(cac, CAC_CMD_GET_LOG_DRV_INFO, &dinfo, sizeof(dinfo),
103 sc->sc_hwunit, 0, CAC_CCB_DATA_IN, NULL)) {
104 aprint_error(": CMD_GET_LOG_DRV_INFO failed\n");
105 return;
106 }
107
108 ld->sc_secsize = CAC_GET2(dinfo.secsize);
109 ld->sc_maxxfer = CAC_MAX_XFER;
110 ld->sc_maxqueuecnt = CAC_MAX_CCBS / cac->sc_nunits; /* XXX */
111 ld->sc_secperunit = CAC_GET2(dinfo.ncylinders) *
112 CAC_GET1(dinfo.nheads) * CAC_GET1(dinfo.nsectors);
113 ld->sc_start = ld_cac_start;
114 ld->sc_dump = ld_cac_dump;
115
116 switch (CAC_GET1(dinfo.mirror)) {
117 case 0:
118 type = "standalone disk or RAID0";
119 break;
120 case 1:
121 type = "RAID4";
122 break;
123 case 2:
124 type = "RAID1";
125 break;
126 case 3:
127 type = "RAID5";
128 break;
129 default:
130 type = "unknown type of";
131 break;
132 }
133
134 aprint_normal(": %s array\n", type);
135
136 /* XXX We should verify this... */
137 ld->sc_flags = LDF_ENABLED;
138 ldattach(ld);
139 }
140
141 int
142 ld_cac_start(struct ld_softc *ld, struct buf *bp)
143 {
144 int flags, cmd;
145 struct cac_softc *cac;
146 struct ld_cac_softc *sc;
147 struct cac_context cc;
148
149 sc = (struct ld_cac_softc *)ld;
150 cac = device_private(device_parent(ld->sc_dv));
151
152 cc.cc_handler = ld_cac_done;
153 cc.cc_context = bp;
154 cc.cc_dv = ld->sc_dv;
155
156 if ((bp->b_flags & B_READ) == 0) {
157 cmd = CAC_CMD_WRITE;
158 flags = CAC_CCB_DATA_OUT;
159 } else {
160 cmd = CAC_CMD_READ;
161 flags = CAC_CCB_DATA_IN;
162 }
163
164 return (cac_cmd(cac, cmd, bp->b_data, bp->b_bcount, sc->sc_hwunit,
165 bp->b_rawblkno, flags, &cc));
166 }
167
168 int
169 ld_cac_dump(struct ld_softc *ld, void *data, int blkno, int blkcnt)
170 {
171 struct ld_cac_softc *sc;
172
173 sc = (struct ld_cac_softc *)ld;
174
175 return (cac_cmd(device_private(device_parent(ld->sc_dv)),
176 CAC_CMD_WRITE_MEDIA, data, blkcnt * ld->sc_secsize,
177 sc->sc_hwunit, blkno, CAC_CCB_DATA_OUT, NULL));
178 }
179
180 void
181 ld_cac_done(struct device *dv, void *context, int error)
182 {
183 struct buf *bp;
184 struct ld_cac_softc *sc;
185 int rv;
186
187 bp = context;
188 rv = 0;
189 sc = device_private(dv);
190
191 if ((error & CAC_RET_CMD_REJECTED) == CAC_RET_CMD_REJECTED) {
192 aprint_error_dev(dv, "command rejected\n");
193 rv = EIO;
194 }
195 if (rv == 0 && (error & CAC_RET_INVAL_BLOCK) != 0) {
196 aprint_error_dev(dv, "invalid request block\n");
197 rv = EIO;
198 }
199 if (rv == 0 && (error & CAC_RET_HARD_ERROR) != 0) {
200 aprint_error_dev(dv, "hard error\n");
201 rv = EIO;
202 }
203 if (rv == 0 && (error & CAC_RET_SOFT_ERROR) != 0) {
204 sc->sc_serrcnt++;
205 if (ratecheck(&sc->sc_serrtm, &ld_cac_serrintvl)) {
206 sc->sc_serrcnt = 0;
207 aprint_error_dev(dv,
208 "%d soft errors; array may be degraded\n",
209 sc->sc_serrcnt);
210 }
211 }
212
213 if (rv) {
214 bp->b_error = rv;
215 bp->b_resid = bp->b_bcount;
216 } else
217 bp->b_resid = 0;
218
219 mutex_exit(sc->sc_mutex);
220 lddone(&sc->sc_ld, bp);
221 mutex_enter(sc->sc_mutex);
222 }
Cache object: e027fd6716ce62ae162ac8af231eeb64
|