1 /* $NetBSD: cs89x0isa.c,v 1.2 2001/11/26 19:55:38 yamt Exp $ */ 2 3 /* 4 * Copyright 1997 5 * Digital Equipment Corporation. All rights reserved. 6 * 7 * This software is furnished under license and may be used and 8 * copied only in accordance with the following terms and conditions. 9 * Subject to these conditions, you may download, copy, install, 10 * use, modify and distribute this software in source and/or binary 11 * form. No title or ownership is transferred hereby. 12 * 13 * 1) Any source code used, modified or distributed must reproduce 14 * and retain this copyright notice and list of conditions as 15 * they appear in the source file. 16 * 17 * 2) No right is granted to use any trade name, trademark, or logo of 18 * Digital Equipment Corporation. Neither the "Digital Equipment 19 * Corporation" name nor any trademark or logo of Digital Equipment 20 * Corporation may be used to endorse or promote products derived 21 * from this software without the prior written permission of 22 * Digital Equipment Corporation. 23 * 24 * 3) This software is provided "AS-IS" and any express or implied 25 * warranties, including but not limited to, any implied warranties 26 * of merchantability, fitness for a particular purpose, or 27 * non-infringement are disclaimed. In no event shall DIGITAL be 28 * liable for any damages whatsoever, and in particular, DIGITAL 29 * shall not be liable for special, indirect, consequential, or 30 * incidental damages or damages for lost profits, loss of 31 * revenue or loss of use, whether such damages arise in contract, 32 * negligence, tort, under statute, in equity, at law or otherwise, 33 * even if advised of the possibility of such damage. 34 */ 35 36 /* isa dma routines for cs89x0 */ 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: cs89x0isa.c,v 1.2 2001/11/26 19:55:38 yamt Exp $"); 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/mbuf.h> 44 #include <sys/socket.h> 45 #include <sys/device.h> 46 47 #include "rnd.h" 48 #if NRND > 0 49 #include <sys/rnd.h> 50 #endif 51 52 #include <net/if.h> 53 #include <net/if_ether.h> 54 #include <net/if_media.h> 55 56 #include <machine/bus.h> 57 58 #include <dev/isa/isareg.h> 59 #include <dev/isa/isavar.h> 60 #include <dev/isa/isadmavar.h> 61 62 #include <dev/ic/cs89x0reg.h> 63 #include <dev/ic/cs89x0var.h> 64 #include <dev/isa/cs89x0isavar.h> 65 66 #define DMA_STATUS_BITS 0x0007 /* bit masks for checking DMA status */ 67 #define DMA_STATUS_OK 0x0004 68 69 void 70 cs_isa_dma_attach(struct cs_softc *sc) 71 { 72 struct cs_softc_isa *isc = (void *)sc; 73 74 if (isc->sc_drq == ISACF_DRQ_DEFAULT) 75 printf("%s: DMA channel unspecified, not using DMA\n", 76 sc->sc_dev.dv_xname); 77 else if (isc->sc_drq < 5 || isc->sc_drq > 7) 78 printf("%s: invalid DMA channel, not using DMA\n", 79 sc->sc_dev.dv_xname); 80 else { 81 bus_size_t maxsize; 82 bus_addr_t dma_addr; 83 84 maxsize = isa_dmamaxsize(isc->sc_ic, isc->sc_drq); 85 if (maxsize < CS8900_DMASIZE) { 86 printf("%s: max DMA size %lu is less than required %d\n", 87 sc->sc_dev.dv_xname, (u_long)maxsize, 88 CS8900_DMASIZE); 89 goto after_dma_block; 90 } 91 92 if (isa_dmamap_create(isc->sc_ic, isc->sc_drq, 93 CS8900_DMASIZE, BUS_DMA_NOWAIT) != 0) { 94 printf("%s: unable to create ISA DMA map\n", 95 sc->sc_dev.dv_xname); 96 goto after_dma_block; 97 } 98 if (isa_dmamem_alloc(isc->sc_ic, isc->sc_drq, 99 CS8900_DMASIZE, &dma_addr, BUS_DMA_NOWAIT) != 0) { 100 printf("%s: unable to allocate DMA buffer\n", 101 sc->sc_dev.dv_xname); 102 goto after_dma_block; 103 } 104 if (isa_dmamem_map(isc->sc_ic, isc->sc_drq, dma_addr, 105 CS8900_DMASIZE, &isc->sc_dmabase, 106 BUS_DMA_NOWAIT | BUS_DMA_COHERENT /* XXX */ ) != 0) { 107 printf("%s: unable to map DMA buffer\n", 108 sc->sc_dev.dv_xname); 109 isa_dmamem_free(isc->sc_ic, isc->sc_drq, dma_addr, 110 CS8900_DMASIZE); 111 goto after_dma_block; 112 } 113 114 isc->sc_dmasize = CS8900_DMASIZE; 115 sc->sc_cfgflags |= CFGFLG_DMA_MODE; 116 isc->sc_dmaaddr = dma_addr; 117 after_dma_block: 118 } 119 } 120 121 void cs_isa_dma_chipinit(struct cs_softc *sc) 122 { 123 struct cs_softc_isa *isc = (void *)sc; 124 125 if (sc->sc_cfgflags & CFGFLG_DMA_MODE) { 126 /* 127 * First we program the DMA controller and ensure the memory 128 * buffer is valid. If it isn't then we just go on without 129 * DMA. 130 */ 131 if (isa_dmastart(isc->sc_ic, isc->sc_drq, isc->sc_dmabase, 132 isc->sc_dmasize, NULL, DMAMODE_READ | DMAMODE_LOOPDEMAND, 133 BUS_DMA_NOWAIT)) { 134 /* XXX XXX XXX */ 135 panic("%s: unable to start DMA\n", sc->sc_dev.dv_xname); 136 } 137 isc->sc_dmacur = isc->sc_dmabase; 138 139 /* interrupt when a DMA'd frame is received */ 140 CS_WRITE_PACKET_PAGE(sc, PKTPG_RX_CFG, 141 RX_CFG_ALL_IE | RX_CFG_RX_DMA_ONLY); 142 143 /* 144 * set the DMA burst bit so we don't tie up the bus for too 145 * long. 146 */ 147 if (isc->sc_dmasize == 16384) { 148 CS_WRITE_PACKET_PAGE(sc, PKTPG_BUS_CTL, 149 ((CS_READ_PACKET_PAGE(sc, PKTPG_BUS_CTL) & 150 ~BUS_CTL_DMA_SIZE) | BUS_CTL_DMA_BURST)); 151 } else { /* use 64K */ 152 CS_WRITE_PACKET_PAGE(sc, PKTPG_BUS_CTL, 153 CS_READ_PACKET_PAGE(sc, PKTPG_BUS_CTL) | 154 BUS_CTL_DMA_SIZE | BUS_CTL_DMA_BURST); 155 } 156 157 CS_WRITE_PACKET_PAGE(sc, PKTPG_DMA_CHANNEL, isc->sc_drq - 5); 158 } 159 } 160 161 void cs_process_rx_dma(struct cs_softc *sc) 162 { 163 struct cs_softc_isa *isc = (void *)sc; 164 struct ifnet *ifp; 165 u_int16_t num_dma_frames; 166 u_int16_t pkt_length; 167 u_int16_t status; 168 u_int to_copy; 169 char *dma_mem_ptr; 170 struct mbuf *m; 171 u_char *pBuff; 172 int pad; 173 174 /* initialise the pointers */ 175 ifp = &sc->sc_ethercom.ec_if; 176 177 /* Read the number of frames DMAed. */ 178 num_dma_frames = CS_READ_PACKET_PAGE(sc, PKTPG_DMA_FRAME_COUNT); 179 num_dma_frames &= (u_int16_t) (0x0fff); 180 181 /* 182 * Loop till number of DMA frames ready to read is zero. After 183 * reading the frame out of memory we must check if any have been 184 * received while we were processing 185 */ 186 while (num_dma_frames != 0) { 187 dma_mem_ptr = isc->sc_dmacur; 188 189 /* 190 * process all of the dma frames in memory 191 * 192 * This loop relies on the dma_mem_ptr variable being set to the 193 * next frames start address. 194 */ 195 for (; num_dma_frames > 0; num_dma_frames--) { 196 197 /* 198 * Get the length and status of the packet. Only the 199 * status is guarenteed to be at dma_mem_ptr, ie need 200 * to check for wraparound before reading the length 201 */ 202 status = *((unsigned short *) dma_mem_ptr)++; 203 if (dma_mem_ptr > (isc->sc_dmabase + isc->sc_dmasize)) { 204 dma_mem_ptr = isc->sc_dmabase; 205 } 206 pkt_length = *((unsigned short *) dma_mem_ptr)++; 207 208 /* Do some sanity checks on the length and status. */ 209 if ((pkt_length > ETHER_MAX_LEN) || 210 ((status & DMA_STATUS_BITS) != DMA_STATUS_OK)) { 211 /* 212 * the SCO driver kills the adapter in this 213 * situation 214 */ 215 /* 216 * should increment the error count and reset 217 * the dma operation. 218 */ 219 printf("%s: cs_process_rx_dma: DMA buffer out of sync about to reset\n", 220 sc->sc_dev.dv_xname); 221 ifp->if_ierrors++; 222 223 /* skip the rest of the DMA buffer */ 224 isa_dmaabort(isc->sc_ic, isc->sc_drq); 225 226 /* now reset the chip and reinitialise */ 227 cs_init(&sc->sc_ethercom.ec_if); 228 return; 229 } 230 /* Check the status of the received packet. */ 231 if (status & RX_EVENT_RX_OK) { 232 /* get a new mbuf */ 233 MGETHDR(m, M_DONTWAIT, MT_DATA); 234 if (m == 0) { 235 printf("%s: cs_process_rx_dma: unable to allocate mbuf\n", 236 sc->sc_dev.dv_xname); 237 ifp->if_ierrors++; 238 /* 239 * couldn't allocate an mbuf so 240 * things are not good, may as well 241 * drop all the packets I think. 242 */ 243 CS_READ_PACKET_PAGE(sc, 244 PKTPG_DMA_FRAME_COUNT); 245 246 /* now reset DMA operation */ 247 isa_dmaabort(isc->sc_ic, isc->sc_drq); 248 249 /* 250 * now reset the chip and 251 * reinitialise 252 */ 253 cs_init(&sc->sc_ethercom.ec_if); 254 return; 255 } 256 /* 257 * save processing by always using a mbuf 258 * cluster, guarenteed to fit packet 259 */ 260 MCLGET(m, M_DONTWAIT); 261 if ((m->m_flags & M_EXT) == 0) { 262 /* couldn't allocate an mbuf cluster */ 263 printf("%s: cs_process_rx_dma: unable to allocate a cluster\n", 264 sc->sc_dev.dv_xname); 265 m_freem(m); 266 267 /* skip the frame */ 268 CS_READ_PACKET_PAGE(sc, PKTPG_DMA_FRAME_COUNT); 269 isa_dmaabort(isc->sc_ic, isc->sc_drq); 270 271 /* 272 * now reset the chip and 273 * reinitialise 274 */ 275 cs_init(&sc->sc_ethercom.ec_if); 276 return; 277 } 278 m->m_pkthdr.rcvif = ifp; 279 m->m_pkthdr.len = pkt_length; 280 m->m_len = pkt_length; 281 282 /* 283 * align ip header on word boundary for 284 * ipintr 285 */ 286 pad = ALIGN(sizeof(struct ether_header)) - 287 sizeof(struct ether_header); 288 m->m_data += pad; 289 290 /* 291 * set up the buffer pointer to point to the 292 * data area 293 */ 294 pBuff = mtod(m, char *); 295 296 /* 297 * Read the frame into free_pktbuf 298 * The buffer is circular buffer, either 299 * 16K or 64K in length. 300 * 301 * need to check where the end of the buffer 302 * is and go back to the start. 303 */ 304 if ((dma_mem_ptr + pkt_length) < 305 (isc->sc_dmabase + isc->sc_dmasize)) { 306 /* 307 * No wrap around. Copy the frame 308 * header 309 */ 310 memcpy(pBuff, dma_mem_ptr, pkt_length); 311 dma_mem_ptr += pkt_length; 312 } else { 313 to_copy = (u_int) 314 ((isc->sc_dmabase + isc->sc_dmasize) - 315 dma_mem_ptr); 316 317 /* Copy the first half of the frame. */ 318 memcpy(pBuff, dma_mem_ptr, to_copy); 319 pBuff += to_copy; 320 321 /* 322 * Rest of the frame is to be read 323 * from the first byte of the DMA 324 * memory. 325 */ 326 /* 327 * Get the number of bytes leftout in 328 * the frame. 329 */ 330 to_copy = pkt_length - to_copy; 331 332 dma_mem_ptr = isc->sc_dmabase; 333 334 /* Copy rest of the frame. */ 335 memcpy(pBuff, dma_mem_ptr, to_copy); 336 dma_mem_ptr += to_copy; 337 } 338 339 cs_ether_input(sc, m); 340 } 341 /* (status & RX_OK) */ 342 else { 343 /* the frame was not received OK */ 344 /* Increment the input error count */ 345 ifp->if_ierrors++; 346 347 /* 348 * If debugging is enabled then log error 349 * messages if we got any. 350 */ 351 if ((ifp->if_flags & IFF_DEBUG) && 352 status != REG_NUM_RX_EVENT) 353 cs_print_rx_errors(sc, status); 354 } 355 /* 356 * now update the current frame pointer. the 357 * dma_mem_ptr should point to the next packet to be 358 * received, without the alignment considerations. 359 * 360 * The cs8900 pads all frames to start at the next 32bit 361 * aligned addres. hence we need to pad our offset 362 * pointer. 363 */ 364 dma_mem_ptr += 3; 365 dma_mem_ptr = (char *) 366 ((long) dma_mem_ptr & 0xfffffffc); 367 if (dma_mem_ptr < (isc->sc_dmabase + isc->sc_dmasize)) { 368 isc->sc_dmacur = dma_mem_ptr; 369 } else { 370 dma_mem_ptr = isc->sc_dmacur = isc->sc_dmabase; 371 } 372 } /* for all frames */ 373 /* Read the number of frames DMAed again. */ 374 num_dma_frames = CS_READ_PACKET_PAGE(sc, PKTPG_DMA_FRAME_COUNT); 375 num_dma_frames &= (u_int16_t) (0x0fff); 376 } /* while there are frames left */ 377 } 378