Давай. У меня пока вот что получилось. Работает, но слегка теряет пакеты. На 38400 - 3% на пинге, чем выше скорость тем меньше.
/***************************************************************************
* Copyright (C) 2005 by Igor Timoshenko *
* timigor@yandex.ru *
* Simple SLIP *
***************************************************************************/
MODULE_LICENSE("GNU");
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/jiffies.h>
#include <asm/io.h>
#include <linux/skbuff.h>
#include <linux/timer.h>
#define TIMEOUT HZ/50
#define TIMEPIC HZ/100
/*РЕГИСТРЫ СОМ ПОРТА*/
#define BASE 0x3f8 // базовый адрес для СОМ1
#define ICR_N 1 // регистр управления прерываниями 3f9
#define IIDR_N 2 // регистр идент прерывания / упр. буферизацией 3fa
#define MCR_N 4 // регистр управления модемом 3fc
#define LSR_N 5 // регистр состояния линии 3fd
#define MSR_N 6 // регистр состояния модема 3fe
// регистр управления модемом
typedef union _MCR_ {
struct {
unsigned char dtr : 1;
unsigned char rts : 1;
unsigned char out1 : 1;
unsigned char out2 : 1;
unsigned char diag : 1;
unsigned char reserv : 3;
} bit_reg;
unsigned char byte;
} MCR;
MCR reg_mcr;
// регистр состояния модема
typedef union _MSR_ {
struct {
unsigned char change_cts : 1;
unsigned char change_dsr : 1;
unsigned char change_ri : 1;
unsigned char change_dcd : 1;
unsigned char cts : 1;
unsigned char dsr : 1;
unsigned char ri : 1;
unsigned char dcd : 1;
} bit_reg;
unsigned char byte;
} MSR;
MSR reg_msr;
// регистр состояния линии
typedef union _LSR_ {
struct {
unsigned char in_ready : 1;
unsigned char overflow : 1;
unsigned char parity : 1;
unsigned char synxr : 1;
unsigned char break_detect : 1;
unsigned char out_ready : 1;
unsigned char shift_ready : 1;
unsigned char taimout : 1;
} bit_reg;
unsigned char byte;
} LSR;
LSR reg_lsr;
/*Структура IP пакета*/
struct iphdr {
unsigned int ihl:4;
unsigned int version:4;
u_int8_t tos;
u_int16_t tot_len;
u_int16_t id;
u_int16_t frag_off;
u_int8_t ttl;
u_int8_t protocol;
u_int16_t check;
unsigned char saddr[4]; /* IP address of originator */
unsigned char daddr[4]; /* IP address of destination */
/*The options start here. */
};
struct my_buf {
int rlen;
unsigned char rtail[2];
union rbuffer{
unsigned char rbuff[1024];
struct iphdr rhdr;
}rb;
int tlen;
union tbuffer{
unsigned char tbuff[1024];
struct iphdr thdr;
}tb;
};
int ssl_stop (struct net_device *dev);
int ssl_open (struct net_device *dev);
static int ssl_xmit(struct sk_buff *skb, struct net_device *dev);
static struct net_device_stats *ssl_get_stats(struct net_device *dev);
static void load_pack(struct my_buf *xbf);
//void tpdumpk(struct my_buf *txbf);
//void rpdumpk(struct my_buf *sxbf);
struct net_device ssl_dev = {
.open
= ssl_open,
.stop
= ssl_stop,
.hard_start_xmit
= ssl_xmit,
};
struct net_device_stats *stats;
struct timer_list timer;
struct my_buf xbf;
spinlock_t timer_lock = SPIN_LOCK_UNLOCKED;
spinlock_t tx_lock = SPIN_LOCK_UNLOCKED;
unsigned long timeout;
unsigned char data;
int retval, shift, i;
/*ПРЕРЫВАНИЕ ТАЙМЕРА=##########*/
void ssl_irq (unsigned long data)
{
spin_lock_bh(&timer_lock);
struct net_device_stats *stats = ssl_dev.priv;
struct my_buf *qbf;
qbf = &xbf;
//ПРЯМОЕ ЧТЕНИЕ ИЗ ПОРТА ttyS0 УПРАВЛЕНИЕ RTS-> DSR<-
reg_msr.byte = inb_p(BASE + MSR_N);
if (reg_msr.bit_reg.dsr != 0) {
//ждём запроса от передатчика
reg_mcr.bit_reg.rts = 1;
outb_p(reg_mcr.byte, BASE + MCR_N);
//подтверждаем готовность приёма
shift = 0;
while (reg_msr.bit_reg.dsr == 1) { //принимаем пока передают
while ((inb_p(BASE + LSR_N) & 1)==0);
qbf->rb.rbuff[++shift-2] = inb_p(BASE);
if (shift > 1024) {
printk(KERN_WARNING "ssl: R_buffer is small and overfull, dropping packet.\n");
stats->rx_dropped++;
goto r_out;
}
reg_msr.byte = inb_p(BASE + MSR_N);
}
//Пакет принят
if (shift == 0) {
printk(KERN_WARNING "ssl: Packet is 0 byte, dropping packet.\n");
stats->rx_dropped++;
goto r_out;
}
qbf->rlen = shift-2;
//rpdumpk(&xbf);
//Дамп принятого в буфер пакета в логе
load_pack(&xbf);
//Отправка принятого пакета в SKB
} //else printk(KERN_WARNING "ssl: Line DSR is free.\n");
r_out:
reg_mcr.bit_reg.rts = 0;
outb_p(reg_mcr.byte, BASE + MCR_N); //снимаем подтверждение приёма
//ПРЯМАЯ ЗАПИСЬ В ПОРТ ttyS0 УПРАВЛЕНИЕ DTR-> CTS<-
reg_lsr.byte = inb_p(BASE + LSR_N);
if (reg_lsr.bit_reg.out_ready != 0) {
if (qbf->tlen > 0) {
reg_msr.byte = inb_p(BASE + MSR_N);
if (reg_msr.bit_reg.cts == 0) {
reg_mcr.bit_reg.dtr = 1;
outb_p(reg_mcr.byte, BASE + MCR_N);
//занял линию
timeout = jiffies + TIMEOUT;
while (reg_msr.bit_reg.cts == 0) {
//ждём ответа CTS от приёмника
reg_msr.byte = inb_p(BASE + MSR_N);
//таймаут
if (jiffies > timeout) {
printk(KERN_WARNING "ssl: Rerly CTS is absen - timeout, dropping packet.\n");
stats->tx_dropped++;
goto t_out;
}
}
shift = 0;
while (shift + 1 <= qbf->tlen) {
//передаём до конца буфера
while ((inb_p(BASE + LSR_N) & 0x20)==0);
outb_p(qbf->tb.tbuff[shift], BASE);
shift++;
}
while ((inb_p(BASE + LSR_N) & 0x20)==0);
//Push bufer UART
outb_p(0, BASE);
while ((inb_p(BASE + LSR_N) & 0x20)==0);
outb_p(0, BASE);
//tpdumpk(&xbf); //Дамп из буфера переданного пакета
} //else printk(KERN_WARNING "ssl: Line CTS is busy.\n");
} //else printk(KERN_WARNING "ssl: Transmit buf is empty.\n");
} //else printk(KERN_WARNING "ssl: Out is full.\n");
t_out:
qbf->tlen = 0;
reg_mcr.bit_reg.dtr = 0;
outb_p(reg_mcr.byte, BASE + MCR_N);
//освободил линию
mod_timer(&timer, jiffies + TIMEPIC);
spin_unlock_bh(&timer_lock);
}
/*ПЕРЕДАЧА ПАКЕТА###########################*/
static int ssl_xmit (struct sk_buff *skb, struct net_device *dev)
{
struct net_device_stats *stats = dev->priv;
struct my_buf *qbf;
qbf = &xbf;
spin_lock_bh(&tx_lock);
if (skb->len > 1024 - 3) {
printk(KERN_WARNING "ssl: T_buffer is small, dropping packet.\n");
stats->tx_dropped++;
} else {
//printk(KERN_WARNING "ssl: CALL TRANSMIT.\n");
if (qbf->tlen == 0) {
//Передача пакета в буфер передатчика
xbf.tlen = skb->len;
shift = 0;
while (shift + 1 <= skb->len) {
xbf.tb.tbuff[shift] = skb->data[shift];
shift++;
}
qbf->tlen = skb->len;
//printk(KERN_WARNING "ssl: TRANSMIT.\n");
stats->tx_bytes += skb->len;
stats->tx_packets++;
} else {
printk(KERN_WARNING "ssl: T_buffer is busy, dropping packet.\n");
stats->tx_dropped++;
}
}
spin_unlock_bh(&tx_lock);
dev_kfree_skb(skb);
stats->tx_bytes += skb->len;
stats->tx_packets++;
return 0;
}
/*===================ПРИЁМ ПАКЕТА=========================*/
static void load_pack(struct my_buf *xbf)
{
struct net_device_stats *stats = ssl_dev.priv;
struct sk_buff *r_skb;
int count;
count = xbf->rlen;
//printk(KERN_WARNING "ssl: Принят пакет.\n");
r_skb = dev_alloc_skb(count);
if (r_skb == NULL) {
printk(KERN_WARNING "ssl: memory squeeze, dropping packet.\n");
stats->rx_dropped++;
return;
}
r_skb->dev = &ssl_dev;
memcpy(skb_put(r_skb, count), xbf->rb.rbuff, count);
r_skb->mac.raw=r_skb->data;
r_skb->protocol=htons(ETH_P_IP);
//rpdumpk(xbf); //Дамп из буфера принятого пакета
netif_rx(r_skb);
stats->rx_bytes += xbf->rlen;
stats->rx_packets++;
}
static struct net_device_stats *ssl_get_stats(struct net_device *dev)
{ return dev->priv; }
/*ИНИЦИАЛИЗАЦИЯ ИНТЕРФЕЙСА ####################*/
int ssl_open (struct net_device *dev)
{
printk(KERN_WARNING "ssl: open ssl.\n");
netif_start_queue (dev);
//ИНИЦИАЛИЗАЦИЯ COM1
outb_p(0, BASE + IIDR_N);
//запрет буферизации
outb_p(0, BASE + ICR_N);
//запрет прерываний
//printk (KERN_WARNING "ssl: Initializing ttySn succesful!.\n");
reg_mcr.byte = 0;
//инициализация таймера
init_timer(&timer);
timer.expires = jiffies + HZ;
timer.function = ssl_irq;
add_timer(&timer);
return 0;
}
/*УБИЕНИЕ ИНТЕРФЕЙСА #############################*/
int ssl_stop (struct net_device *dev)
{
outb_p(0, BASE + MCR_N);
//освободим линии модема
del_timer_sync(&timer);
//остановка таймера
printk (KERN_WARNING "ssl: stop ssl.\n");
netif_stop_queue(dev);
return 0;
}
/*=============ИНИЦИАЛИЗАЦИЯ МОДУЛЯ================*/
int ssl_init_module (void)
{
strcpy (ssl_dev.name, "ssl");
stats = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
if (stats) {
memset(stats, 0, sizeof(struct net_device_stats));
ssl_dev.priv = stats;
ssl_dev.get_stats = &ssl_get_stats;
}
if ((retval = register_netdev (&ssl_dev))) {
printk (KERN_WARNING "ssl: Error %d of initializing ssl module.\n",retval);
return retval;
}
printk(KERN_WARNING "ssl: initializing ssl module.\n");
return 0;
}
/*============ВЫГРУЗКА МОДУЛЯ==========================*/
void ssl_cleanup (void)
{
unregister_netdev (&ssl_dev);
printk (KERN_WARNING "ssl: Cleaning Up ssl module.\n");
return;
}
module_init (ssl_init_module);
module_exit (ssl_cleanup);
/*#############################################################*/
/*===ДЛЯ ИСПОЛЬЗОВАНИЯ В ДЕМОНСТРАЦИОННЫХ ЦЕЛЯХ=======*/
/*##############################################################*/
// Изменение формата адреса из двоичного в текстовый.*/
/*void printAddr(unsigned char *addr)
{
int j;
for ( j = 0; j < 4; j++ )
{
printk("%d", addr[j]);
if ( j < 3 )
printk(".");
}
}
// Дамп буфера передатчика
void tpdumpk(struct my_buf *txbf)
{
int i;
printk("\n----------------");
for ( i = 0; i < txbf->tlen; i++ )
{
if ( !(i & 15) ) printk("\n%04X: ", i);
printk("%02X ", ((unsigned char*)txbf->tb.tbuff)[i]);
}
printk("\n");
printk("IPv%d: hdr-size=%d pkt-size=%d protocol=%d TTL=%d ",
txbf->tb.thdr.version, txbf->tb.thdr.ihl*4, ntohs(txbf->tb.thdr.tot_len),
txbf->tb.thdr.protocol, txbf->tb.thdr.ttl);
printk("\n");
printk("rst= ");
printAddr(txbf->tb.thdr.saddr);
printk(" dst= ");
printAddr(txbf->tb.thdr.daddr);
printk("\n");
}
//Дамп буфера приёмника
void rpdumpk(struct my_buf *sxbf)
{
int i;
printk("\n----------------");
for ( i = 0; i < sxbf->rlen; i++ )
{
if ( !(i & 15) ) printk("\n%04X: ", i);
printk("%02X ", ((unsigned char*)sxbf->rb.rbuff)[i]);
}
printk("\n");
printk("IPv%d: hdr-size=%d pkt-size=%d protocol=%d TTL=%d ",
sxbf->rb.rhdr.version, sxbf->rb.rhdr.ihl*4, ntohs(sxbf->rb.rhdr.tot_len),
sxbf->rb.rhdr.protocol, sxbf->rb.rhdr.ttl);
printk("\n");
printk("rst= ");
printAddr(sxbf->rb.rhdr.saddr);
printk(" dst= ");
printAddr(sxbf->rb.rhdr.daddr);
printk("\n");
}
*/
