lkml.org 
[lkml]   [2012]   [Jan]   [31]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[RESEND PATCHv5 08/11] modem_shm: SHM Configuration data handling
Date
Add configuration handling of modem shared memory. A gen-netlink endpoint
for "modem-shm" is implemented handling channel configuration requests.
The channel configuration is stored in the device and in shared memory.

Signed-off-by: Sjur Brændeland <sjur.brandeland@stericsson.com>
---
drivers/modem_shm/shm_boot.c | 1208 ++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1208 insertions(+), 0 deletions(-)
create mode 100644 drivers/modem_shm/shm_boot.c
diff --git a/drivers/modem_shm/shm_boot.c b/drivers/modem_shm/shm_boot.c
new file mode 100644
index 0000000..87ff053
--- /dev/null
+++ b/drivers/modem_shm/shm_boot.c
@@ -0,0 +1,1208 @@
+/*
+ * Copyright (C) ST-Ericsson AB 2012
+ * Author: Sjur Brændeland / sjur.brandeland@stericsson.com
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ":" fmt
+#include <linux/version.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kobject.h>
+#include <linux/string.h>
+#include <linux/sysfs.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/ctype.h>
+#include <linux/crc-ccitt.h>
+#include <linux/kdev_t.h>
+#include <net/netlink.h>
+#include <net/genetlink.h>
+#include "shm_ipctoc.h"
+#include <linux/modem_shm/shm_dev.h>
+#include <linux/modem_shm/modem_shm_netlink.h>
+#include <linux/c2c_genio.h>
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Sjur Brændland <sjur.brandeland@stericsson.com>");
+
+#define SHM_VERSION 0x1
+#define SHM_SUBVER 0x0
+#define TOC_SZ 512
+#define IMG_MAX_SZ 65536
+#define SHM_ALIGNMT sizeof(u32)
+#define SHM_MIN_CHSZ 3
+#define SHM_PAYL_ALIGN max(32, L1_CACHE_BYTES)
+#define STE_BOOTIMG_NAME "ste-bootimg.bin"
+
+#define GET_OFFSET(base, ptr) (((u8 *)(ptr)) - ((u8 *)(base)))
+#define OFFS2PTR(base, offs) ((void *) ((u8 *)base + offs))
+#define LEOFFS2PTR(base, offs) ((void *) ((u8 *)base + le32_to_cpu(offs)))
+
+/* Structure use in debug mode for integrity checking */
+struct ipctoc_hash {
+ u16 img_hash;
+ u16 ch_hash;
+ u16 ch_size;
+};
+struct shm_modem {
+ bool config_error;
+ bool commited;
+ bool registered;
+ bool addr_set;
+ bool fw_requested;
+ u32 modem_bootimg_size;
+ void *shm_start;
+ u32 channels;
+ struct shm_channel *channel[SHM_MAX_CHANNELS + 1];
+ struct shm_ipctoc *ipctoc;
+ bool gennetl_reg;
+};
+
+static unsigned long shm_start;
+module_param(shm_start, ulong, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(shm_start, "Address for memory shared by host/modem.");
+
+static unsigned long shm_c2c_bootaddr;
+module_param(shm_c2c_bootaddr, ulong, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(shm_c2c_bootaddr,
+ "Address given to modem (through GENI register)");
+
+static long shm_size;
+module_param(shm_size, long, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(shm_size, "Size of SHM area");
+
+#ifdef DEBUG
+
+/* In debug mode we pad around all payload area in order to detect overwrite */
+#define MAGIC_PAD_LEN 32
+#define MAGIC_PAD 0xbc
+
+/* Verify a magic-pad area */
+static inline bool padok(void *mag)
+{
+ u32 *p = mag, v = 0xbcbcbcbc;
+ int i;
+
+ for (i = 0; i < 8; i++)
+ if (*p++ != v)
+ return false;
+ return true;
+}
+
+/* Insert a magic-pad area */
+static inline void add_magic_pad(u32 *offset, void *base)
+{
+ if (*offset < shm_size)
+ memset(base + *offset, MAGIC_PAD, MAGIC_PAD_LEN);
+ *offset += MAGIC_PAD_LEN;
+}
+
+/* Abuse the pad area to create a checksum of the ipc-toc and descriptors */
+static inline void store_checksum(struct shm_modem *modem, u32 size)
+{
+ struct ipctoc_hash *hash = (void *)modem->ipctoc;
+ --hash;
+ hash->img_hash =
+ crc_ccitt(0xffff, (u8 *) modem->shm_start,
+ modem->modem_bootimg_size);
+ hash->ch_hash = crc_ccitt(0xffff, (u8 *) modem->ipctoc, size);
+ hash->ch_size = size;
+}
+
+/* Verify that shm config has not been accidently tampered. */
+static inline bool ok_checksum(struct shm_modem *modem,
+ struct shm_ipctoc *ipctoc)
+{
+ struct ipctoc_hash *hash = (void *) ipctoc;
+ u16 new_hash, new_imghash;
+ int i;
+ u8 *p;
+
+ if (!modem->commited)
+ return false;
+
+ for (i = 0; i < modem->channels; i++) {
+ struct shm_ipctoc_channel *ch;
+
+ ch = LEOFFS2PTR(modem->shm_start,
+ ipctoc->channel_offsets[i].rx);
+ p = LEOFFS2PTR(modem->shm_start, ch->ipc);
+ if (!padok(p - MAGIC_PAD_LEN))
+ return false;
+ p = LEOFFS2PTR(modem->shm_start, ch->offset);
+ if (!padok(p - MAGIC_PAD_LEN))
+ return false;
+ ch = LEOFFS2PTR(modem->shm_start,
+ ipctoc->channel_offsets[i].tx);
+ p = LEOFFS2PTR(modem->shm_start, ch->ipc);
+ if (!padok(p - MAGIC_PAD_LEN))
+ return false;
+ p = LEOFFS2PTR(modem->shm_start, ch->offset);
+ if (!padok(p - MAGIC_PAD_LEN))
+ return false;
+ }
+
+ --hash;
+ new_hash = crc_ccitt(0xffff, (u8 *) ipctoc, hash->ch_size);
+ new_imghash =
+ crc_ccitt(0xffff, (u8 *) modem->shm_start,
+ modem->modem_bootimg_size);
+ pr_debug("Hash result:size:%d chksm:%u/%u img:%u/%u\n",
+ hash->ch_size, hash->ch_hash, new_hash,
+ hash->img_hash, new_imghash);
+ return hash->ch_hash == new_hash && hash->img_hash == new_imghash;
+}
+
+static inline void init_data(void *shm_start, u32 offset,
+ int ch, u32 size)
+{
+ memset((u8 *)shm_start + offset, ch + 1, size);
+}
+#else
+#define MAGIC_PAD_LEN 0
+static inline void add_magic_pad(u32 *offset, void *base)
+{
+}
+static inline void store_checksum(struct shm_modem *modem, u32 size)
+{
+}
+static inline bool ok_checksum(struct shm_modem *modem, void *ipctoc)
+{
+ return true;
+}
+static inline void init_data(struct shm_modem *modem, u32 offs, int ch,
+ u32 size)
+{
+}
+#endif
+
+/* write_to_shm - Write SHM Channel descriptors to SHM.
+ *
+ * Based on the configuration data channel configuration
+ * is written to the shared memory area.
+ * This is the data layout:
+ *
+ * +------------+ <---- shm_start
+ * | TOC |
+ * +------------+
+ * | Boot IMG |
+ * +------------+ <---- rw_start
+ * | RW Data |
+ * +------------+
+ * | RW Buf idx |
+ * +------------+ <---- ipctoc
+ * | IPC TOC |
+ * +------------+
+ * | RW Ch Decr |
+ * +------------+ <---- ro_start
+ * | RO Ch Decr |
+ * +------------+
+ * | RO Buf idx |
+ * +------------+
+ * | RO Data |
+ * +------------+
+ */
+
+static int write_to_shm(struct shm_modem *modem)
+{
+ int i, pri, bitno;
+ u32 offset, ro_start, rw_start, ipctoc_offs, ipcro_offs;
+ bool found;
+ struct shm_ipctoc_channel *ch;
+ struct toc_entry *toc_entry;
+ struct shm_bufidx *bix;
+
+ /*
+ * Find where to put IPC-TOC by adding up
+ * the size of Payload buffers pluss buf-indices
+ */
+ ipctoc_offs = ALIGN(modem->modem_bootimg_size, SHM_PAYL_ALIGN);
+ rw_start = ipctoc_offs;
+ for (i = 0; i < modem->channels; i++) {
+ int n = modem->channel[i]->tx.buffers;
+ ipctoc_offs += MAGIC_PAD_LEN;
+ ipctoc_offs += offsetof(struct shm_bufidx, size[n + 2]);
+ ipctoc_offs = ALIGN(ipctoc_offs, SHM_PAYL_ALIGN);
+ ipctoc_offs += MAGIC_PAD_LEN;
+ ipctoc_offs += modem->channel[i]->tx.ch_size;
+ ipctoc_offs = ALIGN(ipctoc_offs, SHM_PAYL_ALIGN);
+ }
+ add_magic_pad(&ipctoc_offs, modem->shm_start);
+ pr_debug("IPC toc @ %08x\n", ipctoc_offs);
+
+ /*
+ * Allocate the IPC-TOC and, initiatlize it.
+ * The IPC toc will be located after the RW Data and
+ * buffer indices.
+ */
+ offset = ipctoc_offs;
+ modem->ipctoc = OFFS2PTR(modem->shm_start, ipctoc_offs);
+ modem->ipctoc->magic[0] = SHM_IPCTOC_MAGIC1;
+ modem->ipctoc->magic[1] = SHM_IPCTOC_MAGIC2;
+ modem->ipctoc->version = SHM_VERSION;
+ modem->ipctoc->subver = SHM_SUBVER;
+ memset(modem->ipctoc->channel_offsets, 0,
+ sizeof(modem->ipctoc->channel_offsets));
+
+ /* Find start of first channel descriptor */
+ offset += sizeof(struct shm_ipctoc);
+
+ /*
+ * Allocate the location for the RW Channel descriptors.
+ * It will be located after the IPC-TOC.
+ */
+ offset = ALIGN(offset, SHM_ALIGNMT);
+ for (i = 0; i < modem->channels; i++) {
+ pr_debug("Channel descriptor %d RW @ 0x%08x\n", i, offset);
+ modem->ipctoc->channel_offsets[i].tx = cpu_to_le32(offset);
+ offset += sizeof(struct shm_ipctoc_channel);
+ offset = ALIGN(offset, SHM_ALIGNMT);
+ if (offset > shm_size)
+ goto badsize;
+ }
+ ro_start = offset;
+
+ /*
+ * Allocate the location for the RO Channel descriptors.
+ * It will be located after the RW Channels.
+ */
+ for (i = 0; i < modem->channels; i++) {
+ pr_debug("Channel descriptor %d RO @ 0x%08x\n", i, offset);
+ modem->ipctoc->channel_offsets[i].rx = cpu_to_le32(offset);
+ offset += sizeof(struct shm_ipctoc_channel);
+ offset = ALIGN(offset, SHM_ALIGNMT);
+ if (offset > shm_size)
+ goto badsize;
+ }
+
+ /*
+ * Allocate the location for the RO Buffer Indices.
+ * It will be located after the RO Channels.
+ */
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ ipcro_offs = offset;
+ for (i = 0; i < modem->channels; i++) {
+ int n = modem->channel[i]->rx.buffers;
+ ch = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].rx);
+ add_magic_pad(&offset, modem->shm_start);
+ ch->ipc = cpu_to_le32(offset);
+
+ bix = OFFS2PTR(modem->shm_start, offset);
+ bix->read_index = cpu_to_le32(0);
+ bix->write_index = cpu_to_le32(0);
+ bix->state = cpu_to_le32(SHM_CLOSED);
+ bix->size[0] = cpu_to_le32(0);
+
+ pr_debug("IPC RO[%d] @: 0x%08x\n", i, offset);
+ offset += offsetof(struct shm_bufidx, size[n + 2]);
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ if (offset > shm_size)
+ goto badsize;
+ }
+
+ /*
+ * Allocate RO Data Area. This will located after
+ * the RO Buffer Indices at the end of the Share Memory
+ * area.
+ */
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ for (i = 0; i < modem->channels; i++) {
+ u8 align;
+ u32 size;
+ ch = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].rx);
+ add_magic_pad(&offset, modem->shm_start);
+ ch->offset = cpu_to_le32(offset);
+
+ BUILD_BUG_ON(sizeof(ch->mode) != 1);
+ ch->mode = modem->channel[i]->mode & SHM_MODE_MASK;
+ ch->buffers = cpu_to_le32(modem->channel[i]->rx.buffers);
+ align = rounddown_pow_of_two(modem->channel[i]->rx.alignment);
+ ch->alignment = align;
+ ch->packets = modem->channel[i]->rx.packets;
+ ch->mtu = modem->channel[i]->rx.mtu;
+ size = modem->channel[i]->tx.ch_size;
+ if (modem->channel[i]->mode & SHM_PACKET_MODE) {
+ u32 buf_size;
+ buf_size = size / modem->channel[i]->tx.buffers;
+ buf_size = rounddown(buf_size, align);
+ size = buf_size * modem->channel[i]->tx.buffers;
+ }
+ pr_debug("Buffer area RO for Channel[%d] at: 0x%08x size:%d\n",
+ i, offset, size);
+ ch->size = cpu_to_le32(size);
+
+ init_data(modem->shm_start, offset, i,
+ modem->channel[i]->rx.ch_size);
+ offset += modem->channel[i]->rx.ch_size;
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ if (offset > shm_size)
+ goto badsize;
+ }
+
+ /*
+ * Allocate RW Data Area. This will located in the beginning
+ * just after the Modem Boot Image.
+ */
+ offset = rw_start;
+ for (i = 0; i < modem->channels; i++) {
+ u8 align;
+ u32 size;
+ ch = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].tx);
+ add_magic_pad(&offset, modem->shm_start);
+ ch->offset = cpu_to_le32(offset);
+ init_data(modem->shm_start, offset, i,
+ modem->channel[i]->tx.ch_size);
+ ch->mode = modem->channel[i]->mode &
+ SHM_MODE_MASK;
+ ch->buffers = cpu_to_le32(modem->channel[i]->tx.buffers);
+ align = rounddown_pow_of_two(modem->channel[i]->rx.alignment);
+ ch->alignment = align;
+ ch->packets = modem->channel[i]->rx.packets;
+ ch->mtu = modem->channel[i]->rx.mtu;
+ size = modem->channel[i]->tx.ch_size;
+ if (modem->channel[i]->mode & SHM_PACKET_MODE) {
+ u32 buf_size;
+ buf_size = size / modem->channel[i]->tx.buffers;
+ buf_size = rounddown(buf_size, align);
+ size = buf_size * modem->channel[i]->tx.buffers;
+ }
+ ch->size = cpu_to_le32(size);
+ pr_debug("Buffer area RW for Channel[%d] at: 0x%08x size:%d\n",
+ i, offset, size);
+ offset += modem->channel[i]->tx.ch_size;
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ if (offset > ro_start)
+ goto badsize;
+ }
+
+ /*
+ * Allocate RW IPC Area. This will located after RW data area,
+ * just before the IPC-TOC.
+ */
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ for (i = 0; i < modem->channels; i++) {
+ int n = modem->channel[i]->tx.buffers;
+ ch = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].tx);
+ add_magic_pad(&offset, modem->shm_start);
+ ch->ipc = cpu_to_le32(offset);
+ bix = OFFS2PTR(modem->shm_start, offset);
+ bix->read_index = cpu_to_le32(0);
+ bix->write_index = cpu_to_le32(0);
+ bix->state = cpu_to_le32(SHM_CLOSED);
+ bix->size[0] = cpu_to_le32(0);
+
+ pr_debug("IPC RW[%d] @: 0x%08x\n", i, offset);
+ offset += offsetof(struct shm_bufidx, size[n + 2]);
+ offset = ALIGN(offset, SHM_PAYL_ALIGN);
+ if (offset > shm_size)
+ goto badsize;
+ }
+
+ /* Allocate genio bits for each channel according to priority*/
+ bitno = 0;
+ for (pri = 0; pri < 8; pri++) {
+ for (i = 0; i < modem->channels; i++) {
+ if (modem->channel[i]->priority == pri) {
+ ch = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].tx);
+ ch->write_bit = cpu_to_le16(bitno * 4);
+ ch->read_bit = cpu_to_le16(bitno * 4 + 2);
+ ch = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].rx);
+ ch->write_bit = cpu_to_le16(bitno * 4 + 1);
+ ch->read_bit = cpu_to_le16(bitno * 4 + 3);
+ bitno++;
+ }
+ }
+ }
+
+ /*
+ * The Master TOC points out the boot images for the modem,
+ * Use the first avilable entry in the toc to write the pointer,
+ * to the IPC-TOC defined above.
+ */
+ found = false;
+ for (toc_entry = modem->shm_start, i = 0; i < 16; i++, toc_entry++)
+ if (toc_entry->start == cpu_to_le32(0xffffffff)) {
+ pr_debug("IPCTOC address written into Master TOC"
+ " @ 0x%08x\n", i * 32);
+ toc_entry->start =
+ cpu_to_le32(GET_OFFSET(modem->shm_start,
+ modem->ipctoc));
+ toc_entry->size = cpu_to_le32(0);
+ toc_entry->flags = cpu_to_le32(0);
+ toc_entry->entry_point = cpu_to_le32(0);
+ toc_entry->load_addr = cpu_to_le32(0xffffffff);
+ memset(toc_entry->name, 0, sizeof(toc_entry->name));
+ sprintf(toc_entry->name, "ipc-toc");
+ found = true;
+ break;
+ }
+ if (!found) {
+ pr_debug("Cannot insert IPC-TOC in toc\n");
+ goto bad_config;
+ }
+
+ store_checksum(modem, ipcro_offs - ipctoc_offs);
+
+ return 0;
+
+badsize:
+ pr_debug("IPCTOC not enough space offset (size:0x%lx offset:0x%x\n",
+ shm_size, offset);
+ return -ENOSPC;
+
+bad_config:
+ pr_debug("IPCTOC bad configuration data\n");
+ return -EINVAL;
+}
+
+static int shm_verify_config(struct shm_modem *modem,
+ struct shm_channel *xcfg)
+{
+ int j;
+ u32 size;
+
+ if (modem->channels <= 0 || modem->channels > SHM_MAX_CHANNELS) {
+ pr_debug("Bad config: channel mode must be set\n");
+ return -EINVAL;
+ }
+
+ if ((xcfg->mode & SHM_MODE_MASK) != SHM_PACKET_MODE &&
+ (xcfg->mode & SHM_MODE_MASK) != SHM_STREAM_MODE) {
+ pr_debug("Bad config: channel mode must be set\n");
+ return -EINVAL;
+ }
+ if (xcfg->mode & SHM_PACKET_MODE && xcfg->rx.buffers < 2) {
+ pr_debug("Bad config:minimum 2 buffers "
+ "must be set for packet mode\n");
+ return -EINVAL;
+ }
+
+ if (xcfg->rx.ch_size < SHM_MIN_CHSZ) {
+ pr_debug("Bad config:"
+ "Channel size must be larger than %d\n",
+ SHM_MIN_CHSZ);
+ return -EINVAL;
+ }
+
+ if (xcfg->mode & SHM_PACKET_MODE) {
+ if (xcfg->tx.buffers < 2) {
+ pr_debug("Bad config:"
+ "buffers must be minimum 2 packet mode\n");
+ return -EINVAL;
+ }
+ if (xcfg->tx.packets < 1) {
+ pr_debug("Bad config:"
+ "packets must be set for packet mode\n");
+ return -EINVAL;
+ }
+ }
+
+ if (xcfg->tx.ch_size < SHM_MIN_CHSZ) {
+ pr_debug("Bad config:"
+ "Channel size must be larger than %d\n",
+ SHM_MIN_CHSZ);
+ return -EINVAL;
+ }
+
+ if (xcfg->name[0] == '\0') {
+ pr_debug("Channel must be named\n");
+ return -EINVAL;
+ }
+
+ size = modem->modem_bootimg_size;
+
+ for (j = 0; j < modem->channels; j++) {
+ struct shm_channel *xcfg2 = modem->channel[j];
+ size = xcfg2->tx.ch_size + xcfg2->rx.ch_size;
+ if (xcfg != xcfg2 && strcmp(xcfg->name, xcfg2->name) == 0) {
+ pr_debug("Channels has same name:%s\n",
+ xcfg->name);
+ return -EINVAL;
+ }
+ }
+
+ if (size > shm_size) {
+ pr_debug("Channel size too big\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int verify_config(struct shm_modem *modem)
+{
+ int i;
+
+ if (modem->channels == 0) {
+ pr_debug("Bad config: minimum one channel must be defined\n");
+ return -EINVAL;
+ }
+ for (i = 0; i < modem->channels; i++) {
+ int err = shm_verify_config(modem, modem->channel[i]);
+ if (err)
+ return err;
+ }
+ return 0;
+}
+
+/*
+ * Create Configuration data for the shm devices.
+ */
+static void create_devs(struct shm_modem *modem)
+{
+ int i;
+
+ for (i = 0; i < modem->channels; i++) {
+ struct shm_bufidx *buf_rx, *buf_tx;
+ struct shm_ipctoc_channel *ch_rx, *ch_tx;
+ struct shm_channel *xcfg = modem->channel[i];
+ ch_rx = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].rx);
+ buf_rx = LEOFFS2PTR(modem->shm_start, ch_rx->ipc);
+ ch_tx = LEOFFS2PTR(modem->shm_start,
+ modem->ipctoc->channel_offsets[i].tx);
+ buf_tx = LEOFFS2PTR(modem->shm_start, ch_tx->ipc);
+
+ /*
+ * Due to restricted read-only access
+ * we swap positions for read/write
+ * pointers.
+ */
+ xcfg->tx.write = &buf_tx->write_index;
+ xcfg->tx.read = &buf_rx->read_index;
+
+ xcfg->rx.write = &buf_rx->write_index;
+ xcfg->rx.read = &buf_tx->read_index;
+
+ xcfg->rx.addr = LEOFFS2PTR(modem->shm_start, ch_rx->offset);
+ xcfg->tx.addr = LEOFFS2PTR(modem->shm_start, ch_tx->offset);
+ xcfg->rx.state = &buf_rx->state;
+ xcfg->tx.state = &buf_tx->state;
+ xcfg->tx.buf_size = buf_tx->size;
+ xcfg->rx.buf_size = buf_rx->size;
+
+ xcfg->rx.xfer_bit = le16_to_cpu(ch_rx->write_bit);
+ xcfg->tx.xfer_bit = le16_to_cpu(ch_tx->write_bit);
+ xcfg->rx.xfer_done_bit = le16_to_cpu(ch_rx->read_bit);
+ xcfg->tx.xfer_done_bit = le16_to_cpu(ch_tx->read_bit);
+
+ if (xcfg->mode & SHM_PAIR_MODE) {
+ struct shm_channel *pair;
+ pr_debug("Channel[%d] is in PAIR mode\n", i);
+ if (i < 1) {
+ pr_debug("No channel to pair with\n");
+ continue;
+ }
+ /* Cross couple rx/tx on the pair */
+ pair = modem->channel[i - 1];
+
+ /* Copy everything but the kobj which is at the end */
+ memcpy(&xcfg->tx, &pair->rx,
+ offsetof(struct shm_udchannel, kobj));
+ memcpy(&xcfg->rx, &pair->tx,
+ offsetof(struct shm_udchannel, kobj));
+ } else if (xcfg->mode & SHM_LOOP_MODE) {
+ pr_debug("Channel[%d] is in LOOP mode\n", i);
+ /*
+ * Connect rx/tx in a pair. Copy everything,
+ * but the kobj which is at the end
+ */
+ memcpy(&xcfg->tx, &xcfg->rx,
+ offsetof(struct shm_udchannel, kobj));
+ }
+
+ pr_devel("RX[%d] wi:%p ri:%p\n", i, xcfg->rx.read,
+ xcfg->rx.write);
+ pr_devel("TX[%d] wi:%p ri:%p\n", i, xcfg->tx.read,
+ xcfg->tx.write);
+ }
+}
+
+struct shm_modem *modem;
+
+struct shm_modem *get_modem(struct sk_buff *skb, struct genl_info *info)
+{
+ return modem;
+}
+
+static int do_commit(struct shm_modem *modem)
+{
+ int err;
+
+ if (modem->config_error) {
+ pr_devel("config error detected\n");
+ return -EINVAL;
+ }
+
+ if (modem->commited) {
+ pr_devel("already commited\n");
+ modem->config_error = true;
+ return -EINVAL;
+ }
+ err = verify_config(modem);
+ if (err) {
+ pr_devel("bad config\n");
+ modem->config_error = true;
+ return err;
+ }
+ err = write_to_shm(modem);
+ if (err) {
+ pr_devel("writei to SHM failed\n");
+ modem->config_error = true;
+ return err;
+ }
+ modem->commited = true;
+ create_devs(modem);
+ return 0;
+}
+
+static int do_register(struct shm_modem *modem)
+{
+ int err;
+
+ if (!modem->commited || modem->registered || modem->config_error) {
+ pr_devel("bad sequence of requests\n");
+ modem->config_error = true;
+ return -EINVAL;
+ }
+
+ err = verify_config(modem);
+ if (err) {
+ modem->config_error = true;
+ pr_devel("bad config\n");
+ return err;
+ }
+ modem->registered = true;
+
+ modem_shm_register_devices(modem->channel, modem->channels);
+
+ return 0;
+}
+
+static void shm_firmware(const struct firmware *fw, void *context)
+{
+ struct shm_modem *modem = context;
+ struct toc_entry *toc_entry;
+ int i;
+
+ modem->fw_requested = false;
+
+ pr_debug("recevied firmware\n");
+ if (fw == NULL) {
+ pr_warn("No boot-img provided\n");
+ goto out;
+ }
+
+ if (modem->commited) {
+ pr_warn("Received firmware too late in modem boot\n");
+ goto out;
+ }
+
+ toc_entry = (void *)fw->data;
+ if (fw->size < TOC_SZ) {
+ pr_debug("Modem image too short\n");
+ goto bad_img;
+ }
+
+ for (i = 0; i < 16; i++, toc_entry++)
+ if (toc_entry->start == cpu_to_le32(0xffffffff))
+ break;
+
+ if (i == 0) {
+ pr_debug("Empty TOC in firmware image\n");
+ goto bad_img;
+ }
+
+ if (i >= 15) {
+ pr_debug("No free slot for IPC-TOC in received image\n");
+ goto bad_img;
+ }
+
+ modem->modem_bootimg_size = fw->size;
+ memcpy(modem->shm_start, fw->data, fw->size);
+out:
+ release_firmware(fw);
+ return;
+bad_img:
+ pr_warn("Bad modem firmware received\n");
+ modem->config_error = true;
+ release_firmware(fw);
+}
+
+static void do_reset(struct shm_modem *modem)
+{
+ int i;
+
+ modem_shm_reset();
+ modem->config_error = false;
+ modem->registered = false;
+ modem->commited = false;
+ modem->addr_set = false;
+ modem->modem_bootimg_size = TOC_SZ;
+ for (i = 0; i < modem->channels; i++) {
+ kfree(modem->channel[i]);
+ modem->channel[i] = NULL;
+ }
+ modem->channels = 0;
+
+ /* Initiate the Master TOC to 0xff for the first 512 bytes */
+ memset(modem->shm_start, 0xff, TOC_SZ);
+
+ if (!modem->fw_requested)
+ modem_shm_request_firmware(modem, THIS_MODULE,
+ STE_BOOTIMG_NAME, shm_firmware);
+ modem->fw_requested = true;
+}
+
+static int do_set_addr(struct shm_modem *modem)
+{
+ int err;
+ if (!modem->commited || modem->addr_set || modem->config_error) {
+ pr_devel("bad sequence of requests\n");
+ modem->config_error = true;
+ return -EINVAL;
+ }
+ err = verify_config(modem);
+ if (err) {
+ modem->config_error = true;
+ pr_devel("bad config\n");
+ return err;
+ }
+ modem->addr_set = true;
+ return genio_set_shm_addr(shm_c2c_bootaddr, genio_ipc_ready_cb);
+}
+
+static int copy_name(const char *src, char *d, size_t count)
+{
+ const char *s, *end = src + count;
+ for (s = src; *s && s < end; s++, d++)
+ if (*s == '\0' || *s == '\n')
+ break;
+ else if (!isalnum(*s)) {
+ pr_debug("Illegal chr:'%c' in name:'%s'\n", *s, src);
+ return -EINVAL;
+ } else if (s - src >= SHM_NAMESZ - 1) {
+ pr_debug("Name '%s'too long\n", src);
+ return -EINVAL;
+ } else
+ *d = *s;
+ *d = '\0';
+
+ return count;
+}
+
+/* SHM Generic NETLINK family */
+static struct genl_family shm_gnl_family = {
+ .id = GENL_ID_GENERATE,
+ .hdrsize = 0,
+ .name = "modem_shm",
+ .version = SHM_PROTO_VERSION,
+ .maxattr = SHM_A_MAX,
+};
+
+/* SHM Netlink attribute policy */
+static const struct nla_policy shm_genl_policy[SHM_A_MAX + 1] = {
+ [SHM_A_VERSION] = { .type = NLA_U8 },
+ [SHM_A_SUB_VERSION] = { .type = NLA_U8 },
+ [__SHM_A_FLAGS] = { .type = NLA_U32 },
+ [SHM_A_NAME] = { .type = NLA_NUL_STRING, .len = SHM_NAMESZ},
+ [SHM_A_RX_CHANNEL] = { .type = NLA_NESTED },
+ [SHM_A_TX_CHANNEL] = { .type = NLA_NESTED },
+ [SHM_A_PRIORITY] = { .type = NLA_U8 },
+ [SHM_A_LATENCY] = { .type = NLA_U8 },
+};
+
+/* Policy for uni-directional attributes for stream */
+static const struct nla_policy stream_policy[SHM_A_MAX + 1] = {
+ [SHM_A_CHANNEL_SIZE] = { .type = NLA_U32 },
+};
+
+/* Policy for uni-directional attributes for packet */
+static const struct nla_policy packet_policy[SHM_A_MAX + 1] = {
+ [SHM_A_CHANNEL_SIZE] = { .type = NLA_U32 },
+ [SHM_A_CHANNEL_BUFFERS] = { .type = NLA_U32 },
+ [SHM_A_MTU] = { .type = NLA_U16 },
+ [SHM_A_ALIGNMENT] = { .type = NLA_U8 },
+ [SHM_A_PACKETS] = { .type = NLA_U8 },
+};
+
+static int shm_add_udchannel(struct shm_udchannel *chn, int attr,
+ struct genl_info *info, struct nla_policy const *policy)
+{
+ struct nlattr *nla;
+ int nla_rem;
+
+ if (!info->attrs[attr])
+ return -EINVAL;
+
+ if (nla_validate_nested(info->attrs[attr],
+ SHM_A_MAX,
+ policy) != 0) {
+ pr_info("Invalid RX channel attributes\n");
+ return -EINVAL;
+ }
+
+ nla_for_each_nested(nla, info->attrs[attr], nla_rem) {
+
+ if (nla_type(nla) == SHM_A_CHANNEL_SIZE)
+ chn->ch_size = nla_get_u32(nla);
+
+ if (nla_type(nla) == SHM_A_CHANNEL_BUFFERS)
+ chn->buffers = nla_get_u32(nla);
+
+ if (nla_type(nla) == SHM_A_MTU)
+ chn->mtu = nla_get_u16(nla);
+
+ if (nla_type(nla) == SHM_A_PACKETS)
+ chn->packets = nla_get_u8(nla);
+
+ if (nla_type(nla) == SHM_A_ALIGNMENT) {
+ chn->alignment = nla_get_u8(nla);
+ chn->alignment = rounddown_pow_of_two(chn->alignment);
+ }
+
+ }
+ return 0;
+}
+
+static int shm_add_channel(struct shm_channel *cfg, struct genl_info *info,
+ int mode)
+{
+ int len, err;
+ struct nla_policy const *policy;
+ char name[SHM_NAMESZ];
+
+ policy = (mode == SHM_PACKET_MODE) ? packet_policy : stream_policy;
+
+ if (info->attrs[SHM_A_VERSION]) {
+ u8 version;
+ u8 sub_version;
+
+ version = nla_get_u8(info->attrs[SHM_A_VERSION]);
+ if (!info->attrs[SHM_A_SUB_VERSION])
+ return -EINVAL;
+ sub_version = nla_get_u8(info->attrs[SHM_A_SUB_VERSION]);
+ if (version != 1 || sub_version != 0) {
+ pr_info("Bad version or sub_version\n");
+ return -EINVAL;
+ }
+ }
+
+ if (!info->attrs[SHM_A_NAME]) {
+ pr_debug("Name not specified\n");
+ return -EINVAL;
+ }
+
+ len = nla_strlcpy(name, info->attrs[SHM_A_NAME],
+ SHM_NAMESZ);
+
+ if (len > SHM_NAMESZ)
+ return -EINVAL;
+
+ err = copy_name(name, cfg->name, sizeof(name));
+ if (err < 0)
+ return err;
+
+ cfg->excl_group = 1;
+ if (info->attrs[SHM_A_EXCL_GROUP])
+ cfg->excl_group = nla_get_u8(info->attrs[SHM_A_EXCL_GROUP]);
+
+ err = shm_add_udchannel(&cfg->rx, SHM_A_RX_CHANNEL, info, policy);
+ if (err)
+ return err;
+
+ err = shm_add_udchannel(&cfg->tx, SHM_A_TX_CHANNEL, info, policy);
+ if (err)
+ return err;
+
+ if (cfg->tx.ch_size + cfg->rx.ch_size > shm_size) {
+ pr_debug("Channel size too big\n");
+ return -EINVAL;
+ }
+
+ if (info->attrs[SHM_A_PRIORITY]) {
+ cfg->priority = nla_get_u8(info->attrs[SHM_A_PRIORITY]);
+ /* silently fixup bad value */
+ if (cfg->priority > 7)
+ cfg->priority = 0;
+ }
+
+ if (info->attrs[SHM_A_LATENCY])
+ cfg->latency = nla_get_u8(info->attrs[SHM_A_LATENCY]);
+
+ if (info->attrs[__SHM_A_FLAGS])
+ cfg->mode |= nla_get_u32(info->attrs[__SHM_A_FLAGS]);
+
+ return 0;
+}
+
+static int do_reply(struct genl_info *info, int result)
+{
+ struct sk_buff *msg;
+ int err;
+ void *reply;
+
+ msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+ if (msg == NULL)
+ return -ENOMEM;
+
+ reply = genlmsg_put_reply(msg, info, &shm_gnl_family, 0, result);
+ if (reply == NULL) {
+ kfree_skb(msg);
+ return -EMSGSIZE;
+ }
+
+ genlmsg_end(msg, reply);
+ err = genlmsg_reply(msg, info);
+ return err;
+}
+
+static int shm_add_ch(struct sk_buff *skb, struct genl_info *info, int mode)
+{
+ int err;
+ struct shm_channel *cfg;
+ struct shm_modem *modem = get_modem(skb, info);
+ if (!modem)
+ return -EINVAL;
+
+ if (modem->channels + 1 > SHM_MAX_CHANNELS) {
+ pr_debug("Too many channels added\n");
+ return -EINVAL;
+ }
+
+
+ cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
+ if (cfg == NULL)
+ return -ENOMEM;
+
+ cfg->mode = mode;
+ err = shm_add_channel(cfg, info, mode);
+ if (err)
+ goto error;
+
+ modem->channel[modem->channels] = cfg;
+ ++modem->channels;
+
+ err = shm_verify_config(modem, cfg);
+ if (err)
+ goto error_remove;
+
+ err = do_reply(info, 0);
+ if (err)
+ goto error_remove;
+ return err;
+
+error_remove:
+ --modem->channels;
+error:
+ kfree(cfg);
+ return err;
+}
+
+static int shm_add_packet_ch(struct sk_buff *skb, struct genl_info *info)
+{
+ return shm_add_ch(skb, info, SHM_PACKET_MODE);
+}
+
+static int shm_add_stream_ch(struct sk_buff *skb, struct genl_info *info)
+{
+ return shm_add_ch(skb, info, SHM_STREAM_MODE);
+}
+
+
+static int shm_c_commit(struct sk_buff *skb, struct genl_info *info)
+{
+ struct shm_modem *modem = get_modem(skb, info);
+ int err;
+ if (!modem)
+ return -EINVAL;
+
+ err = do_commit(modem);
+ if (!err)
+ do_reply(info, 0);
+ return err;
+}
+
+static int shm_c_register(struct sk_buff *skb, struct genl_info *info)
+{
+ int err;
+ struct shm_modem *modem = get_modem(skb, info);
+ if (!modem)
+ return -EINVAL;
+
+ err = do_register(modem);
+ if (!err)
+ do_reply(info, 0);
+ return err;
+}
+
+static int shm_c_set_addr(struct sk_buff *skb, struct genl_info *info)
+{
+ int err;
+ struct shm_modem *modem = get_modem(skb, info);
+ if (!modem)
+ return -EINVAL;
+
+ err = do_set_addr(modem);
+ if (!err)
+ do_reply(info, 0);
+ return err;
+}
+
+static int shm_c_reset(struct sk_buff *skb, struct genl_info *info)
+{
+ struct shm_modem *modem = get_modem(skb, info);
+ if (!modem)
+ return -EINVAL;
+
+ do_reset(modem);
+ do_reply(info, 0);
+ return 0;
+}
+
+static int shm_c_verify(struct sk_buff *skb, struct genl_info *info)
+{
+ int err;
+ struct shm_modem *modem = get_modem(skb, info);
+ if (!modem)
+ return -EINVAL;
+
+ err = verify_config(modem);
+ if (!err)
+ do_reply(info, 0);
+ return err;
+}
+
+static struct genl_ops shm_genl_ops[] = {
+ {
+ .cmd = SHM_C_ADD_STREAM_CHANNEL,
+ .flags = GENL_ADMIN_PERM,
+ .policy = shm_genl_policy,
+ .doit = shm_add_stream_ch,
+ .dumpit = NULL,
+ },
+ {
+ .cmd = SHM_C_ADD_PACKET_CHANNEL,
+ .flags = GENL_ADMIN_PERM,
+ .policy = shm_genl_policy,
+ .doit = shm_add_packet_ch,
+ .dumpit = NULL,
+ },
+ {
+ .cmd = SHM_C_COMMIT,
+ .flags = GENL_ADMIN_PERM,
+ .doit = shm_c_commit,
+ .dumpit = NULL,
+ },
+ {
+ .cmd = SHM_C_REGISTER,
+ .flags = GENL_ADMIN_PERM,
+ .doit = shm_c_register,
+ .dumpit = NULL,
+ },
+ {
+ .cmd = SHM_C_SET_ADDR,
+ .flags = GENL_ADMIN_PERM,
+ .doit = shm_c_set_addr,
+ .dumpit = NULL,
+ },
+ {
+ .cmd = SHM_C_RESET,
+ .flags = GENL_ADMIN_PERM,
+ .doit = shm_c_reset,
+ .dumpit = NULL,
+ },
+ {
+ .cmd = __SHM_C_VERIFY,
+ .flags = GENL_ADMIN_PERM,
+ .doit = shm_c_verify,
+ .dumpit = NULL,
+ },
+
+};
+
+/* Initialize boot handling and create sysfs entries*/
+int __init shm_boot_init(void)
+{
+ int err = -EINVAL;
+ bool shm_fake = false;
+
+ modem = kzalloc(sizeof(struct shm_modem), GFP_KERNEL);
+ if (modem == NULL)
+ return -ENOMEM;
+
+ /* Negative shm_size indicates module test without real SHM */
+ if (shm_size < 0) {
+ shm_fake = true;
+ shm_size = abs(shm_size);
+ }
+
+ if (shm_size < TOC_SZ)
+ goto bad_config;
+
+ if (shm_fake) {
+ modem->shm_start = kzalloc(shm_size, GFP_KERNEL);
+ err = -ENOMEM;
+ if (!modem->shm_start)
+ goto error;
+ shm_start = (unsigned long) modem->shm_start;
+ memset(modem->shm_start, 0xaa, shm_size);
+ } else {
+ if (shm_start == 0)
+ goto bad_config;
+ modem->shm_start = ioremap(shm_start, shm_size);
+ }
+
+ /* Initiate the Master TOC to 0xff for the first 512 bytes */
+ if (shm_size > TOC_SZ)
+ memset(modem->shm_start, 0xff, TOC_SZ);
+
+ modem->modem_bootimg_size = TOC_SZ;
+
+ pr_debug("Boot image addr: %p size:%d\n", modem->shm_start,
+ modem->modem_bootimg_size);
+
+ err = genl_register_family_with_ops(&shm_gnl_family,
+ shm_genl_ops, ARRAY_SIZE(shm_genl_ops));
+ if (err)
+ goto error;
+
+ modem->gennetl_reg = true;
+ modem->fw_requested = true;
+ err = modem_shm_request_firmware(modem, THIS_MODULE,
+ STE_BOOTIMG_NAME, shm_firmware);
+ if (err)
+ goto error;
+
+ return err;
+error:
+ pr_debug("initialization failed\n");
+
+ if (shm_fake)
+ kfree(modem->shm_start);
+ return err;
+bad_config:
+ pr_err("Bad module configuration:"
+ " shm_base_address:%lu shm_size:%lu err:%d\n",
+ shm_start, shm_size, err);
+ /* Buildin module should not return error */
+ return -EINVAL;
+}
+
+void __exit shm_boot_exit(void)
+{
+
+ if (modem->gennetl_reg)
+ genl_unregister_family(&shm_gnl_family);
+ modem->gennetl_reg = false;
+}
+module_init(shm_boot_init);
+module_exit(shm_boot_exit);
--
1.7.0.4
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

\
 
 \ /
  Last update: 2012-01-31 09:51    [from the cache]
©2003-2011 Jasper Spaans