辉辉308
辉辉308

Linux spi驱动分析(三)----spiddev分析

一、spidev简单介绍

        如果在内核中配置spidev，会在“/dev”目录下产生设备节点，通过此节点可以操作挂载在该SPI总线上的设备，接下来将从驱动层和应用层

来分析程序。

二、spidev驱动层

2.1、驱动注册

        分析一个设备驱动，一般都是从module_init和module_exit处开始，本文也不例外，程序如下：

点击(此处)折叠或打开

  1. #define SPIDEV_MAJOR            153    /* assigned */
  2. #define N_SPI_MINORS            32    /* ... up to 256 */

  4. static DECLARE_BITMAP(minors, N_SPI_MINORS);
  5. static struct spi_driver spidev_spi_driver = {
  6.     .driver = {
  7.         .name =        "spidev",
  8.         .owner =    THIS_MODULE,
  9.     },
  10.     .probe =    spidev_probe,
  11.     .remove =    __devexit_p(spidev_remove),

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

  20. /*-------------------------------------------------------------------------*/

  22. static int __init spidev_init(void)
  23. {
  24.     int status;

  26.     /* Claim our 256 reserved device numbers. Then register a class
  27.      * that will key udev/mdev to add/remove /dev nodes. Last, register
  28.      * the driver which manages those device numbers.
  29.      */
  30.     BUILD_BUG_ON(N_SPI_MINORS > 256);
  31.     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
  32.     if (status < 0)
  33.         return status;

  35.     spidev_class = class_create(THIS_MODULE, "spidev");
  36.     if (IS_ERR(spidev_class)) {
  37.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  38.         return PTR_ERR(spidev_class);
  39.     }

  41.     status = spi_register_driver(&spidev_spi_driver);
  42.     if (status < 0) {
  43.         class_destroy(spidev_class);
  44.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  45.     }
  46.     return status;
  47. }
  48. module_init(spidev_init);

  50. static void __exit spidev_exit(void)
  51. {
  52.     spi_unregister_driver(&spidev_spi_driver);
  53.     class_destroy(spidev_class);
  54.     unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
  55. }
  56. module_exit(spidev_exit);

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

        说明：

        1) 在驱动注册函数中，首先注册函数操作集spidev_fops，该内容将在2.3中具体讲述。

        2) 生成spidev设备类，此类的表现是在“/sys/class”目录下生成一个名为spidev目录。

        3) 注册spi驱动。

        4) 退出函数是注册函数的相反过程，就是释放注册函数中注册的资源。

2.2、探测和移除函数

        探测函数程序如下：

点击(此处)折叠或打开

  1. static int __devinit spidev_probe(struct spi_device *spi)
  2. {
  3.     struct spidev_data    *spidev;
  4.     int            status;
  5.     unsigned long        minor;

  7.     /* Allocate driver data */
  8.     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
  9.     if (!spidev)
  10.         return -ENOMEM;

  12.     /* Initialize the driver data */
  13.     spidev->spi = spi;
  14.     spin_lock_init(&spidev->spi_lock);
  15.     mutex_init(&spidev->buf_lock);

  17.     INIT_LIST_HEAD(&spidev->device_entry);

  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);
  24.     if (minor < N_SPI_MINORS) {
  25.         struct device *dev;

  27.         spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
  28.         dev = device_create(spidev_class, &spi->dev, spidev->devt,
  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) {
  37.         set_bit(minor, minors);
  38.         list_add(&spidev->device_entry, &device_list);
  39.     }
  40.     mutex_unlock(&device_list_lock);

  42.     if (status == 0)
  43.         spi_set_drvdata(spi, spidev);
  44.     else
  45.         kfree(spidev);

  47.     return status;
  48. }

        说明：

        1) 首先声明spidev_data结构体内存。

        2) 初始化其成员变量。

        3) 在位图中寻找第一个未被用到的位。

        4) 如果位图寻找正确，创建“/dev”目录下的设备节点。

        4) 将spidev结构体中的链表插入局部全局链表device_list中，以便在函数操作集中的open函数中使用            

        移除函数如下：

