Programari lliure a les comarques gironines

Amigos, decididamente he pasado a engrosar el mundo de Linux, instal@¡ndome el SuSE 9.0, que por el momento y dentro de mi escao conocimiento, me ha parecido magnífico. El instalador es sensacional, nada que ver con las antiguas versiones. El único problema que tengo y que por los foros de linux, veo que ese problema es compartido por un gran número de usuarios linux, es que tengo un módem ADSL USB Vitelcom, que no funciona bajo esa plataforma. Llamé a Telefónica, que es la que distribuye esos módems y me dijeron que su empresa _solo_ trabaja con Windows y que no puede hacer nada. Buscando por inet hallé en http://www.speedtouchdsl.com/dvrreg_lx.htm y en http://bulmalug.net/body.phtml?nIdNoticia=1224 un código fuente, al parecer, para que ese módem funcione con linux. Yo ignoro si el Linux dispone de un compilador, pero tampoco sabría hacerlo servir. En http://adslinux.iespana.es/adslinux/ hay un driver, pero el link no funciona.
¿Podrian Vds. hacer algo al respecto, en beneficio de la comunidad?. El resultado, si lo hay, lo transmitiré a todos los foros a los que estoy suscrito.
Gracias

_*CÓDIGO FUENTE:*_

/*
* Driver Module for Alcatel SpeedTouch USB xDSL modem
*
* Written by Johan Verrept (Johan.Verrept(arrova)advalvas.be)
*
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include
#include

#include "sarlib.h"

/*
#define DEBUG 1
*/
#define DEBUG_PACKET 1

#ifdef DEBUG
#define PDEBUG(arg...) printk(KERN_DEBUG "SpeedTouch USB: " arg)
#else
#define PDEBUG(arg...)
#endif

#ifdef DEBUG_PACKET
#define PACKETDEBUG(arg...) udsl_print_packet ( arg )
#else
#define PACKETDEBUG(arg...)
#endif

MODULE_AUTHOR ("Johan Verrept (Johan.Verrept(arrova)advalvas.be)");
MODULE_DESCRIPTION ("Driver for the Alcatel Speed Touch USB ADSL modem.");

#define SPEEDTOUCH_VENDORID 0x06b9
#define SPEEDTOUCH_PRODUCTID 0x4061

#define MAX_UDSL 1
#define UDSL_OBUF_SIZE 32768
#define UDSL_MINOR 48
#define UDSL_NUMBER_RCV_URBS 1
#define UDSL_RECEIVE_BUFFER_SIZE 64*53
#define UDSL_MAX_AAL5_MRU 2048 /* max should be (1500 IP mtu + 2 ppp bytes + 32 * 5 cellheader overhead) for PPPoA and (1500 + 14 + 32*5 cellheader overhead) for PPPoE */
#define UDSL_SEND_CONTEXTS 8

#define UDSL_IOCTL_START 1
#define UDSL_IOCTL_STOP 2

/* endpoint declarations */

#define UDSL_ENDPOINT_DATA_OUT 0x7
#define UDSL_ENDPOINT_DATA_IN 0x87

/* usb_device_id struct */

static struct usb_device_id udsl_usb_ids [] =
{
{ USB_DEVICE (SPEEDTOUCH_VENDORID, SPEEDTOUCH_PRODUCTID) },
{ } /* list terminator */
};

/* not exporting this prevents the depmod from generating the map that causes the modules to be isnserted as driver.
* we do not want this, we want the script run.
MODULE_DEVICE_TABLE ( usb, udsl_usb_ids);
*/
/* context declarations */

typedef struct udsl_data_ctx {
struct sk_buff *skb;
urb_t *urb;
struct udsl_instance_data *instance;
} udsl_data_ctx_t;

typedef struct udsl_usb_send_data_context {
urb_t urb;
struct sk_buff *skb;
struct atm_vcc *vcc;
} udsl_usb_send_data_context_t;

/*
* UDSL main driver data
*/

struct udsl_instance_data {
int minor;

/* usb device part */
struct usb_device *usb_dev;
udsl_data_ctx_t *rcvbufs;
struct sk_buff_head skb_queue;
udsl_usb_send_data_context_t send_ctx;
int data_started;

/* atm device part */
struct atm_dev *atm_dev;
struct sk_buff_head recvqueue;
struct sarlib_vcc_data *sarlib_vcc_list;
};

struct udsl_instance_data *minor_data[MAX_UDSL];

static const char udsl_driver_name[] = "Alcatel SpeedTouch USB";

/* data thread */
static int datapid = 0;
DECLARE_WAIT_QUEUE_HEAD(udsl_wqh);

