1

#include <linux/module.h>

     2

#include <linux/kthread.h>

     3

#include <linux/fs.h>

     4

#include <linux/cdev.h>

     5

#include <asm/uaccess.h>

     6

     7

#include "TestMasterSlave.h"

     8

#include "console/console.h"

     9

    10

#define minor 0

    11

    12

MODULE_LICENSE("GPL");

    13

    14

static dev_t canftest_dev;

    15

static struct cdev *canftest_cdev;

    16

static struct task_struct *thread_start_p, *thread_stop_p;

    17

static DECLARE_MUTEX (canftest_mutex);

    18

static int canftest_stopped = 1;

    19

    20

// handler processing write() requests from user-space

    21

ssize_t canftest_write(struct file *filp, const char __user *buf, size_t count,

    22

		       loff_t *f_pos)

    23

{

    24

	int cmd;

    25

    26

	// get integer from user-space

    27

	if (get_user (cmd, buf))

    28

		return -EFAULT;

    29

    30

	// process integer as command

    31

	switch (cmd) {

    32

		case CMD_START:

    33

			wake_up_process (thread_start_p);

    34

			break;

    35

		case CMD_STOP:

    36

			if (canftest_stopped) break;

    37

			wake_up_process (thread_stop_p);

    38

			break;

    39

		// ignore new line character

    40

		case 10:

    41

			break;

    42

		default:

    43

			printk("canftest: bad command %d\n", cmd);

    44

			break;

    45

	}

    46

    47

	return count;

    48

}

    49

    50

// register write() handler

    51

static struct file_operations canftest_fops = {

    52

	.owner =    THIS_MODULE,

    53

	.write =    canftest_write,

    54

};

    55

    56

// start TestMasterSlave example

    57

int thread_start (void* data)

    58

{

    59

	int ret=0;

    60

    61

	down_interruptible (&canftest_mutex);

    62

    63

	ret=TestMasterSlave_start();

    64

    65

	// if started

    66

	if (ret == 0) {

    67

		canftest_stopped = 0;

    68

    69

		// increment module usage count

    70

		try_module_get(THIS_MODULE);

    71

	}

    72

    73

	up (&canftest_mutex);

    74

    75

	return ret;

    76

}

    77

    78

// finish TestMasterSlave example

    79

int thread_stop (void* data)

    80

{

    81

	down_interruptible (&canftest_mutex);

    82

    83

	TestMasterSlave_stop();

    84

	canftest_stopped = 1;

    85

    86

	// decrement usage count

    87

	module_put(THIS_MODULE);

    88

    89

	up (&canftest_mutex);

    90

    91

	return 0;

    92

}

    93

    94

int init_module(void)

    95

{

    96

	int ret, major;

    97

    98

	// get major device number dynamically

    99

	ret = alloc_chrdev_region(&canftest_dev, minor, 1, DEVICE_NAME);

   100

	major = MAJOR(canftest_dev);

   101

	if (ret < 0) {

   102

		printk(KERN_WARNING "canftest: can't get major %d\n", major);

   103

		return ret;

   104

	}

   105

   106

	canftest_cdev = cdev_alloc( );

   107

	canftest_cdev->owner = THIS_MODULE;

   108

	canftest_cdev->ops = &canftest_fops;

   109

   110

	// register new character device

   111

	ret = cdev_add (canftest_cdev, canftest_dev, 1);

   112

	if (ret) {

   113

		printk(KERN_WARNING "canftest: error %d adding char device\n", ret);

   114

		return ret;

   115

	}

   116

   117

	thread_start_p = kthread_create (thread_start, NULL, "canftest_start");

   118

	thread_stop_p = kthread_create (thread_stop, NULL, "canftest_stop");

   119

   120

	if (PTR_ERR(thread_start_p) == -ENOMEM || PTR_ERR(thread_stop_p) == -ENOMEM) {

   121

		printk(KERN_WARNING "canftest: error creating threads\n");

   122

		return -ENOMEM;

   123

	}

   124

   125

	return 0;

   126

}

   127

   128

void cleanup_module(void)

   129

{

   130

	// unregister major device number and character device

   131

	unregister_chrdev_region(canftest_dev, 1);

   132

	cdev_del(canftest_cdev);

   133

}