伍意
伍意

SPI驱动之SPI设备驱动程序



前篇文章分析了SPI主控制器驱动，也就是SPI总线驱动，既然总线有了，根据Linux设备驱动模型，还得有SPI设备和SPI设备驱动。SPI设备是在板级文件中注册，SPI设备驱动需要用户自己实现，好在内核为我们提供了一个通用的SPI设备驱动spidev.c，下面就来分析一下这个文件，该文件位于kernel3.0.15/drivers/spi/spidev.c。

1. 模块初始化和注销：spidev_init & spidev_exit

[cpp] view plain copy print ?
  1. static const struct file_operations spidev_fops = {  
  2.     .owner =    THIS_MODULE,  
  3.     /* REVISIT switch to aio primitives, so that userspace 
  4.      * gets more complete API coverage.  It'll simplify things 
  5.      * too, except for the locking. 
  6.      */  
  7.     .write =    spidev_write,  
  8.     .read =     spidev_read,  
  9.     .unlocked_ioctl = spidev_ioctl,  
  10.     .compat_ioctl = spidev_compat_ioctl,  
  11.     .open =     spidev_open,  
  12.     .release =  spidev_release,  
  13.     .llseek =   no_llseek,  
  14. };  
static const struct file_operations spidev_fops = {
	.owner =	THIS_MODULE,
	/* REVISIT switch to aio primitives, so that userspace
	 * gets more complete API coverage.  It'll simplify things
	 * too, except for the locking.
	 */
	.write =	spidev_write,
	.read =		spidev_read,
	.unlocked_ioctl = spidev_ioctl,
	.compat_ioctl = spidev_compat_ioctl,
	.open =		spidev_open,
	.release =	spidev_release,
	.llseek =	no_llseek,
};

[cpp] view plain copy print ?
  1. static struct spi_driver spidev_spi_driver = {  
  2.     .driver = {  
  3.         .name =     "spidev",  
  4.         .owner =    THIS_MODULE,  
  5.     },  
  6.     .probe =    spidev_probe,  
  7.     .remove =   __devexit_p(spidev_remove),  
  8.   
  9.     /* NOTE:  suspend/resume methods are not necessary here. 
  10.      * We don't do anything except pass the requests to/from 
  11.      * the underlying controller.  The refrigerator handles 
  12.      * most issues; the controller driver handles the rest. 
  13.      */  
  14. };  
  15.   
  16. /*-------------------------------------------------------------------------*/  
  17.   
  18. static int __init spidev_init(void)  
  19. {  
  20.     int status;  
  21.   
  22.     /* Claim our 256 reserved device numbers.  Then register a class 
  23.      * that will key udev/mdev to add/remove /dev nodes.  Last, register 
  24.      * the driver which manages those device numbers. 
  25.      */  
  26.     BUILD_BUG_ON(N_SPI_MINORS > 256);  
  27.     //注册字符设备，参数spidev_fops是struct file_operations的实例，这里就可以知道，用户程序的open、write等操作最终会调用这里面的函数  
  28.     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);  
  29.     if (status < 0)  
  30.         return status;  
  31.   
  32.     spidev_class = class_create(THIS_MODULE, "spidev"); //创建spidev这一类设备，为后面自动生成设备节点做准备  
  33.     if (IS_ERR(spidev_class)) {  
  34.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);  
  35.         return PTR_ERR(spidev_class);  
  36.     }  
  37.   
  38.     status = spi_register_driver(&spidev_spi_driver); //注册spi设备驱动  
  39.     if (status < 0) {  
  40.         class_destroy(spidev_class);  
  41.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);  
  42.     }  
  43.     return status;  
  44. }  
  45. module_init(spidev_init);  
  46.   
  47. static void __exit spidev_exit(void)  
  48. {  
  49.     spi_unregister_driver(&spidev_spi_driver);  
  50.     class_destroy(spidev_class);  
  51.     unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);  
  52. }  
  53. module_exit(spidev_exit);  
  54.   
  55. MODULE_AUTHOR("Andrea Paterniani, ");  
  56. MODULE_DESCRIPTION("User mode SPI device interface");  
  57. MODULE_LICENSE("GPL");  
  58. MODULE_ALIAS("spi:spidev");  
static struct spi_driver spidev_spi_driver = {
	.driver = {
		.name =		"spidev",
		.owner =	THIS_MODULE,
	},
	.probe =	spidev_probe,
	.remove =	__devexit_p(spidev_remove),

	/* NOTE:  suspend/resume methods are not necessary here.
	 * We don't do anything except pass the requests to/from
	 * the underlying controller.  The refrigerator handles
	 * most issues; the controller driver handles the rest.
	 */
};

/*-------------------------------------------------------------------------*/

static int __init spidev_init(void)
{
	int status;

	/* Claim our 256 reserved device numbers.  Then register a class
	 * that will key udev/mdev to add/remove /dev nodes.  Last, register
	 * the driver which manages those device numbers.
	 */
	BUILD_BUG_ON(N_SPI_MINORS > 256);
	//注册字符设备，参数spidev_fops是struct file_operations的实例，这里就可以知道，用户程序的open、write等操作最终会调用这里面的函数
	status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
	if (status < 0)
		return status;

	spidev_class = class_create(THIS_MODULE, "spidev"); //创建spidev这一类设备，为后面自动生成设备节点做准备
	if (IS_ERR(spidev_class)) {
		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
		return PTR_ERR(spidev_class);
	}

	status = spi_register_driver(&spidev_spi_driver); //注册spi设备驱动
	if (status < 0) {
		class_destroy(spidev_class);
		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
	}
	return status;
}
module_init(spidev_init);

static void __exit spidev_exit(void)
{
	spi_unregister_driver(&spidev_spi_driver);
	class_destroy(spidev_class);
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
}
module_exit(spidev_exit);