#ifdef DEBUG_PACKET
int udsl_print_packet (const unsigned char *data, int len);
#endif

/*
* atm driver prototypes and stuctures
*/

static int udsl_atm_open(struct atm_vcc *vcc, short vpi, int vci);
static void udsl_atm_close(struct atm_vcc *vcc);
static int udsl_atm_ioctl(struct atm_dev *dev, unsigned int cmd, void *arg);
static int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb);
int udsl_atm_proc_read (struct atm_dev * atm_dev, loff_t * pos, char * page);
void udsl_atm_processqueue ( struct udsl_instance_data *instance);

static struct atmdev_ops udsl_atm_devops =
{
open: udsl_atm_open,
close: udsl_atm_close,
ioctl: udsl_atm_ioctl,
send: udsl_atm_send,
proc_read: udsl_atm_proc_read,
};

typedef struct udsl_atm_dev_data {
struct sarlib_vcc_data *sarlib_vcc;
} udsl_atm_dev_data_t;

/*
* usb driver prototypes and structures
*/
static void * udsl_usb_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id);
static void udsl_usb_disconnect(struct usb_device *dev, void *ptr);
int udsl_usb_send_data (struct udsl_instance_data *instance, struct atm_vcc *vcc, struct sk_buff *skb);
static int udsl_usb_ioctl (struct usb_device *hub, unsigned int code, void *user_data);

static struct usb_driver udsl_usb_driver =
{
name: udsl_driver_name,
probe: udsl_usb_probe,
disconnect: udsl_usb_disconnect,
ioctl: udsl_usb_ioctl,
id_table: udsl_usb_ids,
};

/************
** ATM **
************/

/************************************************************************** *
*
* init functions
*
*************************************************************************** */

struct atm_dev *udsl_atm_startdevice(struct udsl_instance_data *instance, struct atmdev_ops *devops) {
MOD_INC_USE_COUNT;

instance->atm_dev = atm_dev_register(udsl_driver_name, devops, -1, 0);
instance->atm_dev->dev_data = instance;
instance->atm_dev->ci_range.vpi_bits = ATM_CI_MAX;
instance->atm_dev->ci_range.vci_bits = ATM_CI_MAX;
instance->atm_dev->signal = ATM_PHY_SIG_LOST;

skb_queue_head_init(&instance->recvqueue);

/* tmp init atm device, set to 128kbit */
instance->atm_dev->link_rate = 128*1000/424;

return instance->atm_dev;
}

void udsl_atm_stopdevice(struct udsl_instance_data *instance) {
struct atm_vcc *walk;
struct sk_buff *skb;
struct atm_dev *atm_dev;

if (!instance->atm_dev)
return;

atm_dev = instance->atm_dev;

/* clean queue */
while (!skb_queue_empty(&instance->recvqueue)) {
skb = skb_dequeue (&instance->recvqueue);
dev_kfree_skb(skb);
};

atm_dev->signal = ATM_PHY_SIG_LOST;
walk = atm_dev->vccs;
shutdown_atm_dev(atm_dev);

for (; walk; walk = walk->next)
wake_up(&walk->sleep);

MOD_DEC_USE_COUNT;
}

void udsl_atm_set_mac(struct udsl_instance_data *instance, const char mac[6]) {
if (!instance->atm_dev)
return;

memcpy (instance->atm_dev->esi, mac, 6);
}

/************************************************************************** *
*
* ATM helper functions
*
*************************************************************************** */
struct sk_buff * udsl_atm_alloc_tx(struct atm_vcc *vcc,unsigned int size) {
sarlib_vcc_data_t *sarlib_vcc = ((struct udsl_atm_dev_data *)vcc->dev_data)->sarlib_vcc;

if (sarlib_vcc)
return sarlib_alloc_tx(sarlib_vcc, size);

printk(KERN_INFO "SpeedTouch USB: udsl_atm_alloc_tx could not find correct alloc_tx function !\n");
return NULL;
}

