久久国产成人av_抖音国产毛片_a片网站免费观看_A片无码播放手机在线观看,色五月在线观看,亚洲精品m在线观看,女人自慰的免费网址,悠悠在线观看精品视频,一级日本片免费的,亚洲精品久,国产精品成人久久久久久久

搜索
分享

Linux spi驅(qū)動分析(四)

 dwlinux_gs 2014-08-14

一,、W25Q32BV芯片簡介

        W25X是一系列SPI接口Flash芯片的簡稱,，它采用SPI接口和CPU通信，本文使用的W25Q32BV容量為32M,，具體特性如下：

1.1,、基本特性

        該芯片最大支持104MHz的時鐘,，供電電壓范圍在2.7~3.6V，SPI的片選信號CS低有效,，在操作芯片的時候,，

需要將/WP和/HOLD管腳接電源。

        發(fā)送地址或數(shù)據(jù)到設(shè)備時,，MOSI管腳數(shù)據(jù)采樣在CLK的上升沿,，從芯片讀數(shù)據(jù)或者狀態(tài)時，MISO管腳數(shù)據(jù)采樣在CLK

的下降沿,，所以在設(shè)置SPI的工作模式時,，必須設(shè)置為MODE0或者M(jìn)ODE3，本文設(shè)置為MODE3,。

1.2,、存儲空間簡介

        W25Q32BV總共有16384頁(page)，每頁有256bytes,，每次最大可以編程一頁,。在擦除上，可以一次擦除

4KB,、32KB,、64KB，或者擦除整個芯片,。整個芯片的存儲空間如下圖：


        W25Q32BV存儲空間分為sector和block。一個sector共有4KB,，一個block共有32KB,。一個sector存儲空間如下圖：

    

        本文共支持四種擦除方式，分別如下：

        1) cmd = 0x20,，sector擦除,，一次可以擦除4KB,。芯片共有1024個sector,。

        2) cmd = 0x52,，半個block擦除,，一次可以擦除32KB,。芯片共有128個半block,。

        3) cmd = 0xd8，block擦除,，一次可以擦除64KB,。芯片共有64個block。

        4) cmd = 0xC7,，芯片擦除,，擦除整個芯片。

1.3,、狀態(tài)寄存器

        W25Q32BV共有兩個字節(jié)的狀態(tài)寄存器,，我們需要關(guān)心的就是BIT0和BIT1。

        BIT0：busy flag,，1：busy,，0：free。

        BIT1：write enable latch,，1：write enable,，0：write disable。

1.4,、操作要求

        在操作W25Q32BV時,，如果是寫數(shù)據(jù)到芯片，則每寫一個字節(jié),，都需要讀取一個數(shù)據(jù),。

        在從芯片接收數(shù)據(jù)時，首先往芯片寫一個字節(jié)的0xff,，然后就是需要讀取的數(shù)據(jù),。

二、設(shè)備驅(qū)動

2.1,、設(shè)備注冊

        在系統(tǒng)啟動的時候,，首先會對設(shè)備信息進(jìn)行注冊，見《Linux spi驅(qū)動分析(一)----總線驅(qū)動》中的3.1,，所以編寫w25q的設(shè)備
驅(qū)動程序時,，首先需要對設(shè)備信息進(jìn)行注冊，具體內(nèi)容如下：

點(diǎn)擊(此處)折疊或打開

  1. #if defined(CONFIG_SPI_FLASH_W25Q)
  2.  static struct gsc3280_spi_info w25q_spi1_dev_platdata = {
  3.      .cs_type            = 1,
  4.     .pin_cs            = 87,
  5.     .num_cs            = 1,
  6.     .cs_value            = 0,
  7.     .lsb_flg            = 0,
  8.     .bits_per_word    = 8,
  9. };
  10. #endif
  11. static struct spi_board_info gsc3280_spi_devices[] = {
  12. #if defined(CONFIG_SPI_FLASH_W25Q)
  13.     {
  14.         .modalias        = "spi-w25q",
  15.         .bus_num        = 1,
  16.         .chip_select        = 2,
  17.         .mode            = SPI_MODE_3,
  18.         .max_speed_hz    = 5 * 1000 * 1000,
  19.         .controller_data    = &w25q_spi1_dev_platdata,
  20.     },
  21. #endif

  23. };
  24. static int __init gsc3280_spi_devices_init(void)
  25. {
  26.     spi_register_board_info(gsc3280_spi_devices, ARRAY_SIZE(gsc3280_spi_devices));
  27.     return 0;
  28. }
  29. device_initcall(gsc3280_spi_devices_init);