MODULE_AUTHOR("Andrea Paterniani, ");
MODULE_DESCRIPTION("User mode SPI device interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("spi:spidev");

在模块初始化函数中，创建了一个字符设备以提供API给用户层，同时创建了一个spidev类，最后注册spi_driver到内核中。在这里我们看到了SPI设备驱动是如何提供API给用户层的，那就是通过再熟悉不过的字符设备。通过字符设备，给用户层提供了5个API：open，release，write，read和ioctl。

接下来分析一下spi_register_driver函数，该函数位于kernel3.0.15/drivers/spi/spi.c

[cpp] view plain copy print ?
  1. int spi_register_driver(struct spi_driver *sdrv)  
  2. {  
  3.     sdrv->driver.bus = &spi_bus_type; //该驱动所属的总线  
  4.     if (sdrv->probe)  
  5.         sdrv->driver.probe = spi_drv_probe;  
  6.     if (sdrv->remove)  
  7.         sdrv->driver.remove = spi_drv_remove;  
  8.     if (sdrv->shutdown)  
  9.         sdrv->driver.shutdown = spi_drv_shutdown;  
  10.     //将驱动注册进设备模型，注册成功的话就会在总线上寻找设备，调用总线上的match函数，看能否与之匹配起来，匹配成功的话，驱动中的probe函数就会被调用  
  11.     return driver_register(&sdrv->driver);  
  12. }  
int spi_register_driver(struct spi_driver *sdrv)
{
	sdrv->driver.bus = &spi_bus_type; //该驱动所属的总线
	if (sdrv->probe)
		sdrv->driver.probe = spi_drv_probe;
	if (sdrv->remove)
		sdrv->driver.remove = spi_drv_remove;
	if (sdrv->shutdown)
		sdrv->driver.shutdown = spi_drv_shutdown;
	//将驱动注册进设备模型，注册成功的话就会在总线上寻找设备，调用总线上的match函数，看能否与之匹配起来，匹配成功的话，驱动中的probe函数就会被调用
	return driver_register(&sdrv->driver);
}

在调用driver_register的过程中，将用driver.name和spi_device的modalias字段进行比较，两者相等则将该spi_driver和spi_device进行绑定。当spi_driver注册成功以后，将调用probe方法：spidev_probe函数。

2. 探测和移除函数：spidev_probe & spidev_remove

[cpp] view plain copy print ?
  1. static int __devinit spidev_probe(struct spi_device *spi)  
  2. {  
  3.     struct spidev_data  *spidev;  
  4.     int         status;  
  5.     unsigned long       minor;  
  6.   
  7.     /* Allocate driver data */  
  8.     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL); //分配内存，注意对象的类型是struct spidev_data  
  9.     if (!spidev)  
  10.         return -ENOMEM;  
  11.   
  12.     /* Initialize the driver data */  
  13.     spidev->spi = spi;  
  14.     spin_lock_init(&spidev->spi_lock); //一些锁和链表的初始化  
  15.     mutex_init(&spidev->buf_lock);  
  16.   
  17.     INIT_LIST_HEAD(&spidev->device_entry);  
  18.   
  19.     /* If we can allocate a minor number, hook up this device. 
  20.      * Reusing minors is fine so long as udev or mdev is working. 
  21.      */  
  22.     mutex_lock(&device_list_lock);  
  23.     minor = find_first_zero_bit(minors, N_SPI_MINORS); //从名字上就可以知道，就是找到第一个为0的位，分析见下面  
  24.     if (minor < N_SPI_MINORS) {  
  25.         struct device *dev;  
  26.   
  27.         spidev->devt = MKDEV(SPIDEV_MAJOR, minor); //如果找到了非0位，就将它作为次设备号与之前注册的主设备号生成设备号  
  28.         dev = device_create(spidev_class, &spi->dev, spidev->devt,//创建设备，并生成设备节点，设备节点在/dev目录下，名字的形式为“spidevx.x”  
  29.                     spidev, "spidev%d.%d",  
  30.                     spi->master->bus_num, spi->chip_select);  
  31.         status = IS_ERR(dev) ? PTR_ERR(dev) : 0;  
  32.     } else {  
  33.         dev_dbg(&spi->dev, "no minor number available!\n");  
  34.         status = -ENODEV;  
  35.     }  
  36.     if (status == 0) { //创建设备成功后，将相应的位置1，表示该次设备号已经被使用，同时将该设备加入到设备链表  
  37.         set_bit(minor, minors);  
  38.         list_add(&spidev->device_entry, &device_list);  
  39.     }  
  40.     mutex_unlock(&device_list_lock);  
  41.   
  42.     if (status == 0)  
  43.         spi_set_drvdata(spi, spidev); //将设备的私有数据指针指向该设备  
  44.     else  
  45.         kfree(spidev);  
  46.   
  47.     return status;  
  48. }  
  49.   
  50. static int __devexit spidev_remove(struct spi_device *spi)  
  51. {  
  52.     struct spidev_data  *spidev = spi_get_drvdata(spi);  
  53.   
  54.     /* make sure ops on existing fds can abort cleanly */  
  55.     spin_lock_irq(&spidev->spi_lock);  
  56.     spidev->spi = NULL;  
  57.     spi_set_drvdata(spi, NULL);  
  58.     spin_unlock_irq(&spidev->spi_lock);  
  59.   
  60.     /* prevent new opens */  
  61.     mutex_lock(&device_list_lock);  
  62.     list_del(&spidev->device_entry);  
  63.     device_destroy(spidev_class, spidev->devt);  
  64.     clear_bit(MINOR(spidev->devt), minors);  
  65.     if (spidev->users == 0)  
  66.         kfree(spidev);  
  67.     mutex_unlock(&device_list_lock);  
  68.   
  69.     return 0;  
  70. }  
static int __devinit spidev_probe(struct spi_device *spi)
{
	struct spidev_data	*spidev;
	int			status;
	unsigned long		minor;

	/* Allocate driver data */
	spidev = kzalloc(sizeof(*spidev), GFP_KERNEL); //分配内存，注意对象的类型是struct spidev_data
	if (!spidev)
		return -ENOMEM;

	/* Initialize the driver data */
	spidev->spi = spi;
	spin_lock_init(&spidev->spi_lock); //一些锁和链表的初始化
	mutex_init(&spidev->buf_lock);

	INIT_LIST_HEAD(&spidev->device_entry);

	/* If we can allocate a minor number, hook up this device.
	 * Reusing minors is fine so long as udev or mdev is working.
	 */
	mutex_lock(&device_list_lock);
	minor = find_first_zero_bit(minors, N_SPI_MINORS); //从名字上就可以知道，就是找到第一个为0的位，分析见下面
	if (minor < N_SPI_MINORS) {
		struct device *dev;

		spidev->devt = MKDEV(SPIDEV_MAJOR, minor); //如果找到了非0位，就将它作为次设备号与之前注册的主设备号生成设备号
		dev = device_create(spidev_class, &spi->dev, spidev->devt,//创建设备，并生成设备节点，设备节点在/dev目录下，名字的形式为“spidevx.x”
				    spidev, "spidev%d.%d",
				    spi->master->bus_num, spi->chip_select);
		status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
	} else {
		dev_dbg(&spi->dev, "no minor number available!\n");
		status = -ENODEV;
	}
	if (status == 0) { //创建设备成功后，将相应的位置1，表示该次设备号已经被使用，同时将该设备加入到设备链表
		set_bit(minor, minors);
		list_add(&spidev->device_entry, &device_list);
	}
	mutex_unlock(&device_list_lock);

	if (status == 0)
		spi_set_drvdata(spi, spidev); //将设备的私有数据指针指向该设备
	else
		kfree(spidev);

	return status;
}

static int __devexit spidev_remove(struct spi_device *spi)
{
	struct spidev_data	*spidev = spi_get_drvdata(spi);

	/* make sure ops on existing fds can abort cleanly */
	spin_lock_irq(&spidev->spi_lock);
	spidev->spi = NULL;
	spi_set_drvdata(spi, NULL);
	spin_unlock_irq(&spidev->spi_lock);

	/* prevent new opens */
	mutex_lock(&device_list_lock);
	list_del(&spidev->device_entry);
	device_destroy(spidev_class, spidev->devt);
	clear_bit(MINOR(spidev->devt), minors);
	if (spidev->users == 0)
		kfree(spidev);
	mutex_unlock(&device_list_lock);

	return 0;
}

spidev_data(kernel3.0.15/driver/spi/spidev.c)

