Banto Linux

2008-05-02T23:36:00.000+08:00

To rebuild strace for ARM Platform

CC=arm-unknown-linux-gnu-gcc ./configure --target=arm-linux --host=arm-linux

,build就是你正在使用的机器,host就是你编译好的程序可以运行的平台,target就是你编译的程序可以处理的平台.这个build和host比较好理解,但是target就不好办了,到底什么意思呢?一般来说,我们平时所说的交差编译用不到他target的,比如./configure --build=i386-linux,--host=arm-linux就可以了,在386的平台上编译可以运行在arm板的程序.但是,一般我们都是编译程序,而不是编译工具,如果我们编译工具,比如gcc,这个target就有用了.如果我们需要在一个我们的机器上为arm开发板编译

參考自: http://oss.lzu.edu.cn/blog/blog.php?/do_showone/tid_116.html

2008-04-26T12:53:00.000+08:00

Dummy Block Driver for Linux

/*
* Sample disk driver, from the beginning.
*/

#include <linux/config.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>

#include <linux/sched.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/timer.h>
#include <linux/types.h> /* size_t */
#include <linux/fcntl.h> /* O_ACCMODE */
#include <linux/hdreg.h> /* HDIO_GETGEO */
#include <linux/kdev_t.h>
#include <linux/vmalloc.h>
#include <linux/genhd.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h> /* invalidate_bdev */
#include <linux/bio.h>

MODULE_LICENSE("Dual BSD/GPL");

static int sbull_major = 0;
module_param(sbull_major, int, 0);
static int hardsect_size = 512;
module_param(hardsect_size, int, 0);
static int nsectors = 1024; /* How big the drive is */
module_param(nsectors, int, 0);
static int ndevices = 4;
module_param(ndevices, int, 0);

/*
* The different "request modes" we can use.
*/
enum {
RM_SIMPLE = 0, /* The extra-simple request function */
RM_FULL = 1, /* The full-blown version */
RM_NOQUEUE = 2, /* Use make_request */
};
static int request_mode = RM_SIMPLE;
module_param(request_mode, int, 0);

/*
* Minor number and partition management.
*/
#define SBULL_MINORS 16
#define MINOR_SHIFT 4
#define DEVNUM(kdevnum) (MINOR(kdev_t_to_nr(kdevnum)) >> MINOR_SHIFT

/*
* We can tweak our hardware sector size, but the kernel talks to us
* in terms of small sectors, always.
*/
#define KERNEL_SECTOR_SIZE 512

/*
* After this much idle time, the driver will simulate a media change.
*/
#define INVALIDATE_DELAY 30*HZ

/*
* The internal representation of our device.
*/
struct sbull_dev {
int size; /* Device size in sectors */
u8 *data; /* The data array */
short users; /* How many users */
short media_change; /* Flag a media change? */
spinlock_t lock; /* For mutual exclusion */
struct request_queue *queue; /* The device request queue */
struct gendisk *gd; /* The gendisk structure */
struct timer_list timer; /* For simulated media changes */
};

static struct sbull_dev *Devices = NULL;

/*
* Handle an I/O request.
*/
static void sbull_transfer(struct sbull_dev *dev, unsigned long sector,
unsigned long nsect, char *buffer, int write)
{
unsigned long offset = sector*KERNEL_SECTOR_SIZE;
unsigned long nbytes = nsect*KERNEL_SECTOR_SIZE;

if ((offset + nbytes) > dev->size) {
printk (KERN_NOTICE "Beyond-end write (%ld %ld)n", offset, nbytes);
return;
}
if (write)
memcpy(dev->data + offset, buffer, nbytes);
else
memcpy(buffer, dev->data + offset, nbytes);
}

/*
* The simple form of the request function.
*/
static void sbull_request(request_queue_t *q)
{
struct request *req;

while ((req = elv_next_request(q)) != NULL) {
struct sbull_dev *dev = req->rq_disk->private_data;
if (! blk_fs_request(req)) {
printk (KERN_NOTICE "Skip non-fs requestn");
end_request(req, 0);
continue;
}
// printk (KERN_NOTICE "Req dev %d dir %ld sec %ld, nr %d f %lxn",
// dev - Devices, rq_data_dir(req),
// req->sector, req->current_nr_sectors,
// req->flags);
sbull_transfer(dev, req->sector, req->current_nr_sectors,
req->buffer, rq_data_dir(req));
end_request(req, 1);
}
}

/*
* Transfer a single BIO.
*/
static int sbull_xfer_bio(struct sbull_dev *dev, struct bio *bio)
{
int i;
struct bio_vec *bvec;
sector_t sector = bio->bi_sector;

/* Do each segment independently. */
bio_for_each_segment(bvec, bio, i) {
char *buffer = __bio_kmap_atomic(bio, i, KM_USER0);
sbull_transfer(dev, sector, bio_cur_sectors(bio),
buffer, bio_data_dir(bio) == WRITE);
sector += bio_cur_sectors(bio);
__bio_kunmap_atomic(bio, KM_USER0);
}
return 0; /* Always "succeed" */
}

/*
* Transfer a full request.
*/
static int sbull_xfer_request(struct sbull_dev *dev, struct request *req)
{
struct bio *bio;
int nsect = 0;

rq_for_each_bio(bio, req) {
sbull_xfer_bio(dev, bio);
nsect += bio->bi_size/KERNEL_SECTOR_SIZE;
}
return nsect;
}

/*
* Smarter request function that "handles clustering".
*/
static void sbull_full_request(request_queue_t *q)
{
struct request *req;
int sectors_xferred;
struct sbull_dev *dev = q->queuedata;

while ((req = elv_next_request(q)) != NULL) {
if (! blk_fs_request(req)) {
printk (KERN_NOTICE "Skip non-fs requestn");
end_request(req, 0);
continue;
}
sectors_xferred = sbull_xfer_request(dev, req);
if (! end_that_request_first(req, 1, sectors_xferred)) {
blkdev_dequeue_request(req);
end_that_request_last(req);
}
}
}

/*
* The direct make request version.
*/
static int sbull_make_request(request_queue_t *q, struct bio *bio)
{
struct sbull_dev *dev = q->queuedata;
int status;

status = sbull_xfer_bio(dev, bio);
bio_endio(bio, bio->bi_size, status);
return 0;
}

/*
* Open and close.
*/

static int sbull_open(struct inode *inode, struct file *filp)
{
struct sbull_dev *dev = inode->i_bdev->bd_disk->private_data;

del_timer_sync(&dev->timer);
filp->private_data = dev;
spin_lock(&dev->lock);
if (! dev->users)
check_disk_change(inode->i_bdev);
dev->users++;
spin_unlock(&dev->lock);
return 0;
}

static int sbull_release(struct inode *inode, struct file *filp)
{
struct sbull_dev *dev = inode->i_bdev->bd_disk->private_data;

spin_lock(&dev->lock);
dev->users--;

if (!dev->users) {
dev->timer.expires = jiffies + INVALIDATE_DELAY;
add_timer(&dev->timer);
}
spin_unlock(&dev->lock);

return 0;
}

/*
* Look for a (simulated) media change.
*/
int sbull_media_changed(struct gendisk *gd)
{
struct sbull_dev *dev = gd->private_data;

return dev->media_change;
}

/*
* Revalidate. WE DO NOT TAKE THE LOCK HERE, for fear of deadlocking
* with open. That needs to be reevaluated.
*/
int sbull_revalidate(struct gendisk *gd)
{
struct sbull_dev *dev = gd->private_data;

if (dev->media_change) {
dev->media_change = 0;
memset (dev->data, 0, dev->size);
}
return 0;
}

/*
* The "invalidate" function runs out of the device timer; it sets
* a flag to simulate the removal of the media.
*/
void sbull_invalidate(unsigned long ldev)
{
struct sbull_dev *dev = (struct sbull_dev *) ldev;

spin_lock(&dev->lock);
if (dev->users || !dev->data)
printk (KERN_WARNING "sbull: timer sanity check failedn");
else
dev->media_change = 1;
spin_unlock(&dev->lock);
}

/*
* The ioctl() implementation
*/

int sbull_ioctl (struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg)
{
long size;
struct hd_geometry geo;
struct sbull_dev *dev = filp->private_data;

switch(cmd) {
case HDIO_GETGEO:
/*
* Get geometry: since we are a virtual device, we have to make
* up something plausible. So we claim 16 sectors, four heads,
* and calculate the corresponding number of cylinders. We set the
* start of data at sector four.
*/
size = dev->size*(hardsect_size/KERNEL_SECTOR_SIZE);
geo.cylinders = (size & ~0x3f) >> 6;
geo.heads = 4;
geo.sectors = 16;
geo.start = 4;
if (copy_to_user((void __user *) arg, &geo, sizeof(geo)))
return -EFAULT;
return 0;
}

return -ENOTTY; /* unknown command */
}

/*
* The device operations structure.
*/
static struct block_device_operations sbull_ops = {
.owner = THIS_MODULE,
.open = sbull_open,
.release = sbull_release,
.media_changed = sbull_media_changed,
.revalidate_disk = sbull_revalidate,
.ioctl = sbull_ioctl
};

/*
* Set up our internal device.
*/
static void setup_device(struct sbull_dev *dev, int which)
{
/*
* Get some memory.
*/
memset (dev, 0, sizeof (struct sbull_dev));
dev->size = nsectors*hardsect_size;
dev->data = vmalloc(dev->size);
if (dev->data == NULL) {
printk (KERN_NOTICE "vmalloc failure.n");
return;
}
spin_lock_init(&dev->lock);

/*
* The timer which "invalidates" the device.
*/
init_timer(&dev->timer);
dev->timer.data = (unsigned long) dev;
dev->timer.function = sbull_invalidate;

/*
* The I/O queue, depending on whether we are using our own
* make_request function or not.
*/
switch (request_mode) {
case RM_NOQUEUE:
dev->queue = blk_alloc_queue(GFP_KERNEL);
if (dev->queue == NULL)
goto out_vfree;
blk_queue_make_request(dev->queue, sbull_make_request);
break;

case RM_FULL:
dev->queue = blk_init_queue(sbull_full_request, &dev->lock);
if (dev->queue == NULL)
goto out_vfree;
break;

default:
printk(KERN_NOTICE "Bad request mode %d, using simplen", request_mode);
/* fall into.. */

case RM_SIMPLE:
dev->queue = blk_init_queue(sbull_request, &dev->lock);
if (dev->queue == NULL)
goto out_vfree;
break;
}
blk_queue_hardsect_size(dev->queue, hardsect_size);
dev->queue->queuedata = dev;
/*
* And the gendisk structure.
*/
dev->gd = alloc_disk(SBULL_MINORS);
if (! dev->gd) {
printk (KERN_NOTICE "alloc_disk failuren");
goto out_vfree;
}
dev->gd->major = sbull_major;
dev->gd->first_minor = which*SBULL_MINORS;
dev->gd->fops = &sbull_ops;
dev->gd->queue = dev->queue;
dev->gd->private_data = dev;
snprintf (dev->gd->disk_name, 32, "sbull%c", which + 'a');
set_capacity(dev->gd, nsectors*(hardsect_size/KERNEL_SECTOR_SIZE));
add_disk(dev->gd);
return;

out_vfree:
if (dev->data)
vfree(dev->data);
}

static int __init sbull_init(void)
{
int i;
/*
* Get registered.
*/
sbull_major = register_blkdev(sbull_major, "sbull");
if (sbull_major <= 0) {
printk(KERN_WARNING "sbull: unable to get major numbern");
return -EBUSY;
}
/*
* Allocate the device array, and initialize each one.
*/
Devices = kmalloc(ndevices*sizeof (struct sbull_dev), GFP_KERNEL);
if (Devices == NULL)
goto out_unregister;
for (i = 0; i < ndevices; i++)
setup_device(Devices + i, i);

return 0;

out_unregister:
unregister_blkdev(sbull_major, "sbd");
return -ENOMEM;
}

static void sbull_exit(void)
{
int i;

for (i = 0; i < ndevices; i++) {
struct sbull_dev *dev = Devices + i;

del_timer_sync(&dev->timer);
if (dev->gd) {
del_gendisk(dev->gd);
put_disk(dev->gd);
}
if (dev->queue) {
if (request_mode == RM_NOQUEUE)
blk_put_queue(dev->queue);
else
blk_cleanup_queue(dev->queue);
}
if (dev->data)
vfree(dev->data);
}
unregister_blkdev(sbull_major, "sbull");
kfree(Devices);
}

module_init(sbull_init);
module_exit(sbull_exit);

2008-04-26T08:08:00.001+08:00

Dummy USB driver for Linux

/*
* USB Skeleton driver - 2.0
*
* Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
*
* 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, version 2.
*
* This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c
* but has been rewritten to be easy to read and use, as no locks are now
* needed anymore.
*
*/

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/smp_lock.h>
#include <linux/usb.h>
#include <asm/uaccess.h>

/* Define these values to match your devices */
#define USB_SKEL_VENDOR_ID 0xfff0
#define USB_SKEL_PRODUCT_ID 0xfff0

/* table of devices that work with this driver */
static struct usb_device_id skel_table [] = {
{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, skel_table);

/* Get a minor range for your devices from the usb maintainer */
#define USB_SKEL_MINOR_BASE 192

/* Structure to hold all of our device specific stuff */
struct usb_skel {
struct usb_device * udev; /* the usb device for this device */
struct usb_interface * interface; /* the interface for this device */
unsigned char * bulk_in_buffer; /* the buffer to receive data */
size_t bulk_in_size; /* the size of the receive buffer */
__u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
__u8 bulk_out_endpointAddr; /* the address of the bulk out endpoint */
struct kref kref;
};
#define to_skel_dev(d) container_of(d, struct usb_skel, kref)

static struct usb_driver skel_driver;

static void skel_delete(struct kref *kref)
{
struct usb_skel *dev = to_skel_dev(kref);

usb_put_dev(dev->udev);
kfree (dev->bulk_in_buffer);
kfree (dev);
}

static int skel_open(struct inode *inode, struct file *file)
{
struct usb_skel *dev;
struct usb_interface *interface;
int subminor;
int retval = 0;

subminor = iminor(inode);

interface = usb_find_interface(&skel_driver, subminor);
if (!interface) {
err ("%s - error, can't find device for minor %d",
__FUNCTION__, subminor);
retval = -ENODEV;
goto exit;
}

dev = usb_get_intfdata(interface);
if (!dev) {
retval = -ENODEV;
goto exit;
}

/* increment our usage count for the device */
kref_get(&dev->kref);

/* save our object in the file's private structure */
file->private_data = dev;

exit:
return retval;
}

static int skel_release(struct inode *inode, struct file *file)
{
struct usb_skel *dev;

dev = (struct usb_skel *)file->private_data;
if (dev == NULL)
return -ENODEV;

/* decrement the count on our device */
kref_put(&dev->kref, skel_delete);
return 0;
}

static ssize_t skel_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
struct usb_skel *dev;
int retval = 0;

dev = (struct usb_skel *)file->private_data;

/* do a blocking bulk read to get data from the device */
retval = usb_bulk_msg(dev->udev,
usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
dev->bulk_in_buffer,
min(dev->bulk_in_size, count),
&count, HZ*10);

/* if the read was successful, copy the data to userspace */
if (!retval) {
if (copy_to_user(buffer, dev->bulk_in_buffer, count))
retval = -EFAULT;
else
retval = count;
}

return retval;
}

static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs)
{
/* sync/async unlink faults aren't errors */
if (urb->status &&
!(urb->status == -ENOENT ||
urb->status == -ECONNRESET ||
urb->status == -ESHUTDOWN)) {
dbg("%s - nonzero write bulk status received: %d",
__FUNCTION__, urb->status);
}

/* free up our allocated buffer */
usb_buffer_free(urb->dev, urb->transfer_buffer_length,
urb->transfer_buffer, urb->transfer_dma);
}

static ssize_t skel_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *ppos)
{
struct usb_skel *dev;
int retval = 0;
struct urb *urb = NULL;
char *buf = NULL;

dev = (struct usb_skel *)file->private_data;

/* verify that we actually have some data to write */
if (count == 0)
goto exit;

/* create a urb, and a buffer for it, and copy the data to the urb */
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb) {
retval = -ENOMEM;
goto error;
}

buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);
if (!buf) {
retval = -ENOMEM;
goto error;
}
if (copy_from_user(buf, user_buffer, count)) {
retval = -EFAULT;
goto error;
}

/* initialize the urb properly */
usb_fill_bulk_urb(urb, dev->udev,
usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
buf, count, skel_write_bulk_callback, dev);
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

/* send the data out the bulk port */
retval = usb_submit_urb(urb, GFP_KERNEL);
if (retval) {
err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);
goto error;
}

/* release our reference to this urb, the USB core will eventually free it entirely */
usb_free_urb(urb);

exit:
return count;

error:
usb_buffer_free(dev->udev, count, buf, urb->transfer_dma);
usb_free_urb(urb);
kfree(buf);
return retval;
}

static struct file_operations skel_fops = {
.owner = THIS_MODULE,
.read = skel_read,
.write = skel_write,
.open = skel_open,
.release = skel_release,
};

/*
* usb class driver info in order to get a minor number from the usb core,
* and to have the device registered with devfs and the driver core
*/
static struct usb_class_driver skel_class = {
.name = "usb/skel%d",
.fops = &skel_fops,
.mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
.minor_base = USB_SKEL_MINOR_BASE,
};

static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
struct usb_skel *dev = NULL;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
size_t buffer_size;
int i;
int retval = -ENOMEM;

/* allocate memory for our device state and initialize it */
dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL);
if (dev == NULL) {
err("Out of memory");
goto error;
}
memset(dev, 0x00, sizeof (*dev));
kref_init(&dev->kref);

dev->udev = usb_get_dev(interface_to_usbdev(interface));
dev->interface = interface;

/* set up the endpoint information */
/* use only the first bulk-in and bulk-out endpoints */
iface_desc = interface->cur_altsetting;
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
endpoint = &iface_desc->endpoint[i].desc;

if (!dev->bulk_in_endpointAddr &&
(endpoint->bEndpointAddress & USB_DIR_IN) &&
((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_BULK)) {
/* we found a bulk in endpoint */
buffer_size = endpoint->wMaxPacketSize;
dev->bulk_in_size = buffer_size;
dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
if (!dev->bulk_in_buffer) {
err("Could not allocate bulk_in_buffer");
goto error;
}
}

if (!dev->bulk_out_endpointAddr &&
!(endpoint->bEndpointAddress & USB_DIR_IN) &&
((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_BULK)) {
/* we found a bulk out endpoint */
dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
}
}
if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
err("Could not find both bulk-in and bulk-out endpoints");
goto error;
}

/* save our data pointer in this interface device */
usb_set_intfdata(interface, dev);

/* we can register the device now, as it is ready */
retval = usb_register_dev(interface, &skel_class);
if (retval) {
/* something prevented us from registering this driver */
err("Not able to get a minor for this device.");
usb_set_intfdata(interface, NULL);
goto error;
}

/* let the user know what node this device is now attached to */
info("USB Skeleton device now attached to USBSkel-%d", interface->minor);
return 0;

error:
if (dev)
kref_put(&dev->kref, skel_delete);
return retval;
}

static void skel_disconnect(struct usb_interface *interface)
{
struct usb_skel *dev;
int minor = interface->minor;

/* prevent skel_open() from racing skel_disconnect() */
lock_kernel();

dev = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);

/* give back our minor */
usb_deregister_dev(interface, &skel_class);

unlock_kernel();

/* decrement our usage count */
kref_put(&dev->kref, skel_delete);

info("USB Skeleton #%d now disconnected", minor);
}

static struct usb_driver skel_driver = {
.owner = THIS_MODULE,
.name = "skeleton",
.id_table = skel_table,
.probe = skel_probe,
.disconnect = skel_disconnect,
};

static int __init usb_skel_init(void)
{
int result;

/* register this driver with the USB subsystem */
result = usb_register(&skel_driver);
if (result)
err("usb_register failed. Error number %d", result);

return result;
}

static void __exit usb_skel_exit(void)
{
/* deregister this driver with the USB subsystem */
usb_deregister(&skel_driver);
}

module_init (usb_skel_init);
module_exit (usb_skel_exit);

MODULE_LICENSE("GPL");

2008-04-26T08:08:00.000+08:00

Dummy PCI driver for Linux

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>

static struct pci_device_id ids[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3), },
{ 0, }
};
MODULE_DEVICE_TABLE(pci, ids);