2.2,、初始化函數(shù)

        首先我們從設(shè)備注冊開始,，程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static struct spi_driver w25q_driver = {
  2.     .driver    = {
  3.         .name    = "spi-w25q",
  4.         .owner    = THIS_MODULE,
  5.     },
  6.     //.id_table    = w25q_ids,
  7.     .probe    = w25q_probe,
  8.     .remove    = __devexit_p(w25q_remove),
  9. };


  12. static int __init w25q_init(void)
  13. {
  14.     return spi_register_driver(&w25q_driver);
  15. }
  16. static void __exit w25q_exit(void)
  17. {
  18.     spi_unregister_driver(&w25q_driver);
  19. }
  20. module_init(w25q_init);
  21. module_exit(w25q_exit);

        由于W25Q32BV使用SPI接口，所以將其注冊為SPI驅(qū)動,，接下來看下探測函數(shù)w25q_probe,，程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static int __devinit w25q_probe(struct spi_device *spi)
  2. {
  3.     int ret = 0;
  4.     struct w25q_dev *w25q;

  6.     DBG("############\n");
  7.     DBG("w25q spi flash probe start.\n");
  8.     w25q = kzalloc(sizeof(struct w25q_dev), GFP_KERNEL);
  9.     if (!w25q) {
  10.         DBG("!!!!kzalloc error!\n");
  11.         return -ENOMEM;
  12.     }
  13.     ret = spi_setup(spi);
  14.     if (ret != 0) {
  15.         DBG("!!!!setup error!\n");
  16.         return ret;
  17.     }
  18.     w25q->spi = spi;
  19.     mutex_init(&w25q->mlock);
  20.     strlcpy(w25q->name, W25Q_SPI_FLASH_NAME, sizeof(w25q->name));
  21.     ret = alloc_chrdev_region(&w25q->devt, 0, W25Q_MAX_MINOR, "w25q");
  22.     if (ret < 0) {
  23.         DBG("!!!!%s: failed to allocate char dev region!\n", __FILE__);
  24.         goto err_kzall;
  25.     }
  26.     w25q->dev.devt = MKDEV(MAJOR(w25q->devt), 1);
  27.     cdev_init(&w25q->cdev, &w25q_fops);
  28.     w25q->cdev.owner = THIS_MODULE;
  29.     ret = cdev_add(&w25q->cdev, w25q->devt, 1);
  30.     if (ret) {
  31.         DBG("!!!!cdev add error!\n");
  32.         goto err_alloc;
  33.     }
  34.     w25q->class = class_create(THIS_MODULE, "w25q-spi");
  35.     if (IS_ERR(w25q->class)) {
  36.         DBG("!!!!failed in create w25q spi flash class!\n");
  37.         goto err_alloc;;
  38.     }
  39.     device_create(w25q->class, NULL, w25q->devt, NULL, "w25q");
  40.     dev_set_drvdata(&spi->dev, w25q);
  41.     DBG("w25q spi flash probe success.\n");
  42.     DBG("############\n");
  43.     return 0;

  45. err_alloc:
  46.     unregister_chrdev_region(w25q->devt, W25Q_MAX_MINOR);
  47. err_kzall:
  48.     kfree(w25q);
  49.     printk(KERN_ERR "!!!!!!w25q spi flash probe error.!!!!!!\n");
  50.     return ret;
  51. }

        說明：
        1) 首先申請?jiān)O(shè)備驅(qū)動結(jié)構(gòu)體。
        2) 調(diào)用spi_setup(spi)函數(shù)對設(shè)備信息初始化,。
        3) 初始化設(shè)備驅(qū)動結(jié)構(gòu)體成員變量,。
        4) 創(chuàng)建/dev目錄下操作文件,，操作函數(shù)集為w25q_fops。
        5) 將設(shè)備驅(qū)動結(jié)構(gòu)體中的鏈表插入本文件全局鏈表w25q_device_list中,，以便在函數(shù)操作集的open函數(shù)中找到設(shè)備驅(qū)動結(jié)構(gòu)體,。
        remove函數(shù)是探測函數(shù)的相反過程，具體程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static int __devexit w25q_remove(struct spi_device *spi)
  2. {
  3.     struct w25q_dev *w25q = dev_get_drvdata(&spi->dev);

  5.     cdev_del(&w25q->cdev);
  6.     unregister_chrdev_region(w25q->devt, W25Q_MAX_MINOR);
  7.     device_destroy(w25q->class, w25q->devt);
  8.     class_destroy(w25q->class);
  9.     kfree(w25q);
  10.     return 0;
  11. }