[cpp] view plain copy print ?
  1. struct spidev_data {  
  2.     dev_t           devt; //设备号  
  3.     spinlock_t      spi_lock;  
  4.     struct spi_device   *spi;  
  5.     struct list_head    device_entry; //设备链表，所有采用此驱动的设备将连成一个链表  
  6.   
  7.     /* buffer is NULL unless this device is open (users > 0) */  
  8.     struct mutex        buf_lock;  
  9.     unsigned        users; //计数，也即是此设备被open的次数  
  10.     u8          *buffer;  
  11. };  
struct spidev_data {
	dev_t			devt; //设备号
	spinlock_t		spi_lock;
	struct spi_device	*spi;
	struct list_head	device_entry; //设备链表，所有采用此驱动的设备将连成一个链表

	/* buffer is NULL unless this device is open (users > 0) */
	struct mutex		buf_lock;
	unsigned		users; //计数，也即是此设备被open的次数
	u8			*buffer;
};
find_first_zero_bit(minors, N_SPI_MINORS)
第一个参数minors的定义：

kernel3.0.15/driver/spi/spidev.c

[cpp] view plain copy print ?
  1. #define N_SPI_MINORS            32  /* ... up to 256 */  
  2.   
  3. static DECLARE_BITMAP(minors, N_SPI_MINORS);  
#define N_SPI_MINORS			32	/* ... up to 256 */

static DECLARE_BITMAP(minors, N_SPI_MINORS);
DECLARE_BITMAP是一个宏，定义如下：

kernel3.0.15/include/linux/types.h

[cpp] view plain copy print ?
  1. #define DECLARE_BITMAP(name,bits) \  
  2.     unsigned long name[BITS_TO_LONGS(bits)]  
#define DECLARE_BITMAP(name,bits) \
	unsigned long name[BITS_TO_LONGS(bits)]
将宏展开后是这样的，unsigned long minors[1]，其实就是定义一个只有一个元素的无符号长整形数组miniors。

3. 打开和释放函数：spidev_open & spidev_release

[cpp] view plain copy print ?
  1. static int spidev_open(struct inode *inode, struct file *filp)  
  2. {  
  3.     struct spidev_data  *spidev;  
  4.     int         status = -ENXIO;  
  5.   
  6.     mutex_lock(&device_list_lock);  
  7.   
  8.     list_for_each_entry(spidev, &device_list, device_entry) {  
  9.         if (spidev->devt == inode->i_rdev) { //遍历设备链表，每找到一个设备就将它的设备号与打开文件的设备号进行比较，相等的话表示查找成功  
  10.             status = 0;  
  11.             break;  
  12.         }  
  13.     }  
  14.     //查找成功后就分配读写数据内存，使用计数加1，设置文件私有数据指针指向查找到的设备，以后在驱动的write、read函数里就可以把它取出来  
  15.     if (status == 0) {  
  16.         if (!spidev->buffer) {  
  17.             spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);  
  18.             if (!spidev->buffer) {  
  19.                 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");  
  20.                 status = -ENOMEM;  
  21.             }  
  22.         }  
  23.         if (status == 0) {  
  24.             spidev->users++;  
  25.             filp->private_data = spidev;  
  26.             nonseekable_open(inode, filp);  
  27.         }  
  28.     } else  
  29.         pr_debug("spidev: nothing for minor %d\n", iminor(inode));  
  30.   
  31.     mutex_unlock(&device_list_lock);  
  32.     return status;  
  33. }  
  34.   
  35. static int spidev_release(struct inode *inode, struct file *filp)  
  36. {  
  37.     struct spidev_data  *spidev;  
  38.     int         status = 0;  
  39.   
  40.     mutex_lock(&device_list_lock);  
  41.     spidev = filp->private_data;  
  42.     filp->private_data = NULL;  
  43.   
  44.     /* last close? */  
  45.     spidev->users--;  
  46.     if (!spidev->users) {  
  47.         int     dofree;  
  48.   
  49.         kfree(spidev->buffer);  
  50.         spidev->buffer = NULL;  
  51.   
  52.         /* ... after we unbound from the underlying device? */  
  53.         spin_lock_irq(&spidev->spi_lock);  
  54.         dofree = (spidev->spi == NULL);  
  55.         spin_unlock_irq(&spidev->spi_lock);  
  56.   
  57.         if (dofree)  
  58.             kfree(spidev);  
  59.     }  
  60.     mutex_unlock(&device_list_lock);  
  61.   
  62.     return status;  
  63. }  
static int spidev_open(struct inode *inode, struct file *filp)
{
	struct spidev_data	*spidev;
	int			status = -ENXIO;

	mutex_lock(&device_list_lock);

	list_for_each_entry(spidev, &device_list, device_entry) {
		if (spidev->devt == inode->i_rdev) { //遍历设备链表，每找到一个设备就将它的设备号与打开文件的设备号进行比较，相等的话表示查找成功
			status = 0;
			break;
		}
	}
	//查找成功后就分配读写数据内存，使用计数加1，设置文件私有数据指针指向查找到的设备，以后在驱动的write、read函数里就可以把它取出来
	if (status == 0) {
		if (!spidev->buffer) {
			spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
			if (!spidev->buffer) {
				dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
				status = -ENOMEM;
			}
		}
		if (status == 0) {
			spidev->users++;
			filp->private_data = spidev;
			nonseekable_open(inode, filp);
		}
	} else
		pr_debug("spidev: nothing for minor %d\n", iminor(inode));

	mutex_unlock(&device_list_lock);
	return status;
}

static int spidev_release(struct inode *inode, struct file *filp)
{
	struct spidev_data	*spidev;
	int			status = 0;

	mutex_lock(&device_list_lock);
	spidev = filp->private_data;
	filp->private_data = NULL;

	/* last close? */
	spidev->users--;
	if (!spidev->users) {
		int		dofree;

		kfree(spidev->buffer);
		spidev->buffer = NULL;

		/* ... after we unbound from the underlying device? */
		spin_lock_irq(&spidev->spi_lock);
		dofree = (spidev->spi == NULL);
		spin_unlock_irq(&spidev->spi_lock);

		if (dofree)
			kfree(spidev);
	}
	mutex_unlock(&device_list_lock);

	return status;
}

4. 读和写函数：spidev_read & spidev_write

[cpp] view plain copy print ?
  1. /* Read-only message with current device setup */  
  2. static ssize_t  
  3. spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)  
  4. {  
  5.     struct spidev_data  *spidev;  
  6.     ssize_t         status = 0;  
  7.   
  8.     /* chipselect only toggles at start or end of operation */  
  9.     if (count > bufsiz)  
  10.         return -EMSGSIZE;  
  11.   
  12.     spidev = filp->private_data;  
  13.   
  14.     mutex_lock(&spidev->buf_lock);  
  15.     status = spidev_sync_read(spidev, count);  
  16.     if (status > 0) {  
  17.         unsigned long   missing;  
  18.   
  19.         missing = copy_to_user(buf, spidev->buffer, status);  
  20.         if (missing == status)  
  21.             status = -EFAULT;  
  22.         else  
  23.             status = status - missing;  
  24.     }  
  25.     mutex_unlock(&spidev->buf_lock);  
  26.   
  27.     return status;  
  28. }  
  29.   
  30. /* Write-only message with current device setup */  
  31. static ssize_t  
  32. spidev_write(struct file *filp, const char __user *buf,  
  33.         size_t count, loff_t *f_pos)  
  34. {  
  35.     struct spidev_data  *spidev;  
  36.     ssize_t         status = 0;  
  37.     unsigned long       missing;  
  38.   
  39.     /* chipselect only toggles at start or end of operation */  
  40.     if (count > bufsiz) //应用程序写入的数据不能大于驱动中缓冲区的大小，默认为4096个字节  
  41.         return -EMSGSIZE;  
  42.   
  43.     spidev = filp->private_data; //指向文件的私有数据  
  44.   
  45.     mutex_lock(&spidev->buf_lock);  
  46.     missing = copy_from_user(spidev->buffer, buf, count); //拷贝用户空间的数据到内核空间  
  47.     if (missing == 0) {  
  48.         status = spidev_sync_write(spidev, count);  
  49.     } else  
  50.         status = -EFAULT;  
  51.     mutex_unlock(&spidev->buf_lock);  
  52.   
  53.     return status;  
  54. }  