static unsigned char skel_get_revision(struct pci_dev *dev)
{
u8 revision;

pci_read_config_byte(dev, PCI_REVISION_ID, &revision);
return revision;
}

static int probe(struct pci_dev *dev, const struct pci_device_id *id)
{
/* Do probing type stuff here.
* Like calling request_region();
*/
pci_enable_device(dev);

if (skel_get_revision(dev) == 0x42)
return -ENODEV;

return 0;
}

static void remove(struct pci_dev *dev)
{
/* clean up any allocated resources and stuff here.
* like call release_region();
*/
}

static struct pci_driver pci_driver = {
.name = "pci_skel",
.id_table = ids,
.probe = probe,
.remove = remove,
};

static int __init pci_skel_init(void)
{
return pci_register_driver(&pci_driver);
}

static void __exit pci_skel_exit(void)
{
pci_unregister_driver(&pci_driver);
}

MODULE_LICENSE("GPL");

module_init(pci_skel_init);
module_exit(pci_skel_exit);

2008-04-19T00:36:00.000+08:00

Linux 2.6 驱动设计快速入门

引用自: http://dev.csdn.net/article/67/67489.shtm

Linux 2.6 和 2.4 的比较我不想废话，总体来说 2.6 功能更强，但是资源消耗更多。

由于 2.6 内核在驱动框架，底层调用上和 2.4 内核有很多差别，所以本文主要是为程序员提供 2.4 到 2.6 迁移的指导。

2.6 和 2.4 主要的不同在于

• 内核的 API 变化，增加了不少新功能（例如 mem pool ）

• 提供 sysfs 用于描述设备树

• 驱动模块从 .o 变为 .ko

移植 hello word

下面是一个最简单的 2.4 驱动：

#define MODULE
#include <linux/module.h>
#include <linux/kernel.h>
int init_module(void)
{
printk(KERN_INFO "Hello, worldn");
return 0;
}
void cleanup_module(void)
{
printk(KERN_INFO "Goodbye cruel worldn");
}

2.6的hello world版本！

#include < linux/module.h>
#include < linux/config.h>
#include < linux/init.h>
MODULE_LICENSE("GPL");// 新，否则有 waring, 去掉了 #define MODULE, 自动定义
static int hello_init(void)
{
printk(KERN_ALERT "Hello, worldn");
return 0;
}
static void hello_exit(void)
{
printk(KERN_ALERT "Goodbye, cruel worldn");
}
module_init(hello_init);// 必须！！
module_exit(hello_exit); // 必须！！

注意，在 2.4 中 module_init 不是必须的，只要驱动的初始化函数以及析沟函数命名使用了缺省的 init_module 和 cleanup_module

编译生成：

2.4

gcc -D__KERNEL__ -DMODULE -I/usr/src/linux- 2.4.27 /include -O2 -c testmod.c

2.6

makefile 中要有 obj-m:= hello.o

然后：

make -C /usr/src/linux- 2.6.11 SUBDIRS=$PWD modules （当然简单的 make 也可以）

哈哈够简单！！

其他不同：

计数器：

以前 2.4 内核使用 MOD_INC_USE_COUNT 增加计数例如：

void

inc_mod(void)

{

MOD_INC_USE_COUNT;

} /* end inc_mod */

/************************************************************************

* Calculator DEC

************************************************************************/

void

dec_mod(void)

{

MOD_DEC_USE_COUNT;

} /* end dec_mod */

现在这个也过时了 !!

2.6 ，用户函数要加载模块，使用：

int try_module_get(&module);

函数卸载模块使用

module_put()

而驱动中不必显示定义 inc 和 dec

没有 kdev_t 了

现在都流行用 dev_t 了 , 而且是 32 位的

结构体初始化

老版本使用：

static struct some_structure = {

field1: value,

field2: value

};

现在流行用：

static struct some_structure = {

.field1 = value,

.field2 = value,

...

};

malloc.h

要用核态内存？用 <linux/slab.h> 好了，

内存池

内存管理变化不大，添加了memory pool*(#include<linux/mempool.h> )。（现在什么都是pool，内存线程 ....）这是为块设备提供的，使用mempool最大的优点是分配内存不会错，也不会等待（怎么这个也和RTEMS学）。对于embed的设备还是有些用处的。标准调用方式：

mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data);

使用mempool的函数：

mempool_alloc_t / mempool_free_t

mempool_alloc_slab / mempool_free_slab

mempool_alloc / mempool_free

mempool_resize

结构体赋值

以前，驱动中结构体赋值使用：

static struct some_structure = {

field1: value,

field2: value

};

现在要用：

static struct some_structure = {

.field1 = value,

.field2 = value,

...

};

例如 :

static struct file_operations yourdev_file_ops = {

.open = yourdev_open,

.read = yourdev_read_file,

.write = yourdev_write_file,

};

min() ， max()

不少程序员定义自己的 min 和 max 宏，大家也知道宏不安全， Linux 定义了 min 和 max 函数（注意不是模板函数，需要自己制定比较类型！）

原型变化

call_usermodehelper()

request_module()

函数原型变化了，用到的赶快查 !!!

Devfs

唉，还没怎么用，就过时了的技术，这就是 linux 。不是我们落伍，是世界变化快

字符设备

2.6 中主从设备编号不再局限于原来的 8bit

register_chrdev() 可以升级为：