2.3,、操作函數(shù)集w25q_fops

        操作函數(shù)集結(jié)構(gòu)體具體內(nèi)容如下：

點(diǎn)擊(此處)折疊或打開

  1. static const struct file_operations w25q_fops = {
  2.     .owner = THIS_MODULE,
  3.     .open = w25q_open,
  4.     .write = w25q_write,
  5.     .unlocked_ioctl = w25q_ioctl,
  6.     .read = w25q_read,
  7.     .llseek = w25q_llseek,
  8.     .release = w25q_release,
  9. };

        接下來我們一一講述,。
        首先看下open函數(shù)w25q_open，具體程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static int w25q_open(struct inode *inode, struct file *file)
  2. {
  3.     struct w25q_dev *w25q = container_of(inode->i_cdev, struct w25q_dev, char_cdev);

  5.     if (test_and_set_bit(W25Q_BIT_LOCK_OPEN, &w25q->bit_lock)) {
  6.         DBG("!!!!w25q open err, busy!\n");
  7.         return -EBUSY;
  8.     }
  9.     file->private_data = w25q;
  10.     return 0;
  11. }

        說明：
        1) 通過container_of找到在探測函數(shù)w25q_probe中定義的設(shè)備驅(qū)動結(jié)構(gòu)體,。
        2) 測試并且設(shè)置忙標(biāo)志,，如果測試忙，直接忙退出,。
        3) 將找到的設(shè)備驅(qū)動結(jié)構(gòu)體指針指向file->private_data,，在函數(shù)操作集的其他函數(shù)中就可以使用設(shè)備驅(qū)動結(jié)構(gòu)體了。
        接下來看下寫函數(shù)w25q_write(),，程序如下：

點(diǎn)擊(此處)折疊或打開

  1. #define W25Q_BUF_LEN                4096
  2. #define W25Q_PAGE_NUM                256
  3. static ssize_t w25q_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos)
  4. {
  5.     int ret = 0;
  6.     u8 *buf_start, *buf_tmp, *w25q_buf;
  7.     struct w25q_dev *w25q= file->private_data;
  8.     u32 buf_size = 0, page_num = W25Q_PAGE_NUM, len = 0;
  9.     
  10.     DBG("@@@@w25q write start\n");
  11.     buf_start = buf_tmp = kzalloc(W25Q_BUF_LEN, GFP_KERNEL);
  12.     w25q_buf = w25q->buf = kzalloc(page_num + 4, GFP_KERNEL);
  13.     if (!buf_start || !w25q_buf) {
  14.         DBG("!!!!kzalloc error!\n");
  15.         return -ENOMEM;
  16.     }
  17.     ret = mutex_lock_interruptible(&w25q->mlock);
  18.     if (ret) {
  19.         DBG("!!!!mutex lock error!");
  20.         goto exit_kfree;
  21.     }
  22.     len = W25Q_BUF_LEN;
  23.     buf_size = min(count, len);
  24.     if (copy_from_user(buf_tmp, user_buf, buf_size)) {
  25.         DBG("!!!!copy_from_user() error!\n");
  26.         ret = -EFAULT;
  27.         goto exit_lock;
  28.     }
  29.     DBG("w25q->const_addr = 0x%x\n", w25q->const_addr);
  30.     buf_tmp = buf_start;
  31.     w25q->cmd = W25X_PAGE_PROG;
  32.     w25q->addr = w25q->const_addr;
  33.     while(buf_size) {
  34.         w25q->buf = w25q_buf;
  35.         w25q->len = min(buf_size, page_num);
  36.         memcpy(w25q->buf + 4, buf_tmp, w25q->len);
  37.         ret = w25q_write_date(w25q);
  38.         if (ret != 0) {
  39.             break;
  40.         }
  41.         buf_tmp += w25q->len;
  42.         w25q->addr += w25q->len;
  43.         buf_size -= w25q->len;
  44.     }

  46. exit_lock:
  47.     mutex_unlock(&w25q->mlock);
  48. exit_kfree:
  49.     kfree(buf_start);
  50.     kfree(w25q_buf);
  51.     if (ret != 0)
  52.         DBG("!!!!w25q write error!\n");
  53.     else
  54.         DBG("w25q write success\n");
  55.     return ret;
  56. }

        說明：
        1) 寫函數(shù)首先申請兩段內(nèi)存,，第一段內(nèi)存用于存儲從應(yīng)用層復(fù)制來的待寫數(shù)據(jù)，最大為4KB,。第二段內(nèi)存用于存儲每次
            往W25Q32BV寫的數(shù)據(jù),。由于W25Q32BV每次最大能寫256bytes，所以page_num = 256,，加上4是由于每次
            傳輸時,，需要在最前面加上一個字節(jié)的命令和三個字節(jié)的地址。
        2) 獲取本次可以傳輸?shù)淖畲髷?shù)據(jù)長度,。
        3) 設(shè)置好傳輸?shù)腸md和起始地址，然后進(jìn)入while循環(huán),。
        4) 在while循環(huán)中，獲取本次可以傳輸?shù)淖畲箝L度,，最長為256bytes,，然后將其拷貝到buf中，加上4的目的是因?yàn)閎uf
            的前四個字節(jié)需要放置命令和地址,。
        5) 調(diào)用w25q_write_date(w25q)函數(shù)實(shí)現(xiàn)數(shù)據(jù)傳輸。
        6) 更新變量,，為下一次傳輸做好準(zhǔn)備,。
        w25q_write_date(w25q)函數(shù)具體內(nèi)容如下：

