WebSVN – Kolibri OS – Diff – /drivers/ethernet/pcnet32.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                  ;;
;; Copyright (C) KolibriOS team 2004-2014. All rights reserved.     ;;
;; Distributed under terms of the GNU General Public License        ;;
;;                                                                  ;;
;;  AMD PCnet driver for KolibriOS                                  ;;
;;                                                                  ;;
;;  By hidnplayr & clevermouse                                      ;;
;;                                                                  ;;
;;  Based on the PCnet32 driver for MenuetOS, by Jarek Pelczar      ;;
;;                                                                  ;;
;;          GNU GENERAL PUBLIC LICENSE                              ;;
;;             Version 2, June 1991                                 ;;
;;                                                                  ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
format PE DLL native
entry START
 
        CURRENT_API             = 0x0200
        COMPATIBLE_API          = 0x0100
        API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
 
        MAX_DEVICES             = 16
 
        __DEBUG__               = 1
        __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 
        TX_RING_SIZE            = 4
        RX_RING_SIZE            = 4
 
section '.flat' readable writable executable
 
include '../struct.inc'
include '../macros.inc'
include '../proc32.inc'
include '../fdo.inc'
include '../netdrv_pe.inc'
 
 
        PORT_AUI                = 0x00
        PORT_10BT               = 0x01
        PORT_GPSI               = 0x02
        PORT_MII                = 0x03
        PORT_PORTSEL            = 0x03
        PORT_ASEL               = 0x04
        PORT_100                = 0x40
        PORT_FD                 = 0x80
 
        DMA_MASK                = 0xffffffff
 
        LOG_TX_BUFFERS          = 2             ; FIXME
        LOG_RX_BUFFERS          = 2
 
        TX_RING_MOD_MASK        = (TX_RING_SIZE-1)
        TX_RING_LEN_BITS        = (LOG_TX_BUFFERS shl 12)
 
        RX_RING_MOD_MASK        = (RX_RING_SIZE-1)
        RX_RING_LEN_BITS        = (LOG_RX_BUFFERS shl 4)
 
        PKT_BUF_SZ              = 1544
 
        WIO_RDP                 = 0x10
        WIO_RAP                 = 0x12
        WIO_RESET               = 0x14
        WIO_BDP                 = 0x16
 
        DWIO_RDP                = 0x10
        DWIO_RAP                = 0x14
        DWIO_RESET              = 0x18
        DWIO_BDP                = 0x1C
 
; CSR registers
 
        CSR_CSR                 = 0x00
        CSR_IAB0                = 0x01
        CSR_IAB1                = 0x02
        CSR_IMR                 = 0x03
        CSR_TFEAT               = 0x04
        CSR_EXTCTL1             = 0x05
        CSR_DTBLLEN             = 0x06
        CSR_EXTCTL2             = 0x07
        CSR_MAR0                = 0x08
        CSR_MAR1                = 0x09
        CSR_MAR2                = 0x0A
        CSR_MAR3                = 0x0B
        CSR_PAR0                = 0x0C
        CSR_PAR1                = 0x0D
        CSR_PAR2                = 0x0E
        CSR_MODE                = 0x0F
        CSR_RXADDR0             = 0x18
        CSR_RXADDR1             = 0x19
        CSR_TXADDR0             = 0x1E
        CSR_TXADDR1             = 0x1F
        CSR_TXPOLL              = 0x2F
        CSR_RXPOLL              = 0x31
        CSR_RXRINGLEN           = 0x4C
        CSR_TXRINGLEN           = 0x4E
        CSR_DMACTL              = 0x50
        CSR_BUSTIMER            = 0x52
        CSR_MEMERRTIMEO         = 0x64
        CSR_ONNOWMISC           = 0x74
        CSR_ADVFEAT             = 0x7A
        CSR_MACCFG              = 0x7D
        CSR_CHIPID0             = 0x58
        CSR_CHIPID1             = 0x59
 
; Control and Status Register (CSR0)
 
        CSR_INIT                = 1 shl 0
        CSR_START               = 1 shl 1
        CSR_STOP                = 1 shl 2
        CSR_TX                  = 1 shl 3
        CSR_TXON                = 1 shl 4
        CSR_RXON                = 1 shl 5
        CSR_INTEN               = 1 shl 6
        CSR_INTR                = 1 shl 7
        CSR_IDONE               = 1 shl 8
        CSR_TINT                = 1 shl 9
        CSR_RINT                = 1 shl 10
        CSR_MERR                = 1 shl 11
        CSR_MISS                = 1 shl 12
        CSR_CERR                = 1 shl 13
 
; Interrupt masks and deferral control (CSR3)
 
        IMR_BSWAP               = 0x0004
        IMR_ENMBA               = 0x0008  ; enable modified backoff alg
        IMR_DXMT2PD             = 0x0010
        IMR_LAPPEN              = 0x0020  ; lookahead packet processing enb
        IMR_DXSUFLO             = 0x0040  ; disable TX stop on underflow
        IMR_IDONE               = 0x0100
        IMR_TINT                = 0x0200
        IMR_RINT                = 0x0400
        IMR_MERR                = 0x0800
        IMR_MISS                = 0x1000
 
        IMR                     = IMR_IDONE ; IMR_TINT + IMR_RINT + IMR_MERR + IMR_MISS ;+ IMR_IDONE
 
; Test and features control (CSR4)
 
        TFEAT_TXSTRTMASK        = 0x0004
        TFEAT_TXSTRT            = 0x0008
        TFEAT_RXCCOFLOWM        = 0x0010  ; Rx collision counter oflow
        TFEAT_RXCCOFLOW         = 0x0020
        TFEAT_UINT              = 0x0040
        TFEAT_UINTREQ           = 0x0080
        TFEAT_MISSOFLOWM        = 0x0100
        TFEAT_MISSOFLOW         = 0x0200
        TFEAT_STRIP_FCS         = 0x0400
        TFEAT_PAD_TX            = 0x0800
        TFEAT_TXDPOLL           = 0x1000
        TFEAT_DMAPLUS           = 0x4000
 
; Extended control and interrupt 1 (CSR5)
 
        EXTCTL1_SPND            = 0x0001  ; suspend
        EXTCTL1_MPMODE          = 0x0002  ; magic packet mode
        EXTCTL1_MPENB           = 0x0004  ; magic packet enable
        EXTCTL1_MPINTEN         = 0x0008  ; magic packet interrupt enable
        EXTCTL1_MPINT           = 0x0010  ; magic packet interrupt
        EXTCTL1_MPPLBA          = 0x0020  ; magic packet phys. logical bcast
        EXTCTL1_EXDEFEN         = 0x0040  ; excessive deferral interrupt enb.
        EXTCTL1_EXDEF           = 0x0080  ; excessive deferral interrupt
        EXTCTL1_SINTEN          = 0x0400  ; system interrupt enable
        EXTCTL1_SINT            = 0x0800  ; system interrupt
        EXTCTL1_LTINTEN         = 0x4000  ; last TX interrupt enb
        EXTCTL1_TXOKINTD        = 0x8000  ; TX OK interrupt disable
 
; RX/TX descriptor len (CSR6)
 
        DTBLLEN_RLEN            = 0x0F00
        DTBLLEN_TLEN            = 0xF000
 
; Extended control and interrupt 2 (CSR7)
 
        EXTCTL2_MIIPDTINTE      = 0x0001
        EXTCTL2_MIIPDTINT       = 0x0002
        EXTCTL2_MCCIINTE        = 0x0004
        EXTCTL2_MCCIINT         = 0x0008
        EXTCTL2_MCCINTE         = 0x0010
        EXTCTL2_MCCINT          = 0x0020
        EXTCTL2_MAPINTE         = 0x0040
        EXTCTL2_MAPINT          = 0x0080
        EXTCTL2_MREINTE         = 0x0100
        EXTCTL2_MREINT          = 0x0200
        EXTCTL2_STINTE          = 0x0400
        EXTCTL2_STINT           = 0x0800
        EXTCTL2_RXDPOLL         = 0x1000
        EXTCTL2_RDMD            = 0x2000
        EXTCTL2_RXFRTG          = 0x4000
        EXTCTL2_FASTSPNDE       = 0x8000
 
; Mode (CSR15)
 
        MODE_RXD                = 0x0001  ; RX disable
        MODE_TXD                = 0x0002  ; TX disable
        MODE_LOOP               = 0x0004  ; loopback enable
        MODE_TXCRCD             = 0x0008
        MODE_FORCECOLL          = 0x0010
        MODE_RETRYD             = 0x0020
        MODE_INTLOOP            = 0x0040
        MODE_PORTSEL            = 0x0180
        MODE_RXVPAD             = 0x2000
        MODE_RXNOBROAD          = 0x4000
        MODE_PROMISC            = 0x8000
 
; BCR (Bus Control Registers)
 
        BCR_MMRA                = 0x00    ; Master Mode Read Active
        BCR_MMW                 = 0x01    ; Master Mode Write Active
        BCR_MISCCFG             = 0x02
        BCR_LED0                = 0x04
        BCR_LED1                = 0x05
        BCR_LED2                = 0x06
        BCR_LED3                = 0x07
        BCR_DUPLEX              = 0x09
        BCR_BUSCTL              = 0x12
        BCR_EECTL               = 0x13
        BCR_SSTYLE              = 0x14
        BCR_PCILAT              = 0x16
        BCR_PCISUBVENID         = 0x17
        BCR_PCISUBSYSID         = 0x18
        BCR_SRAMSIZE            = 0x19
        BCR_SRAMBOUND           = 0x1A
        BCR_SRAMCTL             = 0x1B
        BCR_MIICTL              = 0x20
        BCR_MIIADDR             = 0x21
        BCR_MIIDATA             = 0x22
        BCR_PCIVENID            = 0x23
        BCR_PCIPCAP             = 0x24
        BCR_DATA0               = 0x25
        BCR_DATA1               = 0x26
        BCR_DATA2               = 0x27
        BCR_DATA3               = 0x28
        BCR_DATA4               = 0x29
        BCR_DATA5               = 0x2A
        BCR_DATA6               = 0x2B
        BCR_DATA7               = 0x2C
        BCR_ONNOWPAT0           = 0x2D
        BCR_ONNOWPAT1           = 0x2E
        BCR_ONNOWPAT2           = 0x2F
        BCR_PHYSEL              = 0x31
 