int register_chrdev_region(dev_t from, // 设备号 unsigned count, // 注册号 char *name); // 名称

该函数的动态版本（不知道主设备号时使用）

int alloc_chrdev_region(dev_t *dev, unsigned baseminor,

unsigned count, char *name);

新的 file_operations

register_chrdev_region 没有使用 register_chrdev_region 参数，因为设备现在使用 struct cdev 来定义他在 <linux/cdev.h> 中定义。

struct cdev {

struct kobject kobj;

struct module *owner;

struct file_operations *ops;

struct list_head list;

dev_t dev;

unsigned int count;

};

使用时首先需要分配空间： struct cdev *cdev_alloc(void);

然后对其初始化：

void cdev_init(struct cdev *cdev, struct file_operations *fops);

cdev 使用 kobject_set_name 设置名称：例如：

struct cdev *my_cdev = cdev_alloc(); kobject_set_name(&cdev->kobj, "my_cdev%d", devnum);

此后就可以使用 int cdev_add(struct cdev *cdev, dev_t dev, unsigned count); 将 cdev 加入到系统中。

删除 cdev 使用

void cdev_del(struct cdev *cdev);

对于没有使用 cdev_add 添加的 cdev 使用 kobject_put(&cdev->kobj); 删除也就是使用： struct kobject *cdev_get(struct cdev *cdev); void cdev_put(struct cdev *cdev);

太极链；

struct inode -> i_cdev -> cdev

这样就从 inode 链接到 cdev

驱动体系：

/dev 到 /sys

/dev 也过时了，设备文件都跑到 /sys 里了！

# cd /sys

# ls

block bus class devices firmware

2008-04-18T21:28:00.000+08:00

Build Kernel Module as KO files

Show build progress in verbose

make V=1

lib path for glibc

/opt/microtime/pro/devkit/arm/pxa270/gcc-4.0.2-glibc-2.3.3/arm-unknown-linux-gnu/arm-unknown-linux-gnu/lib

bin path of gcc

/opt/microtime/pro/devkit/arm/pxa270/gcc-4.0.2-glibc-2.3.3/arm-unknown-linux-gnu/bin

header file path of Linux Kernel

/usr/src/creator/pxa270/linux/include

obj-y

cmd_drivers/char/creator-pxa270-lcd.o := arm-unknown-linux-gnu-gcc -Wp,-MD,drivers/char/.creator-pxa270-lcd.o.d -nostdinc -isystem /opt/microtime/pro/devkit/arm/pxa270/gcc-4.0.2-glibc-2.3.3/arm-unknown-linux-gnu/bin/../lib/gcc/arm-unknown-linux-gnu/4.0.2/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -mlittle-endian -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -fno-inline -Os -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -fno-omit-frame-pointer -mapcs -mno-sched-prolog -mabi=apcs-gnu -mno-thumb-interwork -D__LINUX_ARM_ARCH__=5 -march=armv5te -mtune=xscale -Wa,-mcpu=xscale -msoft-float -Uarm -Wdeclaration-after-statement -Wno-pointer-sign -DKBUILD_BASENAME=creator_pxa270_lcd -DKBUILD_MODNAME=creator_pxa270_lcd -c -o drivers/char/creator-pxa270-lcd.o drivers/char/creator-pxa270-lcd.c

obj-m

step1:
cmd_drivers/char/creator-pxa270-lcd.o := arm-unknown-linux-gnu-gcc -Wp,-MD,drivers/char/.creator-pxa270-lcd.o.d -nostdinc -isystem /opt/microtime/pro/devkit/arm/pxa270/gcc-4.0.2-glibc-2.3.3/arm-unknown-linux-gnu/bin/../lib/gcc/arm-unknown-linux-gnu/4.0.2/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -mlittle-endian -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -fno-inline -Os -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -fno-omit-frame-pointer -mapcs -mno-sched-prolog -mabi=apcs-gnu -mno-thumb-interwork -D__LINUX_ARM_ARCH__=5 -march=armv5te -mtune=xscale -Wa,-mcpu=xscale -msoft-float -Uarm -Wdeclaration-after-statement -Wno-pointer-sign -DMODULE -DKBUILD_BASENAME=creator_pxa270_lcd -DKBUILD_MODNAME=creator_pxa270_lcd -c -o drivers/char/creator-pxa270-lcd.o drivers/char/creator-pxa270-lcd.c

step2:
scripts/mod/modpost -o /usr/src/creator/pxa270/pro/devkit/lsp/create-pxa270/linux-2.6.15.3/Module.symvers vmlinux drivers/char/creator-pxa270-lcd.o

step3:
arm-unknown-linux-gnu-gcc -Wp,-MD,drivers/char/.creator-pxa270-lcd.mod.o.d -nostdinc -isystem /opt/microtime/pro/devkit/arm/pxa270/gcc-4.0.2-glibc-2.3.3/arm-unknown-linux-gnu/bin/../lib/gcc/arm-unknown-linux-gnu/4.0.2/include -D__KERNEL__ -Iinclude -include include/linux/autoconf.h -mlittle-endian -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -ffreestanding -fno-inline -Os -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -fno-omit-frame-pointer -mapcs -mno-sched-prolog -mabi=apcs-gnu -mno-thumb-interwork -D__LINUX_ARM_ARCH__=5 -march=armv5te -mtune=xscale -Wa,-mcpu=xscale -msoft-float -Uarm -Wdeclaration-after-statement -Wno-pointer-sign -DKBUILD_BASENAME=creator_pxa270_lcd -DKBUILD_MODNAME=creator_pxa270_lcd -DMODULE -c -o drivers/char/creator-pxa270-lcd.mod.o drivers/char/creator-pxa270-lcd.mod.c

step4:
arm-unknown-linux-gnu-ld -EL -r -o drivers/char/creator-pxa270-lcd.ko drivers/char/creator-pxa270-lcd.o drivers/char/creator-pxa270-lcd.mod.o

2008-04-12T07:20:00.000+08:00

arm linux 启动流程之解压内核

引用自: http://blog.csdn.net/dansen_xu/archive/2007/08/13/1740738.aspx

Author-------Dansen-----xzd2734@163.com

从后往前看下编译生成zImage的过程，我们可以找到程序的入口还是那个很重要
链接文件，找到它,生成zImage所在的目录是kernelarcharmbootcompressed
Make过程为....ld -p -X -T vmlinux.lds head.o misc.o head-s3c2410.o piggy.o
libgcc.o -o vmlinux
然后是用二进制工具objcopy把vmlinux制作成可执行的二进制映像文件zImage
这样在我们就去kernelarcharmbootcompressed目录下去找到vmlinux.lds文件
如果没有编译就不会有这个文件，因为它也是在编译过程生成的，由同一目录下的
vmlinux.lds.in生成，打开这个文件
ENTRY(_start)
SECTIONS
{
. = LOAD_ADDR;
_load_addr = .;

. = TEXT_START;
_text = .;

.text : {
_start = .;
*(.start)
*(.text)
........
入口是_start,而且入口就直接定义在这个文件中了
入口直接接着.start段,所以程序开始是从.start段开始执行的
如果看看vmlinux.lds的生成过程就应该能找到LOAD_ADDR和TEXT_START的值
实际上这两个值是由其他两个变量赋给的 ZRELADDR 和 ZTEXTADDR
在kernelarcharmbootMakefile中我们可以找到这两个变量的值
ifeq ($(CONFIG_ARCH_S3C2410),y)
ZTEXTADDR = 0x30008000
ZRELADDR = 0x30008000
endif
所以
LOAD_ADDR = 0x30008000
TEXT_START = 0x30008000
看一下vmlinux.lds吧
ENTRY(_start)
SECTIONS
{
. = 0x30008000;
_load_addr = .;

. = 0;
_text = .;
显然LOAD_ADDR被赋值了0x30008000
看一下TEXT_START怎么成0了，我想这应该是一个偏移吧，偏移是0
所以它还是0x30008000
接着下来就从head.s来开始看代码吧
.section ".start", #alloc, #execinstr
/*
* sort out different calling conventions
*/
.align
start:
.type start,#function
.rept 8
mov r0, r0
.endr

b 1f
.word 0x016f2818 @ Magic numbers to help the loader
.word start @ absolute load/run zImage address
.word _edata @ zImage end address
1: mov r7, r1 @ save architecture ID
这里一定就是程序的入口了，一般汇编程序的含义就看看英文注释就是了
有一个要注意的地方，不是一个汇编文件就是属于一个段的，不是说先执行完了
head.s再去执行head-s3c2410.s,还是要注意链接的段,显然head.s
不一会就开始了另一个段.text
.text
adr r0, LC0
ldmia r0, {r1, r2, r3, r4, r5, r6, ip, sp}
subs r0, r0, r1 @ calculate the delta offset
而我们的head-s3c2410.s呢
.section ".start", #alloc, #execinstr
__S3C2410_start:
bic r2, pc, #0x1f
add r3, r2, #0x4000 @ 16 kb is quite enough...
还是属于.start段的，所以顺序执行下来时先执行head-s3c2410.s，然后再去执行
.text段。head-s3c2410.s主要是cpu的一些初始化工作。接着下来我们会需要把内核
接压缩，先说说为什么吧。还是注意到上面生成zImage的文件中有一个piggy.o，往上
追寻可以看到是piggy.o由那个真正的内核vmlinux生成的，这个vmlinux才是启动后一直在
运行的内核，原本很大，压缩以后可以方便地放在flash中，当然其实不压缩跳到它的
入口也就可以运行了。解压的内核是准备从LOAD_ADDR = 0x30008000开始的4M空间，会覆盖
我们的当前运行的代码，那样就先把内核解压到我们这个zImage+分配堆栈0x10000的最后
cmp r4, r2 //r4 是LOAD_ADDR=0x30008000
bhs wont_overwrite //r2 是当前代码的最底部这里当然不会跳转
add r0, r4, #4096*1024 @ 4MB largest kernel size
cmp r0, r5 //r5 也是0x30008000
bls wont_overwrite //不会跳转

mov r5, r2 //r2是(user_stack+4096)在zImage的最后+0x10000
mov r0, r5
mov r3, r7 //machine type
bl decompress_kernel
有了r5,r0,r7作为参数，就可以调用misc.c中的decompress_kernel函数进行解压缩了
这个函数调用的gunzip函数时gcc的库函数，所以在源码中找不到的
解压在r5开始的地方，函数返回的是r0解压得到的长度。这时候我们需要对代码经行调整
add r1, r5, r0 @ end of decompressed kernel
adr r2, reloc_start
ldr r3, LC1 //LC1: .word reloc_end - reloc_start
add r3, r2, r3
1: ldmia r2!, {r8 - r13} @ copy relocation code
stmia r1!, {r8 - r13}
ldmia r2!, {r8 - r13}
stmia r1!, {r8 - r13}
cmp r2, r3 //这里就把从reloc_start到reloc_end这段我们需要的代码放到了
blo 1b //解压内核的最后，而在下面我们会将zImage都覆盖掉
bl cache_clean_flush
add pc, r5, r0 //调到调整后的reloc_start，在decompressed kernel后
reloc_start: add r8, r5, r0 //r5解压内核开始的地方 r0解压内核的长度
debug_reloc_start
mov r1, r4 //r4=0x30008000
1:
.rept 4
ldmia r5!, {r0, r2, r3, r9 - r13} @ relocate kernel
stmia r1!, {r0, r2, r3, r9 - r13}
.endr

cmp r5, r8

blo 1b //这样就又把解压的真正内核移到了0x30008000处

call_kernel: bl cache_clean_flush

bl cache_off

mov r0, #0

mov r1, r7 @ restore architecture number

mov pc, r4 @ call kernel

上面就是跳到0x30008000这里去执行真正的内核了吧

2008-03-29T03:17:00.000+08:00

Linux 下透過 GPRS 上網

引用自: http://blog.linym.net/archives/171

基本需求：

可連上 GPRS 的硬體設備
編譯 Kernel 使其支援 PPP
擁有 pppd、chat 兩個程式
PPP 連線的 script 檔案

1. 可連上 GPRS 的硬體設備
可以是專用的 GPRS Modem 或是手機，不過當然要先配置好相關設定及驅動，我是使用 Wavecom Q2403A 這個 GSM/GPRS 模組透過 com port 來實驗。

2. 編譯 Kernel 使其支援 PPP
# make menuconfig
選擇 Device Drivers —> Network device support —> PPP (point-to-point protocol) support，底下的子項目如果不確定就全選即可。
核心更新後請檢查 /dev/ppp 是否存在，若無可用 mknod /dev/ppp c 108 0 建立。

3. 擁有 pppd、chat 兩個程式
如果是一般 PC 版本應該都已經有內建了；~~Embedded 平台則可以考慮使用 busybox，裡面也有包含這兩個程式；~~再不然就自行下載 source code 來編譯。

4. PPP 連線的 script 檔案
建立 script 來做 PPP 連線，通常可以在 /usr/share/doc/ppp/examples/scripts 底下找到 ppp-on、ppp-off、ppp-on-dialer 三個範例檔案，不過用範例檔的設定不一定能成功，請參考我的檔案，已測試中華電信可以成功。

相關的設定及原理可以參考：

Linux PPP HOWTO (另有中譯版)
Manually using GPRS

2008-03-29T03:16:00.000+08:00

移植KVM到arm-linux

引用自: http://tech.jayya.com/2007/11/28/porting-kvm-to-armlinux.html

上午kvm能正常在板子上运行了，并且还解决了preverify的问题（感谢一下陶老师的帮助和提醒），今天一并完整的写出来整个过程吧

建立交叉编译环境：

下载xscale-arm-linux-toolchain.tgz,tar zxfv xscale-arm-linux-toolchain.tgz,将解压后的文件在/usr/local/arm-linux下，将他击入当前的路径下，比如修改你的.bash_profile,PATH=$PATH:/usr/local/arm-linux/bin,退出，在登陆使之生效，输入arm -linux-gcc -v可以查看gcc的版本;
很抱歉，写得时候漏写了一个重要的设置步骤，多谢雨里来的提醒,现补充如下：我们还需要安装交叉编译环境的标准C函数库，进入系统的/usr/目录并解压库函数软件包
[user@host]# cd /usr
[user@host]# tar zvxf /root/gnupro-bin-glibc2.2.4.tgz
上述命令会在系统目录/usr/cygnus/xscale-020726/H-i686-pc-linux-gnulibc2.4/目录下建立一系列的子目录和文件，它们是交叉编译时需要的标准C函数库和各种工具。

下载sun的cldc的src

解压，里面包含有相关的源码。我这里使用了j2me_cldc-1_0_4-src-winunix.zip，j2me_cldc-1_1-fcs -src-winunix.zip这两个都可以在sun的网站下载，不过推荐大家抓紧时间下载，因为今天去下载midp2.0就已经不能下载了（sun 阿，令人失望！）。

安装jdk并设置后相关路径

这里不推荐使用jdk1.5，因为他对中文的支持有问题，使用1.4或者更低的都可以（希望可以在sun的官方找到）
我使用的是1.4.2_01。修改.bash_profile或者/etc/profile添加PATH或者CLASSPATH。这里说一些为什么要用到 jdk，主要是要编译api里面的java文件，当然我们只一致kvm就不需要这个了，详细地大家可以看看解开的文件cldc文件夹里面的make文件

修改make文件

进入j2me_cldc/kvm/VmUnix/build/，vi修改Makefile，主要修改将原来使用的x86的编译器GCC改为我们的 arm-linux-gcc，这样才能得到我们的所需，我主要是修改下面的句子：ifeq ($(GCC), true) CC =arm-linux-gcc，另外我又在文件的开始指定export PLATFORM=linux，当然你也可以在make的时候加参数PLATFORM=linux。

编译

先编译preverify，进入tools/preverfiyer/build/linux下，make，这里没有必要对这个makefile进行修改，况且你的编译平台是x86，应该不能进行修改，否则编译出来的preverify是不运行的，那么kvm的编译也将会不能通过。
编译kvm，进入kvm/VmUnix/build,make,就可以得到kvm,注意这个是在kvm的build目录下生成的,file kvm会的到以下信息:kvm: ELF 32-bit LSB executable, ARM, version 1 (ARM), for GNU/Linux 2.4.18, dynamically linked (uses shared libs), not stripped

在板子上运行并进行相应的测试

将得到的kvm,烧到板子上,x86下kvm运行所需文件： libm.so.6 => /lib/tls/libm.so.6 (0xb75c0000)
libnsl.so.1 => /lib/libnsl.so.1 (0xb75ab000)
libc.so.6 => /lib/tls/libc.so.6 (0xb7473000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0xb75eb000)
大家可以参考以下,以便能使板子环境符合要求.更改属性为a+x,运行kvm,没有任何参数的情况下将会出现以下信息:ALERT: Must provide class name
Usage: kvm < -options>
Options:
-version
-classpath
-heapsize (e.g. 65536 or 128k or 1M)

运行helloworld并正确使用preverify

这一步准确来说不是移植要做的事情,因为这是j2me开发者要注意的事情.我们先来看看kvm的执行.class 文件的机制:

如图示:我们javac编译完的生成的.class文件必须经过preverify预验证后才能被kvm正确的执行,否则会出现 java/class/Verifyerror,为什么要采用预验证机制,是因为sun考虑到嵌入式设备资源有限,所以将jvm的庞大字节码验证机制进行严重的”缩水”,也就用了一个轻量级机制
来保证安全.说了这么多,讲讲具体怎么使用(这个流程开发j2me程序的人应该都知道点,虽然大家都不常用这个来开发).
1编译javac -classpath kvm/classes hello.java 这里kvm/classes指你编译生成的classes文件夹
2预验证preverify -classpath kvm/classes -d . mydir
preverify有几个参数: -classpath 同上 -d 输出验证后的class文件,默认的是当前目录下的output文件夹下,还有检测是否使用了 finalizers ,float,native methods等
将检验后的classs文件放到板子上,就可以执行了!

CLDC 1.0.4 Fix for Red_Hat

引用自: http://forum.java.sun.com/thread.jspa?threadID=468349

The following works for J2ME CLDC 1.1 (it may be the same for 1.0.4, I didn't try that).

If you don't care to verify that you are having the same problem, skip ahead a bit to what I did to fix the problem I was having.

Rebuild the kvm with debugging on. Goto the j2me_cldc/build/linux directory
edit Makefile around the 4th line add a line that says "export DEBUG=true"
If you have previously run make then do "make clean" then "make"

Im assuming your PATH and CLASSPATH are set appropriately so you can simply prevreify a class by typing "preverify HelloWorld" and you see "Segmentation fault"

At this point run "preverify -verbose HelloWorld" and you will see that it is indeed running and loading classes but it craps out after a few classes.

To run the debugger on this type "gdb --args preverify HelloWorld"
at the (gdb) prompt type "run". You will see
"Program received signal SIGSEGV, Segmentation fault."
Type bt (or backtrace) in the debuger. If you see something like this

#0 0x4207c1ac in memcpy () from /lib/tls/libc.so.6
#1 0x080520ef in utf2native ()
#2 0x0805b9ab in Locked_InitializeClass ()
...

then you either didn't get the "export DEBUG=true" part right or your didn't "make clean" or something else happened. You should see something more like this (more detail):

#0 0x4207c1ac in memcpy () from /lib/tls/libc.so.6
#1 0x080520ef in utf2native (from=0x8069740 "?_006b", to=0xbfff6ba0 "",
buflen=-1073779800) at ../../src/convert_md.c:100
#2 0x0805b9ab in Locked_InitializeClass (cb=0x8069740, detail=0xbfff6ba0)
at ../../src/classresolver.c:685
#3 0x0805b57a in InitializeClass (cb=0x8069740, detail=0xbfff6ba0)
at ../../src/classresolver.c:506
#4 0x0805c2af in InitializeAndResolveClass (cb=0x8069740, resolve=FALSE)
at ../../src/classresolver.c:991
...

what this is telling you is that the glibc memcpy function is where the segfault happened. memcpy is trying to copy memory but it looks like the buffer length (buflen) is bogus. memcpy is called from utf2native which is called by Locked_InitializerClass in classresolver.c

Quit the debugger (“quit”). Goto j2me_cldc/tools/preverifier/src/

Look at the file classresolver.c, at the Locked_InitializerClass function, around line 572. See the lines

char buff[BUFSIZ];
char *nativeName = &buff[0];

remember them. Look down to line 685, see the lines

utf2native(cbSuperName(cb), nativeName, BUFSIZ);
super = FindClassFromClass(ee, nativeName, FALSE, cb);

Nowehere else in classresolver.c is this buff or *nativeName used (so Im assuming we are free to mess with without significantly impacting anything else). What this is doing is creating a buffer on the stack that is BUFSIZ big (8192 bytes). utf2native gets the buffer and size and calls memcpy. Im guessing that because the preverifier seems to be loading classes recursively that there are lots of buffers like this on the stack hanging around and Im running out of stack space which results in a segmentation fault. I don’t know why EVERYONE running linux doesn’t have this problem.

How to fix this? We are now going to change the program to put the buffer in dynamic memory not on the stack.

In classresolver.c, around line 572, change the buff and nativeName declarations to this (comment out the old ones, put in new ones):

//char buff[BUFSIZ];
//char *nativeName = &buff[0];
char *buff;
char *nativeName;

The skip down to around line 685. Add a few lines around the call to utf2native to look like this:

buff = (char*)malloc(BUFSIZ);
if (buff == NULL)
fprintf( stderr, "Bogus, malloc failed." );
nativeName = buff;

utf2native(cbSuperName(cb), nativeName, BUFSIZ);
super = FindClassFromClass(ee, nativeName, FALSE, cb);

free(buff);

We added 4 lines before the utf2native call and the free(buff) after it. What we are doing is allocating dynamic memory for the buffer (not on the stack this time) and freeing it right after we are done with it.

Save your work. Now "make clean" and "make". When you try to run the preverifier, turn on -verbose. You will get the preverifier to run a little further but it may still die with a segmentation fault, this time in a different place, same problem. I found four c files that declare and use buff[BUFSIZ] (classloader.c, classresolver.c, file.c and jar_support.c). I also found that if you have your CLASSPATH is set to point to the j2me_cldc/api/classes directory or j2me_cldc/api/classes.zip file you will get the same error but different calling functions. My CLASSPATH originally pointed to the classes directory and the classloader.c and classresolver.c were crapping out. I switched to having the CLASSPATH point to the classes.zip file and then the jar_support.c functions were the problem. I fixed all 4 just to be sure. Im not guaranteeing this will solve your problem. But it solved mine.

Dan

2008-02-12T14:11:00.000+08:00

ArmLinux 課程大綱 (PXA-270)

*新華電腦開課資訊: http://www.microtime.com.tw/training/ARM/9504/9604.htm

Linux 操作與系統建置篇(9:00～16:00；6 小時)
1. Linux 簡介

A. Linux 基本操作 (含實機操作)

2. Embedded Linux 系統架構
3. Embedded Linux 核心組態
4. Embedded Linux 檔案系統規劃
A. Virtual PC下建置 Embedded Linux(含實機操作)
B. 透過 Domingo debugger開發環境下載 Embedded Linux (含實機操作)

C. NFS (含實機操作)

D. MTD (含實機操作)

5. Linux 應用程式環境

A. Java Virtual Machine in Linux (含實機操作)

B. pppd (含實機操作)

Linux 程式開發篇(9:00～16:00；6小時)

1. Embedded Linux 開發環境

A. Kbuild System for Kernel

B. Auto Make System for Application

2. Embedded Linux 核心原始碼架構

3. Embedded Linux 核心初始化分析

A. 以 ICE 除錯核心(含實機操作)

4. Linux 應用程式設計

A. Memory Management (含實機操作)

B. File access (含實機操作)

B. Process (含實機操作)

C. Thread (含實機操作)

D. IPC (含實機操作)

5. 應用程式共享程式庫
A. 以MP3 Decoder程式庫為例 (含實機操作)
6. Linux 應用程式除錯工具

A. 以 GDB 除錯應用程式(含實機操作)
B. 記憶體配置除錯(memwatch/YAMD) ( 含實機操作)
C. 系統呼叫追蹤 (strace) (含實機操作)

基本驅動程式開發篇(9:00～16:00；6小時)
1. Linux 核心模組架構
A . 建置與設定核心模組 (含實機操作)
2 Linux 驅動程式架構
A. 建置與設定驅動程式( 含實機操作)
3. Linux 驅動程式除錯工具
A. 列印訊息法(printk) (含實機操作)
B. 訊息紀錄 (Klogd/syslogd) ( 含實機操作)
C. 查詢除錯法(proc) ( 含實機操作)
4. Linux 字元類型驅動程式
A. 以LED & DIP Switch & Key 為例( 含實機操作)

B. Interrupt

C. Task Queue

D. Memory management

進階驅動程式開發篇(9:00～ 16:00；6小時)
1. LCD 驅動程式
A. 以LCD控制IC為例(含實機操作)
B. Frame Buffer 架構

2. Audio Driver 架構
3. 串列埠控制
A. 以Termios UART 控制為例 (含實機操作)

B. 控制台架構 (Console Architecture)

4. USB 驅動程式架構
5. PCI 驅動程式架構
6. Linux 區塊類型驅動程式
A. 以RAM Disk為例 (含實機操作)

網路應用開發篇(9:00～ 16:00；6小時)
1. Linux 網路類型驅動程式
2. 網路應用程式設計
A. 以聊天程式為例(含實機操作)
3. 利用 Embedded Linux 設置網路服務
A. Telnetd建置 (含實機操作)
B. Web Server 建置( 含實機操作)
4. CGI 程式設計
A. 以CGI 程式控制LED(含實機操作)

2008-01-05T21:40:00.000+08:00

有趣的主題

Linux Package

Packman: http://packman.links2linux.org/ : 此網站存放 Suse Linux 軟體套件，讓使用者能很輕易地安裝與移除軟體。
LinuxToy: http://linuxtoy.org/

Ericsk 的 Ubuntu 筆記: http://blog.xuite.net/ericsk0313/ubuntu

Ericsk 的個人網站: http://blog.ericsk.org/

阿駕零零壹 © 學習筆記: http://twntwn.info/blog/ajer001

Linux 的粉絲衝上浪頭 2.0: http://blog.ilc.edu.tw/blog/blog/673/

Device Driver

The GNU/Linux "usbnet" Driver Framework: http://www.linux-usb.org/usbnet/

JVM

Java Midlets Tutorial (PocketPC): http://www.pocketpcmag.com/blogs/index.php?blog=3&p=644&more=1&c=1&tb=1&pb=1
JVMs, JDKs and JREs: http://java-virtual-machine.net/other.html

Network

Boa + PHP for uClinux: http://www.menie.org/georges/uClinux/boa-php.html

PHP for IIS: http://blog.raienet.com/188?TSSESSION=5d9fb85e5c0162885e12924128ef1838

Web Page Editor

AceHTML: http://software.visicommedia.com/en/products/acehtmlfreeware/
HomeSite: http://www.adobe.com/products/homesite/
NotePad++: http://notepad-plus.sourceforge.net/tw/site.htm
EditPlus: http://www.editplus.com/
Crimson: http://www.crimsoneditor.com/

Forum

大鳥的實驗室: http://www.armlabs.com/phpBB2/viewforum.php?f=7

2007-12-30T22:05:00.000+08:00

ArmLinux 相關網站

Linux Kernel 相關網站

The Linux Kernel Archives: http://www.kernel.org/
The ARM Linux Project: http://www.arm.linux.org.uk/
The Familiar Project: http://familiar.handhelds.org/
IPAQ Linux Project: http://www.ipaqlinux.com/

arm-linux-gcc 下載網站

ARM Linux: ftp://ftp.arm.linux.org.uk/pub/armlinux/toolchain/ (Version 2.95.3, 3.0, 3.2)
Handhelds.org: ftp://ftp.handhelds.org/projects/toolchain/ (Version 3.3.2, 3.4.1)
ELDK 4.1: ftp://ftp.denx.de/pub/eldk/4.1/ (Version 4.0.0)
GNU ARM: http://www.gnuarm.org/ (Version 4.0, 4.1, 4.2)

發展工具相關網站

GCC ARM Improvement Project: http://www.inf.u-szeged.hu/gcc-arm/
GNU GCC Source: ftp://ftp.gnu.org/gnu/gcc/

系統建置

Linux from Scratch: http://lamp.linux.gov.cn/Linux/LFS-6.2/index.html
GNU Make Manual: http://www.gnu.org/software/make/manual/
鳥哥的Linux私房菜: http://linux.vbird.org/

討論區

Banto Linux Forum in Google Group: http://groups.google.com.tw/group/banto-linux/?msg=new&lnk=gcis&hl=zh-TW

2007-12-30T21:24:00.000+08:00

ArmLinux 相關書籍

*本課程參考與推薦使用下列書籍:

應用程式設計

Linux 程式設計教學手冊 (基峰)

如果您已經有些許程式設計經驗，而且想要加入Linux程式設計的領域，這本最暢銷的入門書籍就是您所需要的。第三版新增的內容有MySQL的存取和管理、設計GNOME和KDE程式、在Linux標準下設計可攜性的應用程式。本書新增的內容還有核心的程式設計、設備驅動程式、CVS、grep、 GUI開發環境。作者利用一個CD資料庫管理應用程式一步步引導您，讓您得以由簡而繁的學習Linux程式設計。您將從最基本的概念（設計Linux C程式）起步。進而學習到基本的系統呼叫、檔案輸出和輸入、處理程序之間的通訊和shell設計。您也將學到一些使用者介面的開發工具和函式庫。本書從編譯和執行第一個程式的基礎起步。文中都會先說明基本的觀念，隨後再以實作程式範例，指引您將知識應用到真實的應用程式上。

系統建置

Linux 技術手冊 (歐萊禮)

不論你是第一次安裝，還是已經使用 Linux 多年，而現在想要知道多一點關於如何添加網路印表機或設定 ADSL 連線，這本《Linux 技術手冊》（Running Linux）正是你不可或缺的手冊。各種設定上經常令人困擾的疑難雜症，在其它書上鮮少被提及者，本書中都有令你滿意的解答，所以在 Linux 使用族群中本書被公認是入門最佳的參考書。

舉凡要理解、安裝與開始使用 Linux 系統所需的一切知識，在這本《Linux 技術手冊》中皆有涵蓋。本書並不刻意強調 OS、shell、GUI，甚至重要應用程式之間的分野；由於本書的作者都是一些經驗老道的 Linux 熱愛者，他們早就設想到讀者可能會遭遇的問題所在，已為你選擇好穩健且通行的解決方案，並且提供詳盡的討論說明及指引，讓你能夠很愜意的使用 Linux。書中的討論說明儘求明確與完整，不但初學者可以得到清楚的方向，有經驗的使用者也可從中吸取許多新知，對其 Linux 功力的精進將有很大助益。

對任何 Linux 的使用者來說，這都是一本札實的入門手冊；此外，本書中還包括許多的參考資源，可以因應由於各種硬體配備、進階應用，以及陸續出現的新科技所帶來的特殊需求。無論是家用電腦工作站的 Linux 使用者，或是負責維護網路伺服器的系統管理員，當有需要的時候，《Linux 技術手冊》隨時都可以為你提供最專業的建言。

Linux 網路管理 (歐萊禮)

Linux 是最受歡迎的網路作業系統，也是最受歡迎的伺服器平台。本書示範如何使用 Linux 系統架設各種網路伺服器，並提供許多關於管理上的建議。本書涵蓋的題材，從基本的網路介面設定工作開始，TCP/IP 協定的基本觀念、閘道器的設計、如何搭建 PPP 連線、DNS server 的架設與管理、IP 防火牆的設置、電子郵件系統的架設與管理、OpenLDAP、Apache、Samba 伺服器的管理，甚至新興的無線網路與 IPv6。除了實務上的指導，每一章都提供適度的背景知識，讓讀者有能力進行更深度的研究。

建構嵌入式 Linux 系統 (歐萊禮)

《建構嵌入式Linux系統》是第一本深入探討基於Linux核心之嵌入式系統的指南。對想要瞭解如何將Linux應用在嵌入式系統中而不得要領的讀者來說，這是一本不可或缺的書。本書詳細的探討了各種目標板架構以及硬體組態，並且徹底的檢視了Linux對嵌入式硬體的支援。

書中所有說明都是以開放原碼及自由軟體套件的使用為依據。本書會告訴你如何從頭開始建立作業系統元件，以及如何找到更多的文件或協助，因此不論你是基於技術上或經濟上的考量而採用Linux，本書都能輕易地讓你全盤掌控嵌入式作業系統。

驅動程式設計

Linux 驅動程式 (歐萊禮)

詳論設計 Linux 驅動程式的各種技術。
探討 Linux 核心內部運作的各種相關細節。
設計驅動程式所需的各種 API 之參考手冊。

ARM 架構

ARM 系統開發者指南 (全華)

本書從軟體設計的角度，全面、而有系統的介紹ARM處理器基本族系架構和軟體設計與最佳化方法。內容包括：ARM處理器基礎；ARM/Thumb指令集； C與組合語言程式的設計與最佳化；基本運算、操作的最佳化；基於ARM的DSP；異常與中斷處理；韌體與嵌入式OS；Cache與記憶體管理；ARMv6 架構的特點等。全書內容完整，針對各種不同的ARM核心架構都有詳盡論述，並有大量的範例和原始程式碼。附錄部分提供了完整的 ARMv4/v5/Thumb指令的功能、編碼、時序週期，以及組合語言參考。

深入了解用書

Linux 核心詳解 (歐萊禮)

為了全面瞭解是什麼讓 Linux 起作用，以及為什麼 Linux 能在各種系統上運作得那麼好，你必須對核心有深入的瞭解。核心會處理 CPU 和外面世界的所有互動，決定哪些行程可以共用處理器時間，以及它們的使用次序。核心把有限的記憶體管理得很好，讓上百個行程能以有效率的方式共用系統。核心以巧妙的方式安排資料的傳輸，使得 CPU 再也不用等待速度緩慢的硬碟存取。

　　本書要帶領你瞭解，核心中最重要的資料結構、演算法以及程式設計技巧。探索核心功能背後的真相時，對那些想瞭解自己的機器究竟是怎麼運作的讀者，作者提出了寶貴的見解。本書會討論 Intel 特有的重要功能，也會逐一解析相關的程式片段。但是，本書不只談論程式的作用而已，也會說明 Linux 之所以這麼運作的理論基礎。

Linux 網路原理 (歐萊禮)

Linux受歡迎的部分原因是，它擁有效率高且功能豐富的網路疊層。如果你想知道Linux如何利用IP協定把複雜的任務搞定，或者只想透過真實的案例來瞭解現代網路的功能，《Linux 網路原理》就是你的指南。

Linux 系統管理 (歐萊禮)

　　對經驗老道、想學習Linux技巧的系統管理員，以及面對新挑戰的資深Linux用戶而言，本書提供管理各種系統和伺服器的建言。本書總結了一些必要的步驟，幫助你建立獨立式SOHO Hub、網站伺服器、LAN伺服器所組成的負載平衡叢集、以及透過虛擬化方式合併的伺服器。另外，你也會學到設立和維護這些工作環境所需的工具。

　　本書可作為Unix老兵、MCSE、以及大型電腦管理員的Linux簡介，也可作為現職Linux管理員補充和提昇技巧的進階指南。在本書中，你會學到：

．安裝、組態、維護、以及對DNS伺服器除錯﹙使用BIND﹚。
．為中小型公司設立電子郵件服務，並具備完整的認證機制。
．從頭開始在網站伺服器上安裝和組態Apache、PHP、以及MySQL。
．利用免費的Linux Virtual Server結合一些電腦，組成負載平衡的Apache網站伺服器叢集。
．透過Xen或VMWare運用Linux虛擬化，在一件硬體上執行多個核心；管理每個核心對處理器時間、設備、以及記憶體的存取。
．建立命令稿，按你的需求做調整。
．使用rsync、tar、cdrecord、Amanda、及MySQL工具，備份和回存資料。

2007-11-24T07:22:00.000+08:00

gprof

gprof thread

vmstat

top

2007-11-24T07:21:00.001+08:00

Memory Leak

Valgrind

mtrace

2007-11-24T07:21:00.000+08:00

Backtrace

2007-11-24T07:17:00.000+08:00

GDB advanced

Debug Process

Debug Thread

Debug Signal

2007-06-30T15:14:00.000+08:00

USB DISK

2007-05-25T20:34:00.000+08:00

Linux 系統設定檔

inittab

/etc/inittab

init 的腳本
呼叫初始化硬體的腳本 /etc/rc.d/rc.sysinit
呼叫初始化系統參數的腳本 /etc/init.d/rcS
啟動 bash

/etc/rc.d/rc.sysinit

初始化硬體

/etc/rc.d/rc.modules

網路驅動程式在此啟動

/etc/init.d/rcS

初始化系統參數

/etc/init.d/umountfs

copy kernel...OK

copy rootfs...OK
Uncompressing Linux................................................ done, booting the kernel.
Linux version 2.4.18-rmk7-swl8 (root@MDS-Linux-01) (gcc version 2.95.3 20010315 (release)) #3 三 10月 27 14:02:49 CST 24
CPU: SAMSUNG S3C2410(Arm920T)sid(wb) revision 0
Machine: create ARM920T-S3C2410
On node 0 totalpages: 16384
zone(0): 16384 pages.
zone(1): 0 pages.
zone(2): 0 pages.
Kernel command line: root=/dev/ram0 console=ttyS0
Calibrating delay loop... 101.37 BogoMIPS
Memory: 64MB = 64MB total
Memory: 52600KB available (1299K code, 286K data, 44K init)
Dentry-cache hash table entries: 8192 (order: 4, 65536 bytes)
Inode-cache hash table entries: 4096 (order: 3, 32768 bytes)
Mount-cache hash table entries: 1024 (order: 1, 8192 bytes)
Buffer-cache hash table entries: 4096 (order: 2, 16384 bytes)
Page-cache hash table entries: 16384 (order: 4, 65536 bytes)
POSIX conformance testing by UNIFIX
Linux NET4.0 for Linux 2.4
Based upon Swansea University Computer Society NET3.039
Initializing RT netlink socket
Starting kswapd
JFFS version 1.0, (C) 1999, 2000 Axis Communications AB
JFFS2 version 2.1. (C) 2001 Red Hat, Inc., designed by Axis Communications AB.
l3 S3C2410 Adapter Initialized
ttyS0 at MEM 0xe0000000 (irq = 52) is a S3C2410
ttyS1 at MEM 0xe0004000 (irq = 55) is a S3C2410
pty: 256 Unix98 ptys configured
Installing S3C2410 RTC
S3C Real Time Clock driver v1.00
block: 128 slots per queue, batch=32
RAMDISK driver initialized: 16 RAM disks of 8192K size 1024 blocksize
loop: loaded (max 8 devices)
S3C2410 UDA1341 / IIS initialized
usb.c: registered new driver hub
usb-ohci.c: USB OHCI at membase 0xd9000000, IRQ 26
usb.c: new USB bus registered, assigned bus number 1
hub.c: USB hub found
hub.c: 2 ports detected
NET4: Linux TCP/IP 1.0 for NET4.0
IP Protocols: ICMP, UDP, TCP
IP: routing cache hash table of 512 buckets, 4Kbytes
TCP: Hash tables configured (established 4096 bind 4096)
NET4: Unix domain sockets 1.0/SMP for Linux NET4.0.
NetWinder Floating Point Emulator V0.95 (c) 1998-1999 Rebel.com
RAMDISK: ext2 filesystem found at block 0
RAMDISK: Loading 8192 blocks [1 disk] into ram disk... done.
Freeing initrd memory: 10240K
VFS: Mounted root (ext2 filesystem).
Freeing init memory: 44K
INIT: version 2.78 booting
eth0: cs8900 rev K(3.3 Volts) found at 0xf0000300
cs89x0 media RJ-45, IRQ 37
INIT: Entering runlevel: 2
EXT2-fs: Unrecognized mount option
EXT2-fs: Unrecognized mount option
mount: / not mounted already, or bad option
Starting Network
bash-2.04#

2007-05-19T11:02:00.000+08:00

建構 Insight 6.1

V1.2

email: mesmerli@hotmail.com

什麼是 Insight?

本文主要介紹如何建構搭配 ARM 處理器的應用程式除錯工具。

Insight 是一個可以搭配 gdbserver 的圖形化除錯工具。

建構 Insight 6.1

解壓縮 insight 6.1 所有原始碼到一個檔案夾，

接下來，在該檔案夾下建立以下檔案夾

insight-arm-linux-6.1
gdbserver-arm-6.1.

完畢後，檔案夾結構應如下所示:

./gdbserver-arm-6.1 (empty)
./insight-6.1 (the source tree)
./insight-arm-linux-6.1 (empty)

進入 insight-arm-linux-6.1 檔案夾下使用下面的命令建構 Insight 主程式

# cd /usr/src/creator/nfs/Day1/insight-6.1/insight-arm-linux-6.1
# ../insight-6.1/configure --host=i686-pc-linux --target=arm-linux --prefix=/usr/local/insight-arm-6.1 --enable-sim

# make
# make install

接下來，進入 gdbserver-arm-6.1 檔案夾建構 gdbserver

ARM 版本須進行以下修改:

修改 linux-arm-low.c

1. vi ../insight-6.1/gdb/gdbserver/linux-arm-low.c

2. remark #include <sys/reg.h> in line 26

# ../insight-6.1/gdb/gdbserver/configure --target=arm-linux

Note:

修改 Make File

1. vi Makefile

2. change gcc to arm-linux-gcc in line 52

# make

使用Insight 與 gdbserver 除錯

在 gdbserver-arm-6.1 目錄夾找到 "gdbserver"，並把它放到您的實驗板檔案系統中。
重新編譯您的應用程式，並且使用 -ggdb 選項重新編譯。
啟動您的實驗板，並使用以下的命令在實驗板執行應用程式
# gbdserver <your PC TCP/IP address>:<2345 or your port> <your program> <your arguments>
在 Host 端執行 Insight。 /usr/local/insight-arm-6.1/bin/arm-linux-insight
在 Insight 圖形介面，依下面說明操作

在 "File" -> "Target settings" 選單設定以下選項

Connection:
Target: GDBserver/TCP
Hostname:
Port: 2345 (or any free port you want)

展開 "More options"，
Run Options:
[x] Attach to Target
[ ] Download program

Run Method:
< > Run program
<x>Continue from last stop

在 global options 中，確認 "Set breakpoint at main" 被選取。

在 Insight選單中選擇"run"->"Run"，並選擇 ARM program binary。
gdbserver 此時應已與 Insight 連線，所以此時可使用 Insight 除錯實驗板上的應用程式。

後記

gdbserver只適合除錯應用程式，無法除錯 Linux 核心或核心模組 (Kernel Module)。
如不想使用圖形化介面，亦可使用 GDB 文字模式除錯。

2007-05-18T07:05:00.000+08:00

串列埠控制

V1.0

email: mesmerli@hotmail.com

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <termios.h>
#include <fcntl.h>

const char *com2 = "/dev/ttyS1";
static struct termios newtios, oldtios; // terminal settings
static int saved_portfd = -1; // serial port fd

// cleanup atexit handler
static void reset_tty_atexit(void)
{
if(saved_portfd != -1) {
tcsetattr(saved_portfd, TCSANOW, &oldtios);
}
}

// cleanup signal handler
static void reset_tty_handler(int signal)
{
if(saved_portfd != -1) {
tcsetattr(saved_portfd, TCSANOW, &oldtios);
}
_exit(EXIT_FAILURE);
}

static int open_port(const char *portname)
{
struct sigaction sa;
int portfd;

printf("opening serial port: %sn", portname);

// open serial port
if((portfd = open(portname, O_RDWR|O_NOCTTY)) < 0) {
printf("open serial port %s failn", portname);
return portfd;
}

// get serial port parameters, save away
tcgetattr(portfd, &newtios);
memcpy(&oldtios, &newtios, sizeof newtios);

// 115200 bps
cfsetospeed(&newtios, B115200);
cfsetispeed(&newtios, B115200);

// register cleanup stuff
atexit(reset_tty_atexit);
memset(&sa, 0 , sizeof sa);
sa.sa_handler = reset_tty_handler;
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGPIPE, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);

// apply modified termios
saved_portfd = portfd;
tcflush(portfd, TCIFLUSH);
tcsetattr(portfd, TCSADRAIN, &newtios);

return portfd;
}

static void close_port(int portfd)
{
tcsetattr(portfd, TCSANOW, &oldtios);
close(portfd);
saved_portfd = -1;
}

int main(int argc, char *argv[])
{

fd_set fds;
int portfd;
int retval;
unsigned char c;

if((portfd = open_port(com2)) < 0)
return -1;

while(1) {
FD_ZERO(&fds);
FD_SET(portfd, &fds);

retval = select(portfd+1, &fds, NULL, NULL, NULL);
if(FD_ISSET(portfd, &fds)) {
if(read(portfd, &c, 1) == 1)
putchar(c);
}
fflush(NULL);
}
return 0;
}

UART driver (serial_s3c2410.c)

/*
* linux/drivers/char/serial_mx1ads.c
*
* Driver for Samsung S3C2410's internal serial ports (UART0 & UART1)
*
* Copyright (C) 2002 Steve Hein, SGI Inc. (ssh@sgi.com)
* Cho, Hyun-ho <firebird@legend.co.kr> corrected baudrate config.
*
* Adapted from:
*
* Driver for MX1s' dual serial ports.
*
* Based on drivers/serial/serial_amba.c
*
*
* Copyright 1999 ARM Limited
* Copyright (C) 2000 Deep Blue Solutions Ltd.
* Copyright (C) 2002 Shane Nay (shane@minirl.com)
*
* 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
*
*
* Based on the AMBA driver, this is a driver for the S3C2410 boards
* UARTs.
*/
#include <linux/config.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/fcntl.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/circ_buf.h>
#include <linux/serial.h>
#include <linux/console.h>
#include <linux/sysrq.h>

#include <asm/system.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/bitops.h>

#if defined(CONFIG_SERIAL_S3C2410_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
#define SUPPORT_SYSRQ
#endif

#include <linux/serial_core.h>

#include <asm/hardware/serial_s3c2410.h>

#define UART_NR 2

#define MINOR_START 64

#define SERIAL_S3C2410_NAME "ttyS"
#define SERIAL_S3C2410_MAJOR TTY_MAJOR
#define SERIAL_S3C2410_MINOR MINOR_START
#define SERIAL_S3C2410_NR UART_NR

#define CALLOUT_S3C2410_NAME "cuas"
#define CALLOUT_S3C2410_MAJOR 205
#define CALLOUT_S3C2410_MINOR MINOR_START
#define CALLOUT_S3C2410_NR UART_NR

static struct tty_driver normal, callout;
static struct tty_struct *s3c2410_table[UART_NR];
static struct termios *s3c2410_termios[UART_NR], *s3c2410_termios_locked[UART_NR];
#ifdef SUPPORT_SYSRQ
static struct console s3c2410_console;
#endif

#define S3C2410_ISR_PASS_LIMIT 256

/*
* Access macros for the S3C2410 UARTs
*/

#define UART_GET_CHAR(p) __raw_readb((p)->membase + S3C2410_UARTRXH0_OFF)
#define UART_PUT_CHAR(p,c) __raw_writeb((c), (p)->membase + S3C2410_UARTTXH0_OFF)

#define UART_GET_ULCON(p) __raw_readl((p)->membase + S3C2410_UARTLCON_OFF)
#define UART_GET_UCON(p) __raw_readl((p)->membase + S3C2410_UARTCON_OFF)
#define UART_GET_UFCON(p) __raw_readl((p)->membase + S3C2410_UARTFCON_OFF)
#define UART_GET_UMCON(p) __raw_readl((p)->membase + S3C2410_UARTMCON_OFF)
#define UART_GET_UBRDIV(p) __raw_readl((p)->membase + S3C2410_UARTBRDIV_OFF)

#define UART_GET_UTRSTAT(p) __raw_readl((p)->membase + S3C2410_UARTTRSTAT_OFF)
#define UART_GET_UERSTAT(p) __raw_readl((p)->membase + S3C2410_UARTERSTAT_OFF)
#define UART_GET_UFSTAT(p) __raw_readl((p)->membase + S3C2410_UARTFSTAT_OFF)
#define UART_GET_UMSTAT(p) __raw_readl((p)->membase + S3C2410_UARTMSTAT_OFF)

#define UART_PUT_ULCON(p,c) __raw_writel(c, (p)->membase + S3C2410_UARTLCON_OFF)
#define UART_PUT_UCON(p,c) __raw_writel(c, (p)->membase + S3C2410_UARTCON_OFF)
#define UART_PUT_UFCON(p,c) __raw_writel(c, (p)->membase + S3C2410_UARTFCON_OFF)
#define UART_PUT_UMCON(p,c) __raw_writel(c, (p)->membase + S3C2410_UARTMCON_OFF)
#define UART_PUT_UBRDIV(p,c) __raw_writel(c, (p)->membase + S3C2410_UARTBRDIV_OFF)

/* When using the integer divisor for the UART,
* we must set the IR to 0xf prior to programming
* the divisor
*/

#define UART_RX_DATA(s) (((s) & S3C2410_UTRSTAT_RXDR) == S3C2410_UTRSTAT_RXDR)
#define UART_TX_READY(s) (((s) & S3C2410_UTRSTAT_TXFE) == S3C2410_UTRSTAT_TXFE)
#define TX_FIFOCOUNT(port) (((UART_GET_UFSTAT(port))>>4)&0xf)

#define TX_IRQ(port) (port->irq + 1)
#define RX_IRQ(port) (port->irq)

#define UART_DUMMY_RSR_RX 256
#define UART_PORT_SIZE 64

/*
* Our private driver data mappings.
*/

#define drv_old_status driver_priv

static void
s3c2410uart_stop_tx(struct uart_port *port, u_int from_tty)
{
disable_irq(TX_IRQ(port));
}

static void
s3c2410uart_start_tx(struct uart_port *port, u_int nonempty, u_int from_tty)
{
if (nonempty) {
enable_irq(TX_IRQ(port));
}
}

static void
s3c2410uart_stop_rx(struct uart_port *port)
{
disable_irq(RX_IRQ(port));
}

static void
s3c2410uart_enable_ms(struct uart_port *port)
{
/* What is MS? */
}

static void
#ifdef SUPPORT_SYSRQ
s3c2410uart_rx_chars(struct uart_info *info, struct pt_regs *regs)
#else
s3c2410uart_rx_chars(struct uart_info *info)
#endif
{
struct tty_struct *tty = info->tty;
unsigned int status, ch, max_count = 256;
struct uart_port *port = info->port;

status = UART_GET_UTRSTAT(port);
while (UART_RX_DATA(status) && max_count--) {
if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
tty->flip.tqueue.routine((void *) tty);
if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
printk(KERN_WARNING "TTY_DONT_FLIP setn");
return;
}
}

ch = UART_GET_CHAR(port);

*tty->flip.char_buf_ptr = ch;
*tty->flip.flag_buf_ptr = TTY_NORMAL;
port->icount.rx++;
tty->flip.flag_buf_ptr++;
tty->flip.char_buf_ptr++;
tty->flip.count++;
/* No error handling just yet.
* On the MX1 these are seperate
* IRQs, so we need to deal with
* the sanity of 5 IRQs for one
* serial port before we deal
* with the error path properly.
*/
status = UART_GET_UTRSTAT(port);
}
tty_flip_buffer_push(tty);
return;
}

static void
s3c2410uart_tx_chars(struct uart_info *info)
{
struct uart_port *port = info->port;
int count;

if (port->x_char) {
UART_PUT_CHAR(port, port->x_char);
port->icount.tx++;
port->x_char = 0;
return;
}
if (info->xmit.head == info->xmit.tail
|| info->tty->stopped || info->tty->hw_stopped) {
s3c2410uart_stop_tx(port, 0);
return;
}

count = port->fifosize - TX_FIFOCOUNT(port);
do {
UART_PUT_CHAR(port, info->xmit.buf[info->xmit.tail]);
info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1);
port->icount.tx++;
if (info->xmit.head == info->xmit.tail)
break;
} while (--count > 0);

if (CIRC_CNT(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE) <
WAKEUP_CHARS)
uart_event(info, EVT_WRITE_WAKEUP);

if (info->xmit.head == info->xmit.tail)
s3c2410uart_stop_tx(info->port, 0);
}