點(diǎn)擊(此處)折疊或打開

  1. static void w25q_write_enable(struct w25q_dev *w25q)
  2. {
  3.     u8 cmd = W25X_WRITE_ENABLE;

  5.     spi_w8r8(w25q->spi, cmd);
  6. }
  7. static int w25q_wait_null(struct w25q_dev *w25q)
  8. {
  9.     uint8_t limit = 5;

  11.     /* wait BUSY bit clear */
  12.     while(((w25q_read_stat_reg(w25q) & 0x01) == 0x01) && (limit != 0)) {
  13.         limit--;
  14.         mdelay(50);
  15.     }
  16.     if (limit == 0) {
  17.         DBG("!!!!w25q_wait_null:time out!\n");
  18.         return -EBUSY;
  19.     }
  20.     else
  21.         return 0;
  22. }
  23. /*
  24.  * when you call this function,
  25.  * the w25q->cmd, w25q->len(tx date len),
  26.  * w25q->addr and w25q->buf(date) are OK
  27.  *
  28.  */
  29. static int w25q_write_date(struct w25q_dev *w25q)
  30. {
  31.     int ret = 0;
  32.     u8 i = 0, rx = 0;
  33.     struct spi_message message;
  34.     struct spi_transfer    x[(w25q->len + 4) * 2];

  36.     w25q_write_enable(w25q);    //SET WEL
  37.     ret = w25q_wait_null(w25q);
  38.     if (ret != 0) {
  39.         DBG("!!!!w25q_write_date: wait null err!\n");
  40.         return ret;
  41.     }
  42.     if((w25q_read_stat_reg(w25q) & 0x02) != 0x02) {
  43.         DBG("!!!!state register write able is 0\n");
  44.         return -EBUSY;    //disable write
  45.     }

  47.     DBG("cmd = 0x%x, addr = 0x%x\n", w25q->cmd, w25q->addr);
  48.     w25q->buf[0] = w25q->cmd;
  49.     w25q->buf[1] = ((u8)(w25q->addr >> 16));
  50.     w25q->buf[2] = ((u8)(w25q->addr >> 8));
  51.     w25q->buf[3] = ((u8)w25q->addr);
  52.     
  53.     spi_message_init(&message);
  54.     memset(x, 0, sizeof x);
  55.     for (i = 0; i < (w25q->len + 4) * 2; i++) {
  56.         x[i].len = 1;
  57.         spi_message_add_tail(&x[i], &message);
  58.         if ((i % 2) == 0) {
  59.             x[i].tx_buf = w25q->buf++;
  60.         } else {
  61.             x[i].rx_buf = &rx;
  62.         }
  63.     }
  64.     /* do the i/o */
  65.     ret = spi_sync(w25q->spi, &message);
  66.     if (ret != 0) {
  67.         DBG("!!!!w25q_write_date: spi_sync() error!");
  68.         return ret;
  69.     }
  70.     ret = w25q_wait_null(w25q);
  71.     if (ret != 0)
  72.         DBG("!!!!w25q_write_date: w25q_wait_null() error!");
  73.     return ret;
  74. }

        說明：
        1) 在調(diào)用w25q_write_date(w25q)函數(shù)之前,，需要首先設(shè)置好w25q->cmd, w25q->len(tx date len),，
            w25q->addr和w25q->buf(date)變量,。
        2) 設(shè)置芯片狀態(tài)寄存器，使其可寫,。
        3) 等待芯片不忙,。
        4) 讀取芯片狀態(tài)寄存器，查看其是否可寫,。
        5) 配置發(fā)送buf,，調(diào)用spi_sync(w25q->spi, &message);函數(shù)實(shí)現(xiàn)寫數(shù)據(jù),。
        6) 等待芯片不忙,，退出。
        接下來看下函數(shù)操作集中的ioctl函數(shù)，程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static long w25q_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  2. {
  3.     int ret = 0;
  4.     u32 get_value = 0;
  5.     struct w25q_dev *w25q= file->private_data;
  6.     void __user *argp = (void __user *)arg;
  7.     int __user *p = argp;

  9.     DBG("@@@@w25q ioctl start.\n");
  10.     ret = mutex_lock_interruptible(&w25q->mlock);
  11.     if (ret) {
  12.         DBG("!!!!mutex lock error!\n");
  13.         return ret;
  14.     }
  15.     if ((_IOC_TYPE(cmd) != W25Q_IOC_MAGIC) || (_IOC_NR(cmd) > W25Q_IOC_MAXNR)) {
  16.         DBG("!!!!ioc type or ioc nr error!\n");
  17.         ret = -ENOTTY;
  18.         goto exit;
  19.     }
  20.     switch(cmd) {
  21.     case W25Q_SECTOR_ERASE:
  22.     case W25Q_HALF_BLOCK_ERASE:
  23.     case W25Q_BLOCK_ERASE:
  24.         if (get_user(get_value, p)) {
  25.             DBG("!!!!get value error!\n");
  26.             ret = -EFAULT;
  27.             goto exit;
  28.         }
  29.         ret = w25q_erase(w25q, get_value, cmd);
  30.         break;
  31.     case W25Q_CHIP_ERASE:
  32.         ret = w25q_chip_erase(w25q);
  33.         break;
  34.     case W25Q_READ_DEVICE_ID:
  35.         ret = w25q_read_id(w25q);
  36.         if (ret == 0)
  37.             put_user(w25q->result, p);
  38.         break;
  39.     default:
  40.         DBG("!!!!cmd error!\n");
  41.         ret = -ENOTTY;
  42.         break;
  43.     }

  45. exit:
  46.     mutex_unlock(&w25q->mlock);
  47.     if (ret != 0)
  48.         DBG("!!!!w25q ioctl error!\n");
  49.     else
  50.         DBG("w25q ioctl success.\n");
  51.     return ret;
  52. }

        說明：
        1) 目前共支持5個命令，包括sector擦除,，half block擦除,，block擦除,，芯片擦除和讀取芯片ID。
        2) 前三種擦除方式共用一個函數(shù)w25q_erase(w25q, get_value, cmd);，程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static int w25q_erase(struct w25q_dev *w25q, u32 num, unsigned int cmd)
  2. {
  3.     int ret = 0;
  4.     u8 *buf_start;

  6.     switch(cmd) {
  7.     case W25Q_SECTOR_ERASE:
  8.         DBG("sector erase cmd\n");
  9.         if (num > W25Q_SECTOR_MAX) {
  10.             DBG("!!!!sector max is over\n");
  11.             return -EFAULT;
  12.         }
  13.         w25q->const_addr = num * W25Q_ONE_SECTOR_ADDR;
  14.         w25q->cmd = W25X_SECTOR_ERASE_CMD;
  15.         break;
  16.     case W25Q_HALF_BLOCK_ERASE:
  17.         DBG("half block erase cmd\n");
  18.         if (num > W25Q_HALF_BLOCK_MAX) {
  19.             DBG("!!!!half block max is over\n");
  20.             return -EFAULT;
  21.         }
  22.         w25q->const_addr = num * W25Q_HALF_BLOCK_ADDR;
  23.         w25q->cmd = W25X_HALF_BLOCK_ERASE_CMD;
  24.         break;
  25.     case W25Q_BLOCK_ERASE:
  26.         DBG("block erase cmd\n");
  27.         if (num > W25Q_BLOCK_MAX) {
  28.             DBG("!!!!block max is over\n");
  29.             return -EFAULT;
  30.         }
  31.         w25q->const_addr = num * W25Q_ONE_BLOCK_ADDR;
  32.         w25q->cmd = W25X_BLOCK_ERASE_CMD;
  33.         break;
  34.     }
  35.     DBG("w25q->const_addr = 0x%x\n", w25q->const_addr);
  36.     w25q->len = 0;
  37.     buf_start = w25q->buf = kzalloc(w25q->len + 4, GFP_KERNEL);
  38.     if (!buf_start) {
  39.         DBG("!!!!kzalloc is error\n");
  40.         return -ENOMEM;
  41.     }
  42.     w25q->addr = w25q->const_addr;
  43.     ret = w25q_write_date(w25q);
  44.     kfree(buf_start);
  45.     if (ret != 0) {
  46.         DBG("!!!!w25q_erase: spi write err!\n");
  47.         return ret;
  48.     }
  49.     DBG("w25q_erase: erase OK\n");
  50.     return ret;
  51. }

        說明：
        1) 首先根據(jù)不同的擦除方式，設(shè)置命令和地址兩個變量,。
        2) 調(diào)用w25q_write_date(w25q);函數(shù)實(shí)現(xiàn)數(shù)據(jù)傳輸。
        芯片擦除函數(shù)w25q_chip_erase()如下：