点击(此处)折叠或打开

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

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

  11.     /* prevent new opens */
  12.     mutex_lock(&device_list_lock);
  13.     list_del(&spidev->device_entry);
  14.     device_destroy(spidev_class, spidev->devt);
  15.     clear_bit(MINOR(spidev->devt), minors);
  16.     if (spidev->users == 0)
  17.         kfree(spidev);
  18.     mutex_unlock(&device_list_lock);

  20.     return 0;
  21. }

        说明：

        1) 移除函数就是探测函数的相反过程，主要就是释放探测函数中申请的资源。

2.2、函数操作集spidev_fop

        spidev_fop具体如下：

点击(此处)折叠或打开

  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. };

        首先看下打开函数spidev_open，程序如下：

点击(此处)折叠或打开

  1. static int spidev_open(struct inode *inode, struct file *filp)
  2. {
  3.     struct spidev_data    *spidev;
  4.     int            status = -ENXIO;

  6.     mutex_lock(&device_list_lock);

  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.     if (status == 0) {
  15.         if (!spidev->buffer) {
  16.             spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
  17.             if (!spidev->buffer) {
  18.                 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
  19.                 status = -ENOMEM;
  20.             }
  21.         }
  22.         if (status == 0) {
  23.             spidev->users++;
  24.             filp->private_data = spidev;
  25.             nonseekable_open(inode, filp);
  26.         }
  27.     } else
  28.         pr_debug("spidev: nothing for minor %d\n", iminor(inode));

  30.     mutex_unlock(&device_list_lock);
  31.     return status;
  32. }

        说明：

        1) 程序首先上本地全局互斥锁。

        2) 遍历链表device_list，通过设备号找到在探测函数中创建的设备结构体spidev。

        3) 如果寻找成功，将其保存在file的私有成员中，供其他操作集中的函数使用。

        realease函数如下：

点击(此处)折叠或打开

  1. static int spidev_release(struct inode *inode, struct file *filp)
  2. {
  3.     struct spidev_data    *spidev;
  4.     int            status = 0;

  6.     mutex_lock(&device_list_lock);
  7.     spidev = filp->private_data;
  8.     filp->private_data = NULL;

  10.     /* last close? */
  11.     spidev->users--;
  12.     if (!spidev->users) {
  13.         int        dofree;

  15.         kfree(spidev->buffer);
  16.         spidev->buffer = NULL;

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

  23.         if (dofree)
  24.             kfree(spidev);
  25.     }
  26.     mutex_unlock(&device_list_lock);

  28.     return status;
  29. }

        说明：

        1) 首先减少使用次数。

        2) 释放传输buf空间。

        3) 释放结构体内存。

        spi读数据函数如下：

点击(此处)折叠或打开

  1. static inline ssize_t
  2. spidev_sync_read(struct spidev_data *spidev, size_t len)
  3. {
  4.     struct spi_transfer    t = {
  5.             .rx_buf        = spidev->buffer,
  6.             .len        = len,
  7.         };
  8.     struct spi_message    m;

  10.     spi_message_init(&m);
  11.     spi_message_add_tail(&t, &m);
  12.     return spidev_sync(spidev, &m);
  13. }
  14. static ssize_t
  15. spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
  16. {
  17.     struct spidev_data    *spidev;
  18.     ssize_t            status = 0;

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

  24.     spidev = filp->private_data;

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

  31.         missing = copy_to_user(buf, spidev->buffer, status);
  32.         if (missing == status)
  33.             status = -EFAULT;
  34.         else
  35.             status = status - missing;
  36.     }
  37.     mutex_unlock(&spidev->buf_lock);

  39.     return status;
  40. }

        说明：

        1) 进入读函数中，首先上互斥锁。

        2) 然后调用spidev_sync_read函数读数据。

        3) 如果读取成功，将读取到的数据拷贝到应用层。

        4) 解互斥锁。

        5) 在spidev_sync_read函数中，首先定义一个传输结构体spi_transfer，由于是读操作，所以只初始化其接收buf。

        6) 初始化spi_message，调用函数spidev_sync传输数据，其具体程序如下：