static void
s3c2410uart_modem_status(struct uart_info *info)
{
/*
* Not currently supported.
*
*/
}

static void
s3c2410uart_int(int irq, void *dev_id, struct pt_regs *regs)
{
struct uart_info *info = dev_id;
unsigned int status;
status = UART_GET_UTRSTAT(info->port);
if(irq==(TX_IRQ(info->port))) {
if (UART_TX_READY(status))
s3c2410uart_tx_chars(info);
}

if (UART_RX_DATA(status)) {
#ifdef SUPPORT_SYSRQ
s3c2410uart_rx_chars(info, regs);
#else
s3c2410uart_rx_chars(info);
#endif
}
}

static u_int
s3c2410uart_tx_empty(struct uart_port *port)
{
return UART_GET_UTRSTAT(port) & S3C2410_UTRSTAT_TXFE ? TIOCSER_TEMT : 0;
}

static u_int
s3c2410uart_get_mctrl(struct uart_port *port)
{
/* Not currently supported */
return 0;
}

static void
s3c2410uart_set_mctrl(struct uart_port *port, u_int mctrl)
{
/* Not currently supported */
}

static void
s3c2410uart_break_ctl(struct uart_port *port, int break_state)
{
unsigned long ucon=UART_GET_UCON(port);
if (break_state==-1)
ucon |= S3C2410_UCON_SBREAK;
else
ucon &= ~S3C2410_UCON_SBREAK;
UART_PUT_UCON(port,ucon);
}

static int
s3c2410uart_startup(struct uart_port *port, struct uart_info *info)
{

int retval;
/*
* Allocate the IRQ
*/
retval = request_irq(RX_IRQ(port), s3c2410uart_int, 0, "s3c2410uarx", info);
if (retval)
return retval;
retval = request_irq(TX_IRQ(port), s3c2410uart_int, 0, "s3c2410uatx", info);
if (retval)
return retval;

UART_PUT_UCON(port, S3C2410_UCON_DEFAULT);
UART_PUT_UFCON(port, S3C2410_UFCON_DEFAULT);
UART_PUT_UMCON(port, 0);

/* printk("PORT 0x%08X ULCON 0x%08X UCON 0x%08X UFCON 0x%08X UMCON 0x%08X n",
port->membase, UART_GET_ULCON(port), UART_GET_UCON(port),
UART_GET_UFCON(port), UART_GET_UMCON(port));
*/

// UART_PUT_UBRDIV(port,(int)(PCLK/CURRENT_BAUD_RATE*16))-1);
return 0;

}

static void
s3c2410uart_shutdown(struct uart_port *port, struct uart_info *info)
{
/*
* Free the interrupt
*/

free_irq(RX_IRQ(port), info);
free_irq(TX_IRQ(port), info);
}