int udsl_atm_proc_read (struct atm_dev * atm_dev, loff_t * pos, char * page) {
struct udsl_instance_data *instance = (struct udsl_instance_data *) atm_dev->dev_data;
int left = *pos;

if (!left--)
return sprintf(page, "Speed Touch USB:%d (%02x:%02x:%02x:%02x:%02x:%02x)\n", instance->minor,
atm_dev->esi[0], atm_dev->esi[1], atm_dev->esi[2], atm_dev->esi[3], atm_dev->esi[4], atm_dev->esi[5]);

if (!left--)
return sprintf(page, "AAL0: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
atomic_read(&atm_dev->stats.aal0.tx), atomic_read(&atm_dev->stats.aal0.tx_err),
atomic_read(&atm_dev->stats.aal0.rx), atomic_read(&atm_dev->stats.aal0.rx_err), atomic_read(&atm_dev->stats.aal0.rx_drop));

if (!left--)
return sprintf(page, "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
atomic_read(&atm_dev->stats.aal5.tx), atomic_read(&atm_dev->stats.aal5.tx_err),
atomic_read(&atm_dev->stats.aal5.rx), atomic_read(&atm_dev->stats.aal5.rx_err), atomic_read(&atm_dev->stats.aal5.rx_drop));

return 0;
}

/************************************************************************** *
*
* ATM DATA functions
*
*************************************************************************** */
int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb) {
struct udsl_atm_dev_data *dev_data = (struct udsl_atm_dev_data *) vcc->dev_data;
struct udsl_instance_data *instance = (struct udsl_instance_data *) vcc->dev->dev_data;
struct sk_buff *new = NULL;
int err;

PDEBUG("udsl_atm_send called\n");

if (!dev_data)
return -EINVAL;

switch (vcc->qos.aal) {
case ATM_AAL5:
new = sarlib_encode_aal5(dev_data->sarlib_vcc, skb);
if (!new) return -ENOMEM;
if (new != skb) {
vcc->pop(vcc, skb);
skb = new;
}
new = sarlib_encode_rawcell(dev_data->sarlib_vcc, skb);
if (!new) return -ENOMEM;
if (new != skb) {
vcc->pop(vcc, skb);
skb = new;
}
err = udsl_usb_send_data (instance, vcc, skb);
PDEBUG("udsl_atm_send successfull (%d)\n", err);
return err;
break;
default:
return -EINVAL;
};

PDEBUG("udsl_atm_send unsuccessfull\n");
return 0;
};

void udsl_atm_processqueue ( struct udsl_instance_data *instance) {
struct sarlib_vcc_data *sarlib_vcc = NULL;
struct sk_buff *new = NULL, *skb = NULL;

/* quick check */
if (skb_queue_empty(&instance->recvqueue))
return;

PDEBUG("udsl_atm_processqueue entered\n");

while (!skb_queue_empty(&instance->recvqueue)) {
skb = skb_dequeue (&instance->recvqueue);
PDEBUG("skb = %p, skb->len = %d\n", skb, skb->len);

PACKETDEBUG (skb->data, skb->len);

while ( (new = sarlib_decode_rawcell (instance->sarlib_vcc_list, skb, &sarlib_vcc)) != NULL) {
PDEBUG("(after cell processing)skb->len = %d\n", new->len);
switch (sarlib_vcc->type) {
case SARLIB_TYPE_AAL5:
new = sarlib_decode_aal5 (sarlib_vcc, new);

/* we can't send NULL skbs upstream, the ATM layer would try to close the vcc... */
if (new) {
PDEBUG("(after aal5 decap) skb->len = %d\n", new->len);
if (new->len && atm_charge(sarlib_vcc->vcc, new->truesize)) {
PACKETDEBUG (new->data, new->len);
sarlib_vcc->vcc->push(sarlib_vcc->vcc, new);
}
else {
PDEBUG("dropping incoming packet : rx_inuse = %d, vcc->sk->rcvbuf = %d, skb->true_size = %d\n", atomic_read(&sarlib_vcc->vcc->rx_inuse), sarlib_vcc->vcc->sk->rcvbuf, new->truesize);
dev_kfree_skb(new);
}
}
else
PDEBUG("sarlib_decode_aal5 returned NULL!\n");
break;
default:
/* not supported. we delete the skb. */
printk(KERN_INFO "SpeedTouch USB: illegal vcc type. Dropping packet.\n");
dev_kfree_skb(new);
break;
}
};
dev_kfree_skb (skb);
};
PDEBUG("udsl_atm_processqueue successfull\n");
}

