The cam_sim structure was being deallocated unconditionally by device
[dragonfly.git] / sys / dev / disk / i386 / bs / bsif.c
CommitLineData
984263bc
MD
1/* $NecBSD: bsif.c,v 1.6 1997/10/31 17:43:40 honda Exp $ */
2/*
3 * Copyright (c) HONDA Naofumi, KATO Takenori, 1996. 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 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer as
11 * the first lines of this file unmodified.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * $FreeBSD: src/sys/i386/isa/bs/bsif.c,v 1.10.2.1 2000/08/24 08:06:08 kato Exp $
3aed1355 30 * $DragonFly: src/sys/dev/disk/i386/bs/Attic/bsif.c,v 1.6 2004/03/15 01:10:43 dillon Exp $
984263bc
MD
31 */
32
33#if 0
34/* WARNING: Any bug report must contain BS_REL_VERSION */
35#define BS_REL_VERSION "NetBSD1.2/030" /* major jump */
36#endif
37
38#ifdef __NetBSD__
39#include <i386/Cbus/dev/bs/bsif.h>
40#endif /* __NetBSD__ */
84754cd0 41#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
42#include "opt_bs.h"
43#include "opt_pc98.h"
44#include "bs.h"
1f2de5d4 45#include "bsif.h"
984263bc
MD
46#endif /* __FreeBSD__ */
47
1f2de5d4
MD
48#include <bus/cam/cam.h>
49#include <bus/cam/cam_ccb.h>
50#include <bus/cam/cam_sim.h>
51#include <bus/cam/cam_xpt_sim.h>
52#include <bus/cam/cam_debug.h>
984263bc 53
1f2de5d4
MD
54#include <bus/cam/scsi/scsi_all.h>
55#include <bus/cam/scsi/scsi_message.h>
984263bc
MD
56
57/**************************************************
58 * DEVICE DECLARE
59 **************************************************/
60#ifdef __NetBSD__
38e94a25 61static void bs_scsi_minphys (struct buf *);
984263bc
MD
62
63struct cfdriver bs_cd = {
64 NULL, "bs", DV_DULL
65};
66
67struct scsi_device bs_dev = {
68 NULL, /* Use default error handler */
69 NULL, /* have a queue, served by this */
70 NULL, /* have no async handler */
71 NULL, /* Use default 'done' routine */
72};
73
74struct scsi_adapter pc98texa55bs = {
75 bs_scsi_cmd,
76 bs_scsi_minphys,
77 bs_target_open,
78 0,
79};
80#endif /* __NetBSD__ */
81
84754cd0 82#if defined(__DragonFly__) || defined(__FreeBSD__)
38e94a25 83static int bsprobe (struct isa_device *);
984263bc
MD
84static void bs_poll(struct cam_sim *sim);
85static int bsattach(struct isa_device *);
86static ointhand2_t bsintr;
38e94a25 87static int bs_dmarangecheck (caddr_t, unsigned);
984263bc
MD
88
89struct isa_driver bsdriver = {
90 bsprobe,
91 bsattach,
92 "bs"
93};
94#if 0
95struct scsi_device bs_dev = {
96 NULL, /* Use default error handler */
97 NULL, /* have a queue, served by this */
98 NULL, /* have no async handler */
99 NULL, /* Use default 'done' routine */
100 "bs",
101 0, {0, 0}
102};
103#endif
104u_int32_t
105bs_adapter_info(unit)
106 int unit;
107{
108 return (1);
109}
110#if 0
111static struct scsi_adapter pc98texa55bs = {
112 bs_scsi_cmd,
113 bs_scsi_minphys,
114 bs_target_open,
115 0,
116 bs_adapter_info,
117 "bs", {0, 0}
118};
119#endif
120static u_short pc98_irq_ball[16] = {
121 IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, IRQ6, IRQ7,
122 IRQ8, IRQ9, IRQ10, IRQ11, IRQ12, IRQ13, IRQ14, IRQ15
123};
124
125static struct bs_softc *bscdata[NBS];
126#endif /* __FreeBSD__ */
127
128/*****************************************************************
129 * OS <=> BS INTERFACE
130 *****************************************************************/
84754cd0 131#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
132static int
133bsprobe(dev)
134 struct isa_device *dev;
135{
136 struct bs_softc *bsc;
137 int unit = dev->id_unit;
138 u_int irq, drq;
139 int i, rv = 0;
140
141 if (unit >= NBS) {
142 printf("bs%d: unit number too high\n", unit);
143 return rv;
144 }
145 /*
146 * Allocate a storage for us
147 */
148 if (bscdata[unit]) {
149 printf("bs%d: memory already allocated\n", unit);
150 return rv;
151 }
3aed1355 152 bsc = malloc(sizeof(struct bs_softc), M_TEMP, M_WAITOK | M_ZERO);
984263bc
MD
153 callout_handle_init(&bsc->timeout_ch);
154 bscdata[unit] = bsc;
155 bsc->unit = unit;
156
157 bsc->sc_cfgflags = DVCFG_MINOR(dev->id_flags);
158 bsc->sc_hw = DVCFG_HW(&bshw_hwsel, DVCFG_MAJOR(dev->id_flags));
159 if (bsc->sc_hw == NULL)
160 return rv;
161
162 if ((bsc->sc_hw->hw_flags & BSHW_SMFIFO) &&
163 (dev->id_maddr != (caddr_t)MADDRUNK))
164 bsc->sm_offset = (u_long) dev->id_maddr;
165 else
166 bsc->sm_offset = (u_long) 0;
167
168 snprintf(bsc->sc_dvname, sizeof(bsc->sc_dvname), "bs%d", unit);
169
170 if (dev->id_iobase == 0)
171 {
172 printf("%s: iobase not specified. Assume default port(0x%x)\n",
173 bsc->sc_dvname, BSHW_DEFAULT_PORT);
174 dev->id_iobase = BSHW_DEFAULT_PORT;
175 }
176
177 bsc->sc_iobase = dev->id_iobase;
178 irq = IRQUNK;
179 drq = DRQUNK;
180 if (bshw_board_probe(bsc, &drq, &irq))
181 goto bad;
182
183 dev->id_irq = pc98_irq_ball[irq];
184 dev->id_drq = (short)drq;
185
186 /* initialize host queue and target info */
187 bs_hostque_init(bsc);
188 for (i = 0; i < NTARGETS; i++)
189 if (i != bsc->sc_hostid)
190 bs_init_target_info(bsc, i);
191
192 /* initialize ccb queue */
193 bs_init_ccbque(BS_MAX_CCB);
194
195 /* scsi bus reset and restart */
196 bsc->sc_hstate = BSC_BOOTUP;
197 bsc->sc_retry = RETRIES;
198 bsc->sc_wc = delaycount * 250; /* about 1 sec */
199 bs_reset_nexus(bsc);
200
201 return BSHW_IOSZ;
202bad:
203 return rv;
204}
205#endif /* __FreeBSD__ */
206
207#ifdef __NetBSD__
208int
209bsprint(aux, name)
210 void *aux;
211 const char *name;
212{
213
214 if (name != NULL)
215 printf("%s: scsibus ", name);
216 return UNCONF;
217}
218#endif
219
84754cd0 220#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
221static void
222bs_poll(struct cam_sim *sim)
223{
224 bs_sequencer(cam_sim_softc(sim));
225}
226
227static int
228bsattach(dev)
229 struct isa_device *dev;
230{
231 int unit = dev->id_unit;
232 struct bs_softc *bsc = bscdata[unit];
233 struct cam_devq *devq;
234
235 dev->id_ointr = bsintr;
236
237 /*
238 * CAM support HN2 MAX_START, MAX_TAGS xxxx
239 */
240 devq = cam_simq_alloc(256/*MAX_START*/);
241 if (devq == NULL)
242 return 0;
243
244 bsc->sim = cam_sim_alloc(bs_scsi_cmd, bs_poll, "bs",
245 bsc, unit, 1, 32/*MAX_TAGS*/, devq);
3aed1355
MD
246 cam_simq_release(devq);
247 if (bsc->sim == NULL)
984263bc 248 return 0;
984263bc
MD
249
250 if (xpt_bus_register(bsc->sim, 0) != CAM_SUCCESS) {
251 free(bsc->sim, M_DEVBUF);
252 return 0;
253 }
254
255 if (xpt_create_path(&bsc->path, /*periph*/NULL,
256 cam_sim_path(bsc->sim), CAM_TARGET_WILDCARD,
257 CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
258 xpt_bus_deregister(cam_sim_path(bsc->sim));
3aed1355 259 cam_sim_free(bsc->sim);
984263bc
MD
260 free(bsc->sim, M_DEVBUF);
261 return 0;
262 }
263 bs_start_timeout(bsc);
264 return 1;
265}
266#endif /* __FreeBSD__ */
267
268#ifdef __NetBSD__
269int
270bsintr(arg)
271 void *arg;
272{
273
274 return bs_sequencer((struct bs_softc *)arg);
275}
276#endif /* __NetBSD__ */
277
84754cd0 278#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
279static void
280bsintr(unit)
281 int unit;
282{
283 (void)bs_sequencer(bscdata[unit]);
284}
285#endif /* __FreeBSD__ */
286
287/*****************************************************************
288 * JULIAN SCSI <=> BS INTERFACE
289 *****************************************************************/
84754cd0 290#if !defined(__DragonFly__) && !defined(__FreeBSD__)
984263bc
MD
291static void
292bs_scsi_minphys(bp)
293 struct buf *bp;
294{
295
296 if (bp->b_bcount > BSDMABUFSIZ)
297 bp->b_bcount = BSDMABUFSIZ;
298 minphys(bp);
299}
300#endif
301#if 0
302XSBS_INT32T
303bs_target_open(sc, cf)
304 struct scsi_link *sc;
305 struct cfdata *cf;
306{
307 u_int target = sc->target;
308 struct bs_softc *bsc = (struct bs_softc *) (sc->adapter_softc);
309 struct targ_info *ti = bsc->sc_ti[target];
310 u_int flags;
311
312 if ((bsc->sc_openf & (1 << target)) == 0)
313 return ENODEV;
314
315 if ((flags = cf->cf_flags) == 0)
316 flags = BS_SCSI_DEFCFG;
317
318 bs_setup_ctrl(ti, (u_int)sc->quirks, flags);
319 return 0;
320}
321#endif
322/*****************************************************************
323 * BS MEMORY ALLOCATION INTERFACE
324 *****************************************************************/
325#ifdef __NetBSD__
326void
327bs_alloc_buf(ti)
328 struct targ_info *ti;
329{
330 struct bs_softc *bsc = ti->ti_bsc;
331 caddr_t addr, physaddr;
332 bus_dma_segment_t seg;
333 int rseg, error;
334 u_int pages;
335 extern int cold;
336
337 /* XXX:
338 * strategy change!
339 * A) total memory >= 16M at boot: MAXBSIZE * 7 = 112k.
340 * B) others: 4K * 7 = 28 K.
341 */
342 if (get_sysinfo(SYSINFO_MEMLEVEL) == MEM_LEVEL1 && cold != 0)
343 pages = 4;
344 else
345 pages = 1;
346 ti->bounce_size = NBPG * pages;
347
348 addr = NULL;
349 error = bus_dmamem_alloc(bsc->sc_dmat, ti->bounce_size, NBPG, 0,
350 &seg, 1, &rseg, BUS_DMA_NOWAIT);
351 if (rseg == 1 && error == 0)
352 error = bus_dmamem_map(bsc->sc_dmat, &seg, rseg,
353 ti->bounce_size, &addr, BUS_DMA_NOWAIT);
354 if (rseg != 1 || error != 0)
355 {
356 ti->bounce_size = NBPG;
357 if ((addr = malloc(NBPG, M_DEVBUF, M_NOWAIT)) == NULL)
358 goto bad;
359 }
360
361 physaddr = (caddr_t) vtophys(addr);
362 if ((u_int) physaddr >= RAM_END)
363 {
364 /* XXX: mem from malloc only! */
365 free(addr, M_DEVBUF);
366 goto bad;
367 }
368
369 ti->bounce_addr = (u_int8_t *) addr;
370 ti->bounce_phys = (u_int8_t *) physaddr;
371 return;
372
373bad:
374 bs_printf(ti, "bs_alloc_buf", "no phys bounce buffer");
375 printf("WARNING: this target is dislocated\n");
376}
377#endif /* __NetBSD__ */
378
84754cd0 379#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
380static int bs_dmarangecheck(caddr_t va, unsigned length)
381{
382 vm_offset_t phys, priorpage = 0, endva;
383
384 endva = (vm_offset_t)round_page((unsigned long)(va+length));
385 for (; va < (caddr_t)endva; va += PAGE_SIZE) {
386 phys = trunc_page(pmap_extract(pmap_kernel(), (vm_offset_t)va));
387 if (phys == 0)
388 panic("bs_dmarangecheck: no physical page present");
389 if (phys >= RAM_END)
390 return 1;
391 if (priorpage) {
392 if (priorpage + PAGE_SIZE != phys)
393 return 1;
394 }
395 priorpage = phys;
396 }
397 return 0;
398}
399
400void
401bs_alloc_buf(ti)
402 struct targ_info *ti;
403{
404 caddr_t addr, physaddr;
405
406#if BS_BOUNCE_SIZE != 0
407 ti->bounce_size = BS_BOUNCE_SIZE;
408#else
409 ti->bounce_size = BSHW_NBPG;
410#endif
411 /* Try malloc() first. It works better if it works. */
412 addr = malloc(ti->bounce_size, M_DEVBUF, M_NOWAIT);
413 if (addr != NULL) {
414 if (bs_dmarangecheck(addr, ti->bounce_size) == 0) {
415 physaddr = (caddr_t) vtophys(addr);
416 ti->bounce_addr = (u_int8_t *) addr;
417 ti->bounce_phys = (u_int8_t *) physaddr;
418 return;
419 }
420 free(addr, M_DEVBUF);
421 }
422 addr = contigmalloc(ti->bounce_size, M_DEVBUF, M_NOWAIT,
423 0ul, RAM_END, 1ul, 0x10000ul);
424 if (addr == NULL)
425 goto bad;
426
427 physaddr = (caddr_t) vtophys(addr);
428 if ((u_int) physaddr >= RAM_END)
429 {
430 /* XXX:
431 * must free memory !
432 */
433 goto bad;
434 }
435
436 ti->bounce_addr = (u_int8_t *) addr;
437 ti->bounce_phys = (u_int8_t *) physaddr;
438 return;
439
440bad:
441 bs_printf(ti, "bs_alloc_buf", "no phys bounce buffer");
442 printf("WARNING: this target is dislocated\n");
443}
444#endif /* __FreeBSD__ */