static void
s3c2410uart_change_speed(struct uart_port *port, u_int cflag, u_int iflag,
u_int quot)
{
unsigned long flags, lcon;
#if DEBUG
printk("s3c2410uart_set_cflag(0x%x) calledn", cflag);
#endif
/* first, disable everything */
save_flags(flags);
cli();
lcon=UART_GET_ULCON(port);
/* Clear the bits we're going to configure */
lcon &= ~(S3C2410_LCON_CFGMASK);

switch (cflag & CSIZE) {
case CS5:
lcon |= S3C2410_LCON_CS5;
break;
case CS6:
lcon |= S3C2410_LCON_CS6;
break;
case CS7:
lcon |= S3C2410_LCON_CS7;
break;
default:
lcon |= S3C2410_LCON_CS8;
break;
}
if(cflag & CSTOPB) {
lcon |= S3C2410_LCON_STOP;
}
if(cflag & PARENB) {
lcon |= (cflag & PARODD)? S3C2410_LCON_PODD:S3C2410_LCON_PEVEN;
} else {
lcon |= S3C2410_LCON_PNONE;
}

UART_PUT_ULCON(port, lcon);
if(iflag & BRKINT) {
unsigned long ucon=UART_GET_UCON(port);
ucon |= S3C2410_UCON_SBREAK;
UART_PUT_UCON(port, ucon);
}

UART_PUT_UBRDIV(port, quot);
restore_flags(flags);

}

static const char *
s3c2410uart_type(struct uart_port *port)
{
return port->type == PORT_S3C2410 ? "S3C2410" : NULL;
}

/*
* Release the memory region(s) being used by 'port'.
*/
static void
s3c2410uart_release_port(struct uart_port *port)
{
return;
}

/*
* Request the memory region(s) being used by 'port'.
*/
static int
s3c2410uart_request_port(struct uart_port *port)
{
return 0;
}

/*
* Configure/autoconfigure the port.
*/
static void
s3c2410uart_config_port(struct uart_port *port, int flags)
{
if (flags & UART_CONFIG_TYPE && s3c2410uart_request_port(port) == 0)
port->type = PORT_S3C2410;
}

static int
s3c2410uart_verify_port(struct uart_port *port, struct serial_struct *ser)
{
return 0;
}

static struct uart_ops s3c2410_pops = {
tx_empty: s3c2410uart_tx_empty,
set_mctrl: s3c2410uart_set_mctrl,
get_mctrl: s3c2410uart_get_mctrl,
stop_tx: s3c2410uart_stop_tx,
start_tx: s3c2410uart_start_tx,
stop_rx: s3c2410uart_stop_rx,
enable_ms: s3c2410uart_enable_ms,
break_ctl: s3c2410uart_break_ctl,
startup: s3c2410uart_startup,
shutdown: s3c2410uart_shutdown,
change_speed: s3c2410uart_change_speed,
type: s3c2410uart_type,
release_port: s3c2410uart_release_port,
request_port: s3c2410uart_request_port,
config_port: s3c2410uart_config_port,
verify_port: s3c2410uart_verify_port,
};

static struct uart_port s3c2410_ports[UART_NR] = {
{
membase: (void *) VA_UART_BASE,
mapbase: VA_UART_BASE,
iotype: SERIAL_IO_MEM,
irq: IRQ_RXD0,
uartclk: PCLK,
fifosize: 16,
unused: {4, 5},
ops: &s3c2410_pops,
type: PORT_S3C2410,
flags: ASYNC_BOOT_AUTOCONF,
},
{
membase: (void *) (VA_UART_BASE + S3C2410_UART1_OFF),
mapbase: (VA_UART_BASE + S3C2410_UART1_OFF),
iotype: SERIAL_IO_MEM,
irq: IRQ_RXD1,
uartclk: PCLK,
fifosize: 16,
unused: {6, 7},
ops: &s3c2410_pops,
type: PORT_S3C2410,
flags: ASYNC_BOOT_AUTOCONF,
}
};

#ifdef CONFIG_SERIAL_S3C2410_CONSOLE

#ifdef used_and_not_const_char_pointer
static int
s3c2410uart_console_read(struct uart_port *port, char *s, u_int count)
{
unsigned int status;
int c;

#if DEBUG
printk("s3c2410uart_console_read() calledn");
#endif

c = 0;
while (c < count) {
status = UART_GET_USR2(port);
if (UART_RX_DATA(status)) {
*s++ = UART_GET_CHAR(port);
c++;
} else {
// nothing more to get, return
return c;
}
}
// return the count
return c;
}
#endif

static void
s3c2410uart_console_write(struct console *co, const char *s, u_int count)
{
struct uart_port *port = s3c2410_ports + co->index;
unsigned int status;
int i;
/*
* Now, do each character
*/
for (i = 0; i < count; i++) {
do {
status = UART_GET_UTRSTAT(port);
} while (!UART_TX_READY(status));
UART_PUT_CHAR(port, (s[i]) & 0xff);
if (s[i] == 'n') {
do {
status = UART_GET_UTRSTAT(port);
} while (!UART_TX_READY(status));
UART_PUT_CHAR(port, 'r');
}
}
}

static kdev_t
s3c2410uart_console_device(struct console *co)
{

return MKDEV(SERIAL_S3C2410_MAJOR, SERIAL_S3C2410_MINOR + co->index);
}

static int
s3c2410uart_console_wait_key(struct console *co)
{
struct uart_port *port = s3c2410_ports + co->index;
unsigned int status;

do {
status = UART_GET_UTRSTAT(port);
} while (!UART_RX_DATA(status));
return UART_GET_CHAR(port);
}

static void __init
s3c2410uart_console_get_options(struct uart_port *port, int *baud, int *parity,
int *bits)
{
#if 0
*baud = (7833600)/(UART_GET_LCR(port) +1);
#else
*baud = CURRENT_BAUD_RATE;

#endif
*bits = 8;
*parity = 'n';
}

static int __init
s3c2410uart_console_setup(struct console *co, char *options)
{
struct uart_port *port;
int baud = CURRENT_BAUD_RATE;
int bits = 8;
int parity = 'n';
int flow = 'n';

/*
* Check whether an invalid uart number has been specified, and
* if so, search for the first available port that does have
* console support.
*/
port = uart_get_console(s3c2410_ports, UART_NR, co);

if (options)
uart_parse_options(options, &baud, &parity, &bits, &flow);
else
s3c2410uart_console_get_options(port, &baud, &parity, &bits);

return uart_set_options(port, co, baud, parity, bits, flow);
}

static struct console s3c2410_console = {
name: SERIAL_S3C2410_NAME,
write: s3c2410uart_console_write,
#ifdef used_and_not_const_char_pointer
read: s3c2410uart_console_read,
#endif
device: s3c2410uart_console_device,
wait_key: s3c2410uart_console_wait_key,
setup: s3c2410uart_console_setup,
flags: CON_PRINTBUFFER,
index: -1,
};

void __init
s3c2410uart_console_init(void)
{
register_console(&s3c2410_console);
}

#define S3C2410_CONSOLE &s3c2410_console
#else
#define S3C2410_CONSOLE NULL
#endif

static struct uart_driver s3c2410_reg = {
owner: THIS_MODULE,
normal_major: SERIAL_S3C2410_MAJOR,
#ifdef CONFIG_DEVFS_FS
normal_name: SERIAL_S3C2410_NAME "%d",
callout_name: CALLOUT_S3C2410_NAME "%d",
#else
normal_name: SERIAL_S3C2410_NAME,
callout_name: CALLOUT_S3C2410_NAME,
#endif
normal_driver :&normal,
callout_major: CALLOUT_S3C2410_MAJOR,
callout_driver: &callout,
table: s3c2410_table,
termios: s3c2410_termios,
termios_locked: s3c2410_termios_locked,
minor: SERIAL_S3C2410_MINOR,
nr: UART_NR,
port: s3c2410_ports,
cons: S3C2410_CONSOLE,
};

static int __init
s3c2410uart_init(void)
{
return uart_register_driver(&s3c2410_reg);
}

static void __exit
s3c2410uart_exit(void)
{
uart_unregister_driver(&s3c2410_reg);
}

module_init(s3c2410uart_init);
module_exit(s3c2410uart_exit);

EXPORT_NO_SYMBOLS;

MODULE_AUTHOR("Steve Hein <ssh@sgi.com>");
MODULE_DESCRIPTION("Samsung S3C2410X01 serial port driver");
MODULE_LICENSE("GPL");

2007-05-17T22:43:00.001+08:00

Network Core

/linux/drivers/block/genhd.c

int __init device_init(void)
{
rwlock_init(&gendisk_lock);
blk_dev_init();
sti();
#ifdef CONFIG_I2O
i2o_init();
#endif
#ifdef CONFIG_FUSION_BOOT
fusion_init();
#endif
#ifdef CONFIG_FC4_SOC
/* This has to be done before scsi_dev_init */
soc_probe();
#endif
#ifdef CONFIG_BLK_CPQ_DA
cpqarray_init();
#endif
#ifdef CONFIG_NET
net_dev_init();
#endif
#ifdef CONFIG_ATM
(void) atmdev_init();
#endif
#ifdef CONFIG_VT
console_map_init();
#endif
return 0;
}

/linux/net/core/dev.c

int __init net_dev_init(void)
{
struct net_device *dev, **dp;
int i;

if (!dev_boot_phase)
return 0;

#ifdef CONFIG_NET_DIVERT
dv_init();
#endif /* CONFIG_NET_DIVERT */

/*
* Initialise the packet receive queues.
*/

for (i = 0; i < NR_CPUS; i++) {
struct softnet_data *queue;

queue = &softnet_data[i];
skb_queue_head_init(&queue->input_pkt_queue);
queue->throttle = 0;
queue->cng_level = 0;
queue->avg_blog = 10; /* arbitrary non-zero */
queue->completion_queue = NULL;
}

#ifdef CONFIG_NET_PROFILE
net_profile_init();
NET_PROFILE_REGISTER(dev_queue_xmit);
NET_PROFILE_REGISTER(softnet_process);
#endif

#ifdef OFFLINE_SAMPLE
samp_timer.expires = jiffies + (10 * HZ);
add_timer(&samp_timer);
#endif

/*
* Add the devices.
* If the call to dev->init fails, the dev is removed
* from the chain disconnecting the device until the
* next reboot.
*
* NB At boot phase networking is dead. No locking is required.
* But we still preserve dev_base_lock for sanity.
*/

dp = &dev_base;
while ((dev = *dp) != NULL) {
spin_lock_init(&dev->queue_lock);
spin_lock_init(&dev->xmit_lock);
#ifdef CONFIG_NET_FASTROUTE
dev->fastpath_lock = RW_LOCK_UNLOCKED;
#endif
dev->xmit_lock_owner = -1;
dev->iflink = -1;
dev_hold(dev);

/*
* Allocate name. If the init() fails
* the name will be reissued correctly.
*/
if (strchr(dev->name, '%'))
dev_alloc_name(dev, dev->name);

/*
* Check boot time settings for the device.
*/
netdev_boot_setup_check(dev);

if (dev->init && dev->init(dev)) {
/*
* It failed to come up. It will be unhooked later.
* dev_alloc_name can now advance to next suitable
* name that is checked next.
*/
dev->deadbeaf = 1;
dp = &dev->next;
} else {
dp = &dev->next;
dev->ifindex = dev_new_index();
if (dev->iflink == -1)
dev->iflink = dev->ifindex;
if (dev->rebuild_header == NULL)
dev->rebuild_header = default_rebuild_header;
dev_init_scheduler(dev);
set_bit(__LINK_STATE_PRESENT, &dev->state);
}
}

/*
* Unhook devices that failed to come up
*/
dp = &dev_base;
while ((dev = *dp) != NULL) {
if (dev->deadbeaf) {
write_lock_bh(&dev_base_lock);
*dp = dev->next;
write_unlock_bh(&dev_base_lock);
dev_put(dev);
} else {
dp = &dev->next;
}
}

#ifdef CONFIG_PROC_FS
proc_net_create("dev", 0, dev_get_info);
create_proc_read_entry("net/softnet_stat", 0, 0, dev_proc_stats, NULL);
#ifdef WIRELESS_EXT
proc_net_create("wireless", 0, dev_get_wireless_info);
#endif /* WIRELESS_EXT */
#endif /* CONFIG_PROC_FS */

dev_boot_phase = 0;

open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);

dst_init();
dev_mcast_init();

#ifdef CONFIG_NET_SCHED
pktsched_init();
#endif

/*
* Initialise network devices
*/

net_device_init();

return 0;
}

/linux/drivers/net/Space.c

static struct net_device eth7_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, NEXT_DEV, ethif_probe };
static struct net_device eth6_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, &eth7_dev, ethif_probe };
static struct net_device eth5_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, &eth6_dev, ethif_probe };
static struct net_device eth4_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, &eth5_dev, ethif_probe };
static struct net_device eth3_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, &eth4_dev, ethif_probe };
static struct net_device eth2_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, &eth3_dev, ethif_probe };
static struct net_device eth1_dev = {
"eth%d", 0,0,0,0,ETH_NOPROBE_ADDR /* I/O base*/, 0,0,0,0, &eth2_dev, ethif_probe };

static struct net_device eth0_dev = {
"eth%d", 0, 0, 0, 0, ETH0_ADDR, ETH0_IRQ, 0, 0, 0, &eth1_dev, ethif_probe };

# undef NEXT_DEV
# define NEXT_DEV (&eth0_dev)

extern int loopback_init(struct net_device *dev);
struct net_device loopback_dev =
{"lo", 0, 0, 0, 0, 0, 0, 0, 0, 0, NEXT_DEV, loopback_init};

struct net_device *dev_base = &loopback_dev;

static struct devprobe isa_probes[] __initdata = {
#ifdef CONFIG_EL3 /* ISA, EISA, MCA 3c5x9 */
{el3_probe, 0},
#endif
#ifdef CONFIG_HP100 /* ISA, EISA & PCI */
{hp100_probe, 0},
#endif
#ifdef CONFIG_3C515
{tc515_probe, 0},
#endif
#ifdef CONFIG_ULTRA
{ultra_probe, 0},
#endif
#ifdef CONFIG_WD80x3
{wd_probe, 0},
#endif
#ifdef CONFIG_EL2 /* 3c503 */
{el2_probe, 0},
#endif
#ifdef CONFIG_HPLAN
{hp_probe, 0},
#endif
#ifdef CONFIG_HPLAN_PLUS
{hp_plus_probe, 0},
#endif
#ifdef CONFIG_E2100 /* Cabletron E21xx series. */
{e2100_probe, 0},
#endif
#ifdef CONFIG_NE2000 /* ISA (use ne2k-pci for PCI cards) */
{ne_probe, 0},
#endif
#ifdef CONFIG_LANCE /* ISA/VLB (use pcnet32 for PCI cards) */
{lance_probe, 0},
#endif
#ifdef CONFIG_SMC9194
{smc_init, 0},
#endif
#ifdef CONFIG_SEEQ8005
{seeq8005_probe, 0},
#endif
#ifdef CONFIG_AT1500
{at1500_probe, 0},
#endif
#ifdef CONFIG_CS89x0
{cs89x0_probe, 0},
#endif
#ifdef CONFIG_AT1700
{at1700_probe, 0},
#endif
#ifdef CONFIG_FMV18X /* Fujitsu FMV-181/182 */
{fmv18x_probe, 0},
#endif
#ifdef CONFIG_ETH16I
{eth16i_probe, 0}, /* ICL EtherTeam 16i/32 */
#endif
#ifdef CONFIG_ZNET /* Zenith Z-Note and some IBM Thinkpads. */
{znet_probe, 0},
#endif
#ifdef CONFIG_EEXPRESS /* Intel EtherExpress */
{express_probe, 0},
#endif
#ifdef CONFIG_EEXPRESS_PRO /* Intel EtherExpress Pro/10 */
{eepro_probe, 0},
#endif
#ifdef CONFIG_DEPCA /* DEC DEPCA */
{depca_probe, 0},
#endif
#ifdef CONFIG_EWRK3 /* DEC EtherWORKS 3 */
{ewrk3_probe, 0},
#endif
#if defined(CONFIG_APRICOT) || defined(CONFIG_MVME16x_NET) || defined(CONFIG_BVME6000_NET) /* Intel I82596 */
{i82596_probe, 0},
#endif
#ifdef CONFIG_EL1 /* 3c501 */
{el1_probe, 0},
#endif
#ifdef CONFIG_WAVELAN /* WaveLAN */
{wavelan_probe, 0},
#endif
#ifdef CONFIG_ARLAN /* Aironet */
{arlan_probe, 0},
#endif
#ifdef CONFIG_EL16 /* 3c507 */
{el16_probe, 0},
#endif
#ifdef CONFIG_ELPLUS /* 3c505 */
{elplus_probe, 0},
#endif
#ifdef CONFIG_SK_G16
{SK_init, 0},
#endif
#ifdef CONFIG_NI5010
{ni5010_probe, 0},
#endif
#ifdef CONFIG_NI52
{ni52_probe, 0},
#endif
#ifdef CONFIG_NI65
{ni65_probe, 0},
#endif
{NULL, 0},
};

2007-05-17T22:43:00.000+08:00

Network Programming

TCP

TcpEchoServer1.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <errno.h>

