WebSVN – Kolibri OS – Diff – /kernel/branches/net/drivers/i8255x.asm

 ;;    Written by hidnplayr@kolibrios.org                           ;;
 ;;                                                                 ;;
 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
+;; Some parts of this driver are based on the code of eepro100.c   ;;
+;;  from linux.                                                    ;;
 ;;                                                                 ;;
-;; Good read about how to program this family of devices:          ;;
+;; Intel's programming manual for i8255x:                          ;;
 ;; http://www.intel.com/design/network/manuals/8255x_opensdm.htm   ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 format MS COFF
-        API_VERSION             =   0x01000100
+        API_VERSION             = 0x01000100
-        DRIVER_VERSION          =   5
+        DRIVER_VERSION          = 5
-        MAX_DEVICES             =   16
+        MAX_DEVICES             = 16
-        DEBUG                   =   1
+        DEBUG                   = 1
-        __DEBUG__               =   1
+        __DEBUG__               = 1
         device:
         ETH_DEVICE
         .io_addr        dd ?
-        .pci_bus        db ?
+        .pci_bus        dd ?
-        .pci_dev        db ?
+        .pci_dev        dd ?
-        .irq_line       db ?
+        .irq_line       db ?
-        .rx_buffer      dd ?
-        .tx_buffer      dd ?
-        .ee_bus_width   dd ?
-                        rb 0x100 - (($ - device) and 0xff)
-        rxfd:
-        .status         dw ?
-        .command        dw ?
-        .link           dd ?
         .rx_buf_addr    dd ?
-        .count          dw ?
+        .rx_desc        dd ?
         .size           dw ?
-        .packet         dd ?
+        .ee_bus_width   db ?
                         rb 0x100 - (($ - device) and 0xff)
+        txfd:
-        txfd:
+        .status         dw ?
-        .status         dw ?
+        .command        dw ?
-        .command        dw ?
-        .link           dd ?
-        .tx_desc_addr   dd ?
+        .link           dd ?
-        .count          dd ?
+        .tx_desc_addr   dd ?
-        .tx_buf_addr0   dd ?
+        .count          dd ?
-        .tx_buf_size0   dd ?
-        .tx_buf_addr1   dd ?
+        .tx_buf_addr0   dd ?
-        .tx_buf_size1   dd ?
+        .tx_buf_size0   dd ?
                         rb 0x100 - (($ - device) and 0xff)
         rx_resource_errs        dd ?
         rx_overrun_errs         dd ?
         rx_colls_errs           dd ?
         rx_runt_errs            dd ?
+        last_tx_buffer          dd ?    ;;; fixme
         sizeof.device_struct = $ - device
+end virtual
+virtual at 0
+        rxfd:
+        .status         dw ?
+        .command        dw ?
+        .link           dd ?
+        .rx_buf_addr    dd ?
+        .count          dw ?
+        .size           dw ?
+        .packet:
 end virtual
 ; Serial EEPROM
+EE_SK           = 1 shl 0      ; serial clock
+EE_CS           = 1 shl 1      ; chip select
-EE_SK           =   1 shl 0   ; serial clock
+EE_DI           = 1 shl 2      ; data in
-EE_CS           =   1 shl 1   ; chip select
+EE_DO           = 1 shl 3      ; data out
-EE_DI           =   1 shl 2   ; data in
+EE_MASK         = EE_SK + EE_CS + EE_DI + EE_DO
 EE_DO           =   1 shl 3   ; data out
+; opcodes, first bit is start bit and must be 1
-EE_READ         =   110b
+EE_READ         = 110b
-EE_WRITE        =   101b
+EE_WRITE        = 101b
-EE_ERASE        =   111b
+EE_ERASE        = 111b
 ; The SCB accepts the following controls for the Tx and Rx units:
