kauai.c revision 1.1.2.3
1 /* $NetBSD: kauai.c,v 1.1.2.3 2003/06/19 11:24:01 grant Exp $ */ 2 3 /*- 4 * Copyright (c) 2003 Tsubai Masanari. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/device.h> 32 #include <sys/malloc.h> 33 34 #include <uvm/uvm_extern.h> 35 36 #include <machine/bus.h> 37 38 #include <dev/ata/atareg.h> 39 #include <dev/ata/atavar.h> 40 #include <dev/ic/wdcvar.h> 41 42 #include <dev/ofw/openfirm.h> 43 44 #include <dev/pci/pcivar.h> 45 #include <dev/pci/pcireg.h> 46 #include <dev/pci/pcidevs.h> 47 48 #include <macppc/dev/dbdma.h> 49 50 #define WDC_REG_NPORTS 8 51 #define WDC_AUXREG_OFFSET 0x16 52 53 #define PIO_CONFIG_REG (0x200 >> 4) /* PIO and DMA access timing */ 54 #define DMA_CONFIG_REG (0x210 >> 4) /* UDMA access timing */ 55 56 struct kauai_softc { 57 struct wdc_softc sc_wdcdev; 58 struct channel_softc *wdc_chanptr; 59 struct channel_softc wdc_channel; 60 struct channel_queue wdc_queue; 61 dbdma_regmap_t *sc_dmareg; 62 dbdma_command_t *sc_dmacmd; 63 u_int sc_piotiming_r[2]; 64 u_int sc_piotiming_w[2]; 65 u_int sc_dmatiming_r[2]; 66 u_int sc_dmatiming_w[2]; 67 void (*sc_calc_timing)(struct kauai_softc *, int); 68 }; 69 70 int kauai_match __P((struct device *, struct cfdata *, void *)); 71 void kauai_attach __P((struct device *, struct device *, void *)); 72 int kauai_dma_init __P((void *, int, int, void *, size_t, int)); 73 void kauai_dma_start __P((void *, int, int)); 74 int kauai_dma_finish __P((void *, int, int, int)); 75 void kauai_set_modes __P((struct channel_softc *)); 76 static void calc_timing_kauai __P((struct kauai_softc *, int)); 77 static int getnodebypci(pci_chipset_tag_t, pcitag_t); 78 79 struct cfattach kauai_ca = { 80 sizeof(struct kauai_softc), kauai_match, kauai_attach, 81 NULL, wdcactivate 82 }; 83 84 int 85 kauai_match(parent, match, aux) 86 struct device *parent; 87 struct cfdata *match; 88 void *aux; 89 { 90 struct pci_attach_args *pa = aux; 91 92 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_APPLE && 93 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_APPLE_KAUAI) 94 return 5; 95 96 return 0; 97 } 98 99 void 100 kauai_attach(parent, self, aux) 101 struct device *parent, *self; 102 void *aux; 103 { 104 struct kauai_softc *sc = (void *)self; 105 struct pci_attach_args *pa = aux; 106 struct channel_softc *chp = &sc->wdc_channel; 107 pci_intr_handle_t ih; 108 paddr_t regbase, dmabase; 109 int node, reg[5]; 110 111 #ifdef DIAGNOSTIC 112 if ((vaddr_t)sc->sc_dmacmd & 0x0f) { 113 printf(": bad dbdma alignment\n"); 114 return; 115 } 116 #endif 117 118 node = getnodebypci(pa->pa_pc, pa->pa_tag); 119 if (node == 0) { 120 printf(": cannot find gmac node\n"); 121 return; 122 } 123 124 if (OF_getprop(node, "assigned-addresses", reg, sizeof reg) < 12) { 125 printf(": cannot get address property\n"); 126 return; 127 } 128 regbase = reg[2] + 0x2000; 129 dmabase = reg[2] + 0x1000; 130 131 /* 132 * XXX PCI_INTERRUPT_REG seems to be wired to 0. 133 * XXX So use fixed intrpin and intrline values. 134 */ 135 if (pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_INTERRUPT_REG) == 0) { 136 pa->pa_intrpin = 1; 137 pa->pa_intrline = 39; 138 } 139 140 if (pci_intr_map(pa, &ih)) { 141 printf(": unable to map interrupt\n"); 142 return; 143 } 144 printf(": interrupting at %s\n", pci_intr_string(pa->pa_pc, ih)); 145 146 chp->cmd_iot = chp->ctl_iot = macppc_make_bus_space_tag(regbase, 4); 147 148 if (bus_space_map(chp->cmd_iot, 0, WDC_REG_NPORTS, 0, &chp->cmd_ioh) || 149 bus_space_subregion(chp->cmd_iot, chp->cmd_ioh, 150 WDC_AUXREG_OFFSET, 1, &chp->ctl_ioh)) { 151 printf("%s: couldn't map registers\n", self->dv_xname); 152 return; 153 } 154 155 if (pci_intr_establish(pa->pa_pc, ih, IPL_BIO, wdcintr, chp) == NULL) { 156 printf("%s: unable to establish interrupt\n", self->dv_xname); 157 return; 158 } 159 160 161 sc->sc_wdcdev.PIO_cap = 4; 162 sc->sc_wdcdev.DMA_cap = 2; 163 sc->sc_wdcdev.UDMA_cap = 5; 164 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DATA16 | WDC_CAPABILITY_MODE; 165 sc->sc_wdcdev.cap |= WDC_CAPABILITY_DMA | WDC_CAPABILITY_UDMA; 166 sc->wdc_chanptr = chp; 167 sc->sc_wdcdev.channels = &sc->wdc_chanptr; 168 sc->sc_wdcdev.nchannels = 1; 169 sc->sc_wdcdev.dma_arg = sc; 170 sc->sc_wdcdev.dma_init = kauai_dma_init; 171 sc->sc_wdcdev.dma_start = kauai_dma_start; 172 sc->sc_wdcdev.dma_finish = kauai_dma_finish; 173 sc->sc_wdcdev.set_modes = kauai_set_modes; 174 sc->sc_calc_timing = calc_timing_kauai; 175 sc->sc_dmareg = (void *)dmabase; 176 177 chp->channel = 0; 178 chp->wdc = &sc->sc_wdcdev; 179 chp->ch_queue = &sc->wdc_queue; 180 181 wdcattach(chp); 182 183 /* Modify access timings. */ 184 kauai_set_modes(chp); 185 } 186 187 void 188 kauai_set_modes(chp) 189 struct channel_softc *chp; 190 { 191 struct kauai_softc *sc = (void *)chp->wdc; 192 struct ata_drive_datas *drvp0 = &chp->ch_drive[0]; 193 struct ata_drive_datas *drvp1 = &chp->ch_drive[1]; 194 struct ata_drive_datas *drvp; 195 int drive; 196 197 if ((drvp0->drive_flags & DRIVE) && (drvp1->drive_flags & DRIVE)) { 198 drvp0->PIO_mode = drvp1->PIO_mode = 199 min(drvp0->PIO_mode, drvp1->PIO_mode); 200 } 201 202 for (drive = 0; drive < 2; drive++) { 203 drvp = &chp->ch_drive[drive]; 204 if (drvp->drive_flags & DRIVE) { 205 (*sc->sc_calc_timing)(sc, drive); 206 bus_space_write_4(chp->cmd_iot, chp->cmd_ioh, 207 PIO_CONFIG_REG, sc->sc_piotiming_r[drive]); 208 bus_space_write_4(chp->cmd_iot, chp->cmd_ioh, 209 DMA_CONFIG_REG, sc->sc_dmatiming_r[drive]); 210 } 211 } 212 213 wdc_print_modes(chp); 214 } 215 216 /* 217 * IDE transfer timings 218 */ 219 static const u_int pio_timing_kauai[] = { /* 0xff000fff */ 220 0x08000a92, /* Mode 0 */ 221 0x0800060f, /* 1 */ 222 0x0800038b, /* 2 */ 223 0x05000249, /* 3 */ 224 0x04000148 /* 4 */ 225 }; 226 static const u_int dma_timing_kauai[] = { /* 0x00fff000 */ 227 0x00618000, /* Mode 0 */ 228 0x00209000, /* 1 */ 229 0x00148000 /* 2 */ 230 }; 231 static const u_int udma_timing_kauai[] = { /* 0x0000ffff */ 232 0x000070c0, /* Mode 0 */ 233 0x00005d80, /* 1 */ 234 0x00004a60, /* 2 */ 235 0x00003a50, /* 3 */ 236 0x00002a30, /* 4 */ 237 0x00002921 /* 5 */ 238 }; 239 240 /* 241 * Timing calculation for Kauai. 242 */ 243 void 244 calc_timing_kauai(sc, drive) 245 struct kauai_softc *sc; 246 int drive; 247 { 248 struct channel_softc *chp = &sc->wdc_channel; 249 struct ata_drive_datas *drvp = &chp->ch_drive[drive]; 250 int piomode = drvp->PIO_mode; 251 int dmamode = drvp->DMA_mode; 252 int udmamode = drvp->UDMA_mode; 253 u_int pioconf, dmaconf; 254 255 pioconf = pio_timing_kauai[piomode]; 256 257 dmaconf = 0; 258 if (drvp->drive_flags & DRIVE_DMA) 259 dmaconf |= dma_timing_kauai[dmamode]; 260 if (drvp->drive_flags & DRIVE_UDMA) 261 dmaconf |= udma_timing_kauai[udmamode]; 262 263 if (drvp->drive_flags & DRIVE_UDMA) 264 dmaconf |= 1; 265 266 sc->sc_piotiming_r[drive] = sc->sc_piotiming_w[drive] = pioconf; 267 sc->sc_dmatiming_r[drive] = sc->sc_dmatiming_w[drive] = dmaconf; 268 } 269 270 int 271 kauai_dma_init(v, channel, drive, databuf, datalen, flags) 272 void *v; 273 void *databuf; 274 size_t datalen; 275 int flags; 276 { 277 struct kauai_softc *sc = v; 278 dbdma_command_t *cmdp = sc->sc_dmacmd; 279 struct channel_softc *chp = &sc->wdc_channel; 280 vaddr_t va = (vaddr_t)databuf; 281 int read = flags & WDC_DMA_READ; 282 int cmd = read ? DBDMA_CMD_IN_MORE : DBDMA_CMD_OUT_MORE; 283 u_int offset; 284 285 bus_space_write_4(chp->cmd_iot, chp->cmd_ioh, DMA_CONFIG_REG, 286 read ? sc->sc_dmatiming_r[drive] : sc->sc_dmatiming_w[drive]); 287 bus_space_read_4(chp->cmd_iot, chp->cmd_ioh, DMA_CONFIG_REG); 288 289 offset = va & PGOFSET; 290 291 /* if va is not page-aligned, setup the first page */ 292 if (offset != 0) { 293 int rest = PAGE_SIZE - offset; /* the rest of the page */ 294 295 if (datalen > rest) { /* if continues to next page */ 296 DBDMA_BUILD(cmdp, cmd, 0, rest, vtophys(va), 297 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, 298 DBDMA_BRANCH_NEVER); 299 datalen -= rest; 300 va += rest; 301 cmdp++; 302 } 303 } 304 305 /* now va is page-aligned */ 306 while (datalen > PAGE_SIZE) { 307 DBDMA_BUILD(cmdp, cmd, 0, PAGE_SIZE, vtophys(va), 308 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER); 309 datalen -= PAGE_SIZE; 310 va += PAGE_SIZE; 311 cmdp++; 312 } 313 314 /* the last page (datalen <= PAGE_SIZE here) */ 315 cmd = read ? DBDMA_CMD_IN_LAST : DBDMA_CMD_OUT_LAST; 316 DBDMA_BUILD(cmdp, cmd, 0, datalen, vtophys(va), 317 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER); 318 cmdp++; 319 320 DBDMA_BUILD(cmdp, DBDMA_CMD_STOP, 0, 0, 0, 321 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER); 322 323 return 0; 324 } 325 326 void 327 kauai_dma_start(v, channel, drive) 328 void *v; 329 int channel, drive; 330 { 331 struct kauai_softc *sc = v; 332 333 dbdma_start(sc->sc_dmareg, sc->sc_dmacmd); 334 } 335 336 int 337 kauai_dma_finish(v, channel, drive, read) 338 void *v; 339 int channel, drive; 340 int read; 341 { 342 struct kauai_softc *sc = v; 343 344 dbdma_stop(sc->sc_dmareg); 345 return 0; 346 } 347 348 /* 349 * Find OF-device corresponding to the PCI device. 350 */ 351 int 352 getnodebypci(pc, tag) 353 pci_chipset_tag_t pc; 354 pcitag_t tag; 355 { 356 int bus, dev, func; 357 u_int reg[5]; 358 int p, q; 359 int l, b, d, f; 360 361 pci_decompose_tag(pc, tag, &bus, &dev, &func); 362 363 for (q = OF_peer(0); q; q = p) { 364 l = OF_getprop(q, "assigned-addresses", reg, sizeof(reg)); 365 if (l > 4) { 366 b = (reg[0] >> 16) & 0xff; 367 d = (reg[0] >> 11) & 0x1f; 368 f = (reg[0] >> 8) & 0x07; 369 370 if (b == bus && d == dev && f == func) 371 return q; 372 } 373 if ((p = OF_child(q))) 374 continue; 375 while (q) { 376 if ((p = OF_peer(q))) 377 break; 378 q = OF_parent(q); 379 } 380 } 381 return 0; 382 } 383
Indexes created Sun Oct 19 02:09:48 GMT 2025