点击(此处)折叠或打开

  1. static ssize_t
  2. spidev_sync(struct spidev_data *spidev, struct spi_message *message)
  3. {
  4.     DECLARE_COMPLETION_ONSTACK(done);
  5.     int status;

  7.     message->complete = spidev_complete;
  8.     message->context = &done;

  10.     spin_lock_irq(&spidev->spi_lock);
  11.     if (spidev->spi == NULL)
  12.         status = -ESHUTDOWN;
  13.     else
  14.         status = spi_async(spidev->spi, message);
  15.     spin_unlock_irq(&spidev->spi_lock);

  17.     if (status == 0) {
  18.         wait_for_completion(&done);
  19.         status = message->status;
  20.         if (status == 0)
  21.             status = message->actual_length;
  22.     }
  23.     return status;
  24. }

        说明：

        1) 首先定义并初始化一个completion。

        2) 上自旋锁，调用spi_async函数传输数据，spi_async就是在Linux核心中提供的传输函数。

        3) 如果调用传输函数成功，则等待。

        3) wait_for_completion(&done);等待传输完成，如果传输正确，函数返回值为传输的字节数。

        函数操作集写函数spidev_write程序如下：

点击(此处)折叠或打开

  1. static inline ssize_t
  2. spidev_sync_write(struct spidev_data *spidev, size_t len)
  3. {
  4.     struct spi_transfer    t = {
  5.             .tx_buf        = spidev->buffer,
  6.             .len        = len,
  7.         };
  8.     struct spi_message    m;

  10.     spi_message_init(&m);
  11.     spi_message_add_tail(&t, &m);
  12.     return spidev_sync(spidev, &m);
  13. }
  14. static ssize_t
  15. spidev_write(struct file *filp, const char __user *buf,
  16.         size_t count, loff_t *f_pos)
  17. {
  18.     struct spidev_data    *spidev;
  19.     ssize_t            status = 0;
  20.     unsigned long        missing;

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

  26.     spidev = filp->private_data;

  28.     mutex_lock(&spidev->buf_lock);
  29.     missing = copy_from_user(spidev->buffer, buf, count);
  30.     if (missing == 0) {
  31.         status = spidev_sync_write(spidev, count);
  32.     } else
  33.         status = -EFAULT;
  34.     mutex_unlock(&spidev->buf_lock);

  36.     return status;
  37. }

        说明：

        1) 写函数首先上互斥锁，然后从应用层拷贝需要写的数据。

        2) 如果拷贝成功，调用函数spidev_sync_write完成写数据。

        3) 解互斥锁。

        4) spidev_sync_write函数中，首先定义spi_transfer传输结构体，由于是写，此结构体只有tx_buf。

        5) 初始化spi_message，然后调用spidev_sync传输数据，此函数在上面的读操作中已经讲述。

        ioctl函数如下：

点击(此处)折叠或打开

  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;

  12.     /* Check type and command number */
  13.     if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
  14.         return -ENOTTY;

  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;

  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);

  37.     if (spi == NULL)
  38.         return -ESHUTDOWN;

  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);

  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;

  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;

  71.             if (tmp & ~SPI_MODE_MASK) {
  72.                 retval = -EINVAL;
  73.                 break;
  74.             }

  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;

  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;

  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;

  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;

  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.         }

  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;

  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.         }

  158.         /* translate to spi_message, execute */
  159.         retval = spidev_message(spidev, ioc, n_ioc);
  160.         kfree(ioc);
  161.         break;
  162.     }

  164.     mutex_unlock(&spidev->buf_lock);
  165.     spi_dev_put(spi);
  166.     return retval;
  167. }

        说明：

        1) 函数首先判断命令是否有效，如果无效，直接退出。

        2) 上互斥锁。

        3) switch分支中，前面的case都是支持对SPI设备的设置，包括模式、传输位、位方向和最大速率等。

        4) 在设置分支中，最后调用spi_setup实现设置，此函数最终是调用总线驱动中的gsc3280_spi_setup(struct spi_device *spi)

