On Sat, 20. Sep 14:52, mhornung.linux@gmail.com wrote: Hello again,

Hello,

I am trying to do my first driver, a Raspberry Pi misc char driver for controlling 433 MHz power plugs. The transmitter is a 433 MHz radio module connected to one of the RPi's GPIOs, the receiver is a 433 MHz power plug. The power plug expects a specific protocol which is normally send by an encoder chip (PT2260 or PT2262) within the appropriate remote control. The char driver shall replace those encoder chips and generate the correct bit sequence by the GPIO.

I already have a user-space library [1] which works if I send the codeword multiple times (no real time kernel). Now I am trying to do this in kernel space which is where I ran into the same problem. The socket does only switch if I send the codeword multiple times (e.g. #define REPEAT 3).

One of the possible counterparts of the remote control encoder is the PT2270 decoder chip, sitting inside the power plug. The PT2270 datasheet tells the following: "If both addresses match *for 2 consecutive code words*, PT2270 drives the data output pins." If I set #define REPEAT 2 the socket always switches as expected.

I would really appreciate any hint on how to get around this problem. Any comment on the code in general is also highly desirable.

I would really appreciate if someone could say some words about the code itself.

With best regards

Michael

[1] https://github.com/graznik/librsswitch

Thank you very much Michael

<code>

#include <linux/cdev.h> #include <linux/ctype.h> #include <linux/delay.h> #include <linux/device.h> #include <linux/fs.h> #include <linux/gpio.h> #include <linux/init.h> #include <linux/kdev_t.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/time.h> #include <linux/types.h> #include <linux/uaccess.h> #include <linux/moduleparam.h> #include <linux/miscdevice.h>

#define GPIO4 4 /* The default GPIO pin */ #define REPEAT 1 /* Times to repeat the codeword */ #define HIGH 1 #define LOW 0 #define PULSE_LEN 350

/* * Each encoder chip used in the power socket remote controls can be described * with the following struct. */ struct Encoder { char **groups; /* Group identifiers */ uint ngroups; /* Number of groups */ char **sockets; /* Socket identifiers */ uint nsockets; /* Number of sockets within one group */ char **data; /* On or off */ uint ndata; /* On or off => 2 */ uint pulse_len; /* This might differ */ };

/* The 433 MHz sender must be connected to one of these pins */ static uint valid_gpios[] = {4, 17, 21, 22, 23, 24, 25};

static int send_pin = GPIO4; /* The default pin */ module_param(send_pin, int, 0644); MODULE_PARM_DESC(send_pin, "GPIO the 433 MHz sender is connected to");

static void transmit(int nhigh, int nlow) { /* * FIXME: PULSE_LEN is the pulse length in us. This should be a parameter in the future, depending on the encoder chip within the remote control. */ gpio_set_value(send_pin, HIGH); udelay(PULSE_LEN * nhigh); gpio_set_value(send_pin, LOW); udelay(PULSE_LEN * nlow); } /** * Sends a Tri-State "0" Bit * _ _ * Waveform: | |___| |___ */ static void send_0(void) { transmit(1, 3); transmit(1, 3); }

/** * Sends a Tri-State "1" Bit * ___ ___ * Waveform: | |_| |_ */ static void send_1(void) { transmit(3, 1); transmit(3, 1); }

/** * Sends a Tri-State "F" Bit * _ ___ * Waveform: | |___| |_ */ static void send_f(void) { transmit(1, 3); transmit(3, 1); }

/** * Sends a "Sync" Bit * _ * Waveform Protocol 1: | |_______________________________ * _ * Waveform Protocol 2: | |__________ */ static void send_sync(void) { transmit(1, 31); }

static void send_tris(char *codeword) { int i = 0; unsigned long flags;

local_irq_save(flags); while (codeword[i] != '\0') { switch (codeword[i]) { case '0': send_0(); break; case '1': send_1(); break; case 'F': send_f(); break; } i++; } send_sync(); local_irq_restore(flags); }

/** * Configure struct for the PT2260 encoder * @param pt2260 Pointer to a pt2260 instance */ static int pt2260_init(struct Encoder *pt2260) { char * const groups[] = {"1FFF", "F1FF", "FF1F", "FFF1"}; char * const sockets[] = {"1FF0", "F1F0", "FF10"}; char * const data[] = {"0001", "0010"}; int i;

/* Four possible switch groups */ pt2260->ngroups = 4; pt2260->groups = kmalloc(pt2260->ngroups * sizeof(char *), GFP_KERNEL); if (pt2260->groups == NULL) { pr_err("modrss: Cannot kmalloc\n"); return -1; } /* Three possible switches per group */ pt2260->nsockets = 3; pt2260->sockets = kmalloc(pt2260->nsockets * sizeof(char *), GFP_KERNEL); if (pt2260->sockets == NULL) { pr_err("modrss: Cannot kmalloc\n"); return -1; }

/* Data is either "On" or "Off" */ pt2260->ndata = 2; pt2260->data = kmalloc(pt2260->ndata * sizeof(char *), GFP_KERNEL); if (pt2260->data == NULL) { pr_err("modrss: Cannot kmalloc\n"); return -1; }

for (i = 0; i < pt2260->ngroups; i++) pt2260->groups[i] = groups[i];

for (i = 0; i < pt2260->nsockets; i++) pt2260->sockets[i] = sockets[i];

for (i = 0; i < pt2260->ndata; i++) pt2260->data[i] = data[i];

return 0; }

/** * Configure struct for the PT2262 encoder * @param *pt2262 Pointer to a pt2262 instance */ static int pt2262_init(struct Encoder *pt2262) { char * const groups[] = {"FFFF", "0FFF", "F0FF", "00FF", "FF0F", "0F0F", "F00F", "000F", "FFF0", "0FF0", "F0F0", "00F0", "FF00", "0F00", "F000", "0000"}; char * const sockets[] = {"F0FF", "FF0F", "FFF0", "FFFF"}; char * const data[] = {"FFF0", "FF0F"}; int i;

/* 16 possible switch groups (A-P in Intertechno code) */ pt2262->ngroups = 16; pt2262->groups = kmalloc(pt2262->ngroups * sizeof(char *), GFP_KERNEL); if (pt2262->groups == NULL) { pr_err("modrss: Cannot kmalloc\n"); return -1; }

/* Four possible switches per group */ pt2262->nsockets = 4; pt2262->sockets = kmalloc(pt2262->nsockets * sizeof(char *), GFP_KERNEL); if (pt2262->sockets == NULL) { pr_err("modrss: Cannot kmalloc\n"); return -1; }

/* Data is either "On" or "Off" */ pt2262->ndata = 2; pt2262->data = kmalloc(pt2262->ndata * sizeof(char *), GFP_KERNEL); if (pt2262->data == NULL) { pr_err("modrss: Cannot kmalloc\n"); return -1; }

for (i = 0; i < pt2262->ngroups; i++) pt2262->groups[i] = groups[i];

for (i = 0; i < pt2262->nsockets; i++) pt2262->sockets[i] = sockets[i];

for (i = 0; i < pt2262->ndata; i++) pt2262->data[i] = data[i];

return 0; }

/** * Emulate an encoder chip * @param *enc Pointer to an encoder instance * @param uint group Socket group * @param uint socket Socket within group * @param uint data Data to send */ static int socket_ctrl(struct Encoder *enc, uint group, uint socket, uint data) { int i; size_t s; char *codeword;

/* Calculate the codeword size */ s = strlen(enc->groups[group]) + strlen(enc->sockets[socket]) + strlen(enc->data[data]);

codeword = kmalloc(s + 1, GFP_KERNEL);

/* Generate the codeword including '\0' */ snprintf(codeword, s + 1, "%s%s%s", enc->groups[group], enc->sockets[socket], enc->data[data]);

pr_debug("codeword: %s\n", codeword);

/* Send the codeword */ for (i = 0; i < REPEAT; i++) send_tris(codeword);

return 0; }

static int socket_send(uint dev, uint group, uint socket, uint data) { struct Encoder encoder;

switch (dev) { case 0: pt2260_init(&encoder); break; case 1: pt2262_init(&encoder); break; default: pr_err("modrss: Unknown encoder type.\n"); return -1; }

socket_ctrl(&encoder, group, socket, data);

return 0; }

static ssize_t driver_write(struct file *f, const char __user *ubuf, size_t len, loff_t *off) { char *kbuf; uint encoder, group, socket, data; int i, data_len;

kbuf = kmalloc(len, GFP_KERNEL); if (!kbuf) return -ENOMEM;

if (copy_from_user(kbuf, ubuf, len)) { pr_err("Error: Unable to read user input\n"); kfree(kbuf); return -EFAULT; }

data_len = strlen(kbuf);

/* Check for valid hex values from user space */ for (i = 0; i < data_len; i++) { if ((kbuf[i] >= 'a') && (kbuf[i] <= 'f')) { kbuf[i] = kbuf[i] - 'a'; } else if ((kbuf[i] >= 'A') && (kbuf[i] <= 'F')) { kbuf[i] = kbuf[i] - 'A'; } else if ((kbuf[i] >= '0') && (kbuf[i] <= '9')) { kbuf[i] = kbuf[i] - '0'; } else { pr_err("modrss: Only characters 0-9, a-f, and A-F.\n"); return -1; } }

pr_debug("modrss: socket_ctrl(%d, %d, %d, %d)\n", (uint)kbuf[0], (uint)kbuf[1], (uint)kbuf[2], (uint)kbuf[3]);

socket_send((uint)kbuf[0], (uint)kbuf[1], (uint)kbuf[2], (uint)kbuf[3]);

return len; }

static const struct file_operations fops = { .owner = THIS_MODULE, .write = driver_write, };

static struct miscdevice modrss_dev = { .minor = MISC_DYNAMIC_MINOR, .name = "rsswitch", .fops = &fops, };

static int __init modrsswitch_init(void) { int ret, i, valid;

pr_debug("modrss: Module registered");

misc_register(&modrss_dev);

valid = 0; /* Check for valid GPIO */ for (i = 0; i < ARRAY_SIZE(valid_gpios); i++) { if (send_pin == valid_gpios[i]) { valid = 1; break; } }

if (valid) { send_pin = GPIO4; pr_err("modrss: using default GPIO %d\n", GPIO4); }

/* Register GPIO and set to LOW */ ret = gpio_request_one(send_pin, GPIOF_OUT_INIT_LOW, "send_pin"); if (ret) { pr_err("modrss: Unable to request GPIO: %d\n", ret); return ret; }

pr_debug("modrss: Using GPIO %d\n", send_pin);

return 0; }

static void __exit modrsswitch_exit(void) { gpio_set_value(send_pin, 0); gpio_free(send_pin);

misc_deregister(&modrss_dev);

pr_debug("modrss: Module unregistered"); }

module_init(modrsswitch_init); module_exit(modrsswitch_exit);

MODULE_AUTHOR("Michael Hornung"); MODULE_DESCRIPTION("Remote socket switch character driver"); MODULE_LICENSE("GPL");

</code>