>From 80d279ec11492ca6729f1421983f52b8e7144cd4 Mon Sep 17 00:00:00 2001
From: Doron Cohen <[email protected]>
Date: Sun, 25 Sep 2011 17:47:12 +0300
Subject: [PATCH v2] Add smsspi driver to support Siano SPI connected
device
using SPI generic driver
modified: drivers/media/dvb/siano/smsspidrv.c
modified: drivers/media/dvb/siano/smsspiphy.c
new file: drivers/media/dvb/siano/smsspidrv.c
new file: drivers/media/dvb/siano/smsspiphy.c
new file: drivers/media/dvb/siano/smsspidrv.c
new file: drivers/media/dvb/siano/smsspiphy.c
new file: drivers/media/dvb/siano/smsspiphy.h
modified: drivers/media/dvb/siano/Kconfig
new file: drivers/media/dvb/siano/smsspiphy.c
Signed-off-by: Doron Cohen <[email protected]>
---
drivers/media/dvb/siano/Kconfig | 23 ++
drivers/media/dvb/siano/Makefile | 2 +
drivers/media/dvb/siano/smscoreapi.c | 2 +-
drivers/media/dvb/siano/smsdbg_prn.h | 56 ++++
drivers/media/dvb/siano/smsspicommon.c | 407
+++++++++++++++++++++++++++
drivers/media/dvb/siano/smsspicommon.h | 96 +++++++
drivers/media/dvb/siano/smsspidrv.c | 472
++++++++++++++++++++++++++++++++
drivers/media/dvb/siano/smsspiphy.c | 218 +++++++++++++++
drivers/media/dvb/siano/smsspiphy.h | 38 +++
9 files changed, 1313 insertions(+), 1 deletions(-)
create mode 100644 drivers/media/dvb/siano/smsdbg_prn.h
create mode 100644 drivers/media/dvb/siano/smsspicommon.c
create mode 100644 drivers/media/dvb/siano/smsspicommon.h
create mode 100644 drivers/media/dvb/siano/smsspidrv.c
create mode 100644 drivers/media/dvb/siano/smsspiphy.c
create mode 100644 drivers/media/dvb/siano/smsspiphy.h
diff --git a/drivers/media/dvb/siano/Kconfig
b/drivers/media/dvb/siano/Kconfig
index bc6456e..a47a131 100644
--- a/drivers/media/dvb/siano/Kconfig
+++ b/drivers/media/dvb/siano/Kconfig
@@ -17,6 +17,15 @@ config SMS_SIANO_MDTV
if SMS_SIANO_MDTV
menu "Siano module components"
+# Kernel sub systems support
+
+config SMS_NET_SUBSYS
+ tristate "Siano Network Adapter"
+ depends on NET
+ default n
+ ---help---
+ Choose if you would like to have Siano's network adapter
support.
+
# Hardware interfaces support
config SMS_USB_DRV
@@ -30,5 +39,19 @@ config SMS_SDIO_DRV
depends on DVB_CORE && MMC
---help---
Choose if you would like to have Siano's support for SDIO
interface
+
+config SMS_SPI_DRV
+ tristate "SPI interface support"
+ depends on SPI
+ default y if SPI
+ ---help---
+ Choose if you would like to have Siano's support for SPI
interface
+
+config SMS_I2C_DRV
+ tristate "I2C interface support"
+ depends on DVB_CORE && I2C
+ ---help---
+ Choose if you would like to have Siano's support for I2C
interface
+
endmenu
endif # SMS_SIANO_MDTV
diff --git a/drivers/media/dvb/siano/Makefile
b/drivers/media/dvb/siano/Makefile
index c54140b..affaf01 100644
--- a/drivers/media/dvb/siano/Makefile
+++ b/drivers/media/dvb/siano/Makefile
@@ -1,9 +1,11 @@
smsmdtv-objs := smscoreapi.o sms-cards.o smsendian.o smsir.o
+smsspi-objs := smsspicommon.o smsspidrv.o smsspiphy.o
obj-$(CONFIG_SMS_SIANO_MDTV) += smsmdtv.o smsdvb.o
obj-$(CONFIG_SMS_USB_DRV) += smsusb.o
obj-$(CONFIG_SMS_SDIO_DRV) += smssdio.o
+obj-$(CONFIG_SMS_SPI_DRV) += smsspi.o
EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
diff --git a/drivers/media/dvb/siano/smscoreapi.c
b/drivers/media/dvb/siano/smscoreapi.c
index 78765ed..239f453 100644
--- a/drivers/media/dvb/siano/smscoreapi.c
+++ b/drivers/media/dvb/siano/smscoreapi.c
@@ -39,7 +39,7 @@
#include "smsir.h"
#include "smsendian.h"
-static int sms_dbg;
+int sms_dbg;
module_param_named(debug, sms_dbg, int, 0644);
MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
diff --git a/drivers/media/dvb/siano/smsdbg_prn.h
b/drivers/media/dvb/siano/smsdbg_prn.h
new file mode 100644
index 0000000..ea157da
--- /dev/null
+++ b/drivers/media/dvb/siano/smsdbg_prn.h
@@ -0,0 +1,56 @@
+/****************************************************************
+
+Siano Mobile Silicon, Inc.
+MDTV receiver kernel modules.
+Copyright (C) 2006-2008, Uri Shkolnik
+
+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.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************/
+
+#ifndef _SMS_DBG_H_
+#define _SMS_DBG_H_
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+/**********************************************************************
**/
+/* Debug Zones definitions.
*/
+/**********************************************************************
**/
+#undef PERROR
+# define PERROR(fmt, args...) \
+ printk(KERN_ERR "spibus error: line %d- %s(): " fmt, __LINE__,\
+ __func__, ## args)
+#undef PWARNING
+# define PWARNING(fmt, args...) \
+ printk(KERN_WARNING "spibus warning: line %d- %s(): " fmt,
__LINE__, \
+ __func__, ## args)
+
+/* the debug macro - conditional compilation from the makefile */
+#undef PDEBUG /* undef it, just in case */
+#ifdef SPIBUS_DEBUG
+# define PDEBUG(fmt, args...) \
+ printk(KERN_DEBUG "spibus: line %d- %s(): " fmt, __LINE__, \
+ __func__, ## args)
+#else
+# define PDEBUG(fmt, args...) /* not debugging: nothing */
+#endif
+
+/* The following defines are used for printing and
+are mandatory for compilation. */
+#define TXT(str) str
+#define PRN_DBG(str) PDEBUG str
+#define PRN_ERR(str) PERROR str
+
+#endif /*_SMS_DBG_H_*/
diff --git a/drivers/media/dvb/siano/smsspicommon.c
b/drivers/media/dvb/siano/smsspicommon.c
new file mode 100644
index 0000000..9fd9508
--- /dev/null
+++ b/drivers/media/dvb/siano/smsspicommon.c
@@ -0,0 +1,407 @@
+/****************************************************************
+
+Siano Mobile Silicon, Inc.
+MDTV receiver kernel modules.
+Copyright (C) 2006-2008, Uri Shkolnik
+
+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.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************/
+#include "smsspicommon.h"
+#include "smsdbg_prn.h"
+
+static struct _rx_buffer_st *smsspi_handle_unused_bytes_buf(
+ struct _spi_dev *dev,
+ struct _rx_buffer_st *buf, int offset, int len,
+ int unused_bytes)
+{
+ struct _rx_buffer_st *tmp_buf;
+ tmp_buf = dev->cb.allocate_rx_buf(dev->context,
+ RX_PACKET_SIZE);
+ if (!tmp_buf) {
+ PRN_ERR((TXT
+ ("Failed to allocate RX buffer.\n")));
+ return NULL;
+ }
+ if (unused_bytes > 0) {
+ /* Copy the remaining bytes to the end of
+ alignment block (256 bytes) so next read
+ will be aligned. */
+ int align_block =
+ (((unused_bytes + SPI_PACKET_SIZE -
+ 1) >> SPI_PACKET_SIZE_BITS) <<
+ SPI_PACKET_SIZE_BITS);
+ memset(tmp_buf->ptr, 0,
+ align_block - unused_bytes);
+ memcpy((char *)tmp_buf->ptr +
+ (align_block - unused_bytes),
+ (char *)buf->ptr + offset + len -
+ unused_bytes, unused_bytes);
+ }
+ return tmp_buf;
+}
+
+static struct _rx_buffer_st *smsspi_common_find_msg(struct _spi_dev
*dev,
+ struct _rx_buffer_st *buf, int offset, int len,
+ int *unused_bytes, int *missing_bytes)
+{
+ int i;
+ int recieved_bytes, padded_msg_len;
+ int align_fix;
+ int msg_offset;
+ unsigned char *ptr = (unsigned char *)buf->ptr + offset;
+ if (unused_bytes == NULL || missing_bytes == NULL)
+ return NULL;
+
+ *missing_bytes = 0;
+ *unused_bytes = 0;
+
+ PRN_DBG((TXT("entering with %d bytes.\n"), len));
+ for (i = 0; i < len; i++, ptr++) {
+ switch (dev->rxState) {
+ case RxsWait_a5:
+ dev->rxState =
+ ((*ptr & 0xff) == 0xa5) ? RxsWait_5a :
RxsWait_a5;
+ dev->rxPacket.msg_offset =
+ (unsigned long)ptr - (unsigned long)buf->ptr
+ 4;
+ break;
+ case RxsWait_5a:
+ if ((*ptr & 0xff) == 0x5a) {
+ dev->rxState = RxsWait_e7;
+ } else{
+ dev->rxState = RxsWait_a5;
+ i--;
+ ptr--; /* re-scan current byte*/
+ }
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsWait_e7:
+ if ((*ptr & 0xff) == 0xe7) {
+ dev->rxState = RxsWait_7e;
+ } else{
+ dev->rxState = RxsWait_a5;
+ i--;
+ ptr--; /* re-scan current byte*/
+ }
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsWait_7e:
+ if ((*ptr & 0xff) == 0x7e) {
+ dev->rxState = RxsTypeH;
+ } else{
+ dev->rxState = RxsWait_a5;
+ i--;
+ ptr--; /* re-scan current byte*/
+ }
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsTypeH:
+ dev->rxPacket.msg_buf = buf;
+ dev->rxPacket.msg_offset =
+ (unsigned long)ptr - (unsigned
long)buf->ptr;
+ dev->rxState = RxsTypeL;
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsTypeL:
+ dev->rxState = RxsGetSrcId;
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsGetSrcId:
+ dev->rxState = RxsGetDstId;
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsGetDstId:
+ dev->rxState = RxsGetLenL;
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsGetLenL:
+ dev->rxState = RxsGetLenH;
+ dev->rxPacket.msg_len = (*ptr & 0xff);
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsGetLenH:
+ dev->rxState = RxsFlagsL;
+ dev->rxPacket.msg_len += (*ptr & 0xff) << 8;
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsFlagsL:
+ dev->rxState = RxsFlagsH;
+ dev->rxPacket.msg_flags = (*ptr & 0xff);
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsFlagsH:
+ dev->rxState = RxsData;
+ dev->rxPacket.msg_flags += (*ptr & 0xff) << 8;
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ case RxsData:
+ recieved_bytes =
+ len + offset - dev->rxPacket.msg_offset;
+ padded_msg_len =
+ ((dev->rxPacket.msg_len + 4 +
SPI_PACKET_SIZE -
+ 1) >> SPI_PACKET_SIZE_BITS) <<
+ SPI_PACKET_SIZE_BITS;
+ if (recieved_bytes < padded_msg_len) {
+ *unused_bytes = 0;
+ *missing_bytes = padded_msg_len -
+ recieved_bytes;
+ return buf;
+ }
+ dev->rxState = RxsWait_a5;
+ if (dev->cb.msg_found_cb) {
+ align_fix = 0;
+ if (dev->rxPacket.
+ msg_flags &
MSG_HDR_FLAG_SPLIT_MSG_HDR) {
+ align_fix =
+ (dev->rxPacket.
+ msg_flags >> 8) & 0x3;
+ /* The FW aligned the message
data
+ therefore - alignment bytes
should be
+ thrown away. Throw the alignment
bytes
+ by moving the header ahead over
the
+ alignment bytes. */
+ if (align_fix) {
+ int length;
+ ptr = (unsigned char *)
+ dev->rxPacket.
+ msg_buf->ptr +
+
dev->rxPacket.msg_offset;
+
+ /* Restore header to
original
+ state before alignment
changes
+ */
+ length =
+ (ptr[5] << 8) |
ptr[4];
+ length -= align_fix;
+ ptr[5] = length >> 8;
+ ptr[4] = length & 0xff;
+ /* Zero alignment flags
*/
+ ptr[7] &= 0xfc;
+
+ for (i = MSG_HDR_LEN -
1;
+ i >= 0; i--) {
+ ptr[i +
align_fix] =
+ ptr[i];
+ }
+ dev->rxPacket.msg_offset
+=
+ align_fix;
+ }
+ }
+
+ PRN_DBG((TXT
+ ("Msg found and sent to callback
func.\n")));
+
+ /* force all messages to start on
+ * 4-byte boundary */
+ msg_offset = dev->rxPacket.msg_offset;
+ if (msg_offset & 0x3) {
+ msg_offset &= (~0x3);
+ memmove((unsigned char *)
+
(dev->rxPacket.msg_buf->ptr)
+ + msg_offset,
+ (unsigned char *)
+
(dev->rxPacket.msg_buf->ptr)
+ +
dev->rxPacket.msg_offset,
+ dev->rxPacket.msg_len -
+ align_fix);
+ }
+
+ *unused_bytes =
+ len + offset -
dev->rxPacket.msg_offset -
+ dev->rxPacket.msg_len;
+
+ /* In any case we got here -
unused_bytes
+ * should not be 0 Because we want to
force
+ * reading at least 256 after the end
+ * of any found message */
+ if (*unused_bytes == 0)
+ *unused_bytes = -1;
+
+ buf =
smsspi_handle_unused_bytes_buf(dev, buf,
+ offset, len,
*unused_bytes);
+
+ dev->cb.msg_found_cb(dev->context,
+
dev->rxPacket.msg_buf,
+ msg_offset,
+
dev->rxPacket.msg_len -
+ align_fix);
+ *missing_bytes = 0;
+ return buf;
+ } else {
+ PRN_DBG((TXT
+ ("Msg found but no callback. therefore - thrown
away.\n")));
+ }
+ PRN_DBG((TXT("state %d.\n"), dev->rxState));
+ break;
+ }
+ }
+
+ if (dev->rxState == RxsWait_a5) {
+ *unused_bytes = 0;
+ *missing_bytes = 0;
+ return buf;
+ } else {
+ /* Workaround to corner case: if the last byte of the
buffer
+ is "a5" (first byte of the preamble), the host thinks it
should
+ send another 256 bytes. In case the a5 is the firmware
+ underflow byte, this will cause an infinite loop, so we
check
+ for this case explicitly. */
+ if (dev->rxState == RxsWait_5a) {
+ if ((*(ptr - 2) == 0xa5) ||
+ (*((unsigned int *)(void *)(ptr-4)) ==
+ *((unsigned int *)(void *)(ptr-8)))) {
+ dev->rxState = RxsWait_a5;
+ *unused_bytes = 0;
+ *missing_bytes = 0;
+
+ return buf;
+ }
+ }
+
+ if (dev->rxPacket.msg_offset >= (SPI_PACKET_SIZE + 4))
+ /* adding 4 for the preamble. */
+ { /*The packet will be copied to a new
buffer
+ and rescaned by the state machine */
+ struct _rx_buffer_st *tmp_buf = buf;
+ *unused_bytes = dev->rxState - RxsWait_a5;
+ tmp_buf = smsspi_handle_unused_bytes_buf(dev,
buf,
+ offset, len, *unused_bytes);
+ dev->rxState = RxsWait_a5;
+ dev->cb.free_rx_buf(dev->context, buf);
+ *missing_bytes = 0;
+ return tmp_buf;
+ } else {
+ /* report missing bytes and continue
+ with message scan. */
+ *unused_bytes = 0;
+ *missing_bytes = SPI_PACKET_SIZE;
+ return buf;
+ }
+ }
+}
+
+void smsspi_common_transfer_msg(struct _spi_dev *dev, struct _spi_msg
*txmsg,
+ int padding_allowed)
+{
+ int len, bytes_to_transfer;
+ unsigned long tx_phy_addr;
+ int missing_bytes, tx_bytes;
+ int offset, unused_bytes;
+ int align_block;
+ char *txbuf;
+ struct _rx_buffer_st *buf, *tmp_buf;
+
+ len = 0;
+ if (!dev->cb.transfer_data_cb) {
+ PRN_ERR((TXT
+ ("function called while module is not
initialized.\n")));
+ return;
+ }
+ if (txmsg == 0) {
+ bytes_to_transfer = SPI_PACKET_SIZE;
+ txbuf = 0;
+ tx_phy_addr = 0;
+ tx_bytes = 0;
+ } else {
+ tx_bytes = txmsg->len;
+ if (padding_allowed)
+ bytes_to_transfer =
+ (((tx_bytes + SPI_PACKET_SIZE -
+ 1) >> SPI_PACKET_SIZE_BITS) <<
+ SPI_PACKET_SIZE_BITS);
+ else
+ bytes_to_transfer = (((tx_bytes + 3) >> 2) <<
2);
+ txbuf = txmsg->buf;
+ tx_phy_addr = txmsg->buf_phy_addr;
+ }
+ offset = 0;
+ unused_bytes = 0;
+ buf =
+ dev->cb.allocate_rx_buf(dev->context,
+ RX_PACKET_SIZE + SPI_PACKET_SIZE*2);
+ if (!buf) {
+ PRN_ERR((TXT("Failed to allocate RX buffer.\n")));
+ return;
+ }
+ while (bytes_to_transfer || unused_bytes) {
+ if ((unused_bytes <= 0) && (bytes_to_transfer > 0)) {
+ len = min(bytes_to_transfer, RX_PACKET_SIZE);
+ PRN_DBG((TXT("transfering block of %d bytes\n"),
len));
+ dev->cb.transfer_data_cb(dev->phy_context,
+ (unsigned char *)txbuf,
+ tx_phy_addr,
+ (unsigned char *)buf->ptr +
offset,
+ buf->phy_addr + offset, len);
+ }
+
+ tmp_buf =
+ smsspi_common_find_msg(dev, buf, offset, len,
+ &unused_bytes,
&missing_bytes);
+ if (bytes_to_transfer)
+ bytes_to_transfer -= len;
+
+ if (tx_bytes)
+ tx_bytes -= len;
+
+ if (missing_bytes)
+ offset += len;
+
+ if (unused_bytes) {
+ /* In this case tmp_buf is a new buffer
allocated
+ * in smsspi_common_find_msg
+ * and it already contains the unused bytes */
+ if (unused_bytes > 0) {
+ align_block =
+ (((unused_bytes + SPI_PACKET_SIZE -
+ 1) >> SPI_PACKET_SIZE_BITS) <<
+ SPI_PACKET_SIZE_BITS);
+ len = align_block;
+ }
+ offset = 0;
+ buf = tmp_buf;
+ }
+ if (tx_bytes <= 0) {
+ txbuf = 0;
+ tx_bytes = 0;
+ }
+ if (bytes_to_transfer < missing_bytes) {
+ bytes_to_transfer =
+ (((missing_bytes + SPI_PACKET_SIZE -
+ 1) >> SPI_PACKET_SIZE_BITS) <<
+ SPI_PACKET_SIZE_BITS);
+ PRN_DBG((TXT
+ ("a message was found, adding bytes to transfer, txmsg %d, total
%d\n")
+ , tx_bytes, bytes_to_transfer));
+ }
+ }
+ dev->cb.free_rx_buf(dev->context, buf);
+}
+
+int smsspicommon_init(struct _spi_dev *dev, void *context, void
*phy_context,
+ struct _spi_dev_cb_st *cb)
+{
+ PRN_DBG((TXT("entering.\n")));
+ if (cb->transfer_data_cb == 0 ||
+ cb->msg_found_cb == 0 ||
+ cb->allocate_rx_buf == 0 || cb->free_rx_buf == 0) {
+ PRN_ERR((TXT("Invalid input parameters of init
routine.\n")));
+ return -1;
+ }
+ dev->context = context;
+ dev->phy_context = phy_context;
+ memcpy(&dev->cb, cb, sizeof(struct _spi_dev_cb_st));
+ dev->rxState = RxsWait_a5;
+ PRN_DBG((TXT("exiting.\n")));
+ return 0;
+}
diff --git a/drivers/media/dvb/siano/smsspicommon.h
b/drivers/media/dvb/siano/smsspicommon.h
new file mode 100644
index 0000000..8976d04
--- /dev/null
+++ b/drivers/media/dvb/siano/smsspicommon.h
@@ -0,0 +1,96 @@
+/****************************************************************
+
+Siano Mobile Silicon, Inc.
+MDTV receiver kernel modules.
+Copyright (C) 2006-2008, Uri Shkolnik
+
+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.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************/
+#ifndef _SMS_SPI_COMMON_H_
+#define _SMS_SPI_COMMON_H_
+
+#define RX_PACKET_SIZE 0x1000
+#define SPI_PACKET_SIZE_BITS 8
+#define SPI_PACKET_SIZE (1<<SPI_PACKET_SIZE_BITS)
+#define SPI_MAX_CTRL_MSG_SIZE 0x100
+
+#define MSG_HDR_FLAG_SPLIT_MSG_HDR 0x0004
+#define MSG_HDR_LEN 8
+
+enum _spi_rx_state {
+ RxsWait_a5 = 0,
+ RxsWait_5a,
+ RxsWait_e7,
+ RxsWait_7e,
+ RxsTypeH,
+ RxsTypeL,
+ RxsGetSrcId,
+ RxsGetDstId,
+ RxsGetLenL,
+ RxsGetLenH,
+ RxsFlagsL,
+ RxsFlagsH,
+ RxsData
+};
+
+struct _rx_buffer_st {
+ void *ptr;
+ unsigned long phy_addr;
+};
+
+struct _rx_packet_request {
+ struct _rx_buffer_st *msg_buf;
+ int msg_offset;
+ int msg_len;
+ int msg_flags;
+};
+
+struct _spi_dev_cb_st {
+ void (*transfer_data_cb) (void *context, unsigned char *,
+ unsigned long, unsigned char *, unsigned long,
int);
+ void (*msg_found_cb) (void *, void *, int, int);
+ struct _rx_buffer_st *(*allocate_rx_buf) (void *, int);
+ void (*free_rx_buf) (void *, struct _rx_buffer_st *);
+};
+
+struct _spi_dev {
+ void *context;
+ void *phy_context;
+ struct _spi_dev_cb_st cb;
+ char *rxbuf;
+ enum _spi_rx_state rxState;
+ struct _rx_packet_request rxPacket;
+ char *internal_tx_buf;
+};
+
+struct _spi_msg {
+ char *buf;
+ unsigned long buf_phy_addr;
+ int len;
+};
+
+void smsspi_common_transfer_msg(struct _spi_dev *dev, struct _spi_msg
*txmsg,
+ int padding_allowed);
+int smsspicommon_init(struct _spi_dev *dev, void *contex, void
*phy_context,
+ struct _spi_dev_cb_st *cb);
+
+#if defined HEXDUMP_DEBUG && defined SPIBUS_DEBUG
+/*! dump a human readable print of a binary buffer */
+void smsspi_khexdump(char *buf, int len);
+#else
+#define smsspi_khexdump(buf, len)
+#endif
+
+#endif /*_SMS_SPI_COMMON_H_*/
diff --git a/drivers/media/dvb/siano/smsspidrv.c
b/drivers/media/dvb/siano/smsspidrv.c
new file mode 100644
index 0000000..4526cb8
--- /dev/null
+++ b/drivers/media/dvb/siano/smsspidrv.c
@@ -0,0 +1,472 @@
+/****************************************************************
+
+Siano Mobile Silicon, Inc.
+MDTV receiver kernel modules.
+ Copyright (C) 2006-2010, Erez Cohen
+
+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.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************/
+/*!
+ \file spibusdrv.c
+
+ \brief spi bus driver module
+
+ This file contains implementation of the spi bus driver.
+*/
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+
+#include "smscoreapi.h"
+#include "smsspicommon.h"
+#include "smsspiphy.h"
+
+#define SMS_INTR_PIN 19 /* 0 for nova sip, 26 for
vega */
+#define TX_BUFFER_SIZE 0x200
+#define RX_BUFFER_SIZE (0x1000 + SPI_PACKET_SIZE +
0x100)
+#define NUM_RX_BUFFERS 72
+
+struct _spi_device_st {
+ struct _spi_dev dev;
+ void *phy_dev;
+
+ struct completion write_operation;
+ struct list_head tx_queue;
+ int allocatedPackets;
+ int padding_allowed;
+ char *rxbuf;
+
+ struct smscore_device_t *coredev;
+ struct list_head txqueue;
+ char *txbuf;
+ dma_addr_t txbuf_phy_addr;
+};
+
+struct _smsspi_txmsg {
+ struct list_head node; /*! internal management */
+ void *buffer;
+ size_t size;
+ int alignment;
+ int add_preamble;
+ struct completion completion;
+ void (*prewrite) (void *);
+ void (*postwrite) (void *);
+};
+
+struct _Msg {
+ struct SmsMsgHdr_ST hdr;
+ u32 data[3];
+};
+
+struct _spi_device_st *spi_dev;
+
+int sms_dbg;
+static void spi_worker_thread(void *arg);
+static DECLARE_WORK(spi_work_queue, (void *)spi_worker_thread);
+static u8 smsspi_preamble[] = { 0xa5, 0x5a, 0xe7, 0x7e };
+static u8 smsspi_startup[] = { 0, 0, 0xde, 0xc1, 0xa5, 0x51, 0xf1, 0xed
};
+static u32 sms_intr_pin = SMS_INTR_PIN;
+
+static u32 default_type = SMS_NOVA_B0;
+
+module_param_named(debug, sms_dbg, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
+
+module_param(default_type, int, S_IRUGO);
+MODULE_PARM_DESC(default_type, "default SMS device type.");
+
+module_param(sms_intr_pin, int, S_IRUGO);
+MODULE_PARM_DESC(sms_intr_pin, "interrupt pin number used by SMS
chip.");
+
+module_param(host_intr_pin, int, S_IRUGO);
+MODULE_PARM_DESC(host_intr_pin, "interrupt pin number used by Host.");
+
+/******************************************/
+static void spi_worker_thread(void *arg)
+{
+ struct _spi_device_st *spi_device = spi_dev;
+ struct _smsspi_txmsg *msg = NULL;
+ struct _spi_msg txmsg;
+
+ sms_info("worker start\n");
+ do {
+ /* do we have a msg to write ? */
+ if (!msg && !list_empty(&spi_device->txqueue))
+ msg = (struct _smsspi_txmsg *)
+ list_entry(spi_device->txqueue.
+ next, struct _smsspi_txmsg,
node);
+
+ if (msg) {
+ if (msg->add_preamble) {
+ txmsg.len =
+ min(msg->size +
sizeof(smsspi_preamble),
+ (size_t) TX_BUFFER_SIZE);
+ txmsg.buf = spi_device->txbuf;
+ txmsg.buf_phy_addr =
+ spi_device->txbuf_phy_addr;
+ memcpy(txmsg.buf, smsspi_preamble,
+ sizeof(smsspi_preamble));
+
memcpy(&txmsg.buf[sizeof(smsspi_preamble)],
+ msg->buffer,
+ txmsg.len -
sizeof(smsspi_preamble));
+ msg->add_preamble = 0;
+ msg->buffer +=
+ txmsg.len - sizeof(smsspi_preamble);
+ msg->size -=
+ txmsg.len - sizeof(smsspi_preamble);
+ /* zero out the rest of aligned buffer
*/
+ memset(&txmsg.buf[txmsg.len], 0,
+ TX_BUFFER_SIZE - txmsg.len);
+
smsspi_common_transfer_msg(&spi_device->dev,
+ &txmsg, 1);
+ } else {
+ txmsg.len =
+ min(msg->size, (size_t)
TX_BUFFER_SIZE);
+ txmsg.buf = spi_device->txbuf;
+ txmsg.buf_phy_addr =
+ spi_device->txbuf_phy_addr;
+ memcpy(txmsg.buf, msg->buffer,
txmsg.len);
+
+ msg->buffer += txmsg.len;
+ msg->size -= txmsg.len;
+ /* zero out the rest of aligned buffer
*/
+ memset(&txmsg.buf[txmsg.len], 0,
+ TX_BUFFER_SIZE - txmsg.len);
+
smsspi_common_transfer_msg(&spi_device->dev,
+ &txmsg, 0);
+ }
+
+ } else {
+ smsspi_common_transfer_msg(&spi_device->dev,
NULL, 1);
+ }
+
+ /* if there was write, have we finished ? */
+ if (msg && !msg->size) {
+ /* call postwrite call back */
+ if (msg->postwrite)
+ msg->postwrite(spi_device);
+
+ list_del(&msg->node);
+ complete(&msg->completion);
+ msg = NULL;
+ }
+ /* if there was read, did we read anything ? */
+
+ } while (!list_empty(&spi_device->txqueue) || msg);
+
+ sms_info("worker end\n");
+
+}
+
+static void msg_found(void *context, void *buf, int offset, int len)
+{
+ struct _spi_device_st *spi_device = (struct _spi_device_st *)
context;
+ struct smscore_buffer_t *cb =
+ (struct smscore_buffer_t
+ *)(container_of(buf, struct smscore_buffer_t, p));
+
+ sms_info("entering\n");
+ cb->offset = offset;
+ cb->size = len;
+ /* sms_err ("buffer %p is sent back to core databuf=%p,
+ offset=%d.\n", cb, cb->p, cb->offset); */
+ smscore_onresponse(spi_device->coredev, cb);
+
+ sms_info("exiting\n");
+
+}
+
+static void smsspi_int_handler(void *context)
+{
+ sms_info("interrupt\n");
+ PREPARE_WORK(&spi_work_queue, (void *)spi_worker_thread);
+ schedule_work(&spi_work_queue);
+}
+
+static int smsspi_queue_message_and_wait(struct _spi_device_st
*spi_device,
+ struct _smsspi_txmsg *msg)
+{
+ init_completion(&msg->completion);
+ list_add_tail(&msg->node, &spi_device->txqueue);
+ schedule_work(&spi_work_queue);
+ wait_for_completion(&msg->completion);
+
+ return 0;
+}
+
+static int smsspi_preload(void *context)
+{
+ struct _smsspi_txmsg msg;
+ struct _spi_device_st *spi_device = (struct _spi_device_st *)
context;
+ struct _Msg Msg = {
+ {
+ MSG_SMS_SPI_INT_LINE_SET_REQ, 0, HIF_TASK,
+ sizeof(struct _Msg), 0}, {
+ 0, sms_intr_pin, 0}
+ };
+ int rc;
+
+ sms_err("preparing for download\n");
+ prepareForFWDnl(spi_device->phy_dev);
+ sms_err("Sending SPI init sequence\n");
+ msg.buffer = smsspi_startup;
+ msg.size = sizeof(smsspi_startup);
+ msg.alignment = 4;
+ msg.add_preamble = 0;
+ msg.prewrite = NULL; /* smsspiphy_reduce_clock; */
+ msg.postwrite = NULL; /* smsspiphy_restore_clock; */
+
+ rc = smsspi_queue_message_and_wait(context, &msg);
+ if (rc < 0) {
+ sms_err("smsspi_queue_message_and_wait error, rc =
%d\n", rc);
+ return rc;
+ }
+
+ sms_debug("sending MSG_SMS_SPI_INT_LINE_SET_REQ");
+ sms_info("Sending SPI Set Interrupt command sequence\n");
+ msg.buffer = &Msg;
+ msg.size = sizeof(Msg);
+ msg.alignment = SPI_PACKET_SIZE;
+ msg.add_preamble = 1;
+
+ rc = smsspi_queue_message_and_wait(context, &msg);
+ if (rc < 0) {
+ sms_err("set interrupt line failed, rc = %d\n", rc);
+ return rc;
+ }
+
+ return rc;
+}
+
+static int smsspi_postload(void *context)
+{
+ struct _spi_device_st *spi_device = (struct _spi_device_st *)
context;
+ int mode =
smscore_registry_getmode(spi_device->coredev->devpath);
+ if ((mode != DEVICE_MODE_ISDBT) &&
+ (mode != DEVICE_MODE_ISDBT_BDA)) {
+ fwDnlComplete(spi_device->phy_dev, 0);
+
+ }
+
+ return 0;
+}
+
+static int smsspi_write(void *context, void *txbuf, size_t len)
+{
+ struct _smsspi_txmsg msg;
+ msg.buffer = txbuf;
+ msg.size = len;
+ msg.prewrite = NULL;
+ msg.postwrite = NULL;
+ if (len > 0x1000) {
+ /* The FW is the only long message. Do not add preamble,
+ and do not padd it */
+ msg.alignment = 4;
+ msg.add_preamble = 0;
+ msg.prewrite = smschipreset;
+ } else {
+ msg.alignment = SPI_PACKET_SIZE;
+ msg.add_preamble = 1;
+ }
+ sms_info("Writing message to SPI.\n");
+ sms_info("msg hdr: 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x,
0x%x.\n",
+ ((u8 *) txbuf)[0], ((u8 *) txbuf)[1], ((u8 *) txbuf)[2],
+ ((u8 *) txbuf)[3], ((u8 *) txbuf)[4], ((u8 *) txbuf)[5],
+ ((u8 *) txbuf)[6], ((u8 *) txbuf)[7]);
+ return smsspi_queue_message_and_wait(context, &msg);
+}
+
+struct _rx_buffer_st *allocate_rx_buf(void *context, int size)
+{
+ struct smscore_buffer_t *buf;
+ struct _spi_device_st *spi_device = (struct _spi_device_st *)
context;
+ if (size > RX_BUFFER_SIZE) {
+ sms_err("Requested size is bigger than max buffer
size.\n");
+ return NULL;
+ }
+ buf = smscore_getbuffer(spi_device->coredev);
+ sms_info("Recieved Rx buf %p physical 0x%x (contained in %p)\n",
+ buf->p, buf->phys, buf);
+
+ /* note: this is not mistake! the rx_buffer_st is identical to
part of
+ smscore_buffer_t and we return the address of the start of
the
+ identical part */
+ return (struct _rx_buffer_st *) &buf->p;
+}
+
+static void free_rx_buf(void *context, struct _rx_buffer_st *buf)
+{
+ struct _spi_device_st *spi_device = (struct _spi_device_st *)
context;
+ struct smscore_buffer_t *cb =
+ (struct smscore_buffer_t
+ *)(container_of(((void *)buf), struct smscore_buffer_t,
p));
+ sms_info("buffer %p is released.\n", cb);
+ smscore_putbuffer(spi_device->coredev, cb);
+}
+
+/*! Release device STUB
+
+\param[in] dev: device control block
+\return void
+*/
+static void smsspi_release(struct device *dev)
+{
+ sms_info("nothing to do\n");
+ /* Nothing to release */
+}
+
+static struct platform_device smsspi_device = {
+ .name = "smsspi",
+ .id = 1,
+ .dev = {
+ .release = smsspi_release,
+ },
+};
+
+static int __init smsspi_module_init(void)
+{
+ struct smsdevice_params_t params;
+ int ret;
+ struct _spi_device_st *spi_device;
+ struct _spi_dev_cb_st common_cb;
+
+ sms_info("entering\n");
+
+ spi_device =
+ kmalloc(sizeof(struct _spi_device_st), GFP_KERNEL);
+ spi_dev = spi_device;
+
+ INIT_LIST_HEAD(&spi_device->txqueue);
+
+ ret = platform_device_register(&smsspi_device);
+ if (ret < 0) {
+ sms_err("platform_device_register failed\n");
+ return ret;
+ }
+
+ spi_device->txbuf =
+ dma_alloc_coherent(NULL, TX_BUFFER_SIZE,
+ &spi_device->txbuf_phy_addr,
+ GFP_KERNEL | GFP_DMA);
+ if (!spi_device->txbuf) {
+ printk(KERN_INFO "%s dma_alloc_coherent(...) failed\n",
+ __func__);
+ ret = -ENOMEM;
+ goto txbuf_error;
+ }
+
+ spi_device->phy_dev =
+ smsspiphy_init(NULL, smsspi_int_handler, spi_device);
+ if (spi_device->phy_dev == 0) {
+ printk(KERN_INFO "%s smsspiphy_init(...) failed\n",
__func__);
+ goto phy_error;
+ }
+
+ common_cb.allocate_rx_buf = allocate_rx_buf;
+ common_cb.free_rx_buf = free_rx_buf;
+ common_cb.msg_found_cb = msg_found;
+ common_cb.transfer_data_cb = smsspibus_xfer;
+
+ ret =
+ smsspicommon_init(&spi_device->dev, spi_device,
+ spi_device->phy_dev, &common_cb);
+ if (ret) {
+ printk(KERN_INFO "%s smsspiphy_init(...) failed\n",
__func__);
+ goto common_error;
+ }
+
+ /* register in smscore */
+ memset(¶ms, 0, sizeof(params));
+ params.context = spi_device;
+ params.device = &smsspi_device.dev;
+ params.buffer_size = RX_BUFFER_SIZE;
+ params.num_buffers = NUM_RX_BUFFERS;
+ params.flags = SMS_DEVICE_NOT_READY;
+ params.sendrequest_handler = smsspi_write;
+ strcpy(params.devpath, "spi");
+ params.device_type = default_type;
+
+ params.flags =
+ SMS_DEVICE_FAMILY2 | SMS_DEVICE_NOT_READY;
+ params.preload_handler = smsspi_preload;
+ params.postload_handler = smsspi_postload;
+ sms_info("registering spi device type %d", params.device_type);
+ ret = smscore_register_device(¶ms, &spi_device->coredev);
+ if (ret < 0) {
+ printk(KERN_INFO "%s smscore_register_device(...)
failed\n",
+ __func__);
+ goto reg_device_error;
+ }
+
+ ret = smscore_start_device(spi_device->coredev);
+ if (ret < 0) {
+ printk(KERN_INFO "%s smscore_start_device(...)
failed\n",
+ __func__);
+ goto start_device_error;
+ }
+
+ sms_info("exiting\n");
+ return 0;
+
+start_device_error:
+ smscore_unregister_device(spi_device->coredev);
+
+reg_device_error:
+
+common_error:
+ smsspiphy_deinit(spi_device->phy_dev);
+
+phy_error:
+ dma_free_coherent(NULL, TX_BUFFER_SIZE, spi_device->txbuf,
+ spi_device->txbuf_phy_addr);
+
+txbuf_error:
+ platform_device_unregister(&smsspi_device);
+
+ sms_info("exiting error %d\n", ret);
+
+ return ret;
+}
+
+static void __exit smsspi_module_exit(void)
+{
+ struct _spi_device_st *spi_device = spi_dev;
+ sms_info("entering\n");
+
+ /* stop interrupts */
+ smsspiphy_deinit(spi_device->phy_dev);
+ smscore_unregister_device(spi_device->coredev);
+
+ dma_free_coherent(NULL, TX_BUFFER_SIZE, spi_device->txbuf,
+ spi_device->txbuf_phy_addr);
+
+ platform_device_unregister(&smsspi_device);
+ sms_info("exiting\n");
+}
+
+
+module_init(smsspi_module_init);
+module_exit(smsspi_module_exit);
+
+MODULE_DESCRIPTION("Siano MDTV SPI device driver");
+MODULE_AUTHOR("Siano Mobile Silicon, Inc. ([email protected])");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/siano/smsspiphy.c
b/drivers/media/dvb/siano/smsspiphy.c
new file mode 100644
index 0000000..f55131c
--- /dev/null
+++ b/drivers/media/dvb/siano/smsspiphy.c
@@ -0,0 +1,218 @@
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/spi/spi.h>
+#include <linux/dma-mapping.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+
+#include "smscoreapi.h"
+#include "smsspiphy.h"
+
+#define MAX_SPEED_DURING_DOWNLOAD 6000000
+#define MAX_SPEED_DURING_WORK 6000000
+#define SPI_PACKET_SIZE 256
+
+int sms_spi_interrupt = 135;
+module_param_named(debug, sms_spi_interrupt, int, 0644);
+MODULE_PARM_DESC(debug, "set interrupt gpio pin for spi device.");
+
+
+int spi_max_speed = MAX_SPEED_DURING_WORK;
+
+struct sms_spi {
+ struct spi_device *spi_dev;
+ char *zero_txbuf;
+ dma_addr_t zero_txbuf_phy_addr;
+ int bus_speed;
+ void (*interruptHandler) (void *);
+ void *intr_context;
+};
+
+/*!
+invert the endianness of a single 32it integer
+
+\param[in] u: word to invert
+
+\return the inverted word
+*/
+static inline u32 invert_bo(u32 u)
+{
+ return ((u & 0xff) << 24) | ((u & 0xff00) << 8) | ((u &
0xff0000) >> 8)
+ | ((u & 0xff000000) >> 24);
+}
+
+/*!
+invert the endianness of a data buffer
+
+\param[in] buf: buffer to invert
+\param[in] len: buffer length
+
+\return the inverted word
+*/
+
+
+static int invert_endianness(char *buf, int len)
+{
+ int i;
+ u32 *ptr = (u32 *) buf;
+
+ len = (len + 3) / 4;
+ for (i = 0; i < len; i++, ptr++)
+ *ptr = invert_bo(*ptr);
+
+ return 4 * ((len + 3) & (~3));
+}
+
+static irqreturn_t spibus_interrupt(int irq, void *context)
+{
+ struct sms_spi *sms_spi = (struct sms_spi *)context;
+ if (sms_spi->interruptHandler)
+ sms_spi->interruptHandler(sms_spi->intr_context);
+ return IRQ_HANDLED;
+
+}
+
+void prepareForFWDnl(void *context)
+{
+ /*Reduce clock rate for FW download*/
+ struct sms_spi *sms_spi = (struct sms_spi *)context;
+ sms_spi->bus_speed = MAX_SPEED_DURING_DOWNLOAD;
+ sms_err("Start FW download.");
+ msleep(100);
+ sms_err("done sleeping.");
+}
+
+void fwDnlComplete(void *context, int App)
+{
+ /*Set clock rate for working mode*/
+ struct sms_spi *sms_spi = (struct sms_spi *)context;
+ sms_spi->bus_speed = spi_max_speed;
+ sms_err("FW download complete.");
+ msleep(100);
+}
+
+
+void smsspibus_xfer(void *context, unsigned char *txbuf,
+ unsigned long txbuf_phy_addr, unsigned char *rxbuf,
+ unsigned long rxbuf_phy_addr, int len)
+{
+ struct sms_spi *sms_spi = (struct sms_spi *)context;
+ struct spi_message msg;
+ struct spi_transfer xfer = {
+ .tx_buf = txbuf,
+ .rx_buf = rxbuf,
+ .len = len,
+ .tx_dma = txbuf_phy_addr,
+ .rx_dma = rxbuf_phy_addr,
+ .cs_change = 0,
+ .speed_hz = sms_spi->bus_speed,
+ .bits_per_word = 0,
+ };
+
+ if (txbuf)
+ invert_endianness(txbuf, len);
+
+
+ if (!txbuf) {
+ xfer.tx_buf = sms_spi->zero_txbuf;
+ xfer.tx_dma = sms_spi->zero_txbuf_phy_addr;
+
+ }
+
+ spi_message_init(&msg);
+ msg.is_dma_mapped = 1;
+ spi_message_add_tail(&xfer, &msg);
+ spi_sync(sms_spi->spi_dev, &msg);
+ invert_endianness(rxbuf, len);
+
+}
+
+
+
+void *smsspiphy_init(void *context, void (*smsspi_interruptHandler)
(void *),
+ void *intr_context)
+{
+ int ret;
+ struct sms_spi *sms_spi;
+ struct spi_device *sms_device;
+
+ struct spi_master *master = spi_busnum_to_master(3);
+ struct spi_board_info sms_chip = {
+ .modalias = "SmsSPI",
+ .platform_data = NULL,
+ .controller_data = NULL,
+ .irq = 0, /*OMAP_GPIO_IRQ(4)*/
+ .max_speed_hz = spi_max_speed,
+ .bus_num = 3,
+ .chip_select = 1,
+ .mode = SPI_MODE_0,
+ };
+
+ sms_err("sms_debug = %d\n", sms_dbg);
+
+ sms_device = spi_new_device(master, &sms_chip);
+ if (!sms_device) {
+ sms_err("Failed on allocating new SPI device for SMS");
+ return NULL;
+ }
+ sms_device->bits_per_word = 32;
+ if (spi_setup(sms_device)) {
+ sms_err("SMS device setup failed");
+ return NULL;
+ }
+
+ sms_spi = kzalloc(sizeof(struct sms_spi), GFP_KERNEL);
+
+ sms_spi->zero_txbuf = dma_alloc_coherent(NULL, SPI_PACKET_SIZE,
+ &sms_spi->zero_txbuf_phy_addr,
+ GFP_KERNEL | GFP_DMA);
+ if (!sms_spi->zero_txbuf) {
+ sms_err("dma_alloc_coherent(...) failed\n");
+ kfree(sms_spi);
+ return NULL;
+ }
+ memset(sms_spi->zero_txbuf, 0, SPI_PACKET_SIZE);
+ sms_spi->interruptHandler = smsspi_interruptHandler;
+ sms_spi->intr_context = intr_context;
+
+
+ if ((gpio_request(sms_spi_interrupt, "SMSSPI") == 0) &&
+ (gpio_direction_input(sms_spi_interrupt) == 0)) {
+ gpio_export(sms_spi_interrupt, 0);
+ }
+
+ irq_set_irq_type(gpio_to_irq(sms_spi_interrupt),
+ IRQ_TYPE_EDGE_FALLING);
+ ret = request_irq(gpio_to_irq(sms_spi_interrupt),
+ spibus_interrupt, IRQF_TRIGGER_FALLING,
+ "SMSSPI", sms_spi);
+ if (ret) {
+ sms_err("Could not get intrpt for SMS device. status
=%d\n",
+ ret);
+ return NULL;
+ }
+
+ sms_spi->spi_dev = sms_device;
+ sms_spi->bus_speed = spi_max_speed;
+ sms_err("after init sms_spi=0x%x, spi_dev = 0x%x",
+ (int)sms_spi, (int)sms_spi->spi_dev);
+
+ return sms_spi;
+}
+
+void smsspiphy_deinit(void *context)
+{
+ struct sms_spi *sms_spi = (struct sms_spi *)context;
+ printk(KERN_INFO "smsspiphy_deinit\n");
+ kfree(sms_spi);
+
+}
+
+void smschipreset(void *context)
+{
+ sms_err("sms chip reset");
+}
+
+
+
diff --git a/drivers/media/dvb/siano/smsspiphy.h
b/drivers/media/dvb/siano/smsspiphy.h
new file mode 100644
index 0000000..a70198b
--- /dev/null
+++ b/drivers/media/dvb/siano/smsspiphy.h
@@ -0,0 +1,38 @@
+/****************************************************************
+
+Siano Mobile Silicon, Inc.
+MDTV receiver kernel modules.
+Copyright (C) 2006-2008, Uri Shkolnik
+
+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.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************/
+
+#ifndef __SMS_SPI_PHY_H__
+#define __SMS_SPI_PHY_H__
+
+extern int host_intr_pin;
+extern int sms_dbg;
+void smsspibus_xfer(void *context, unsigned char *txbuf,
+ unsigned long txbuf_phy_addr, unsigned char *rxbuf,
+ unsigned long rxbuf_phy_addr, int len);
+void *smsspiphy_init(void *context, void (*smsspi_interruptHandler)
(void *),
+ void *intr_context);
+void smsspiphy_deinit(void *context);
+void smschipreset(void *context);
+void WriteFWtoStellar(void *pSpiPhy, unsigned char *pFW, unsigned long
Len);
+void prepareForFWDnl(void *pSpiPhy);
+void fwDnlComplete(void *context, int App);
+
+#endif /* __SMS_SPI_PHY_H__ */
--
1.7.4.1
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