-CU_START        =   0x0010
+CU_START        = 0x0010
-CU_RESUME       =   0x0020
+CU_RESUME       = 0x0020
-CU_STATSADDR    =   0x0040
+CU_STATSADDR    = 0x0040
-CU_SHOWSTATS    =   0x0050   ; Dump statistics counters.
+CU_SHOWSTATS    = 0x0050        ; Dump statistics counters.
-CU_CMD_BASE     =   0x0060   ; Base address to add to add CU commands.
+CU_CMD_BASE     = 0x0060        ; Base address to add CU commands.
-CU_DUMPSTATS    =   0x0070   ; Dump then reset stats counters.
+CU_DUMPSTATS    = 0x0070        ; Dump then reset stats counters.
-RX_START        =   0x0001
+RX_START        = 0x0001
-RX_RESUME       =   0x0002
+RX_RESUME       = 0x0002
-RX_ABORT        =   0x0004
+RX_ABORT        = 0x0004
-RX_ADDR_LOAD    =   0x0006
+RX_ADDR_LOAD    = 0x0006
-RX_RESUMENR     =   0x0007
+RX_RESUMENR     = 0x0007
-INT_MASK        =   0x0100
+INT_MASK        = 0x0100
-DRVR_INT        =   0x0200   ; Driver generated interrupt
+DRVR_INT        = 0x0200        ; Driver generated interrupt
-CmdIASetup      =   0x0001
+CmdIASetup      = 0x0001
-CmdConfigure    =   0x0002
+CmdConfigure    = 0x0002
-CmdTx           =   0x0004 ;;;;
+CmdTx           = 0x0004
-CmdTxFlex       =   0x0008 ;;;
+CmdTxFlex       = 0x0008
-Cmdsuspend      =   0x4000
+Cmdsuspend      = 0x4000
 reg_scb_status  =   0