; RX status register
 
        RXSTAT_BPE              = 0x0080        ; bus parity error
        RXSTAT_ENP              = 0x0100        ; end of packet
        RXSTAT_STP              = 0x0200        ; start of packet
        RXSTAT_BUFF             = 0x0400        ; buffer error
        RXSTAT_CRC              = 0x0800        ; CRC error
        RXSTAT_OFLOW            = 0x1000        ; rx overrun
        RXSTAT_FRAM             = 0x2000        ; framing error
        RXSTAT_ERR              = 0x4000        ; error summary
        RXSTAT_OWN              = 0x8000
 
; TX status register
 
        TXSTAT_TRC              = 0x0000000F    ; transmit retries
        TXSTAT_RTRY             = 0x04000000    ; retry
        TXSTAT_LCAR             = 0x08000000    ; lost carrier
        TXSTAT_LCOL             = 0x10000000    ; late collision
        TXSTAT_EXDEF            = 0x20000000    ; excessive deferrals
        TXSTAT_UFLOW            = 0x40000000    ; transmit underrun
        TXSTAT_BUFF             = 0x80000000    ; buffer error
 
        TXCTL_OWN               = 0x8000
        TXCTL_ERR               = 0x4000        ; error summary
        TXCTL_ADD_FCS           = 0x2000        ; add FCS to pkt
        TXCTL_MORE_LTINT        = 0x1000
        TXCTL_ONE               = 0x0800
        TXCTL_DEF               = 0x0400
        TXCTL_STP               = 0x0200
        TXCTL_ENP               = 0x0100
        TXCTL_BPE               = 0x0080
 
        TXCTL_MBO               = 0x0000F000
        TXCTL_BUFSZ             = 0x00000FFF
 
        MAX_PHYS                = 32
 
 
struct  device          ETH_DEVICE
 
        rb 0x100-($ and 0xff)   ; align 256
 
; Pcnet configuration structure
        mode            dw ?
        tlen_rlen       dw ?
        phys_addr       dp ?
        reserved        dw ?
        filter          dq ?
        rx_ring_phys    dd ?
        tx_ring_phys    dd ?
; end of pcnet config struct
 
        rb 0x100-($ and 0xff)   ; align 256
 
        rx_ring         rb RX_RING_SIZE * sizeof.descriptor
 
        rb 0x100-($ and 0xff)   ; align 256
 
        tx_ring         rb TX_RING_SIZE * sizeof.descriptor
 
        cur_rx          db ?
        cur_tx          db ?
        last_tx         db ?
        options         dd ?
        full_duplex     db ?
        chip_version    dw ?
        mii             db ?
        ltint           db ?
        dxsuflo         db ?
        fset            db ?
        fdx             db ?
 
        io_addr         dd ?
        irq_line        db ?
        pci_bus         dd ?
        pci_dev         dd ?
 
        phy             dw ?
 
        read_csr        dd ?
        write_csr       dd ?
        read_bcr        dd ?
        write_bcr       dd ?
        read_rap        dd ?
        write_rap       dd ?
        sw_reset        dd ?
 
ends
 
struct  descriptor
 
        base            dd ?
        length          dw ?
        status          dw ?
        msg_length      dw ?
        misc            dw ?
        virtual         dd ?
 
ends
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc START             ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc START c, reason:dword, cmdline:dword
 
        cmp     [reason], DRV_ENTRY
        jne     .fail
 
        DEBUGF  2,"Loading driver\n"
        invoke  RegService, my_service, service_proc
        ret
 
  .fail:
        xor eax, eax
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;; proc SERVICE_PROC      ;;
;;                        ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
proc service_proc stdcall, ioctl:dword
 
        mov     edx, [ioctl]
        mov     eax, [edx + IOCTL.io_code]
 
;------------------------------------------------------
 
        cmp     eax, 0 ;SRV_GETVERSION
        jne     @F
 
        cmp     [edx + IOCTL.out_size], 4
        jb      .fail
        mov     eax, [edx + IOCTL.output]
        mov     [eax], dword API_VERSION
 
        xor     eax, eax
        ret
 
;------------------------------------------------------
  @@:
        cmp     eax, 1 ;SRV_HOOK
        jne     .fail
 
        cmp     [edx + IOCTL.inp_size], 3               ; Data input must be at least 3 bytes
        jb      .fail
 
        mov     eax, [edx + IOCTL.input]
        cmp     byte[eax], 1                            ; 1 means device number and bus number (pci) are given
        jne     .fail                                   ; other types arent supported for this card yet
 
; check if the device is already listed
 
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .firstdevice
 
        mov     esi, device_list
;        mov     eax, [edx + IOCTL.input]                ; get the pci bus and device numbers
        mov     ax, [eax+1]                             ;
  .nextdevice:
        mov     ebx, [esi]
        cmp     al, byte[ebx + device.pci_bus]
        jne     @f
        cmp     ah, byte[ebx + device.pci_dev]
        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
       @@:
        add     esi, 4
        loop    .nextdevice
 
; This device doesnt have its own eth_device structure yet, lets create one
 
  .firstdevice:
        cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
        jae     .fail
 
        allocate_and_clear ebx, sizeof.device, .fail
 
; Fill in the direct call addresses into the struct
 
        mov     [ebx + device.reset], reset
        mov     [ebx + device.transmit], transmit
        mov     [ebx + device.unload], unload
        mov     [ebx + device.name], my_service
 
; save the pci bus and device numbers
 
        mov     eax, [edx + IOCTL.input]
        movzx   ecx, byte[eax+1]
        mov     [ebx + device.pci_bus], ecx
        movzx   ecx, byte[eax+2]
        mov     [ebx + device.pci_dev], ecx
 
; Now, it's time to find the base io addres of the PCI device
 
        stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
        mov     [ebx + device.io_addr], eax
 
; We've found the io address, find IRQ now
 
        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
        mov     [ebx + device.irq_line], al
 
        DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4
 
; Ok, the eth_device structure is ready, let's probe the device
; Because initialization fires IRQ, IRQ handler must be aware of this device
        mov     eax, [devices]                                          ; Add the device structure to our device list
        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
        inc     [devices]                                               ;
 
        call    probe                                                   ; this function will output in eax
        test    eax, eax
        jnz     .destroy                                                ; If an error occured, exit
 
        mov     [ebx + device.type], NET_TYPE_ETH
        invoke  NetRegDev
        cmp     eax, -1
        je      .destroy
 
        ret
 
; If the device was already loaded, find the device number and return it in eax
 
  .find_devicenum:
        DEBUGF  1,"Trying to find device number of already registered device\n"
        invoke  NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
                                                                        ; into a device number in edi
        mov     eax, edi                                                ; Application wants it in eax instead
        DEBUGF  1,"Kernel says: %u\n", eax
        ret
 
; If an error occured, remove all allocated data and exit (returning -1 in eax)
 
  .destroy:
        ; todo: reset device into virgin state
 
        dec     [devices]
  .err:
        DEBUGF  2,"Error, removing all data !\n"
        invoke  KernelFree, ebx
 
  .fail:
        or      eax, -1
        ret
 
;------------------------------------------------------
endp
 
 
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;;                                                                        ;;
;;        Actual Hardware dependent code starts here                      ;;
;;                                                                        ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 
align 4
unload:
        ; TODO: (in this particular order)
        ;
        ; - Stop the device
        ; - Detach int handler
        ; - Remove device from local list (device_list)
        ; - call unregister function in kernel
        ; - Remove all allocated structures and buffers the card used
 
        or      eax,-1
 
ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;  probe: enables the device (if it really is a PCnet device)
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
probe:
 
        mov     edx, [ebx + device.io_addr]
 
        call    wio_reset
 
        xor     ecx, ecx
        call    wio_read_csr
        cmp     eax, 4
        jne     .try_dwio
 
        ; Try Word I/O
        mov     ax, 88
        add     edx, WIO_RAP
        out     dx, ax
        nop
        nop
        in      ax, dx
        sub     edx, WIO_RAP
        cmp     ax, 88
        jne     .try_dwio
 
        call    switch_to_wio
 
        jmp     .L1
 
  .try_dwio:
        call    dwio_reset
 
        xor     ecx, ecx
        call    dwio_read_csr
        cmp     eax, 4
        jne     .no_dev
 
        ; Try Dword I/O
        add     edx, DWIO_RAP
        mov     eax, 88
        out     dx, eax
        nop
        nop
        in      eax, dx
        sub     edx, DWIO_RAP
        and     eax, 0xffff
        cmp     eax, 88
        jne     .no_dev
 
        call    switch_to_dwio
 
        jmp     .L1
 
  .no_dev:
        DEBUGF  2,"device not found!\n"
        mov     eax, 1
        ret
 
  .L1:
        mov     ecx, CSR_CHIPID0
        call    [ebx + device.read_csr]
 
        mov     esi, eax
        shr     esi, 12
 
        and     ax, 0xfff
        cmp     ax, 3
        jne     .no_dev
 
        mov     ecx, CSR_CHIPID1
        call    [ebx + device.read_csr]
        shl     eax, 4
        or      eax, esi
        mov     [ebx + device.chip_version], ax
 
        mov     [ebx + device.fdx], 0
        mov     [ebx + device.mii], 0
        mov     [ebx + device.fset], 0
        mov     [ebx + device.dxsuflo], 0
        mov     [ebx + device.ltint], 0
 
        cmp     ax, 0x2420
        je      .L2
        cmp     ax, 0x2430
        je      .L2
 
        mov     [ebx + device.fdx], 1
 
        cmp     ax, 0x2621
        je      .L4
        cmp     ax, 0x2623
        je      .L5
        cmp     ax, 0x2624
        je      .L6
        cmp     ax, 0x2625
        je      .L7
        cmp     ax, 0x2626
        je      .L8
        cmp     ax, 0x2627
        je      .L9
 
        DEBUGF  1,"Invalid chip rev\n"
        jmp     .no_dev
  .L2:
        mov     [ebx + device.name], device_l2
        jmp     .L10
  .L4:
        mov     [ebx + device.name], device_l4
