drivers/spi/spi-rockchip-test.c

   1 /*drivers/serial/spi_test.c -spi test driver\r
   2  *\r
   3  *\r
   4  * This program is distributed in the hope that it will be useful,\r
   5  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
   6  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
   7  * GNU General Public License for more details.\r
   8  */\r
   9 #include <linux/interrupt.h>\r
  10 #include <linux/slab.h>\r
  11 #include <linux/init.h>\r
  12 #include <linux/module.h>\r
  13 #include <linux/workqueue.h>\r
  14 #include <linux/interrupt.h>\r
  15 #include <linux/delay.h>\r
  16 #include <linux/clk.h>\r
  17 #include <linux/fs.h>\r
  18 #include <linux/dma-mapping.h>\r
  19 #include <linux/dmaengine.h>\r
  20 #include <linux/platform_device.h>\r
  21 #include <linux/pm_runtime.h>\r
  22 #include <linux/spi/spi.h>\r
  23 #include <linux/gpio.h>\r
  24 #include <linux/of.h>\r
  25 #include <linux/of_gpio.h>\r
  26 #include <linux/miscdevice.h>\r
  27 #include <linux/platform_data/spi-rockchip.h>\r
  28 #include <asm/uaccess.h>\r
  29 \r
  30 #include "spi-rockchip-core.h"\r
  31 \r
  32 #define MAX_SPI_DEV_NUM 6\r
  33 #define SPI_MAX_SPEED_HZ        12000000\r
  34 \r
  35 \r
  36 struct spi_test_data {\r
  37         struct device   *dev;\r
  38         struct spi_device       *spi;\r
  39         char *rx_buf;\r
  40         int rx_len; \r
  41         char *tx_buf;\r
  42         int tx_len; \r
  43 };\r
  44 \r
  45 static struct spi_test_data *g_spi_test_data[MAX_SPI_DEV_NUM];\r
  46 \r
  47 \r
  48 static ssize_t spi_test_write(struct file *file, \r
  49                         const char __user *buf, size_t count, loff_t *offset)\r
  50 {\r
  51         u8 nr_buf[8];\r
  52         int nr = 0, ret;\r
  53         int i = 0;\r
  54         struct spi_device *spi = NULL;\r
  55         char txbuf[256],rxbuf[256];\r
  56 \r
  57         printk("%s:0:bus=0,cs=0; 1:bus=0,cs=1; 2:bus=1,cs=0; 3:bus=1,cs=1\n",__func__);\r
  58 \r
  59         if(count > 5)\r
  60             return -EFAULT;\r
  61         \r
  62         ret = copy_from_user(nr_buf, buf, count);\r
  63         if(ret < 0)\r
  64             return -EFAULT;\r
  65 \r
  66         sscanf(nr_buf, "%d", &nr);\r
  67         if(nr >= 6 || nr < 0)\r
  68         {\r
  69                 printk("%s:cmd is error\n",__func__);\r
  70             return -EFAULT;\r
  71         }\r
  72         \r
  73         for(i=0; i<256; i++)\r
  74         txbuf[i] = i;\r
  75 \r
  76         if(!g_spi_test_data[nr] || !g_spi_test_data[nr]->spi)\r
  77         {\r
  78                 printk("%s:error g_spi_test_data is null\n",__func__);          \r
  79                 return -EFAULT;\r
  80         }\r
  81 \r
  82         spi = g_spi_test_data[nr]->spi;\r
  83 \r
  84         for(i=0; i<100; i++)\r
  85         {\r
  86                 ret = spi_write(spi, txbuf, 256);\r
  87                 ret = spi_read(spi, rxbuf, 256);\r
  88                 ret = spi_write_then_read(spi,txbuf,256,rxbuf,256);             \r
  89                 ret = spi_write_and_read(spi,txbuf,rxbuf,256);\r
  90                 printk("%s:test %d times\n\n",__func__,i+1);\r
  91         }\r
  92         \r
  93         if(!ret)\r
  94         printk("%s:bus_num=%d,chip_select=%d,ok\n",__func__,spi->master->bus_num, spi->chip_select);\r
  95         else\r
  96         printk("%s:bus_num=%d,chip_select=%d,error\n",__func__,spi->master->bus_num, spi->chip_select);\r
  97         \r
  98         return count;\r
  99 }\r
 100 \r
 101 \r
 102 static const struct file_operations spi_test_fops = {\r
 103         .write = spi_test_write,\r
 104 };\r
 105 \r
 106 static struct miscdevice spi_test_misc = {\r
 107         .minor = MISC_DYNAMIC_MINOR,\r
 108         .name = "spi_misc_test",\r
 109         .fops = &spi_test_fops,\r
 110 };\r
 111 \r
 112 #ifdef CONFIG_OF\r
 113 static struct dw_spi_chip *rockchip_spi_parse_dt(struct device *dev)\r
 114 {\r
 115         u32 temp;\r
 116         struct dw_spi_chip *spi_chip_data; \r
 117 \r
 118         spi_chip_data = devm_kzalloc(dev, sizeof(*spi_chip_data), GFP_KERNEL);\r
 119         if (!spi_chip_data) {\r
 120                 dev_err(dev, "memory allocation for spi_chip_data failed\n");\r
 121                 return ERR_PTR(-ENOMEM);\r
 122         }\r
 123         \r
 124         if (of_property_read_u32(dev->of_node, "poll_mode", &temp)) {\r
 125                 dev_warn(dev, "fail to get poll_mode, default set 0\n");\r
 126                 spi_chip_data->poll_mode = 0;\r
 127         } else {\r
 128                 spi_chip_data->poll_mode = temp;\r
 129         }\r
 130 \r
 131         if (of_property_read_u32(dev->of_node, "type", &temp)) {\r
 132                 dev_warn(dev, "fail to get type, default set 0\n");\r
 133                 spi_chip_data->type = 0;\r
 134         } else {\r
 135                 spi_chip_data->type = temp;\r
 136         }\r
 137 \r
 138         if (of_property_read_u32(dev->of_node, "enable_dma", &temp)) {\r
 139                 dev_warn(dev, "fail to get enable_dma, default set 0\n");\r
 140                 spi_chip_data->enable_dma = 0;\r
 141         } else {\r
 142                 spi_chip_data->enable_dma = temp;\r
 143         }\r
 144         \r
 145 \r
 146         return spi_chip_data;\r
 147 }\r
 148 #else\r
 149 static struct spi_board_info *rockchip_spi_parse_dt(struct device *dev)\r
 150 {\r
 151         return dev->platform_data;\r
 152 }\r
 153 #endif\r
 154 \r
 155 \r
 156 static int rockchip_spi_test_probe(struct spi_device *spi)\r
 157 {       \r
 158         int ret;\r
 159         int i =0;\r
 160         char txbuf[256],rxbuf[256];     \r
 161         int id = 0;\r
 162         static struct dw_spi_chip *spi_chip_data;\r
 163         struct spi_test_data *spi_test_data;\r
 164         \r
 165         if(!spi)        \r
 166         return -ENOMEM;\r
 167 \r
 168         if (!spi_chip_data && spi->dev.of_node) {\r
 169                 spi_chip_data = rockchip_spi_parse_dt(&spi->dev);\r
 170                 if (IS_ERR(spi_chip_data))\r
 171                 return -ENOMEM;\r
 172         }\r
 173         \r
 174         spi_test_data = (struct spi_test_data *)kzalloc(sizeof(struct spi_test_data), GFP_KERNEL);\r
 175         if(!spi_test_data){\r
 176                 dev_err(&spi->dev, "ERR: no memory for spi_test_data\n");\r
 177                 return -ENOMEM;
 178         }\r
 179 \r
 180         spi->bits_per_word = 8; \r
 181         spi->controller_data = spi_chip_data;\r
 182         \r
 183         spi_test_data->spi = spi;\r
 184         spi_test_data->dev = &spi->dev;\r
 185         \r
 186         ret = spi_setup(spi);\r
 187         if (ret < 0){\r
 188                 dev_err(spi_test_data->dev, "ERR: fail to setup spi\n");\r
 189                 return -1;\r
 190         }       \r
 191 \r
 192         if((spi->master->bus_num == 0) && (spi->chip_select == 0))\r
 193                 id = 0;\r
 194         else if((spi->master->bus_num == 0) && (spi->chip_select == 1))\r
 195                 id = 1;\r
 196         else if ((spi->master->bus_num == 1) && (spi->chip_select == 0))\r
 197                 id = 2;\r
 198         else if ((spi->master->bus_num == 1) && (spi->chip_select == 1))\r
 199                 id = 3;\r
 200         else if ((spi->master->bus_num == 2) && (spi->chip_select == 0))\r
 201                 id = 4;\r
 202         else if ((spi->master->bus_num == 2) && (spi->chip_select == 1))\r
 203                 id = 5;\r
 204 \r
 205         g_spi_test_data[id] = spi_test_data;\r
 206                 \r
 207         printk("%s:name=%s,bus_num=%d,cs=%d,mode=%d,speed=%d\n",__func__,spi->modalias, spi->master->bus_num, spi->chip_select, spi->mode, spi->max_speed_hz);\r
 208 \r
 209         printk("%s:poll_mode=%d, type=%d, enable_dma=%d\n",__func__, spi_chip_data->poll_mode, spi_chip_data->type, spi_chip_data->enable_dma);\r
 210         return ret;\r
 211 \r
 212 }\r
 213 \r
 214 static int rockchip_spi_test_remove(struct spi_device *spi)\r
 215 {\r
 216         printk("%s\n",__func__);\r
 217         return 0;\r
 218 }\r
 219 \r
 220 #ifdef CONFIG_OF\r
 221 static const struct of_device_id rockchip_spi_test_dt_match[] = {\r
 222         { .compatible = "rockchip,spi_test_bus0_cs0", },\r
 223         { .compatible = "rockchip,spi_test_bus0_cs1", },\r
 224         { .compatible = "rockchip,spi_test_bus1_cs0", },\r
 225         { .compatible = "rockchip,spi_test_bus1_cs1", },\r
 226         {},\r
 227 };\r
 228 MODULE_DEVICE_TABLE(of, rockchip_spi_test_dt_match);\r
 229 \r
 230 #endif /* CONFIG_OF */\r
 231 \r
 232 static struct spi_driver spi_rockchip_test_driver = {\r
 233         .driver = {\r
 234                 .name   = "spi_test",\r
 235                 .owner = THIS_MODULE,\r
 236                 .of_match_table = of_match_ptr(rockchip_spi_test_dt_match),\r
 237         },\r
 238         .probe = rockchip_spi_test_probe,\r
 239         .remove = rockchip_spi_test_remove,\r
 240 };\r
 241 \r
 242 static int __init spi_rockchip_test_init(void)\r
 243 {       \r
 244         int ret= 0;\r
 245         misc_register(&spi_test_misc);\r
 246         ret = spi_register_driver(&spi_rockchip_test_driver);\r
 247         \r
 248         return ret;\r
 249 }\r
 250 module_init(spi_rockchip_test_init);\r
 251 \r
 252 static void __exit spi_rockchip_test_exit(void)\r
 253 {\r
 254         misc_deregister(&spi_test_misc);\r
 255         return spi_unregister_driver(&spi_rockchip_test_driver);\r
 256 }\r
 257 module_exit(spi_rockchip_test_exit);\r
 258 \r
 259 MODULE_AUTHOR("Luo Wei <lw@rock-chips.com>");\r
 260 MODULE_DESCRIPTION("ROCKCHIP SPI TEST Driver");\r
 261 MODULE_LICENSE("GPL");\r
 262 MODULE_ALIAS("spi:spi_test");\r
 263 \r