int udsl_atm_processqueue_thread (void *data) {
int i=0;
DECLARE_WAITQUEUE(wait, current);

lock_kernel();
exit_files(current); /* daemonize doesn't do exit_files */
daemonize();

/* Setup a nice name */
strcpy(current->comm, "kSpeedSARd");

add_wait_queue(&udsl_wqh, &wait);

for(;descriptor.idProduct, ifnum);

if ((dev->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC)||
(dev->descriptor.idVendor != SPEEDTOUCH_VENDORID)||
(dev->descriptor.idProduct != SPEEDTOUCH_PRODUCTID)||
(ifnum!=1))
return NULL;

MOD_INC_USE_COUNT;

for (i=0; i < MAX_UDSL; i++)
if (minor_data == NULL)
break;

if (i >= MAX_UDSL) {
printk(KERN_INFO "No minor table space available for SpeedTouch USB\n");
return NULL;
};

PDEBUG("Device Accepted, assigning minor %d\n", i);

/* device init */
instance = kmalloc(sizeof(struct udsl_instance_data), GFP_KERNEL);
if (!instance) {
PDEBUG("No memory for Instance data!\n");
return NULL;
}

/* initialize structure */
memset(instance, 0, sizeof(struct udsl_instance_data));
instance->minor = i;
instance->usb_dev = dev;
instance->rcvbufs = NULL;

udsl_atm_startdevice(instance, &udsl_atm_devops);

/* set MAC address, it is stored in the serial number */
usb_string(instance->usb_dev, instance->usb_dev->descriptor.iSerialNumber, mac_str, 13);
for (i=0; i<6; i++)
mac = (hex2int(mac_str[i*2])*16) + (hex2int(mac_str[i*2+1]));

PDEBUG("MAC is %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
udsl_atm_set_mac(instance, mac);

minor_data[instance->minor] = instance;

return instance;
}

void udsl_usb_disconnect(struct usb_device *dev, void *ptr)
{
struct udsl_instance_data *instance = (struct udsl_instance_data *)ptr;
int i = instance->minor;

/* unlinking receive buffers */
udsl_usb_data_exit(instance);

/* removing atm device */
if (instance->atm_dev)
udsl_atm_stopdevice(instance);

PDEBUG("disconnecting minor %d\n", i);

while (MOD_IN_USE > 1) {
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(1);
}

kfree (instance);
minor_data = NULL;

MOD_DEC_USE_COUNT;
}

/************************************************************************** *
*
* Driver Init
*
*************************************************************************** */

int udsl_usb_init(void)
{
int i;

PDEBUG ("Initializing driver\n");

for (i =0; i < MAX_UDSL ; i++)
minor_data = NULL;

init_waitqueue_head(&udsl_wqh);
udsl_atm_sar_start();

return usb_register(&udsl_usb_driver);
}

int udsl_usb_cleanup(void)
{
/* killing threads */
udsl_atm_sar_stop();

usb_deregister(&udsl_usb_driver);
return 0;
}

#ifdef MODULE
int init_module(void)
{
return udsl_usb_init();
}

int cleanup_module(void)
{
return udsl_usb_cleanup();
}
#endif

#ifdef DEBUG_PACKET
/************************************************************************** *****
*
* Debug
*
*************************************************************************** ****/

int udsl_print_packet (const unsigned char *data, int len) {
unsigned char buffer[256];
int i=0, j=0;

for (i = 0; i < len ; ) {
buffer[0] = '\0';
sprintf(buffer,"%.3d :", i);
for (j = 0; (j < 16) && (i< len) ; j++, i++) {
sprintf(buffer, "%s %2.2x", buffer, data);
}
PDEBUG("%s\n", buffer);
}
return i;
};

#endif /* PACKETDEBUG */

Amigos, decididamente he pasado a engrosar el mundo de Linux, instal@¡ndome el SuSE 9.0, que por el momento y dentro de mi escao conocimiento, me ha parecido magnífico. El instalador es sensacional, nada que ver con las antiguas versiones. El único problema que tengo y que por los foros de linux, veo que ese problema es compartido por un gran número de usuarios linux, es que tengo un módem ADSL USB Vitelcom, que no funciona bajo esa plataforma. Llamé a Telefónica, que es la que distribuye esos módems y me dijeron que su empresa solo trabaja con Windows y que no puede hacer nada. Buscando por inet hallé en http://www.speedtouchdsl.com/dvrreg_lx.htm y en http://bulmalug.net/body.phtml?nIdNoticia=1224 un código fuente, al parecer, para que ese módem funcione con linux. Yo ignoro si el Linux dispone de un compilador, pero tampoco sabría hacerlo servir. En http://adslinux.iespana.es/adslinux/ hay un driver, pero el link no funciona.
¿Podrian Vds. hacer algo al respecto, en beneficio de la comunidad?. El resultado, si lo hay, lo transmitiré a todos los foros a los que estoy suscrito.
Gracias

PD-El código fuente no lo puedo insertar en éste mensaje, dado que es muy grande.

Dios santo, a saber si ésto funciona. Deberías darle a algún programador para que lo mire con lupa y lo compile.
--
. Corellian Engineering Corporation .