实现设置。

        5) default分支中是进行数据传输的分支，首先判断是否是有效的数据，如果不是，退出switch分支。

        6) 申请内存，复制从应用层传过来的数据。

        7) 调用spidev_message函数实现数据传输。

        8) 解互斥锁，退出。

        spidev_message函数如下：

点击(此处)折叠或打开

  1. static int spidev_message(struct spidev_data *spidev,
  2.         struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
  3. {
  4.     struct spi_message    msg;
  5.     struct spi_transfer    *k_xfers;
  6.     struct spi_transfer    *k_tmp;
  7.     struct spi_ioc_transfer *u_tmp;
  8.     unsigned        n, total;
  9.     u8            *buf;
  10.     int            status = -EFAULT;

  12.     spi_message_init(&msg);
  13.     k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
  14.     if (k_xfers == NULL)
  15.         return -ENOMEM;

  17.     /* Construct spi_message, copying any tx data to bounce buffer.
  18.      * We walk the array of user-provided transfers, using each one
  19.      * to initialize a kernel version of the same transfer.
  20.      */
  21.     buf = spidev->buffer;
  22.     total = 0;
  23.     for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
  24.             n;
  25.             n--, k_tmp++, u_tmp++) {
  26.         k_tmp->len = u_tmp->len;

  28.         total += k_tmp->len;
  29.         if (total > bufsiz) {
  30.             status = -EMSGSIZE;
  31.             goto done;
  32.         }

  34.         if (u_tmp->rx_buf) {
  35.             k_tmp->rx_buf = buf;
  36.             if (!access_ok(VERIFY_WRITE, (u8 __user *)
  37.                         (uintptr_t) u_tmp->rx_buf,
  38.                         u_tmp->len))
  39.                 goto done;
  40.         }
  41.         if (u_tmp->tx_buf) {
  42.             k_tmp->tx_buf = buf;
  43.             if (copy_from_user(buf, (const u8 __user *)
  44.                         (uintptr_t) u_tmp->tx_buf,
  45.                     u_tmp->len))
  46.                 goto done;
  47.         }
  48.         buf += k_tmp->len;

  50.         k_tmp->cs_change = !!u_tmp->cs_change;
  51.         k_tmp->bits_per_word = u_tmp->bits_per_word;
  52.         k_tmp->delay_usecs = u_tmp->delay_usecs;
  53.         k_tmp->speed_hz = u_tmp->speed_hz;
  54. #ifdef VERBOSE
  55.         dev_dbg(&spidev->spi->dev,
  56.             " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
  57.             u_tmp->len,
  58.             u_tmp->rx_buf ? "rx " : "",
  59.             u_tmp->tx_buf ? "tx " : "",
  60.             u_tmp->cs_change ? "cs " : "",
  61.             u_tmp->bits_per_word ? : spidev->spi->bits_per_word,
  62.             u_tmp->delay_usecs,
  63.             u_tmp->speed_hz ? : spidev->spi->max_speed_hz);
  64. #endif
  65.         spi_message_add_tail(k_tmp, &msg);
  66.     }

  68.     status = spidev_sync(spidev, &msg);
  69.     if (status < 0)
  70.         goto done;

  72.     /* copy any rx data out of bounce buffer */
  73.     buf = spidev->buffer;
  74.     for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
  75.         if (u_tmp->rx_buf) {
  76.             if (__copy_to_user((u8 __user *)
  77.                     (uintptr_t) u_tmp->rx_buf, buf,
  78.                     u_tmp->len)) {
  79.                 status = -EFAULT;
  80.                 goto done;
  81.             }
  82.         }
  83.         buf += u_tmp->len;
  84.     }
  85.     status = total;

  87. done:
  88.     kfree(k_xfers);
  89.     return status;
  90. }

        说明：

        1) 申请传输的结构体内存。

        2) 通过for循环，对spi_ioc_transfer类型的数据进行转换。

        3) 转换中，首先对本次传输的数据大小进行累计，如果总传输量超出buf的大小，直接退出。

        4) 如果本次传输是接收，则设置接收数组，并对buf进行检查，查看是否可读。

        5) 如果本次传输是写，则从应用层拷贝数据。

        6) 对传输中参数进行赋值，包括速度、模式、速率等等。

        7) 调用spidev_sync进行数据传输。

        8) 将接收数据拷贝到应用层。

