开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
spi.c
资源名称：ixp425_spi.rar　[点击查看]
上传用户：beauty0755
上传日期：2022-02-24
资源大小：7k
文件大小：6k
源码类别：

驱动编程

开发平台：

Unix_Linux

spi.c：源码内容
  2. #include <linux/init.h>
  3. #include <linux/kernel.h>
  4. #include <linux/module.h>
  5. #include <linux/delay.h>
  6. #include <linux/proc_fs.h>
  7. #include <asm/uaccess.h>
  9. #include "spi.h"
  11. #define DEBUG
  13. #ifdef DEBUG
  14. #define PRINTK(format,argument...) printk(format,##argument)
  15. #else
  16. #define PRINTK(format,argument...)
  17. #endif
  19. MODULE_DESCRIPTION("IXP400 GPIO spi driver");
  20. MODULE_LICENSE("GPL");
  21. MODULE_AUTHOR("ONet Corporation");
  22. #define MODULE_NAME "spi"
  23. #define MOD_VERSION "0.1"
  25. static int sb_gpio_init(void)
  26. {
  27.     uint32_t gpio;
  28.     
  29.     gpio = SPI_SCK | SPI_SS |SPI_MOSI;
  30.     *IXP4XX_GPIO_GPOER &= ~gpio;
  31.     
  32.     *IXP4XX_GPIO_GPOUTR |= SPI_SCK;
  33.     *IXP4XX_GPIO_GPOUTR |= SPI_SS;
  34.     *IXP4XX_GPIO_GPOUTR |= SPI_MISO;
  35.     *IXP4XX_GPIO_GPOUTR |= SPI_MOSI;
  36.     
  37.     return 0;
  38. }
  40. static int sb_gpio(int out, unsigned long gpio,int logic)
  41. {
  42.     int val = 0;
  43.     
  44.     if(out)
  45.     {
  46.         if(logic)
  47.          *IXP4XX_GPIO_GPOUTR |= gpio;
  48.      else
  49.          *IXP4XX_GPIO_GPOUTR &= ~gpio;
  50.     }else
  51.     {
  52.         val = (*IXP4XX_GPIO_GPINR & gpio)?1:0;  
  53.         return val;
  54.     }    
  55.     
  56.     return 0;
  57. }
  59. static int sb_spi_read(uint8_t * buf, int len)
  60. {
  61.     int i;
  62.     uint8_t mask, byte; 
  63.     
  64.     for (i = 0; i < len; i++) {
  65.         /* Bit bang from MSB to LSB */
  66.         for (mask = 0x80, byte = 0; mask; mask >>= 1) {
  67.             /* Clock low */
  68.             sb_gpio(GPIOOUTPUT, SPI_SCK, 0);
  69.             POLL_DELAY();
  71.             /* Sample */
  72.             if (sb_gpio(GPIOINPUT, SPI_MISO, 0))
  73.                 byte |= mask;
  75.             /* Clock high */
  76.             sb_gpio(GPIOOUTPUT, SPI_SCK, 1);
  77.             POLL_DELAY();
  78.         }
  79.         buf[i] = byte;
  80.     }
  82.     return 0;
  83. }
  85. static int sb_spi_write(uint8_t *buf, int len)
  86. {
  87.     int i;
  88.     uint8_t mask;
  90.     for (i = 0; i < len; i++) {
  91.         /* Bit bang from MSB to LSB */
  92.         
  94.         for (mask = 0x80; mask; mask >>= 1) {
  95.             /* Clock low */
  96.             sb_gpio(GPIOOUTPUT, SPI_SCK, 0);
  97.             POLL_DELAY();
  99.             /* Output on rising edge */
  100.             sb_gpio(GPIOOUTPUT, SPI_MOSI, (mask & buf[i])?1:0);
  102.             /* Clock high */
  103.             sb_gpio(GPIOOUTPUT, SPI_SCK, 1);
  104.             POLL_DELAY();
  105.         }
  106.     }
  108.     return 0;
  109. }
  111. static int cur_page = -1;
  113. static int robo_select_page(int page)
  114. {
  115.     if (cur_page == page) {
  116.         return 0;
  117.     }
  118.     
  119.     cur_page = page;
  120.     sb_gpio(GPIOOUTPUT, SPI_SS, 0);
  121.     SPI_WRITE8(0x61);
  122.     SPI_WRITE8(R_ROBOSPI_PAGE);
  123.     SPI_WRITE8(page);
  124.     sb_gpio(GPIOOUTPUT, SPI_SS, 1);
  126.     return 0;
  127. }
  129. static int robo_reset(void)
  130. {
  131.     /* Force page change */
  132.     cur_page = -1;
  133.     robo_select_page(0);
  134.     cur_page = -1;
  136.     return 0;
  137. }
  139. static int robo_fast_rack_poll()
  140. {
  141.     uint8_t status;
  142.     int timeout = 10;
  144.     while(timeout-- > 0) 
  145.     {
  146.         sb_spi_read(&status, 1);
  148.         if (status & M_SPISTAT_FAST_RACK) {
  149.             return 0;
  150.         }
  152.         POLL_DELAY();
  153.     }
  154.     return -1;
  155. }
  157. static int robo_read_reg(int page, int reg, uint8_t * buffer, int length)
  158. {
  159.     if (length > 8)
  160.         return -1;
  161.         
  162.     robo_select_page(page);
  164.     sb_gpio(GPIOOUTPUT, SPI_SS, 0);
  165.     SPI_WRITE8(0x10);
  166.     SPI_WRITE8(reg);
  168.     if (robo_fast_rack_poll() < 0) // Timeout
  169.     {     
  170.         sb_gpio(GPIOOUTPUT, SPI_SS, 1);
  171.         robo_reset();
  172.         return -1;
  173.     }
  175.     // Read registers 
  176.     sb_spi_read(buffer, length);
  177.     sb_gpio(GPIOOUTPUT, SPI_SS, 1);
  178.     return 0;
  179. }
  181. static int robo_write_reg(int page, int reg, uint8_t * buffer, int length)
  182. {
  183.     if (length > 8)
  184.         return -1;
  185.         
  186.     robo_select_page(page);
  188.     sb_gpio(GPIOOUTPUT, SPI_SS, 0);
  189.     SPI_WRITE8(0x61);
  190.     SPI_WRITE8(reg);
  191.     sb_spi_write(buffer, length);
  192.     sb_gpio(GPIOOUTPUT, SPI_SS, 1);
  194.     return 0;
  195. }
  197. void BCM5324_soft_init(void)
  198. {
  199.     uint8_t value;    
  200. //MII/IMP PORT (24) CONTROL REGISTER (PAGE 00H/ADDR E8H)
  201.     value = 0xf7; 
  202. robo_write_reg(0x00, 0x00, (uint8_t *)&value, sizeof(value));
  203.     
  204. //MII/IMP PORT (24) CONTROL REGISTER (PAGE 00H/ADDR E8H)
  205. value = (1<<4) | (1<<3) | (1<<2);
  206. robo_write_reg(0x00, 0xe8, (uint8_t *)&value, sizeof(value));
  207.      
  208.     /*GLOBAL MANAGEMENT CONFIGURATION REGISTER (PAGE 02H/ADDR 00H) */
  209.     value = 0x83;
  210.     robo_write_reg(0x02, 0x00, (uint8_t *)&value, sizeof(value));
  212. value = 0x82; //unReset MIB Counters.
  213. robo_write_reg(0x02, 0x00, (uint8_t *)&value, sizeof(value));
  215. /* 802.1Q CONTROL 5 REGISTER (PAGE 34H/ADDR 08H) */
  216. value = 0x03;
  217. robo_write_reg(0x34, 0x08, (uint8_t *)&value, sizeof(value));
  219. /* PORT 24 MII PORT STATE OVERRIDE REGISTER (PAGE 00H/ADDR B8H) */
  220. value = 0xc7;
  221. robo_write_reg(0x00, 0xb8, (uint8_t *)&value,1);
  222. }
  224. static struct semaphore   spi_sem;
  225. static spinlock_t         device_spi_lock;
  227. static int spi_open(struct inode *inode, 
  228.                        struct file *file)
  229. {
  230.   return 0;
  231. }
  233. static int spi_release(struct inode *inode, 
  234.                           struct file *file)
  235. {
  236.   return 0;
  237. }
  239. int spi_ioctl(
  240.     struct inode *inode,
  241.     struct file *file,
  242.     unsigned int ioctl_num,/*  ioctl 号 */
  243.     unsigned long ioctl_param) /* 对它的参数 */
  244. {
  245.     uint8_t *temp = (char *)ioctl_param;
  246.     uint8_t * val =  temp+4;
  247.     uint8_t page = temp[0];
  248.     uint8_t reg = temp[1];
  249.     uint8_t size = temp[2];
  250.     unsigned long irqflags = 0x00;
  251.     
  252.     down_interruptible(&spi_sem);
  253.     spin_lock_irqsave(&device_spi_lock, irqflags);
  254.     
  255.     switch (ioctl_num) {
  256.         case IOCTL_SPI_READ:
  257.             robo_read_reg(page, reg, val, size);
  258.             break;
  259.         case IOCTL_SPI_WRITE:
  260.             robo_write_reg(page, reg, val, size);
  261.             break;
  262.         default:
  263.             break;
  264.     }
  265.     spin_unlock_irqrestore(&device_spi_lock, irqflags);
  266.     up(&spi_sem);
  268.   return 0;
  269. }
  271. struct file_operations Fops = {
  272.   .ioctl = spi_ioctl,   /* ioctl */
  273.   .open = spi_open,
  274.   .release = spi_release  /* 又名关闭 */
  275. };
  277. static int __init spi_module_init(void)
  278. {
  279.     int ret_val;
  280.     uint8_t cfg;
  282. ret_val = register_chrdev(SPIDEV_MAJOR, DEVICE_NAME, &Fops);
  283. if (ret_val < 0) {
  284. printk("%s failed with %dn",
  285.        "Sorry, registering the character device ", ret_val);
  286. return ret_val;
  287. }
  289.     sb_gpio_init();
  290.     
  291. //    BCM5324_soft_init();
  292.     
  293.     sema_init(&spi_sem, 1);
  294.     
  295. //    robo_read_reg(0x34, 0x00, &cfg, 1);
  296. //    printk("cfg 0x%02xn",cfg);
  297. return 0;
  298. }
  300. static int __exit spi_module_cleanup(void)
  301. {
  302.     int ret;
  304. ret = unregister_chrdev(SPIDEV_MAJOR, DEVICE_NAME);
  306. if (ret < 0)
  307. printk("Error in module_unregister_chrdev: %dn", ret);
  309. return 0;
  310. }
  312. module_init(spi_module_init);
  313. module_exit(spi_module_cleanup);