2.6.18内核下已经添加了完整的spi子系统了，参考mtd的分析，将从下到上层，再从上到下层的对其进行分析。
以下先从下到上的进行分析：
driver/spi下有两个底层相关的spi驱动程序：
spi_s3c24xx.c和spi_s3c24xx_gpio.c
其中spi_s3c24xx.c是基于s3c24xx下相应的spi接口的驱动程序，spi_s3c24xx_gpio.c允许用户指定3个gpio口，分别充当spi_clk、spi_mosi和spi_miso接口，模拟标准的spi总线。
s3c2410自带了两个spi接口(spi0和spi1)，在此我只研究基于s3c2410下spi接口的驱动程序spi_s3c24xx.c。
首先从spi驱动的检测函数进行分析：
static int
s3c24xx_spi_probe(struct platform_device *pdev)
{
struct s3c24xx_spi *hw;
struct spi_master *master;
struct spi_board_info *bi;
struct resource *res;
int err = 0;
int i;
/* pi_alloc_master函数申请了struct spi_master+struct s3c24xx_spi大小的数据， * spi_master_get_devdata和spi_master_get分别取出struct s3c24xx_spi和struct spi_master结构指针 */ master = spi_alloc_master(&pdev->dev, sizeof(struct s3c24xx_spi));
if (master == NULL) {
dev_err(&pdev->dev, "No memory for spi_master\n");
err = -ENOMEM;
goto err_nomem;
}
/* 填充struct spi_master结构 */ hw = spi_master_get_devdata(master);
memset(hw, 0, sizeof(struct s3c24xx_spi));
hw->master = spi_master_get(master);
hw->pdata = pdev->dev.platform_data;
hw->dev = &pdev->dev;
if (hw->pdata == NULL) {
dev_err(&pdev->dev, "No platform data supplied\n");
err = -ENOENT;
goto err_no_pdata;
}
platform_set_drvdata(pdev, hw);//dev_set_drvdata(&pdev->dev, hw)
init_completion(&hw->done);
/* setup the state for the bitbang driver */
/* 填充hw->bitbang结构(hw->bitbang结构充当一个中间层，相当与input system的input_handle struct) */ hw->bitbang.master = hw->master;
hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer;
hw->bitbang.chipselect = s3c24xx_spi_chipsel;
hw->bitbang.txrx_bufs = s3c24xx_spi_txrx;
hw->bitbang.master->setup = s3c24xx_spi_setup;
dev_dbg(hw->dev, "bitbang at %p\n", &hw->bitbang);
/* find and map our resources */
/* 申请spi所用到的资源：io、irq、时钟等 */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
err = -ENOENT;
goto err_no_iores;
}
hw->ioarea = request_mem_region(res->start, (res->end - res->start)+1,
pdev->name);
if (hw->ioarea == NULL) {
dev_err(&pdev->dev, "Cannot reserve region\n");
err = -ENXIO;
goto err_no_iores;
}
hw->regs = ioremap(res->start, (res->end - res->start)+1);
if (hw->regs == NULL) {
dev_err(&pdev->dev, "Cannot map IO\n");
err = -ENXIO;
goto err_no_iomap;
}
hw->irq = platform_get_irq(pdev, 0);
if (hw->irq < 0) {
dev_err(&pdev->dev, "No IRQ specified\n");
err = -ENOENT;
goto err_no_irq;
}
err = request_irq(hw->irq, s3c24xx_spi_irq, 0, pdev->name, hw);
if (err) {
dev_err(&pdev->dev, "Cannot claim IRQ\n");
goto err_no_irq;
}
hw->clk = clk_get(&pdev->dev, "spi");
if (IS_ERR(hw->clk)) {
dev_err(&pdev->dev, "No clock for device\n");
err = PTR_ERR(hw->clk);
goto err_no_clk;
}
/* for the moment, permanently enable the clock */
clk_enable(hw->clk);
/* program defaults into the registers */
/* 初始化spi相关的寄存器 */ writeb(0xff, hw->regs + S3C2410_SPPRE);
writeb(SPPIN_DEFAULT, hw->regs + S3C2410_SPPIN);
writeb(SPCON_DEFAULT, hw->regs + S3C2410_SPCON);
/* add by lfc */
s3c2410_gpio_setpin(S3C2410_GPE13, 0);
s3c2410_gpio_setpin(S3C2410_GPE12, 0);
s3c2410_gpio_cfgpin(S3C2410_GPE13, S3C2410_GPE13_SPICLK0);
s3c2410_gpio_cfgpin(S3C2410_GPE12, S3C2410_GPE12_SPIMOSI0);
s3c2410_gpio_cfgpin(S3C2410_GPE11, S3C2410_GPE11_SPIMISO0);
/* end add */
/* setup any gpio we can */
/* 片选 */
if (!hw->pdata->set_cs) {
s3c2410_gpio_setpin(hw->pdata->pin_cs, 1);
s3c2410_gpio_cfgpin(hw->pdata->pin_cs, S3C2410_GPIO_OUTPUT);
}
/* register our spi controller */
/* 最终通过调用spi_register_master来注册spi控制器(驱动) */ err = spi_bitbang_start(&hw->bitbang);
if (err) {
dev_err(&pdev->dev, "Failed to register SPI master\n");
goto err_register;
}
dev_dbg(hw->dev, "shutdown=%d\n", hw->bitbang.shutdown);
/* register all the devices associated */
/* 注册所用使用本spi驱动的设备 */ bi = &hw->pdata->board_info[0];
for (i = 0; i < hw->pdata->board_size; i++, bi++) {
dev_info(hw->dev, "registering %s\n", bi->modalias);
bi->controller_data = hw;
spi_new_device(master, bi);
}
return 0;
err_register:
clk_disable(hw->clk);
clk_put(hw->clk);
err_no_clk:
free_irq(hw->irq, hw);
err_no_irq:
iounmap(hw->regs);
err_no_iomap:
release_resource(hw->ioarea);
kfree(hw->ioarea);
err_no_iores:
err_no_pdata:
spi_master_put(hw->master);;
err_nomem:
return err;
}
/*
* spi_alloc_master - allocate SPI master controller
* @dev: the controller, possibly using the platform_bus
* @size: how much driver-private data to preallocate; the pointer to this
* memory is in the class_data field of the returned class_device,
* accessible with spi_master_get_devdata().
*
* This call is used only by SPI master controller drivers, which are the
* only ones directly touching chip registers. It's how they allocate
* an spi_master structure, prior to calling spi_register_master().
*
* This must be called from context that can sleep. It returns the SPI
* master structure on success, else NULL.
*
* The caller is responsible for assigning the bus number and initializing
* the master's methods before calling spi_register_master(); and (after errors
* adding the device) calling spi_master_put() to prevent a memory leak.
*/
/*注释已经写得很清楚了，本函数旨在分配spi_master struct *其中，device为主控制设备，size为需要预分配的设备私有数据大小 *该函数被spi主控制器驱动所调用，用于在调用spi_register_master注册主控制器前 *分配spi_master struct，分配bus number和初始化主控制器的操作方法 *注意在分配spi_master struct的时候多分配了大小为size的设备私有数据 *并通过spi_master_set_devdata函数把其放到class_data field里，以后可以通过spi_master_get_devdata来访问 */
struct spi_master * __init_or_module
spi_alloc_master(struct device *dev, unsigned size)
{
struct spi_master *master;
if (!dev)
return NULL;
master = kzalloc(size + sizeof *master, SLAB_KERNEL);
if (!master)
return NULL;
class_device_initialize(&master->cdev);
master->cdev.class = &spi_master_class;
master->cdev.dev = get_device(dev);
spi_master_set_devdata(master, &master[1]);
return master;
}
/*
* spi_bitbang_start - start up a polled/bitbanging SPI master driver
* @bitbang: driver handle
*
* Caller should have zero-initialized all parts of the structure, and then
* provided callbacks for chip selection and I/O loops. If the master has
* a transfer method, its final step should call spi_bitbang_transfer; or,
* that's the default if the transfer routine is not initialized. It should
* also set up the bus number and number of chipselects.
*
* For i/o loops, provide callbacks either per-word (for bitbanging, or for
* hardware that basically exposes a shift register) or per-spi_transfer
* (which takes better advantage of hardware like fifos or DMA engines).
*
* Drivers using per-word I/O loops should use (or call) spi_bitbang_setup and
* spi_bitbang_cleanup to handle those spi master methods. Those methods are
* the defaults if the bitbang->txrx_bufs routine isn't initialized.
*
* This routine registers the spi_master, which will process requests in a
* dedicated task, keeping IRQs unblocked most of the time. To stop
* processing those requests, call spi_bitbang_stop().
*/
int
spi_bitbang_start(struct spi_bitbang *bitbang)
{
int status;
if (!bitbang->master || !bitbang->chipselect)
return -EINVAL;
/*bitbang_work * 初始化a work，后面再create_singlethread_workqueue， * 等到有数据要传输的时候，在spi_bitbang_transfer函数中通过调用queue_work(bitbang->workqueue, &bitbang->work) * 把work扔进workqueue中调度运行 * 这是内核的一贯做法，在mmc/sd驱动中也是这样处理的^_^ */ INIT_WORK(&bitbang->work, bitbang_work, bitbang);
/* 初始化自旋锁和链表头，以后用到 */ spin_lock_init(&bitbang->lock);
spi_new_device INIT_LIST_HEAD(&bitbang->queue);
if (!bitbang->master->transfer)
bitbang->master->transfer = spi_bitbang_transfer;
//spi数据的传输就是通过调用这个方法来实现的 /* spi_s3c24xx.c驱动中有相应的txrx_bufs处理方法，在bitbang_work中被调用 */ if (!bitbang->txrx_bufs) {
bitbang->use_dma = 0;
bitbang->txrx_bufs = spi_bitbang_bufs;
if (!bitbang->master->setup) {
if (!bitbang->setup_transfer)
bitbang->setup_transfer =
spi_bitbang_setup_transfer;
bitbang->master->setup = spi_bitbang_setup;
bitbang->master->cleanup = spi_bitbang_cleanup;
}
/* spi_s3c24xx.c驱动中有相应的setup处理方法，在稍后的spi_new_device中被调用 */ } else if (!bitbang->master->setup)
return -EINVAL;
/* this task is the only thing to touch the SPI bits */
bitbang->busy = 0;
/* 创建工作者进程 */ bitbang->workqueue = create_singlethread_workqueue(
bitbang->master->cdev.dev->bus_id);
if (bitbang->workqueue == NULL) {
status = -EBUSY;
goto err1;
}
/* driver may get busy before register() returns, especially
* if someone registered boardinfo for devices
*/
status = spi_register_master(bitbang->master);
if (status < 0)
goto err2;
return status;
err2:
destroy_workqueue(bitbang->workqueue);
err1:
return status;
}
/**
* spi_register_master - register SPI master controller
* @master: initialized master, originally from spi_alloc_master()
*
* SPI master controllers connect to their drivers using some non-SPI bus,
* such as the platform bus. The final stage of probe() in that code
* includes calling spi_register_master() to hook up to this SPI bus glue.
*
* SPI controllers use board specific (often SOC specific) bus numbers,
* and board-specific addressing for SPI devices combines those numbers
* with chip select numbers. Since SPI does not directly support dynamic
* device identification, boards need configuration tables telling which
* chip is at which address.
*
* This must be called from context that can sleep. It returns zero on
* success, else a negative error code (dropping the master's refcount).
* After a successful return, the caller is responsible for calling
* spi_unregister_master().
*/
int __init_or_module
spi_register_master(struct spi_master *master)
{
static atomic_t dyn_bus_id = ATOMIC_INIT((1<<16) - 1);
struct device *dev = master->cdev.dev;
int status = -ENODEV;
int dynamic = 0;
if (!dev)
return -ENODEV;
/* convention: dynamically assigned bus IDs count down from the max */
if (master->bus_num < 0) {
master->bus_num = atomic_dec_return(&dyn_bus_id);
dynamic = 1;
}
/* register the device, then userspace will see it.
* registration fails if the bus ID is in use.
*/
snprintf(master->cdev.class_id, sizeof master->cdev.class_id,
"spi%u", master->bus_num);
status = class_device_add(&master->cdev);
//注册设备 if (status < 0)
goto done;
dev_dbg(dev, "registered master %s%s\n", master->cdev.class_id,
dynamic ? " (dynamic)" : "");
/* populate children from any spi device tables */
scan_boardinfo(master);
status = 0;
done:
return status;
}
/* FIXME someone should add support for a __setup("spi", ...) that
* creates board info from kernel command lines
*/
/* * scan board_list for spi_board_info which is registered by spi_register_board_info * 很可惜，s3c24xx的spi驱动中不支持spi_register_board_info这种标准方式注册方式，而是直接调用spi_new_device内部函数 */后记：
如果像atmel那样，初始化的时候调用
spi_register_board_info函数注册spi设备信息，那么调用
spi_register_master注册spi控制器的时候，就可以通过调用scan_boardinfo函数，完成spi设备的注册了^_^。static void __init_or_module
scan_boardinfo(struct spi_master *master)
{
struct boardinfo *bi;
struct device *dev = master->cdev.dev;
down(&board_lock);
list_for_each_entry(bi, &board_list, list) {
struct spi_board_info *chip = bi->board_info;
unsigned n;
for (n = bi->n_board_info; n > 0; n--, chip++) {
if (chip->bus_num != master->bus_num)
continue;
/* some controllers only have one chip, so they
* might not use chipselects. otherwise, the
* chipselects are numbered 0..max.
*/
if (chip->chip_select >= master->num_chipselect
&& master->num_chipselect) {
dev_dbg(dev, "cs%d > max %d\n",
chip->chip_select,
master->num_chipselect);
continue;
}
(void) spi_new_device(master, chip);
}
}
up(&board_lock);
}
/*
* Board-specific early init code calls this (probably during arch_initcall)
* with segments of the SPI device table. Any device nodes are created later,
* after the relevant parent SPI controller (bus_num) is defined. We keep
* this table of devices forever, so that reloading a controller driver will
* not make Linux forget about these hard-wired devices.
*
* Other code can also call this, e.g. a particular add-on board might provide
* SPI devices through its expansion connector, so code initializing that board
* would naturally declare its SPI devices.
*
* The board info passed can safely be __initdata ... but be careful of
* any embedded pointers (platform_data, etc), they're copied as-is.
*/
int __init
spi_register_board_info(struct spi_board_info const *info, unsigned n)
{
struct boardinfo *bi;
bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
if (!bi)
return -ENOMEM;
bi->n_board_info = n;
memcpy(bi->board_info, info, n * sizeof *info);
down(&board_lock);
list_add_tail(&bi->list, &board_list);
up(&board_lock);
return 0;
}
/* On typical mainboards, this is purely internal; and it's not needed
* after board init creates the hard-wired devices. Some development
* platforms may not be able to use spi_register_board_info though, and
* this is exported so that for example a USB or parport based adapter
* driver could add devices (which it would learn about out-of-band).
*/
struct spi_device *__init_or_module
spi_new_device(struct spi_master *master, struct spi_board_info *chip)
{
struct spi_device *proxy;
//这个结构很重要，以后就是通过这个结构来操作实际的spi设备的 struct device *dev = master->cdev.dev;
int status;
/* NOTE: caller did any chip->bus_num checks necessary */
if (!spi_master_get(master))
return NULL;
proxy = kzalloc(sizeof *proxy, GFP_KERNEL);
if (!proxy) {
dev_err(dev, "can't alloc dev for cs%d\n",
chip->chip_select);
goto fail;
}
/* 初始化spi_device 结构各成员 */ proxy->master = master;
proxy->chip_select = chip->chip_select;
proxy->max_speed_hz = chip->max_speed_hz;
proxy->mode = chip->mode;
proxy->irq = chip->irq;
proxy->modalias = chip->modalias;
snprintf(proxy->dev.bus_id, sizeof proxy->dev.bus_id,
"%s.%u", master->cdev.class_id,
chip->chip_select);
proxy->dev.parent = dev;
proxy->dev.bus = &spi_bus_type;
proxy->dev.platform_data = (void *) chip->platform_data;
proxy->controller_data = chip->controller_data;
proxy->controller_state = NULL;
proxy->dev.release = spidev_release;
/* drivers may modify this default i/o setup */
/* 调用master->setup(即s3c24xx_spi_setup)函数初始化spi设备 */ status = master->setup(proxy);
if (status < 0) {
dev_dbg(dev, "can't %s %s, status %d\n",
"setup", proxy->dev.bus_id, status);
goto fail;
}
/* driver core catches callers that misbehave by defining
* devices that already exist.
*/
status = device_register(&proxy->dev);
//真正注册原始设备 if (status < 0) {
dev_dbg(dev, "can't %s %s, status %d\n",
"add", proxy->dev.bus_id, status);
goto fail;
}
dev_dbg(dev, "registered child %s\n", proxy->dev.bus_id);
return proxy;
fail:
spi_master_put(master);
kfree(proxy);
return NULL;
}
好了，至此spi主控制器(驱动)和板上spi设备注册完毕，以后要使用spi来传输数据的话，只要先获得spi设备结构，然后就可以利用它来和spi驱动打交道了(就好像你要操作一个文件，先要获取文件句柄一样，明白吧^_^)static int
s3c24xx_spi_setup(struct spi_device *spi)
{
int ret;
/* 进行一些检查性操作 */ if (!spi->bits_per_word)
spi->bits_per_word = 8;
if ((spi->mode & SPI_LSB_FIRST) != 0)
return -EINVAL;
ret = s3c24xx_spi_setupxfer(spi, NULL);
if (ret < 0) {
dev_err(&spi->dev, "setupxfer returned %d\n", ret);
return ret;
}
dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n",
__FUNCTION__, spi->mode, spi->bits_per_word,
spi->max_speed_hz);
return 0;
}
static int
s3c24xx_spi_setupxfer(struct spi_device *spi,
struct spi_transfer *t)
{
struct s3c24xx_spi *hw = to_hw(spi);
unsigned int bpw;
unsigned int hz;
unsigned int div;
bpw = t ? t->bits_per_word : spi->bits_per_word;
hz = t ? t->speed_hz : spi->max_speed_hz;
if (bpw != 8) {
dev_err(&spi->dev, "invalid bits-per-word (%d)\n", bpw);
return -EINVAL;
}
div = clk_get_rate(hw->clk) / hz;
/* is clk = pclk / (2 * (pre+1)), or is it
* clk = (pclk * 2) / ( pre + 1) */
div = (div / 2) - 1;
//求出预分频值 if (div < 0)
div = 1;
if (div > 255)
div = 255;
dev_dbg(&spi->dev, "setting pre-scaler to %d (hz %d)\n", div, hz);
writeb(div, hw->regs + S3C2410_SPPRE);
//设置预分频值 spin_lock(&hw->bitbang.lock);
if (!hw->bitbang.busy) {
hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE);
//修改时钟，先禁用spi /* need to ndelay for 0.5 clocktick ? */
}
spin_unlock(&hw->bitbang.lock);
return 0;
}
static void
s3c24xx_spi_chipsel(struct spi_device *spi, int value)
{
struct s3c24xx_spi *hw = to_hw(spi);
unsigned int cspol = spi->mode & SPI_CS_HIGH ? 1 : 0;
unsigned int spcon;
switch (value) {
case BITBANG_CS_INACTIVE:
/* 禁用spi(禁用片选) */ if (hw->pdata->set_cs)
hw->pdata->set_cs(hw->pdata, value, cspol);
else
s3c2410_gpio_setpin(hw->pdata->pin_cs, cspol ^ 1);
break;
case BITBANG_CS_ACTIVE:
/* * 启用spi：根据需要设置寄存器并启用使能片选 * (如果spi_board_info中没有设置相应的mode选项的话，那就只能使用默认值SPPIN_DEFAULT和SPCON_DEFAULT了) */ spcon = readb(hw->regs + S3C2410_SPCON);
if (spi->mode & SPI_CPHA)
spcon |= S3C2410_SPCON_CPHA_FMTB;
else
spcon &= ~S3C2410_SPCON_CPHA_FMTB;
if (spi->mode & SPI_CPOL)
spcon |= S3C2410_SPCON_CPOL_HIGH;
else
spcon &= ~S3C2410_SPCON_CPOL_HIGH;
spcon |= S3C2410_SPCON_ENSCK;
/* write new configration */
writeb(spcon, hw->regs + S3C2410_SPCON);
if (hw->pdata->set_cs)
hw->pdata->set_cs(hw->pdata, value, cspol);
else
s3c2410_gpio_setpin(hw->pdata->pin_cs, cspol);
break;
}
}
posted @
2007-09-24 08:45 lfc 阅读(6326) |
评论 (5) |
编辑 收藏
#!/bin/sh
#
# What to do with this USB hotplug event?
#
case $ACTION in
add)
#echo $ACTION>/dev/tts/0
DIR="/dev/ub"
for I in "$DIR/"*;do
#echo $I>/dev/tts/0
if [ -d $I -a -e $I/part1 ];then
#echo "found&mount $I/part1">/dev/tts/0
mount -t vfat $I/part1 /mnt 2>/dev/tts/0
else
#echo "$I/part1 not found">/dev/tts/0
sleep 1;
if [ -d $I -a -e $I/part1 ];then
#echo "found&mount $I/part1">/dev/tts/0
mount -t vfat $I/part1 /mnt 2>/dev/tts/0
fi
fi
done
;;
remove)
#echo $ACTION>/dev/tts/0
#echo "umount /mnt">/dev/tts/0
umount /mnt 2>/dev/tts/0
;;
*)
exit 1
;;
esac
后记：
这脚本太简单了，建议使用usbautomount^_^。
posted @
2007-09-19 14:13 lfc 阅读(1000) |
评论 (0) |
编辑 收藏
下面研究一下系统总线地址(cpu_addr)、宽度(bus_width)与nor flash设备总线地址(device_addr)、位度(device_width)的区别与联系：
一、对于nor flash设备来说
1、nor flash设备的位宽视芯片厂商而定，有x8、x16两总方式(虽然现在主要使用x16的方式，不过内核于启动代码里面仍然保留着对x8和x16两种方式的支持);把多片nor flash并起来使用可以扩大位宽(比如两片x8的nor flash并起来使用位宽扩大为x16)。
2、nor flash设备的总线地址(寻址)范围视具体芯片以及其采用的位宽而定：
以富士通的29LV650为例:
(29LV650的容量是8Mbyte,共128个sector，每个sector的大小是64 kbyte）
1)如果选择位宽为x8，设备总线的每个地址代表了一个byte的存储单元，固其总线地址范围为8M(0x000000~0x7fffff);
2)如果选择位宽为x16，设备总线的每个地址代表了两个byte的存储单元，固其总线地址范围为4M(0x000000~0x3fffff);
再来看看intel的E29F128：
(E29F128的容量为16Mbyte,共128个sector,每个sector的大小是128Kbyte)
1)如果选择位宽为x8,设备总线的每个地址代表了一个byte的存储单元，固其总线地址范围为16M(0x000000~0xffffff);
2)如果选择位宽为x16,情况和富士通的29LV650不同，这时候设备的A0脚不可用，所以你不能访问到奇地址的存储单元，而只能0、2、4...地址的来访问，其总线地址范围为8M(0x000000~0xffffff的偶地址)
二、对于系统来说
以S3C2410为例，cpu总线宽度是32位，可以通过8、16、32位的总线宽度来访问nor flash设备，视设备的位宽和是否并起来使用而定：
注：
buswidth=device_width*interleave：
然而，在cpu的眼里，每一个地址代表1byte的存储单元，不像nor flash设备那样，还有byte、word之分。
三、好了，了解了系统总线地址、宽度与nor flash设备总线地址、位宽后的区别后，
现在讨论一下cpu与nor flash的接法问题(通过举例来说明)：
1、对于富士通的29LV650
1)选择x8方式，cpu的A0~A22接nor flash的A0~A22
2)选择x16方式，cpu的A1~A22接nor flash的A0~A21
注意：
cpu的A1接nor flash的A0，cpu只能访问偶地址，cpu的一次操作访问了2byte大小的存储单元。
2、对于intel的E29F128
1)选择x8方式，cpu的A0~A23接nor flash的A0~A23
2)选择x16方式，由于这时候地址线A0不再有效(这点与富士通的29LV650不同)，
intel E29F128的A1等价于富士通的29LV650的A0,所以系统总线A1~A23接nor flash的A1~A23
四、在cpu对nor flash寻址方面
1、对于富士通的29LV650
1)在x8模式，系统总线和nor flash总线一一对应，直接访问
2)在x16模式，nor flash的对外总线缩小一半，一个地址可寻址的存储单元由原来的1 byte变为1 word(1 sector的地址范围由原来的1<<16变为1<<15)，所以我们对其进行寻址的时候，需要把所要寻址的存储单元地址>>1位
注意：
我这里说的是以byte为单位的存储单元地址
由于系统总线的A1接nor flash的A0，固系统总线地址等于nor flash总线地址<<1位
注意：
我这里说的是nor flash的总线地址，对于x8方式以byte为单位，对于x16方式以word为单位
2、对于intel的E29F128
1)在x8模式，系统总线和nor flash总线一一对应，直接访问
2)在x16模式，nor flash总线的A0不再使用，有效的总线为A1~A23,所以我们对其寻址的时候，不必像富士通的29LV650那样需要把所要访问的存储单元地址>>1位(因为A0不再有效，等于奇地址自动被忽略，只有偶地址起作用)
同样：
由于nor flash总线的A0不起作用，系统总线的A1接nor flash的A1，所以我们只要直接给出存储单元的地址即可，不比对其进行<<1位操作(不过由于设备总线A0不起作用，所以系统只能访问到偶地址的存储单元，奇地址将会被忽略)
后记：
看了以上对系统总线和nor flash总线的介绍后，是否觉得很难理解？不过不要紧，因为我们访问nor flash存储单元的时候，其实我们只需要操作系统总线就行，至于系统总线是如何转化成nor flash所需要的总线地址，这个由cpu与nor flash的硬件接法帮你解决，是硬件工程师的事情。
呵呵，这样想的话，是否清晰很多了^_^
posted @
2007-09-17 08:41 lfc 阅读(1462) |
评论 (0) |
编辑 收藏
摘要: 上一个贴由下到上的介绍了FLASH硬件驱动是如何与MTD原始设备建立联系的，现在再由上到下的研究一下是如何通过MTD原始设备来访问FLASH硬件驱动的。首先分析一下如何通过MTD原始设备进而通过FLASH硬件驱动来读取FLASH存储器的数据。引用自<<Linux系统移植>>一文："读Nand Flash：当对nand flash的设备文件(nand flash在/dev下对...
阅读全文
posted @
2007-09-04 16:18 lfc 阅读(9778) |
评论 (1) |
编辑 收藏
摘要: 看了<<Linux MTD源代码分析>>后对以MTD的分层结构以及各层的分工情况有了大致的了解，然而各层之间是如何进行对话的呢，对于这个问题，<<Linux MTD源代码分析>>上没有详细的去说明。小弟抽空研究了一下，打算从下到上，在从上到下，分两条主线来研究一下MTD原始设备与FLASH硬件驱动的对话(MTD原始设备与更上层的对话留待以后再研究)。...
阅读全文
posted @
2007-08-31 11:51 lfc 阅读(15518) |
评论 (5) |
编辑 收藏
上文介绍了input_dev
、input_handle、input_handler三者是如何联系起来了，现在继续介绍如何通过它们来传递信息。
在开始之前还是先引用一位大侠的帖子：
引：
现在看用户获取触摸屏输入的一个流程(以tsdev为例/drivers/input/tsdev.c)：
static struct file_operations tsdev_fops = {
.owner = THIS_MODULE,
.open = tsdev_open,
.release = tsdev_release,
.read = tsdev_read,
.poll = tsdev_poll,
.fasync = tsdev_fasync,
.ioctl = tsdev_ioctl,
};
假设所有初始化早已完成，用户open该设备后，使用read系统调用进入内核，系统
转移控制到tsdev_read，使用wait_event_interruptible等待事件。
此时驱动层得到用户输入，于是调用input_report_abs，input_report_abs只是
input_event的简单包装：
static inline void input_report_abs(struct input_dev *dev,
unsigned int code, int value)
{
input_event(dev, EV_ABS, code, value);
}
void input_event(struct input_dev *dev, unsigned int type,
unsigned int code, int value)
{
...
switch (type) {
...
case EV_ABS:
...
break;
...
}
...
if (dev->grab)
dev->grab->handler->event(dev->grab, type, code, value);
else
list_for_each_entry(handle, &dev->h_list, d_node)
if (handle->open)
handle->handler->event(handle, type, code, value);
}
前面的处理关系具体设备，见最后对handler函数的调用，就是从input_dev的h_list链
上的input_handle获得每一个相关input_handler，并调用其中的event函数，对tsdev
来说：
static struct input_handler tsdev_handler = {
.event = tsdev_event,
.connect = tsdev_connect,
.disconnect = tsdev_disconnect,
.fops = &tsdev_fops,
.minor = TSDEV_MINOR_BASE,
.name = "tsdev",
.id_table = tsdev_ids,
};
即调用tsdev_event函数，接着看：
static void tsdev_event(struct input_handle *handle, unsigned int type,
unsigned int code, int value)
{
...
switch (type) {
case EV_ABS:
break;
...
list_for_each_entry(list, &tsdev->list, node) {
int x, y, tmp;
do_gettimeofday(&time);
list->event[list->head].millisecs = time.tv_usec / 100;
list->event[list->head].pressure = tsdev->pressure;
x = tsdev->x;
y = tsdev->y;
/* Calibration */
if (!list->raw) {
x = ((x * tsdev->cal.xscale) >> 8) + tsdev->cal.xtrans;
y = ((y * tsdev->cal.yscale) >> 8) + tsdev->cal.ytrans;
if (tsdev->cal.xyswap) {
tmp = x; x = y; y = tmp;
}
}
list->event[list->head].x = x;
list->event[list->head].y = y;
list->head = (list->head + 1) & (TSDEV_BUFFER_SIZE - 1);
kill_fasync(&list->fasync, SIGIO, POLL_IN);
}
wake_up_interruptible(&tsdev->wait);
}
它填充数据，并唤醒等待着的请求。于是前面等待着的read请求就可继续了，
回到tsdev_read中，copy_to_user拷贝数据，最后返回用户层。
一个简单流程就结束了。
注： 原文请看以下网址：http://bbs.ustc.edu.cn/cgi/bbstcon?board=Kernel&file=M.1179398612.A看了以上的内容，相信你对2.6内核的输入子系统的消息传递过程应该有个大概的了解了，现在我就如何通过input_dev
、input_handle、input_handler这三者传递信息进行详细的分析：
################
从<tsdev.c>开始
################
static ssize_t tsdev_read(struct file *file, char __user *buffer, size_t count,
loff_t * ppos)
{
struct tsdev_list *list = file->private_data;
int retval = 0;
/* 设备存在(exist=1:在tsdev_connect函数里设置)，但缓冲中无数据，而又配置为非阻塞读取方式，直接返回 */
if (list->head == list->tail && list->tsdev->exist && (file->f_flags & O_NONBLOCK))
return -EAGAIN;
/* 否则睡眠等待数据都来临 */
retval = wait_event_interruptible(list->tsdev->wait,
list->head != list->tail || !list->tsdev->exist);
/* 被信号中断唤醒，直接返回 */
if (retval)
return retval;
/* 检查设备是否还存在，不存在(exist=0:在tsdev_disconnect函数中设置)的话直接返回 */
if (!list->tsdev->exist)
return -ENODEV;
/* 有数据，循环读取用户所需要都数据 */
while (list->head != list->tail &&
retval + sizeof (struct ts_event) <= count) {
if (copy_to_user (buffer + retval, list->event + list->tail,
sizeof (struct ts_event)))
return -EFAULT;
list->tail = (list->tail + 1) & (TSDEV_BUFFER_SIZE - 1);//更新读指针
retval += sizeof (struct ts_event);//更新读字节数
}
return retval;
}
#################
<s3c2410-ts.c>
#################
input_report_abs(&ts.dev, ABS_X, ts.xp);
input_report_abs(&ts.dev, ABS_Y, ts.yp);
input_report_key(&ts.dev, BTN_TOUCH, 1);
input_report_abs(&ts.dev, ABS_PRESSURE, 1);
input_sync(&ts.dev);
###########################
<input.h>
###########################
static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_ABS, code, value);
}
##########################
<input.c>
##########################
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct input_handle *handle;
........................................................................................................
switch (type) {
case EV_ABS:
if (code > ABS_MAX || !test_bit(code, dev->absbit))//一些条件测试
return;
if (dev->absfuzz[code]) {
if ((value > dev->abs[code] - (dev->absfuzz[code] >> 1)) &&
(value < dev->abs[code] + (dev->absfuzz[code] >> 1)))
return;
if ((value > dev->abs[code] - dev->absfuzz[code]) &&
(value < dev->abs[code] + dev->absfuzz[code]))
value = (dev->abs[code] * 3 + value) >> 2;
if ((value > dev->abs[code] - (dev->absfuzz[code] << 1)) &&
(value < dev->abs[code] + (dev->absfuzz[code] << 1)))
value = (dev->abs[code] + value) >> 1;
}
if (dev->abs[code] == value)//比较当前值与上一次都值是否相同，相同则不作处理
return;
dev->abs[code] = value;//备份当前值，以便下一次作比较
break;
...............................................................................................................
if (type != EV_SYN)
dev->sync = 0;
if (dev->grab)
dev->grab->handler->event(dev->grab, type, code, value);
else
list_for_each_entry(handle, &dev->h_list, d_node)//通过input_dev找出与其联系的input_handle
if (handle->open)//相应的接口设备(比如tsdev)被打开(通过调用tsdev.c的tsdev_open函数进而调用input_open_device
函数增加handle->open的计数值)
handle->handler->event(handle, type, code, value);//调用该接口设备的event函数对数据进行处理
}
################
在<tsdev.c>结束
################
static void tsdev_event(struct input_handle *handle, unsigned int type,
unsigned int code, int value)
{
struct tsdev *tsdev = handle->private;
struct tsdev_list *list;
struct timeval time;
switch (type) {
case EV_ABS:
switch (code) {
case ABS_X:
tsdev->x = value;//记录x坐标值
break;
case ABS_Y:
tsdev->y = value;//记录y坐标值
break;
case ABS_PRESSURE:
if (value > handle->dev->absmax[ABS_PRESSURE])
value = handle->dev->absmax[ABS_PRESSURE];
value -= handle->dev->absmin[ABS_PRESSURE];
if (value < 0)
value = 0;
tsdev->pressure = value;//记录触摸屏的按压状态
break;
}
break;
...................................................................................................
if (type != EV_SYN || code != SYN_REPORT)//键值的传递以EV_SYN为结束标志(通过input_sync函数)，等到数据都填充好tsdev结构后再统一发送出去，否则直接返回，继续填充另一个数据
return;
list_for_each_entry(list, &tsdev->list, node) { //通过tsdev获取struct tsdev_list结构(在tsdev_open函数中定义):
//list_add_tail(&list->node, &tsdev_table[i]->list);
int x, y, tmp;
do_gettimeofday(&time); //填充事件的时间
list->event[list->head].millisecs = time.tv_usec / 100;
list->event[list->head].pressure = tsdev->pressure;//填充触摸屏的状态
x = tsdev->x;
y = tsdev->y;
/* Calibration */
if (!list->raw) {
x = ((x * tsdev->cal.xscale) >> 8) + tsdev->cal.xtrans;
y = ((y * tsdev->cal.yscale) >> 8) + tsdev->cal.ytrans;
if (tsdev->cal.xyswap) {
tmp = x; x = y; y = tmp;
}
}
list->event[list->head].x = x; //填充x坐标值
list->event[list->head].y = y; //填充y坐标值
list->head = (list->head + 1) & (TSDEV_BUFFER_SIZE - 1);//更新写指针
kill_fasync(&list->fasync, SIGIO, POLL_IN);
}
wake_up_interruptible(&tsdev->wait);//唤醒睡眠在tsdev->wait下等待数据都进程读取数据。至此，数据传递过程结束，开始新一轮的数据传递。
}
posted @
2007-08-27 08:58 lfc 阅读(5426) |
评论 (1) |
编辑 收藏
前面对s3c2410的触摸屏驱动进行了分析，现深入一层，对其所在的输入子系统进行刺探。
首先引用一个不错的帖子，对2.6内核的输入子系统进行一个大致的描述：
引：
在做触摸屏？对于输入子系统，相信你也早看了网上一些介绍文章文章了，
读一下就可了解对其基本架构，剩下的只是一些源码细节阅读。
输入子系统的3层间的联系是很简单的，驱动层的核心结构为struct input_dev：
struct input_dev {
...
struct list_head h_list;
...
};
在input_register_device时就会将input_dev与input_handle联系起来；
所谓联系就是将有关的input_handle链入以input_dev中h_list为Hash头的链中；
而事件处理层的核心结构是struct input_handler：
struct input_handler {
...
struct list_head h_list;
...
};
在input_register_handler时同样会将input_handler与input_handle联系起来，
所谓联系就是将有关的input_handle链入以input_handler中h_list为Hash头的链中；
由上可见input_handle即是一个用于关联驱动层input_dev和事件处理
层input_handler的中间结构：
struct input_handle {
...
struct input_dev *dev;
struct input_handler *handler;
struct list_head d_node;
struct list_head h_node;
};
其中d_node用于input_dev链，h_node用于input_handler链，有了input_handle，
就把相关dev与handler联系起来，相互能容易的找到。
注： 原文请看一下网址：http://bbs.ustc.edu.cn/cgi/bbstcon?board=Kernel&file=M.1179398612.A看了以上的内容，相信你对2.6内核的输入子系统应该有个大概的了解了，
现在我就input_dev
、input_handle、input_handler这三者建立联系的过程进行详细的分析：
触摸屏驱动中，s3c2410ts_probe函数的最后一步，调用input_register_device函数开始进入三者建立联系的过程：
void input_register_device(struct input_dev *dev)
{
struct input_handle *handle;
struct input_handler *handler;
struct input_device_id *id;
........................................................................................
INIT_LIST_HEAD(&dev->h_list);
list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)
if (!handler->blacklist || !input_match_device(handler->blacklist, dev))
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
..........................................................................................
}
注：
我只保留重要的部分，省略号部分不是我关心的，以下同。
list_for_each_entry(handler, &input_handler_list, node)的作用在于：
从input_handler_list的链表中提取input_handler的指针。
##################################################################################
那这个input_handler的指针又是何时存放在input_handler_list链表里面的呢？
答案是像tsdev.c这些接口驱动里面调用input_register_handler
进而调用list_add_tail(&handler->node, &input_handler_list);
把其input_handler指针加进input_handler_list里面，详细请查看源码，在此不做详细分析。
###################################################################################
获取了input_handler指针后通过input_match_device进行匹配选择：
static struct input_device_id *input_match_device(struct input_device_id *id, struct input_dev *dev)
{
int i;
for (; id->flags || id->driver_info; id++) {
................................................................
MATCH_BIT(evbit, EV_MAX);
MATCH_BIT(keybit, KEY_MAX);
MATCH_BIT(relbit, REL_MAX);
MATCH_BIT(absbit, ABS_MAX);
MATCH_BIT(mscbit, MSC_MAX);
MATCH_BIT(ledbit, LED_MAX);
MATCH_BIT(sndbit, SND_MAX);
MATCH_BIT(ffbit, FF_MAX);
MATCH_BIT(swbit, SW_MAX);
return id;
}
return NULL;
}
该函数拿刚才获得的input_handler指针所拥有的特性表handler->id_table
与我们所注册的input_dev的特性表dev.id进行对照。
仍以触摸屏驱动s3c2410-ts.c与触摸屏接口tsdev.c为例：
s3c2410-ts.c：
ts.dev.evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
ts.dev.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
input_set_abs_params(&ts.dev, ABS_X, 0, 0x3FF, 0, 0);
input_set_abs_params(&ts.dev, ABS_Y, 0, 0x3FF, 0, 0);
input_set_abs_params(&ts.dev, ABS_PRESSURE, 0, 1, 0, 0);
ts.dev.id.bustype = BUS_RS232;
ts.dev.id.vendor = 0xDEAD;
ts.dev.id.product = 0xBEEF;
ts.dev.id.version = S3C2410TSVERSION;
tsdev.c：
static struct input_device_id tsdev_ids[] = {
{
.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_RELBIT,
.evbit = { BIT(EV_KEY) | BIT(EV_REL) },
.keybit = { [LONG(BTN_LEFT)] = BIT(BTN_LEFT) },
.relbit = { BIT(REL_X) | BIT(REL_Y) },
},/* A mouse like device, at least one button, two relative axes */
{
.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT
| INPUT_DEVICE_ID_MATCH_ABSBIT,
.evbit = { BIT(EV_KEY) | BIT(EV_ABS) },
.keybit = { [LONG(BTN_TOUCH)] = BIT(BTN_TOUCH) },
.absbit = { BIT(ABS_X) | BIT(ABS_Y) },
},/* A tablet like device, at least touch detection, two absolute axes */
{
.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_ABSBIT,
.evbit = { BIT(EV_ABS) },
.absbit = { BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE) },
},/* A tablet like device with several gradations of pressure */
{},/* Terminating entry */
};
可以看到，tsdev.c接口定义了三项特性，对应id为0、1、2，
input_match_device函数依次取出其中的选项与s3c2410-ts.c里面定义的input_dev的选项进行对比。
这里对比的标准是tsdev.c里面定义的选项s3c2410-ts.c里面必须满足，否则continue，继续判断下一个id号的选项。
详细请看MATCH_BIT这个宏的定义：
#define MATCH_BIT(bit, max) \
for (i = 0; i < NBITS(max); i++) \
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
break; \
if (i != NBITS(max)) \
continue;
例如：
在这里，tsdev.c定义的id为0的选项里面定义的BIT(EV_REL)这一项
在s3c2410-ts.c里面定义的input_dev设备上是不具备的，
所以，执行到MATCH_BIT(evbit, EV_MAX);后直接continue，
继续判断tsdev.c里面id为1的选项，直到找到合适的，然后返回真，否则返回NULL。
###########################################################################################
在list_for_each_entry(handler, &input_handler_list, node)
这个大循环里与我们所注册的input_dev所匹配的不限于一个接口，
例如，以下是我的调试记录：
s3c2410 TouchScreen successfully loaded
kbd
input_match_device
mousedev
input_match_device
mousedev_connect
joydev
input_match_device
evdev
input_match_device
evdev_connect
tsdev
input_match_device
tsdev_connect
evbug
input_match_device
evbug_connect
可以看到，对于s3c2410-ts.c里面定义的input_dev设备，同时与其匹配的就有
mousedev、evdev、tsdev、evbug等众多接口(不知道我的理解是否正确，如果理解错了，还望指正^_^)
###########################################################################################
找到匹配的选项以后，就可以开始着手把input_dev、input_handle、input_handler这三者联系齐来了，具体调用
handle = handler->connect(handler, dev, id)函数，
主要的目的是填充input_handle结构，然后接着调用
input_link_handle(handle)函数：
static void input_link_handle(struct input_handle *handle)
{
list_add_tail(&handle->d_node, &handle->dev->h_list);
list_add_tail(&handle->h_node, &handle->handler->h_list);
}
看到吧，就是上面那位大侠提到的，把input_handle分别链入input_dev和input_handler中h_list为Hash头的链中。
好了，到此，input_dev、input_handle、input_handler这三者总算是联系起来了^_^
posted @
2007-08-24 15:33 lfc 阅读(6623) |
评论 (0) |
编辑 收藏
驱动不是很多，在此把它贴出来然后加上必要的注释：
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/arch/regs-adc.h>
#include <asm/arch/regs-gpio.h>
#include <asm/arch/s3c2410-ts.h>
#include <asm/hardware/clock.h>
/* For ts.dev.id.version */
#define S3C2410TSVERSION 0x0101
#define WAIT4INT(x) (((x)<<8) | S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | S3C2410_ADCTSC_XY_PST(3))
#define AUTOPST (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))
#define DEBUG_LVL KERN_DEBUG
MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
MODULE_DESCRIPTION("s3c2410 touchscreen driver");
MODULE_LICENSE("GPL");
/*
* Definitions & global arrays.
*/
static char *s3c2410ts_name = "s3c2410 TouchScreen";
/*
* Per-touchscreen data.
*/
struct s3c2410ts {
struct input_dev dev;
long xp;
long yp;
int count;
int shift;
char phys[32];
};
static struct s3c2410ts ts;
static void __iomem *base_addr;
static inline void s3c2410_ts_connect(void)
{
s3c2410_gpio_cfgpin(S3C2410_GPG12, S3C2410_GPG12_XMON);
s3c2410_gpio_cfgpin(S3C2410_GPG13, S3C2410_GPG13_nXPON);
s3c2410_gpio_cfgpin(S3C2410_GPG14, S3C2410_GPG14_YMON);
s3c2410_gpio_cfgpin(S3C2410_GPG15, S3C2410_GPG15_nYPON);
}
static void
touch_timer_fire(unsigned long data)
{
unsigned long data0;
unsigned long data1;
int updown;
/*
读取stylus的状态
0 = Stylus down state
1 = Stylus up state
*/
data0 = readl(base_addr+S3C2410_ADCDAT0);
data1 = readl(base_addr+S3C2410_ADCDAT1);
updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT1_UPDOWN));
/*
更新stylus状态寄存器updown：
1 = down
0 = up
*/
/*
touch_timer_fire这个函数主要实现以下功能：
1、stylus down的时候，在中断函数
stylus_updown里面被调用，
此时缓存区没有数据，ts.count为0，所以只是简单的设置ad转换的模式，然后开启ad转换。
2、但ADC中断函数stylus_action把缓冲区填满的时候，作为中断后半段函数稍后被调用，
此时ts.count为4，算出其平均值后，交给事件处理层(Event Handler)处理，
主要是填写缓冲，然后唤醒等待输入数据的进程。
3、stylus抬起，等到缓冲区填满后(可能会包含一些无用的数据)被调用，
这时候判断出
stylus up，报告
stylus up事件，重新等待
stylus down。
if (updown) {
if (ts.count != 0) { <功能2>
/* 求平均值 */
ts.xp >>= ts.shift;
ts.yp >>= ts.shift;
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
{
struct timeval tv;
do_gettimeofday(&tv);
printk(DEBUG_LVL "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts.xp, ts.yp);
}
#endif
/* 报告x、y的绝对坐标值 */
input_report_abs(&ts.dev, ABS_X, ts.xp);
input_report_abs(&ts.dev, ABS_Y, ts.yp);
/* 报告按键事件，键值为1(代表触摸屏对应的按键被按下) */
input_report_key(&ts.dev, BTN_TOUCH, 1);
/* 报告触摸屏的状态，1表明触摸屏被按下 */
input_report_abs(&ts.dev, ABS_PRESSURE, 1);
/* 等待接收方受到数据后回复确认，用于同步 */
input_sync(&ts.dev);
}
<功能1>
ts.xp = 0;
ts.yp = 0;
ts.count = 0;
writel(S3C2410_ADCTSC_XP_PULL_UP_DIS | AUTOPST, base_addr+S3C2410_ADCTSC);
/* 设置触摸屏的模式为AUTOPST */
writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
/* 启动ADC转换 */
}
else { <功能3>
ts.count = 0;
/* 报告按键事件，键值为1(代表触摸屏对应的按键被释放) */
input_report_key(&ts.dev, BTN_TOUCH, 0);
/* 报告触摸屏的状态，0表明触摸屏没被按下 */
input_report_abs(&ts.dev, ABS_PRESSURE, 0);
/* 等待接收方受到数据后回复确认，用于同步 */
input_sync(&ts.dev);
/* 进入s3c2410触摸屏提供的,Waiting for Interrupt Mode，waits for Stylus down */
writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
}
}
static struct timer_list touch_timer =
TIMER_INITIALIZER(touch_timer_fire, 0, 0);
static irqreturn_t
stylus_updown(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long data0;
unsigned long data1;
int updown;
/*
读取ADCDAT0/1寄存器，判断Stylus的状态：
0 = Stylus down state
1 = Stylus up state
*/
data0 = readl(base_addr+S3C2410_ADCDAT0);
data1 = readl(base_addr+S3C2410_ADCDAT1);
updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT1_UPDOWN));
/*
更新stylus状态寄存器updown：
1 = down
0 = up
*/
/* TODO we should never get an interrupt with updown set while
* the timer is running, but maybe we ought to verify that the
* timer isn't running anyways. */
/* 判断出stylus down，调用touch_timer_fire函数 */
if (updown)
touch_timer_fire(0);
return IRQ_HANDLED;
}
static irqreturn_t
stylus_action(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long data0;
unsigned long data1;
data0 = readl(base_addr+S3C2410_ADCDAT0);
data1 = readl(base_addr+S3C2410_ADCDAT1);
/*
触摸屏的XY线接的是反的，所以只好这样做了
另外，可以参考这个方法：
http://www.arm9bbs.com/redirect.php?tid=637&goto=lastpost
*/
/**************************modify by lfc********************/
ts.yp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
ts.xp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;
/***********************************************************/
ts.count++;
if (ts.count < (1<<ts.shift)) {
/* 缓冲区未满，再次激活ADC转换 */
writel(S3C2410_ADCTSC_XP_PULL_UP_DIS | AUTOPST, base_addr+S3C2410_ADCTSC);
writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);
} else {
/* 缓冲区满，激活下半部处理程序
touch_timer_fire，处理接收数据 */ mod_timer(&touch_timer, jiffies+1);
writel(WAIT4INT(1), base_addr+S3C2410_ADCTSC);
}
return IRQ_HANDLED;
}
static struct clk *adc_clock;
/*
* The functions for inserting/removing us as a module.
*/
static int __init
s3c2410ts_probe(struct device *dev)
{
struct s3c2410_ts_mach_info *info;
info = ( struct s3c2410_ts_mach_info *)dev->platform_data;
注：
s3c2410_ts_mach_info这个结构需要我们去填充，里面存放的是触摸屏需要的一些配置参数，见下面的附录部分。
if (!info)
{
printk(KERN_ERR "Hm... too bad : no platform data for ts\n");
return -EINVAL;
}
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
printk(DEBUG_LVL "Entering s3c2410ts_init\n");
#endif
adc_clock = clk_get(NULL, "adc");
if (!adc_clock) {
printk(KERN_ERR "failed to get adc clock source\n");
return -ENOENT;
}
clk_use(adc_clock);//这个在高版本下已经不需要了
clk_enable(adc_clock);
#ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG
printk(DEBUG_LVL "got and enabled clock\n");
#endif
base_addr=ioremap(S3C2410_PA_ADC,0x20);//映射触摸屏的控制寄存器，应该不需要解析了吧^_^
if (base_addr == NULL) {
printk(KERN_ERR "Failed to remap register block\n");
return -ENOMEM;
}
/* Configure GPIOs */
s3c2410_ts_connect();
/*以下根据我们提供的s3c2410_ts_mach_info结构，配置触摸屏的一些控制寄存器*/
/* Set the prscvl*/
if ((info->presc&0xff) > 0)
writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\
base_addr+S3C2410_ADCCON);
else
writel(0,base_addr+S3C2410_ADCCON);
/* Initialise the adcdly registers */
if ((info->delay&0xffff) > 0)
writel(info->delay & 0xffff, base_addr+S3C2410_ADCDLY);
/* 进入s3c2410触摸屏提供的Waiting for Interrupt Mode，waits for Stylus down.The controller generates Interrupt (INT_TC) signals when the Stylus is down on Touch Screen Panel.*/
writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);
/* Initialise input stuff */
memset(&ts, 0, sizeof(struct s3c2410ts));
/* 以下配置2.6内核划分出来的输入设备 */
init_input_dev(&ts.dev);
ts.dev.evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
/*
evbit字段用来定义该输入设备可以支持的（产生和响应）的事件的类型，
在此触摸屏设置为支持同步(EN_SYN)、按键(EN_KEY)、绝对坐标(EV_ABS)事件
*/
ts.dev.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
/* 设置所支持的按键(键值)，触摸屏可以看成只有一个按键的设备 */
input_set_abs_params(&ts.dev, ABS_X, 0, 0x3FF, 0, 0);
/* 设置绝对坐标x的最小最大值，在这是0-0x3FF */
input_set_abs_params(&ts.dev, ABS_Y, 0, 0x3FF, 0, 0);
/* 设置绝对坐标y的最小最大值，在这是0-0x3FF */
input_set_abs_params(&ts.dev, ABS_PRESSURE, 0, 1, 0, 0);
sprintf(ts.phys, "ts0");
ts.dev.private = &ts;
ts.dev.name = s3c2410ts_name;
ts.dev.phys = ts.phys;
ts.dev.id.bustype = BUS_RS232;
ts.dev.id.vendor = 0xDEAD;
ts.dev.id.product = 0xBEEF;
ts.dev.id.version = S3C2410TSVERSION;
ts.shift = info->oversampling_shift;
/*
这个比较重要，配置输入数据的缓存区大小，
在这里oversampling_shift设为2，也就是缓存区的大小为4(1<<2)
*/
/* ADC转换中断，转换结束后触发 */
if (request_irq(IRQ_ADC, stylus_action, SA_SAMPLE_RANDOM,
"s3c2410_action", &ts.dev)) {
printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_ADC !\n");
iounmap(base_addr);
return -EIO;
}
/*
检测stylus updown的中断，设置为Waiting for Interrupt Mode时，
The controller generates Interrupt (INT_TC) signals when the Stylus is down on Touch Screen Panel，还记得吧^_^
*/
if (request_irq(IRQ_TC, stylus_updown, SA_SAMPLE_RANDOM,
"s3c2410_action", &ts.dev)) {
printk(KERN_ERR "s3c2410_ts.c: Could not allocate ts IRQ_TC !\n");
iounmap(base_addr);
return -EIO;
}
printk(KERN_INFO "%s successfully loaded\n", s3c2410ts_name);
/* All went ok, so register to the input system */
input_register_device(&ts.dev);//注册输入设备
return 0;
}
/* 好了，一切都准备好了，等待stylus updown的发生然后进入IRQ_TC中断处理程序吧^_^ */
static int s3c2410ts_remove(struct device *dev)
{
disable_irq(IRQ_ADC);
disable_irq(IRQ_TC);
free_irq(IRQ_TC,&ts.dev);
free_irq(IRQ_ADC,&ts.dev);
if (adc_clock) {
clk_disable(adc_clock);
clk_unuse(adc_clock);
clk_put(adc_clock);
adc_clock = NULL;
}
input_unregister_device(&ts.dev);
iounmap(base_addr);
return 0;
}
static struct device_driver s3c2410ts_driver = {
.name = "s3c2410-ts",
.bus = &platform_bus_type,
.probe = s3c2410ts_probe,
.remove = s3c2410ts_remove,
};
int __init s3c2410ts_init(void)
{
return driver_register(&s3c2410ts_driver);
}
void __exit s3c2410ts_exit(void)
{
driver_unregister(&s3c2410ts_driver);
}
module_init(s3c2410ts_init);
module_exit(s3c2410ts_exit);
附录：
见/arch/arm/mach-s3c2410/dev.c文件：
static struct s3c2410_ts_mach_info sbc2410_ts_platdata = {
.delay = 10000,
.presc = 49,
.oversampling_shift = 2,
};
struct platform_device s3c_device_ts = {
.name = "s3c2410-ts",
.id = -1,
.dev = {
.platform_data = &sbc2410_ts_platdata,
}
};
EXPORT_SYMBOL(s3c_device_ts);
posted @
2007-08-22 09:15 lfc 阅读(8411) |
评论 (5) |
编辑 收藏
1、编译libz：
首先安装 zlib 库，这个是后面的库的编译基础。
http://www.zlib.net/zlib-1.2.3.tar.gz
解压
tar zxf zlib-1.2.3.tar.gz
由于 zlib 库的configure 脚本不支持交叉编译选项，可以采用以下方法来解决：
1)CC=arm-linux-gcc
./configure --prefix=/usr/local/arm/2.95.3/arm-linux/ --shared
注意：这里配置指向 /usr/local/arm/2.95.3/arm-linux/ 目录，会自动安装在 /usr/local/arm/2.95.3/arm-linux/ [include,lib] 目录下，
千万不要装错目录了，不然后面会找不到这个库的。
2)make
3)make install
安
装完后检查一下目录 /usr/local/arm/2.95.3/arm-linux/ [include,lib] ，假如 include
中没有 zlib.h 之类的头文件，lib 中没有 libz.so.1.2.3 ，那就自己手动拷到这些目录下去，记着拷的时候把所有的 *.h
都需要拷过去，在拷库的时候用 cp –a libz.* /…./lib 就行，要用上 –a 选项
2、编译mtd-utils：
下载mtd-utils-1.0.0.tar.gz:
ftp://ftp.infradead.org/pub/mtd-utils/mtd-utils-1.0.0.tar.gz解压目录为mtd-utils-1.0.0
#cd mtd-utils-1.0.0
1) 修改Makefile
CROSS=arm-linux-
2) make （ 用file命令查看,如 file mkfs.jffs2 ）
#file mkfs.jffs2
mkfs.jffs2: ELF 32-bit LSB executable, ARM, version 1 (ARM), for GNU/Linux 2.0.0, dynamically linked (uses shared libs), for GNU/Linux 2.0.0, not stripped
可知：交叉编译成功。
posted @
2007-08-10 16:57 lfc 阅读(10259) |
评论 (5) |
编辑 收藏
注：
原文出自taoyuetao大侠的博客上：
http://www.eetop.cn/blog/html/45/11145_itemid_1838.html
小弟参考之研究s3c2410相关代码，然后做了稍微的修改，作为一个学习笔记，方便以后的学习，也希望对后人有所帮助^_^
函数__mmap_switched介绍：
/*
* The following fragment of code is
executed with the MMU on, and uses
* absolute addresses; this is not
position independent.
*
*
r0 = cp#15 control register
*
r1 = machine ID
*
r9 = processor ID
*/
1： .type __mmap_switched,
%function
2： __mmap_switched:
3： adr r3, __switch_data + 4
4： ldmia r3!, {r4, r5, r6,
r7}
5： cmp r4, r5 @
Copy data segment if needed
6： 1: cmpne r5, r6
7： ldrne fp, [r4], #4
8： strne fp, [r5], #4
9： bne 1b
10： mov fp, #0 @ Clear BSS (and zero fp)
11：1: cmp r6, r7
12： strcc fp, [r6],#4
13： bcc 1b
14： ldmia r3, {r4, r5, r6, sp}
15： str r9, [r4] @ Save processor ID
16： str r1, [r5] @ Save machine type
17： bic r4, r0, #CR_A @ Clear 'A' bit
18： stmia r6, {r0, r4} @
Save control register values
19： b start_kernel
20： .type __switch_data, %object
21：__switch_data:
22： .long __mmap_switched
23： .long __data_loc @
r4
24： .long __data_start @ r5
25： .long __bss_start @
r6
26： .long _end @
r7
27： .long processor_id @ r4
28： .long __machine_arch_type @ r5
29： .long cr_alignment @ r6
30： .long init_thread_union + THREAD_START_SP @ sp
程序的4行执行完成之后的结果是r4=__data_loc，r5=__data_start，r6=__bss_start，r7=_end，第10-13行将__bss_start到_end清零，定义在vmlinux.lds文件中，如下：
.bss :
{
__bss_start = .;
/*
BSS
*/
*(.bss)
*(COMMON)
_end = . ;
}
第15-16行分别将处理器类型和机器类型存储到变量processor_id和__machine_arch_type中，这些变量以后会在start_kernel->setup_arch中使用，来得到当前处理器的struct
proc_info_list结构和当前系统的machine_desc结构的数据。
第17-18将processor control
register保存到cr_alignment中，19行跳转到init/main.c中的start_kernel进入内核启动的第二阶段。
posted @
2007-08-04 10:24 lfc 阅读(1030) |
评论 (2) |
编辑 收藏