1 /* $NetBSD: wdc_mb.c,v 1.40 2017/10/20 07:06:06 jdolecek 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 * 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 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: wdc_mb.c,v 1.40 2017/10/20 07:06:06 jdolecek Exp $"); 34 35 #include <sys/types.h> 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/malloc.h> 39 #include <sys/device.h> 40 41 #include <sys/bswap.h> 42 #include <machine/cpu.h> 43 #include <sys/bus.h> 44 #include <machine/iomap.h> 45 #include <machine/mfp.h> 46 #include <machine/dma.h> 47 48 #include <dev/ata/atavar.h> 49 #include <dev/ic/wdcvar.h> 50 51 #include <m68k/asm_single.h> 52 53 #include <atari/dev/ym2149reg.h> 54 #include <atari/atari/device.h> 55 56 /* Falcon IDE register locations (base and offsets). */ 57 #define FALCON_WD_BASE 0xfff00000 58 #define FALCON_WD_LEN 0x40 59 #define FALCON_WD_AUX 0x38 60 61 /* 62 * XXX This code currently doesn't even try to allow 32-bit data port use. 63 */ 64 static int claim_hw(struct ata_channel *, int); 65 static void free_hw(struct ata_channel *); 66 static void read_multi_2_swap(bus_space_tag_t, bus_space_handle_t, 67 bus_size_t, uint16_t *, bus_size_t); 68 static void write_multi_2_swap(bus_space_tag_t, bus_space_handle_t, 69 bus_size_t, const uint16_t *, bus_size_t); 70 71 struct wdc_mb_softc { 72 struct wdc_softc sc_wdcdev; 73 struct ata_channel *sc_chanlist[1]; 74 struct ata_channel sc_channel; 75 struct wdc_regs sc_wdc_regs; 76 void *sc_ih; 77 }; 78 79 int wdc_mb_probe(device_t, struct cfdata *, void *); 80 void wdc_mb_attach(device_t, device_t, void *); 81 82 CFATTACH_DECL_NEW(wdc_mb, sizeof(struct wdc_mb_softc), 83 wdc_mb_probe, wdc_mb_attach, NULL, NULL); 84 85 int 86 wdc_mb_probe(device_t parent, cfdata_t cfp, void *aux) 87 { 88 static int wdc_matched = 0; 89 struct wdc_regs wdr; 90 int result = 0, i; 91 uint8_t sv_ierb; 92 93 if ((machineid & ATARI_TT) || strcmp("wdc", aux) || wdc_matched) 94 return 0; 95 if (!atari_realconfig) 96 return 0; 97 98 wdr.cmd_iot = wdr.ctl_iot = mb_alloc_bus_space_tag(); 99 if (wdr.cmd_iot == NULL) 100 return 0; 101 wdr.cmd_iot->stride = 0; 102 wdr.cmd_iot->wo_1 = 1; 103 104 if (bus_space_map(wdr.cmd_iot, FALCON_WD_BASE, FALCON_WD_LEN, 0, 105 &wdr.cmd_baseioh)) 106 goto out; 107 for (i = 0; i < WDC_NREG; i++) { 108 if (bus_space_subregion(wdr.cmd_iot, wdr.cmd_baseioh, 109 i * 4, 4, &wdr.cmd_iohs[i]) != 0) 110 goto outunmap; 111 } 112 wdc_init_shadow_regs(&wdr); 113 114 if (bus_space_subregion(wdr.cmd_iot, wdr.cmd_baseioh, FALCON_WD_AUX, 4, 115 &wdr.ctl_ioh)) 116 goto outunmap; 117 118 /* 119 * Make sure IDE interrupts are disabled during probing. 120 */ 121 sv_ierb = MFP->mf_ierb; 122 MFP->mf_ierb &= ~IB_DINT; 123 124 /* 125 * Make sure that IDE is turned on on the Falcon. 126 */ 127 if (machineid & ATARI_FALCON) 128 ym2149_ser2(0); 129 130 result = wdcprobe(&wdr); 131 132 MFP->mf_ierb = sv_ierb; 133 134 outunmap: 135 bus_space_unmap(wdr.cmd_iot, wdr.cmd_baseioh, FALCON_WD_LEN); 136 out: 137 mb_free_bus_space_tag(wdr.cmd_iot); 138 139 if (result) 140 wdc_matched = 1; 141 return result; 142 } 143 144 void 145 wdc_mb_attach(device_t parent, device_t self, void *aux) 146 { 147 struct wdc_mb_softc *sc = device_private(self); 148 struct wdc_regs *wdr; 149 int i; 150 151 aprint_normal("\n"); 152 153 sc->sc_wdcdev.sc_atac.atac_dev = self; 154 sc->sc_wdcdev.regs = wdr = &sc->sc_wdc_regs; 155 wdr->cmd_iot = wdr->ctl_iot = 156 mb_alloc_bus_space_tag(); 157 wdr->cmd_iot->stride = 0; 158 wdr->cmd_iot->wo_1 = 1; 159 wdr->cmd_iot->abs_rms_2 = read_multi_2_swap; 160 wdr->cmd_iot->abs_wms_2 = write_multi_2_swap; 161 if (bus_space_map(wdr->cmd_iot, FALCON_WD_BASE, FALCON_WD_LEN, 0, 162 &wdr->cmd_baseioh)) { 163 aprint_error_dev(self, "couldn't map registers\n"); 164 return; 165 } 166 for (i = 0; i < WDC_NREG; i++) { 167 if (bus_space_subregion(wdr->cmd_iot, wdr->cmd_baseioh, 168 i * 4, 4, &wdr->cmd_iohs[i]) != 0) { 169 aprint_error_dev(self, 170 "couldn't subregion cmd reg %i\n", i); 171 bus_space_unmap(wdr->cmd_iot, wdr->cmd_baseioh, 172 FALCON_WD_LEN); 173 return; 174 } 175 } 176 177 if (bus_space_subregion(wdr->cmd_iot, 178 wdr->cmd_baseioh, FALCON_WD_AUX, 4, &wdr->ctl_ioh)) { 179 bus_space_unmap(wdr->cmd_iot, wdr->cmd_baseioh, FALCON_WD_LEN); 180 aprint_error_dev(self, "couldn't subregion aux reg\n"); 181 return; 182 } 183 184 /* 185 * Play a nasty trick here. Normally we only manipulate the 186 * interrupt *mask*. However to defeat wd_get_parms(), we 187 * disable the interrupts here using the *enable* register. 188 */ 189 MFP->mf_ierb &= ~IB_DINT; 190 191 sc->sc_wdcdev.sc_atac.atac_cap |= ATAC_CAP_DATA16 | 192 ATAC_CAP_ATA_NOSTREAM; 193 sc->sc_wdcdev.sc_atac.atac_pio_cap = 0; 194 sc->sc_wdcdev.sc_atac.atac_claim_hw = &claim_hw; 195 sc->sc_wdcdev.sc_atac.atac_free_hw = &free_hw; 196 sc->sc_chanlist[0] = &sc->sc_channel; 197 sc->sc_wdcdev.sc_atac.atac_channels = sc->sc_chanlist; 198 sc->sc_wdcdev.sc_atac.atac_nchannels = 1; 199 sc->sc_wdcdev.wdc_maxdrives = 2; 200 sc->sc_channel.ch_channel = 0; 201 sc->sc_channel.ch_atac = &sc->sc_wdcdev.sc_atac; 202 203 wdc_init_shadow_regs(wdr); 204 205 /* 206 * Setup & enable disk related interrupts. 207 */ 208 MFP->mf_ierb |= IB_DINT; 209 MFP->mf_iprb = (uint8_t)~IB_DINT; 210 MFP->mf_imrb |= IB_DINT; 211 212 wdcattach(&sc->sc_channel); 213 } 214 215 /* 216 * Hardware locking 217 */ 218 static int wd_lock; 219 220 static int 221 claim_hw(struct ata_channel *chp, int maysleep) 222 { 223 ata_channel_lock_owned(chp); 224 225 if (wd_lock != DMA_LOCK_GRANT) { 226 if (wd_lock == DMA_LOCK_REQ) { 227 /* 228 * ST_DMA access is being claimed. 229 */ 230 return 0; 231 } 232 if (!st_dmagrab((dma_farg)wdcintr, 233 (dma_farg)(maysleep ? NULL : wdcrestart), chp, 234 &wd_lock, 1, &chp->ch_lock)) 235 return 0; 236 } 237 return 1; 238 } 239 240 static void 241 free_hw(struct ata_channel *chp) 242 { 243 ata_channel_lock_owned(chp); 244 245 /* 246 * Flush pending interrupts before giving-up lock 247 */ 248 MFP->mf_iprb = (uint8_t)~IB_DINT; 249 250 /* 251 * Only free the lock on a Falcon. On the Hades, keep it. 252 */ 253 /* if (machineid & ATARI_FALCON) */ 254 st_dmafree(chp, &wd_lock); 255 } 256 257 /* 258 * XXX 259 * This piece of uglyness is caused by the fact that the byte lanes of 260 * the data-register are swapped on the atari. This works OK for an IDE 261 * disk, but turns into a nightmare when used on atapi devices. 262 */ 263 #define calc_addr(base, off, stride, wm) \ 264 ((u_long)(base) + ((off) << (stride)) + (wm)) 265 266 static void 267 read_multi_2_swap(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, 268 uint16_t *a, bus_size_t c) 269 { 270 volatile uint16_t *ba; 271 272 ba = (volatile uint16_t *)calc_addr(h, o, t->stride, t->wo_2); 273 for (; c; a++, c--) 274 *a = bswap16(*ba); 275 } 276 277 static void 278 write_multi_2_swap(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, 279 const uint16_t *a, bus_size_t c) 280 { 281 volatile uint16_t *ba; 282 283 ba = (volatile uint16_t *)calc_addr(h, o, t->stride, t->wo_2); 284 for (; c; a++, c--) 285 *ba = bswap16(*a); 286 } 287