wdc_mb.c revision 1.19 1 /* $NetBSD: wdc_mb.c,v 1.19 2004/01/03 01:50:52 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 1998, 2003 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Charles M. Hannum and by Onno van der Linden.
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 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: wdc_mb.c,v 1.19 2004/01/03 01:50:52 thorpej Exp $");
41
42 #include <sys/types.h>
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/malloc.h>
46 #include <sys/device.h>
47
48 #include <machine/bswap.h>
49 #include <machine/cpu.h>
50 #include <machine/bus.h>
51 #include <machine/iomap.h>
52 #include <machine/mfp.h>
53 #include <machine/dma.h>
54
55 #include <dev/ata/atavar.h>
56 #include <dev/ic/wdcvar.h>
57
58 #include <m68k/asm_single.h>
59
60 #include <atari/dev/ym2149reg.h>
61 #include <atari/atari/device.h>
62
63 /*
64 * XXX This code currently doesn't even try to allow 32-bit data port use.
65 */
66 static int claim_hw __P((void *, int));
67 static void free_hw __P((void *));
68 static void read_multi_2_swap __P((bus_space_tag_t, bus_space_handle_t,
69 bus_size_t, u_int16_t *, bus_size_t));
70 static void write_multi_2_swap __P((bus_space_tag_t, bus_space_handle_t,
71 bus_size_t, const u_int16_t *, bus_size_t));
72
73 struct wdc_mb_softc {
74 struct wdc_softc sc_wdcdev;
75 struct wdc_channel wdc_chanlist[1];
76 struct wdc_channel wdc_channel;
77 struct ata_queue wdc_chqueue;
78 void *sc_ih;
79 };
80
81 int wdc_mb_probe __P((struct device *, struct cfdata *, void *));
82 void wdc_mb_attach __P((struct device *, struct device *, void *));
83
84 CFATTACH_DECL(wdc_mb, sizeof(struct wdc_mb_softc),
85 wdc_mb_probe, wdc_mb_attach, NULL, NULL);
86
87 int
88 wdc_mb_probe(parent, cfp, aux)
89 struct device *parent;
90 struct cfdata *cfp;
91 void *aux;
92 {
93 static int wdc_matched = 0;
94 struct wdc_channel ch;
95 int result = 0;
96 u_char sv_ierb;
97
98 if ((machineid & ATARI_TT) || strcmp("wdc", aux) || wdc_matched)
99 return 0;
100 if (!atari_realconfig)
101 return 0;
102
103 memset(&ch, 0, sizeof(ch));
104
105 ch.cmd_iot = ch.ctl_iot = mb_alloc_bus_space_tag();
106 if (ch.cmd_iot == NULL)
107 return 0;
108 ch.cmd_iot->stride = 2;
109 ch.cmd_iot->wo_1 = 1;
110
111 if (bus_space_map(ch.cmd_iot, 0xfff00000, 0x40, 0, &ch.cmd_baseioh))
112 return 0;
113 if (bus_space_subregion(ch.cmd_iot, ch.cmd_baseioh, 0x38, 1,
114 &ch.ctl_ioh))
115 return 0;
116
117 /*
118 * Make sure IDE interrupts are disabled during probing.
119 */
120 sv_ierb = MFP->mf_ierb;
121 MFP->mf_ierb &= ~IB_DINT;
122
123 /*
124 * Make sure that IDE is turned on on the Falcon.
125 */
126 if (machineid & ATARI_FALCON)
127 ym2149_ser2(0);
128
129 result = wdcprobe(&ch);
130
131 MFP->mf_ierb = sv_ierb;
132
133 bus_space_unmap(ch.cmd_iot, ch.cmd_baseioh, 0x40);
134 mb_free_bus_space_tag(ch.cmd_iot);
135
136 if (result)
137 wdc_matched = 1;
138 return (result);
139 }
140
141 void
142 wdc_mb_attach(parent, self, aux)
143 struct device *parent, *self;
144 void *aux;
145 {
146 struct wdc_mb_softc *sc = (void *)self;
147
148 printf("\n");
149
150 sc->wdc_channel.cmd_iot = sc->wdc_channel.ctl_iot =
151 mb_alloc_bus_space_tag();
152 sc->wdc_channel.cmd_iot->stride = 2;
153 sc->wdc_channel.cmd_iot->wo_1 = 1;
154 sc->wdc_channel.cmd_iot->abs_rms_2 = read_multi_2_swap;
155 sc->wdc_channel.cmd_iot->abs_wms_2 = write_multi_2_swap;
156 if (bus_space_map(sc->wdc_channel.cmd_iot, 0xfff00000, 0x40, 0,
157 &sc->wdc_channel.cmd_baseioh)) {
158 printf("%s: couldn't map registers\n",
159 sc->sc_wdcdev.sc_dev.dv_xname);
160 return;
161 }
162 if (bus_space_subregion(sc->wdc_channel.cmd_iot,
163 sc->wdc_channel.cmd_baseioh, 0x38, 1, &sc->wdc_channel.ctl_ioh))
164 return;
165
166 /*
167 * Play a nasty trick here. Normally we only manipulate the
168 * interrupt *mask*. However to defeat wd_get_parms(), we
169 * disable the interrupts here using the *enable* register.
170 */
171 MFP->mf_ierb &= ~IB_DINT;
172
173 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_HWLOCK |
174 WDC_CAPABILITY_ATA_NOSTREAM;
175 sc->sc_wdcdev.PIO_cap = 0;
176 sc->sc_wdcdev.claim_hw = &claim_hw;
177 sc->sc_wdcdev.free_hw = &free_hw;
178 sc->wdc_chanlist[0] = &sc->wdc_channel;
179 sc->sc_wdcdev.channels = sc->wdc_chanlist;
180 sc->sc_wdcdev.nchannels = 1;
181 sc->wdc_channel.channel = 0;
182 sc->wdc_channel.wdc = &sc->sc_wdcdev;
183 sc->wdc_channel.ch_queue = &sc->wdc_chqueue;
184
185 /*
186 * Setup & enable disk related interrupts.
187 */
188 MFP->mf_ierb |= IB_DINT;
189 MFP->mf_iprb = (u_int8_t)~IB_DINT;
190 MFP->mf_imrb |= IB_DINT;
191
192 wdcattach(&sc->wdc_channel);
193 }
194
195 /*
196 * Hardware locking
197 */
198 static int wd_lock;
199
200 static int
201 claim_hw(softc, maysleep)
202 void *softc;
203 int maysleep;
204 {
205 if (wd_lock != DMA_LOCK_GRANT) {
206 if (wd_lock == DMA_LOCK_REQ) {
207 /*
208 * ST_DMA access is being claimed.
209 */
210 return 0;
211 }
212 if (!st_dmagrab((dma_farg)wdcintr,
213 (dma_farg)(maysleep ? NULL : wdcrestart), softc,
214 &wd_lock, 1))
215 return 0;
216 }
217 return 1;
218 }
219
220 static void
221 free_hw(softc)
222 void *softc;
223 {
224 /*
225 * Flush pending interrupts before giving-up lock
226 */
227 MFP->mf_iprb = (u_int8_t)~IB_DINT;
228
229 /*
230 * Only free the lock on a Falcon. On the Hades, keep it.
231 */
232 /* if (machineid & ATARI_FALCON) */
233 st_dmafree(softc, &wd_lock);
234 }
235
236 /*
237 * XXX
238 * This piece of uglyness is caused by the fact that the byte lanes of
239 * the data-register are swapped on the atari. This works OK for an IDE
240 * disk, but turns into a nightmare when used on atapi devices.
241 */
242 #define calc_addr(base, off, stride, wm) \
243 ((u_long)(base) + ((off) << (stride)) + (wm))
244
245 static void
246 read_multi_2_swap(t, h, o, a, c)
247 bus_space_tag_t t;
248 bus_space_handle_t h;
249 bus_size_t o, c;
250 u_int16_t *a;
251 {
252 u_int16_t *ba;
253
254 ba = (u_int16_t *)calc_addr(h, o, t->stride, t->wo_2);
255 for (; c; a++, c--)
256 *a = bswap16(*ba);
257 }
258
259 static void
260 write_multi_2_swap(t, h, o, a, c)
261 bus_space_tag_t t;
262 bus_space_handle_t h;
263 bus_size_t o, c;
264 const u_int16_t *a;
265 {
266 u_int16_t *ba;
267
268 ba = (u_int16_t *)calc_addr(h, o, t->stride, t->wo_2);
269 for (; c; a++, c--)
270 *ba = bswap16(*a);
271 }
272