點(diǎn)擊(此處)折疊或打開

  1. static int w25q_chip_erase(struct w25q_dev *w25q)
  2. {
  3.     int ret = 0;
  4.     u8 cmd = W25X_CHIP_ERASE;

  6.     DBG("w25q_chip_erase\n");
  7.     w25q_write_enable(w25q);    //SET WEL
  8.     ret = w25q_wait_null(w25q);
  9.     if (ret != 0) {
  10.         DBG("!!!!chip_erase: wait null err!\n");
  11.         return ret;
  12.     }
  13.     if((w25q_read_stat_reg(w25q) & 0x02) != 0x02) {
  14.         DBG("!!!!state register write able is 0\n");
  15.         return -EBUSY;    //disable write
  16.     }
  17.     spi_w8r8(w25q->spi, cmd);
  18.     return w25q_wait_null(w25q);
  19. }

        讀取設(shè)備ID函數(shù)w25q_read_id()如下：

點(diǎn)擊(此處)折疊或打開

  1. static int w25q_read_id(struct w25q_dev *w25q)
  2. {
  3.     int ret = 0;
  4.     u8 *buf_start;

  6.     DBG("w25q_read_id\n");
  7.     w25q->len = 2;
  8.     w25q->addr = 0;
  9.     w25q->cmd = W25X_READ_ID_CMD;
  10.     buf_start = w25q->buf = kzalloc(w25q->len, GFP_KERNEL);
  11.     if (!buf_start) {
  12.         DBG("!!!!kzalloc is error\n");
  13.         return -ENOMEM;
  14.     }
  15.     ret = w25q_read_data(w25q);
  16.     w25q->buf = buf_start;
  17.     w25q->result = *w25q->buf << 8;
  18.     w25q->buf++;
  19.     w25q->result |= *w25q->buf;
  20.     kfree(buf_start);
  21.     if (ret != 0) {
  22.         DBG("!!!!w25q_read_id: w25q_read_data error!\n");
  23.         return ret;
  24.     }
  25.     DBG("w25q_read_id: read id OK\n");
  26.     return ret;
  27. }

        說明：
        1) 首先設(shè)置好變量，申請內(nèi)存
        2) 調(diào)用w25q_read_data()函數(shù)實(shí)現(xiàn)讀取數(shù)據(jù),。
        w25q_read_data函數(shù)如下：

