Works!

Author: bjarkevad

Makefile

@@ -35,7 +35,7 @@ else
     # called from kernel build system: just declare what our modules are
 #    obj-m := ads7870.o #ads7870-core.o ads7870-spi.o
     obj-m += psoc5mod.o
-    psoc5mod-objs := psoc5-cdrv.o psoc5-spi.o
+    psoc5mod-objs := psoc5-spi.o psoc5-cdrv.o
 
 endif
 

psoc5-cdrv.c

@@ -2,21 +2,11 @@
 #include <linux/sched.h>
 #include <linux/gpio.h>
 
-#include "psoc5-cdrv.h"
 #include "psoc5-spi.h"
-
-#define INTGPIO 7 
-
-static struct cdev psoc5Dev;
-struct file_operations psoc5_Fops;
-static int devno;
-
-DECLARE_WAIT_QUEUE_HEAD(wait_queue);
-int newData = 0;
-
+#include "psoc5-cdrv.h"
 
 irqreturn_t psoc5_isr(int irq, void *dev_id) {
-	//printk("PSoC5 interrupt!\n");
+	//printk(KERN_ALERT "PSoC5 interrupt!\n");
 	newData = 1;
 	wake_up_interruptible(&wait_queue);
 	return IRQ_HANDLED;
@@ -52,10 +42,8 @@ static int __init psoc5_cdrv_init(void) {
 }
 
 static void __exit psoc5_cdrv_exit(void) {
-	int err;
-	
 	printk("PSoC5 cdrv exit\n");
-	err = psoc5_spi_exit();
+  psoc5_spi_exit();
 	unregister_chrdev_region(devno, 1);
 	cdev_del(&psoc5Dev);
 	gpio_free(INTGPIO);
@@ -94,13 +82,13 @@ ssize_t psoc5_cdrv_write(struct file *filep, const char __user *ubuf,
 	char kbuf[MAXLEN];
 
 	len = count < MAXLEN ? count : MAXLEN;
-
+  len--;
 	if(copy_from_user(kbuf, ubuf, len))
 		return -EFAULT;
 
-	printk("Received '%X, %X' from user. Len = %i\n", kbuf[0], kbuf[1],len);
+	//kbuf[len] = '\0';
 
-		psoc5_spi_write(kbuf, len);
+	psoc5_spi_write(kbuf, len);
 
 	return count;
 }
@@ -110,9 +98,11 @@ ssize_t psoc5_cdrv_read(struct file *filep, char __user *ubuf,
 	char result;
 	char resultBuf[5];
 
+	//wait_event_interruptible(wait_queue, newData == 1);
 	if(wait_event_interruptible_timeout(wait_queue, newData == 1, 1000) == 0) {
 		result = 0;
 		copy_to_user(ubuf, &result, 1);
+		printk(KERN_ALERT "cdrv timeout read: '%X' \n", result);
 		return 1;
 	}
 
@@ -122,7 +112,8 @@ ssize_t psoc5_cdrv_read(struct file *filep, char __user *ubuf,
 
 	count = snprintf(resultBuf, sizeof(resultBuf), "%c", result);
 
-	printk("cdrv read: '%X' \n", result);
+	/*if(result != 0x00 && result != 0x0F)
+		printk(KERN_ALERT "cdrv read: '%X' \n", result);*/
 
 	if(copy_to_user(ubuf, resultBuf, sizeof(resultBuf)) != 0) {
 		printk("Error copying to user \n");

psoc5-cdrv.h

@@ -1,3 +1,28 @@
+/**
+ * @file 
+ * @author Bjarke Vad Andersen
+ *
+ * @section LICENSE
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details at
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @section DESCRIPTION
+ *
+ * This kernel module is written to used on a DevKit8000, 
+ * and is supposed  used with a PSoC5 device connected trough SPI.
+ * This file contains the character driver properties of the SPI kernel module.
+ * This includes init, exit, read, write, open and release methods.
+ *
+ */
 #include <linux/err.h>
 #include <linux/ctype.h>
 #include <linux/cdev.h>
@@ -6,17 +31,127 @@
 #include <linux/input.h>
 #include <linux/module.h>
 
+/**
+ * @brief The Major number of the node.
+ */
 #define PSOC5_MAJOR 62
+/**
+ * @brief The Minor number of the node.
+ */
 #define PSOC5_MINOR 0
+/**
+ * @brief The maximum length for data to write to the device node in one function call.
+ * */
 #define MAXLEN			512
+/**
+ * @brief The GPIO pin which is used for receiving "word complete" interrupts from the PSoC5.
+ */
+#define INTGPIO 130 //7/137  
 
+
+/**
+ * @brief The init method.
+ *
+ * This method is called whenever the module is inserted into the kernel.
+ * Here the basic setup and registering of the character driver takes place, including requesting
+ * GPIO resources for the interrupt pin, and setting said GPIO to input. 
+ * psoc5_spi_init() is called to initialize the SPI part of the module.
+ *
+ * @return 0 on success.
+ */
 static int __init psoc5_cdrv_init(void);
+/*
+ * @brief The exit method.
+ *
+ * This method is called whenever the module is removed from the kernel.
+ * The character device is unregistered and deleted, and the requested GPIO resources are freed.
+ */
 static void __exit psoc5_cdrv_exit(void);
-
+/**
+ * @brief The open method.
+ *
+ * This method is called whenever a user is trying to read from or write to the device.
+ * Here interrupt resources are requested. This is done here and not in the init method 
+ * to prevent allocating resources that are not used.
+ *
+ * @return 0 on success.
+ */
 int psoc5_cdrv_open(struct inode *inodep, struct file *filep);
+/**
+ * @brief The release method.
+ *
+ * This method is called when a user is closing an open PSoC5 device, 
+ * e.g. after reading from the device.
+ * Here interrupt line resources are freed.
+ *
+ * @return 0 on success.
+ */
 int psoc5_cdrv_release(struct inode *inodep, struct file *filep);
-
+/**
+ * @brief The write method.
+ *
+ * This method is called when a user is writing to the device. 
+ * Prevents the user from sending strings longer than MAXLEN,
+ * and sends the data received from userspace through SPI by calling "psoc5_spi_write()".
+ * 
+ * @param ubuf The received data from userspace, represented as a character array.
+ * @param count The length of the received character array.
+ *
+ * @return The length of the string written to the device.
+ */
 ssize_t psoc5_cdrv_write(struct file *filep, const char __user *ubuf,
 												size_t count, loff_t *f_pos);
+/**
+ * @brief The read method.
+ *
+ * This method is called when a user is trying to read from the device.
+ * Waits for an interrupt, and then continues to read out the data from the SPI, 
+ * and copies them to userspace.
+ * If no interrupt is received within 1000 jiffies 0 is sent to userspace.
+ *
+ * @param ubuf The address on which the user expects data to be copied to.
+ * @return The length of the received character array.
+ */
 ssize_t psoc5_cdrv_read(struct file *filep, char __user *ubuf,
 												size_t count, loff_t *f_pos);
+
+/**
+ * @brief The interrupt service routine.
+ *
+ * This ISR is called whenever a interrupt is received on the assigned GPIO pin,
+ * meaning that a new word is received, it sets newData to 1.
+ *
+ * @return IRQ_HANDLED.
+ */
+irqreturn_t psoc5_isr(int irq, void *dev_id);
+
+/**
+ * @brief The character device struct.
+ *
+ * Used to register the device in the kernel. 
+ * Contains all information of the character driver characteristics of the module,
+ * including the file_operations struct.
+ */
+static struct cdev psoc5Dev;
+/**
+ * @brief The file operations struct
+ *
+ * Used to define which operations are called when the device 
+ * is used as a file/node.
+ */
+struct file_operations psoc5_Fops;
+/**
+ * @brief A static in that contains the major/minor number characteristics returned from MKDEV.
+ */
+static int devno;
+/**
+ * @brief The wait queue which psoc5_cdrv_read() waits for.
+ *
+ * This wait queue is used to signal the character driver read method
+ * from the ISR, that new data is ready from the PSoC5 device. 
+ */
+DECLARE_WAIT_QUEUE_HEAD(wait_queue);
+/**
+ * @brief The variable that is checked to see if new data is ready.
+ */
+int newData = 0;

psoc5-spi.c

@@ -1,26 +1,15 @@
 #include "psoc5-spi.h"
-
-#define MAXLEN 512
-
-static struct spi_device *psoc5_spi_device;
-
-static struct omap2_mcspi_device_config psoc5_mcspi_device_config = {
-	.turbo_mode 		= 0,
-	.single_channel = 1, //Master
-};
-
 struct spi_board_info omap3devkit8000_spi_board_info[] = {
 	{
 		.modalias			= "psoc5",
 		.bus_num			= 1,
 		.chip_select 	= 0, 
-		.max_speed_hz = 15000000, //Should be ok, can be set lower if transfer errors occur
+		.max_speed_hz =  2000000, //1500000, //Should be ok, can be set lower if transfer errors occur
 		.controller_data = &psoc5_mcspi_device_config,
 		.mode					= SPI_MODE_3,
 	},
 };
 
-
 static int __devinit psoc5_probe(struct spi_device* spi) {
 
 	psoc5_spi_device->bits_per_word = 8;
@@ -43,6 +32,7 @@ static struct spi_driver psoc5_spi_driver = {
 	},
 	.probe = psoc5_probe,
 	.remove = __devexit_p(psoc5_remove),
+
 };
 
 int psoc5_spi_init(void) {
@@ -70,45 +60,48 @@ int psoc5_spi_exit(void) {
 char psoc5_spi_read(void) {
 	struct spi_transfer t[1];
 	struct spi_message m;
-	char data;
+	unsigned char data;
+
+	char data2;
+	data2 = 65;
 
 	memset(t, 0, sizeof(t));
 	spi_message_init(&m);
 	m.spi = psoc5_spi_device;
 
-	t[0].tx_buf = NULL;
+	t[0].tx_buf = NULL; //&data2;
 	t[0].rx_buf = &data;
 	t[0].len = 1;
 	spi_message_add_tail(&t[0], &m);
 
 	spi_sync(m.spi, &m);
 
-	printk("PSoC5-spi: read: '%X'\n", data); 
+	//printk("PSoC5-spi: read: '%X'\n", data); 
 
 	return data;
 }
 
 void psoc5_spi_write(char *dataToWrite, unsigned int len) {
-	int i;
-	char *data;
-	struct spi_transfer t[len];
+	struct spi_transfer t[1];
 	struct spi_message m;
 
-	data = dataToWrite;
-
-	memset(&t, 0, sizeof(t));
+	memset(t, 0, sizeof(t));
 	spi_message_init(&m);
 	m.spi = psoc5_spi_device;
 
+	t[0].tx_buf = dataToWrite;
+	t[0].rx_buf = NULL;
+	t[0].len = 1;
+	spi_message_add_tail(&t[0], &m);
+
+	/* enable this to print out what is sent in HEX
+	 * int i;
 	for( i = 0 ; i < len ; i++ )
 	{
-		t[i].tx_buf = &data[i];
-		t[i].rx_buf = NULL;
-		t[i].len = 1;
-		spi_message_add_tail(&t[i], &m);
-		printk("PSoC5-spi: write: '%X' \n", data[i]);
-	}
+		printk("PSoC5-spi: write: '%c' \nLen: %i \n", dataToWrite[i], len);
+	}*/
 
-	spi_sync(m.spi, &m);
+	if(spi_sync(m.spi, &m)!= 0)
+		printk(KERN_ALERT "SPI syncronization error!");
 }