URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/rtos/ecos-2.0/packages/io/usb/eth/slave/v2_0/host
- from Rev 27 to Rev 174
- ↔ Reverse comparison
Rev 27 → Rev 174
/ecos_usbeth.c
0,0 → 1,572
//========================================================================== |
// |
// ecos_usbeth.c |
// |
// Linux device driver for eCos-based USB ethernet peripherals. |
// |
//========================================================================== |
//####ECOSGPLCOPYRIGHTBEGIN#### |
// ------------------------------------------- |
// This file is part of eCos, the Embedded Configurable Operating System. |
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
// |
// eCos is free software; you can redistribute it and/or modify it under |
// the terms of the GNU General Public License as published by the Free |
// Software Foundation; either version 2 or (at your option) any later version. |
// |
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
// WARRANTY; without even the implied warranty of MERCHANTABILITY or |
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
// for more details. |
// |
// You should have received a copy of the GNU General Public License along |
// with eCos; if not, write to the Free Software Foundation, Inc., |
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
// |
// As a special exception, if other files instantiate templates or use macros |
// or inline functions from this file, or you compile this file and link it |
// with other works to produce a work based on this file, this file does not |
// by itself cause the resulting work to be covered by the GNU General Public |
// License. However the source code for this file must still be made available |
// in accordance with section (3) of the GNU General Public License. |
// |
// This exception does not invalidate any other reasons why a work based on |
// this file might be covered by the GNU General Public License. |
// |
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
// at http://sources.redhat.com/ecos/ecos-license/ |
// ------------------------------------------- |
//####ECOSGPLCOPYRIGHTEND#### |
//========================================================================== |
//#####DESCRIPTIONBEGIN#### |
// |
// Author(s): bartv |
// Contributors: bartv |
// Date: 2000-11-12 |
// |
//####DESCRIPTIONEND#### |
//========================================================================== |
|
#include <linux/module.h> |
#include <linux/init.h> |
#include <linux/usb.h> |
#include <linux/netdevice.h> |
#include <linux/etherdevice.h> |
|
#ifdef MODULE |
MODULE_AUTHOR("Bart Veer <bartv@redhat.com>"); |
MODULE_DESCRIPTION("USB ethernet driver for eCos-based peripherals"); |
#endif |
|
// This array identifies specific implementations of eCos USB-ethernet |
// devices. All implementations should add their vendor and device |
// details. |
|
typedef struct ecos_usbeth_impl { |
const char* name; |
__u16 vendor; |
__u16 id; |
} ecos_usbeth_impl; |
|
const static ecos_usbeth_impl ecos_usbeth_implementations[] = { |
{ "eCos ether", 0x4242, 0x4242 }, |
{ (const char*) 0, 0, 0 } |
}; |
|
|
// Constants. These have to be kept in sync with the target-side |
// code. |
#define ECOS_USBETH_MAXTU 1516 |
#define ECOS_USBETH_MAX_CONTROL_TU 8 |
#define ECOS_USBETH_CONTROL_GET_MAC_ADDRESS 0x01 |
#define ECOS_USBETH_CONTROL_SET_PROMISCUOUS_MODE 0x02 |
|
// The main data structure. It keeps track of both the USB |
// and network side of things, and provides buffers for |
// the various operations. |
// |
// NOTE: currently this driver only supports a single |
// plugged-in device. Theoretically multiple eCos-based |
// USB ethernet devices could be plugged in to a single |
// host and each one would require an ecos_usbeth |
// structure. |
typedef struct ecos_usbeth { |
spinlock_t usb_lock; |
int target_promiscuous; |
struct usb_device* usb_dev; |
struct net_device* net_dev; |
struct net_device_stats stats; |
struct urb rx_urb; |
struct urb tx_urb; |
unsigned char rx_buffer[ECOS_USBETH_MAXTU]; |
unsigned char tx_buffer[ECOS_USBETH_MAXTU]; |
} ecos_usbeth; |
|
|
// open() |
// Invoked by the TCP/IP stack when the interface is brought up. |
// This just starts a receive operation. |
static int |
ecos_usbeth_open(struct net_device* net) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) net->priv; |
int res; |
|
netif_start_queue(net); |
res = usb_submit_urb(&(usbeth->rx_urb)); |
if (0 != res) { |
printk("ecos_usbeth: failed to start USB receives, %d\n", res); |
} |
MOD_INC_USE_COUNT; |
return 0; |
} |
|
// close() |
// Invoked by the TCP/IP stack when the interface is taken down. |
// Any active USB operations need to be cancelled. During |
// a disconnect this may get called twice, once for the |
// disconnect and once for the network interface being |
// brought down. |
static int |
ecos_usbeth_close(struct net_device* net) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) net->priv; |
|
if (0 != netif_running(net)) { |
netif_stop_queue(net); |
net->start = 0; |
|
if (-EINPROGRESS == usbeth->rx_urb.status) { |
usb_unlink_urb(&(usbeth->rx_urb)); |
} |
if (-EINPROGRESS == usbeth->tx_urb.status) { |
usb_unlink_urb(&(usbeth->tx_urb)); |
} |
MOD_DEC_USE_COUNT; |
} |
|
return 0; |
} |
|
// Reception. |
// probe() fills in an rx_urb. When the net device is brought up |
// the urb is activated, and this callback gets run for incoming |
// data. |
static void |
ecos_usbeth_rx_callback(struct urb* urb) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) urb->context; |
struct net_device* net = usbeth->net_dev; |
struct sk_buff* skb; |
int len; |
int res; |
|
if (0 != urb->status) { |
// This happens numerous times during a disconnect. Do not |
// issue a warning, but do clear the status field or things |
// get confused when resubmitting. |
// |
// Some host hardware does not distinguish between CRC errors |
// (very rare) and timeouts (perfectly normal). Do not |
// increment the error count if it might have been a timeout. |
if (USB_ST_CRC != urb->status) { |
usbeth->stats.rx_errors++; |
} |
urb->status = 0; |
} else if (2 > urb->actual_length) { |
// With some hardware the target may have to send a bogus |
// first packet. Just ignore those. |
|
} else { |
len = usbeth->rx_buffer[0] + (usbeth->rx_buffer[1] << 8); |
if (len > (urb->actual_length - 2)) { |
usbeth->stats.rx_errors++; |
usbeth->stats.rx_length_errors++; |
printk("ecos_usbeth: warning, packet size mismatch, got %d bytes, expected %d\n", |
urb->actual_length, len); |
} else { |
skb = dev_alloc_skb(len + 2); |
if ((struct sk_buff*)0 == skb) { |
printk("ecos_usbeth: failed to alloc skb, dropping packet\n"); |
usbeth->stats.rx_dropped++; |
} else { |
#if 0 |
{ |
int i; |
printk("--------------------------------------------------------------\n"); |
printk("ecos_usbeth RX: total size %d\n", len); |
for (i = 0; (i < len) && (i < 128); i+= 8) { |
printk("rx %x %x %x %x %x %x %x %x\n", |
usbeth->rx_buffer[i+0], usbeth->rx_buffer[i+1], usbeth->rx_buffer[i+2], usbeth->rx_buffer[i+3], |
usbeth->rx_buffer[i+4], usbeth->rx_buffer[i+5], usbeth->rx_buffer[i+6], usbeth->rx_buffer[i+7]); |
} |
printk("--------------------------------------------------------------\n"); |
} |
#endif |
skb->dev = net; |
eth_copy_and_sum(skb, &(usbeth->rx_buffer[2]), len, 0); |
skb_put(skb, len); |
skb->protocol = eth_type_trans(skb, net); |
netif_rx(skb); |
usbeth->stats.rx_packets++; |
usbeth->stats.rx_bytes += len; |
} |
} |
} |
|
if (0 != netif_running(net)) { |
res = usb_submit_urb(&(usbeth->rx_urb)); |
if (0 != res) { |
printk("ecos_usbeth: failed to restart USB receives after packet, %d\n", res); |
} |
} |
} |
|
// start_tx(). |
// Transmit a single packet. The relevant USB protocol requires a |
// 2-byte length field at the start, the incoming buffer has no space |
// for this, and the URB API does not support any form of |
// scatter/gather. Therefore unfortunately the whole packet has to be |
// copied. The callback function is specified when the URB is filled |
// in by probe(). |
static void |
ecos_usbeth_tx_callback(struct urb* urb) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) urb->context; |
spin_lock(&usbeth->usb_lock); |
if (0 != netif_running(usbeth->net_dev)) { |
netif_wake_queue(usbeth->net_dev); |
} |
spin_unlock(&usbeth->usb_lock); |
} |
|
static int |
ecos_usbeth_start_tx(struct sk_buff* skb, struct net_device* net) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) net->priv; |
int res; |
|
if ((skb->len + 2) > ECOS_USBETH_MAXTU) { |
printk("ecos_usbeth: oversized packet of %d bytes\n", skb->len); |
return 0; |
} |
|
if (netif_queue_stopped(net)) { |
// Another transmission already in progress. |
// USB bulk operations should complete within 5s. |
int current_delay = jiffies - net->trans_start; |
if (current_delay < (5 * HZ)) { |
return 1; |
} else { |
// There has been a timeout. Discard this message. |
//printk("transmission timed out\n"); |
usbeth->stats.tx_errors++; |
dev_kfree_skb(skb); |
return 0; |
} |
} |
|
spin_lock(&usbeth->usb_lock); |
usbeth->tx_buffer[0] = skb->len & 0x00FF; |
usbeth->tx_buffer[1] = (skb->len >> 8) & 0x00FF; |
memcpy(&(usbeth->tx_buffer[2]), skb->data, skb->len); |
usbeth->tx_urb.transfer_buffer_length = skb->len + 2; |
|
// Some targets are unhappy about receiving 0-length packets, not |
// just sending them. |
if (0 == (usbeth->tx_urb.transfer_buffer_length % 64)) { |
usbeth->tx_urb.transfer_buffer_length++; |
} |
#if 0 |
{ |
int i; |
printk("--------------------------------------------------------------\n"); |
printk("ecos_usbeth start_tx: len %d\n", skb->len + 2); |
for (i = 0; (i < (skb->len + 2)) && (i < 128); i+= 8) { |
printk("tx %x %x %x %x %x %x %x %x\n", |
usbeth->tx_buffer[i], usbeth->tx_buffer[i+1], usbeth->tx_buffer[i+2], usbeth->tx_buffer[i+3], |
usbeth->tx_buffer[i+4], usbeth->tx_buffer[i+5], usbeth->tx_buffer[i+6], usbeth->tx_buffer[i+7]); |
} |
printk("--------------------------------------------------------------\n"); |
} |
#endif |
res = usb_submit_urb(&(usbeth->tx_urb)); |
if (0 == res) { |
netif_stop_queue(net); |
net->trans_start = jiffies; |
usbeth->stats.tx_packets++; |
usbeth->stats.tx_bytes += skb->len; |
} else { |
printk("ecos_usbeth: failed to start USB packet transmission, %d\n", res); |
usbeth->stats.tx_errors++; |
} |
|
spin_unlock(&usbeth->usb_lock); |
dev_kfree_skb(skb); |
return 0; |
} |
|
|
// set_rx_mode() |
// Invoked by the network stack to enable/disable promiscuous mode or |
// for multicasting. The latter is not yet supported on the target |
// side. The former involves a USB control message. The main call |
// is not allowed to block. |
static void |
ecos_usbeth_set_rx_mode_callback(struct urb* urb) |
{ |
kfree(urb->setup_packet); |
usb_free_urb(urb); |
} |
|
static void |
ecos_usbeth_set_rx_mode(struct net_device* net) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) net->priv; |
__u16 promiscuous = net->flags & IFF_PROMISC; |
int res; |
|
if (promiscuous != usbeth->target_promiscuous) { |
devrequest* req; |
urb_t* urb; |
|
urb = usb_alloc_urb(0); |
if ((urb_t*)0 == urb) { |
return; |
} |
req = kmalloc(sizeof(devrequest), GFP_KERNEL); |
if ((devrequest*)0 == req) { |
usb_free_urb(urb); |
return; |
} |
req->requesttype = USB_TYPE_CLASS | USB_RECIP_DEVICE; |
req->request = ECOS_USBETH_CONTROL_SET_PROMISCUOUS_MODE; |
req->value = cpu_to_le16p(&promiscuous); |
req->index = 0; |
req->length = 0; |
|
FILL_CONTROL_URB(urb, |
usbeth->usb_dev, |
usb_sndctrlpipe(usbeth->usb_dev, 0), |
(unsigned char*) req, |
(void*) 0, |
0, |
&ecos_usbeth_set_rx_mode_callback, |
(void*) usbeth); |
res = usb_submit_urb(urb); |
if (0 != res) { |
kfree(req); |
usb_free_urb(urb); |
} else { |
usbeth->target_promiscuous = promiscuous; |
} |
} |
} |
|
// netdev_stats() |
// Supply the current network statistics. These are held in |
// the stats field of the ecos_usbeth structure |
static struct net_device_stats* |
ecos_usbeth_netdev_stats(struct net_device* net) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) net->priv; |
return &(usbeth->stats); |
} |
|
// ioctl() |
// Currently none of the network ioctl()'s are supported |
static int |
ecos_usbeth_ioctl(struct net_device* net, struct ifreq* request, int command) |
{ |
return -EINVAL; |
} |
|
// probe(). |
// This is invoked by the generic USB code when a new device has |
// been detected and its configuration details have been extracted |
// and stored in the usbdev structure. The interface_id specifies |
// a specific USB interface, to cope with multifunction peripherals. |
// |
// FIXME; right now this code only copes with simple enumeration data. |
// OK, to be really honest it just looks for the vendor and device ids |
// in the simple test cases and ignores everything else. |
// |
// On success it should return a non-NULL pointer, which happens to be |
// a newly allocated ecos_usbeth structure. This will get passed to |
// the disconnect function. Filling in the ecos_usbeth structure will, |
// amongst other things, register this as a network device driver. |
// The MAC address is obtained from the peripheral via a control |
// request. |
|
static void* |
ecos_usbeth_probe(struct usb_device* usbdev, unsigned int interface_id) |
{ |
struct net_device* net; |
ecos_usbeth* usbeth; |
int res; |
unsigned char MAC[6]; |
unsigned char dummy[1]; |
int tx_endpoint = -1; |
int rx_endpoint = -1; |
const ecos_usbeth_impl* impl; |
int found_impl = 0; |
|
// See if this is the correct driver for this USB peripheral. |
impl = ecos_usbeth_implementations; |
while (impl->name != NULL) { |
if ((usbdev->descriptor.idVendor != impl->vendor) || |
(usbdev->descriptor.idProduct != impl->id)) { |
found_impl = 1; |
break; |
} |
impl++; |
} |
if (! found_impl) { |
return (void*) 0; |
} |
|
// For now only support USB-ethernet peripherals consisting of a single |
// configuration, with a single interface, with two bulk endpoints. |
if ((1 != usbdev->descriptor.bNumConfigurations) || |
(1 != usbdev->config[0].bNumInterfaces) || |
(2 != usbdev->config[0].interface[0].altsetting->bNumEndpoints)) { |
return (void*) 0; |
} |
if ((0 == (usbdev->config[0].interface[0].altsetting->endpoint[0].bEndpointAddress & USB_DIR_IN)) && |
(0 != (usbdev->config[0].interface[0].altsetting->endpoint[1].bEndpointAddress & USB_DIR_IN))) { |
tx_endpoint = usbdev->config[0].interface[0].altsetting->endpoint[0].bEndpointAddress; |
rx_endpoint = usbdev->config[0].interface[0].altsetting->endpoint[1].bEndpointAddress & ~USB_DIR_IN; |
} |
if ((0 != (usbdev->config[0].interface[0].altsetting->endpoint[0].bEndpointAddress & USB_DIR_IN)) && |
(0 == (usbdev->config[0].interface[0].altsetting->endpoint[1].bEndpointAddress & USB_DIR_IN))) { |
tx_endpoint = usbdev->config[0].interface[0].altsetting->endpoint[1].bEndpointAddress; |
rx_endpoint = usbdev->config[0].interface[0].altsetting->endpoint[0].bEndpointAddress & ~USB_DIR_IN; |
} |
if (-1 == tx_endpoint) { |
return (void*) 0; |
} |
|
res = usb_set_configuration(usbdev, usbdev->config[0].bConfigurationValue); |
if (0 != res) { |
printk("ecos_usbeth: failed to set configuration, %d\n", res); |
return (void*) 0; |
} |
res = usb_control_msg(usbdev, |
usb_rcvctrlpipe(usbdev, 0), |
ECOS_USBETH_CONTROL_GET_MAC_ADDRESS, |
USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, |
0, |
0, |
(void*) MAC, |
6, |
5 * HZ); |
if (6 != res) { |
printk("ecos_usbeth: failed to get MAC address, %d\n", res); |
return (void*) 0; |
} |
|
res = usb_control_msg(usbdev, |
usb_sndctrlpipe(usbdev, 0), // pipe |
ECOS_USBETH_CONTROL_SET_PROMISCUOUS_MODE, // request |
USB_TYPE_CLASS | USB_RECIP_DEVICE, // requesttype |
0, // value |
0, // index |
(void*) dummy, // data |
0, // size |
5 * HZ); // timeout |
if (0 != res) { |
printk("ecos_usbeth: failed to disable promiscous mode, %d\n", res); |
} |
|
usbeth = (ecos_usbeth*) kmalloc(sizeof(ecos_usbeth), GFP_KERNEL); |
if ((ecos_usbeth*)0 == usbeth) { |
printk("ecos_usbeth: failed to allocate memory for usbeth data structure\n"); |
return (void*) 0; |
} |
memset(usbeth, 0, sizeof(ecos_usbeth)); |
|
net = init_etherdev(0, 0); |
if ((struct net_device*) 0 == net) { |
kfree(usbeth); |
printk("ecos_usbeth: failed to allocate memory for net data structure\n"); |
return (void*) 0; |
} |
|
usbeth->usb_lock = SPIN_LOCK_UNLOCKED; |
usbeth->usb_dev = usbdev; |
FILL_BULK_URB(&(usbeth->tx_urb), usbdev, usb_sndbulkpipe(usbdev, tx_endpoint), |
usbeth->tx_buffer, ECOS_USBETH_MAXTU, &ecos_usbeth_tx_callback, (void*) usbeth); |
FILL_BULK_URB(&(usbeth->rx_urb), usbdev, usb_rcvbulkpipe(usbdev, rx_endpoint), |
usbeth->rx_buffer, ECOS_USBETH_MAXTU, &ecos_usbeth_rx_callback, (void*) usbeth); |
|
usbeth->net_dev = net; |
usbeth->target_promiscuous = 0; |
|
net->priv = (void*) usbeth; |
net->open = &ecos_usbeth_open; |
net->stop = &ecos_usbeth_close; |
net->do_ioctl = &ecos_usbeth_ioctl; |
net->hard_start_xmit = &ecos_usbeth_start_tx; |
net->set_multicast_list = &ecos_usbeth_set_rx_mode; |
net->get_stats = &ecos_usbeth_netdev_stats; |
net->mtu = 1500; // ECOS_USBETH_MAXTU - 2; |
memcpy(net->dev_addr, MAC, 6); |
|
printk("eCos-based USB ethernet peripheral active at %s\n", net->name); |
MOD_INC_USE_COUNT; |
return (void*) usbeth; |
} |
|
// disconnect(). |
// Invoked after probe() has recognized a device but that device |
// has gone away. |
static void |
ecos_usbeth_disconnect(struct usb_device* usbdev, void* data) |
{ |
ecos_usbeth* usbeth = (ecos_usbeth*) data; |
if (!usbeth) { |
printk("ecos_usbeth: warning, disconnecting unconnected device\n"); |
return; |
} |
if (0 != netif_running(usbeth->net_dev)) { |
ecos_usbeth_close(usbeth->net_dev); |
} |
unregister_netdev(usbeth->net_dev); |
if (-EINPROGRESS == usbeth->rx_urb.status) { |
usb_unlink_urb(&(usbeth->rx_urb)); |
} |
if (-EINPROGRESS == usbeth->tx_urb.status) { |
usb_unlink_urb(&(usbeth->tx_urb)); |
} |
kfree(usbeth); |
MOD_DEC_USE_COUNT; |
} |
|
static struct usb_driver ecos_usbeth_driver = { |
name: "ecos_usbeth", |
probe: ecos_usbeth_probe, |
disconnect: ecos_usbeth_disconnect, |
}; |
|
// init() |
// Called when the module is loaded. It just registers the device with |
// the generic USB code. Nothing else can really be done until |
// the USB code detects that a device has been attached. |
int __init |
ecos_usbeth_init(void) |
{ |
printk("eCos USB-ethernet device driver\n"); |
return usb_register(&ecos_usbeth_driver); |
} |
|
// exit() |
// Called when the module is unloaded. disconnect() will be |
// invoked if appropriate. |
void __exit |
ecos_usbeth_exit(void) |
{ |
usb_deregister(&ecos_usbeth_driver); |
} |
|
module_init(ecos_usbeth_init); |
module_exit(ecos_usbeth_exit); |
/COPYING
0,0 → 1,340
GNU GENERAL PUBLIC LICENSE |
Version 2, June 1991 |
|
Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Everyone is permitted to copy and distribute verbatim copies |
of this license document, but changing it is not allowed. |
|
Preamble |
|
The licenses for most software are designed to take away your |
freedom to share and change it. By contrast, the GNU General Public |
License is intended to guarantee your freedom to share and change free |
software--to make sure the software is free for all its users. This |
General Public License applies to most of the Free Software |
Foundation's software and to any other program whose authors commit to |
using it. (Some other Free Software Foundation software is covered by |
the GNU Library General Public License instead.) You can apply it to |
your programs, too. |
|
When we speak of free software, we are referring to freedom, not |
price. Our General Public Licenses are designed to make sure that you |
have the freedom to distribute copies of free software (and charge for |
this service if you wish), that you receive source code or can get it |
if you want it, that you can change the software or use pieces of it |
in new free programs; and that you know you can do these things. |
|
To protect your rights, we need to make restrictions that forbid |
anyone to deny you these rights or to ask you to surrender the rights. |
These restrictions translate to certain responsibilities for you if you |
distribute copies of the software, or if you modify it. |
|
For example, if you distribute copies of such a program, whether |
gratis or for a fee, you must give the recipients all the rights that |
you have. You must make sure that they, too, receive or can get the |
source code. And you must show them these terms so they know their |
rights. |
|
We protect your rights with two steps: (1) copyright the software, and |
(2) offer you this license which gives you legal permission to copy, |
distribute and/or modify the software. |
|
Also, for each author's protection and ours, we want to make certain |
that everyone understands that there is no warranty for this free |
software. If the software is modified by someone else and passed on, we |
want its recipients to know that what they have is not the original, so |
that any problems introduced by others will not reflect on the original |
authors' reputations. |
|
Finally, any free program is threatened constantly by software |
patents. We wish to avoid the danger that redistributors of a free |
program will individually obtain patent licenses, in effect making the |
program proprietary. To prevent this, we have made it clear that any |
patent must be licensed for everyone's free use or not licensed at all. |
|
The precise terms and conditions for copying, distribution and |
modification follow. |
|
GNU GENERAL PUBLIC LICENSE |
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
|
0. This License applies to any program or other work which contains |
a notice placed by the copyright holder saying it may be distributed |
under the terms of this General Public License. The "Program", below, |
refers to any such program or work, and a "work based on the Program" |
means either the Program or any derivative work under copyright law: |
that is to say, a work containing the Program or a portion of it, |
either verbatim or with modifications and/or translated into another |
language. (Hereinafter, translation is included without limitation in |
the term "modification".) Each licensee is addressed as "you". |
|
Activities other than copying, distribution and modification are not |
covered by this License; they are outside its scope. The act of |
running the Program is not restricted, and the output from the Program |
is covered only if its contents constitute a work based on the |
Program (independent of having been made by running the Program). |
Whether that is true depends on what the Program does. |
|
1. You may copy and distribute verbatim copies of the Program's |
source code as you receive it, in any medium, provided that you |
conspicuously and appropriately publish on each copy an appropriate |
copyright notice and disclaimer of warranty; keep intact all the |
notices that refer to this License and to the absence of any warranty; |
and give any other recipients of the Program a copy of this License |
along with the Program. |
|
You may charge a fee for the physical act of transferring a copy, and |
you may at your option offer warranty protection in exchange for a fee. |
|
2. You may modify your copy or copies of the Program or any portion |
of it, thus forming a work based on the Program, and copy and |
distribute such modifications or work under the terms of Section 1 |
above, provided that you also meet all of these conditions: |
|
a) You must cause the modified files to carry prominent notices |
stating that you changed the files and the date of any change. |
|
b) You must cause any work that you distribute or publish, that in |
whole or in part contains or is derived from the Program or any |
part thereof, to be licensed as a whole at no charge to all third |
parties under the terms of this License. |
|
c) If the modified program normally reads commands interactively |
when run, you must cause it, when started running for such |
interactive use in the most ordinary way, to print or display an |
announcement including an appropriate copyright notice and a |
notice that there is no warranty (or else, saying that you provide |
a warranty) and that users may redistribute the program under |
these conditions, and telling the user how to view a copy of this |
License. (Exception: if the Program itself is interactive but |
does not normally print such an announcement, your work based on |
the Program is not required to print an announcement.) |
|
These requirements apply to the modified work as a whole. If |
identifiable sections of that work are not derived from the Program, |
and can be reasonably considered independent and separate works in |
themselves, then this License, and its terms, do not apply to those |
sections when you distribute them as separate works. But when you |
distribute the same sections as part of a whole which is a work based |
on the Program, the distribution of the whole must be on the terms of |
this License, whose permissions for other licensees extend to the |
entire whole, and thus to each and every part regardless of who wrote it. |
|
Thus, it is not the intent of this section to claim rights or contest |
your rights to work written entirely by you; rather, the intent is to |
exercise the right to control the distribution of derivative or |
collective works based on the Program. |
|
In addition, mere aggregation of another work not based on the Program |
with the Program (or with a work based on the Program) on a volume of |
a storage or distribution medium does not bring the other work under |
the scope of this License. |
|
3. You may copy and distribute the Program (or a work based on it, |
under Section 2) in object code or executable form under the terms of |
Sections 1 and 2 above provided that you also do one of the following: |
|
a) Accompany it with the complete corresponding machine-readable |
source code, which must be distributed under the terms of Sections |
1 and 2 above on a medium customarily used for software interchange; or, |
|
b) Accompany it with a written offer, valid for at least three |
years, to give any third party, for a charge no more than your |
cost of physically performing source distribution, a complete |
machine-readable copy of the corresponding source code, to be |
distributed under the terms of Sections 1 and 2 above on a medium |
customarily used for software interchange; or, |
|
c) Accompany it with the information you received as to the offer |
to distribute corresponding source code. (This alternative is |
allowed only for noncommercial distribution and only if you |
received the program in object code or executable form with such |
an offer, in accord with Subsection b above.) |
|
The source code for a work means the preferred form of the work for |
making modifications to it. For an executable work, complete source |
code means all the source code for all modules it contains, plus any |
associated interface definition files, plus the scripts used to |
control compilation and installation of the executable. However, as a |
special exception, the source code distributed need not include |
anything that is normally distributed (in either source or binary |
form) with the major components (compiler, kernel, and so on) of the |
operating system on which the executable runs, unless that component |
itself accompanies the executable. |
|
If distribution of executable or object code is made by offering |
access to copy from a designated place, then offering equivalent |
access to copy the source code from the same place counts as |
distribution of the source code, even though third parties are not |
compelled to copy the source along with the object code. |
|
4. You may not copy, modify, sublicense, or distribute the Program |
except as expressly provided under this License. Any attempt |
otherwise to copy, modify, sublicense or distribute the Program is |
void, and will automatically terminate your rights under this License. |
However, parties who have received copies, or rights, from you under |
this License will not have their licenses terminated so long as such |
parties remain in full compliance. |
|
5. You are not required to accept this License, since you have not |
signed it. However, nothing else grants you permission to modify or |
distribute the Program or its derivative works. These actions are |
prohibited by law if you do not accept this License. Therefore, by |
modifying or distributing the Program (or any work based on the |
Program), you indicate your acceptance of this License to do so, and |
all its terms and conditions for copying, distributing or modifying |
the Program or works based on it. |
|
6. Each time you redistribute the Program (or any work based on the |
Program), the recipient automatically receives a license from the |
original licensor to copy, distribute or modify the Program subject to |
these terms and conditions. You may not impose any further |
restrictions on the recipients' exercise of the rights granted herein. |
You are not responsible for enforcing compliance by third parties to |
this License. |
|
7. If, as a consequence of a court judgment or allegation of patent |
infringement or for any other reason (not limited to patent issues), |
conditions are imposed on you (whether by court order, agreement or |
otherwise) that contradict the conditions of this License, they do not |
excuse you from the conditions of this License. If you cannot |
distribute so as to satisfy simultaneously your obligations under this |
License and any other pertinent obligations, then as a consequence you |
may not distribute the Program at all. For example, if a patent |
license would not permit royalty-free redistribution of the Program by |
all those who receive copies directly or indirectly through you, then |
the only way you could satisfy both it and this License would be to |
refrain entirely from distribution of the Program. |
|
If any portion of this section is held invalid or unenforceable under |
any particular circumstance, the balance of the section is intended to |
apply and the section as a whole is intended to apply in other |
circumstances. |
|
It is not the purpose of this section to induce you to infringe any |
patents or other property right claims or to contest validity of any |
such claims; this section has the sole purpose of protecting the |
integrity of the free software distribution system, which is |
implemented by public license practices. Many people have made |
generous contributions to the wide range of software distributed |
through that system in reliance on consistent application of that |
system; it is up to the author/donor to decide if he or she is willing |
to distribute software through any other system and a licensee cannot |
impose that choice. |
|
This section is intended to make thoroughly clear what is believed to |
be a consequence of the rest of this License. |
|
8. If the distribution and/or use of the Program is restricted in |
certain countries either by patents or by copyrighted interfaces, the |
original copyright holder who places the Program under this License |
may add an explicit geographical distribution limitation excluding |
those countries, so that distribution is permitted only in or among |
countries not thus excluded. In such case, this License incorporates |
the limitation as if written in the body of this License. |
|
9. The Free Software Foundation may publish revised and/or new versions |
of the General Public License from time to time. Such new versions will |
be similar in spirit to the present version, but may differ in detail to |
address new problems or concerns. |
|
Each version is given a distinguishing version number. If the Program |
specifies a version number of this License which applies to it and "any |
later version", you have the option of following the terms and conditions |
either of that version or of any later version published by the Free |
Software Foundation. If the Program does not specify a version number of |
this License, you may choose any version ever published by the Free Software |
Foundation. |
|
10. If you wish to incorporate parts of the Program into other free |
programs whose distribution conditions are different, write to the author |
to ask for permission. For software which is copyrighted by the Free |
Software Foundation, write to the Free Software Foundation; we sometimes |
make exceptions for this. Our decision will be guided by the two goals |
of preserving the free status of all derivatives of our free software and |
of promoting the sharing and reuse of software generally. |
|
NO WARRANTY |
|
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
REPAIR OR CORRECTION. |
|
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
POSSIBILITY OF SUCH DAMAGES. |
|
END OF TERMS AND CONDITIONS |
|
How to Apply These Terms to Your New Programs |
|
If you develop a new program, and you want it to be of the greatest |
possible use to the public, the best way to achieve this is to make it |
free software which everyone can redistribute and change under these terms. |
|
To do so, attach the following notices to the program. It is safest |
to attach them to the start of each source file to most effectively |
convey the exclusion of warranty; and each file should have at least |
the "copyright" line and a pointer to where the full notice is found. |
|
<one line to give the program's name and a brief idea of what it does.> |
Copyright (C) 19yy <name of author> |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
|
Also add information on how to contact you by electronic and paper mail. |
|
If the program is interactive, make it output a short notice like this |
when it starts in an interactive mode: |
|
Gnomovision version 69, Copyright (C) 19yy name of author |
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
This is free software, and you are welcome to redistribute it |
under certain conditions; type `show c' for details. |
|
The hypothetical commands `show w' and `show c' should show the appropriate |
parts of the General Public License. Of course, the commands you use may |
be called something other than `show w' and `show c'; they could even be |
mouse-clicks or menu items--whatever suits your program. |
|
You should also get your employer (if you work as a programmer) or your |
school, if any, to sign a "copyright disclaimer" for the program, if |
necessary. Here is a sample; alter the names: |
|
Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
`Gnomovision' (which makes passes at compilers) written by James Hacker. |
|
<signature of Ty Coon>, 1 April 1989 |
Ty Coon, President of Vice |
|
This General Public License does not permit incorporating your program into |
proprietary programs. If your program is a subroutine library, you may |
consider it more useful to permit linking proprietary applications with the |
library. If this is what you want to do, use the GNU Library General |
Public License instead of this License. |
/Makefile
0,0 → 1,95
# |
# Makefile for the Linux device driver for eCos USB-ethernet |
# devices. This makefile has been cloned from the one in |
# /usr/src/linux-2.2.16/drivers/usb |
# |
|
# This makefile will chain to the Linux makefile if appropriate. |
# The toplevel Linux makefile sets the variable KERNELRELEASE |
ifeq (,$(KERNELRELEASE)) |
|
default: |
make -C /usr/src/linux SUBDIRS=$(shell pwd) modules |
|
modules: default |
|
modules_install: |
@echo Support for installing this module not yet implemented. |
|
else |
|
# A recursive invocation of this makefile from the Linux one. |
|
# Build this driver as a module. |
CONFIG_USB_ECOS_USBETH = m |
|
# Subdirs. |
|
SUB_DIRS := |
MOD_SUB_DIRS := $(SUB_DIRS) |
MOD_IN_SUB_DIRS := $(SUB_DIRS) |
ALL_SUB_DIRS := $(SUB_DIRS) |
|
# The target object and module list name. |
|
O_TARGET := |
M_OBJS := |
O_OBJS := |
MOD_LIST_NAME := ECOS_USBETH_MODULE |
|
# Objects that export symbols. |
|
export-objs := |
|
# Multipart objects. |
|
list-multi := |
|
# Optional parts of multipart objects. |
|
# Object file lists. |
|
obj-y := |
obj-m := |
obj-n := |
obj- := |
|
# Object files in subdirectories |
|
# Each configuration option enables a list of files. |
|
obj-$(CONFIG_USB_ECOS_USBETH) += ecos_usbeth.o |
|
# Extract lists of the multi-part drivers. |
# The 'int-*' lists are the intermediate files used to build the multi's. |
|
multi-y := $(filter $(list-multi), $(obj-y)) |
multi-m := $(filter $(list-multi), $(obj-m)) |
int-y := $(sort $(foreach m, $(multi-y), $($(basename $(m))-objs))) |
int-m := $(sort $(foreach m, $(multi-m), $($(basename $(m))-objs))) |
|
# Files that are both resident and modular: remove from modular. |
|
obj-m := $(filter-out $(obj-y), $(obj-m)) |
int-m := $(filter-out $(int-y), $(int-m)) |
|
# Take multi-part drivers out of obj-y and put components in. |
|
obj-y := $(filter-out $(list-multi), $(obj-y)) $(int-y) |
|
# Translate to Rules.make lists. |
|
O_OBJS := $(sort $(filter-out $(export-objs), $(obj-y))) |
OX_OBJS := $(sort $(filter $(export-objs), $(obj-y))) |
M_OBJS := $(sort $(filter-out $(export-objs), $(obj-m))) |
MX_OBJS := $(sort $(filter $(export-objs), $(obj-m))) |
MI_OBJS := $(sort $(filter-out $(export-objs), $(int-m))) |
MIX_OBJS := $(sort $(filter $(export-objs), $(int-m))) |
|
# The global Rules.make. |
|
include $(TOPDIR)/Rules.make |
|
# Link rules for multi-part drivers. |
|
endif |