-reg_scb_cmd     =   2
+reg_scb_status  = 0
-reg_scb_ptr     =   4
+reg_scb_cmd     = 2
-reg_port        =   8
+reg_scb_ptr     = 4
-reg_eeprom_ctrl =   12
+reg_port        = 8
-reg_eeprom      =   14
+reg_eeprom      = 14
-reg_mdi_ctrl    =   16
+reg_mdi_ctrl    = 16
 macro delay {
         push    eax
-        in      eax, dx
+        in      ax, dx
-        in      eax, dx
+        in      ax, dx
-        in      eax, dx
+        in      ax, dx
-        in      eax, dx
+        in      ax, dx
 ;        mov     eax, [IOCTL.input]                      ; get the pci bus and device numbers
         mov     ax , [eax+1]                            ;
   .nextdevice:
         mov     ebx, [esi]
+        cmp     al, byte[device.pci_bus]
+        jne     @f
-        cmp     ax , word [device.pci_bus]              ; compare with pci and device num in device list (notice the usage of word instead of byte)
+        cmp     ah, byte[device.pci_dev]
+        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
-        je      .find_devicenum                         ; Device is already loaded, let's find it's device number
+       @@:
         add     esi, 4
         loop    .nextdevice
         mov     [device.name], my_service
 ; save the pci bus and device numbers
         mov     eax, [IOCTL.input]
-        mov     cl, [eax+1]
+        movzx   ecx, byte[eax+1]
-        mov     [device.pci_bus], cl
+        mov     [device.pci_bus], ecx
-        mov     cl, [eax+2]
+        movzx   ecx, byte[eax+2]
-        mov     [device.pci_dev], cl
+        mov     [device.pci_dev], ecx
 ; Now, it's time to find the base io addres of the PCI device
-        find_io [device.pci_bus], [device.pci_dev], [device.io_addr]
+        PCI_find_io
-; We've found the io address, find IRQ now
         find_irq [device.pci_bus], [device.pci_dev], [device.irq_line]
+; We've found the io address, find IRQ now
+        PCI_find_irq
         DEBUGF  2,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
         [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
-        allocate_and_clear [device.rx_buffer], (4096), .err
+; Ok, the eth_device structure is ready, let's probe the device
         allocate_and_clear [device.tx_buffer], (4096), .err
+        pushf
         cli                     ; disable ints until initialisation is done
 ; Ok, the eth_device structure is ready, let's probe the device
         call    probe                                                   ; this function will output in eax
         ret
 ; If an error occured, remove all allocated data and exit (returning -1 in eax)
-  .err:
         stdcall KernelFree, [device.rx_buffer]
-        stdcall KernelFree, [device.tx_buffer]
+  .err:
         stdcall KernelFree, ebx
 align 4
 probe:
         DEBUGF  1,"Probing i8255x\n"
-        make_bus_master [device.pci_bus], [device.pci_dev]
+        PCI_make_bus_master
-;---------------------------
-; First, identify the device
 ;---------------------------
-        movzx   ecx, [device.pci_bus]
+; First, identify the device
         movzx   edx, [device.pci_dev]
 ;----------
 align 4
+reset:
+        movzx   eax, [device.irq_line]
+        DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
+        stdcall AttachIntHandler, eax, int_handler, dword 0
+        test    eax, eax
+        jnz     @f
+        DEBUGF  1,"\nCould not attach int handler!\n"
+;        or      eax, -1
+;        ret
+  @@:
-reset:
+        DEBUGF  1,"Resetting %s\n", my_service
 ;---------------
 ; reset the card
 ;---------------------------------
 ; Tell device where to store stats
         lea     eax, [lstats]
+        GetRealAddr
-        GetRealAddr
+        set_io  0
         set_io  reg_scb_ptr
         out     dx, eax
         mov     ax, INT_MASK + CU_STATSADDR
         set_io  reg_scb_cmd
         out     dx, ax
         call    cmd_wait
 ;-----------------
+;-----------------
-; Set CU base to 0
+; setup RX
         xor     eax, eax
+        set_io  reg_scb_ptr
-        set_io  reg_scb_ptr
+        xor     eax, eax
         out     dx, eax
-        mov     ax, INT_MASK + RX_ADDR_LOAD
+        set_io  reg_scb_cmd
-        set_io  reg_scb_cmd
-        out     dx, ax
-        call    cmd_wait
-;---------------------
-; build rxfd structure
-        mov     ax, 0x0001
-        mov     [rxfd.status], ax
-        mov     ax, 0x0000
-        mov     [rxfd.command], ax
-        lea     eax, [rxfd.status]
-        GetRealAddr
-        mov     [rxfd.link], eax
-        lea     eax, [device.rx_buffer]
+        mov     ax, INT_MASK + RX_ADDR_LOAD
-        GetRealAddr
-        mov     [rxfd.rx_buf_addr], eax
+        out     dx, ax
+        call    cmd_wait
         xor     ax, ax
-        mov     [rxfd.count], ax
+;-----------------------------
 ; Create RX and TX descriptors
         mov     ax, 1528
-        mov     [rxfd.size], ax
         call    create_ring
-;-------------------------------
-; Set ptr to first command block
-        set_io  reg_scb_ptr
-        lea     eax, [rxfd]
-        GetRealAddr
-        out     dx, eax
-        set_io  reg_scb_cmd
-        mov     ax, INT_MASK + RX_START
-        out     dx, ax
-        call    cmd_wait
-;-------------------
 ; start the receiver
-        mov     [rxfd.status], 0
+; RX start
         mov     [rxfd.command], 0xc000
-        set_io  reg_scb_ptr
+        set_io  0
-        lea     eax, [rxfd]
+        set_io  reg_scb_ptr
-        GetRealAddr
+        mov     eax, [device.rx_desc]
-        out     dx, eax
+        GetRealAddr
         out     dx, eax
         set_io  reg_scb_cmd
         mov     ax, INT_MASK + RX_START
-        out     dx, ax
+        set_io  reg_scb_cmd
-        call    cmd_wait
+        out     dx, ax
+        call    cmd_wait
-;-----------------
+; Set-up TX
+        set_io  reg_scb_ptr
+        xor     eax, eax
+        out     dx, eax
+        set_io  reg_scb_cmd
+        mov     ax, INT_MASK + CU_CMD_BASE
+        out     dx, ax
+        call    cmd_wait
+;  --------------------
+        mov     [confcmd.command], CmdConfigure + Cmdsuspend
+        mov     [confcmd.status], 0
-; set CU base to 0
+        lea     eax, [txfd]
         GetRealAddr
-        set_io  reg_scb_ptr
+        mov     [confcmd.link], eax
         xor     eax, eax
-        out     dx, eax
+        mov     esi, confcmd_data
-        set_io  reg_scb_cmd
-        mov     ax, INT_MASK + CU_CMD_BASE
-        out     dx, ax
+        lea     edi, [confcmd.data]
-        call    cmd_wait
-;--------------------
-; Set TX Base address
-; First, set up confcmd values
-        mov     [txfd.command], CmdIASetup
-        mov     [txfd.status], 0
+        mov     ecx, 22
+        rep     movsb
-        lea     eax, [confcmd]
+        mov     byte[confcmd.data + 1], 0x88  ; fifo of 8 each
-        GetRealAddr
-        mov     [txfd.link], eax
-        mov     word [confcmd.command], Cmdsuspend + CmdConfigure
+        mov     byte[confcmd.data + 4], 0
+        mov     byte[confcmd.data + 5], 0x80
+        mov     byte[confcmd.data + 15], 0x48
-        mov     word [confcmd.status], 0
+        mov     byte[confcmd.data + 19], 0x80
-        lea     eax, [txfd]
+        mov     byte[confcmd.data + 21], 0x05
-        GetRealAddr
+        mov     [txfd.command], CmdIASetup
+        mov     [txfd.status], 0
-        mov     [confcmd.link], eax
+        lea     eax, [confcmd]
         GetRealAddr
+        mov     [txfd.link], eax
-        mov     byte [confcmd.data + 1], 0x88  ; fifo of 8 each
+;;; copy in our MAC
-        mov     byte [confcmd.data + 4], 0
-        mov     byte [confcmd.data + 5], 0x80
-        mov     byte [confcmd.data + 15], 0x48
+        lea     edi, [txfd.tx_desc_addr]
+        lea     esi, [device.mac]
+        movsd
-        mov     byte [confcmd.data + 19], 0x80
+        movsw
-        mov     byte [confcmd.data + 21], 0x05
+        set_io  reg_scb_ptr
+        lea     eax, [txfd]
+        GetRealAddr
+        out     dx, eax
+; Start CU & enable ints
+        set_io  reg_scb_cmd
+        mov     ax, CU_START
+        out     dx, ax
+        call    cmd_wait
+;-----------------------
+; build txfd structure (again!)
+        lea     eax, [txfd]
+        GetRealAddr
+        mov     [txfd.link], eax
+        mov     [txfd.count], 0x02208000
+        lea     eax, [txfd.tx_buf_addr0]
+        GetRealAddr
+        mov     [txfd.tx_desc_addr], eax
+; Indicate that we have successfully reset the card
+        DEBUGF  1,"Resetting %s complete\n", my_service
+        mov     [device.mtu], 1514
+        xor     eax, eax        ; indicate that we have successfully reset the card
+        ret
+align 4
+create_ring:
 ; CU start
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 transmit:
-        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n",[esp+4],[esp+8]
+        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [esp+4], [esp+8]
         mov     eax, [esp+4]
         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     dword [esp+8], 1500
+        cmp     dword [esp+8], 1514
-        ja      .error                          ; packet is too long
-        cmp     dword [esp+8], 60
-        jb      .error                          ; packet is too short
-        set_io  0
-        in      ax, dx
-        and     ax, 0xfc00
+        ja      .error                          ; packet is too long
-        out     dx, ax
-        mov     [txfd.status], 0
-        mov     [txfd.command], Cmdsuspend + CmdTx + CmdTxFlex
-        lea     eax, [txfd]
-        GetRealAddr
-        mov     [txfd.link], eax
+        cmp     dword [esp+8], 60
-        mov     [txfd.count], 0x02208000
-        lea     eax, [txfd.tx_buf_addr0]
+        jb      .error                          ; packet is too short
+        ;;; TODO: check if current descriptor is in use
-        GetRealAddr
+        ; fill in buffer address and size
-        mov     [txfd.tx_desc_addr], eax
+        mov     eax, [esp+4]
         mov     [last_tx_buffer], eax   ;;; FIXME
-        mov     eax, [esp+4]
+        GetRealAddr
         mov     [txfd.tx_buf_addr0], eax
+        mov     eax, [esp+8]
-        mov     eax, [esp+8]
+        mov     [txfd.tx_buf_size0], eax
-        mov     [txfd.tx_buf_size0], eax
+        mov     [txfd.status], 0
         mov     [txfd.command], Cmdsuspend + CmdTx + CmdTxFlex + 1 shl 15 ;;; EL bit
-        ; Copy the buffer address and size in
+ ;       mov     [txfd.count], 0x02208000   ;;;;;;;;;;;
         mov     [txfd.tx_buf_addr1], 0
+        ; Inform device of the new/updated transmit descriptor
-        mov     [txfd.tx_buf_size1], 0
+        lea     eax, [txfd]
         GetRealAddr
-        lea     eax, [txfd]
+        set_io  0
-        GetRealAddr
         set_io  reg_scb_ptr
+        out     dx, eax
+        ; Start the transmit
+        mov     ax, CU_START
+        set_io  reg_scb_cmd
-        out     dx, eax
+        out     dx, ax
+        call    cmd_wait
+;        set_io  0               ;; why?
+;        in      ax, dx          ;;
-        mov     ax, INT_MASK + CU_START
+;
-        set_io  reg_scb_cmd
+;  @@:
+;        cmp     [txfd.status], 0  ; wait for completion? dont seems a good idea to me..
+;        je      @r
-        out     dx, ax
-        call    cmd_wait
+;
-        in      ax, dx
+;        set_io  0               ;; why?
 ;        in      ax, dx          ;;
   .I8t_001:
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+;        set_io  0              ; reg_scb_status = 0
         set_io  reg_scb_status
         in      ax, dx
         out     dx, ax                              ; send it back to ACK
         test    ax, ax
   .nothing:
         ret                                         ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
   .got_it:
+        DEBUGF  1,"Device: %x Status: %x\n", ebx, ax
+        test    ax, 1 shl 14    ; did we receive a frame?
+        jz      .no_rx
+        push    ax
-        DEBUGF  1,"Device: %x Status: %x ", ebx, ax
+        DEBUGF  1,"Receiving\n"
+        push    ebx
+  .rx_loop:
         pop     ebx
-       ;;; receive
+        mov     esi, [device.rx_desc]
+        cmp     [esi + rxfd.status], 0        ; we could also check bits C and OK (bit 15 and 13)
+        je      .nodata
-        cmp     [rxfd.status], 0
+        DEBUGF  1,"rxfd status=0x%x\n", [esi + rxfd.status]:4
-        je      .nodata
+        movzx   ecx, [esi + rxfd.count]
+        and     ecx, 0x3fff
+        push    ebx
+        push    .rx_loop
+        push    ecx
+        add     esi, rxfd.packet
+        push    esi
+; Update stats
+        add     dword [device.bytes_rx], ecx
+        adc     dword [device.bytes_rx + 4], 0
+        inc     dword [device.packets_rx]
+; allocate new descriptor
+        stdcall KernelAlloc, 2000
+        mov     [device.rx_desc], eax
+        mov     esi, eax
+        GetRealAddr
+        mov     [esi + rxfd.status], 0x0000
+        mov     [esi + rxfd.command], 0xc000    ; End of list + Suspend
+        mov     [esi + rxfd.link], eax
+        mov     [esi + rxfd.count], 0
+        mov     [esi + rxfd.size], 1528
-        mov     [rxfd.status], 0
+; restart RX
         mov     [rxfd.command], 0xc000
+        set_io  0
         set_io  reg_scb_ptr
-        lea     eax, [rxfd.status]
-        GetRealAddr
+;        lea     eax, [device.rx_desc]
-        out     dx, eax
+;        GetRealAddr
-        set_io  reg_scb_cmd
-        mov     ax, INT_MASK + RX_START
-        out     dx, ax
+        out     dx, eax
+        set_io  reg_scb_cmd
+        mov     ax, RX_START
-        call    cmd_wait
+        out     dx, ax
-        movzx   ecx, [rxfd.count]
-        and     ecx, 0x3fff
-        stdcall KernelAlloc, ecx        ; Allocate a buffer to put packet into
-        push    ecx
-        push    eax
-        lea     esi, [device.rx_buffer]
-  .copy:
-        shr     ecx, 1
+        call    cmd_wait
+; And give packet to kernel
+        jmp     Eth_input
-        jnc     .nb
+  .nodata:
-        movsb
+        DEBUGF  1, "no more data\n"
-  .nb:
+        pop     ax
+align 4
+ee_read:        ; esi = address to read
 align 4
-ee_read:        ; esi = address to read
+        DEBUGF  1,"Eeprom read from 0x%x", esi
         set_io  0
         set_io  reg_eeprom
 ;-----------------------------------------------------
 ; Prepend start bit + read opcode to the address field
 ; and shift it to the very left bits of esi
-        mov     ecx, 32
+        mov     cl, 29
+        sub     cl, [device.ee_bus_width]
+        shl     esi, cl
+        or      esi, EE_READ shl 29
-        sub     ecx, [device.ee_bus_width]
+        movzx   ecx, [device.ee_bus_width]
-        shl     esi, cl
+        add     ecx, 3
         or      esi, EE_READ shl 28
+        mov     al, EE_CS
-        mov     ecx, [device.ee_bus_width]
+        out     dx, al
-        add     ecx, 3
+        delay
 ;-----------------------
 ; Write this to the chip
   .loop:
-        mov     eax, EE_CS
+        mov     al, EE_CS + EE_SK
         shl     esi, 1
         jnc     @f
-        or      eax, EE_DI
+        or      al, EE_DI
         xor     esi, esi
         mov     ecx, 16
+  .loop2:
-  .loop2:
+        shl     esi, 1
-        mov     eax, EE_CS + EE_SK
+        mov     al, EE_CS + EE_SK
-        out     dx , eax
+        out     dx, al
         delay
-        in      eax, dx
+        in      al, dx
-        test    eax, EE_DO
+        test    al, EE_DO
-        jz      @f
-        inc     esi
+        jz      @f
-       @@:
+        inc     esi
-        shl     esi, 1
+       @@:
-        mov     eax, EE_CS
+        mov     al, EE_CS
-        out     dx , eax
+        out     dx, al
         delay
         loop    .loop2
 ;-----------------------
 ; de-activate the eeprom
+        xor     ax, ax
         out     dx, ax
         xor     eax, eax
         out     dx, eax
         DEBUGF  1,"=0x%x\n", esi:4
         ret
-        DEBUGF  1,"data=%x\n", esi
-        ret
+align 4
+ee_write:       ; esi = address to write to, di = data
 align 4
+        DEBUGF  1,"Eeprom write 0x%x to 0x%x\n", di, esi
+        set_io  0
-ee_write:       ; esi = address to write to, di = data
+        set_io  reg_eeprom
-        set_io  0
+;-----------------------------------------------------
-        set_io  reg_eeprom
+; Prepend start bit + write opcode to the address field
 ; and shift it to the very left bits of esi
 ;-----------------------------------------------------
-; Prepend start bit + write opcode to the address field
+        mov     cl, 29
-; and shift it to the very left bits of esi
+        sub     cl, [device.ee_bus_width]
+        shl     esi, cl
-        mov     ecx, 32
+        or      esi, EE_WRITE shl 29
-        sub     ecx, [device.ee_bus_width]
-        shl     esi, cl
+        movzx   ecx, [device.ee_bus_width]
-        or      esi, EE_WRITE shl 28
+        add     ecx, 3
-        mov     ecx, [device.ee_bus_width]
+        mov     al, EE_CS       ; enable chip
-        add     ecx, 3
+        out     dx, al
 ;-----------------------
 ; Write this to the chip
   .loop:
-        mov     eax, EE_CS
+        mov     al, EE_CS + EE_SK
         shl     esi, 1
         jnc     @f
-        or      eax, EE_DI
+        or      al, EE_DI
        @@:
-        out     dx , eax
+        out     dx, al
         delay
-        or      eax, EE_SK
+        and     al, not EE_SK
-        out     dx , eax
+        out     dx, al
         delay
         loop    .loop
 ;-----------------------------
+; Now write the data to eeprom
-; Now write the data to eeprom
+        mov     ecx, 16
+  .loop2:
+        mov     al, EE_CS + EE_SK
+        shl     di, 1
+        jnc     @f
-        mov     ecx, 16
+        or      al, EE_DI
        @@:
-  .loop2:
+        out     dx, al
+        delay
+        and     al, not EE_SK
-        mov     eax, EE_CS
+        out     dx, al
+        delay
-        shl     di , 1
-        jnc     @f
+        loop    .loop2
-        or      eax, EE_DI
-       @@:
+;-----------------------
-        out     dx , eax
+; de-activate the eeprom
         delay
+        xor     al, al
+        out     dx, al
-        or      eax, EE_SK
+        ret
         out     dx , eax
+align 4
+ee_get_width:
+;        DEBUGF  1,"Eeprom get width\n"
-        delay
+        set_io  0
-        loop    .loop2
+        set_io  reg_eeprom
 ; ax = data
 align 4
+mdio_read:
-mdio_read:
+        DEBUGF  1,"MDIO read\n"
         shl     ecx, 21                 ; PHY addr
         shl     edx, 16                 ; PHY reg addr
 ; ax = data
 align 4
+mdio_write:
-mdio_write:
+        DEBUGF  1,"MDIO write\n"
         and     eax, 0xffff
 align 4
 MAC_read_eeprom:
         mov     esi, 0
+        call    ee_read
-        call    ee_read
+        mov     word[device.mac], si
+        mov     esi, 1
-        mov     esi, 1
-        call    ee_read
-        mov     esi, 14
+        call    ee_read
-        call    ee_read
+        mov     word[device.mac+2], si
         mov     esi, 2
 ; End of code
 align 4                                         ; Place all initialised data here
-devices       dd 0                              ; number of currently running devices
+devices         dd 0                              ; number of currently running devices
+version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
+my_service      db 'i8255x', 0                    ; max 16 chars include zero
+devicename      db 'Intel Etherexpress pro/100', 0
-version       dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
+confcmd_data    db 22, 0x08, 0, 0, 0, 0x80, 0x32, 0x03, 1
-my_service    db 'i8255x',0                     ; max 16 chars include zero
+                db 0, 0x2e, 0, 0x60, 0, 0xf2, 0x48, 0, 0x40, 0xf2

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/drivers/i8255x.asm @ 3346 – Rev 3155 → 3206