/* Read-only message with current device setup */
static ssize_t
spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
	struct spidev_data	*spidev;
	ssize_t			status = 0;

	/* chipselect only toggles at start or end of operation */
	if (count > bufsiz)
		return -EMSGSIZE;

	spidev = filp->private_data;

	mutex_lock(&spidev->buf_lock);
	status = spidev_sync_read(spidev, count);
	if (status > 0) {
		unsigned long	missing;

		missing = copy_to_user(buf, spidev->buffer, status);
		if (missing == status)
			status = -EFAULT;
		else
			status = status - missing;
	}
	mutex_unlock(&spidev->buf_lock);

	return status;
}

/* Write-only message with current device setup */
static ssize_t
spidev_write(struct file *filp, const char __user *buf,
		size_t count, loff_t *f_pos)
{
	struct spidev_data	*spidev;
	ssize_t			status = 0;
	unsigned long		missing;

	/* chipselect only toggles at start or end of operation */
	if (count > bufsiz) //应用程序写入的数据不能大于驱动中缓冲区的大小，默认为4096个字节
		return -EMSGSIZE;

	spidev = filp->private_data; //指向文件的私有数据

	mutex_lock(&spidev->buf_lock);
	missing = copy_from_user(spidev->buffer, buf, count); //拷贝用户空间的数据到内核空间
	if (missing == 0) {
		status = spidev_sync_write(spidev, count);
	} else
		status = -EFAULT;
	mutex_unlock(&spidev->buf_lock);

	return status;
}

5.ioctl函数：spidev_ioctl

[cpp] view plain copy print ?
  1. static long  
  2. spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)  
  3. {  
  4.     int         err = 0;  
  5.     int         retval = 0;  
  6.     struct spidev_data  *spidev;  
  7.     struct spi_device   *spi;  
  8.     u32         tmp;  
  9.     unsigned        n_ioc;  
  10.     struct spi_ioc_transfer *ioc;  
  11.   
  12.     /* Check type and command number */  
  13.     if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)  
  14.         return -ENOTTY;  
  15.   
  16.     /* Check access direction once here; don't repeat below. 
  17.      * IOC_DIR is from the user perspective, while access_ok is 
  18.      * from the kernel perspective; so they look reversed. 
  19.      */  
  20.     if (_IOC_DIR(cmd) & _IOC_READ)  
  21.         err = !access_ok(VERIFY_WRITE,  
  22.                 (void __user *)arg, _IOC_SIZE(cmd));  
  23.     if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)  
  24.         err = !access_ok(VERIFY_READ,  
  25.                 (void __user *)arg, _IOC_SIZE(cmd));  
  26.     if (err)  
  27.         return -EFAULT;  
  28.   
  29.     /* guard against device removal before, or while, 
  30.      * we issue this ioctl. 
  31.      */  
  32.     spidev = filp->private_data;  
  33.     spin_lock_irq(&spidev->spi_lock);  
  34.     spi = spi_dev_get(spidev->spi);  
  35.     spin_unlock_irq(&spidev->spi_lock);  
  36.   
  37.     if (spi == NULL)  
  38.         return -ESHUTDOWN;  
  39.   
  40.     /* use the buffer lock here for triple duty: 
  41.      *  - prevent I/O (from us) so calling spi_setup() is safe; 
  42.      *  - prevent concurrent SPI_IOC_WR_* from morphing 
  43.      *    data fields while SPI_IOC_RD_* reads them; 
  44.      *  - SPI_IOC_MESSAGE needs the buffer locked "normally". 
  45.      */  
  46.     mutex_lock(&spidev->buf_lock);  
  47.   
  48.     switch (cmd) {  
  49.     /* read requests */  
  50.     case SPI_IOC_RD_MODE:  
  51.         retval = __put_user(spi->mode & SPI_MODE_MASK,  
  52.                     (__u8 __user *)arg);  
  53.         break;  
  54.     case SPI_IOC_RD_LSB_FIRST:  
  55.         retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,  
  56.                     (__u8 __user *)arg);  
  57.         break;  
  58.     case SPI_IOC_RD_BITS_PER_WORD:  
  59.         retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);  
  60.         break;  
  61.     case SPI_IOC_RD_MAX_SPEED_HZ:  
  62.         retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);  
  63.         break;  
  64.   
  65.     /* write requests */  
  66.     case SPI_IOC_WR_MODE:  
  67.         retval = __get_user(tmp, (u8 __user *)arg);  
  68.         if (retval == 0) {  
  69.             u8  save = spi->mode;  
  70.   
  71.             if (tmp & ~SPI_MODE_MASK) {  
  72.                 retval = -EINVAL;  
  73.                 break;  
  74.             }  
  75.   
  76.             tmp |= spi->mode & ~SPI_MODE_MASK;  
  77.             spi->mode = (u8)tmp;  
  78.             retval = spi_setup(spi);  
  79.             if (retval < 0)  
  80.                 spi->mode = save;  
  81.             else  
  82.                 dev_dbg(&spi->dev, "spi mode %02x\n", tmp);  
  83.         }  
  84.         break;  
  85.     case SPI_IOC_WR_LSB_FIRST:  
  86.         retval = __get_user(tmp, (__u8 __user *)arg);  
  87.         if (retval == 0) {  
  88.             u8  save = spi->mode;  
  89.   
  90.             if (tmp)  
  91.                 spi->mode |= SPI_LSB_FIRST;  
  92.             else  
  93.                 spi->mode &= ~SPI_LSB_FIRST;  
  94.             retval = spi_setup(spi);  
  95.             if (retval < 0)  
  96.                 spi->mode = save;  
  97.             else  
  98.                 dev_dbg(&spi->dev, "%csb first\n",  
  99.                         tmp ? 'l' : 'm');  
  100.         }  
  101.         break;  
  102.     case SPI_IOC_WR_BITS_PER_WORD:  
  103.         retval = __get_user(tmp, (__u8 __user *)arg);  
  104.         if (retval == 0) {  
  105.             u8  save = spi->bits_per_word;  
  106.   
  107.             spi->bits_per_word = tmp;  
  108.             retval = spi_setup(spi);  
  109.             if (retval < 0)  
  110.                 spi->bits_per_word = save;  
  111.             else  
  112.                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);  
  113.         }  
  114.         break;  
  115.     case SPI_IOC_WR_MAX_SPEED_HZ:  
  116.         retval = __get_user(tmp, (__u32 __user *)arg);  
  117.         if (retval == 0) {  
  118.             u32 save = spi->max_speed_hz;  
  119.   
  120.             spi->max_speed_hz = tmp;  
  121.             retval = spi_setup(spi);  
  122.             if (retval < 0)  
  123.                 spi->max_speed_hz = save;  
  124.             else  
  125.                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);  
  126.         }  
  127.         break;  
  128.   
  129.     default:  
  130.         /* segmented and/or full-duplex I/O request */  
  131.         if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))  
  132.                 || _IOC_DIR(cmd) != _IOC_WRITE) {  
  133.             retval = -ENOTTY;  
  134.             break;  
  135.         }  
  136.   
  137.         tmp = _IOC_SIZE(cmd);  
  138.         if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {  
  139.             retval = -EINVAL;  
  140.             break;  
  141.         }  
  142.         n_ioc = tmp / sizeof(struct spi_ioc_transfer);  
  143.         if (n_ioc == 0)  
  144.             break;  
  145.   
  146.         /* copy into scratch area */  
  147.         ioc = kmalloc(tmp, GFP_KERNEL);  
  148.         if (!ioc) {  
  149.             retval = -ENOMEM;  
  150.             break;  
  151.         }  
  152.         if (__copy_from_user(ioc, (void __user *)arg, tmp)) {  
  153.             kfree(ioc);  
  154.             retval = -EFAULT;  
  155.             break;  
  156.         }  
  157.   
  158.         /* translate to spi_message, execute */  
  159.         retval = spidev_message(spidev, ioc, n_ioc);  
  160.         kfree(ioc);  
  161.         break;  
  162.     }  
  163.   
  164.     mutex_unlock(&spidev->buf_lock);  
  165.     spi_dev_put(spi);  
  166.     return retval;  
  167. }  