;        mov     [ebx + device.fdx], 1
        jmp     .L10
  .L5:
        mov     [ebx + device.name], device_l5
;        mov     [ebx + device.fdx], 1
        mov     [ebx + device.mii], 1
        mov     [ebx + device.fset], 1
        mov     [ebx + device.ltint], 1
        jmp     .L10
  .L6:
        mov     [ebx + device.name], device_l6
;        mov     [ebx + device.fdx], 1
        mov     [ebx + device.mii], 1
        mov     [ebx + device.fset], 1
        jmp     .L10
  .L7:
        mov     [ebx + device.name], device_l7
;        mov     [ebx + device.fdx], 1
        mov     [ebx + device.mii], 1
        jmp     .L10
  .L8:
        mov     [ebx + device.name], device_l8
;        mov     [ebx + device.fdx], 1
        mov     ecx, CSR_RXPOLL
        call    dword [ebx + device.read_bcr]
        call    dword [ebx + device.write_bcr]
        jmp     .L10
  .L9:
        mov     [ebx + device.name], device_l9
;        mov     [ebx + device.fdx], 1
        mov     [ebx + device.mii], 1
  .L10:
        DEBUGF  1,"device name: %s\n", [ebx + device.name]
 
        cmp     [ebx + device.fset], 1
        jne     .L11
        mov     ecx, BCR_BUSCTL
        call    [ebx + device.read_bcr]
        or      eax, 0x800
        call    [ebx + device.write_bcr]
 
        mov     ecx, CSR_DMACTL
        call    [ebx + device.read_csr]
;        and     eax, 0xc00
;        or      eax, 0xc00
        mov     eax, 0xc00
        call    [ebx + device.write_csr]
 
        mov     [ebx + device.dxsuflo],1
        mov     [ebx + device.ltint],1
  .L11:
 
; Make the device a bus master
        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
        or      al, PCI_CMD_MASTER
        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
 
        mov     [ebx + device.options], PORT_ASEL
        mov     [ebx + device.mode], MODE_RXD + MODE_TXD     ; disable receive and transmit
        mov     [ebx + device.tlen_rlen], (TX_RING_LEN_BITS or RX_RING_LEN_BITS)
 
        mov     dword[ebx + device.filter], 0
        mov     dword[ebx + device.filter+4], 0
 
align 4
reset:
 
; attach int handler
 
        movzx   eax, [ebx + device.irq_line]
        DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
        invoke  AttachIntHandler, eax, int_handler, ebx
        test    eax, eax
        jnz     @f
        DEBUGF  2,"Could not attach int handler!\n"
        or      eax, -1
        ret
  @@:
 
        mov     edx, [ebx + device.io_addr]
        call    [ebx + device.sw_reset]
 
        ; Switch pcnet32 to 32bit mode
        mov     ecx, BCR_SSTYLE
        mov     eax, 2
        call    [ebx + device.write_bcr]
 
        ; set/reset autoselect bit
        mov     ecx, BCR_MISCCFG
        call    [ebx + device.read_bcr]
        and     eax, not 2
        test    [ebx + device.options], PORT_ASEL
        jz      @f
        or      eax, 2
  @@:
        call    [ebx + device.write_bcr]
 
        ; Handle full duplex setting
        cmp     byte [ebx + device.full_duplex], 0
        je      .duplex_ok
        mov     ecx, BCR_DUPLEX
        call    [ebx + device.read_bcr]
        and     eax, not 3
        test    [ebx + device.options], PORT_FD
        jz      @f
        or      eax, 1
        cmp     [ebx + device.options], PORT_FD or PORT_AUI
        jne     .set_duplex
        or      eax, 2
        jmp     .set_duplex
  @@:
        test    [ebx + device.options], PORT_ASEL
        jz      .set_duplex
        cmp     [ebx + device.chip_version], 0x2627
        jne     .set_duplex
        or      eax, 3
  .set_duplex:
        mov     ecx, BCR_DUPLEX
        call    [ebx + device.write_bcr]
  .duplex_ok:
 
        ; set/reset GPSI bit in test register
        mov     ecx, 124
        call    [ebx + device.read_csr]
        mov     ecx, [ebx + device.options]
        and     ecx, PORT_PORTSEL
        cmp     ecx, PORT_GPSI
        jne     @f
        or      eax, 0x10
  @@:
        call    [ebx + device.write_csr]
        cmp     [ebx + device.mii], 0
        je      .L6
        test    [ebx + device.options], PORT_ASEL
        jnz     .L6
        mov     ecx, BCR_MIICTL
        call    [ebx + device.read_bcr]
        and     eax, not 0x38
        test    [ebx + device.options], PORT_FD
        jz      @f
        or      eax, 0x10
  @@:
        test    [ebx + device.options], PORT_100
        jz      @f
        or      eax, 0x08
  @@:
        call    [ebx + device.write_bcr]
        jmp     .L9
  .L6:
        test    [ebx + device.options], PORT_ASEL
        jz      .L9
        mov     ecx, BCR_MIICTL
        DEBUGF  1,"ASEL, enable auto-negotiation\n"
        call    [ebx + device.read_bcr]
        and     eax, not 0x98
        or      eax, 0x20
        call    [ebx + device.write_bcr]
  .L9:
        cmp     [ebx + device.ltint], 0
        je      @f
        mov     ecx, 5
        call    [ebx + device.read_csr]
        or      eax, (1 shl 14)
        call    [ebx + device.write_csr]
  @@:
        mov     eax, [ebx + device.options]
        and     eax, PORT_PORTSEL
        shl     eax, 7
        mov     [ebx + device.mode], ax
        mov     dword [ebx + device.filter], -1
        mov     dword [ebx + device.filter+4], -1
 
 
 
;-----------------------------
 
        test    [ebx + device.mii], 1
        jz      .no_mii
 
        mov     [ebx + device.phy], 0
 
  .mii_loop:
        mov     ecx, MII_PHYSID1
        call    mdio_read
        cmp     ax, 0xffff
        je      .next
 
        DEBUGF  1, "0x%x\n", ax
 
        mov     ecx, MII_PHYSID2
        call    mdio_read
        cmp     ax, 0xffff
        je      .next
 
        DEBUGF  1, "0x%x\n", ax
 
        jmp     .got_phy
 
        cmp     [ebx + device.phy], 31
        jne     .next
        mov     ax, [ebx + device.chip_version]
        inc     ax
        and     ax, 0xfffe
        cmp     ax, 0x2624              ; 79c971 & 79c972 have phantom phy at id 31
        je      .got_phy
 
  .next:
        inc     [ebx + device.phy]
        cmp     [ebx + device.phy], MAX_PHYS
        jb      .mii_loop
 
        DEBUGF  2, "No PHY found!\n"
        or      eax, -1
        ret
 
  .got_phy:
        DEBUGF  1, "Found PHY at 0x%x\n", [ebx + device.phy]:4
 
  .no_mii:
 
;-----------------------------------------------
 
        call    read_mac
 
        lea     esi, [ebx + device.mac]
        lea     edi, [ebx + device.phys_addr]
        movsd
        movsw
 
        call    init_ring
 
        mov     edx, [ebx + device.io_addr]   ; init ring destroys edx
 
        lea     eax, [ebx + device.mode]
        invoke  GetPhysAddr
        push    eax
        and     eax, 0xffff
        mov     ecx, 1
        call    [ebx + device.write_csr]
        pop     eax
        shr     eax, 16
        mov     ecx, 2
        call    [ebx + device.write_csr]
 
        mov     ecx, 4
        mov     eax, 0x0915
        call    [ebx + device.write_csr]
 
; Set the interrupt mask
        mov     ecx, CSR_IMR
        mov     eax, IMR
        call    [ebx + device.write_csr]
 
; Initialise the device
        xor     ecx, ecx
        mov     eax, CSR_INIT
        call    [ebx + device.write_csr]
 
        mov     esi, 100
;        xor     ecx, ecx
  @@:
        call    [ebx + device.read_csr]
        test    ax, CSR_IDONE
        jnz     @f
 
        dec     esi
        jnz     @r
        DEBUGF  2,"Initialize timeout!\n"
  @@:
 
; Start the device and enable interrupts
        xor     ecx, ecx
        mov     eax, CSR_START + CSR_INTEN
        call    [ebx + device.write_csr]
 
; Set the mtu, kernel will be able to send now
        mov     [ebx + device.mtu], 1514
 
; get link status
        mov     [ebx + device.state], ETH_LINK_UNKNOWN
 
        call    check_media
 
        DEBUGF  1,"reset complete\n"
        xor     eax, eax
        ret
 
 