int main(int argc,char *argv[])
{
int iServerActive,iIncomingBytes;
int iSocketFD,iConnectedFD;
pid_t pid_tChildPid;
char buffer[1000];
socklen_t socklen_tClientLen;
struct sockaddr_in sockaddr_inClientAddress;
struct sockaddr_in sockaddr_inServerAddress;

if(argc != 2)
{
printf("Usage:n");
printf("./TcpEchoServer1.exe [Port number]n");
printf("Port number example: 12345n");
exit(1);
}

if((iSocketFD=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("socket errorn");
exit(1);
}

memset(&sockaddr_inServerAddress,0,
sizeof(sockaddr_inServerAddress));

sockaddr_inServerAddress.sin_family=AF_INET;
sockaddr_inServerAddress.sin_addr.s_addr=
htonl(INADDR_ANY);
sockaddr_inServerAddress.sin_port=htons(atoi(argv[1]));

if(bind(iSocketFD,
(struct sockaddr *)&sockaddr_inServerAddress,
sizeof(sockaddr_inServerAddress)) < 0)
{
printf("bind errorn");
exit(1);
}
if(listen(iSocketFD,3)<0)
{
printf("listen errorn");
exit(1);
}

iServerActive=1;
while(iServerActive)
{
socklen_tClientLen=sizeof(sockaddr_inClientAddress);
if((iConnectedFD=accept(iSocketFD,(struct sockaddr *)
&sockaddr_inClientAddress,&socklen_tClientLen))<0)
{
printf("accept error");
exit(1);
}

printf("Connect from %sn",
inet_ntoa(sockaddr_inClientAddress.sin_addr));

while(1)
{
memset(buffer,0,1000);
if(iIncomingBytes=
read(iConnectedFD,buffer,sizeof(buffer))>0)
{
printf("%s",buffer);
if(write(iConnectedFD,buffer,sizeof(buffer)) < 0)
{
printf("send error!");
exit(1);
}
}
}
}
}

TcpEchoClient.c

int main(int argc,char *argv[])
{
int iSocketFD;
char buffer[1000];
int iIncomingBytes;
struct sockaddr_in sockaddr_inServerAddress;

if(argc !=3)
{
printf("Usage: ./TcpEchoClient.exe
n <IP address> <Port number>n");
exit(1);
}

if((iSocketFD=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("socket errorn");
exit(1);
}

memset(&sockaddr_inServerAddress,
0,
sizeof(sockaddr_inServerAddress));
sockaddr_inServerAddress.sin_family=AF_INET;
sockaddr_inServerAddress.sin_addr.s_addr=inet_addr(argv[1]);
sockaddr_inServerAddress.sin_port=htons(atoi(argv[2]));

if(connect(iSocketFD,
(struct sockaddr *)
&sockaddr_inServerAddress,
sizeof(sockaddr_inServerAddress)) < 0)
{
printf("connect errorn");
exit(1);
}

while(fgets(buffer,1000,stdin)!=NULL)
{
if(write(iSocketFD,buffer,strlen(buffer))<0)
{
perror("send error");
exit(0);
}
if(iIncomingBytes=read(iSocketFD,buffer,sizeof(buffer))>0)
{
printf("%s",buffer);
}
memset(buffer,0,1000);
}
exit(0);
}

int main(int argc,char *argv[])
{
int iServerActive,iIncomingBytes,iSocketFD,iConnectedFD;
pid_t pid_tChildPid;
socklen_t socklen_tClientLen;
struct sockaddr_in sockaddr_inClientAddress;
struct sockaddr_in sockaddr_inServerAddress;
char buffer[1000];

if(argc != 2)
{
printf("Usage:n");
printf("./TcpEchoServer2.exe [Port number]n");
printf("Port number example: 12345n");
exit(1);
}

if((iSocketFD=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("socket errorn");
exit(1);
}

memset(&sockaddr_inServerAddress,
0,
sizeof(sockaddr_inServerAddress));
sockaddr_inServerAddress.sin_family=AF_INET;
sockaddr_inServerAddress.sin_addr.s_addr=
htonl(INADDR_ANY);
sockaddr_inServerAddress.sin_port=htons(atoi(argv[1]));

if (bind(iSocketFD,
(struct sockaddr *) &sockaddr_inServerAddress,
sizeof(sockaddr_inServerAddress)) < 0)
{
printf("bind errorn");
exit(1);
}
if(listen(iSocketFD,3)<0)
{
printf("listen errorn");
exit(1);
}

iServerActive=1;
while(iServerActive)
{
socklen_tClientLen=sizeof(sockaddr_inClientAddress);
if((iConnectedFD=accept(iSocketFD,(struct sockaddr *)
&sockaddr_inClientAddress,&socklen_tClientLen))<0)
{
printf("accept error");
exit(1);
}
if((pid_tChildPid = fork()) == -1)
{
printf("accept error");
exit(1);
}
if(pid_tChildPid == 0)
{
if (close(iSocketFD) == -1)
{
printf("close error");
exit(1);
}
printf("Connect from %sn",
inet_ntoa(sockaddr_inClientAddress.sin_addr));

while(1)
{
memset(buffer,0,1000);
if(iIncomingBytes=
read(iConnectedFD,buffer,sizeof(buffer))>0)
{
printf("%s",buffer);
if(write(iConnectedFD,
buffer,
sizeof(buffer)) < 0)
{
printf("send error!");
exit(1);
}
}
}
exit(0);
}
if (close(iConnectedFD) == -1)
{
printf("close error");
exit(1);
}
}
}

UDP

UdpServer.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

main(int argc,char *argv[])
{
int SockFD,Len;
struct sockaddr_in Addr;
int AddrLen=sizeof(struct sockaddr_in);
char cTemp[1000];

if(argc != 2)
{
printf("Usage : udpserver [port number]n");
printf("Example: udpserver 12345n");
exit(1);
}

if((SockFD=socket(AF_INET,SOCK_DGRAM,0))<0)
{
printf("socket error!");
exit(1);
}

memset(cTemp,0,1000);
Addr.sin_family = AF_INET;
Addr.sin_port = htons(atoi(argv[1]));
Addr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(SockFD,&Addr,sizeof(Addr))<0)
{
printf("bind error!");
exit(1);
}

while(1)
{
memset(cTemp,0,1000);
Len=recvfrom(SockFD,
cTemp,
sizeof(cTemp),
0,
&Addr,
&AddrLen);
if(Len>0)
{
printf("receive %sn",cTemp);
printf("Received data = %s, length = %d bytes, received from %sn",
cTemp,
Len,
inet_ntoa(Addr.sin_addr));
sendto(SockFD,cTemp,Len,0,&Addr,AddrLen);
}
}
}

UdpClient.c

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

main(int argc,char *argv[])
{
int SockFD,Len;
struct sockaddr_in Addr;
int AddrLen=sizeof(struct sockaddr_in);
char cTemp[1000];

if(argc != 3)
{
printf("Usage:n");
printf("udpclient [IP address] [Port number]nn");
printf("IP address example: 192.168.181.222n");
printf("Port number example: 12345n");
exit(1);
}

if((SockFD=socket(AF_INET,SOCK_DGRAM,0))<0)
{
printf("socket error");
exit(1);
}

memset(&Addr,0,sizeof(Addr));
Addr.sin_family = AF_INET;
Addr.sin_port = htons(atoi(argv[2]));
Addr.sin_addr.s_addr = inet_addr(argv[1]);

while(1)
{
memset(cTemp,0,1000);
Len=read(STDIN_FILENO,cTemp,sizeof(cTemp));
sendto(SockFD,cTemp,Len,0,&Addr,AddrLen);
Len=recvfrom(SockFD,
cTemp,
sizeof(cTemp),
0,
&Addr,
&AddrLen);
printf("receive %sn",cTemp);
}
}

2007-05-17T22:42:00.000+08:00

Network Driver

/* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
* driver for linux.
*/

/*
Written 1996 by Russell Nelson, with reference to skeleton.c
written 1993-1994 by Donald Becker.

This software may be used and distributed according to the terms
of the GNU General Public License, incorporated herein by reference.

The author may be reached at nelson@crynwr.com, Crynwr
Software, 521 Pleasant Valley Rd., Potsdam, NY 13676

Changelog:

Mike Cruse : mcruse@cti-ltd.com
: Changes for Linux 2.0 compatibility.
: Added dev_id parameter in net_interrupt(),
: request_irq() and free_irq(). Just NULL for now.

Mike Cruse : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
: in net_open() and net_close() so kerneld would know
: that the module is in use and wouldn't eject the
: driver prematurely.

Mike Cruse : Rewrote init_module() and cleanup_module using 8390.c
: as an example. Disabled autoprobing in init_module(),
: not a good thing to do to other devices while Linux
: is running from all accounts.

Russ Nelson : Jul 13 1998. Added RxOnly DMA support.

Melody Lee : Aug 10 1999. Changes for Linux 2.2.5 compatibility.
: email: ethernet@crystal.cirrus.com

Alan Cox : Removed 1.2 support, added 2.1 extra counters.

Andrew Morton : andrewm@uow.edu.au
: Kernel 2.3.48
: Handle kmalloc() failures
: Other resource allocation fixes
: Add SMP locks
: Integrate Russ Nelson's ALLOW_DMA functionality back in.
: If ALLOW_DMA is true, make DMA runtime selectable
: Folded in changes from Cirrus (Melody Lee
: <klee@crystal.cirrus.com>)
: Don't call netif_wake_queue() in net_send_packet()
: Fixed an out-of-mem bug in dma_rx()
: Updated Documentation/cs89x0.txt

Andrew Morton : andrewm@uow.edu.au / Kernel 2.3.99-pre1
: Use skb_reserve to longword align IP header (two places)
: Remove a delay loop from dma_rx()
: Replace '100' with HZ
: Clean up a couple of skb API abuses
: Added 'cs89x0_dma=N' kernel boot option
: Correctly initialise lp->lock in non-module compile

Andrew Morton : andrewm@uow.edu.au / Kernel 2.3.99-pre4-1
: MOD_INC/DEC race fix (see
: http://www.uwsg.indiana.edu/hypermail/linux/kernel/0003.3/1532.html)

Andrew Morton : andrewm@uow.edu.au / Kernel 2.4.0-test7-pre2
: Enhanced EEPROM support to cover more devices,
: abstracted IRQ mapping to support CONFIG_ARCH_CLPS7500 arch
: (Jason Gunthorpe <jgg@ualberta.ca>)

Andrew Morton : Kernel 2.4.0-test11-pre4
: Use dev->name in request_*() (Andrey Panin)
: Fix an error-path memleak in init_module()
: Preserve return value from request_irq()
: Fix type of `media' module parm (Keith Owens)
: Use SET_MODULE_OWNER()
: Tidied up strange request_irq() abuse in net_open().

Andrew Morton : Kernel 2.4.3-pre1
: Request correct number of pages for DMA (Hugh Dickens)
: Select PP_ChipID _after_ unregister_netdev in cleanup_module()
: because unregister_netdev() calls get_stats.
: Make `version[]' __initdata
: Uninlined the read/write reg/word functions.

/* Always include 'config.h' first in case the user wants to turn on
or override something. */
#include <linux/config.h>
#include <linux/module.h>
#include <linux/version.h>

/*
* Set this to zero to disable DMA code
*
* Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
* module options so we don't break any startup scripts.
*/
#define ALLOW_DMA 1

/*
* Set this to zero to remove all the debug statements via
* dead code elimination
*/
#define DEBUGGING 0
//#define DEBUGGING 1

/*
Sources:

Crynwr packet driver epktisa.

Crystal Semiconductor data sheets.

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/init.h>
#include <asm/system.h>
#include <asm/bitops.h>
#include <asm/io.h>
#if ALLOW_DMA
#include <asm/dma.h>
#endif
#include <linux/errno.h>
#include <linux/spinlock.h>

#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>

#ifdef CONFIG_ARCH_S3C2410
#include <asm/irq.h>
#include <asm/hardware.h>
#endif

#include "cs89x0.h"

static char version[] __initdata =
"cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>n";

/* First, a few definitions that the brave might change.
A zero-terminated list of I/O addresses to be probed. Some special flags..
Addr & 1 = Read back the address port, look for signature and reset
the page window before probing
Addr & 3 = Reset the page window and probe
The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
but it is possible that a Cirrus board could be plugged into the ISA
slots. */
/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
them to system IRQ numbers. This mapping is card specific and is set to
the configuration of the Cirrus Eval board for this chip. */
#ifdef CONFIG_ARCH_CLPS7500
static unsigned int netcard_portlist[] __initdata =
{ 0x80090303, 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
static unsigned int cs8900_irq_map[] = {12,0,0,0};

#elif defined(CONFIG_ARCH_S3C2410)
/*
* Samsung SMDK2410 (Samsung S3C2410 eval board) has the Cirrus chip
* on CS3, using external interrupt EINT9
*/
static unsigned int netcard_portlist[] __initdata =
{ VA_CS8900A_BASE+DEFAULTIOBASE, 0};
static unsigned int cs8900_irq_map[] = {IRQ_EINT9,0,0,0};
/*
* on the SMDK2410, we are mapped into IO memory space instead of IO port space,
* so redirect request/release_region to use IO memory versus IO ports
*/
#ifdef request_region
#undef request_region
#endif
#ifdef release_region
#undef release_region
#endif
#define request_region(a,s,n) request_mem_region(a,s,n)
#define release_region(a,s) release_mem_region(a,s)
#else /* End of S3C2410 */

static unsigned int netcard_portlist[] __initdata =
{ 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
static unsigned int cs8900_irq_map[] = {10,11,12,5};
#endif

#if DEBUGGING
static unsigned int net_debug = DEBUGGING;
#else
#define net_debug 0 /* gcc will remove all the debug code for us */
#endif

/* The number of low I/O ports used by the ethercard. */
#define NETCARD_IO_EXTENT 16

/* we allow the user to override various values normally set in the EEPROM */
#define FORCE_RJ45 0x0001 /* pick one of these three */
#define FORCE_AUI 0x0002
#define FORCE_BNC 0x0004

#define FORCE_AUTO 0x0010 /* pick one of these three */
#define FORCE_HALF 0x0020
#define FORCE_FULL 0x0030

/* Information that need to be kept for each board. */
struct net_local {
struct net_device_stats stats;
int chip_type; /* one of: CS8900, CS8920, CS8920M */
char chip_revision; /* revision letter of the chip ('A'...) */
int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
int auto_neg_cnf; /* auto-negotiation word from EEPROM */
int adapter_cnf; /* adapter configuration from EEPROM */
int isa_config; /* ISA configuration from EEPROM */
int irq_map; /* IRQ map from EEPROM */
int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
int curr_rx_cfg; /* a copy of PP_RxCFG */
int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
int send_underrun; /* keep track of how many underruns in a row we get */
int force; /* force various values; see FORCE* above. */
spinlock_t lock;
#if ALLOW_DMA
int use_dma; /* Flag: we're using dma */
int dma; /* DMA channel */
int dmasize; /* 16 or 64 */
unsigned char *dma_buff; /* points to the beginning of the buffer */
unsigned char *end_dma_buff; /* points to the end of the buffer */
unsigned char *rx_dma_ptr; /* points to the next packet */
#endif
};

/* Index to functions, as function prototypes. */

extern int cs89x0_probe(struct net_device *dev);

static int cs89x0_probe1(struct net_device *dev, int ioaddr);
static int net_open(struct net_device *dev);
static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
static void net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static void set_multicast_list(struct net_device *dev);
static void net_timeout(struct net_device *dev);
static void net_rx(struct net_device *dev);
static int net_close(struct net_device *dev);
static struct net_device_stats *net_get_stats(struct net_device *dev);
static void reset_chip(struct net_device *dev);
static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
static int get_eeprom_cksum(int off, int len, int *buffer);
static int set_mac_address(struct net_device *dev, void *addr);
static void count_rx_errors(int status, struct net_local *lp);
#if ALLOW_DMA
static void get_dma_channel(struct net_device *dev);
static void release_dma_buff(struct net_local *lp);
#endif

/* Example routines you must write ;->. */
#define tx_done(dev) 1

/*
* Permit 'cs89x0_dma=N' in the kernel boot environment
*/
#if !defined(MODULE) && (ALLOW_DMA != 0)
static int g_cs89x0_dma;

static int __init dma_fn(char *str)
{
g_cs89x0_dma = simple_strtol(str,NULL,0);
return 1;
}

__setup("cs89x0_dma=", dma_fn);
#endif /* !defined(MODULE) && (ALLOW_DMA != 0) */

/* Check for a network adaptor of this type, and return '0' iff one exists.
If dev->base_addr == 0, probe all likely locations.
If dev->base_addr == 1, always return failure.
If dev->base_addr == 2, allocate space for the device and return success
(detachable devices only).
Return 0 on success.
*/

#ifdef S3C2410_HWINIT_ETHER_INFORMATION
int __init S3C2410_HWinit()
{

/******* S3C2410 *****************/
#define CS8900_Tacs (0x0) // 0clk
#define CS8900_Tcos (0x3) // 4clk
#define CS8900_Tacc (0x7) // 14clk
#define CS8900_Tcoh (0x1) // 1clk
#define CS8900_Tah (0x3) // 4clk
#define CS8900_Tacp (0x3) // 6clk
#define CS8900_PMC (0x0) // normal(1data)

// initialize CS8900

rBWSCON = (rBWSCON&~(0xf<<12))|(0xd<<12); /* nWAIT */
// rGSTATUS0; /* Read Only */
rGPACON; /* look up uncomress.h */
rGPGCON = (rGPGCON&~(3<<2))|(2<<2); /* EXINT 9 */
rBANKCON3=((CS8900_Tacs<<13)+(CS8900_Tcos<<11)+(CS8900_Tacc<<8)
+(CS8900_Tcoh<<6)+(CS8900_Tah<<4)+(CS8900_Tacp<<2)+(CS8900_PMC));
rEXTINT1 = (rEXTINT1&~(7<<4))|(4<<4); /* Rising Edge Detect Mode */
return 0;
}
#endif

int __init cs89x0_probe(struct net_device *dev)
{
int i;
int base_addr = dev ? dev->base_addr : 0;

SET_MODULE_OWNER(dev);

// initialize CS8900
if (net_debug)
printk("cs89x0:cs89x0_probe(0x%x)n", base_addr);

if (base_addr > 0x1ff) /* Check a single specified location. */
return cs89x0_probe1(dev, base_addr);
else if (base_addr != 0) /* Don't probe at all. */
return -ENXIO;

for (i = 0; netcard_portlist[i]; i++) {
if (cs89x0_probe1(dev, netcard_portlist[i]) == 0)
return 0;
}
printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUPn");
return -ENODEV;
}

static int
readreg(struct net_device *dev, int portno)
{
outw(portno, dev->base_addr + ADD_PORT);
return inw(dev->base_addr + DATA_PORT);
}

static void
writereg(struct net_device *dev, int portno, int value)
{
outw(portno, dev->base_addr + ADD_PORT);
outw(value, dev->base_addr + DATA_PORT);
}

static int
readword(struct net_device *dev, int portno)
{
return inw(dev->base_addr + portno);
}

static void
writeword(struct net_device *dev, int portno, int value)
{
outw(value, dev->base_addr + portno);
}

static int __init
wait_eeprom_ready(struct net_device *dev)
{
int timeout = jiffies;
/* check to see if the EEPROM is ready, a timeout is used -
just in case EEPROM is ready when SI_BUSY in the
PP_SelfST is clear */
while(readreg(dev, PP_SelfST) & SI_BUSY)
if (jiffies - timeout >= 40)
return -1;
return 0;
}

static int __init
get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
{
int i;

if (net_debug > 3) printk("EEPROM data from %x for %x:n",off,len);
for (i = 0; i < len; i++) {
if (wait_eeprom_ready(dev) < 0) return -1;
/* Now send the EEPROM read command and EEPROM location to read */
writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
if (wait_eeprom_ready(dev) < 0) return -1;
buffer[i] = readreg(dev, PP_EEData);
if (net_debug > 3) printk("%04x ", buffer[i]);
}
if (net_debug > 3) printk("n");
return 0;
}

static int __init
get_eeprom_cksum(int off, int len, int *buffer)
{
int i, cksum;

cksum = 0;
for (i = 0; i < len; i++)
cksum += buffer[i];
cksum &= 0xffff;
if (cksum == 0)
return 0;
return -1;
}

/* This is the real probe routine. Linux has a history of friendly device
probes on the ISA bus. A good device probes avoids doing writes, and
verifies that the correct device exists and functions.
Return 0 on success.
*/

static int __init
cs89x0_probe1(struct net_device *dev, int ioaddr)
{
struct net_local *lp;
static unsigned version_printed;
int i;
unsigned rev_type = 0;
int eeprom_buff[CHKSUM_LEN];
int retval;

/* Initialize the device structure. */
if (dev->priv == NULL) {
dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
if (dev->priv == 0) {
retval = -ENOMEM;
goto out;
}
lp = (struct net_local *)dev->priv;
memset(lp, 0, sizeof(*lp));
spin_lock_init(&lp->lock);
#if !defined(MODULE) && (ALLOW_DMA != 0)
if (g_cs89x0_dma) {
lp->use_dma = 1;
lp->dma = g_cs89x0_dma;
lp->dmasize = 16; /* Could make this an option... */
}
#endif
}
lp = (struct net_local *)dev->priv;

/* Grab the region so we can find another board if autoIRQ fails. */
if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, dev->name)) {
printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failedn",
dev->name, ioaddr, NETCARD_IO_EXTENT);
retval = -EBUSY;
goto out1;
}

/* if they give us an odd I/O address, then do ONE write to
the address port, to get it back to address zero, where we
expect to find the EISA signature word. An IO with a base of 0x3
will skip the test for the ADD_PORT. */
if (ioaddr & 1) {
if (net_debug > 1)
printk(KERN_INFO "%s: odd ioaddr 0x%xn", dev->name, ioaddr);
if ((ioaddr & 2) != 2)
if ((inw((ioaddr & ~3)+ ADD_PORT) & ADD_MASK) != ADD_SIG) {
printk(KERN_ERR "%s: bad signature 0x%xn",
dev->name, inw((ioaddr & ~3)+ ADD_PORT));
retval = -ENODEV;
goto out2;
}
ioaddr &= ~3;
}

outw(PP_ChipID, ioaddr + ADD_PORT);

if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG) {
printk(KERN_ERR "%s: incorrect signature 0x%xn",
dev->name, inw(ioaddr + DATA_PORT));
retval = -ENODEV;
goto out2;
}

/* Fill in the 'dev' fields. */
dev->base_addr = ioaddr;

/* get the chip type */
rev_type = readreg(dev, PRODUCT_ID_ADD);

lp->chip_type = rev_type &~ REVISON_BITS;
lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';

/* Check the chip type and revision in order to set the correct send command
CS8920 revision C and CS8900 revision F can use the faster send. */
lp->send_cmd = TX_AFTER_381;
if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
lp->send_cmd = TX_NOW;
if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
lp->send_cmd = TX_NOW;

if (net_debug && version_printed++ == 0)
printk(version);

printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
dev->name,
lp->chip_type==CS8900?'0':'2',
lp->chip_type==CS8920M?"M":"",
lp->chip_revision,
dev->base_addr);

reset_chip(dev);

#ifdef CONFIG_ARCH_S3C2410
/* The SMDK2410 eval board does not have an EEPROM attached
to the CS8900A.... so set some defaults */
/* Force a 10 Base-T connection. */
lp->force = FORCE_RJ45;
lp->auto_neg_cnf = IMM_BIT; /* don't error if no cable plugged */
#endif

/* Here we read the current configuration of the chip. If there
is no Extended EEPROM then the idea is to not disturb the chip
configuration, it should have been correctly setup by automatic
EEPROM read on reset. So, if the chip says it read the EEPROM
the driver will always do *something* instead of complain that
adapter_cnf is 0. */
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
(EEPROM_OK|EEPROM_PRESENT)) {
/* Load the MAC. */
for (i=0; i < ETH_ALEN/2; i++) {
unsigned int Addr;
Addr = readreg(dev, PP_IA+i*2);
dev->dev_addr[i*2] = Addr & 0xFF;
dev->dev_addr[i*2+1] = Addr >> 8;
}

/* Load the Adapter Configuration.
Note: Barring any more specific information from some
other source (ie EEPROM+Schematics), we would not know
how to operate a 10Base2 interface on the AUI port.
However, since we do read the status of HCB1 and use
settings that always result in calls to control_dc_dc(dev,0)
a BNC interface should work if the enable pin
(dc/dc converter) is on HCB1. It will be called AUI
however. */

lp->adapter_cnf = 0;
i = readreg(dev, PP_LineCTL);
/* Preserve the setting of the HCB1 pin. */
if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
/* Save the sqelch bit */
if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
/* Check if the card is in 10Base-t only mode */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
/* Check if the card is in AUI only mode */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
/* Check if the card is in Auto mode. */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;

if (net_debug > 1)
printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%xn",
dev->name, i, lp->adapter_cnf);