你可能感兴趣的:(硬件驱动)

  • 新一代网络研发利器——开物™，让用户每一行代码都贡献在核心创新 中科驭数 网络云计算大数据人工智能
    随着云计算、人工智能、大数据的快速发展，现有的IT系统越来越复杂，传统网络技术难以满足新的业务需求，DPU技术开始崭露头角，越来越多的企业与研究机构认识到高性能网络处理技术带来的巨大价值，并积极开展创新与实践，从而实现更匹配的功能和更高的系统性能。但是，从零开始进行网络系统的搭建，开发人员需要掌握各类创新技术无关的、最底层的技术架构原理，如硬件设计逻辑、API接口、底层IP、硬件驱动等一系列复杂的
  • “在工作中学习”和“根据遇到的问题捡知识”两者有巨大不同 常敲代码手不生 沉羽学习学习方法职场和发展
    目前整个软件行业越来越需要一堆多面手，也许现在已经是这样了，只是我还没有注意到。当然，我也不喜欢这种情。现在，好像没有人愿意花更多的时间来把某一个东西学好学深学扎实编程语言推荐：C语言不用多说，现今这个世界上几乎所有重要的软件都跟C有直接和间接的关系，操作系统、网络、硬件驱动等等。说得霸气一点儿，这个世界就是在C语言之上运行的。C++来说，现在主流的浏览器、数据库、MicrosoftOffice、
  • LabVIEW软件，如何检测连接到的设备？ LabVIEW开发 LabVIEW知识labview设备连接
    在LabVIEW软件中，检测连接到的设备通常是通过NI提供的硬件驱动和相关工具来完成的。以下是几种常见的检测设备的方法：1.使用NIMAX（Measurement&AutomationExplorer）打开NIMAX：LabVIEW设备管理通常通过NIMAX完成，打开NIMAX后，你可以查看系统中所有连接的NI硬件设备。识别设备：在“设备和接口”下，NIMAX会列出所有可用的硬件设备，包括数据采集
  • iOS 中，用户点击一个按钮到响应的全部流程 ilycyq ioscocoamacos网络objective-c
    在iOS中，当用户点击一个按钮（或其他UI控件）时，会触发一系列复杂的操作流程，从硬件到软件，再到应用层的事件处理。以下是从用户点击一个按钮到应用响应的完整流程：硬件层：触摸事件的生成•用户用手指点击屏幕。•屏幕（电容式触摸屏）检测到用户的触摸事件。触摸屏幕的电容变化会被屏幕的传感器检测到。•触摸控制器（TouchController）将这些电容变化转化为电信号。硬件驱动层：事件传递到操作系统内核
  • 100% 蓝屏解决方案：以 DPC_WATCHDOG_VIOLATION 为例 明矛顿了 人工智能电脑
    Windows蓝屏的原因众多，你在网上搜到的解决方案，大多与你的情况不同，无法解决实际问题。但是，如果你找到并分析电脑上的dmp蓝屏日志，就会发现Windows已经给出了你的蓝屏原因。比如DPC_WATCHDOG_VIOLATION蓝屏，大多是由于硬件驱动出现问题造成的。你可以通过回退、更新或卸载驱动来修复蓝屏。接下来，我将具体介绍如何导出蓝屏日志、分析并解决蓝屏原因。#导出蓝屏日志安装WinDb
  • 【C语言】socket 层到网络接口的驱动程序之间的函数调用过程 尘中928 编程#C语言#linux内核c语言开发语言
    一、socket层到网络接口的驱动程序之间的函数调用过程概述在Linux操作系统中，socket层到网络接口的驱动程序之间的函数调用过程相对复杂，涉及多个层次的交互。以下是一个简化的概述，描述数据从socket传递到硬件驱动，再到硬件设备的基本调用过程：1.用户空间到内核空间：用户程序通过socketAPI发起网络操作。当用户空间要发送数据时，它会调用如sendto或write等系统调用，这些调用
  • Netty应用(四) 之 Reactor模型 & 零拷贝 etcEriksen Netty应用java开发语言netty后端
    目录6.Reactor模型6.1单线程Reactor6.2主从多线程Reactor(主--->Boss|从--->Worker|一主多从机制)7.扩展与补充8.Reactor模型的实现8.1多线程Reactor模型的实现（一个Boss线程，一个Worker线程）8.2多线程Reactor模型的实现（一个Boss线程，多个Worker线程）9.零拷贝10.硬件驱动程序与软件驱动程序（数据库驱动程序）
  • dx12 龙书第四章学习笔记 -- Direct3D的初始化 帅狗狗灬 DirectX笔记游戏学习c++
    1.预备知识：①Direct3D12概述：通过Direct3D这种底层图形应用程序编程接口(ApplicationProgrammingInterface,API),即可在应用程序中对图形处理器(GraphicsProcessingUnit,GPU)进行控制和编程Direct3D层和硬件驱动会协作将Direct3D命令转换为系统中GPU可以执行的本地机器指令--无需考虑GPU的具体规格和硬件控制层
  • HAL层(硬件驱动接口)和库函数的(访问硬件寄存器的接口) 学无止境2022 C语言
    HAL函数库提供了更高级的抽象和更好的可移植性，适合快速开发和跨平台应用。而库函数则更加底层，性能更高，适合对性能要求较高的应用HAL（HardwareAbstractionLayer）层是一种硬件抽象层，它提供了一组函数接口，用于访问底层硬件资源。HAL层的目标是使应用程序与底层硬件解耦，从而实现跨平台的移植性和可重用性。HAL层提供了一种统一的编程接口，使开发人员可以使用相同的代码在不同的硬件
  • Centos 6.5 内核版本升级 一个头发茂密的程序员
    1.uname-r//查看当前内核版本2.安装elrepoyum源（提供内核更新、硬件驱动等软件源支持）rpm-Uvhhttp://www.elrepo.org/elrepo-release-6-8.el6.elrepo.noarch.rpm内核升级yumelrepo源两种内核:ml（mainline为最新版本的内核）lt（长期支持的内核)选择lt内核yum--enablerepo=elrepo-
  • RK3568平台 热插拔机制 嵌入式_笔记 瑞芯微linux运维服务器
    一.热插拔的基本概念热插拔是指在设备运行的情况下，能够安全地插入或拔出硬件设备，而无需关闭或重启系统。这意味着你可以在计算机或其他电子设备上插入或拔出硬件组件（比如USB设备，扩展卡，硬件驱动器等），而无需关机或中断正在进行的操作。比如鼠标，键盘，打印机，存储设备等。二.热插拔用到的文件系统mdev：mdev是一个轻量级的热插拔设备文件系统，通常用于嵌入式Linux系统。它是udev的简化版本，使
  • 江科大stm32学习笔记7——按键控制LED 风痕天际 江科大stm32学习笔记stm32学习笔记C
    接线：复制粘贴蜂鸣器文件夹，重命名为“3-4按键控制LED”，新建一个名为“Hardware”的文件夹用于存放硬件驱动文件。打开keil5，点击三个箱子按钮，在“Groups”中新建一个“Hardware”。再点击魔术棒按钮，在C/C++中选择“IncludePaths”，将Hardware的文件路径加入进来。回到keil，右键“Hardware”新建“LED.c”和“LED.h”，注意在新建时记
  • 深度学习编译器后端和运行时 RJ_theMag 机器学习编译深度学习人工智能
    编译器前端将用户代码解析得到计算图IR，并且做了一些和计算设备无关的通用优化。编译器后端做的优化就和具体的设备有关了（不同设备有不同的allocator，不同的编程模型，比如英伟达的CUDA），后端优化更加贴合硬件，会针对硬件特点为IR中的计算节点选择在硬件上的算子，然后为每个算子的输入输出分配硬件内存，最终生成一个可以在硬件上执行的任务序列。如上图所示，编译器后端位于前端和硬件驱动层之间，主要做
  • LabVIEW电火花线切割放电点位置 LabVIEW开发 LabVIEW开发案例LabVIEWLabVIEW开发LabVIEW编程labview
    介绍了一个电火花线切割放电点位置分布评价系统，特别是在系统组成、硬件选择和LabVIEW软件应用方面。本系统由两个主要部分组成：硬件和软件。硬件部分包括电流传感器、高速数据采集卡、开关电源、电阻和导线。软件部分则由LabVIEW编程环境构成，包括硬件驱动模块、模数转换模块、放电位置采集模块、显示与存储模块、放电点位置分布评价模块等。硬件部分通过电流传感器和数据采集卡，捕获电火花线切割过程中的放电点
  • 系统移植(系统移植环境搭建及简单概念) °嘟嘟嘟嘟 系统移植内核ubootarm
    linux系统=linux内核+根文件系统;根文件系统=库(/lib和/usr/lib)+命令(/bin和/usr/bin)+配置文件(/etc)+GUI(图形化界面，如:QT)1、为什么学习系统移植为后边学习linux驱动开发打基础linux驱动开发：基于linux内核提供的接口，完成硬件驱动的开发。2、系统移植的目的给开发板移植一个linux操作系统3、如何学习系统移植系统移植都是流程化的操作
  • 单片机C51之1：流水灯 jllws1 C语言51单片机c语言
    前言：51系列单片机硬件驱动入门基础流水灯是第一个单片机程序，或者说是最简单的单片机程序，但是里面蕴含了一个最基本的原理：用数据直接控制外设，小小的led灯即是数据的最直接体现。目录1.C语言移位指令实现连续点亮；2.C51库函数实现循环点亮；3.万能方法---硬写入数值并延时；4.C语言掩码实现连续点亮；5.C语言实现循环点亮6.连续亮灭实验准备：实验板P1口连接8个led小灯的阴极，共阳极接法
  • 查看电脑系统信息，msinfo32查看硬件驱动软件服务程序图文教程 老盖聊技术
    大家好，我是老盖，感谢观看本篇文章，本文做的也有视频，也可以看我发布的视频。今天给大家介绍一下系统自带的一个程序，它能查看系统的信息。程序包含了很多系统相关的信息，下边一一介绍一下。点开始运行输入命令，msinfo32。这个就是系统信息程序，程序启动后可以看有一些显示数据，比如计算机的名称，bios，内存等一些信息，左侧有一个树形菜单列表，我们点一下看一下内容。随便点一些选项进行查看，比如点组件的
  • 单片机和Linux嵌入式区别 左手的月光 单片机linux嵌入式硬件
    1.单片机单片机是一种集成电路，它能够在一个芯片上完成各种计算、控制和管理任务。单片机没有明确的分层，这是因为它通常被用来设计嵌入式系统，其程序结构和功能要根据具体的应用需求来设计。在单片机的程序设计中，可以通过一些方法将程序分为不同的层次，比如可以将程序分为用户层和驱动层。用户层是指处理应用程序逻辑的部分，驱动层是指处理硬件驱动和底层操作的部分。用户层是为了方便开发人员理解和维护程序而设计的，它
  • INCA基础操作：文件刷写 菲益科电子 python
    搞汽车嵌入式开发，大家对INCA应该不陌生。尤其搞应用算法的同学，最擅长使用INCA或者CANape。使用INCA，除了进行标定，常见的另一个用途就是刷写文件（eg：App或者标定文件）。1、INCA硬件连接及注意事项使用INCA，需要软/硬件设备。软件：INCA软件、INCA对应硬件驱动程序硬件：INCA硬件接口卡（比如：ES581等）、目标板、电源等。INCA的连接示意如下所示：（一）INCA
  • 使用MATLAB连接USRP 须尽欢~~ USRPmatlabUSRP软件无线电
    文章目录前言一、本地环境二、前期准备1、MATLAB版本、labview版本、UHD版本对应关系2、下载GNURadioCompanion3、确定USRPUHD版本①、下载一个USRP硬件驱动程序②、确认MATLAB的UHD版本三、下载USRP通信工具箱支持包四、使用MATLAB连接USRP前言本文记录搭建使用MATLAB连接USRP环境的步骤。这个博客我写了近一周，遇到了很多坑，matlab版本
  • 芯课堂 | SWM211C8T7显示屏硬件驱动 华芯微特SYNWIT 单片机嵌入式硬件
    SWM211C8T7简介：SWM211C8T7为32位MCU（以下简称SWM211）内嵌ARM®Cortex®-M0内核，凭借其出色的性能以及高可靠性、低功耗、代码密度大等突出特点，可应用于工业控制、电机控制、白色家电等多种领域。SWM211C8T7支持片上包含精度为1%以内的12M时钟及PLL模块，最高支持90MHz的时钟输出。同时提供最大为64K字节的FLASH和最大8K字节的SRAM。此外，
  • linux usb drivers开发 武溪嵌人 linux驱动
    Linux下的硬件驱动——USB设备（上）（驱动配置部分）http://www.ibm.com/developerworks/cn/linux/l-usb/index1.htmlLinux下的硬件驱动——USB设备（下）（驱动开发部分）http://www.ibm.com/developerworks/cn/linux/l-usb/index2.html关于kernel2.6中USBhostcon
  • 2、HarmonyOS系统架构 黄金圣手 鸿蒙系统基础harmonyos系统架构华为学习开发语言
    一、HarmonyOS系统采用分层架构1、整体系统功能按照：“系统>子系统>功能/模块”逐级展开。在多设备部署场景下，支持根据实际需求裁剪某些非必要的子系统或功能/模块。2、内核子系统：HarmonyOS采用多内核设计，支持针对不同资源受限设备，选用适合的OS内核，为上层提供基础操作系统能力。3、驱动子系统：硬件驱动框架（HDF）是HarmonyOS硬件生态开放的基础，提供统一外设访问能力和驱动开
  • STM32上驱动NRF24L01 Davidysw stm32stm32嵌入式单片机
    文章目录一、模块工作流程1.接口电路2.NRF24L01状态机（1）主要有以下几个状态：（2）对24L01的固件编程的基本思路如下：3.Tx与Rx的配置过程（1）Tx模式初始化过程（2）Rx模式初始化过程二、移植步骤1、硬件驱动2、SPI接口函数3、函数封装4、模块初始化5、应用函数、数据处理三、代码1、bsp_spi_nrf.c2、bsp_spi_nrf.h3、app_spi_nrf.c4、ap
  • C语言光速入门笔记 Generalzy C/C++C
    C语言是一门面向过程的编译型语言，它的运行速度极快，仅次于汇编语言。C语言是计算机产业的核心语言，操作系统、硬件驱动、关键组件、数据库等都离不开C语言；不学习C语言，就不能了解计算机底层。目录C语言介绍C语言特性C编译器GCC(GNUCompilerCollection):Clang:MSVC(MicrosoftVisualC++Compiler):对比为什么要使用C？C语言的版本C11第一个C程
  • 论文笔记 Understanding Electricity-Theft Behavior via Multi-Source Data UQI-LIUWJ 论文笔记论文阅读
    WWW2020oral1INTRO1.1背景1.1.1窃电窃电（electricitytheft）指用户为了逃避电费而进行非法操作的一种行为常用的反窃电方法可分为两类：基于硬件驱动的反窃电方法电表开盖检测、集中器检测。。。。硬件驱动的方法响应快，定位准，但需要非常专业的领域知识，同时随着窃电策略的改变会随即失效基于数据驱动的反窃电方法分析用户用电时序曲线、分析台区线损时序曲线数据驱动的方法可以全盘
  • 深入探索C++：面向未来的高效编程 跑起来总会有风 未来科技与编程视角c++c语言游戏编辑器
    引言C++是一种高效的编程语言，它提供了丰富的特性，包括面向对象编程、泛型编程和低级内存操作。这些特性使得C++非常适合用于开发硬件驱动、操作系统、游戏等性能敏感的应用。C++的高性能特性来源于其接近硬件的编程能力，使得开发者能够精确控制程序的内存和处理器使用。此外，C++的面向对象和泛型编程特性提供了代码重用性和可维护性，这对于构建大型和复杂的软件系统尤为重要。C++还拥有一个强大的标准库，包括
  • SWM211C8T7显示屏硬件驱动 华芯微特SYNWIT 单片机嵌入式硬件
    SWM211C8T7简介：SWM211C8T7为32位MCU（以下简称SWM211）内嵌ARM®Cortex®-M0内核，凭借其出色的性能以及高可靠性、低功耗、代码密度大等突出特点，可应用于工业控制、电机控制、白色家电等多种领域。SWM211C8T7支持片上包含精度为1%以内的12M时钟及PLL模块，最高支持90MHz的时钟输出。同时提供最大为64K字节的FLASH和最大8K字节的SRAM。此外，
  • 如何在iPhone设备中查看崩溃日志 iOS学霸 日志查看iPhone设备ios
    目录如何在iPhone设备中查看崩溃日志摘要引言导致iPhone设备崩溃的主要原因是什么？使用克魔助手查看iPhone设备中的崩溃日志奔溃日志分析总结摘要本文介绍了如何在iPhone设备中查看崩溃日志，以便调查崩溃的原因。我们将展示三种不同的方法，包括使用克魔助手查看崩溃日志。引言当你的iPhone设备崩溃、冻结或自动重启时，不要担心。崩溃可能是由任何硬件驱动或iPhone设备错误造成的。在这种情
  • 如何在iPhone设备中查看崩溃日志 憧憬blog 代码混淆iOS证书android
    目录如何在iPhone设备中查看崩溃日志摘要引言导致iPhone设备崩溃的主要原因是什么？使用克魔助手查看iPhone设备中的崩溃日志奔溃日志分析总结摘要本文介绍了如何在iPhone设备中查看崩溃日志，以便调查崩溃的原因。我们将展示三种不同的方法，包括使用克魔助手查看崩溃日志。引言当你的iPhone设备崩溃、冻结或自动重启时，不要担心。崩溃可能是由任何硬件驱动或iPhone设备错误造成的。在这种情
  • SQL的各种连接查询 xieke90 UNION ALLUNION外连接内连接JOIN
    一、内连接   概念：内连接就是使用比较运算符根据每个表共有的列的值匹配两个表中的行。                 内连接（join 或者inner join ）       SQL语法：       select * fron
  • java编程思想--复用类 百合不是茶 java继承代理组合final类
          复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书   一:组合语法:就是将对象的引用放到新类中即可     代码:     package com.wj.reuse; /** * * @author Administrator 组
  • [开源与生态系统]国产CPU的生态系统 comsci cpu
          计算机要从娃娃抓起...而孩子最喜欢玩游戏....       要让国产CPU在国内市场形成自己的生态系统和产业链,国家和企业就不能够忘记游戏这个非常关键的环节....       投入一些资金和资源,人力和政策,让游
  • JVM内存区域划分Eden Space、Survivor Space、Tenured Gen，Perm Gen解释 商人shang jvm内存
    jvm区域总体分两类，heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。 非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。 HotSpot虚拟机GC算法采用分代收
  • 页面上调用 QQ oloz qq
    <A href="tencent://message/?uin=707321921&amp;Site=有事Q我&amp;Menu=yes">   <img style="border:0px;" src=http://wpa.qq.com/pa?p=1:707321921:1></a>
  • 一些问题 文强chu 问题
    1.eclipse 导出 doc  出现“The Javadoc command does not exist.” javadoc command 选择 jdk/bin/javadoc.exe 2.tomcate 配置 web 项目 ..... SQL:3.mysql  * 必须得放前面 否则  select&nbs
  • 生活没有安全感 小桔子 生活孤独安全感
           圈子好小，身边朋友没几个，交心的更是少之又少。在深圳，除了男朋友，没几个亲密的人。不知不觉男朋友成了唯一的依靠，毫不夸张的说，业余生活的全部。现在感情好，也很幸福的。但是说不准难免人心会变嘛，不发生什么大家都乐融融，发生什么很难处理。我想说如果不幸被分手(无论原因如何)，生活难免变化很大，在深圳，我没交心的朋友。明
  • php 基础语法 aichenglong php 基本语法
    1 .1 php变量必须以$开头 <?php $a=” b”; echo ?> 1 .2 php基本数据库类型 Integer  float/double Boolean string 1 .3 复合数据类型 数组array和对象 object 1 .4 特殊数据类型  null 资源类型(resource)    $co
  • mybatis tools 配置详解 AILIKES mybatis
    MyBatis Generator中文文档 MyBatis Generator中文文档地址： http://generator.sturgeon.mopaas.com/ 该中文文档由于尽可能和原文内容一致，所以有些地方如果不熟悉，看中文版的文档的也会有一定的障碍，所以本章根据该中文文档以及实际应用，使用通俗的语言来讲解详细的配置。 本文使用Markdown进行编辑，但是博客显示效
  • 继承与多态的探讨 百合不是茶 JAVA面向对象 继承 对象
    继承 extends   多态 继承是面向对象最经常使用的特征之一：继承语法是通过继承发、基类的域和方法 //继承就是从现有的类中生成一个新的类，这个新类拥有现有类的所有extends是使用继承的关键字：     在A类中定义属性和方法； class A{ //定义属性 int age； //定义方法 public void go
  • JS的undefined与null的实例 bijian1013 JavaScriptJavaScript
    <form name="theform" id="theform"> </form> <script language="javascript"> var a alert(typeof(b)); //这里提示undefined if(theform.datas
  • TDD实践（一） bijian1013 java敏捷TDD
    一.TDD概述         TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。     
  • [Maven学习笔记十]Maven Profile与资源文件过滤器 bit1129 maven
    什么是Maven Profile Maven Profile的含义是针对编译打包环境和编译打包目的配置定制，可以在不同的环境上选择相应的配置，例如DB信息，可以根据是为开发环境编译打包，还是为生产环境编译打包，动态的选择正确的DB配置信息   Profile的激活机制 1.Profile可以手工激活，比如在Intellij Idea的Maven Project视图中可以选择一个P
  • 【Hive八】Hive用户自定义生成表函数(UDTF) bit1129 hive
    1. 什么是UDTF   UDTF，是User Defined Table-Generating Functions，一眼看上去，貌似是用户自定义生成表函数，这个生成表不应该理解为生成了一个HQL Table， 貌似更应该理解为生成了类似关系表的二维行数据集   2. 如何实现UDTF 继承org.apache.hadoop.hive.ql.udf.generic
  • tfs restful api 加auth 2.0认计 ronin47
    　　目前思考如何给tfs的ngx-tfs api增加安全性。有如下两点： 　　一是基于客户端的ip设置。这个比较容易实现。 　　二是基于OAuth2.0认证，这个需要lua，实现起来相对于一来说，有些难度。 　　现在重点介绍第二种方法实现思路。 　　 前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGe
  • jdk环境变量配置 byalias javajdk
    进行java开发，首先要安装jdk，安装了jdk后还要进行环境变量配置： 1、下载jdk（http://java.sun.com/javase/downloads/index.jsp），我下载的版本是：jdk-7u79-windows-x64.exe 2、安装jdk-7u79-windows-x64.exe 3、配置环境变量：右击"计算机"-->&quo
  • 《代码大全》表驱动法-Table Driven Approach-2 bylijinnan java
    package com.ljn.base; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.uti
  • SQL 数值四舍五入 小数点后保留2位 chicony 四舍五入
    1.round() 函数是四舍五入用，第一个参数是我们要被操作的数据，第二个参数是设置我们四舍五入之后小数点后显示几位。 2.numeric 函数的2个参数，第一个表示数据长度，第二个参数表示小数点后位数。 例如： 　　select   cast(round(12.5,2)   as   numeric(5,2))  
  • c++运算符重载 CrazyMizzz C++
    一、加+，减-，乘*，除/ 的运算符重载 Rational operator*(const Rational &x) const{ return Rational(x.a * this->a); } 在这里只写乘法的，加减除的写法类似 二、<<输出,>>输入的运算符重载      &nb
  • hive DDL语法汇总 daizj hive修改列DDL修改表
    hive DDL语法汇总 １、对表重命名 hive> ALTER TABLE table_name RENAME TO new_table_name;   2、修改表备注 hive> ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comm
  • jbox使用说明 dcj3sjt126com Web
    参考网址：http://www.kudystudio.com/jbox/jbox-demo.html jBox v2.3 beta [ 点击下载]  技术交流QQGroup：172543951 100521167 [2011-11-11] jBox v2.3 正式版 - [调整&修复] IE6下有iframe或页面有active、applet控件
  • UISegmentedControl 开发笔记 dcj3sjt126com
      //    typedef NS_ENUM(NSInteger, UISegmentedControlStyle) {     //        UISegmentedControlStylePlain,     // large plain   &
  • Slick生成表映射文件 ekian scala
    Scala添加SLICK进行数据库操作，需在sbt文件上添加slick-codegen包 "com.typesafe.slick" %% "slick-codegen" % slickVersion 因为我是连接SQL Server数据库，还需添加slick-extensions，jtds包 "com.typesa
  • ES-TEST gengzg test
    package com.MarkNum; import java.io.IOException; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.servlet.ServletException; import javax.servlet.annotation
  • 为何外键不再推荐使用 hugh.wang mysqlDB
    表的关联，是一种逻辑关系，并不需要进行物理上的“硬关联”，而且你所期望的关联，其实只是其数据上存在一定的联系而已，而这种联系实际上是在设计之初就定义好的固有逻辑。 在业务代码中实现的时候，只要按照设计之初的这种固有关联逻辑来处理数据即可，并不需要在数据库层面进行“硬关联”，因为在数据库层面通过使用外键的方式进行“硬关联”，会带来很多额外的资源消耗来进行一致性和完整性校验，即使很多时候我们并不
  • 领域驱动设计 julyflame VODAO设计模式DTOpo
    概念： VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对
  • 单例设计模式 hm4123660 javaSingleton单例设计模式懒汉式饿汉式
           单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。      &nb
  • logback zhb8015 loglogback
    一、logback的介绍      Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-class
  • 整合Kafka到Spark Streaming——代码示例和挑战 Stark_Summer sparkstormzookeeperPARALLELISMprocessing
    作者Michael G. Noll是瑞士的一位工程师和研究员，效力于Verisign，是Verisign实验室的大规模数据分析基础设施（基础Hadoop）的技术主管。本文，Michael详细的演示了如何将Kafka整合到Spark Streaming中。 期间， Michael还提到了将Kafka整合到 Spark Streaming中的一些现状，非常值得阅读，虽然有一些信息在Spark 1.2版
  • spring-master-slave-commondao 王新春 DAOspringdataSourceslavemaster
    互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。 为此，往往搭建 db的 一主多从库的 数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他