if_dse.c revision 1.8
1 /* $NetBSD: if_dse.c,v 1.8 2024/09/08 04:42:49 nat Exp $ */ 2 3 /* 4 * Driver for DaynaPORT SCSI/Link SCSI-Ethernet 5 * 6 * Written by Hiroshi Noguchi <ngc (at) ff.iij4u.or.jp> 7 * 8 * Modified by Matt Sandstrom <mattias (at) beauty.se> for NetBSD 1.5.3 9 * 10 * This driver is written based on "if_se.c". 11 */ 12 13 /* 14 * Copyright (c) 1997 Ian W. Dall <ian.dall (at) dsto.defence.gov.au> 15 * All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions 19 * are met: 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution. 25 * 3. All advertising materials mentioning features or use of this software 26 * must display the following acknowledgement: 27 * This product includes software developed by Ian W. Dall. 28 * 4. The name of the author may not be used to endorse or promote products 29 * derived from this software without specific prior written permission. 30 * 31 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 32 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 33 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 34 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 35 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 36 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 37 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 38 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 40 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 41 */ 42 43 #include "opt_inet.h" 44 #include "opt_atalk.h" 45 46 #include <sys/types.h> 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/callout.h> 50 #include <sys/syslog.h> 51 #include <sys/kernel.h> 52 #include <sys/file.h> 53 #include <sys/stat.h> 54 #include <sys/ioctl.h> 55 #include <sys/buf.h> 56 #include <sys/uio.h> 57 #include <sys/malloc.h> 58 #include <sys/errno.h> 59 #include <sys/device.h> 60 #include <sys/disklabel.h> 61 #include <sys/disk.h> 62 #include <sys/proc.h> 63 #include <sys/conf.h> 64 65 #include <sys/workqueue.h> 66 67 #include <dev/scsipi/scsipi_all.h> 68 #include <dev/scsipi/scsiconf.h> 69 70 #include <sys/mbuf.h> 71 72 #include <sys/socket.h> 73 #include <net/if.h> 74 #include <net/if_dl.h> 75 #include <net/if_ether.h> 76 #include <net/if_media.h> 77 78 #ifdef INET 79 #include <netinet/in.h> 80 #include <netinet/if_inarp.h> 81 #endif 82 83 #ifdef NETATALK 84 #include <netatalk/at.h> 85 #endif 86 87 #include <net/bpf.h> 88 89 90 /* 91 * debug flag 92 */ 93 #if 0 94 #define DSE_DEBUG 95 #endif 96 97 98 #define DSE_TIMEOUT 100000 99 #define DSE_OUTSTANDING 4 100 #define DSE_RETRIES 4 101 #define DSE_MINSIZE 60 102 103 #define DSE_HEADER_TX 4 104 #define DSE_TAIL_TX 4 105 #define DSE_EXTRAS_TX (DSE_HEADER_TX + DSE_TAIL_TX) 106 107 #define DSE_HEADER_RX 6 108 #define DSE_TAIL_RX 0 109 #define DSE_EXTRAS_RX (DSE_HEADER_RX + DSE_TAIL_RX) 110 111 #define MAX_BYTES_RX (ETHERMTU + sizeof(struct ether_header) + ETHER_CRC_LEN) 112 113 /* 10 full length packets appears to be the max ever returned. 16k is OK */ 114 #define RBUF_LEN (16 * 1024) 115 116 /* 117 * Tuning parameters: 118 * We will attempt to adapt to polling fast enough to get RDATA_GOAL packets 119 * per read 120 */ 121 #define RDATA_MAX 10 /* maximum of returned packets (guessed) */ 122 #define RDATA_GOAL 8 123 124 /* 125 * maximum of available multicast address entries (guessed) 126 */ 127 #define DSE_MCAST_MAX 10 128 129 130 /* dse_poll and dse_poll0 are the normal polling rate and the minimum 131 * polling rate respectively. dse_poll0 should be chosen so that at 132 * maximum ethernet speed, we will read nearly RDATA_MAX packets. dse_poll 133 * should be chosen for reasonable maximum latency. 134 * In practice, if we are being saturated with min length packets, we 135 * can't poll fast enough. Polling with zero delay actually 136 * worsens performance. dse_poll0 is enforced to be always at least 1 137 */ 138 #if MAC68K_DEBUG 139 #define DSE_POLL 50 /* default in milliseconds */ 140 #define DSE_POLL0 30 /* default in milliseconds */ 141 #else 142 #define DSE_POLL 80 /* default in milliseconds */ 143 #define DSE_POLL0 40 /* default in milliseconds */ 144 #endif 145 int dse_poll = 0; /* Delay in ticks set at attach time */ 146 int dse_poll0 = 0; 147 int dse_max_received = 0; /* Instrumentation */ 148 149 150 151 152 /*========================================== 153 data type defs 154 ==========================================*/ 155 typedef struct scsipi_inquiry_data dayna_ether_inquiry_data; 156 157 typedef struct { 158 uint8_t opcode[2]; 159 uint8_t byte3; 160 uint8_t length[2]; 161 uint8_t byte6; 162 } scsi_dayna_ether_generic; 163 164 #define DAYNA_CMD_SEND 0x0A /* same as generic "Write" */ 165 #define DAYNA_CMD_RECV 0x08 /* same as generic "Read" */ 166 167 #define DAYNA_CMD_GET_ADDR 0x09 /* ???: read MAC address ? */ 168 #define REQ_LEN_GET_ADDR 0x12 169 170 #define DAYNA_CMD_SET_MULTI 0x0D /* set multicast address */ 171 172 #define DAYNA_CMD_VENDOR1 0x0E /* ???: initialize signal ? */ 173 174 #define IS_SEND(generic) ((generic)->opcode == DAYNA_CMD_SEND) 175 #define IS_RECV(generic) ((generic)->opcode == DAYNA_CMD_RECV) 176 177 struct dse_softc { 178 device_t sc_dev; 179 struct ethercom sc_ethercom; /* Ethernet common part */ 180 struct scsipi_periph *sc_periph;/* contains our targ, lun, etc. */ 181 182 struct callout sc_recv_ch; 183 struct kmutex sc_iflock; 184 struct if_percpuq *sc_ipq; 185 struct workqueue *sc_recv_wq, *sc_send_wq; 186 struct work sc_recv_work, sc_send_work; 187 int sc_recv_work_pending, sc_send_work_pending; 188 189 char *sc_tbuf; 190 char *sc_rbuf; 191 int sc_debug; 192 int sc_flags; 193 int sc_last_timeout; 194 int sc_enabled; 195 int sc_attach_state; 196 }; 197 198 /* bit defs of "sc_flags" */ 199 #define DSE_NEED_RECV 0x1 200 201 static int dsematch(device_t, cfdata_t, void *); 202 static void dseattach(device_t, device_t, void *); 203 static int dsedetach(device_t, int); 204 205 static void dse_ifstart(struct ifnet *); 206 static void dse_send_worker(struct work *wk, void *cookie); 207 208 static void dsedone(struct scsipi_xfer *, int); 209 static int dse_ioctl(struct ifnet *, u_long, void *); 210 static void dsewatchdog(struct ifnet *); 211 212 static void dse_recv_callout(void *); 213 static void dse_recv_worker(struct work *wk, void *cookie); 214 static void dse_recv(struct dse_softc *); 215 static struct mbuf* dse_get(struct dse_softc *, uint8_t *, int); 216 static int dse_read(struct dse_softc *, uint8_t *, int); 217 218 static int dse_init_adaptor(struct dse_softc *); 219 static int dse_get_addr(struct dse_softc *, uint8_t *); 220 static int dse_set_multi(struct dse_softc *); 221 222 static int dse_reset(struct dse_softc *); 223 224 #if 0 /* 07/16/2000 comment-out */ 225 static int dse_set_mode(struct dse_softc *, int, int); 226 #endif 227 static int dse_init(struct dse_softc *); 228 static void dse_stop(struct dse_softc *); 229 230 #if 0 231 static __inline uint16_t ether_cmp(void *, void *); 232 #endif 233 234 static inline int dse_scsipi_cmd(struct scsipi_periph *periph, 235 struct scsipi_generic *scsipi_cmd, 236 int cmdlen, u_char *data_addr, int datalen, 237 int retries, int timeout, struct buf *bp, 238 int flags); 239 240 int dse_enable(struct dse_softc *); 241 void dse_disable(struct dse_softc *); 242 243 244 CFATTACH_DECL_NEW(dse, sizeof(struct dse_softc), 245 dsematch, dseattach, dsedetach, NULL); 246 247 extern struct cfdriver dse_cd; 248 249 dev_type_open(dseopen); 250 dev_type_close(dseclose); 251 dev_type_ioctl(dseioctl); 252 253 const struct cdevsw dse_cdevsw = { 254 .d_open = dseopen, 255 .d_close = dseclose, 256 .d_read = noread, 257 .d_write = nowrite, 258 .d_ioctl = dseioctl, 259 .d_stop = nostop, 260 .d_tty = notty, 261 .d_poll = nopoll, 262 .d_mmap = nommap, 263 .d_kqfilter = nokqfilter, 264 .d_discard = nodiscard, 265 .d_flag = D_OTHER | D_MPSAFE 266 }; 267 268 const struct scsipi_periphsw dse_switch = { 269 270 NULL, /* Use default error handler */ 271 NULL, /* have no queue */ 272 NULL, /* have no async handler */ 273 dsedone, /* deal with stats at interrupt time */ 274 }; 275 276 struct scsipi_inquiry_pattern dse_patterns[] = { 277 { T_PROCESSOR, T_FIXED, 278 "Dayna", "SCSI/Link", "" }, 279 }; 280 281 282 283 /*==================================================== 284 definitions for SCSI commands 285 ====================================================*/ 286 287 /* 288 * command templates 289 */ 290 /* unknown commands */ 291 /* Vendor #1 */ 292 static const scsi_dayna_ether_generic sonic_ether_vendor1 = { 293 { DAYNA_CMD_VENDOR1, 0x00 }, 294 0x00, 295 { 0x00, 0x00 }, 296 0x80 297 }; 298 299 300 301 #if 0 302 /* 303 * Compare two Ether/802 addresses for equality, inlined and 304 * unrolled for speed. 305 * Note: use this like memcmp() 306 */ 307 static __inline uint16_t 308 ether_cmp(void *one, void *two) 309 { 310 uint16_t* a; 311 uint16_t* b; 312 uint16_t diff; 313 314 a = (uint16_t *) one; 315 b = (uint16_t *) two; 316 317 diff = (a[0] - b[0]) | (a[1] - b[1]) | (a[2] - b[2]); 318 319 return (diff); 320 } 321 322 #define ETHER_CMP ether_cmp 323 #endif 324 325 /* 326 * check to match with SCSI inquiry information 327 */ 328 static int 329 dsematch(device_t parent, cfdata_t match, void *aux) 330 { 331 struct scsipibus_attach_args *sa = aux; 332 int priority; 333 334 (void)scsipi_inqmatch(&sa->sa_inqbuf, 335 dse_patterns, sizeof(dse_patterns) / sizeof(dse_patterns[0]), 336 sizeof(dse_patterns[0]), &priority); 337 return priority; 338 } 339 340 341 /* 342 * The routine called by the low level scsi routine when it discovers 343 * a device suitable for this driver. 344 */ 345 static void 346 dseattach(device_t parent, device_t self, void *aux) 347 { 348 struct dse_softc *sc = device_private(self); 349 struct scsipibus_attach_args *sa = aux; 350 struct scsipi_periph *periph = sa->sa_periph; 351 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 352 uint8_t myaddr[ETHER_ADDR_LEN]; 353 char wqname[MAXCOMLEN]; 354 int rv; 355 356 sc->sc_dev = self; 357 358 aprint_normal("\n"); 359 SC_DEBUG(periph, SCSIPI_DB2, ("dseattach: ")); 360 361 sc->sc_attach_state = 0; 362 callout_init(&sc->sc_recv_ch, CALLOUT_MPSAFE); 363 callout_setfunc(&sc->sc_recv_ch, dse_recv_callout, (void *)sc); 364 mutex_init(&sc->sc_iflock, MUTEX_DEFAULT, IPL_SOFTNET); 365 366 /* 367 * Store information needed to contact our base driver 368 */ 369 sc->sc_periph = periph; 370 periph->periph_dev = sc->sc_dev; 371 periph->periph_switch = &dse_switch; 372 #if 0 373 sc_periph->sc_link_dbflags = SCSIPI_DB1; 374 #endif 375 376 dse_poll = mstohz(DSE_POLL); 377 dse_poll = dse_poll? dse_poll: 1; 378 dse_poll0 = mstohz(DSE_POLL0); 379 dse_poll0 = dse_poll0? dse_poll0: 1; 380 381 /* 382 * Initialize and attach send and receive buffers 383 */ 384 sc->sc_tbuf = malloc(ETHERMTU + sizeof(struct ether_header) + 385 DSE_EXTRAS_TX + 16, M_DEVBUF, M_WAITOK); 386 387 sc->sc_rbuf = malloc(RBUF_LEN + 16, M_DEVBUF, M_WAITOK); 388 389 /* initialize adaptor and obtain MAC address */ 390 dse_init_adaptor(sc); 391 sc->sc_attach_state = 1; 392 393 /* Initialize ifnet structure. */ 394 strcpy(ifp->if_xname, device_xname(sc->sc_dev)); 395 ifp->if_softc = sc; 396 ifp->if_start = dse_ifstart; 397 ifp->if_ioctl = dse_ioctl; 398 ifp->if_watchdog = dsewatchdog; 399 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 400 ifp->if_extflags = IFEF_MPSAFE; 401 402 dse_get_addr(sc, myaddr); 403 404 /* Attach the interface. */ 405 if_initialize(ifp); 406 407 snprintf(wqname, sizeof(wqname), "%sRx", device_xname(sc->sc_dev)); 408 rv = workqueue_create(&sc->sc_recv_wq, wqname, dse_recv_worker, sc, 409 PRI_SOFTNET, IPL_NET, WQ_MPSAFE); 410 if (rv != 0) { 411 aprint_error_dev(sc->sc_dev, 412 "unable to create recv Rx workqueue\n"); 413 dsedetach(sc->sc_dev, 0); 414 return; /* Error */ 415 } 416 sc->sc_recv_work_pending = false; 417 sc->sc_attach_state = 2; 418 419 snprintf(wqname, sizeof(wqname), "%sTx", device_xname(sc->sc_dev)); 420 rv = workqueue_create(&sc->sc_send_wq, wqname, dse_send_worker, ifp, 421 PRI_SOFTNET, IPL_NET, WQ_MPSAFE); 422 if (rv != 0) { 423 aprint_error_dev(sc->sc_dev, 424 "unable to create send Tx workqueue\n"); 425 dsedetach(sc->sc_dev, 0); 426 return; /* Error */ 427 } 428 sc->sc_send_work_pending = false; 429 sc->sc_ipq = if_percpuq_create(&sc->sc_ethercom.ec_if); 430 ether_ifattach(ifp, myaddr); 431 if_register(ifp); 432 sc->sc_attach_state = 4; 433 434 bpf_attach(ifp, DLT_EN10MB, sizeof(struct ether_header)); 435 } 436 437 static int 438 dsedetach(device_t self, int flags) 439 { 440 struct dse_softc *sc = device_private(self); 441 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 442 443 switch(sc->sc_attach_state) { 444 case 4: 445 dse_stop(sc); 446 mutex_enter(&sc->sc_iflock); 447 ifp->if_flags &= ~IFF_RUNNING; 448 dse_disable(sc); 449 ether_ifdetach(ifp); 450 if_detach(ifp); 451 mutex_exit(&sc->sc_iflock); 452 if_percpuq_destroy(sc->sc_ipq); 453 /*FALLTHROUGH*/ 454 case 3: 455 workqueue_destroy(sc->sc_send_wq); 456 /*FALLTHROUGH*/ 457 case 2: 458 workqueue_destroy(sc->sc_recv_wq); 459 /*FALLTHROUGH*/ 460 case 1: 461 free(sc->sc_rbuf, M_DEVBUF); 462 free(sc->sc_tbuf, M_DEVBUF); 463 callout_destroy(&sc->sc_recv_ch); 464 mutex_destroy(&sc->sc_iflock); 465 break; 466 default: 467 aprint_error_dev(sc->sc_dev, "detach failed (state %d)\n", 468 sc->sc_attach_state); 469 return 1; 470 break; 471 } 472 473 return 0; 474 } 475 476 477 /* 478 * submit SCSI command 479 */ 480 static __inline int 481 dse_scsipi_cmd(struct scsipi_periph *periph, struct scsipi_generic *cmd, 482 int cmdlen, u_char *data_addr, int datalen, int retries, int timeout, 483 struct buf *bp, int flags) 484 { 485 int error = 0; 486 487 error = scsipi_command(periph, cmd, cmdlen, data_addr, 488 datalen, retries, timeout, bp, flags); 489 490 return error; 491 } 492 493 494 /* 495 * Start routine for calling from network sub system 496 */ 497 static void 498 dse_ifstart(struct ifnet *ifp) 499 { 500 struct dse_softc *sc = ifp->if_softc; 501 502 mutex_enter(&sc->sc_iflock); 503 if (!sc->sc_send_work_pending) { 504 sc->sc_send_work_pending = true; 505 workqueue_enqueue(sc->sc_send_wq, &sc->sc_send_work, NULL); 506 } 507 mutex_exit(&sc->sc_iflock); 508 if (sc->sc_flags & DSE_NEED_RECV) { 509 sc->sc_flags &= ~DSE_NEED_RECV; 510 } 511 } 512 513 /* 514 * Invoke the transmit workqueue and transmission on the interface. 515 */ 516 static void 517 dse_send_worker(struct work *wk, void *cookie) 518 { 519 struct ifnet *ifp = cookie; 520 struct dse_softc *sc = ifp->if_softc; 521 scsi_dayna_ether_generic cmd_send; 522 struct mbuf *m, *m0; 523 int len, error; 524 u_char *cp; 525 526 mutex_enter(&sc->sc_iflock); 527 sc->sc_send_work_pending = false; 528 mutex_exit(&sc->sc_iflock); 529 530 KASSERT(if_is_mpsafe(ifp)); 531 532 /* Don't transmit if interface is busy or not running */ 533 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING) 534 return; 535 536 while (1) { 537 IFQ_DEQUEUE(&ifp->if_snd, m0); 538 if (m0 == NULL) 539 break; 540 /* If BPF is listening on this interface, let it see the 541 * packet before we commit it to the wire. 542 */ 543 bpf_mtap(ifp, m0, BPF_D_OUT); 544 545 /* We need to use m->m_pkthdr.len, so require the header */ 546 if ((m0->m_flags & M_PKTHDR) == 0) 547 panic("ctscstart: no header mbuf"); 548 len = m0->m_pkthdr.len; 549 550 /* Mark the interface busy. */ 551 ifp->if_flags |= IFF_OACTIVE; 552 553 /* Chain; copy into linear buffer allocated at attach time. */ 554 cp = sc->sc_tbuf; 555 for (m = m0; m != NULL; ) { 556 memcpy(cp, mtod(m, u_char *), m->m_len); 557 cp += m->m_len; 558 m = m0 = m_free(m); 559 } 560 if (len < DSE_MINSIZE) { 561 #ifdef DSE_DEBUG 562 if (sc->sc_debug) 563 aprint_error_dev(sc->sc_dev, 564 "packet size %d (%zu) < %d\n", len, 565 cp - (u_char *)sc->sc_tbuf, DSE_MINSIZE); 566 #endif 567 memset(cp, 0, DSE_MINSIZE - len); 568 len = DSE_MINSIZE; 569 } 570 571 /* Fill out SCSI command. */ 572 memset(&cmd_send, 0, sizeof(cmd_send)); 573 cmd_send.opcode[0] = DAYNA_CMD_SEND; 574 _lto2b(len, &(cmd_send.length[0])); 575 cmd_send.byte6 = 0x00; 576 577 /* Send command to device. */ 578 error = dse_scsipi_cmd(sc->sc_periph, 579 (void *)&cmd_send, sizeof(cmd_send), 580 sc->sc_tbuf, len, DSE_RETRIES, 581 DSE_TIMEOUT, NULL, XS_CTL_NOSLEEP | XS_CTL_DATA_OUT); 582 if (error) { 583 aprint_error_dev(sc->sc_dev, 584 "not queued, error %d\n", error); 585 if_statinc(ifp, if_oerrors); 586 ifp->if_flags &= ~IFF_OACTIVE; 587 } else 588 if_statinc(ifp, if_opackets); 589 } 590 } 591 592 593 /* 594 * Called from the scsibus layer via our scsi device switch. 595 */ 596 static void 597 dsedone(struct scsipi_xfer *xs, int error) 598 { 599 struct dse_softc *sc = device_private(xs->xs_periph->periph_dev); 600 struct scsipi_generic *cmd = xs->cmd; 601 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 602 603 if (IS_SEND(cmd)) { 604 ifp->if_flags &= ~IFF_OACTIVE; 605 } else if (IS_RECV(cmd)) { 606 /* RECV complete */ 607 /* pass data up. reschedule a recv */ 608 /* scsipi_free_xs will call start. Harmless. */ 609 610 if (error) { 611 /* Reschedule after a delay */ 612 callout_schedule(&sc->sc_recv_ch, dse_poll); 613 } else { 614 int n, ntimeo; 615 n = dse_read(sc, xs->data, xs->datalen - xs->resid); 616 if (n > dse_max_received) 617 dse_max_received = n; 618 if (n == 0) 619 ntimeo = dse_poll; 620 else if (n >= RDATA_MAX) 621 ntimeo = dse_poll0; 622 else { 623 ntimeo = sc->sc_last_timeout; 624 ntimeo = (ntimeo * RDATA_GOAL)/n; 625 ntimeo = (ntimeo < dse_poll0? 626 dse_poll0: ntimeo); 627 ntimeo = (ntimeo > dse_poll? 628 dse_poll: ntimeo); 629 } 630 sc->sc_last_timeout = ntimeo; 631 callout_schedule(&sc->sc_recv_ch, ntimeo); 632 } 633 } 634 } 635 636 637 /* 638 * Setup a receive command by queuing the work. 639 * Usually called from a callout, but also from se_init(). 640 */ 641 static void 642 dse_recv_callout(void *v) 643 { 644 /* do a recv command */ 645 struct dse_softc *sc = (struct dse_softc *) v; 646 647 if (sc->sc_enabled == 0) 648 return; 649 650 mutex_enter(&sc->sc_iflock); 651 if (sc->sc_recv_work_pending == true) { 652 callout_schedule(&sc->sc_recv_ch, dse_poll); 653 mutex_exit(&sc->sc_iflock); 654 return; 655 } 656 657 sc->sc_recv_work_pending = true; 658 workqueue_enqueue(sc->sc_recv_wq, &sc->sc_recv_work, NULL); 659 mutex_exit(&sc->sc_iflock); 660 } 661 662 /* 663 * Invoke the receive workqueue 664 */ 665 static void 666 dse_recv_worker(struct work *wk, void *cookie) 667 { 668 struct dse_softc *sc = (struct dse_softc *) cookie; 669 670 dse_recv(sc); 671 mutex_enter(&sc->sc_iflock); 672 sc->sc_recv_work_pending = false; 673 mutex_exit(&sc->sc_iflock); 674 675 } 676 677 /* 678 * Do the actual work of receiving data. 679 */ 680 static void 681 dse_recv(struct dse_softc *sc) 682 { 683 scsi_dayna_ether_generic cmd_recv; 684 int error, len; 685 686 /* do a recv command */ 687 /* fill out command buffer */ 688 memset(&cmd_recv, 0, sizeof(cmd_recv)); 689 cmd_recv.opcode[0] = DAYNA_CMD_RECV; 690 len = MAX_BYTES_RX + DSE_EXTRAS_RX; 691 _lto2b(len, &(cmd_recv.length[0])); 692 cmd_recv.byte6 = 0xC0; 693 694 error = dse_scsipi_cmd(sc->sc_periph, 695 (void *)&cmd_recv, sizeof(cmd_recv), 696 sc->sc_rbuf, RBUF_LEN, DSE_RETRIES, DSE_TIMEOUT, NULL, 697 XS_CTL_NOSLEEP | XS_CTL_POLL | XS_CTL_DATA_IN); 698 if (error) 699 callout_schedule(&sc->sc_recv_ch, dse_poll); 700 } 701 702 703 /* 704 * We copy the data into mbufs. When full cluster sized units are present 705 * we copy into clusters. 706 */ 707 static struct mbuf * 708 dse_get(struct dse_softc *sc, uint8_t *data, int totlen) 709 { 710 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 711 struct mbuf *m, *m0, *newm; 712 int len; 713 714 MGETHDR(m0, M_DONTWAIT, MT_DATA); 715 if (m0 == NULL) 716 return NULL; 717 718 m_set_rcvif(m0, ifp); 719 m0->m_pkthdr.len = totlen; 720 len = MHLEN; 721 m = m0; 722 723 while (totlen > 0) { 724 if (totlen >= MINCLSIZE) { 725 MCLGET(m, M_DONTWAIT); 726 if((m->m_flags & M_EXT) == 0) 727 goto bad; 728 729 len = MCLBYTES; 730 } 731 732 if (m == m0) { 733 char *newdata = (char *) 734 ALIGN(m->m_data + sizeof(struct ether_header)) - 735 sizeof(struct ether_header); 736 len -= newdata - m->m_data; 737 m->m_data = newdata; 738 } 739 740 m->m_len = len = uimin(totlen, len); 741 memcpy(mtod(m, void *), data, len); 742 data += len; 743 744 totlen -= len; 745 if (totlen > 0) { 746 MGET(newm, M_DONTWAIT, MT_DATA); 747 if (newm == NULL) 748 goto bad; 749 750 len = MLEN; 751 m = m->m_next = newm; 752 } 753 } 754 755 return m0; 756 757 bad: 758 m_freem(m0); 759 return NULL ; 760 } 761 762 763 #ifdef MAC68K_DEBUG 764 static int 765 peek_packet(uint8_t* buf) 766 { 767 struct ether_header *eh; 768 uint16_t type; 769 int len; 770 771 eh = (struct ether_header*)buf; 772 type = _2btol((uint8_t*)&(eh->ether_type)); 773 774 len = sizeof(struct ether_header); 775 776 if (type <= ETHERMTU) { 777 /* for 802.3 */ 778 len += type; 779 } else{ 780 /* for Ethernet II (DIX) */ 781 switch (type) { 782 case ETHERTYPE_ARP: 783 len += 28; 784 break; 785 case ETHERTYPE_IP: 786 len += _2btol(buf + sizeof(struct ether_header) + 2); 787 break; 788 default: 789 len = 0; 790 goto l_end; 791 break; 792 } 793 } 794 if (len < DSE_MINSIZE) { 795 len = DSE_MINSIZE; 796 } 797 len += ETHER_CRC_LEN; 798 799 l_end:; 800 return len; 801 } 802 #endif 803 804 805 /* 806 * Pass packets to higher levels. 807 */ 808 static int 809 dse_read(struct dse_softc *sc, uint8_t *data, int datalen) 810 { 811 struct mbuf *m; 812 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 813 int len; 814 int n; 815 #ifdef MAC68K_DEBUG 816 int peek_flag = 1; 817 #endif 818 819 mutex_enter(&sc->sc_iflock); 820 n = 0; 821 while (datalen >= DSE_HEADER_RX) { 822 /* 823 * fetch bytes of stream. 824 * here length = (ether frame length) + (FCS's 4 bytes) 825 */ 826 /* fetch frame length */ 827 len = _2btol(data); 828 829 /* skip header part */ 830 data += DSE_HEADER_RX; 831 datalen -= DSE_HEADER_RX; 832 833 #if 0 /* 03/10/2001 only for debug */ 834 { 835 printf("DATALEN %d len %d\n", datalen, len); 836 int j; 837 printf("\ndump[%d]: ",n); 838 for ( j = 0 ; j < datalen ; j++ ) { 839 printf("%02X ",data[j-DSE_HEADER_RX]); 840 } 841 } 842 #endif 843 #ifdef MAC68K_DEBUG 844 if (peek_flag) { 845 peek_flag = 0; 846 len = peek_packet(data); 847 } 848 #endif 849 if (len == 0) 850 break; 851 852 #ifdef DSE_DEBUG 853 aprint_error_dev(sc->sc_dev, "dse_read: datalen = %d, packetlen" 854 " = %d, proto = 0x%04x\n", datalen, len, 855 ntohs(((struct ether_header *)data)->ether_type)); 856 #endif 857 if ((len < (DSE_MINSIZE + ETHER_CRC_LEN)) || 858 (MAX_BYTES_RX < len)) { 859 #ifdef DSE_DEBUG 860 aprint_error_dev(sc->sc_dev, "invalid packet size " 861 "%d; dropping\n", len); 862 #endif 863 if_statinc(ifp, if_ierrors); 864 break; 865 } 866 867 /* Don't need crc. Must keep ether header for BPF */ 868 m = dse_get(sc, data, len - ETHER_CRC_LEN); 869 if (m == NULL) { 870 #ifdef DSE_DEBUG 871 if (sc->sc_debug) 872 aprint_error_dev(sc->sc_dev, "dse_read: " 873 "dse_get returned null\n"); 874 #endif 875 if_statinc(ifp, if_ierrors); 876 goto next_packet; 877 } 878 if_statinc(ifp, if_ipackets); 879 880 /* 881 * Check if there's a BPF listener on this interface. 882 * If so, hand off the raw packet to BPF. 883 */ 884 if (ifp->if_bpf) 885 bpf_mtap(ifp, m, BPF_D_OUT); 886 887 /* Pass the packet up. */ 888 if_percpuq_enqueue(sc->sc_ipq, m); 889 890 next_packet: 891 data += len; 892 datalen -= len; 893 n++; 894 } 895 mutex_exit(&sc->sc_iflock); 896 897 return n; 898 } 899 900 901 static void 902 dsewatchdog(struct ifnet *ifp) 903 { 904 struct dse_softc *sc = ifp->if_softc; 905 906 log(LOG_ERR, "%s: device timeout\n", device_xname(sc->sc_dev)); 907 if_statinc(ifp, if_oerrors); 908 909 dse_reset(sc); 910 } 911 912 913 static int 914 dse_reset(struct dse_softc *sc) 915 { 916 int error; 917 #if 0 918 /* Maybe we don't *really* want to reset the entire bus 919 * because the ctron isn't working. We would like to send a 920 * "BUS DEVICE RESET" message, but don't think the ctron 921 * understands it. 922 */ 923 error = dse_scsipi_cmd(sc->sc_periph, 0, 0, 0, 0, DSE_RETRIES, 2000, 924 NULL, XS_CTL_RESET); 925 #endif 926 error = dse_init(sc); 927 return error; 928 } 929 930 931 static int 932 dse_init_adaptor(struct dse_softc *sc) 933 { 934 scsi_dayna_ether_generic cmd_vend1; 935 u_char tmpbuf[sizeof(cmd_vend1)]; 936 int error; 937 938 #if 0 /* 07/21/2001 for test */ 939 /* Maybe we don't *really* want to reset the entire bus 940 * because the ctron isn't working. We would like to send a 941 * "BUS DEVICE RESET" message, but don't think the ctron 942 * understands it. 943 */ 944 error = dse_scsipi_cmd(sc->sc_periph, 0, 0, 0, 0, DSE_RETRIES, 945 2000, NULL, XS_CTL_RESET); 946 #endif 947 948 cmd_vend1 = sonic_ether_vendor1; 949 950 error = dse_scsipi_cmd(sc->sc_periph, 951 (struct scsipi_generic *)&cmd_vend1, sizeof(cmd_vend1), 952 &(tmpbuf[0]), sizeof(tmpbuf), 953 DSE_RETRIES, DSE_TIMEOUT, NULL, XS_CTL_POLL | XS_CTL_DATA_IN); 954 955 if (error) 956 goto l_end; 957 958 /* wait 500 msec */ 959 kpause("dsesleep", false, hz / 2, NULL); 960 961 l_end: 962 return error; 963 } 964 965 966 static int 967 dse_get_addr(struct dse_softc *sc, uint8_t *myaddr) 968 { 969 scsi_dayna_ether_generic cmd_get_addr; 970 u_char tmpbuf[REQ_LEN_GET_ADDR]; 971 int error; 972 973 memset(&cmd_get_addr, 0, sizeof(cmd_get_addr)); 974 cmd_get_addr.opcode[0] = DAYNA_CMD_GET_ADDR; 975 _lto2b(REQ_LEN_GET_ADDR, cmd_get_addr.length); 976 977 error = dse_scsipi_cmd(sc->sc_periph, 978 (struct scsipi_generic *)&cmd_get_addr, sizeof(cmd_get_addr), 979 tmpbuf, sizeof(tmpbuf), 980 DSE_RETRIES, DSE_TIMEOUT, NULL, XS_CTL_POLL | XS_CTL_DATA_IN); 981 982 if (error == 0) { 983 memcpy(myaddr, &(tmpbuf[0]), ETHER_ADDR_LEN); 984 985 aprint_normal_dev(sc->sc_dev, "ethernet address %s\n", 986 ether_sprintf(myaddr)); 987 } 988 989 return error; 990 } 991 992 993 #if 0 /* 07/16/2000 comment-out */ 994 static int 995 dse_set_mode(struct dse_softc *sc, int len, int mode) 996 997 return 0; 998 } 999 #endif 1000 1001 1002 static int 1003 dse_init(struct dse_softc *sc) 1004 { 1005 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 1006 int error = 0; 1007 1008 if ((ifp->if_flags & (IFF_RUNNING | IFF_UP)) == IFF_UP) { 1009 ifp->if_flags |= IFF_RUNNING; 1010 mutex_enter(&sc->sc_iflock); 1011 if (!sc->sc_recv_work_pending) { 1012 sc->sc_recv_work_pending = true; 1013 workqueue_enqueue(sc->sc_recv_wq, &sc->sc_recv_work, 1014 NULL); 1015 } 1016 mutex_exit(&sc->sc_iflock); 1017 ifp->if_flags &= ~IFF_OACTIVE; 1018 mutex_enter(&sc->sc_iflock); 1019 if (!sc->sc_send_work_pending) { 1020 sc->sc_send_work_pending = true; 1021 workqueue_enqueue(sc->sc_send_wq, &sc->sc_send_work, 1022 NULL); 1023 } 1024 mutex_exit(&sc->sc_iflock); 1025 } 1026 return error; 1027 } 1028 1029 1030 static uint8_t BROADCAST_ADDR[ETHER_ADDR_LEN] = 1031 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 1032 1033 1034 static int 1035 dse_set_multi(struct dse_softc *sc) 1036 { 1037 scsi_dayna_ether_generic cmd_set_multi; 1038 struct ether_multistep step; 1039 struct ether_multi *enm; 1040 u_char *cp, *mybuf; 1041 int error, len; 1042 1043 error = 0; 1044 1045 #ifdef DSE_DEBUG 1046 aprint_error_dev(sc->sc_dev, "dse_set_multi\n"); 1047 #endif 1048 1049 mybuf = malloc(ETHER_ADDR_LEN * DSE_MCAST_MAX, M_DEVBUF, M_NOWAIT); 1050 if (mybuf == NULL) { 1051 error = EIO; 1052 goto l_end; 1053 } 1054 1055 /* 1056 * copy all entries to transfer buffer 1057 */ 1058 cp = mybuf; 1059 len = 0; 1060 ETHER_FIRST_MULTI(step, &(sc->sc_ethercom), enm); 1061 while ((len < (DSE_MCAST_MAX - 1)) && (enm != NULL)) { 1062 /* ### refer low side entry */ 1063 memcpy(cp, enm->enm_addrlo, ETHER_ADDR_LEN); 1064 1065 cp += ETHER_ADDR_LEN; 1066 len++; 1067 ETHER_NEXT_MULTI(step, enm); 1068 } 1069 1070 /* add broadcast address as default */ 1071 memcpy(cp, BROADCAST_ADDR, ETHER_ADDR_LEN); 1072 len++; 1073 1074 len *= ETHER_ADDR_LEN; 1075 1076 memset(&cmd_set_multi, 0, sizeof(cmd_set_multi)); 1077 cmd_set_multi.opcode[0] = DAYNA_CMD_SET_MULTI; 1078 _lto2b(len, cmd_set_multi.length); 1079 1080 error = dse_scsipi_cmd(sc->sc_periph, 1081 (struct scsipi_generic*)&cmd_set_multi, sizeof(cmd_set_multi), 1082 mybuf, len, DSE_RETRIES, DSE_TIMEOUT, NULL, XS_CTL_DATA_OUT); 1083 1084 free(mybuf, M_DEVBUF); 1085 1086 l_end: 1087 return error; 1088 } 1089 1090 1091 static void 1092 dse_stop(struct dse_softc *sc) 1093 { 1094 /* Don't schedule any reads */ 1095 callout_stop(&sc->sc_recv_ch); 1096 1097 /* Wait for the workqueues to finish */ 1098 mutex_enter(&sc->sc_iflock); 1099 workqueue_wait(sc->sc_recv_wq, &sc->sc_recv_work); 1100 workqueue_wait(sc->sc_send_wq, &sc->sc_send_work); 1101 mutex_exit(&sc->sc_iflock); 1102 1103 /* Abort any scsi cmds in progress */ 1104 mutex_enter(chan_mtx(sc->sc_periph->periph_channel)); 1105 scsipi_kill_pending(sc->sc_periph); 1106 mutex_exit(chan_mtx(sc->sc_periph->periph_channel)); 1107 } 1108 1109 1110 /* 1111 * Process an ioctl request. 1112 */ 1113 static int 1114 dse_ioctl(struct ifnet *ifp, u_long cmd, void *data) 1115 { 1116 struct dse_softc *sc; 1117 struct ifaddr *ifa; 1118 struct ifreq *ifr; 1119 struct sockaddr *sa; 1120 int error; 1121 1122 error = 0; 1123 sc = ifp->if_softc; 1124 ifa = (struct ifaddr *)data; 1125 ifr = (struct ifreq *)data; 1126 1127 switch (cmd) { 1128 case SIOCINITIFADDR: 1129 mutex_enter(&sc->sc_iflock); 1130 if ((error = dse_enable(sc)) != 0) 1131 break; 1132 ifp->if_flags |= IFF_UP; 1133 mutex_exit(&sc->sc_iflock); 1134 1135 #if 0 1136 if ((error = dse_set_media(sc, CMEDIA_AUTOSENSE)) != 0) 1137 break; 1138 #endif 1139 1140 switch (ifa->ifa_addr->sa_family) { 1141 #ifdef INET 1142 case AF_INET: 1143 if ((error = dse_init(sc)) != 0) 1144 break; 1145 arp_ifinit(ifp, ifa); 1146 break; 1147 #endif 1148 #ifdef NETATALK 1149 case AF_APPLETALK: 1150 if ((error = dse_init(sc)) != 0) 1151 break; 1152 break; 1153 #endif 1154 default: 1155 error = dse_init(sc); 1156 break; 1157 } 1158 break; 1159 1160 1161 case SIOCSIFADDR: 1162 mutex_enter(&sc->sc_iflock); 1163 error = dse_enable(sc); 1164 mutex_exit(&sc->sc_iflock); 1165 if (error != 0) 1166 break; 1167 ifp->if_flags |= IFF_UP; 1168 1169 switch (ifa->ifa_addr->sa_family) { 1170 #ifdef INET 1171 case AF_INET: 1172 if ((error = dse_init(sc)) != 0) 1173 break; 1174 arp_ifinit(ifp, ifa); 1175 break; 1176 #endif 1177 #ifdef NETATALK 1178 case AF_APPLETALK: 1179 if ((error = dse_init(sc)) != 0) 1180 break; 1181 break; 1182 #endif 1183 default: 1184 error = dse_init(sc); 1185 break; 1186 } 1187 break; 1188 1189 case SIOCSIFFLAGS: 1190 if ((error = ifioctl_common(ifp, cmd, data)) != 0) 1191 break; 1192 /* XXX re-use ether_ioctl() */ 1193 switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) { 1194 case IFF_RUNNING: 1195 /* 1196 * If interface is marked down and it is running, then 1197 * stop it. 1198 */ 1199 dse_stop(sc); 1200 mutex_enter(&sc->sc_iflock); 1201 ifp->if_flags &= ~IFF_RUNNING; 1202 dse_disable(sc); 1203 mutex_exit(&sc->sc_iflock); 1204 break; 1205 case IFF_UP: 1206 /* 1207 * If interface is marked up and it is stopped, then 1208 * start it. 1209 */ 1210 mutex_enter(&sc->sc_iflock); 1211 error = dse_enable(sc); 1212 mutex_exit(&sc->sc_iflock); 1213 if (error) 1214 break; 1215 error = dse_init(sc); 1216 break; 1217 default: 1218 /* 1219 * Reset the interface to pick up changes in any other 1220 * flags that affect hardware registers. 1221 */ 1222 mutex_enter(&sc->sc_iflock); 1223 if (sc->sc_enabled) 1224 error = dse_init(sc); 1225 mutex_exit(&sc->sc_iflock); 1226 break; 1227 } 1228 #ifdef DSE_DEBUG 1229 if (ifp->if_flags & IFF_DEBUG) 1230 sc->sc_debug = 1; 1231 else 1232 sc->sc_debug = 0; 1233 #endif 1234 break; 1235 1236 case SIOCADDMULTI: 1237 if (sc->sc_enabled == 0) { 1238 error = EIO; 1239 break; 1240 } 1241 mutex_enter(&sc->sc_iflock); 1242 sa = sockaddr_dup(ifreq_getaddr(cmd, ifr), M_WAITOK); 1243 mutex_exit(&sc->sc_iflock); 1244 if (ether_addmulti(sa, &sc->sc_ethercom) == ENETRESET) { 1245 error = dse_set_multi(sc); 1246 #ifdef DSE_DEBUG 1247 aprint_error_dev(sc->sc_dev, "add multi: %s\n", 1248 ether_sprintf(ifr->ifr_addr.sa_data)); 1249 #endif 1250 } else 1251 error = 0; 1252 1253 mutex_enter(&sc->sc_iflock); 1254 sockaddr_free(sa); 1255 mutex_exit(&sc->sc_iflock); 1256 1257 break; 1258 1259 case SIOCDELMULTI: 1260 if (sc->sc_enabled == 0) { 1261 error = EIO; 1262 break; 1263 } 1264 mutex_enter(&sc->sc_iflock); 1265 sa = sockaddr_dup(ifreq_getaddr(cmd, ifr), M_WAITOK); 1266 mutex_exit(&sc->sc_iflock); 1267 if (ether_delmulti(sa, &sc->sc_ethercom) == ENETRESET) { 1268 error = dse_set_multi(sc); 1269 #ifdef DSE_DEBUG 1270 aprint_error_dev(sc->sc_dev, "delete multi: %s\n", 1271 ether_sprintf(ifr->ifr_addr.sa_data)); 1272 #endif 1273 } else 1274 error = 0; 1275 1276 mutex_enter(&sc->sc_iflock); 1277 sockaddr_free(sa); 1278 mutex_exit(&sc->sc_iflock); 1279 1280 break; 1281 1282 default: 1283 error = ether_ioctl(ifp, cmd, data); 1284 break; 1285 } 1286 1287 1288 return error; 1289 } 1290 1291 1292 /* 1293 * Enable the network interface. 1294 */ 1295 int 1296 dse_enable(struct dse_softc *sc) 1297 { 1298 struct scsipi_periph *periph = sc->sc_periph; 1299 struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; 1300 int error = 0; 1301 1302 if (sc->sc_enabled == 0) { 1303 if ((error = scsipi_adapter_addref(adapt)) == 0) 1304 sc->sc_enabled = 1; 1305 else 1306 aprint_error_dev(sc->sc_dev, "device enable failed\n"); 1307 } 1308 1309 return error; 1310 } 1311 1312 1313 /* 1314 * Disable the network interface. 1315 */ 1316 void 1317 dse_disable(struct dse_softc *sc) 1318 { 1319 struct scsipi_periph *periph = sc->sc_periph; 1320 struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; 1321 if (sc->sc_enabled != 0) { 1322 scsipi_adapter_delref(adapt); 1323 sc->sc_enabled = 0; 1324 } 1325 } 1326 1327 1328 #define DSEUNIT(z) (minor(z)) 1329 1330 /* 1331 * open the device. 1332 */ 1333 int 1334 dseopen(dev_t dev, int flag, int fmt, struct lwp *l) 1335 { 1336 int unit, error; 1337 struct dse_softc *sc; 1338 struct scsipi_periph *periph; 1339 struct scsipi_adapter *adapt; 1340 1341 unit = DSEUNIT(dev); 1342 sc = device_lookup_private(&dse_cd, unit); 1343 if (sc == NULL) 1344 return ENXIO; 1345 1346 periph = sc->sc_periph; 1347 adapt = periph->periph_channel->chan_adapter; 1348 1349 if ((error = scsipi_adapter_addref(adapt)) != 0) 1350 return error; 1351 1352 SC_DEBUG(periph, SCSIPI_DB1, 1353 ("scopen: dev=0x%"PRIx64" (unit %d (of %d))\n", dev, unit, 1354 dse_cd.cd_ndevs)); 1355 1356 periph->periph_flags |= PERIPH_OPEN; 1357 1358 SC_DEBUG(periph, SCSIPI_DB3, ("open complete\n")); 1359 1360 return 0; 1361 } 1362 1363 1364 /* 1365 * close the device.. only called if we are the LAST 1366 * occurrence of an open device 1367 */ 1368 int 1369 dseclose(dev_t dev, int flag, int fmt, struct lwp *l) 1370 { 1371 struct dse_softc *sc = device_lookup_private(&dse_cd, DSEUNIT(dev)); 1372 struct scsipi_periph *periph = sc->sc_periph; 1373 struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; 1374 1375 SC_DEBUG(sc->sc_periph, SCSIPI_DB1, ("closing\n")); 1376 1377 scsipi_wait_drain(periph); 1378 1379 scsipi_adapter_delref(adapt); 1380 periph->periph_flags &= ~PERIPH_OPEN; 1381 1382 return 0; 1383 } 1384 1385 1386 /* 1387 * Perform special action on behalf of the user 1388 * Only does generic scsi ioctls. 1389 */ 1390 int 1391 dseioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l) 1392 { 1393 struct dse_softc *sc = device_lookup_private(&dse_cd, DSEUNIT(dev)); 1394 1395 return (scsipi_do_ioctl(sc->sc_periph, dev, cmd, addr, flag, l)); 1396 } 1397 1398
Indexes created Mon Sep 29 21:09:56 GMT 2025