FreeBSD/Linux Kernel Cross Reference
sys/pci/simos.c
1 /*-
2 * Copyright (c) 1998 Doug Rabson
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 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: releng/5.0/sys/pci/simos.c 103592 2002-09-19 03:40:17Z peter $
27 */
28
29 #ifdef COMPILING_LINT
30 #warning "The simos driver is broken and is not compiled with LINT"
31 #else
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/malloc.h>
36 #include <sys/bio.h>
37 #include <sys/buf.h>
38 #include <sys/proc.h>
39
40 #include <cam/cam.h>
41 #include <cam/cam_ccb.h>
42 #include <cam/cam_sim.h>
43 #include <cam/cam_xpt_sim.h>
44 #include <cam/cam_debug.h>
45
46 #include <cam/scsi/scsi_all.h>
47 #include <cam/scsi/scsi_message.h>
48
49 #include <machine/clock.h>
50 #include <vm/vm.h>
51 #include <vm/vm_param.h>
52 #include <vm/pmap.h>
53 #include <sys/kernel.h>
54
55 #include <pci/simos.h>
56
57 #include <pci/pcireg.h>
58 #include <pci/pcivar.h>
59
60 #ifndef COMPAT_OLDPCI
61 #error "The simos device requires the old pci compatibility shims"
62 #endif
63
64 #include <machine/alpha_cpu.h>
65
66 struct simos_softc {
67 int sc_unit;
68 SimOS_SCSI* sc_regs;
69
70 /*
71 * SimOS only supports one pending command.
72 */
73 struct cam_sim *sc_sim;
74 struct cam_path *sc_path;
75 struct ccb_scsiio *sc_pending;
76 };
77
78 struct simos_softc* simosp[10];
79
80 static u_long simos_unit;
81
82 static const char *simos_probe(pcici_t tag, pcidi_t type);
83 static void simos_attach(pcici_t config_d, int unit);
84 static void simos_action(struct cam_sim *sim, union ccb *ccb);
85 static void simos_poll(struct cam_sim *sim);
86
87 struct pci_device simos_driver = {
88 "simos",
89 simos_probe,
90 simos_attach,
91 &simos_unit,
92 NULL
93 };
94 COMPAT_PCI_DRIVER (simos, simos_driver);
95
96 static const char *
97 simos_probe(pcici_t tag, pcidi_t type)
98 {
99 switch (type) {
100 case 0x1291|(0x1291<<16):
101 return "SimOS SCSI";
102 default:
103 return NULL;
104 }
105
106 }
107
108 static void
109 simos_attach(pcici_t config_id, int unit)
110 {
111 struct simos_softc* sc;
112 struct cam_devq *devq;
113
114 sc = malloc(sizeof(struct simos_softc), M_DEVBUF, M_WAITOK | M_ZERO);
115 simosp[unit] = sc;
116
117 sc->sc_unit = unit;
118 sc->sc_regs = (SimOS_SCSI*) SIMOS_SCSI_ADDR;
119 sc->sc_pending = 0;
120
121 devq = cam_simq_alloc(/*maxopenings*/1);
122 if (devq == NULL)
123 return;
124
125 sc->sc_sim = cam_sim_alloc(simos_action, simos_poll, "simos", sc, unit,
126 /*untagged*/1, /*tagged*/0, devq);
127 if (sc->sc_sim == NULL) {
128 cam_simq_free(devq);
129 return;
130 }
131
132 if (xpt_bus_register(sc->sc_sim, /*bus*/0) != CAM_SUCCESS) {
133 cam_sim_free(sc->sc_sim, /*free_devq*/TRUE);
134 return;
135 }
136
137 if (xpt_create_path(&sc->sc_path, /*periph*/NULL,
138 cam_sim_path(sc->sc_sim), CAM_TARGET_WILDCARD,
139 CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
140 xpt_bus_deregister(cam_sim_path(sc->sc_sim));
141 cam_sim_free(sc->sc_sim, /*free_devq*/TRUE);
142 return;
143 }
144
145 alpha_register_pci_scsi(config_id->bus, config_id->slot, sc->sc_sim);
146
147 return;
148 }
149
150 static void
151 simos_start(struct simos_softc* sc, struct ccb_scsiio *csio)
152 {
153 struct scsi_generic *cmd;
154 int cmdlen;
155 caddr_t data;
156 int datalen;
157 int s;
158 u_int8_t* p;
159 int i, count, target;
160 vm_offset_t va;
161 vm_size_t size;
162
163 cmd = (struct scsi_generic *) &csio->cdb_io.cdb_bytes;
164 cmdlen = csio->cdb_len;
165 data = csio->data_ptr;
166 datalen = csio->dxfer_len;
167
168 /*
169 * Simos doesn't understand some commands
170 */
171 if (cmd->opcode == START_STOP || cmd->opcode == PREVENT_ALLOW
172 || cmd->opcode == SYNCHRONIZE_CACHE) {
173 csio->ccb_h.status = CAM_REQ_CMP;
174 xpt_done((union ccb *) csio);
175 return;
176 }
177
178 if (sc->sc_pending) {
179 /*
180 * Don't think this can happen.
181 */
182 printf("simos_start: can't start command while one is pending\n");
183 csio->ccb_h.status = CAM_BUSY;
184 xpt_done((union ccb *) csio);
185 return;
186 }
187
188 s = splcam();
189
190 csio->ccb_h.status |= CAM_SIM_QUEUED;
191 sc->sc_pending = csio;
192
193 target = csio->ccb_h.target_id;
194
195 /*
196 * Copy the command into SimOS' buffer
197 */
198 p = (u_int8_t*) cmd;
199 count = cmdlen;
200 for (i = 0; i < count; i++)
201 sc->sc_regs->cmd[i] = *p++;
202 sc->sc_regs->length = count;
203 sc->sc_regs->target = target;
204 sc->sc_regs->lun = csio->ccb_h.target_lun;
205
206 /*
207 * Setup the segment descriptors.
208 */
209 va = (vm_offset_t) data;
210 size = datalen;
211 i = 0;
212 while (size > 0) {
213 vm_size_t len = PAGE_SIZE - (va & PAGE_MASK);
214 if (len > size)
215 len = size;
216 sc->sc_regs->sgMap[i].pAddr = vtophys(va);
217 sc->sc_regs->sgMap[i].len = len;
218 size -= len;
219 va += len;
220 i++;
221 }
222 sc->sc_regs->sgLen = i;
223
224 /*
225 * Start the i/o.
226 */
227 alpha_wmb();
228 sc->sc_regs->startIO = 1;
229 alpha_wmb();
230
231 splx(s);
232 }
233
234 static void
235 simos_done(struct simos_softc* sc)
236 {
237 struct ccb_scsiio* csio = sc->sc_pending;
238 int s, done;
239
240 /*
241 * Spurious interrupt caused by my bogus interrupt broadcasting.
242 */
243 if (!csio)
244 return;
245
246 sc->sc_pending = 0;
247
248 done = sc->sc_regs->done[csio->ccb_h.target_id];
249 if (!done)
250 return;
251
252 s = splcam();
253
254 if (done >> 16)
255 /* Error detected */
256 csio->ccb_h.status = CAM_CMD_TIMEOUT;
257 else
258 csio->ccb_h.status = CAM_REQ_CMP;
259
260 /*
261 * Ack the interrupt to clear it.
262 */
263 sc->sc_regs->done[csio->ccb_h.target_id] = 1;
264 alpha_wmb();
265
266 xpt_done((union ccb *) csio);
267
268 splx(s);
269 }
270
271 static void
272 simos_action(struct cam_sim *sim, union ccb *ccb)
273 {
274 struct simos_softc* sc = (struct simos_softc *)sim->softc;
275
276 switch (ccb->ccb_h.func_code) {
277 case XPT_SCSI_IO:
278 {
279 struct ccb_scsiio *csio;
280
281 csio = &ccb->csio;
282 simos_start(sc, csio);
283 break;
284 }
285
286 case XPT_CALC_GEOMETRY:
287 {
288 struct ccb_calc_geometry *ccg;
289 u_int32_t size_mb;
290 u_int32_t secs_per_cylinder;
291
292 ccg = &ccb->ccg;
293 size_mb = ccg->volume_size
294 / ((1024L * 1024L) / ccg->block_size);
295
296 ccg->heads = 64;
297 ccg->secs_per_track = 32;
298
299 secs_per_cylinder = ccg->heads * ccg->secs_per_track;
300 ccg->cylinders = ccg->volume_size / secs_per_cylinder;
301
302 ccb->ccb_h.status = CAM_REQ_CMP;
303 xpt_done(ccb);
304 break;
305 }
306
307 case XPT_RESET_BUS:
308 {
309 ccb->ccb_h.status = CAM_REQ_CMP;
310 xpt_done(ccb);
311 break;
312 }
313
314 case XPT_PATH_INQ:
315 {
316 struct ccb_pathinq *cpi = &ccb->cpi;
317
318 cpi->version_num = 1; /* XXX??? */
319 cpi->max_target = 2;
320 cpi->max_lun = 0;
321 cpi->initiator_id = 7;
322 cpi->bus_id = sim->bus_id;
323 cpi->base_transfer_speed = 3300;
324 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
325 strncpy(cpi->hba_vid, "SimOS", HBA_IDLEN);
326 strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
327 cpi->unit_number = sim->unit_number;
328
329 cpi->ccb_h.status = CAM_REQ_CMP;
330 xpt_done(ccb);
331 break;
332 }
333
334 default:
335 ccb->ccb_h.status = CAM_REQ_INVALID;
336 xpt_done(ccb);
337 break;
338 }
339 }
340
341 static void
342 simos_poll(struct cam_sim *sim)
343 {
344 simos_done(cam_sim_softc(sim));
345 }
346
347 void
348 simos_intr(int unit)
349 {
350 /* XXX bogus */
351 struct simos_softc* sc = simosp[unit];
352
353 simos_done(sc);
354 }
355
356
357 #endif /* !COMPILING_LINT */
Cache object: c38a0a6067b4280ee95d2eb2239fd3d8
|