align 4
init_ring:
 
        DEBUGF  1,"init ring\n"
 
        lea     edi, [ebx + device.rx_ring]
        mov     eax, edi
        invoke  GetPhysAddr
        mov     [ebx + device.rx_ring_phys], eax
        mov     ecx, RX_RING_SIZE
  .rx_init:
        push    ecx
        invoke  KernelAlloc, PKT_BUF_SZ
        pop     ecx
        mov     [edi + descriptor.virtual], eax
        invoke  GetPhysAddr
        mov     [edi + descriptor.base], eax
        mov     [edi + descriptor.length], - PKT_BUF_SZ
        mov     [edi + descriptor.status], RXSTAT_OWN
        mov     dword[edi + descriptor.msg_length], 0    ; also clears misc field
        add     edi, sizeof.descriptor
        dec     ecx
        jnz     .rx_init
 
        lea     edi, [ebx + device.tx_ring]
        mov     eax, edi
        invoke  GetPhysAddr
        mov     [ebx + device.tx_ring_phys], eax
        mov     ecx, TX_RING_SIZE
  .tx_init:
        mov     [edi + descriptor.status], 0
        add     edi, sizeof.descriptor
        dec     ecx
        jnz     .tx_init
 
        mov     [ebx + device.tlen_rlen], (TX_RING_LEN_BITS or RX_RING_LEN_BITS)
 
        mov     [ebx + device.cur_tx], 0
        mov     [ebx + device.last_tx], 0
        mov     [ebx + device.cur_rx], 0
 
        ret
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                         ;;
;; Transmit                                ;;
;;                                         ;;
;; In: pointer to device structure in ebx  ;;
;;                                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
proc transmit stdcall bufferptr, buffersize
 
        pushf
        cli
 
        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
        mov     eax, [bufferptr]
        DEBUGF  1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
        [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
        [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
        [eax+13]:2,[eax+12]:2
 
        cmp     [buffersize], 1514
        ja      .fail
        cmp     [buffersize], 60
        jb      .fail
 
; check descriptor
        lea     edi, [ebx + device.tx_ring]
        movzx   eax, [ebx + device.cur_tx]
        shl     eax, 4
        add     edi, eax
 
        test    [edi + descriptor.status], TXCTL_OWN
        jnz     .fail
; descriptor is free, use it
        mov     eax, [bufferptr]
        mov     [edi + descriptor.virtual], eax
        invoke  GetPhysAddr
        mov     [edi + descriptor.base], eax
; set length
        mov     eax, [buffersize]
        neg     eax
        mov     [edi + descriptor.length], ax
; put to transfer queue
        mov     [edi + descriptor.status], TXCTL_OWN + TXCTL_STP + TXCTL_ENP
 
; trigger an immediate send
        mov     edx, [ebx + device.io_addr]
        xor     ecx, ecx                        ; CSR0
        call    [ebx + device.read_csr]
        or      eax, CSR_TX
        call    [ebx + device.write_csr]
 
; get next descriptor 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, ...
        inc     [ebx + device.cur_tx]
        and     [ebx + device.cur_tx], TX_RING_SIZE - 1
 
; Update stats
        inc     [ebx + device.packets_tx]
        mov     eax, [buffersize]
        add     dword[ebx + device.bytes_tx], eax
        adc     dword[ebx + device.bytes_tx + 4], 0
 
  .finish:
        popf
        xor     eax, eax
        ret
 
  .fail:
        DEBUGF  2, "Send failed\n"
        invoke  KernelFree, [bufferptr]
        popf
        or      eax, -1
        ret
 
endp
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Interrupt handler ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
int_handler:
 
        push    ebx esi edi
 
        DEBUGF  1,"INT\n"
 
; find pointer of device wich made IRQ occur
 
        mov     ecx, [devices]
        test    ecx, ecx
        jz      .nothing
        mov     esi, device_list
  .nextdevice:
        mov     ebx, [esi]
        mov     edx, [ebx + device.io_addr]
        push    ecx
        xor     ecx, ecx                        ; CSR0
        call    [ebx + device.read_csr]         ; get IRQ reason
        call    [ebx + device.write_csr]        ; write it back to ACK
        pop     ecx
        and     ax, CSR_RINT or CSR_TINT
        jnz     .got_it
  .continue:
        add     esi, 4
        dec     ecx
        jnz     .nextdevice
  .nothing:
        pop     edi esi ebx
        xor     eax, eax
 
        ret
 
  .got_it:
        DEBUGF  1,"Device: %x status: %x\n", ebx, eax:4
 
        push    ax
        test    ax, CSR_RINT
        jz      .not_receive
 
        push    ebx
  .rx_loop:
        pop     ebx
        movzx   eax, [ebx + device.cur_rx]
        shl     eax, 4
        lea     edi, [ebx + device.rx_ring]
        add     edi, eax                        ; edi now points to current rx ring entry
 
        mov     ax, [edi + descriptor.status]
        DEBUGF  1,"RX packet status: %x\n", eax:4
 
        test    ax, RXSTAT_OWN                  ; If this bit is set, the controller OWN's the packet, if not, we do
        jnz     .not_receive
 
        test    ax, RXSTAT_ENP
        jz      .not_receive
 
        test    ax, RXSTAT_STP
        jz      .not_receive
 
        movzx   ecx, [edi + descriptor.msg_length]      ; get packet length in ecx
        sub     ecx, 4                                  ; We dont need the CRC
        DEBUGF  1,"Got %u bytes\n", ecx
 
; Set pointers for ETH_input
        push    ebx
 
        push    .rx_loop                                ; return address
        push    ecx                                     ; packet size
        push    [edi + descriptor.virtual]              ; packet address
 
; Update stats
        add     dword[ebx + device.bytes_rx], ecx
        adc     dword[ebx + device.bytes_rx + 4], 0
        inc     [ebx + device.packets_rx]
 
; now allocate a new buffer
        invoke  KernelAlloc, PKT_BUF_SZ                 ; Allocate a buffer for the next packet
        mov     [edi + descriptor.virtual], eax         ; set virtual address
        invoke  GetPhysAddr
        mov     [edi + descriptor.base], eax            ; and physical address
        mov     [edi + descriptor.status], RXSTAT_OWN   ; give it back to PCnet controller
 
        inc     [ebx + device.cur_rx]                   ; set next receive descriptor
        and     [ebx + device.cur_rx], RX_RING_SIZE - 1
 
        jmp     [Eth_input]
 
  .not_receive:
        pop     ax
 
        test    ax, CSR_TINT
        jz      .not_transmit
 
  .tx_loop:
        lea     edi, [ebx + device.tx_ring]
        movzx   eax, [ebx + device.last_tx]
        shl     eax, 4
        add     edi, eax
 
        test    [edi + descriptor.status], TXCTL_OWN
        jnz     .not_transmit
 
        mov     eax, [edi + descriptor.virtual]
        test    eax, eax
        jz      .not_transmit
 
        mov     [edi + descriptor.virtual], 0
 
        DEBUGF  1,"Removing packet %x from memory\n", eax
 
        invoke  KernelFree, eax
 
        inc     [ebx + device.last_tx]
        and     [ebx + device.last_tx], TX_RING_SIZE - 1
        jmp     .tx_loop
 
  .not_transmit:
        pop     edi esi ebx
        xor     eax, eax
        inc     eax
 
        ret
 
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;
;;                   ;;
;; Write MAC address ;;
;;                   ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
write_mac:      ; in: mac pushed onto stack (as 3 words)
 
        DEBUGF  1,"Writing MAC: %x-%x-%x-%x-%x-%x\n",\
        [esp+0]:2,[esp+1]:2,[esp+2]:2,[esp+3]:2,[esp+4]:2,[esp+5]:2
 
        mov     edx, [ebx + device.io_addr]
        add     dx, 2
        xor     eax, eax
 
        mov     ecx, CSR_PAR0
       @@:
        pop     ax
        call    [ebx + device.write_csr]
        inc     ecx
        cmp     ecx, CSR_PAR2
        jb      @r
 
; Notice this procedure does not ret, but continues to read_mac instead.
 
;;;;;;;;;;;;;;;;;;;;;;
;;                  ;;
;; Read MAC address ;;
;;                  ;;
;;;;;;;;;;;;;;;;;;;;;;
align 4
read_mac:
        DEBUGF  1,"Reading MAC\n"
 
        mov     edx, [ebx + device.io_addr]
        lea     edi, [ebx + device.mac]
        in      ax, dx
        stosw
 
        inc     dx
        inc     dx
        in      ax, dx
        stosw
 
        inc     dx
        inc     dx
        in      ax, dx
        stosw
 
        DEBUGF  1,"MAC = %x-%x-%x-%x-%x-%x\n",\
        [ebx + device.mac+0]:2,[ebx + device.mac+1]:2,[ebx + device.mac+2]:2,\
        [ebx + device.mac+3]:2,[ebx + device.mac+4]:2,[ebx + device.mac+5]:2
 
        ret
 
align 4
switch_to_wio:
 
        DEBUGF  1,"Switching to 16-bit mode\n"
 
        mov     [ebx + device.read_csr], wio_read_csr
        mov     [ebx + device.write_csr], wio_write_csr
        mov     [ebx + device.read_bcr], wio_read_bcr
        mov     [ebx + device.write_bcr], wio_write_bcr
        mov     [ebx + device.read_rap], wio_read_rap
        mov     [ebx + device.write_rap], wio_write_rap
        mov     [ebx + device.sw_reset], wio_reset
 
        ret
 
align 4
switch_to_dwio:
 
        DEBUGF  1,"Switching to 32-bit mode\n"
 
        mov     [ebx + device.read_csr], dwio_read_csr
        mov     [ebx + device.write_csr], dwio_write_csr
        mov     [ebx + device.read_bcr], dwio_read_bcr
        mov     [ebx + device.write_bcr], dwio_write_bcr
        mov     [ebx + device.read_rap], dwio_read_rap
        mov     [ebx + device.write_rap], dwio_write_rap
        mov     [ebx + device.sw_reset], dwio_reset
 
        ret
 
 
; ecx - index
; return:
; eax - data
align 4
wio_read_csr:
 
        add     edx, WIO_RAP
        mov     ax, cx
        out     dx, ax
        add     edx, WIO_RDP - WIO_RAP
        in      ax, dx
        and     eax, 0xffff
        sub     edx, WIO_RDP
 
        ret
 
 
; eax - data
; ecx - index
align 4
wio_write_csr:
 
        add     edx, WIO_RAP
        xchg    eax, ecx
        out     dx, ax
        xchg    eax, ecx
        add     edx, WIO_RDP - WIO_RAP
        out     dx, ax
        sub     edx, WIO_RDP
 
        ret
 
 
; ecx - index
; return:
; eax - data
align 4
wio_read_bcr:
 
        add     edx, WIO_RAP
        mov     ax, cx
        out     dx, ax
        add     edx, WIO_BDP - WIO_RAP
        in      ax, dx
        and     eax, 0xffff
        sub     edx, WIO_BDP
 
        ret
 
 
; eax - data
; ecx - index
align 4
wio_write_bcr:
 
        add     edx, WIO_RAP
        xchg    eax, ecx
        out     dx, ax
        xchg    eax, ecx
        add     edx, WIO_BDP - WIO_RAP
        out     dx, ax
        sub     edx, WIO_BDP
 
        ret
 
align 4
wio_read_rap:
 
        add     edx, WIO_RAP
        in      ax, dx
        and     eax, 0xffff
        sub     edx, WIO_RAP
 
        ret
 
; eax - val
align 4
wio_write_rap:
 
        add     edx, WIO_RAP
        out     dx, ax
        sub     edx, WIO_RAP
 
        ret
 
align 4
wio_reset:
 
        push    eax
        add     edx, WIO_RESET
        in      ax, dx
        pop     eax
        sub     edx, WIO_RESET
 
        ret
 
 
 
; ecx - index
; return:
; eax - data
align 4
dwio_read_csr:
 
        add     edx, DWIO_RAP
        mov     eax, ecx
        out     dx, eax
        add     edx, DWIO_RDP - DWIO_RAP
        in      eax, dx
        and     eax, 0xffff
        sub     edx, DWIO_RDP
 
        ret
 
 
; ecx - index
; eax - data
align 4
dwio_write_csr:
 
        add     edx, DWIO_RAP
        xchg    eax, ecx
        out     dx, eax
        add     edx, DWIO_RDP - DWIO_RAP
        xchg    eax, ecx
        out     dx, eax
        sub     edx, DWIO_RDP
 
        ret
 
; ecx - index
; return:
; eax - data
align 4
dwio_read_bcr:
 
        add     edx, DWIO_RAP
        mov     eax, ecx
        out     dx, eax
        add     edx, DWIO_BDP - DWIO_RAP
        in      eax, dx
        and     eax, 0xffff
        sub     edx, DWIO_BDP
 
        ret
 
 
; ecx - index
; eax - data
align 4
dwio_write_bcr:
 
        add     edx, DWIO_RAP
        xchg    eax, ecx
        out     dx, eax
        add     edx, DWIO_BDP - DWIO_RAP
        xchg    eax, ecx
        out     dx, eax
        sub     edx, DWIO_BDP
 
        ret
 
align 4
dwio_read_rap:
 
        add     edx, DWIO_RAP
        in      eax, dx
        and     eax, 0xffff
        sub     edx, DWIO_RAP
 
        ret
 
 
; eax - val
align 4
dwio_write_rap:
 
        add     edx, DWIO_RAP
        out     dx, eax
        sub     edx, DWIO_RAP
 
        ret
 
align 4
dwio_reset:
 
        push    eax
        add     edx, DWIO_RESET
        in      eax, dx
        pop     eax
        sub     edx, DWIO_RESET
 
        ret
 
 
align 4
mdio_read:
 
        and     ecx, 0x1f
        mov     ax, [ebx + device.phy]
        and     ax, 0x1f
        shl     ax, 5
        or      ax, cx
 
        mov     ecx, BCR_MIIADDR
        call    [ebx + device.write_bcr]
 
        mov     ecx, BCR_MIIDATA
        call    [ebx + device.read_bcr]
 
        ret
 
 
align 4
mdio_write:
 
        push    eax
        and     ecx, 0x1f
        mov     ax, [ebx + device.phy]
        and     ax, 0x1f
        shl     ax, 5
        or      ax, cx
 
        mov     ecx, BCR_MIIADDR
        call    [ebx + device.write_bcr]
 
        pop     eax
        mov     ecx, BCR_MIIDATA
        call    [ebx + device.write_bcr]
 
        ret
 
 
align 4
check_media:
 
        DEBUGF  1, "check_media\n"
 
        test    [ebx + device.mii], 1
        jnz     mii_link_ok
 
        mov     ecx, BCR_LED0
        call    [ebx + device.read_bcr]
        cmp     eax, 0xc0
 
        DEBUGF  1, "link status=0x%x\n", ax
 
        ret
 
 
 
; End of code
 
 
data fixups
end data
 
include '../peimport.inc'
 
my_service    db 'PCNET32',0            ; max 16 chars include zero
 
device_l2     db "PCnet/PCI 79C970",0
device_l4     db "PCnet/PCI II 79C970A",0
device_l5     db "PCnet/FAST 79C971",0
device_l6     db "PCnet/FAST+ 79C972",0
device_l7     db "PCnet/FAST III 79C973",0
device_l8     db "PCnet/Home 79C978",0
device_l9     db "PCnet/FAST III 79C975",0
 
options_mapping:
dd PORT_ASEL                            ; 0 Auto-select
dd PORT_AUI                             ; 1 BNC/AUI
dd PORT_AUI                             ; 2 AUI/BNC
dd PORT_ASEL                            ; 3 not supported
dd PORT_10BT or PORT_FD                 ; 4 10baseT-FD
dd PORT_ASEL                            ; 5 not supported
dd PORT_ASEL                            ; 6 not supported
dd PORT_ASEL                            ; 7 not supported
dd PORT_ASEL                            ; 8 not supported
dd PORT_MII                             ; 9 MII 10baseT
dd PORT_MII or PORT_FD                  ; 10 MII 10baseT-FD
dd PORT_MII                             ; 11 MII (autosel)
dd PORT_10BT                            ; 12 10BaseT
dd PORT_MII or PORT_100                 ; 13 MII 100BaseTx
dd PORT_MII or PORT_100 or PORT_FD      ; 14 MII 100BaseTx-FD
dd PORT_ASEL                            ; 15 not supported
 
include_debug_strings                                   ; All data wich FDO uses will be included here
 
 
align 4
devices     dd 0
device_list rd MAX_DEVICES                              ; This list contains all pointers to device structures the driver is handling

Rev 4582	Rev 4629
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; AMD PCnet driver for KolibriOS ;;	6	;; AMD PCnet driver for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; By hidnplayr & clevermouse ;;	8	;; By hidnplayr & clevermouse ;;
9	;; ;;	9	;; ;;
10	;; Based on the PCnet32 driver for MenuetOS, by Jarek Pelczar ;;	10	;; Based on the PCnet32 driver for MenuetOS, by Jarek Pelczar ;;
11	;; ;;	11	;; ;;
12	;; GNU GENERAL PUBLIC LICENSE ;;	12	;; GNU GENERAL PUBLIC LICENSE ;;
13	;; Version 2, June 1991 ;;	13	;; Version 2, June 1991 ;;
14	;; ;;	14	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	format PE DLL native	17	format PE DLL native
18	entry START	18	entry START
19		19
20	CURRENT_API = 0x0200	20	CURRENT_API = 0x0200
21	COMPATIBLE_API = 0x0100	21	COMPATIBLE_API = 0x0100
22	API_VERSION = (COMPATIBLE_API shl 16) + CURRENT_API	22	API_VERSION = (COMPATIBLE_API shl 16) + CURRENT_API
23		23
24	MAX_DEVICES = 16	24	MAX_DEVICES = 16
25		25
26	__DEBUG__ = 1	26	__DEBUG__ = 1
27	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only	27	__DEBUG_LEVEL__ = 2 ; 1 = verbose, 2 = errors only
28		28
29	TX_RING_SIZE = 4	29	TX_RING_SIZE = 4
30	RX_RING_SIZE = 4	30	RX_RING_SIZE = 4
31		31
32	section '.flat' readable writable executable	32	section '.flat' readable writable executable
33		33
34	include '../struct.inc'	34	include '../struct.inc'
35	include '../macros.inc'	35	include '../macros.inc'
36	include '../proc32.inc'	36	include '../proc32.inc'
37	include '../fdo.inc'	37	include '../fdo.inc'
38	include '../netdrv_pe.inc'	38	include '../netdrv_pe.inc'
39		39
40		40
41	PORT_AUI = 0x00	41	PORT_AUI = 0x00
42	PORT_10BT = 0x01	42	PORT_10BT = 0x01
43	PORT_GPSI = 0x02	43	PORT_GPSI = 0x02
44	PORT_MII = 0x03	44	PORT_MII = 0x03
45	PORT_PORTSEL = 0x03	45	PORT_PORTSEL = 0x03
46	PORT_ASEL = 0x04	46	PORT_ASEL = 0x04
47	PORT_100 = 0x40	47	PORT_100 = 0x40
48	PORT_FD = 0x80	48	PORT_FD = 0x80
49		49
50	DMA_MASK = 0xffffffff	50	DMA_MASK = 0xffffffff
51		51
52	LOG_TX_BUFFERS = 2 ; FIXME	52	LOG_TX_BUFFERS = 2 ; FIXME
53	LOG_RX_BUFFERS = 2	53	LOG_RX_BUFFERS = 2
54		54
55	TX_RING_MOD_MASK = (TX_RING_SIZE-1)	55	TX_RING_MOD_MASK = (TX_RING_SIZE-1)
56	TX_RING_LEN_BITS = (LOG_TX_BUFFERS shl 12)	56	TX_RING_LEN_BITS = (LOG_TX_BUFFERS shl 12)
57		57
58	RX_RING_MOD_MASK = (RX_RING_SIZE-1)	58	RX_RING_MOD_MASK = (RX_RING_SIZE-1)
59	RX_RING_LEN_BITS = (LOG_RX_BUFFERS shl 4)	59	RX_RING_LEN_BITS = (LOG_RX_BUFFERS shl 4)
60		60
61	PKT_BUF_SZ = 1544	61	PKT_BUF_SZ = 1544
62		62
63	WIO_RDP = 0x10	63	WIO_RDP = 0x10
64	WIO_RAP = 0x12	64	WIO_RAP = 0x12
65	WIO_RESET = 0x14	65	WIO_RESET = 0x14
66	WIO_BDP = 0x16	66	WIO_BDP = 0x16
67		67
68	DWIO_RDP = 0x10	68	DWIO_RDP = 0x10
69	DWIO_RAP = 0x14	69	DWIO_RAP = 0x14
70	DWIO_RESET = 0x18	70	DWIO_RESET = 0x18
71	DWIO_BDP = 0x1C	71	DWIO_BDP = 0x1C
72		72
73	; CSR registers	73	; CSR registers
74		74
75	CSR_CSR = 0x00	75	CSR_CSR = 0x00
76	CSR_IAB0 = 0x01	76	CSR_IAB0 = 0x01
77	CSR_IAB1 = 0x02	77	CSR_IAB1 = 0x02
78	CSR_IMR = 0x03	78	CSR_IMR = 0x03
79	CSR_TFEAT = 0x04	79	CSR_TFEAT = 0x04
80	CSR_EXTCTL1 = 0x05	80	CSR_EXTCTL1 = 0x05
81	CSR_DTBLLEN = 0x06	81	CSR_DTBLLEN = 0x06
82	CSR_EXTCTL2 = 0x07	82	CSR_EXTCTL2 = 0x07
83	CSR_MAR0 = 0x08	83	CSR_MAR0 = 0x08
84	CSR_MAR1 = 0x09	84	CSR_MAR1 = 0x09
85	CSR_MAR2 = 0x0A	85	CSR_MAR2 = 0x0A
86	CSR_MAR3 = 0x0B	86	CSR_MAR3 = 0x0B
87	CSR_PAR0 = 0x0C	87	CSR_PAR0 = 0x0C
88	CSR_PAR1 = 0x0D	88	CSR_PAR1 = 0x0D
89	CSR_PAR2 = 0x0E	89	CSR_PAR2 = 0x0E
90	CSR_MODE = 0x0F	90	CSR_MODE = 0x0F
91	CSR_RXADDR0 = 0x18	91	CSR_RXADDR0 = 0x18
92	CSR_RXADDR1 = 0x19	92	CSR_RXADDR1 = 0x19
93	CSR_TXADDR0 = 0x1E	93	CSR_TXADDR0 = 0x1E
94	CSR_TXADDR1 = 0x1F	94	CSR_TXADDR1 = 0x1F
95	CSR_TXPOLL = 0x2F	95	CSR_TXPOLL = 0x2F
96	CSR_RXPOLL = 0x31	96	CSR_RXPOLL = 0x31
97	CSR_RXRINGLEN = 0x4C	97	CSR_RXRINGLEN = 0x4C
98	CSR_TXRINGLEN = 0x4E	98	CSR_TXRINGLEN = 0x4E
99	CSR_DMACTL = 0x50	99	CSR_DMACTL = 0x50
100	CSR_BUSTIMER = 0x52	100	CSR_BUSTIMER = 0x52
101	CSR_MEMERRTIMEO = 0x64	101	CSR_MEMERRTIMEO = 0x64
102	CSR_ONNOWMISC = 0x74	102	CSR_ONNOWMISC = 0x74
103	CSR_ADVFEAT = 0x7A	103	CSR_ADVFEAT = 0x7A
104	CSR_MACCFG = 0x7D	104	CSR_MACCFG = 0x7D
105	CSR_CHIPID0 = 0x58	105	CSR_CHIPID0 = 0x58
106	CSR_CHIPID1 = 0x59	106	CSR_CHIPID1 = 0x59
107		107
108	; Control and Status Register (CSR0)	108	; Control and Status Register (CSR0)
109		109
110	CSR_INIT = 1 shl 0	110	CSR_INIT = 1 shl 0
111	CSR_START = 1 shl 1	111	CSR_START = 1 shl 1
112	CSR_STOP = 1 shl 2	112	CSR_STOP = 1 shl 2
113	CSR_TX = 1 shl 3	113	CSR_TX = 1 shl 3
114	CSR_TXON = 1 shl 4	114	CSR_TXON = 1 shl 4
115	CSR_RXON = 1 shl 5	115	CSR_RXON = 1 shl 5
116	CSR_INTEN = 1 shl 6	116	CSR_INTEN = 1 shl 6
117	CSR_INTR = 1 shl 7	117	CSR_INTR = 1 shl 7
118	CSR_IDONE = 1 shl 8	118	CSR_IDONE = 1 shl 8
119	CSR_TINT = 1 shl 9	119	CSR_TINT = 1 shl 9
120	CSR_RINT = 1 shl 10	120	CSR_RINT = 1 shl 10
121	CSR_MERR = 1 shl 11	121	CSR_MERR = 1 shl 11
122	CSR_MISS = 1 shl 12	122	CSR_MISS = 1 shl 12
123	CSR_CERR = 1 shl 13	123	CSR_CERR = 1 shl 13
124		124
125	; Interrupt masks and deferral control (CSR3)	125	; Interrupt masks and deferral control (CSR3)
126		126
127	IMR_BSWAP = 0x0004	127	IMR_BSWAP = 0x0004
128	IMR_ENMBA = 0x0008 ; enable modified backoff alg	128	IMR_ENMBA = 0x0008 ; enable modified backoff alg
129	IMR_DXMT2PD = 0x0010	129	IMR_DXMT2PD = 0x0010
130	IMR_LAPPEN = 0x0020 ; lookahead packet processing enb	130	IMR_LAPPEN = 0x0020 ; lookahead packet processing enb
131	IMR_DXSUFLO = 0x0040 ; disable TX stop on underflow	131	IMR_DXSUFLO = 0x0040 ; disable TX stop on underflow
132	IMR_IDONE = 0x0100	132	IMR_IDONE = 0x0100
133	IMR_TINT = 0x0200	133	IMR_TINT = 0x0200
134	IMR_RINT = 0x0400	134	IMR_RINT = 0x0400
135	IMR_MERR = 0x0800	135	IMR_MERR = 0x0800
136	IMR_MISS = 0x1000	136	IMR_MISS = 0x1000
137		137
138	IMR = IMR_IDONE ; IMR_TINT + IMR_RINT + IMR_MERR + IMR_MISS ;+ IMR_IDONE	138	IMR = IMR_IDONE ; IMR_TINT + IMR_RINT + IMR_MERR + IMR_MISS ;+ IMR_IDONE
139		139
140	; Test and features control (CSR4)	140	; Test and features control (CSR4)
141		141
142	TFEAT_TXSTRTMASK = 0x0004	142	TFEAT_TXSTRTMASK = 0x0004
143	TFEAT_TXSTRT = 0x0008	143	TFEAT_TXSTRT = 0x0008
144	TFEAT_RXCCOFLOWM = 0x0010 ; Rx collision counter oflow	144	TFEAT_RXCCOFLOWM = 0x0010 ; Rx collision counter oflow
145	TFEAT_RXCCOFLOW = 0x0020	145	TFEAT_RXCCOFLOW = 0x0020
146	TFEAT_UINT = 0x0040	146	TFEAT_UINT = 0x0040
147	TFEAT_UINTREQ = 0x0080	147	TFEAT_UINTREQ = 0x0080
148	TFEAT_MISSOFLOWM = 0x0100	148	TFEAT_MISSOFLOWM = 0x0100
149	TFEAT_MISSOFLOW = 0x0200	149	TFEAT_MISSOFLOW = 0x0200
150	TFEAT_STRIP_FCS = 0x0400	150	TFEAT_STRIP_FCS = 0x0400
151	TFEAT_PAD_TX = 0x0800	151	TFEAT_PAD_TX = 0x0800
152	TFEAT_TXDPOLL = 0x1000	152	TFEAT_TXDPOLL = 0x1000
153	TFEAT_DMAPLUS = 0x4000	153	TFEAT_DMAPLUS = 0x4000
154		154
155	; Extended control and interrupt 1 (CSR5)	155	; Extended control and interrupt 1 (CSR5)
156		156
157	EXTCTL1_SPND = 0x0001 ; suspend	157	EXTCTL1_SPND = 0x0001 ; suspend
158	EXTCTL1_MPMODE = 0x0002 ; magic packet mode	158	EXTCTL1_MPMODE = 0x0002 ; magic packet mode
159	EXTCTL1_MPENB = 0x0004 ; magic packet enable	159	EXTCTL1_MPENB = 0x0004 ; magic packet enable
160	EXTCTL1_MPINTEN = 0x0008 ; magic packet interrupt enable	160	EXTCTL1_MPINTEN = 0x0008 ; magic packet interrupt enable
161	EXTCTL1_MPINT = 0x0010 ; magic packet interrupt	161	EXTCTL1_MPINT = 0x0010 ; magic packet interrupt
162	EXTCTL1_MPPLBA = 0x0020 ; magic packet phys. logical bcast	162	EXTCTL1_MPPLBA = 0x0020 ; magic packet phys. logical bcast
163	EXTCTL1_EXDEFEN = 0x0040 ; excessive deferral interrupt enb.	163	EXTCTL1_EXDEFEN = 0x0040 ; excessive deferral interrupt enb.
164	EXTCTL1_EXDEF = 0x0080 ; excessive deferral interrupt	164	EXTCTL1_EXDEF = 0x0080 ; excessive deferral interrupt
165	EXTCTL1_SINTEN = 0x0400 ; system interrupt enable	165	EXTCTL1_SINTEN = 0x0400 ; system interrupt enable
166	EXTCTL1_SINT = 0x0800 ; system interrupt	166	EXTCTL1_SINT = 0x0800 ; system interrupt
167	EXTCTL1_LTINTEN = 0x4000 ; last TX interrupt enb	167	EXTCTL1_LTINTEN = 0x4000 ; last TX interrupt enb
168	EXTCTL1_TXOKINTD = 0x8000 ; TX OK interrupt disable	168	EXTCTL1_TXOKINTD = 0x8000 ; TX OK interrupt disable
169		169
170	; RX/TX descriptor len (CSR6)	170	; RX/TX descriptor len (CSR6)
171		171
172	DTBLLEN_RLEN = 0x0F00	172	DTBLLEN_RLEN = 0x0F00
173	DTBLLEN_TLEN = 0xF000	173	DTBLLEN_TLEN = 0xF000
174		174
175	; Extended control and interrupt 2 (CSR7)	175	; Extended control and interrupt 2 (CSR7)
176		176
177	EXTCTL2_MIIPDTINTE = 0x0001	177	EXTCTL2_MIIPDTINTE = 0x0001
178	EXTCTL2_MIIPDTINT = 0x0002	178	EXTCTL2_MIIPDTINT = 0x0002
179	EXTCTL2_MCCIINTE = 0x0004	179	EXTCTL2_MCCIINTE = 0x0004
180	EXTCTL2_MCCIINT = 0x0008	180	EXTCTL2_MCCIINT = 0x0008
181	EXTCTL2_MCCINTE = 0x0010	181	EXTCTL2_MCCINTE = 0x0010
182	EXTCTL2_MCCINT = 0x0020	182	EXTCTL2_MCCINT = 0x0020
183	EXTCTL2_MAPINTE = 0x0040	183	EXTCTL2_MAPINTE = 0x0040
184	EXTCTL2_MAPINT = 0x0080	184	EXTCTL2_MAPINT = 0x0080
185	EXTCTL2_MREINTE = 0x0100	185	EXTCTL2_MREINTE = 0x0100
186	EXTCTL2_MREINT = 0x0200	186	EXTCTL2_MREINT = 0x0200
187	EXTCTL2_STINTE = 0x0400	187	EXTCTL2_STINTE = 0x0400
188	EXTCTL2_STINT = 0x0800	188	EXTCTL2_STINT = 0x0800
189	EXTCTL2_RXDPOLL = 0x1000	189	EXTCTL2_RXDPOLL = 0x1000
190	EXTCTL2_RDMD = 0x2000	190	EXTCTL2_RDMD = 0x2000
191	EXTCTL2_RXFRTG = 0x4000	191	EXTCTL2_RXFRTG = 0x4000
192	EXTCTL2_FASTSPNDE = 0x8000	192	EXTCTL2_FASTSPNDE = 0x8000
193		193
194	; Mode (CSR15)	194	; Mode (CSR15)
195		195
196	MODE_RXD = 0x0001 ; RX disable	196	MODE_RXD = 0x0001 ; RX disable
197	MODE_TXD = 0x0002 ; TX disable	197	MODE_TXD = 0x0002 ; TX disable
198	MODE_LOOP = 0x0004 ; loopback enable	198	MODE_LOOP = 0x0004 ; loopback enable
199	MODE_TXCRCD = 0x0008	199	MODE_TXCRCD = 0x0008
200	MODE_FORCECOLL = 0x0010	200	MODE_FORCECOLL = 0x0010
201	MODE_RETRYD = 0x0020	201	MODE_RETRYD = 0x0020
202	MODE_INTLOOP = 0x0040	202	MODE_INTLOOP = 0x0040
203	MODE_PORTSEL = 0x0180	203	MODE_PORTSEL = 0x0180
204	MODE_RXVPAD = 0x2000	204	MODE_RXVPAD = 0x2000
205	MODE_RXNOBROAD = 0x4000	205	MODE_RXNOBROAD = 0x4000
206	MODE_PROMISC = 0x8000	206	MODE_PROMISC = 0x8000
207		207
208	; BCR (Bus Control Registers)	208	; BCR (Bus Control Registers)
209		209
210	BCR_MMRA = 0x00 ; Master Mode Read Active	210	BCR_MMRA = 0x00 ; Master Mode Read Active
211	BCR_MMW = 0x01 ; Master Mode Write Active	211	BCR_MMW = 0x01 ; Master Mode Write Active
212	BCR_MISCCFG = 0x02	212	BCR_MISCCFG = 0x02
213	BCR_LED0 = 0x04	213	BCR_LED0 = 0x04
214	BCR_LED1 = 0x05	214	BCR_LED1 = 0x05
215	BCR_LED2 = 0x06	215	BCR_LED2 = 0x06
216	BCR_LED3 = 0x07	216	BCR_LED3 = 0x07
217	BCR_DUPLEX = 0x09	217	BCR_DUPLEX = 0x09
218	BCR_BUSCTL = 0x12	218	BCR_BUSCTL = 0x12
219	BCR_EECTL = 0x13	219	BCR_EECTL = 0x13
220	BCR_SSTYLE = 0x14	220	BCR_SSTYLE = 0x14
221	BCR_PCILAT = 0x16	221	BCR_PCILAT = 0x16
222	BCR_PCISUBVENID = 0x17	222	BCR_PCISUBVENID = 0x17
223	BCR_PCISUBSYSID = 0x18	223	BCR_PCISUBSYSID = 0x18
224	BCR_SRAMSIZE = 0x19	224	BCR_SRAMSIZE = 0x19
225	BCR_SRAMBOUND = 0x1A	225	BCR_SRAMBOUND = 0x1A
226	BCR_SRAMCTL = 0x1B	226	BCR_SRAMCTL = 0x1B
227	BCR_MIICTL = 0x20	227	BCR_MIICTL = 0x20
228	BCR_MIIADDR = 0x21	228	BCR_MIIADDR = 0x21
229	BCR_MIIDATA = 0x22	229	BCR_MIIDATA = 0x22
230	BCR_PCIVENID = 0x23	230	BCR_PCIVENID = 0x23
231	BCR_PCIPCAP = 0x24	231	BCR_PCIPCAP = 0x24
232	BCR_DATA0 = 0x25	232	BCR_DATA0 = 0x25
233	BCR_DATA1 = 0x26	233	BCR_DATA1 = 0x26
234	BCR_DATA2 = 0x27	234	BCR_DATA2 = 0x27
235	BCR_DATA3 = 0x28	235	BCR_DATA3 = 0x28
236	BCR_DATA4 = 0x29	236	BCR_DATA4 = 0x29
237	BCR_DATA5 = 0x2A	237	BCR_DATA5 = 0x2A
238	BCR_DATA6 = 0x2B	238	BCR_DATA6 = 0x2B
239	BCR_DATA7 = 0x2C	239	BCR_DATA7 = 0x2C
240	BCR_ONNOWPAT0 = 0x2D	240	BCR_ONNOWPAT0 = 0x2D
241	BCR_ONNOWPAT1 = 0x2E	241	BCR_ONNOWPAT1 = 0x2E
242	BCR_ONNOWPAT2 = 0x2F	242	BCR_ONNOWPAT2 = 0x2F
243	BCR_PHYSEL = 0x31	243	BCR_PHYSEL = 0x31
244		244
245	; RX status register	245	; RX status register
246		246
247	RXSTAT_BPE = 0x0080 ; bus parity error	247	RXSTAT_BPE = 0x0080 ; bus parity error
248	RXSTAT_ENP = 0x0100 ; end of packet	248	RXSTAT_ENP = 0x0100 ; end of packet
249	RXSTAT_STP = 0x0200 ; start of packet	249	RXSTAT_STP = 0x0200 ; start of packet
250	RXSTAT_BUFF = 0x0400 ; buffer error	250	RXSTAT_BUFF = 0x0400 ; buffer error
251	RXSTAT_CRC = 0x0800 ; CRC error	251	RXSTAT_CRC = 0x0800 ; CRC error
252	RXSTAT_OFLOW = 0x1000 ; rx overrun	252	RXSTAT_OFLOW = 0x1000 ; rx overrun
253	RXSTAT_FRAM = 0x2000 ; framing error	253	RXSTAT_FRAM = 0x2000 ; framing error
254	RXSTAT_ERR = 0x4000 ; error summary	254	RXSTAT_ERR = 0x4000 ; error summary
255	RXSTAT_OWN = 0x8000	255	RXSTAT_OWN = 0x8000
256		256
257	; TX status register	257	; TX status register
258		258
259	TXSTAT_TRC = 0x0000000F ; transmit retries	259	TXSTAT_TRC = 0x0000000F ; transmit retries
260	TXSTAT_RTRY = 0x04000000 ; retry	260	TXSTAT_RTRY = 0x04000000 ; retry
261	TXSTAT_LCAR = 0x08000000 ; lost carrier	261	TXSTAT_LCAR = 0x08000000 ; lost carrier
262	TXSTAT_LCOL = 0x10000000 ; late collision	262	TXSTAT_LCOL = 0x10000000 ; late collision
263	TXSTAT_EXDEF = 0x20000000 ; excessive deferrals	263	TXSTAT_EXDEF = 0x20000000 ; excessive deferrals
264	TXSTAT_UFLOW = 0x40000000 ; transmit underrun	264	TXSTAT_UFLOW = 0x40000000 ; transmit underrun
265	TXSTAT_BUFF = 0x80000000 ; buffer error	265	TXSTAT_BUFF = 0x80000000 ; buffer error
266		266
267	TXCTL_OWN = 0x8000	267	TXCTL_OWN = 0x8000
268	TXCTL_ERR = 0x4000 ; error summary	268	TXCTL_ERR = 0x4000 ; error summary
269	TXCTL_ADD_FCS = 0x2000 ; add FCS to pkt	269	TXCTL_ADD_FCS = 0x2000 ; add FCS to pkt
270	TXCTL_MORE_LTINT = 0x1000	270	TXCTL_MORE_LTINT = 0x1000
271	TXCTL_ONE = 0x0800	271	TXCTL_ONE = 0x0800
272	TXCTL_DEF = 0x0400	272	TXCTL_DEF = 0x0400
273	TXCTL_STP = 0x0200	273	TXCTL_STP = 0x0200
274	TXCTL_ENP = 0x0100	274	TXCTL_ENP = 0x0100
275	TXCTL_BPE = 0x0080	275	TXCTL_BPE = 0x0080
276		276
277	TXCTL_MBO = 0x0000F000	277	TXCTL_MBO = 0x0000F000
278	TXCTL_BUFSZ = 0x00000FFF	278	TXCTL_BUFSZ = 0x00000FFF
279		279
280	MAX_PHYS = 32	280	MAX_PHYS = 32
281		281
282		282
283	struct device ETH_DEVICE	283	struct device ETH_DEVICE
284		284
285	rb 0x100-($ and 0xff) ; align 256	285	rb 0x100-($ and 0xff) ; align 256
286		286
287	; Pcnet configuration structure	287	; Pcnet configuration structure
288	mode dw ?	288	mode dw ?
289	tlen_rlen dw ?	289	tlen_rlen dw ?
290	phys_addr dp ?	290	phys_addr dp ?
291	reserved dw ?	291	reserved dw ?
292	filter dq ?	292	filter dq ?
293	rx_ring_phys dd ?	293	rx_ring_phys dd ?
294	tx_ring_phys dd ?	294	tx_ring_phys dd ?
295	; end of pcnet config struct	295	; end of pcnet config struct
296		296
297	rb 0x100-($ and 0xff) ; align 256	297	rb 0x100-($ and 0xff) ; align 256
298		298
299	rx_ring rb RX_RING_SIZE * sizeof.descriptor	299	rx_ring rb RX_RING_SIZE * sizeof.descriptor
300		300
301	rb 0x100-($ and 0xff) ; align 256	301	rb 0x100-($ and 0xff) ; align 256
302		302
303	tx_ring rb TX_RING_SIZE * sizeof.descriptor	303	tx_ring rb TX_RING_SIZE * sizeof.descriptor
304		304
305	cur_rx db ?	305	cur_rx db ?
306	cur_tx db ?	306	cur_tx db ?
307	last_tx db ?	307	last_tx db ?
308	options dd ?	308	options dd ?
309	full_duplex db ?	309	full_duplex db ?
310	chip_version dw ?	310	chip_version dw ?
311	mii db ?	311	mii db ?
312	ltint db ?	312	ltint db ?
313	dxsuflo db ?	313	dxsuflo db ?
314	fset db ?	314	fset db ?
315	fdx db ?	315	fdx db ?
316		316
317	io_addr dd ?	317	io_addr dd ?
318	irq_line db ?	318	irq_line db ?
319	pci_bus dd ?	319	pci_bus dd ?
320	pci_dev dd ?	320	pci_dev dd ?
321		321
322	phy dw ?	322	phy dw ?
323		323
324	read_csr dd ?	324	read_csr dd ?
325	write_csr dd ?	325	write_csr dd ?
326	read_bcr dd ?	326	read_bcr dd ?
327	write_bcr dd ?	327	write_bcr dd ?
328	read_rap dd ?	328	read_rap dd ?
329	write_rap dd ?	329	write_rap dd ?
330	sw_reset dd ?	330	sw_reset dd ?
331		331
332	ends	332	ends
333		333
334	struct descriptor	334	struct descriptor
335		335
336	base dd ?	336	base dd ?
337	length dw ?	337	length dw ?
338	status dw ?	338	status dw ?
339	msg_length dw ?	339	msg_length dw ?
340	misc dw ?	340	misc dw ?
341	virtual dd ?	341	virtual dd ?
342		342
343	ends	343	ends
344		344
345		345
346	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	346	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
347	;; ;;	347	;; ;;
348	;; proc START ;;	348	;; proc START ;;
349	;; ;;	349	;; ;;
350	;; (standard driver proc) ;;	350	;; (standard driver proc) ;;
351	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	351	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
352		352
353	proc START c, reason:dword, cmdline:dword	353	proc START c, reason:dword, cmdline:dword
354		354
355	cmp [reason], DRV_ENTRY	355	cmp [reason], DRV_ENTRY
356	jne .fail	356	jne .fail
357		357
358	DEBUGF 2,"Loading driver\n"	358	DEBUGF 2,"Loading driver\n"
359	invoke RegService, my_service, service_proc	359	invoke RegService, my_service, service_proc
360	ret	360	ret
361		361
362	.fail:	362	.fail:
363	xor eax, eax	363	xor eax, eax
364	ret	364	ret
365		365
366	endp	366	endp
367		367
368		368
369	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	369	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
370	;; ;;	370	;; ;;
371	;; proc SERVICE_PROC ;;	371	;; proc SERVICE_PROC ;;
372	;; ;;	372	;; ;;
373	;; (standard driver proc) ;;	373	;; (standard driver proc) ;;
374	;;;;;;;;;;;;;;;;;;;;;;;;;;;;	374	;;;;;;;;;;;;;;;;;;;;;;;;;;;;
375		375
376	align 4	376	align 4
377	proc service_proc stdcall, ioctl:dword	377	proc service_proc stdcall, ioctl:dword
378		378
379	mov edx, [ioctl]	379	mov edx, [ioctl]
380	mov eax, [edx + IOCTL.io_code]	380	mov eax, [edx + IOCTL.io_code]
381		381
382	;------------------------------------------------------	382	;------------------------------------------------------
383		383
384	cmp eax, 0 ;SRV_GETVERSION	384	cmp eax, 0 ;SRV_GETVERSION
385	jne @F	385	jne @F
386		386
387	cmp [edx + IOCTL.out_size], 4	387	cmp [edx + IOCTL.out_size], 4
388	jb .fail	388	jb .fail
389	mov eax, [edx + IOCTL.output]	389	mov eax, [edx + IOCTL.output]
390	mov [eax], dword API_VERSION	390	mov [eax], dword API_VERSION
391		391
392	xor eax, eax	392	xor eax, eax
393	ret	393	ret
394		394
395	;------------------------------------------------------	395	;------------------------------------------------------
396	@@:	396	@@:
397	cmp eax, 1 ;SRV_HOOK	397	cmp eax, 1 ;SRV_HOOK
398	jne .fail	398	jne .fail
399		399
400	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes	400	cmp [edx + IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
401	jb .fail	401	jb .fail
402		402
403	mov eax, [edx + IOCTL.input]	403	mov eax, [edx + IOCTL.input]
404	cmp byte[eax], 1 ; 1 means device number and bus number (pci) are given	404	cmp byte[eax], 1 ; 1 means device number and bus number (pci) are given
405	jne .fail ; other types arent supported for this card yet	405	jne .fail ; other types arent supported for this card yet
406		406
407	; check if the device is already listed	407	; check if the device is already listed
408		408
409	mov ecx, [devices]	409	mov ecx, [devices]
410	test ecx, ecx	410	test ecx, ecx
411	jz .firstdevice	411	jz .firstdevice
412		412
413	mov esi, device_list	413	mov esi, device_list
414	; mov eax, [edx + IOCTL.input] ; get the pci bus and device numbers	414	; mov eax, [edx + IOCTL.input] ; get the pci bus and device numbers
415	mov ax, [eax+1] ;	415	mov ax, [eax+1] ;
416	.nextdevice:	416	.nextdevice:
417	mov ebx, [esi]	417	mov ebx, [esi]
418	cmp al, byte[ebx + device.pci_bus]	418	cmp al, byte[ebx + device.pci_bus]
419	jne @f	419	jne @f
420	cmp ah, byte[ebx + device.pci_dev]	420	cmp ah, byte[ebx + device.pci_dev]
421	je .find_devicenum ; Device is already loaded, let's find it's device number	421	je .find_devicenum ; Device is already loaded, let's find it's device number
422	@@:	422	@@:
423	add esi, 4	423	add esi, 4
424	loop .nextdevice	424	loop .nextdevice
425		425
426	; This device doesnt have its own eth_device structure yet, lets create one	426	; This device doesnt have its own eth_device structure yet, lets create one
427		427
428	.firstdevice:	428	.firstdevice:
429	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card	429	cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
430	jae .fail	430	jae .fail
431		431
432	allocate_and_clear ebx, sizeof.device, .fail	432	allocate_and_clear ebx, sizeof.device, .fail
433		433
434	; Fill in the direct call addresses into the struct	434	; Fill in the direct call addresses into the struct
435		435
436	mov [ebx + device.reset], reset	436	mov [ebx + device.reset], reset
437	mov [ebx + device.transmit], transmit	437	mov [ebx + device.transmit], transmit
438	mov [ebx + device.unload], unload	438	mov [ebx + device.unload], unload
439	mov [ebx + device.name], my_service	439	mov [ebx + device.name], my_service
440		440
441	; save the pci bus and device numbers	441	; save the pci bus and device numbers
442		442
443	mov eax, [edx + IOCTL.input]	443	mov eax, [edx + IOCTL.input]
444	movzx ecx, byte[eax+1]	444	movzx ecx, byte[eax+1]
445	mov [ebx + device.pci_bus], ecx	445	mov [ebx + device.pci_bus], ecx
446	movzx ecx, byte[eax+2]	446	movzx ecx, byte[eax+2]
447	mov [ebx + device.pci_dev], ecx	447	mov [ebx + device.pci_dev], ecx
448		448
449	; Now, it's time to find the base io addres of the PCI device	449	; Now, it's time to find the base io addres of the PCI device
450		450
451	stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]	451	stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
452	mov [ebx + device.io_addr], eax	452	mov [ebx + device.io_addr], eax
453		453
454	; We've found the io address, find IRQ now	454	; We've found the io address, find IRQ now
455		455
456	invoke PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line	456	invoke PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
457	mov [ebx + device.irq_line], al	457	mov [ebx + device.irq_line], al
458		458
459	DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\	459	DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
460	[ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4	460	[ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4
461		461
462	; Ok, the eth_device structure is ready, let's probe the device	462	; Ok, the eth_device structure is ready, let's probe the device
463	; Because initialization fires IRQ, IRQ handler must be aware of this device	463	; Because initialization fires IRQ, IRQ handler must be aware of this device
464	mov eax, [devices] ; Add the device structure to our device list	464	mov eax, [devices] ; Add the device structure to our device list
465	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)	465	mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)
466	inc [devices] ;	466	inc [devices] ;
467		467
468	call probe ; this function will output in eax	468	call probe ; this function will output in eax
469	test eax, eax	469	test eax, eax
470	jnz .destroy ; If an error occured, exit	470	jnz .destroy ; If an error occured, exit
471		471
472	mov [ebx + device.type], NET_TYPE_ETH	472	mov [ebx + device.type], NET_TYPE_ETH
473	invoke NetRegDev	473	invoke NetRegDev
474	cmp eax, -1	474	cmp eax, -1
475	je .destroy	475	je .destroy
476		476
477	ret	477	ret
478		478
479	; If the device was already loaded, find the device number and return it in eax	479	; If the device was already loaded, find the device number and return it in eax
480		480
481	.find_devicenum:	481	.find_devicenum:
482	DEBUGF 1,"Trying to find device number of already registered device\n"	482	DEBUGF 1,"Trying to find device number of already registered device\n"
483	invoke NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx	483	invoke NetPtrToNum ; This kernel procedure converts a pointer to device struct in ebx
484	; into a device number in edi	484	; into a device number in edi
485	mov eax, edi ; Application wants it in eax instead	485	mov eax, edi ; Application wants it in eax instead
486	DEBUGF 1,"Kernel says: %u\n", eax	486	DEBUGF 1,"Kernel says: %u\n", eax
487	ret	487	ret
488		488
489	; If an error occured, remove all allocated data and exit (returning -1 in eax)	489	; If an error occured, remove all allocated data and exit (returning -1 in eax)
490		490
491	.destroy:	491	.destroy:
492	; todo: reset device into virgin state	492	; todo: reset device into virgin state
493		493
494	dec [devices]	494	dec [devices]
495	.err:	495	.err:
496	DEBUGF 2,"Error, removing all data !\n"	496	DEBUGF 2,"Error, removing all data !\n"
497	invoke KernelFree, ebx	497	invoke KernelFree, ebx
498		498
499	.fail:	499	.fail:
500	or eax, -1	500	or eax, -1

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/pcnet32.asm – Rev 4582 → 4629