#include <linux/init.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <mach/lpc32xx_ssp.h>
#include <mach/board.h>
#include <mach/lpc32xx_gpio.h>
#include <mach/platform.h>
#include <mach/sys-lpc32xx.h>
#include <mach/lpc32xx_clkpwr.h>
#define SPIDEV_MAJOR 154 /* assigned */
#define GPIO_IOBASE io_p2v(GPIO_BASE)
#define CLK_PM_IOBASE io_p2v(CLK_PM_BASE)
#define BUFLENGTH 60
//#define DEBUG
#ifdef DEBUG
/* If you are writing a driver, please use dev_dbg instead */
#define p_debug(fmt, arg...) \
printk(KERN_WARNING fmt, ##arg)
#else
#define p_debug(fmt, arg...) \
({ if (0) printk(KERN_WARNING fmt, ##arg); 0; })
#endif
struct myspistruct
{
struct cdev cdev;
dev_t devt;
void __iomem *membase;
int irq;
wait_queue_head_t waitq;
spinlock_t lock;
u8 bufa[BUFLENGTH];
u8 bufb[BUFLENGTH];
unsigned int lena;
unsigned int lenb;
};
struct myspistruct mydev;
struct myspistruct *dev=&mydev;
//***********************************************************************
static irqreturn_t lpc32xx_spi_irq(int irq, void *dev_id)
{
u8 data=0;
unsigned long flags;
int status;
/* Disable interrupts for now, do not clear the interrupt states */
__raw_writel(0, SSP_IMSC(dev->membase));
if(__raw_readl(SSP_RIS(dev->membase)) &(SSP_MIS_RTMIS | SSP_MIS_RXMIS))
{
spin_lock_irqsave(&dev->lock, flags);
/* Has an overflow occurred? */
if (unlikely(__raw_readl(SSP_MIS(dev->membase)) &
SSP_MIS_RORMIS))
{
status = -EIO;
return status;
}
/* Clear other interrupts */
__raw_writel((SSP_ICR_RORIC | SSP_ICR_RTIC),SSP_ICR(dev->membase));
/* Is there any data to read? */
while (__raw_readl(SSP_SR(dev->membase)) & SSP_SR_RNE)
data = (u8)__raw_readl(SSP_DATA(dev->membase));
if((dev->lena < BUFLENGTH)&&(dev->lena>0))
{
dev->bufa[dev->lena]=data;
dev->lena++;
goto finalpoint;
}
if((dev->lenb < BUFLENGTH)&&(dev->lenb>0))
{
dev->bufb[dev->lenb]=data;
dev->lenb++;
goto finalpoint;
}
if(dev->lena==0)
{
dev->bufa[dev->lena]=data;
dev->lena++;
p_debug("irq function data read begin\n");
goto finalpoint;
}
if(dev->lenb==0)
{
dev->bufb[dev->lenb]=data;
dev->lenb++;
}
finalpoint: spin_unlock_irqrestore(&dev->lock, flags);
if((dev->lenb) ==( dev->lena)==(BUFLENGTH))
{
printk(KERN_WARNING "read slow\n");
return -EBUSY;
}
if(dev->lena==BUFLENGTH||dev->lenb==BUFLENGTH)
wake_up_interruptible(&dev->waitq);
}
__raw_writel((SSP_IMSC_RTIM | SSP_IMSC_RXIM), SSP_IMSC(dev->membase));
return IRQ_HANDLED;
}
static int spidev_open(struct inode *inode, struct file *filp)
{
int status = -ENXIO;
int tmp;
unsigned long flags;
spin_lock_irqsave(&dev->lock, flags);
if (dev->devt == inode->i_rdev) {
status = 0;
}
tmp=__raw_readl(CLKPWR_TIMERS_PWMS_CLK_CTRL_1(CLK_PM_IOBASE));
__raw_writel(tmp&(~(1<<6)), CLKPWR_TIMERS_PWMS_CLK_CTRL_1(CLK_PM_IOBASE));//disable pwm clock
mdelay(1);
tmp=__raw_readl(GPIO_P2_MUX_SET(GPIO_IOBASE));
__raw_writel((tmp|1 << 5), GPIO_P2_MUX_SET(GPIO_IOBASE));//link to pin SSEL0
mdelay(1);
tmp=__raw_readl(GPIO_P_MUX_SET(GPIO_IOBASE));
__raw_writel( (tmp|0x03 << 9) | (0x01 << 12), GPIO_P_MUX_SET(GPIO_IOBASE));//link to pin SCK0,MOSI0,MISO0
mdelay(1);
__raw_writel(0x1, CLKPWR_SSP_CLK_CTRL(CLK_PM_IOBASE));//enable the clock
//************************************************************************
__raw_writel(SSP_CR1_SSP_DISABLE , SSP_CR1(dev->membase));
tmp=__raw_readl(SSP_CR1(dev->membase));
__raw_writel(tmp|SSP_CR1_MS, SSP_CR1(dev->membase));
//*************************************************************************
tmp=__raw_readl(SSP_CR1(dev->membase));
__raw_writel(tmp|SSP_CR1_SSP_ENABLE, SSP_CR1(dev->membase));//*******slave mode
// Setup default SPI mode
__raw_writel((SSP_CR0_DSS(8)|SSP_CR0_FRF_SPI|SSP_CR0_CPOL(0)|
SSP_CR0_CPHA(0) ), SSP_CR0(dev->membase));
// Clear and mask SSP interrupts
__raw_writel(0x0, SSP_ICR(dev->membase));
__raw_writel(0, SSP_IMSC(dev->membase));
dev->lena=0;
dev->lenb=0;
do
{
tmp = __raw_readl(SSP_DATA(dev->membase));
}
while (__raw_readl(SSP_SR(dev->membase)) & SSP_SR_RNE);
__raw_writel((SSP_IMSC_RTIM | SSP_IMSC_RXIM), SSP_IMSC(dev->membase));
enable_irq(dev->irq);
spin_unlock_irqrestore(&dev->lock, flags);
return status;
}
static int spidev_release(struct inode *inode, struct file *filp)
{
disable_irq(dev->irq);
return 0;
}
static spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
u8 *rd;
int len=BUFLENGTH;
int status;
unsigned long flags;
p_debug("driver read function before wait_event!\n");
wait_event_interruptible(dev->waitq,(dev->lena==BUFLENGTH)||(dev->lenb==BUFLENGTH));
spin_lock_irqsave(&dev->lock, flags);
if(dev->lena==BUFLENGTH)
{
dev->lena=0;
rd=dev->bufa;
}else
{
dev->lenb=0;
rd=dev->bufb;
}
if(count!=BUFLENGTH)
printk(KERN_WARNING "please keep read size %d\n",len);
p_debug("driver read function before copy_to_user!\n");
if(copy_to_user(buf, rd, BUFLENGTH))
status=-EFAULT;
else
status=BUFLENGTH;
spin_unlock_irqrestore(&dev->lock, flags);
return status;
}
static struct file_operations myspidev_fops = {
.owner = THIS_MODULE,
.read = spidev_read,
.open = spidev_open,
.release = spidev_release,
};
//**************************************************************************
static struct class *spidev_class;
static int lpc32xx_spi_probe(struct platform_device *pdev)
{
int ret;
int err;
int irq;
struct resource *res;
dev_t devno = MKDEV(SPIDEV_MAJOR,0);/*主，次设备号*/
if(SPIDEV_MAJOR){
/*register_chrdev_region(设备号指针，设备号数目，设备名)*/
ret = register_chrdev_region(devno,1,"myspidev");
}
else
/*alloc_chrdev_region(分配到的设备号指针，起始次设备号，
需要分配的设备号数目，设备名称)*/
{
ret = alloc_chrdev_region(&devno,0,1,"myspidev");
//SPIDEV_MAJOR=MAJOR(devno);
}
if (ret < 0)
return ret;
dev->devt=MKDEV(SPIDEV_MAJOR,0);
/*第二步：初始化cdev*/
cdev_init(&dev->cdev,&myspidev_fops);/*建立cdev和file_operations之间的连接*/
dev->cdev.owner=THIS_MODULE;
dev->cdev.ops=&myspidev_fops;
/*第三步：注册字符设备*/
/*cdev_add(cdev结构指针，设备号，设备数目)*/
err=cdev_add(&dev->cdev,devno,1);
if(err)
printk(KERN_NOTICE "Error %d adding globalvar",err);
spidev_class = class_create(THIS_MODULE, "myspidev");
device_create(spidev_class, NULL, MKDEV(SPIDEV_MAJOR, 0), NULL, "myspidev");
if (IS_ERR(spidev_class)){
cdev_del(&dev->cdev);/*注销cdev结构*/
unregister_chrdev_region(MKDEV(SPIDEV_MAJOR,0),1);/*注销设备号*/
return PTR_ERR(spidev_class);
}
spin_lock_init(&dev->lock);
init_waitqueue_head(&dev->waitq);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
irq = platform_get_irq(pdev, 0);
if ((!res) || (irq < 0) | (irq >= NR_IRQS))
{
printk(KERN_WARNING "no resource!\n");
return -EBUSY;
}
/* Save IO resources */
dev->membase = ioremap(res->start, res->end - res->start + 1);
if (!dev->membase)
{
ret = -EBUSY;
printk(KERN_WARNING "no memory!\n");
goto errout1;
}
dev->irq=irq;
ret = request_irq(dev->irq, lpc32xx_spi_irq,
IRQF_DISABLED, "spiirq", NULL);
if (ret)
{
ret = -EBUSY;
goto errout2;
}
disable_irq(dev->irq);
return 0;
errout2:
free_irq(dev->irq, NULL);
errout1:
iounmap(dev->membase);
return ret;
}
static int lpc32xx_spi_remove(struct platform_device *pdev)
{
free_irq(dev->irq, NULL);
iounmap(dev->membase);
class_destroy(spidev_class);
device_destroy(spidev_class,MKDEV(SPIDEV_MAJOR,0));
cdev_del(&dev->cdev);/*注销cdev结构*/
unregister_chrdev_region(MKDEV(SPIDEV_MAJOR,0),1);/*注销设备号*/
return 0;
}
static struct platform_driver lpc32xx_spi_driver = {
.probe = lpc32xx_spi_probe,
.remove = lpc32xx_spi_remove,
.driver = {
.name = "myspidev",
.owner = THIS_MODULE,
},
};
static int __init spidev_init(void)
{
printk(KERN_WARNING "hello,myspidev!\n");
return platform_driver_register(&lpc32xx_spi_driver);
}
static void __exit spidev_exit(void)
{
platform_driver_unregister(&lpc32xx_spi_driver);
printk(KERN_WARNING "goodbye,myspidev!\n");
}
module_init(spidev_init);
module_exit(spidev_exit);
MODULE_AUTHOR("yongan@zhuhaiyirui");
MODULE_DESCRIPTION("User mode SPI device interface");
MODULE_LICENSE("GPL");
//**************************************************************************************
qt测试
spidev.h
#ifndef SPIDEV_H
#define SPIDEV_H
#include <QPainter>
#include <QPen>
#include <QString>
#include <QRect>
#include <QPushButton>
#include <QPoint>
#include <QTimer>
#include <QCloseEvent>
#include "mythread.h"
class mainWidget : public QWidget
{
Q_OBJECT
public:
mainWidget(QWidget *parent = 0);
~mainWidget();
bool labelchange;
private slots:
void transData();
void threadslot();
void writeStopCmd();
void writeStartCmd();
protected:
void paintEvent(QPaintEvent *);
void closeEvent(QCloseEvent *event);
private:
int maxY;
int numYticks;
int minY;
int maxX;
int minX;
int numXticks;
enum { Margin = 20 };
QPushButton *btnclose;
QPushButton *btnstart;
static unsigned char startCmd[5];
static unsigned char stopCmd[5];
MyThread mythread;
QTimer *timer;
};
#endif // SPIDEV_H
spi.cpp
#include "spidev.h"
#include <termios.h> /*PPSIX terminal controle */
#include <stdio.h> /* stand input and output... */
#include <stdlib.h> /* stand lib */
#include <unistd.h> /* UNIX stand function */
#include <sys/types.h> /**/
#include <sys/stat.h> /**/
#include <fcntl.h> /* file controle */
unsigned char mainWidget::startCmd[5]={0xAA,0x01,0x02,0x03,0x04};
unsigned char mainWidget::stopCmd[5]={0xAA,0x04,0x03,0x02,0x01};
mainWidget::mainWidget(QWidget *parent)
: QWidget(parent)
{
setWindowTitle("myspidev data curve");
setBackgroundRole(QPalette::Dark);
setAutoFillBackground(true);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setFocusPolicy(Qt::StrongFocus);
minX=0;
minY=0;
maxX=500;
maxY=0xffffff;
numXticks=5;
numYticks=5;
btnclose = new QPushButton(tr("&close"),this);
btnstart = new QPushButton(tr("&start"),this);
connect(btnclose,SIGNAL(clicked()),this,SLOT(close()));
connect(btnstart,SIGNAL(clicked()),this,SLOT(transData()));
connect(&mythread,SIGNAL(finished ()),this,SLOT(writeStopCmd()));
connect(&mythread,SIGNAL(sgWriteStart()),this,SLOT(writeStartCmd()));
labelchange=false;
connect(btnstart,SIGNAL(clicked()),this,SLOT(threadslot()));
timer=new QTimer(this);
timer->start(200);
connect(timer,SIGNAL(timeout()),this,SLOT(update()));
}
mainWidget::~mainWidget()
{
}
void mainWidget::paintEvent(QPaintEvent *)
{
QPainter painter(this);
QRect rect(2*Margin, Margin,width() - 3 * Margin, height() - 4 * Margin);
if (!rect.isValid())
return;
QPen quiteDark = palette().dark().color().light();
QPen light = palette().light().color();
for (int i = 0; i <= numXticks; ++i) {
int x = rect.left() + (i * (rect.width() - 1) / numXticks);
painter.setPen(quiteDark);
painter.drawLine(x, rect.top(), x, rect.bottom());
painter.setPen(light);
painter.drawLine(x, rect.bottom(), x, rect.bottom() + 5);
painter.drawText(x, rect.bottom() + 5, Margin - 5, Margin,
Qt::AlignHCenter | Qt::AlignTop,
QString::number(i));
}
int y;
for (int j = 0; j <= numYticks; ++j) {
y = rect.bottom() - (j * (rect.height() - 1) / numYticks);
painter.setPen(quiteDark);
painter.drawLine(rect.left(), y, rect.right(), y);
painter.setPen(light);
painter.drawLine(rect.left() - 5, y, rect.left(), y);
painter.drawText(rect.left() - Margin, y - 10, Margin - 5, Margin,
Qt::AlignRight | Qt::AlignVCenter,
QString::number(j));
}
//------------------------------------------------------------coordination painted over.
btnstart->setGeometry(4*Margin,height()-2*Margin,3*Margin,Margin);
btnclose->setGeometry(10*Margin,height()-2*Margin,3*Margin,Margin);
//---------------------------------------------draw curve
QPoint points[240];
unsigned int *p=mythread.getdata();
for(int i=0;i<240;i++)
{
points[i].setX(i+rect.left());
points[i].setY((*(p+i))*(rect.height())/maxY+rect.top()+2*y);
}
painter.drawPoints(points, 240);
}
//************************************************serial port set
void set_speed(int fd, int speed)
{
int status;
struct termios Opt;
tcgetattr(fd, &Opt); // get attribute of serial port
tcflush(fd, TCIOFLUSH);
cfsetispeed(&Opt, speed);
cfsetospeed(&Opt, speed);
status = tcsetattr(fd, TCSANOW, &Opt); // set attribute
if (status != 0)
{
perror("tcsetattr fd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
int set_data_format(int fd,int databits,int stopbits,int parity)
{
struct termios opt;
if( tcgetattr(fd, &opt) != 0)
{
perror("SetupSerial 1");
return -1;
}
opt.c_cflag &= ~CSIZE;
switch (databits)
{
case 5:
opt.c_cflag |= CS5;
break;
case 6:
opt.c_cflag |= CS6;
break;
case 7:
opt.c_cflag |= CS7;
break;
case 8:
opt.c_cflag |= CS8;
break;
default:
fprintf(stderr,"Unsupported data size\n");
return -1;
}
switch (parity)
{
case 'n':
case 'N':
opt.c_cflag &= ~PARENB; /* Clear parity enable */
opt.c_iflag &= ~INPCK; /* Enable parity checking */
break;
case 'o':
case 'O':
opt.c_cflag |= (PARODD | PARENB); /* parity checking */
opt.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'e':
case 'E':
opt.c_cflag |= PARENB; /* Enable parity */
opt.c_cflag &= ~PARODD; /* */
opt.c_iflag |= INPCK; /* Disnable parity checking */
break;
default:
fprintf(stderr,"Unsupported parity\n");
return -1;
}
switch (stopbits)
{
case 1:
opt.c_cflag &= ~CSTOPB;
break;
case 2:
opt.c_cflag |= CSTOPB;
break;
default:
fprintf(stderr,"Unsupported stop bits\n");
return -1;
}
/* Set input parity option */
if (parity != 'n')
opt.c_iflag |= INPCK;
opt.c_cc[VTIME] = 100; // 10 seconds
opt.c_cc[VMIN] = 0;
tcflush(fd, TCIFLUSH); /* Update the options and do it NOW */
if (tcsetattr(fd, TCSANOW, &opt) != 0)
{
perror("SetupSerial 3");
return -1;
}
return 0;
}
//******************************************************************serial port set
void mainWidget::transData()
{
//change labeltext
labelchange=!labelchange;
if(labelchange)
btnstart->setText(tr("&stop"));
else
btnstart->setText(tr("&start"));
update();
}
void mainWidget::writeStopCmd()
{
int fd;
fd = open("/dev/ttyS1", O_RDWR); // read and write
if(fd == -1)
{
printf("Can't open ttyS1!\n");
exit(0);
}
set_speed(fd, B9600); // 9600
if (set_data_format(fd, 8, 1, 'N')== -1)
{
printf("Data format Error!\n");
exit(1);
}
::write(fd,stopCmd,5);
::close(fd);
}
void mainWidget::writeStartCmd()
{
int fd;
printf("writeStartCmd works!\n");
fd = open("/dev/ttyS1", O_RDWR); // read and write
if(fd == -1)
{
printf("Can't open ttyS1!\n");
exit(0);
}
set_speed(fd, B9600); // 9600
if (set_data_format(fd, 8, 1, 'N')== -1)
{
printf("Data format Error!\n");
exit(1);
}
::write(fd,startCmd,5);
::close(fd);
}
void mainWidget::threadslot()
{
if (mythread.isRunning())
{
mythread.stop();
}
else
{
mythread.start();
}
}
void mainWidget::closeEvent(QCloseEvent *event)
{
mythread.stop();
mythread.wait();
event->accept();
}
mythread.h
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QtGui/QWidget>
#include <QThread>
#include <QVector>
#include <QMutex>
class MyThread : public QThread
{
Q_OBJECT
public:
MyThread();
void stop();
unsigned int* getdata();
signals:
void sgWriteStart();
protected:
void run();
private:
volatile bool stopped;
unsigned int mydata[240];
QVector<unsigned int> vect;
QMutex mutex;
};
#endif // MYTHREAD_H
mythread.cpp
#include "mythread.h"
#include <stdio.h> /* stand input and output... */
#include <stdlib.h> /* stand lib */
#include <unistd.h> /* UNIX stand function */
#include <sys/types.h> /**/
#include <sys/stat.h> /**/
#include <fcntl.h> /* file controle */
#include <errno.h> /* error */
#include <strings.h>
#include <pthread.h>
MyThread::MyThread()
{
stopped = false;
memset(mydata,0,sizeof(mydata));
}
void MyThread::run()
{
int fd;
int res;
unsigned char spidata[60];
fd=open("/dev/myspidev",O_RDWR);
if (fd==-1){
printf("Can't open myspidev device!\n");
exit(EXIT_FAILURE);
}
vect.clear();
emit sgWriteStart();
printf(" sgWriteStart() sends!\n");
while (!stopped)
{
res=::read(fd,spidata,60);
if(res!=60)
printf("read error\n");
mutex.lock();
for(int i=0;i<60;i++)
{
vect.append((int)spidata[i]);
}
mutex.unlock();
}//------------------while ends
// printf("after while\n");
stopped = false;
::close(fd);
emit finished ();
}
void MyThread::stop()
{
stopped = true;
}
unsigned int* MyThread::getdata()
{
QVector<unsigned int>::iterator T = vect.begin();
mutex.lock();
if(vect.size()>800)
{
for(int i=0;i<240;i++)
{
mydata[i]=(vect[i*3] << 16)+(vect[i*3+1] << 8)+(vect[i*3+2]);
T++;
T++;
T++;
}
vect.erase(vect.begin(),T);
//the following used for debug
/* for(int i=0;i<720;i++)
{
if(i%15==0)
printf("\n");
printf("%3x\t",vect[i]);
}
while(1);*/
}
mutex.unlock();
return mydata;
}
main.c
#include <QtGui/QApplication>
#include "spidev.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
mainWidget w;
w.show();
return a.exec();
}