點(diǎn)擊(此處)折疊或打開

  1. /*
  2.  * when you call this function,
  3.  * the w25q->cmd, w25q->len(receive len)
  4.  * w25q->buf(kzalloc receive) and w25q->addr are OK
  5.  *
  6.  */
  7. static int w25q_read_data(struct w25q_dev *w25q)
  8. {
  9.     int ret = 0;
  10.     struct spi_message message;
  11.     struct spi_transfer    x[(w25q->len + 4) * 2];
  12.     u8 i = 0, rx = 0, dumy_value = 0xff, tx_buff[4] = {0};

  14.     w25q_write_enable(w25q);    //SET WEL
  15.     ret = w25q_wait_null(w25q);
  16.     if (ret != 0) {
  17.         DBG("!!!!chip_erase: wait null err!\n");
  18.         return ret;
  19.     }
  20.     if((w25q_read_stat_reg(w25q) & 0x02) != 0x02) {
  21.         DBG("!!!!state register write able is 0\n");
  22.         return -EBUSY;    //disable write
  23.     }

  25.     DBG("cmd = 0x%x, addr = 0x%x\n", w25q->cmd, w25q->addr);
  26.     tx_buff[0] = w25q->cmd;
  27.     tx_buff[1] = ((uint8_t)(w25q->addr >> 16));
  28.     tx_buff[2] = ((uint8_t)(w25q->addr >> 8));
  29.     tx_buff[3] = ((uint8_t)(w25q->addr));
  30.     
  31.     spi_message_init(&message);
  32.     memset(x, 0, sizeof x);
  33.     for (i = 0; i < 8; i++) {    //cmd
  34.         x[i].len = 1;
  35.         spi_message_add_tail(&x[i], &message);
  36.         if ((i % 2) == 0) {
  37.             x[i].tx_buf = &tx_buff[i / 2];
  38.         } else {
  39.             x[i].rx_buf = &rx;
  40.         }
  41.     }
  42.     for (i = 8; i < (w25q->len + 4) * 2; i++) {
  43.         x[i].len = 1;
  44.         spi_message_add_tail(&x[i], &message);
  45.         if ((i % 2) == 0) {
  46.             x[i].tx_buf = &dumy_value;
  47.         } else {
  48.             x[i].rx_buf = w25q->buf++;
  49.         }
  50.     }
  51.     /* do the i/o */
  52.     return spi_sync(w25q->spi, &message);
  53. }

        說明：
        1) 在從芯片讀取數(shù)據(jù)時的格式為：首先發(fā)送一個字節(jié)命令+三個字節(jié)讀取地址,，然后就可以接收數(shù)據(jù)了。
        2) 第一個for循環(huán)發(fā)送的是命令和地址,，第二個for循環(huán)是接收數(shù)據(jù),。
        3) 調(diào)用此函數(shù)之前，需要設(shè)置好w25q->cmd, w25q->len(receive len),，w25q->buf(kzalloc receive)和w25q->addr,。
        接下來看下函數(shù)操作集中的讀數(shù)據(jù)函數(shù)w25q_read()，程序如下：