/* IRQ. Other chips already probe, see below. */
if (lp->chip_type == CS8900)
lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;

printk( "[Cirrus EEPROM] ");
}

printk("n");

/* First check to see if an EEPROM is attached. */
if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....n");
else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
printk(KERN_WARNING "ncs89x0: EEPROM read failed, relying on command line.n");
} else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
/* Check if the chip was able to read its own configuration starting
at 0 in the EEPROM*/
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
(EEPROM_OK|EEPROM_PRESENT))
printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command linen");

} else {
/* This reads an extended EEPROM that is not documented
in the CS8900 datasheet. */

/* get transmission control word but keep the autonegotiation bits */
if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
/* Store adapter configuration */
if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
/* Store ISA configuration */
lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;

/* eeprom_buff has 32-bit ints, so we can't just memcpy it */
/* store the initial memory base address */
for (i = 0; i < ETH_ALEN/2; i++) {
dev->dev_addr[i*2] = eeprom_buff[i];
dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
}
if (net_debug > 1)
printk(KERN_DEBUG "%s: new adapter_cnf: 0x%xn",
dev->name, lp->adapter_cnf);
}

/* allow them to force multiple transceivers. If they force multiple, autosense */
{
int count = 0;
if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
}

if (net_debug > 1)
printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%xn",
dev->name, lp->force, lp->adapter_cnf);

/* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */

/* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */

/* FIXME: we don't set the Ethernet address on the command line. Use
ifconfig IFACE hw ether AABBCCDDEEFF */

printk(KERN_INFO "cs89x0 media %s%s",
(lp->adapter_cnf & A_CNF_10B_T)?"RJ-45":"",
(lp->adapter_cnf & A_CNF_AUI)?"AUI":"");

dev->dev_addr[0] = 0x00;
dev->dev_addr[1] = 0x00;
dev->dev_addr[2] = 0xc0;
dev->dev_addr[3] = 0xff;
dev->dev_addr[4] = 0xee;
dev->dev_addr[5] = 0x08;
set_mac_address(dev, dev->dev_addr);

dev->irq = IRQ_LAN;
printk(", IRQ %d", dev->irq);

dev->open = net_open;
dev->stop = net_close;
dev->tx_timeout = net_timeout;
dev->watchdog_timeo = HZ;
dev->hard_start_xmit = net_send_packet;
dev->get_stats = net_get_stats;
dev->set_multicast_list = set_multicast_list;
dev->set_mac_address = set_mac_address;

/* Fill in the fields of the device structure with ethernet values. */
ether_setup(dev);

printk("n");
if (net_debug)
printk("cs89x0_probe1() successfuln");
return 0;
out2:
release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
out1:
kfree(dev->priv);
dev->priv = 0;
out:
return retval;
}

/*********************************
* This page contains DMA routines
**********************************/

#if ALLOW_DMA

#define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)

static void
get_dma_channel(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;

if (lp->dma) {
dev->dma = lp->dma;
lp->isa_config |= ISA_RxDMA;
} else {
if ((lp->isa_config & ANY_ISA_DMA) == 0)
return;
dev->dma = lp->isa_config & DMA_NO_MASK;
if (lp->chip_type == CS8900)
dev->dma += 5;
if (dev->dma < 5 || dev->dma > 7) {
lp->isa_config &= ~ANY_ISA_DMA;
return;
}
}
return;
}

static void
write_dma(struct net_device *dev, int chip_type, int dma)
{
struct net_local *lp = (struct net_local *)dev->priv;
if ((lp->isa_config & ANY_ISA_DMA) == 0)
return;
if (chip_type == CS8900) {
writereg(dev, PP_CS8900_ISADMA, dma-5);
} else {
writereg(dev, PP_CS8920_ISADMA, dma);
}
}

static void
set_dma_cfg(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;

if (lp->use_dma) {
if ((lp->isa_config & ANY_ISA_DMA) == 0) {
if (net_debug > 3)
printk("set_dma_cfg(): no DMAn");
return;
}
if (lp->isa_config & ISA_RxDMA) {
lp->curr_rx_cfg |= RX_DMA_ONLY;
if (net_debug > 3)
printk("set_dma_cfg(): RX_DMA_ONLYn");
} else {
lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
if (net_debug > 3)
printk("set_dma_cfg(): AUTO_RX_DMAn");
}
}
}

static int
dma_bufcfg(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
if (lp->use_dma)
return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
else
return 0;
}

static int
dma_busctl(struct net_device *dev)
{
int retval = 0;
struct net_local *lp = (struct net_local *)dev->priv;
if (lp->use_dma) {
if (lp->isa_config & ANY_ISA_DMA)
retval |= RESET_RX_DMA; /* Reset the DMA pointer */
if (lp->isa_config & DMA_BURST)
retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
if (lp->dmasize == 64)
retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
}
return retval;
}

static void
dma_rx(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
struct sk_buff *skb;
int status, length;
unsigned char *bp = lp->rx_dma_ptr;

status = bp[0] + (bp[1]<<8);
length = bp[2] + (bp[3]<<8);
bp += 4;
if (net_debug > 5) {
printk( "%s: receiving DMA packet at %lx, status %x, length %xn",
dev->name, (unsigned long)bp, status, length);
}
if ((status & RX_OK) == 0) {
count_rx_errors(status, lp);
goto skip_this_frame;
}

/* Malloc up new buffer. */
skb = dev_alloc_skb(length + 2);
if (skb == NULL) {
if (net_debug) /* I don't think we want to do this to a stressed system */
printk("%s: Memory squeeze, dropping packet.n", dev->name);
lp->stats.rx_dropped++;

/* AKPM: advance bp to the next frame */
skip_this_frame:
bp += (length + 3) & ~3;
if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
lp->rx_dma_ptr = bp;
return;
}
skb_reserve(skb, 2); /* longword align L3 header */
skb->dev = dev;

if (bp + length > lp->end_dma_buff) {
int semi_cnt = lp->end_dma_buff - bp;
memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
length - semi_cnt);
} else {
memcpy(skb_put(skb,length), bp, length);
}
bp += (length + 3) & ~3;
if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
lp->rx_dma_ptr = bp;

if (net_debug > 3) {
printk( "%s: received %d byte DMA packet of type %xn",
dev->name, length,
(skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
}
skb->protocol=eth_type_trans(skb,dev);
netif_rx(skb);
dev->last_rx = jiffies;
lp->stats.rx_packets++;
lp->stats.rx_bytes += length;
}

#endif /* ALLOW_DMA */

void __init reset_chip(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
int ioaddr = dev->base_addr;
int reset_start_time;

writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);

/* wait 30 ms */
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(30*HZ/1000);

if (lp->chip_type != CS8900) {
/* Hardware problem requires PNP registers to be reconfigured after a reset */
outw(PP_CS8920_ISAINT, ioaddr + ADD_PORT);
outb(dev->irq, ioaddr + DATA_PORT);
outb(0, ioaddr + DATA_PORT + 1);

outw(PP_CS8920_ISAMemB, ioaddr + ADD_PORT);
outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
}
/* Wait until the chip is reset */
reset_start_time = jiffies;
while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
;
}

static void
control_dc_dc(struct net_device *dev, int on_not_off)
{
struct net_local *lp = (struct net_local *)dev->priv;
unsigned int selfcontrol;
int timenow = jiffies;
/* control the DC to DC convertor in the SelfControl register.
Note: This is hooked up to a general purpose pin, might not
always be a DC to DC convertor. */

selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
selfcontrol |= HCB1;
else
selfcontrol &= ~HCB1;
writereg(dev, PP_SelfCTL, selfcontrol);

/* Wait for the DC/DC converter to power up - 500ms */
while (jiffies - timenow < HZ)
;
}

#define DETECTED_NONE 0
#define DETECTED_RJ45H 1
#define DETECTED_RJ45F 2
#define DETECTED_AUI 3
#define DETECTED_BNC 4

static int
detect_tp(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
int timenow = jiffies;
int fdx;

if (net_debug > 1) printk("%s: Attempting TPn", dev->name);

/* If connected to another full duplex capable 10-Base-T card the link pulses
seem to be lost when the auto detect bit in the LineCTL is set.
To overcome this the auto detect bit will be cleared whilst testing the
10-Base-T interface. This would not be necessary for the sparrow chip but
is simpler to do it anyway. */
writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
control_dc_dc(dev, 0);

/* Delay for the hardware to work out if the TP cable is present - 150ms */
for (timenow = jiffies; jiffies - timenow < 15; )
;
if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
return DETECTED_NONE;

if (lp->chip_type == CS8900) {
switch (lp->force & 0xf0) {
#if 0
case FORCE_AUTO:
printk("%s: cs8900 doesn't autonegotiaten",dev->name);
return DETECTED_NONE;
#endif
/* CS8900 doesn't support AUTO, change to HALF*/
case FORCE_AUTO:
lp->force &= ~FORCE_AUTO;
lp->force |= FORCE_HALF;
break;
case FORCE_HALF:
break;
case FORCE_FULL:
writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
break;
}
fdx = readreg(dev, PP_TestCTL) & FDX_8900;
} else {
switch (lp->force & 0xf0) {
case FORCE_AUTO:
lp->auto_neg_cnf = AUTO_NEG_ENABLE;
break;
case FORCE_HALF:
lp->auto_neg_cnf = 0;
break;
case FORCE_FULL:
lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
break;
}

writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);

if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
printk(KERN_INFO "%s: negotiating duplex...n",dev->name);
while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
if (jiffies - timenow > 4000) {
printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****n");
break;
}
}
}
fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
}
if (fdx)
return DETECTED_RJ45F;
else
return DETECTED_RJ45H;
}

/* send a test packet - return true if carrier bits are ok */
static int
send_test_pkt(struct net_device *dev)
{
char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
0, 46, /* A 46 in network order */
0, 0, /* DSAP=0 & SSAP=0 fields */
0xf3, 0 /* Control (Test Req + P bit set) */ };
long timenow = jiffies;

writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);

memcpy(test_packet, dev->dev_addr, ETH_ALEN);
memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);

writeword(dev, TX_CMD_PORT, TX_AFTER_ALL);
writeword(dev, TX_LEN_PORT, ETH_ZLEN);

/* Test to see if the chip has allocated memory for the packet */
while (jiffies - timenow < 5)
if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
break;
if (jiffies - timenow >= 5)
return 0; /* this shouldn't happen */

/* Write the contents of the packet */
outsw(dev->base_addr + TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);

if (net_debug > 1) printk("Sending test packet ");
/* wait a couple of jiffies for packet to be received */
for (timenow = jiffies; jiffies - timenow < 3; )
;
if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
if (net_debug > 1) printk("succeededn");
return 1;
}
if (net_debug > 1) printk("failedn");
return 0;
}

static int
detect_aui(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;

if (net_debug > 1) printk("%s: Attempting AUIn", dev->name);
control_dc_dc(dev, 0);

writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);

if (send_test_pkt(dev))
return DETECTED_AUI;
else
return DETECTED_NONE;
}

static int
detect_bnc(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;

if (net_debug > 1) printk("%s: Attempting BNCn", dev->name);
control_dc_dc(dev, 1);

writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);

if (send_test_pkt(dev))
return DETECTED_BNC;
else
return DETECTED_NONE;
}

static void
write_irq(struct net_device *dev, int chip_type, int irq)
{
int i;

if (chip_type == CS8900) {
/* Search the mapping table for the corresponding IRQ pin. */
for (i = 0; i != sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]); i++)
if (cs8900_irq_map[i] == irq)
break;
/* Not found */
if (i == sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
i = 3;
writereg(dev, PP_CS8900_ISAINT, i);
} else {
writereg(dev, PP_CS8920_ISAINT, irq);
}
}

/* Open/initialize the board. This is called (in the current kernel)
sometime after booting when the 'ifconfig' program is run.

This routine should set everything up anew at each open, even
registers that "should" only need to be set once at boot, so that
there is non-reboot way to recover if something goes wrong.
*/

/* AKPM: do we need to do any locking here? */

static int
net_open(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
int result = 0;
int i;
int ret;

if (dev->irq < 2) {
/* Allow interrupts to be generated by the chip */
/* Cirrus' release had this: */
#if 0
writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
#endif
/* And 2.3.47 had this: */
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);

for (i = 2; i < CS8920_NO_INTS; i++) {
if ((1 << dev->irq) & lp->irq_map) {
if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
dev->irq = i;
write_irq(dev, lp->chip_type, i);
/* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
break;
}
}
}

if (i >= CS8920_NO_INTS) {
writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
printk(KERN_ERR "cs89x0: can't get an interruptn");
ret = -EAGAIN;
goto bad_out;
}
} else {
if (((1 << dev->irq) & lp->irq_map) == 0) {
printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %xn",
dev->name, dev->irq, lp->irq_map);
ret = -EAGAIN;
goto bad_out;
}
/* FIXME: Cirrus' release had this: */
writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
/* And 2.3.47 had this: */
#if 0
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
#endif
write_irq(dev, lp->chip_type, dev->irq);
ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
if (ret) {
if (net_debug)
printk(KERN_DEBUG "cs89x0: request_irq(%d) failedn", dev->irq);
goto bad_out;
}
}

#if ALLOW_DMA
if (lp->use_dma) {
if (lp->isa_config & ANY_ISA_DMA) {
unsigned long flags;
lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
get_order(lp->dmasize * 1024));

if (!lp->dma_buff) {
printk(KERN_ERR "%s: cannot get %dK memory for DMAn", dev->name, lp->dmasize);
goto release_irq;
}
if (net_debug > 1) {
printk( "%s: dma %lx %lxn",
dev->name,
(unsigned long)lp->dma_buff,
(unsigned long)virt_to_bus(lp->dma_buff));
}
if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
!dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
printk(KERN_ERR "%s: not usable as DMA buffern", dev->name);
goto release_irq;
}
memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
if (request_dma(dev->dma, dev->name)) {
printk(KERN_ERR "%s: cannot get dma channel %dn", dev->name, dev->dma);
goto release_irq;
}
write_dma(dev, lp->chip_type, dev->dma);
lp->rx_dma_ptr = lp->dma_buff;
lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
spin_lock_irqsave(&lp->lock, flags);
disable_dma(dev->dma);
clear_dma_ff(dev->dma);
set_dma_mode(dev->dma, 0x14); /* auto_init as well */
set_dma_addr(dev->dma, virt_to_bus(lp->dma_buff));
set_dma_count(dev->dma, lp->dmasize*1024);
enable_dma(dev->dma);
spin_unlock_irqrestore(&lp->lock, flags);
}
}
#endif /* ALLOW_DMA */

/* set the Ethernet address */
for (i=0; i < ETH_ALEN/2; i++)
writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));

/* while we're testing the interface, leave interrupts disabled */
writereg(dev, PP_BusCTL, MEMORY_ON);

/* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
lp->linectl = LOW_RX_SQUELCH;
else
lp->linectl = 0;

/* check to make sure that they have the "right" hardware available */
switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
}
if (!result) {
printk(KERN_ERR "%s: EEPROM is configured for unavailable median", dev->name);
release_irq:
#if ALLOW_DMA
release_dma_buff(lp);
#endif
writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
free_irq(dev->irq, dev);
ret = -EAGAIN;
goto bad_out;
}

/* set the hardware to the configured choice */
switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
case A_CNF_MEDIA_10B_T:
result = detect_tp(dev);
if (result==DETECTED_NONE) {

#ifdef CONFIG_ARCH_S3C2410

#else
printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cablen", dev->name);
#endif
if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
#ifdef CONFIG_ARCH_S3C2410
result = DETECTED_RJ45F; /* Yes! I don't care if I see a link pulse */
#else
result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
#endif
}
break;
case A_CNF_MEDIA_AUI:
result = detect_aui(dev);
if (result==DETECTED_NONE) {
printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cablen", dev->name);
if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
}
break;
case A_CNF_MEDIA_10B_2:
result = detect_bnc(dev);
if (result==DETECTED_NONE) {
printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cablen", dev->name);
if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
}
break;
case A_CNF_MEDIA_AUTO:
writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
if (lp->adapter_cnf & A_CNF_10B_T)
if ((result = detect_tp(dev)) != DETECTED_NONE)
break;
if (lp->adapter_cnf & A_CNF_AUI)
if ((result = detect_aui(dev)) != DETECTED_NONE)
break;
if (lp->adapter_cnf & A_CNF_10B_2)
if ((result = detect_bnc(dev)) != DETECTED_NONE)
break;
printk(KERN_ERR "%s: no media detectedn", dev->name);
goto release_irq;
}
switch(result) {
case DETECTED_NONE:
printk(KERN_ERR "%s: no network cable attached to configured median", dev->name);
goto release_irq;
case DETECTED_RJ45H:
printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)n", dev->name);
break;
case DETECTED_RJ45F:
printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)n", dev->name);
break;
case DETECTED_AUI:
printk(KERN_INFO "%s: using 10Base-5 (AUI)n", dev->name);
break;
case DETECTED_BNC:
printk(KERN_INFO "%s: using 10Base-2 (BNC)n", dev->name);
break;
}

/* Turn on both receive and transmit operations */
writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);

/* Receive only error free packets addressed to this card */
lp->rx_mode = 0;
writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);

lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;

if (lp->isa_config & STREAM_TRANSFER)
lp->curr_rx_cfg |= RX_STREAM_ENBL;
#if ALLOW_DMA
set_dma_cfg(dev);
#endif
writereg(dev, PP_RxCFG, lp->curr_rx_cfg);

writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
#if ALLOW_DMA
dma_bufcfg(dev) |
#endif
TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);

/* now that we've got our act together, enable everything */
writereg(dev, PP_BusCTL, ENABLE_IRQ
| (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
#if ALLOW_DMA
| dma_busctl(dev)
#endif
);
netif_start_queue(dev);
if (net_debug > 1)
printk("cs89x0: net_open() succeededn");
return 0;
bad_out:
return ret;
}