三、应用层

        在应用层提供了二中驱动的测试程序，在“/documenation/spi”目录下，文件名称为spidev_test.c中，具体程序如下：

点击(此处)折叠或打开

  1. int main(int argc, char *argv[])
  2. {
  3.     int ret = 0;
  4.     int fd;

  6.     parse_opts(argc, argv);

  8.     fd = open(device, O_RDWR);
  9.     if (fd < 0)
  10.         pabort("can't open device");

  12.     /*
  13.      * spi mode
  14.      */
  15.     ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
  16.     if (ret == -1)
  17.         pabort("can't set spi mode");

  19.     ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
  20.     if (ret == -1)
  21.         pabort("can't get spi mode");

  23.     /*
  24.      * bits per word
  25.      */
  26.     ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
  27.     if (ret == -1)
  28.         pabort("can't set bits per word");

  30.     ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
  31.     if (ret == -1)
  32.         pabort("can't get bits per word");

  34.     /*
  35.      * max speed hz
  36.      */
  37.     ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
  38.     if (ret == -1)
  39.         pabort("can't set max speed hz");

  41.     ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
  42.     if (ret == -1)
  43.         pabort("can't get max speed hz");

  45.     printf("spi mode: %d\n", mode);
  46.     printf("bits per word: %d\n", bits);
  47.     printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);

  49.     transfer(fd);

  51.     close(fd);

  53.     return ret;
  54. }

        说明：

        1) 首先打开设备。

        2) 然后设置工作模式、位大小和速率等。

        3) 传输数据