點(diǎn)擊(此處)折疊或打開

  1. static ssize_t w25q_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos)
  2. {
  3.     int ret = 0;
  4.     u8 *buf_start, *buf_tmp, *w25q_buf;
  5.     struct w25q_dev *w25q = file->private_data;
  6.     u32 buf_size = 0, read_len = 0, page_num = W25Q_PAGE_NUM;

  8.     DBG("@@@@w25q read start\n");
  9.     buf_start = buf_tmp = kzalloc(W25Q_BUF_LEN, GFP_KERNEL);
  10.     w25q_buf = w25q->buf = kzalloc(page_num, GFP_KERNEL);
  11.     if (!buf_start || !w25q_buf ) {
  12.         DBG("!!!!kzalloc error!\n");
  13.         return -ENOMEM;
  14.     }
  15.     ret = mutex_lock_interruptible(&w25q->mlock);
  16.     if (ret) {
  17.         DBG("!!!!mutex lock error!\n");
  18.         goto exit_kfree;
  19.     }
  20.     read_len = W25Q_BUF_LEN;
  21.     buf_size = min(count, read_len);
  22.     read_len = buf_size;
  23.     
  24.     w25q->cmd = W25X_READ_DATA;
  25.     w25q->addr = w25q->const_addr;
  26.     DBG("w25q->addr = 0x%x\n", w25q->addr);
  27.     while (buf_size) {
  28.         w25q->buf = w25q_buf;
  29.         w25q->len = min(buf_size, page_num);
  30.         ret = w25q_read_data(w25q);
  31.         if (ret != 0) {
  32.             goto exit_lock;
  33.         }
  34.         memcpy(buf_tmp, w25q_buf, w25q->len);
  35.         buf_tmp += w25q->len;
  36.         buf_size -= w25q->len;
  37.         w25q->addr += w25q->len;
  38.     }
  39.     ret = copy_to_user(user_buf, buf_start, read_len);
  40.     ret = read_len -ret;

  42. exit_lock:
  43.     mutex_unlock(&w25q->mlock);
  44. exit_kfree:
  45.     kfree(buf_start);
  46.     kfree(w25q_buf);
  47.     DBG("w25q read stop, ret = %d\n", ret);
  48.     return ret;
  49. }

        說明：
        1) 此函數(shù)需要申請兩段內(nèi)存空間,，第一段用于存放從W25Q32BV接收到的數(shù)據(jù),，第二段用于存放每次接收的數(shù)據(jù)。
        2) 設(shè)置好變量后,，調(diào)用w25q_read_data(w25q)讀取數(shù)據(jù),。
        3) 讀取完成后，將讀取到的數(shù)據(jù)拷貝到應(yīng)用層,。

三,、應(yīng)用層測試

        應(yīng)用層測試程序如下：