static void net_timeout(struct net_device *dev)
{
/* If we get here, some higher level has decided we are broken.
There should really be a "kick me" function call instead. */
if (net_debug > 0) printk("%s: transmit timed out, %s?n", dev->name,
tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
/* Try to restart the adaptor. */
netif_wake_queue(dev);
}

static int net_send_packet(struct sk_buff *skb, struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;

if (net_debug > 3) {
printk("%s: sent %d byte packet of type %xn",
dev->name, skb->len,
(skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
}

/* keep the upload from being interrupted, since we
ask the chip to start transmitting before the
whole packet has been completely uploaded. */

spin_lock_irq(&lp->lock);
netif_stop_queue(dev);

/* initiate a transmit sequence */
writeword(dev, TX_CMD_PORT, lp->send_cmd);
writeword(dev, TX_LEN_PORT, skb->len);

/* Test to see if the chip has allocated memory for the packet */
if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
/*
* Gasp! It hasn't. But that shouldn't happen since
* we're waiting for TxOk, so return 1 and requeue this packet.
*/

spin_unlock_irq(&lp->lock);
if (net_debug) printk("cs89x0: Tx buffer not free!n");
return 1;
}
/* Write the contents of the packet */
outsw(dev->base_addr + TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
spin_unlock_irq(&lp->lock);
dev->trans_start = jiffies;
dev_kfree_skb (skb);

/*
* We DO NOT call netif_wake_queue() here.
* We also DO NOT call netif_start_queue().
*
* Either of these would cause another bottom half run through
* net_send_packet() before this packet has fully gone out. That causes
* us to hit the "Gasp!" above and the send is rescheduled. it runs like
* a dog. We just return and wait for the Tx completion interrupt handler
* to restart the netdevice layer
*/

return 0;
}

/* The typical workload of the driver:
Handle the network interface interrupts. */

static void net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
{
struct net_device *dev = dev_id;
struct net_local *lp;
int ioaddr, status;

ioaddr = dev->base_addr;
lp = (struct net_local *)dev->priv;

/* we MUST read all the events out of the ISQ, otherwise we'll never
get interrupted again. As a consequence, we can't have any limit
on the number of times we loop in the interrupt handler. The
hardware guarantees that eventually we'll run out of events. Of
course, if you're on a slow machine, and packets are arriving
faster than you can read them off, you're screwed. Hasta la
vista, baby! */
while ((status = readword(dev, ISQ_PORT))) {
if (net_debug > 4)printk("%s: event=%04xn", dev->name, status);
switch(status & ISQ_EVENT_MASK) {
case ISQ_RECEIVER_EVENT:
/* Got a packet(s). */
net_rx(dev);
break;
case ISQ_TRANSMITTER_EVENT:
lp->stats.tx_packets++;
netif_wake_queue(dev); /* Inform upper layers. */
if ((status & ( TX_OK |
TX_LOST_CRS |
TX_SQE_ERROR |
TX_LATE_COL |
TX_16_COL)) != TX_OK) {
if ((status & TX_OK) == 0) lp->stats.tx_errors++;
if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
}
break;
case ISQ_BUFFER_EVENT:
if (status & READY_FOR_TX) {
/* we tried to transmit a packet earlier,
but inexplicably ran out of buffers.
That shouldn't happen since we only ever
load one packet. Shrug. Do the right
thing anyway. */
netif_wake_queue(dev); /* Inform upper layers. */
}
if (status & TX_UNDERRUN) {
if (net_debug > 0) printk("%s: transmit underrunn", dev->name);
lp->send_underrun++;
if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
/* transmit cycle is done, although
frame wasn't transmitted - this
avoids having to wait for the upper
layers to timeout on us, in the
event of a tx underrun */
netif_wake_queue(dev); /* Inform upper layers. */
}
#if ALLOW_DMA
if (lp->use_dma && (status & RX_DMA)) {
int count = readreg(dev, PP_DmaFrameCnt);
while(count) {
if (net_debug > 5)
printk("%s: receiving %d DMA framesn", dev->name, count);
if (net_debug > 2 && count >1)
printk("%s: receiving %d DMA framesn", dev->name, count);
dma_rx(dev);
if (--count == 0)
count = readreg(dev, PP_DmaFrameCnt);
if (net_debug > 2 && count > 0)
printk("%s: continuing with %d DMA framesn", dev->name, count);
}
}
#endif
break;
case ISQ_RX_MISS_EVENT:
lp->stats.rx_missed_errors += (status >>6);
break;
case ISQ_TX_COL_EVENT:
lp->stats.collisions += (status >>6);
break;
}
}
}

static void
count_rx_errors(int status, struct net_local *lp)
{
lp->stats.rx_errors++;
if (status & RX_RUNT) lp->stats.rx_length_errors++;
if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
/* per str 172 */
lp->stats.rx_crc_errors++;
if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
return;
}

/* We have a good packet(s), get it/them out of the buffers. */
static void
net_rx(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
struct sk_buff *skb;
int status, length;

int ioaddr = dev->base_addr;
status = inw(ioaddr + RX_FRAME_PORT);
length = inw(ioaddr + RX_FRAME_PORT);

if ((status & RX_OK) == 0) {
count_rx_errors(status, lp);
return;
}

/* Malloc up new buffer. */
skb = dev_alloc_skb(length + 2);
if (skb == NULL) {
#if 0 /* Again, this seems a cruel thing to do */
printk(KERN_WARNING "%s: Memory squeeze, dropping packet.n", dev->name);
#endif
lp->stats.rx_dropped++;
return;
}
skb_reserve(skb, 2); /* longword align L3 header */
skb->dev = dev;

insw(ioaddr + RX_FRAME_PORT, skb_put(skb, length), length >> 1);
if (length & 1)
skb->data[length-1] = inw(ioaddr + RX_FRAME_PORT);

if (net_debug > 3) {
printk( "%s: received %d byte packet of type %xn",
dev->name, length,
(skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
}

skb->protocol=eth_type_trans(skb,dev);
netif_rx(skb);
dev->last_rx = jiffies;
lp->stats.rx_packets++;
lp->stats.rx_bytes += length;
}

#if ALLOW_DMA
static void release_dma_buff(struct net_local *lp)
{
if (lp->dma_buff) {
free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
lp->dma_buff = 0;
}
}
#endif

/* The inverse routine to net_open(). */
static int
net_close(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;

netif_stop_queue(dev);

writereg(dev, PP_RxCFG, 0);
writereg(dev, PP_TxCFG, 0);
writereg(dev, PP_BufCFG, 0);
writereg(dev, PP_BusCTL, 0);

free_irq(dev->irq, dev);

#if ALLOW_DMA
if (lp->use_dma && lp->dma) {
free_dma(dev->dma);
release_dma_buff(lp);
}
#endif

/* Update the statistics here. */
return 0;
}

/* Get the current statistics. This may be called with the card open or
closed. */
static struct net_device_stats *
net_get_stats(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
unsigned long flags;

spin_lock_irqsave(&lp->lock, flags);
/* Update the statistics from the device registers. */
lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
spin_unlock_irqrestore(&lp->lock, flags);

return &lp->stats;
}

static void set_multicast_list(struct net_device *dev)
{
struct net_local *lp = (struct net_local *)dev->priv;
unsigned long flags;

spin_lock_irqsave(&lp->lock, flags);
if(dev->flags&IFF_PROMISC)
{
lp->rx_mode = RX_ALL_ACCEPT;
}
else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
{
/* The multicast-accept list is initialized to accept-all, and we
rely on higher-level filtering for now. */
lp->rx_mode = RX_MULTCAST_ACCEPT;
}
else
lp->rx_mode = 0;

writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);

/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
(lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
spin_unlock_irqrestore(&lp->lock, flags);
}

static int set_mac_address(struct net_device *dev, void *addr)
{
int i;

if (netif_running(dev))
return -EBUSY;
if (net_debug) {
printk("%s: Setting MAC address to ", dev->name);
for (i = 0; i < 6; i++)
printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
printk(".n");
}
/* set the Ethernet address */
for (i=0; i < ETH_ALEN/2; i++)
writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));

return 0;
}

#ifdef MODULE

static struct net_device dev_cs89x0 = {
"",
0, 0, 0, 0,
0, 0,
0, 0, 0, NULL, NULL };

/*
* Support the 'debug' module parm even if we're compiled for non-debug to
* avoid breaking someone's startup scripts
*/

static int io;
static int irq;
static int debug;
static char media[8];
static int duplex=-1;

static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
static int dma;
static int dmasize=16; /* or 64 */

MODULE_PARM(io, "i");
MODULE_PARM(irq, "i");
MODULE_PARM(debug, "i");
MODULE_PARM(media, "c8");
MODULE_PARM(duplex, "i");
MODULE_PARM(dma , "i");
MODULE_PARM(dmasize , "i");
MODULE_PARM(use_dma , "i");
MODULE_PARM_DESC(io, "cs89x0 I/O base address");
MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
#if DEBUGGING
MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
#else
MODULE_PARM_DESC(debug, "(ignored)");
#endif
MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
/* No other value than -1 for duplex seems to be currently interpreted */
MODULE_PARM_DESC(duplex, "(ignored)");
#if ALLOW_DMA
MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
#else
MODULE_PARM_DESC(dma , "(ignored)");
MODULE_PARM_DESC(dmasize , "(ignored)");
MODULE_PARM_DESC(use_dma , "(ignored)");
#endif

MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>");
MODULE_LICENSE("GPL");

EXPORT_NO_SYMBOLS;

/*
* media=t - specify media type
or media=2
or media=aui
or medai=auto
* duplex=0 - specify forced half/full/autonegotiate duplex
* debug=# - debug level

* Default Chip Configuration:
* DMA Burst = enabled
* IOCHRDY Enabled = enabled
* UseSA = enabled
* CS8900 defaults to half-duplex if not specified on command-line
* CS8920 defaults to autoneg if not specified on command-line
* Use reset defaults for other config parameters

* Assumptions:
* media type specified is supported (circuitry is present)
* if memory address is > 1MB, then required mem decode hw is present
* if 10B-2, then agent other than driver will enable DC/DC converter
(hw or software util)

int
init_module(void)
{
struct net_local *lp;
int ret = 0;

#if DEBUGGING
net_debug = debug;
#else
debug = 0;
#endif

dev_cs89x0.irq = irq;
dev_cs89x0.base_addr = io;

dev_cs89x0.init = cs89x0_probe;
dev_cs89x0.priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
if (dev_cs89x0.priv == 0) {
printk(KERN_ERR "cs89x0.c: Out of memory.n");
return -ENOMEM;
}
memset(dev_cs89x0.priv, 0, sizeof(struct net_local));
lp = (struct net_local *)dev_cs89x0.priv;

#if ALLOW_DMA
if (use_dma) {
lp->use_dma = use_dma;
lp->dma = dma;
lp->dmasize = dmasize;
}
#endif

spin_lock_init(&lp->lock);

/* boy, they'd better get these right */
if (!strcmp(media, "rj45"))
lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
else if (!strcmp(media, "aui"))
lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
else if (!strcmp(media, "bnc"))
lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
else
lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;

if (duplex==-1)
lp->auto_neg_cnf = AUTO_NEG_ENABLE;

if (io == 0) {
printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.n");
printk(KERN_ERR "cs89x0.c: Append io=0xNNNn");
ret = -EPERM;
goto out;
}

#if ALLOW_DMA
if (use_dma && dmasize != 16 && dmasize != 64) {
printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dKn", dmasize);
ret = -EPERM;
goto out;
}
#endif

if (register_netdev(&dev_cs89x0) != 0) {
printk(KERN_ERR "cs89x0.c: No card found at 0x%xn", io);
ret = -ENXIO;
goto out;
}
out:
if (ret)
kfree(dev_cs89x0.priv);
return ret;
}

void
cleanup_module(void)
{
if (dev_cs89x0.priv != NULL) {
/* Free up the private structure, or leak memory :-) */
unregister_netdev(&dev_cs89x0);
outw(PP_ChipID, dev_cs89x0.base_addr + ADD_PORT);
kfree(dev_cs89x0.priv);
dev_cs89x0.priv = NULL; /* gets re-allocated by cs89x0_probe1 */
/* If we don't do this, we can't re-insmod it later. */
release_region(dev_cs89x0.base_addr, NETCARD_IO_EXTENT);
}
}
#endif /* MODULE */

/*
* Local variables:
* version-control: t
* kept-new-versions: 5
* c-indent-level: 8
* tab-width: 8
* End:
*
*/

2007-05-17T22:41:00.000+08:00

CGI

CGIstr.c

/*************************************************************************/
/** **/
/** getcgivars.c-- routine to read CGI input variables into an **/
/** array of strings. **/
/** **/
/** Written in 1996 by James Marshall, james@jmarshall.com, except **/
/** that the x2c() and unescape_url() routines were lifted directly **/
/** from NCSA's sample program util.c, packaged with their HTTPD. **/
/** **/
/** For the latest, see http://www.jmarshall.com/easy/cgi/ . **/
/** **/
/*************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/** Convert a two-char hex string into the char it represents. **/
char x2c(char *what)
{
register char digit;

digit = (what[0] >= 'A' ? ((what[0] & 0xdf) - 'A')+10 : (what[0] - '0'));
digit *= 16;
digit += (what[1] >= 'A' ? ((what[1] & 0xdf) - 'A')+10 : (what[1] - '0'));
return(digit);
}

/** Reduce any %xx escape sequences to the characters they represent. **/
void unescape_url(char *url)
{
register int i,j;

for(i=0,j=0; url[j]; ++i,++j) {
if((url[i] = url[j]) == '%') {
url[i] = x2c(&url[j+1]) ;
j+= 2 ;
}
}
url[i] = '0' ;
}

/** Read the CGI input and place all name/val pairs into list. **/
/** Returns list containing name1, value1, name2, value2, ... , NULL **/
char **getcgivars()
{
register int i ;
char *request_method ;
int content_length;
char *cgiinput ;
char **cgivars ;
char **pairlist ;
int paircount ;
char *nvpair ;
char *eqpos ;

/** Depending on the request method, read all CGI input into cgiinput. **/
request_method= getenv("REQUEST_METHOD") ;

if(request_method == NULL)
{
printf("request_method is NULLn");
request_method= "GET";
}

if (!strcmp(request_method, "GET") || !strcmp(request_method, "HEAD") ) {
/* Some servers apparently don't provide QUERY_STRING if it's empty, */
/* so avoid strdup()'ing a NULL pointer here. */
char *qs ;
qs = getenv("QUERY_STRING") ;

printf("<p>qs: %s</p>",qs);
if(qs == NULL)
{
printf("qs is NULLn");
qs = "http://192.168.0.200/cgi-bin/led_flash.cgi?checkedbox=LED0&checkedbox=LED2&submitbutton=Do+it%21";
}

cgiinput= strdup(qs ? qs : "") ;
}
else if (!strcmp(request_method, "POST")) {
/* strcasecmp() is not supported in Windows-- use strcmpi() instead */
if ( strcasecmp(getenv("CONTENT_TYPE"), "application/x-www-form-urlencoded")) {
printf("Content-Type: text/plainnn") ;
printf("getcgivars(): Unsupported Content-Type.n") ;
exit(1) ;
}
if ( !(content_length = atoi(getenv("CONTENT_LENGTH"))) ) {
printf("Content-Type: text/plainnn") ;
printf("getcgivars(): No Content-Length was sent with the POST request.n") ;
exit(1) ;
}
if ( !(cgiinput= (char *) malloc(content_length+1)) ) {
printf("Content-Type: text/plainnn") ;
printf("getcgivars(): Couldn't malloc for cgiinput.n") ;
exit(1) ;
}
if (!fread(cgiinput, content_length, 1, stdin)) {
printf("Content-Type: text/plainnn") ;
printf("getcgivars(): Couldn't read CGI input from STDIN.n") ;
exit(1) ;
}
cgiinput[content_length]='0' ;
}
else {
printf("Content-Type: text/plainnn") ;
printf("getcgivars(): Unsupported REQUEST_METHOD.n") ;
exit(1) ;
}

/** Change all plusses back to spaces. **/
for (i=0; cgiinput[i]; i++) if (cgiinput[i] == '+') cgiinput[i] = ' ' ;

/** First, split on "&" and ";" to extract the name-value pairs into **/
/** pairlist. **/
pairlist= (char **) malloc(256*sizeof(char **)) ;
paircount= 0 ;
nvpair= strtok(cgiinput, "&;?") ;
while (nvpair) {
pairlist[paircount++]= strdup(nvpair) ;
if (!(paircount%256))
pairlist= (char **) realloc(pairlist,(paircount+256)*sizeof(char **)) ;
nvpair= strtok(NULL, "&;") ;
}
pairlist[paircount]= 0 ; /* terminate the list with NULL */

/** Then, from the list of pairs, extract the names and values. **/
cgivars= (char **) malloc((paircount*2+1)*sizeof(char **)) ;
for (i= 0; i<paircount; i++) {
if (eqpos=strchr(pairlist[i], '=')) {
*eqpos= '0' ;
unescape_url(cgivars[i*2+1]= strdup(eqpos+1)) ;
} else {
unescape_url(cgivars[i*2+1]= strdup("")) ;
}
unescape_url(cgivars[i*2]= strdup(pairlist[i])) ;
}
cgivars[paircount*2]= 0 ; /* terminate the list with NULL */

/** Free anything that needs to be freed. **/
free(cgiinput) ;
for (i=0; pairlist[i]; i++) free(pairlist[i]) ;
free(pairlist) ;

/** Return the list of name-value strings. **/
return cgivars ;

}

/***************** end of the getcgivars() module ********************/

led_flash.c

/****************************************/
/** Creator PIO(LED) Test Program **/
/****************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <signal.h>
#include <strings.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <netdb.h>

//#include "led-creator.h"
#include "creator_s3c2410_lcd.h"

char **getcgivars();

int testLED(unsigned short data)
{
int fd, ret;
// unsigned short data;

fd = open("/dev/lcd", O_RDWR);
if (fd < 0){
printf("Open /dev/lcd errorn");
return (-1);
}
/*

Update the code

*/
// 點亮全部8 LED Lamps, 1 : 亮, 0 : 不亮
//data = 0xff; //LED_ALL_ON;
ioctl(fd, LED_IOCTL_SET, &data);
//sleep(3);
#if 0
// 點亮全部8 LED Lamps, 1 : 亮, 0 : 不亮
data = 0xff; //LED_ALL_ON;
ioctl(fd, LED_IOCTL_SET, &data);
sleep(3);

// 熄滅單一個D9之LED Lamp
data = 0x1; //LED_D9_INDEX;
ret = ioctl(fd, LED_IOCTL_BIT_CLEAR, &data);
sleep(3);

// 點亮單一個D9之LED Lamp
data = 0x1; //LED_D9_INDEX;
ret = ioctl(fd, LED_IOCTL_BIT_SET, &data);
#endif

close(fd);
return (ret);
}

//char * msg = "LED toggle! q-- exit,2- led on, 1-- led off n";

int main()
{
int i, j;
char** cgivars;
char *ptr;
char Index;
unsigned char value;

printf("Content-type: text/htmlnn");
printf("<html><head><title>CGI DEMO</title></head>n");
printf("<body bgcolor="#FFFFFF">n");
printf("<h1>Hello CGI World!</h1>n");

printf("If you can read this and you can see the LED flash, then the CGI worked.n");
printf("</body></html>n");
fflush(stdout);

cgivars = getcgivars();

#if 1
i = 0; value = 0;
while(cgivars[i] != 0)
{
printf("<p>%s = %s</p>n", cgivars[i], cgivars[i+1]);
ptr = cgivars[i+1];
Index = ptr[3] - '0';
//printf("ptr=%s, Index=%dn", ptr, Index);

value += (1 << Index);
i= i + 2;
// Compare cgivars with LEDx and then call LEDtest
}
#else
value = 0x55;
#endif

printf("LED data = %xn", value);
testLED(value);

free(cgivars);

return 0;
}

Banto Linux

To rebuild strace for ARM Platform

Dummy Block Driver for Linux

Dummy USB driver for Linux

Dummy PCI driver for Linux

Linux 2.6 驱动设计快速入门

移植 hello word

编译生成：

其他不同：

计数器：

没有 kdev_t 了

结构体初始化

malloc.h

内存池

结构体赋值

min() ， max()

原型变化

Devfs

字符设备

新的 file_operations

太极链；

驱动体系：

Build Kernel Module as KO files

Show build progress in verbose

lib path for glibc

bin path of gcc

header file path of Linux Kernel

obj-y

obj-m

arm linux 启动流程之 解压内核

Linux 下透過 GPRS 上網

移植KVM到arm-linux

CLDC 1.0.4 Fix for Red_Hat

ArmLinux 課程大綱 (PXA-270)

有趣的主題

Linux Package

Device Driver

JVM

Network

Web Page Editor

Forum

ArmLinux 相關網站

Linux Kernel 相關網站

arm-linux-gcc 下載網站

發展工具相關網站

系統建置

討論區

ArmLinux 相關書籍

應用程式設計

Linux 程式設計教學手冊 (基峰)

系統建置

Linux 技術手冊 (歐萊禮)

Linux 網路管理 (歐萊禮)

建構嵌入式 Linux 系統 (歐萊禮)

驅動程式設計

Linux 驅動程式 (歐萊禮)

ARM 架構

ARM 系統開發者指南 (全華)

深入了解用書

Linux 核心詳解 (歐萊禮)

Linux 網路原理 (歐萊禮)

Linux 系統管理 (歐萊禮)

gprof

Memory Leak

Backtrace

GDB advanced

USB DISK

Linux 系統設定檔

inittab

/etc/inittab

/etc/rc.d/rc.sysinit

/etc/rc.d/rc.modules

/etc/init.d/rcS

/etc/init.d/umountfs

建構 Insight 6.1

什麼是 Insight?

建構 Insight 6.1

使用Insight 與 gdbserver 除錯

後記

串列埠控制

arm linux 启动流程之解压内核