你可能感兴趣的:(Linux,SPI子系统)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • Linux sh命令 fengyehongWorld Linuxlinux
    目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
  • Linux vi常用命令 fengyehongWorld Linuxlinux
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • MongoDB知识概括 GeorgeLin98 持久层mongodb
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • Linux CTF逆向入门 蚁景网络安全 linux运维CTF
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
  • NPM私库搭建-verdaccio（Linux） Beam007 npmlinux前端
    1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件，解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改：/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT
  • python爬取微信小程序数据,python爬取小程序数据 2301_81900439 前端
    大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
  • APQP，ASPICE，敏捷，功能安全，预期安全，这些汽车行业的一堆标准 二大宝贝 安全架构
    前言APQP,ASPICE,敏捷，功能安全，预期安全，PMP，PRICE2汽车行业的有这样一堆标准。我是半路出家来到汽车行业做项目经理的，对几个标准的感觉是，看了文档和各种解析之后还是一头雾水，不知道到底说了个啥，别人问我还是一脸懵逼。APQP（TS16949的最重要工具），ASPICE（软件）这些是质量标准，是优化整个公司体系的，但这套体系对项目管理有要求；敏捷，PMP这些是项目管理的标准；项目
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • linux脚本sed替换变量,sed 命令中替换值为shell变量 诺坎普之约 linux脚本sed替换变量
    文章目录sed命令中替换值为shell变量替换基本语法sed中替换使用shell变量总结参考文档sed命令中替换值为shell变量替换基本语法大家都是sed有很多用法，最多就应该是替换一些值了。让我们先回忆sed的替换语法。在sed进行替换的时候sed-i's/old/new/g'1.txtecho"hellooldfrank"|sed's/old/new/g'结果如下：hellonewfrank
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • linux 安装Sublime Text 3 hhyiyuanyu Python学习linuxsublimetext
    方法/步骤打开官网http://www.sublimetext.com/3，选择64位进行下载执行命令wgethttps://download.sublimetext.com/sublime_text_3_build_3126_x64.tar.bz2进行下载3、下载完成进行解压,执行tar-xvvfsublime_text_3_build_3126_x64.tar.bz解压4、解压完成以后，移动到
  • 探索ASPICE V3.1：汽车行业软件开发的中文指南 阮懿同
    探索ASPICEV3.1：汽车行业软件开发的中文指南ASPICE_V3.1中文版.pdf.zip项目地址:https://gitcode.com/open-source-toolkit/422a2在汽车软件工程领域，高质量的标准对于确保行车安全和提升用户体验至关重要。今天，我们为您介绍一个珍贵的开源宝藏——ASPICEV3.1中文版资源。这是一篇专为国内汽车行业开发者、质量管理者准备的深度解读，旨
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • 史上最全git命令,git回滚,git命令大全 騒周 其他git
    git命令大全一、Git整体理解二、由暂存区本地仓库三、由本地仓->远程仓库四、冲突处理五、Git分支操作六、bug的分支七、feature分支八、暂存的使用九、远程仓的操作十、标签的使用十一、Git配置全局信息十二、Linux的一些简单操作和一些符号的解释十三、符号解释十四、显示安装详细信息十五、gitconfig十六、Gitclone十七、Gitinit十八、gitstatus十九、gitre
  • 【显示 后台运行 & 的命令】 晨春计 debuglinux服务器运维
    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
  • jquery实现的jsonp掉java后台 知了ing javajsonpjquery
    什么是JSONP？ 先说说JSONP是怎么产生的： 其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 2、
  • Struts2学习笔记 caoyong struts2
    SSH : Spring + Struts2 + Hibernate 三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 分层原则:单向依赖，接口耦合 1、Struts2  =  Struts  + Webwork 2、搭建struts2开发环境    a>、到www.apac
  • SpringMVC学习之后台往前台传值方法 满城风雨近重阳 springMVC
    springMVC控制器往前台传值的方法有以下几种： 1.ModelAndView    通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参：      ModelAndView mv=new ModelAndView();  mv.setViewName="success
  • WebService存在的必要性？ 一炮送你回车库 webservice
    做Java的经常在选择Webservice框架上徘徊很久，Axis  Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。 是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。 当在不同的平台间传输数据时，就需要一个都能解析的数据格式。 但是为什么要使用xml呢？不能使json或者其他通用数据
  • js年份下拉框 3213213333332132 java web ee
    <div id="divValue">test...</div>测试 //年份 <select id="year"></select> <script type="text/javascript"> window.onload =
  • 简单链式调用的实现技术 归来朝歌 方法调用链式反应编程思想
    在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用 这样的调用你可能在Ajax中，在页面中添加标签： $("<p>").append($("<span>").text(list[i].name)).appendTo("#result");   也可能在HQ
  • JAVA调用.net 发布的webservice 接口 darkranger webservice
    /** * @Title: callInvoke * @Description: TODO(调用接口公共方法) * @param @param url 地址 * @param @param method 方法 * @param @param pama 参数 * @param @return * @param @throws BusinessException
  • Javascript模糊查找 | 第一章 循环不能不重视。 aijuans Way
    最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： function search(){ var arr=new Array("my
  • 狼和羊，该怎么抉择 atongyeye 工作
    狼和羊，该怎么抉择 在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。 今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
  • 读取android系统的联系人拨号 百合不是茶 androidsqlite数据库内容提供者系统服务的使用
           联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢   关键代码:     1, 使用javabean操作存储读取到的数据 package com.example.bean; /** * * @author Admini
  • ORACLE自定义异常 bijian1013 数据库自定义异常
    实例： CREATE OR REPLACE PROCEDURE test_Exception ( ParameterA IN varchar2, ParameterB IN varchar2, ErrorCode OUT varchar2 --返回值,错误编码 ) AS /*以下是一些变量的定义*/ V1 NUMBER; V2 nvarc
  • 查看端号使用情况 征客丶 windows
    一、查看端口 在windows命令行窗口下执行： >netstat -aon|findstr "8080" 显示结果： TCP     127.0.0.1:80         0.0.0.0:0    &
  • 【Spark二十】运行Spark Streaming的NetworkWordCount实例 bit1129 wordcount
    Spark Streaming简介   NetworkWordCount代码   /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with
  • Struts2 与 SpringMVC的比较 BlueSkator struts2spring mvc
    1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
  • Hibernate在更新时，是可以不用session的update方法的(转帖） BreakingBad Hibernateupdate
    地址：http://blog.csdn.net/plpblue/article/details/9304459 public void synDevNameWithItil() {Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
  • 读《研磨设计模式》-代码笔记-观察者模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; import java.util.Observable; import java.util.Observer; /** * “观
  • 重置MySQL密码 chenhbc mysql重置密码忘记密码
    如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 1、关闭MySQL服务 2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL mysqld --skip-grant-tables  3、新开一个CMD窗口，进入MySQL mysql -uroot  
  • 再谈系统论，控制论和信息论 comsci 设计模式生物能源企业应用领域模型
                               再谈系统论，控制论和信息论     偶然看
  • oracle moving window size与 AWR retention period关系 daizj oracle
    转自： http://tomszrp.itpub.net/post/11835/494147 晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. SQL> select * from v$version; BANNER -------------------
  • Python版B树 dieslrae python
    话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 首先是数据实体对象,很简单,只存放key,value class Entity(object): '''数据实体''' def __init__(self,key,value)
  • C语言冒泡排序 dcj3sjt126com 算法
    代码示例： # include <stdio.h> //冒泡排序 void sort(int * a, int len) { int i, j, t; for (i=0; i<len-1; i++) { for (j=0; j<len-1-i; j++) { if (a[j] > a[j+1]) // >表示升序
  • 自定义导航栏样式 dcj3sjt126com 自定义
    -(void)setupAppAppearance { [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]]; [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
  • 11.性能优化-优化-JVM参数总结 frank1234 jvm参数性能优化
    1.堆 -Xms --初始堆大小 -Xmx --最大堆大小 -Xmn --新生代大小 -Xss --线程栈大小 -XX:PermSize  --永久代初始大小 -XX:MaxPermSize  --永久代最大值 -XX:SurvivorRatio --新生代和suvivor比例,默认为8 -XX:TargetSurvivorRatio --survivor可使用
  • nginx日志分割 for linux HarborChung nginxlinux脚本
    nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本   使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限   复制代码代码如下: chmo
  • Spring4新特性——泛型限定式依赖注入 jinnianshilongnian springspring4泛型式依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • centOS安装GCC和G++ liuxihope centosgcc
    Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。 按照这个思路，我想安装过程如下： 安装gcc：yum install gcc 安装g++： yum install g++ 实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
  • 第13章 Ajax进阶（上） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • How to determine BusinessObjects service pack and fix pack blueoxygen BO
    http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/   The table below is helpful. Reference   BOE XI 3.x 12.0.0. y BOE XI 3.0 12.0. x. y BO
  • Oracle里的自增字段设置 tomcat_oracle oracle
    　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列 create table t ( id 　　 　　 number generated by default as identity (start with 1 increment b
  • Spring Security（01）——初体验 yang_winnie springSecurity
    Spring Security（01）——初体验     博客分类： spring Security Spring Security入门安全认证        首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他