點(diǎn)擊(此處)折疊或打開

  1. /*
  2. * first you must erase,
  3. * then write, then read
  4. * or you can read only
  5. *
  6. */
  7. #include "w25q.h"


  10. int main(int argc, char **argv)
  11. {
  12.     char str[10] = {0};
  13.     int fd = 0, ret = 0;
  14.     unsigned char buffer[BUFSIZE] = {0};
  15.     unsigned int i = 0, idCmd = 0, num = 0;
  16.     
  17.     fd = open("/dev/w25q", O_RDWR);
  18.     if (fd < 0) {
  19.         printf("Open ADC Device Faild!\n");
  20.         exit(1);
  21.     }
  22.     while(1) {
  23.         idCmd = 0;
  24.         printf("please enter the cmd and num :\n");
  25.         scanf("%s%x", str, &num);
  26.         //printf("cmd = %s, idFreq = %d\n", str, idFreq);
  27.         if (num >= 0) {
  28.             if (strcmp(str, "SECTOR") == 0) {
  29.                 idCmd = W25Q_SECTOR_ERASE;
  30.                 ret = ioctl(fd, idCmd, &num);
  31.                 if (ret != 0) {
  32.                     printf("sector erase Faild!\n");
  33.                 }
  34.             } else if(strcmp(str, "HALF") == 0) {
  35.                 idCmd = W25Q_HALF_BLOCK_ERASE;
  36.                 ret = ioctl(fd, idCmd, &num);
  37.                 if (ret != 0) {
  38.                     printf("half block erase Faild!\n");
  39.                 }
  40.             } else if(strcmp(str, "BLOCK") == 0) {
  41.                 idCmd = W25Q_BLOCK_ERASE;
  42.                 ret = ioctl(fd, idCmd, &num);
  43.                 if (ret != 0) {
  44.                     printf("block erase Faild!\n");
  45.                 }
  46.             } else if(strcmp(str, "CHIP") == 0) {
  47.                 idCmd = W25Q_CHIP_ERASE;
  48.                 ret = ioctl(fd, idCmd, &num);
  49.                 if (ret != 0) {
  50.                     printf("chip erase Faild!\n");
  51.                 }
  52.             } else if(strcmp(str, "ID") == 0) {
  53.                 idCmd = W25Q_READ_DEVICE_ID;
  54.                 ret = ioctl(fd, idCmd, &num);
  55.                 if (ret != 0) {
  56.                     printf("read ID Faild!\n");
  57.                 } else {
  58.                     printf("ID = 0x%x\n", num);
  59.                 }
  60.             } else if(strcmp(str, "READ") == 0) {
  61.                 memset(buffer, 0, BUFSIZE);
  62.                 printf("------------\n");
  63.                 for (i = 0; i < WRITE_NUM; i++) {
  64.                     if((i != 0) && ((i % 8) == 0)) {
  65.                         printf("\n");
  66.                     }
  67.                     printf("0x%x ", buffer[i]);
  68.                 }
  69.                 printf("\n------------\n");
  70.                 ret = read(fd, buffer, WRITE_NUM);
  71.                 printf("\n------------\n");
  72.                 for (i = 0; i < WRITE_NUM; i++) {
  73.                     if((i != 0) && ((i % 8) == 0)) {
  74.                         printf("\n");
  75.                     }
  76.                     printf("0x%x ", buffer[i]);
  77.                 }
  78.                 printf("\n------------\n");
  79.             } else if(strcmp(str, "WRITE") == 0) {
  80.                 for (i = 0; i < WRITE_NUM; i++) {
  81.                     buffer[i] = i;
  82.                 }
  83.                 ret = write(fd, buffer, WRITE_NUM);
  84.                 if (ret != 0) {
  85.                     printf("w25q write oper Faild!\n");
  86.                 }
  87.             } else if(strcmp(str, "QUIT") == 0) {
  88.                 break;
  89.             } else {
  90.                 printf("wrong string\n");
  91.             }
  92.         } else {
  93.             printf("wrong input num(< 0)\n");
  94.         }
  95.     }/* end while(1) */
  96.     close(fd);
  97.     return 0;
  98. }

        說明：
        1) 首先從終端接收命令內(nèi)容。
        2) 比較命令,，然后進(jìn)入不同的處理流程,。

四、測試演示

4.1,、讀取芯片ID



4.2,、讀寫芯片


    本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布,，不代表本站觀點(diǎn),。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息,，謹(jǐn)防詐騙,。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點(diǎn)擊一鍵舉報(bào),。
    轉(zhuǎn)藏 分享 獻(xiàn)花（0）

    0條評論

    發(fā)表

    請遵守用戶 評論公約

    類似文章 更多