Lines Matching refs:data
251 #define io_lock(data) acquire_sem(data->iolock)
252 #define io_unlock(data) release_sem_etc(data->iolock, 1, B_DO_NOT_RESCHEDULE)
257 #define output_wait(data, t) acquire_sem_etc(data->olock, 1, B_TIMEOUT, t)
258 #define output_unwait(data, c) release_sem_etc(data->olock, c, B_DO_NOT_RESCHEDULE)
263 #define input_wait(data) acquire_sem_etc(data->ilock ,1, B_CAN_INTERRUPT, 0)
264 #define input_unwait(data, c) release_sem_etc(data->ilock, c, B_DO_NOT_RESCHEDULE)
272 static status_t read_hook(void *data, off_t pos, void *buf, size_t *len);
273 static status_t write_hook(void *data, off_t pos, const void *buf, size_t *len);
274 //static int32 etherpci_interrupt(void *data); /* interrupt handler */
278 //static status_t enable_addressing(etherpci_private_t *data); /* enable pci io address space for device */
279 //static int domulti(etherpci_private_t *data,char *addr);
350 io_count(etherpci_private_t *data)
354 get_sem_count(data->iolock, &count);
361 output_count(etherpci_private_t *data)
365 get_sem_count(data->olock, &count);
374 input_count(etherpci_private_t *data)
378 get_sem_count(data->ilock, &count);
384 #define INTR_LOCK(data, expression) (expression)
391 #define intr_lock(data) acquire_spinlock(&data->intrlock)
392 #define intr_unlock(data) release_spinlock(&data->intrlock)
398 #define INTR_LOCK(data, expression) (intr_lock(data), (expression), intr_unlock(data))
409 calc_constants(etherpci_private_t *data)
411 data->EC_VMEM_PAGE = (data->ETHER_BUF_START >> EC_PAGE_SHIFT);
412 data->EC_VMEM_NPAGES = (data->ETHER_BUF_SIZE >> EC_PAGE_SHIFT);
414 data->EC_RXBUF_START_PAGE = (data->EC_VMEM_PAGE + 6);
415 data->EC_RXBUF_END_PAGE = (data->EC_VMEM_PAGE + data->EC_VMEM_NPAGES);
417 data->EC_RINGSTART = (data->EC_RXBUF_START_PAGE << EC_PAGE_SHIFT);
418 data->EC_RINGSIZE = ((data->EC_VMEM_NPAGES - 6) << EC_PAGE_SHIFT);
439 getisr(etherpci_private_t *data)
441 return ether_inb(data, EN0_ISR);
447 setisr(etherpci_private_t *data, unsigned char isr)
449 ether_outb(data, EN0_ISR, isr);
455 wait_for_dma_complete(etherpci_private_t *data, unsigned short addr,
469 while (!(getisr(data) & ISR_DMADONE) && ++bogus < MAXBOGUS) {
480 hi = ether_inb(data, EN0_RADDRHI);
481 low = ether_inb(data, EN0_RADDRLO);
494 setisr(data, ISR_DMADONE);
495 ether_outb(data, EN_CCMD, ENC_NODMA);
502 check_transmit_status(etherpci_private_t *data)
506 status = ether_inb(data, EN0_TPSR);
511 if (data->wints + data->werrs != data->writes) {
513 data->wints, data->werrs, data->writes);
520 inrw(etherpci_private_t *data)
522 return data->inrw;
527 create_sems(etherpci_private_t *data)
529 data->iolock = create_sem(1, "ethercard io");
530 if (data->iolock < B_OK)
531 return data->iolock;
533 data->olock = create_sem(1, "ethercard output");
534 if (data->olock < B_OK) {
535 delete_sem(data->iolock);
536 return data->olock;
539 data->ilock = create_sem(0, "ethercard input");
540 if (data->ilock < B_OK) {
541 delete_sem(data->iolock);
542 delete_sem(data->olock);
543 return data->ilock;
550 /*! Get data from the ne2000 card */
552 etherpci_min(etherpci_private_t *data, unsigned char *dst,
560 ether_outb(data, EN0_RCNTLO, len & 0xff);
561 ether_outb(data, EN0_RCNTHI, len >> 8);
562 ether_outb(data, EN0_RADDRLO, src & 0xff);
563 ether_outb(data, EN0_RADDRHI, src >> 8);
564 ether_outb(data, EN_CCMD, ENC_DMAREAD);
569 word = ether_inw(data, NE_DATA);
578 wait_for_dma_complete(data, src, len);
582 /*! Put data on the ne2000 card */
584 etherpci_mout(etherpci_private_t *data, unsigned dst,
604 ether_outb(data, EN0_RCNTHI, len >> 8);
605 ether_outb(data, EN0_RADDRLO, dst & 0xff);
606 ether_outb(data, EN0_RADDRHI, dst >> 8);
617 ether_outb(data, EN0_RCNTLO, 2);
619 ether_outb(data, EN0_RCNTLO, len & 0xff);
623 ether_outb(data, EN_CCMD, ENC_DMAREAD); /* Step 2 */
626 ether_outb(data, EN_CCMD, ENC_DMAWRITE);
636 ether_outw(data, NE_DATA, word);
643 ether_outw(data, NE_DATA, 0);
646 if (wait_for_dma_complete(data, dst, len) != 0) {
657 ringzero(etherpci_private_t *data, unsigned boundary,
669 if (data->boundary < next_boundary) {
670 pages = next_boundary - data->boundary;
672 pages = (data->EC_RINGSIZE >> EC_PAGE_SHIFT) - (data->boundary - next_boundary);
676 offset = data->boundary << EC_PAGE_SHIFT;
677 etherpci_mout(data, offset, (unsigned char *)&ring, sizeof(ring));
678 data->boundary++;
679 if (data->boundary >= data->EC_RXBUF_END_PAGE) {
680 data->boundary = data->EC_RXBUF_START_PAGE;
689 probe(etherpci_private_t *data)
697 data->ETHER_BUF_START = ETHER_BUF_START_NE2000;
698 data->ETHER_BUF_SIZE = ETHER_BUF_SIZE_NE2000;
699 calc_constants(data);
701 reg = ether_inb(data, NE_RESET);
703 ether_outb(data, NE_RESET, reg);
705 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_STOP | ENC_PAGE0);
709 reg_val = ether_inb(data, EN0_ISR);
715 ether_outb(data, EN0_ISR, 0xff);
716 ether_outb(data, EN0_DCFG, DCFG_BM16);
717 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_STOP | ENC_PAGE0);
721 reg = ether_inb(data, EN_CCMD);
727 ether_outb(data, EN0_TXCR, 0);
728 ether_outb(data, EN0_RXCR, ENRXCR_MON);
729 ether_outb(data, EN0_STARTPG, data->EC_RXBUF_START_PAGE);
730 ether_outb(data, EN0_STOPPG, data->EC_RXBUF_END_PAGE);
731 ether_outb(data, EN0_BOUNDARY, data->EC_RXBUF_END_PAGE);
732 ether_outb(data, EN0_IMR, 0);
733 ether_outb(data, EN0_ISR, 0);
734 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE1 | ENC_STOP);
735 ether_outb(data, EN1_CURPAG, data->EC_RXBUF_START_PAGE);
736 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE0 | ENC_STOP);
739 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE0);
740 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_STOP);
743 etherpci_min(data, (unsigned char *)&waddr[0], 0, sizeof(waddr));
746 data->myaddr.ebyte[i] = ((unsigned char *)&waddr[0])[2*i];
754 etherpci_mout(data, data->ETHER_BUF_START, (unsigned char *)&test[0], sizeof(test));
756 etherpci_min(data, (unsigned char *)&test[0], data->ETHER_BUF_START, sizeof(test));
766 print_address(&data->myaddr);
773 init(etherpci_private_t *data)
781 ringzero(data, data->EC_RXBUF_START_PAGE, data->EC_RXBUF_END_PAGE);
784 /* initialize data configuration register */
785 ether_outb(data, EN0_DCFG, DCFG_BM16);
788 ether_outb(data, EN0_RCNTLO, 0x0);
789 ether_outb(data, EN0_RCNTHI, 0x0);
792 ether_outb(data, EN0_RXCR, ENRXCR_BCST);
795 ether_outb(data, EN0_TXCR, TXCR_LOOPBACK);
798 ether_outb(data, EN0_BOUNDARY, data->EC_RXBUF_END_PAGE);
799 data->boundary = data->EC_RXBUF_START_PAGE;
800 ether_outb(data, EN0_STARTPG, data->EC_RXBUF_START_PAGE);
801 ether_outb(data, EN0_STOPPG, data->EC_RXBUF_END_PAGE);
804 ether_outb(data, EN0_TPSR, data->EC_VMEM_PAGE);
807 ether_outb(data, EN0_ISR, 0xff);
810 ether_outb(data, EN0_IMR, INTS_WE_CARE_ABOUT);
813 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE1);
817 ether_outb(data, EN1_PHYS + i, data->myaddr.ebyte[i]);
822 ether_outb(data, EN1_MULT+i, 0xff);
824 data->nmulti = 0;
827 ether_outb(data, EN1_CURPAG, data->EC_RXBUF_START_PAGE);
830 ether_outb(data, EN_CCMD, ENC_START | ENC_PAGE0 | ENC_NODMA);
833 ether_outb(data, EN0_TXCR, 0x00);
837 /*! Copy data from the card's ring buffer */
839 ringcopy(etherpci_private_t *data, unsigned char *ether_buf,
845 roffset = offset - data->EC_RINGSTART;
846 rem = data->EC_RINGSIZE - roffset;
848 etherpci_min(data, ðer_buf[0], offset, rem);
849 etherpci_min(data, ðer_buf[rem], data->EC_RINGSTART, len - rem);
851 etherpci_min(data, ðer_buf[0], offset, len);
862 setboundary(etherpci_private_t *data, unsigned char nextboundary)
864 if (nextboundary != data->EC_RXBUF_START_PAGE) {
865 ether_outb(data, EN0_BOUNDARY, nextboundary - 1);
868 ether_outb(data, EN0_BOUNDARY, data->EC_RXBUF_END_PAGE - 1);
870 data->boundary = nextboundary;
876 reset(etherpci_private_t *data)
881 cmd = ether_inb(data, EN_CCMD);
882 ether_outb(data, EN_CCMD, ENC_STOP | ENC_NODMA);
884 ether_outb(data, EN0_RCNTLO, 0x0);
885 ether_outb(data, EN0_RCNTHI, 0x0);
887 if(!(getisr(data) & (ISR_TRANSMIT | ISR_TRANSMIT_ERROR)))
891 ether_outb(data, EN0_TXCR, TXCR_LOOPBACK);
892 ether_outb(data, EN_CCMD, ENC_START | ENC_PAGE0 | ENC_NODMA);
899 finish_reset(etherpci_private_t *data, int resend)
901 setisr(data, ISR_OVERWRITE);
902 ether_outb(data, EN0_TXCR, 0x00);
906 ether_outb(data, EN_CCMD, ENC_START | ENC_PAGE0 | ENC_NODMA | ENC_TRANS);
915 etherpci_private_t *data = (etherpci_private_t *) _data;
920 data->ints++;
922 ETHER_DEBUG(INTERRUPT, data->debug, "ENTR isr=%x & %x?\n",getisr(data), INTS_WE_CARE_ABOUT);
923 for (INTR_LOCK(data, isr = getisr(data));
925 INTR_LOCK(data, isr = getisr(data))) {
927 data->rints++;
929 INTR_LOCK(data, setisr(data, ISR_RECEIVE));
934 data->werrs++;
935 INTR_LOCK(data, setisr(data, ISR_TRANSMIT_ERROR));
941 data->wints++;
942 INTR_LOCK(data, setisr(data, ISR_TRANSMIT));
949 err_count = ether_inb(data, EN0_CNTR0); data->frame_errs += err_count;
950 err_count = ether_inb(data, EN0_CNTR1); data->crc_errs += err_count;
951 err_count = ether_inb(data, EN0_CNTR2); data->frames_lost += err_count;
954 INTR_LOCK(data, setisr(data, ISR_RECEIVE_ERROR));
969 INTR_LOCK(data, setisr(data, ISR_COUNTER));
979 // isr,input_count(data), output_count(data),io_count(data),
980 // data->inrw,data->nonblocking);
981 INTR_LOCK(data, setisr(data, isr));
982 data->interrs++;
986 input_unwait(data, 1);
989 output_unwait(data, 1);
998 check_errors(etherpci_private_t *data)
1006 DOIT(data->rerrs, "Receive errors now %d\n");
1007 DOIT(data->werrs, "Transmit errors now %d\n");
1008 DOIT(data->interrs, "Interrupt errors now %d\n");
1009 DOIT(data->frames_lost, "Frames lost now %d\n");
1016 DOIT(data->frame_errs, "Frame alignment errors now %d\n");
1017 DOIT(data->crc_errs, "CRC errors now %d\n");
1024 more_packets(etherpci_private_t *data, int didreset)
1030 offset = data->boundary << EC_PAGE_SHIFT;
1031 etherpci_min(data, (unsigned char *)&ring, offset, sizeof(ring));
1043 intr_lock(data);
1044 ether_outb(data, EN_CCMD, ENC_PAGE1);
1045 cur = ether_inb(data, EN1_CURPAG);
1046 ether_outb(data, EN_CCMD, ENC_PAGE0);
1047 intr_unlock(data);
1055 return didreset || cur != data->boundary;
1062 copy_packet(etherpci_private_t *data, unsigned char *ether_buf,
1073 io_lock(data);
1074 check_errors(data);
1079 if (getisr(data) & ISR_OVERWRITE) {
1081 data->resets++;
1082 resend = reset(data);
1086 if (more_packets(data, didreset)) do {
1090 offset = data->boundary << EC_PAGE_SHIFT;
1091 etherpci_min(data, (unsigned char *)&ring, offset, sizeof(ring));
1097 ring.status, ring.next_packet, ring.count, data->boundary);
1100 ether_len = 0; setboundary(data, ring.next_packet);
1104 if (ring.next_packet < data->EC_RXBUF_START_PAGE
1105 || ring.next_packet >= data->EC_RXBUF_END_PAGE) {
1107 ring.status, ring.next_packet, ring.count, data->boundary);
1109 data->rerrs++;
1111 ether_len = 0; setboundary(data, ring.next_packet);
1119 ring.status, ring.next_packet, ring.count, data->boundary);
1121 data->rerrs++;
1123 ether_len = 0; setboundary(data, ring.next_packet);
1130 ringcopy(data, ether_buf, offset + 4, rlen);
1133 ringzero(data, data->boundary, ring.next_packet);
1137 setboundary(data, ring.next_packet);
1138 data->reads++;
1143 finish_reset(data, resend);
1146 if (input_count(data) <= 0 && more_packets(data, didreset)) {
1151 input_unwait(data, 1);
1154 io_unlock(data);
1161 my_packet(etherpci_private_t *data, char *addr)
1166 if (memcmp(addr, &data->myaddr, sizeof(data->myaddr)) == 0
1170 for (i = 0; i < data->nmulti; i++) {
1171 if (memcmp(addr, &data->multi[i], sizeof(data->multi[i])) == 0)
1180 enable_addressing(etherpci_private_t *data)
1185 data->reg_base = data->pciInfo->u.h0.base_registers[0];
1188 base = data->pciInfo->u.h0.base_registers[0];
1189 size = data->pciInfo->u.h0.base_register_sizes[0];
1195 offset = data->pciInfo->u.h0.base_registers[0] - base;
1201 if ((data->ioarea = map_physical_memory(kDevName "_regs", base, size,
1203 (void **)&data->reg_base)) < 0) {
1207 data->reg_base = data->reg_base + offset;
1210 dprintf(kDevName ": reg_base=%" B_PRIx32 "\n", data->reg_base);
1213 cmd = (gPCIModInfo->read_pci_config)(data->pciInfo->bus, data->pciInfo->device, data->pciInfo->function, PCI_command, 2);
1214 (gPCIModInfo->write_pci_config)(data->pciInfo->bus, data->pciInfo->device, data->pciInfo->function, PCI_command, 2, cmd | PCI_command_io);
1221 domulti(etherpci_private_t *data, char *addr)
1224 int nmulti = data->nmulti;
1230 if (memcmp(&data->multi[i], addr, sizeof(data->multi[i])) == 0) {
1239 memcpy(&data->multi[i], addr, sizeof(data->multi[i]));
1240 data->nmulti++;
1242 if (data->nmulti == 1) {
1244 ether_outb(data, EN0_RXCR, ENRXCR_BCST | ENRXCR_MCST);
1438 etherpci_private_t *data = (etherpci_private_t *) _data;
1443 atomic_add(&data->inrw, 1);
1444 if (data->interrupted) {
1445 atomic_add(&data->inrw, -1);
1450 if (!data->nonblocking) {
1451 input_wait(data);
1453 if (data->interrupted) {
1454 atomic_add(&data->inrw, -1);
1457 packet_len = copy_packet(data, (unsigned char *)buf, buflen);
1458 if ((packet_len) && (data->debug & RX)) {
1461 } while (!data->nonblocking && packet_len == 0 && !my_packet(data, buf));
1463 atomic_add(&data->inrw, -1);
1476 etherpci_private_t *data;
1492 if (!(*cookie = data = (etherpci_private_t *)malloc(sizeof(etherpci_private_t)))) {
1496 memset(data, 0, sizeof(etherpci_private_t));
1499 data->pciInfo = gDevList[devID];
1500 data->devID = devID;
1501 data->interrupted = 0;
1502 data->inrw = 0;
1503 data->nonblocking = 0;
1505 data->debug = DEFAULT_DEBUG_FLAGS;
1506 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": open %s dev=%p\n", name, data);
1509 gdev = data;
1514 if ((status = enable_addressing(data)) != B_OK)
1517 if (!probe(data)) {
1522 if (create_sems(data) != B_OK)
1526 install_io_interrupt_handler( data->pciInfo->u.h0.interrupt_line, etherpci_interrupt, *cookie, 0 );
1528 dprintf("Interrupts installed at %x\n", data->pciInfo->u.h0.interrupt_line);
1530 init(data);
1536 delete_area(data->ioarea);
1542 free(data);
1554 etherpci_private_t *data = (etherpci_private_t *)_data;
1555 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": close dev=%p\n", data);
1560 io_lock(data);
1561 data->interrupted = 1;
1562 input_unwait(data, 1);
1563 output_unwait(data, 1);
1564 io_unlock(data);
1565 while (inrw(data)) {
1573 ether_outb(data, EN_CCMD, ENC_STOP);
1579 remove_io_interrupt_handler(data->pciInfo->u.h0.interrupt_line, etherpci_interrupt, data);
1580 delete_sem(data->iolock);
1581 delete_sem(data->ilock);
1582 delete_sem(data->olock);
1587 data->ints = 0;
1588 data->rints = 0;
1589 data->rerrs = 0;
1590 data->wints = 0;
1591 data->werrs = 0;
1592 data->reads = 0;
1593 data->writes = 0;
1594 data->interrs = 0;
1595 data->resets = 0;
1596 data->frame_errs = 0;
1597 data->crc_errs = 0;
1598 data->frames_lost = 0;
1600 data->rerrs_last = 0;
1601 data->werrs_last = 0;
1602 data->interrs_last = 0;
1603 data->frame_errs_last = 0;
1604 data->crc_errs_last = 0;
1605 data->frames_lost_last = 0;
1607 data->chip_rx_frame_errors = 0;
1608 data->chip_rx_crc_errors = 0;
1609 data->chip_rx_missed_errors = 0;
1622 etherpci_private_t *data = (etherpci_private_t *)_data;
1625 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": free dev=%p\n", data);
1628 delete_area(data->ioarea);
1632 mask = 1L << data->devID;
1635 free(data);
1643 etherpci_private_t *data = (etherpci_private_t *) _data;
1648 atomic_add(&data->inrw, 1);
1649 if (data->interrupted) {
1650 atomic_add(&data->inrw, -1);
1656 status = output_wait(data, ETHER_TRANSMIT_TIMEOUT);
1657 if (status < B_NO_ERROR || data->interrupted) {
1658 atomic_add(&data->inrw, -1);
1662 io_lock(data);
1663 check_errors(data);
1665 if (data->writes > 0)
1666 check_transmit_status(data);
1668 etherpci_mout(data, data->ETHER_BUF_START, (const unsigned char *)buf, buflen);
1675 ether_outb(data, EN0_TCNTLO, (char)(buflen & 0xff));
1676 ether_outb(data, EN0_TCNTHI, (char)(buflen >> 8));
1677 ether_outb(data, EN_CCMD, ENC_NODMA | ENC_TRANS);
1678 data->writes++;
1679 io_unlock(data);
1680 atomic_add(&data->inrw, -1);
1683 if (data->debug & TX)
1694 etherpci_private_t *data = (etherpci_private_t *) _data;
1698 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: ETHER_INIT \n");
1702 if (data == NULL)
1705 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: GET_ADDR \n");
1706 memcpy(buf, &data->myaddr, sizeof(data->myaddr));
1710 if (data == NULL)
1713 memcpy(&data->nonblocking, buf, sizeof(data->nonblocking));
1714 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: NON_BLOCK %x\n", data->nonblocking);
1718 ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: DO_MULTI\n");
1719 return domulti(data, (char *)buf);