From aba072902ac0dc668d31da3c3cbaac0a5ed5d6e5 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 19 May 2008 14:56:13 -0400 Subject: add support for SMS1010 and SMS1150 based digital television devices From: Michael Krufky initial driver drop, provided by Siano Mobile Silicon, Inc. Signed-off-by: Michael Krufky --- linux/drivers/media/Kconfig | 14 + linux/drivers/media/Makefile | 1 + linux/drivers/media/mdtv/Kconfig | 36 + linux/drivers/media/mdtv/Makefile | 8 + linux/drivers/media/mdtv/smschar.c | 575 +++++++++++++++ linux/drivers/media/mdtv/smschar.h | 7 + linux/drivers/media/mdtv/smscharioctl.h | 17 + linux/drivers/media/mdtv/smscoreapi.c | 1225 +++++++++++++++++++++++++++++++ linux/drivers/media/mdtv/smscoreapi.h | 101 +++ linux/drivers/media/mdtv/smsdvb.c | 438 +++++++++++ linux/drivers/media/mdtv/smskdefs.h | 36 + linux/drivers/media/mdtv/smsnet.c | 447 +++++++++++ linux/drivers/media/mdtv/smstypes.h | 361 +++++++++ linux/drivers/media/mdtv/smsusb.c | 432 +++++++++++ 14 files changed, 3698 insertions(+) create mode 100644 linux/drivers/media/mdtv/Kconfig create mode 100644 linux/drivers/media/mdtv/Makefile create mode 100644 linux/drivers/media/mdtv/smschar.c create mode 100644 linux/drivers/media/mdtv/smschar.h create mode 100644 linux/drivers/media/mdtv/smscharioctl.h create mode 100644 linux/drivers/media/mdtv/smscoreapi.c create mode 100644 linux/drivers/media/mdtv/smscoreapi.h create mode 100644 linux/drivers/media/mdtv/smsdvb.c create mode 100644 linux/drivers/media/mdtv/smskdefs.h create mode 100644 linux/drivers/media/mdtv/smsnet.c create mode 100644 linux/drivers/media/mdtv/smstypes.h create mode 100644 linux/drivers/media/mdtv/smsusb.c (limited to 'linux') diff --git a/linux/drivers/media/Kconfig b/linux/drivers/media/Kconfig index 7a7803b5d..e6a5879ea 100644 --- a/linux/drivers/media/Kconfig +++ b/linux/drivers/media/Kconfig @@ -115,6 +115,20 @@ source "drivers/media/radio/Kconfig" source "drivers/media/dvb/Kconfig" +# +# Mobile Digital TV devices (DVB-H, T-DMB, etc.) +# +menuconfig MDTV_ADAPTERS + bool "Mobile Digital TV adapter" + default y + +if MDTV_ADAPTERS + +source "drivers/media/mdtv/Kconfig" + +endif # MDTV_ADAPTERS + + config DAB boolean "DAB adapters" ---help--- diff --git a/linux/drivers/media/Makefile b/linux/drivers/media/Makefile index 09a829d8a..ec2102bcb 100644 --- a/linux/drivers/media/Makefile +++ b/linux/drivers/media/Makefile @@ -6,3 +6,4 @@ obj-y += common/ video/ obj-$(CONFIG_VIDEO_DEV) += radio/ obj-$(CONFIG_DVB_CORE) += dvb/ +obj-$(CONFIG_MDTV_ADAPTERS) += mdtv/ \ No newline at end of file diff --git a/linux/drivers/media/mdtv/Kconfig b/linux/drivers/media/mdtv/Kconfig new file mode 100644 index 000000000..f3bae4500 --- /dev/null +++ b/linux/drivers/media/mdtv/Kconfig @@ -0,0 +1,36 @@ +# +# Mobile Digital TV device configuration +# + +config MDTV_SIANO_STELLAR_COMMON + tristate "Siano SMS10xx adapter" + default m + ---help--- + Choose Y here if you have SMS10xx chipset. + + In order to control the SMS10xx chipset you will need SMS Host Control library. + + Further documentation on this driver can be found on the WWW at + . + + To compile this driver as a module, choose M here: the + modules will be called smschar and smsnet. + +config MDTV_SIANO_STELLAR_USB + tristate "Siano SMS10xx USB dongle support" + depends on MDTV_SIANO_STELLAR_COMMON + default m + ---help--- + Choose Y here if you have USB dongle with SMS10xx chipset. + + In order to control the SMS10xx chipset you will need SMS Host Control library. + + Further documentation on this driver can be found on the WWW at + . + + To compile this driver as a module, choose M here: the + module will be called smsusb. + + + + diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile new file mode 100644 index 000000000..1e54d8f79 --- /dev/null +++ b/linux/drivers/media/mdtv/Makefile @@ -0,0 +1,8 @@ +# +# Makefile for the kernel MDTV driver +# + +obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smschar.o smsnet.o +obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsusb.o + +EXTRA_CFLAGS += diff --git a/linux/drivers/media/mdtv/smschar.c b/linux/drivers/media/mdtv/smschar.c new file mode 100644 index 000000000..0477ad0ed --- /dev/null +++ b/linux/drivers/media/mdtv/smschar.c @@ -0,0 +1,575 @@ +/*! + + \file smschar.c + + \brief Implementation of smscore client for cdev based access + + \par Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. + + \par This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License version 3 as + published by the Free Software Foundation; + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. + + \author Anatoly Greenblat + +*/ + +#include +#include +#include + +#include /* printk() */ +#include /* everything... */ +#include /* size_t */ +#include +#include +#include /* cli(), *_flags */ +#include /* copy_*_user */ + +#include "smskdefs.h" // page, scatterlist, kmutex +#include "smscoreapi.h" +#include "smstypes.h" + +#include "smscharioctl.h" + +#define SMS_CHR_MAX_Q_LEN 10 // max number of packets allowed to be pending on queue +#define SMSCHAR_NR_DEVS 7 + +typedef struct _smschar_device +{ + struct cdev cdev; //!< Char device structure - kernel's device model representation + + wait_queue_head_t waitq; /* Processes waiting */ + spinlock_t lock; //!< critical section + int pending_count; + struct list_head pending_data; //!< list of pending data + + smscore_buffer_t *currentcb; + + int device_index; + + smscore_device_t *coredev; + smscore_client_t *smsclient; +} smschar_device_t; + +//! Holds the major number of the device node. may be changed at load time. +int smschar_major = 251; + +//! Holds the first minor number of the device node. may be changed at load time. +int smschar_minor = 0; + +// macros that allow the load time parameters change +module_param ( smschar_major, int, S_IRUGO ); +module_param ( smschar_minor, int, S_IRUGO ); + +#ifdef SMSCHAR_DEBUG + + #undef PERROR +# define PERROR(fmt, args...) printk( KERN_INFO "smschar error: line %d- %s(): " fmt,__LINE__, __FUNCTION__, ## args) + #undef PWARNING +# define PWARNING(fmt, args...) printk( KERN_INFO "smschar warning: line %d- %s(): " fmt,__LINE__, __FUNCTION__, ## args) + #undef PDEBUG /* undef it, just in case */ +# define PDEBUG(fmt, args...) printk( KERN_INFO "smschar - %s(): " fmt, __FUNCTION__, ## args) + +#else /* not debugging: nothing */ + + #define PDEBUG(fmt, args...) + #define PERROR(fmt, args...) + #define PWARNING(fmt, args...) + +#endif + +smschar_device_t smschar_devices[SMSCHAR_NR_DEVS]; +static int g_smschar_inuse = 0; + +/** + * unregisters sms client and returns all queued buffers + * + * @param dev pointer to the client context (smschar parameters block) + * + */ +void smschar_unregister_client(smschar_device_t* dev) +{ + unsigned long flags; + + if (dev->coredev && dev->smsclient) + { + wake_up_interruptible(&dev->waitq); + + spin_lock_irqsave(&dev->lock, flags); + + while (!list_empty(&dev->pending_data)) + { + smscore_buffer_t *cb = (smscore_buffer_t *) dev->pending_data.next; + list_del(&cb->entry); + + smscore_putbuffer(dev->coredev, cb); + + dev->pending_count --; + } + + if (dev->currentcb) + { + smscore_putbuffer(dev->coredev, dev->currentcb); + dev->currentcb = NULL; + dev->pending_count --; + } + + smscore_unregister_client(dev->smsclient); + dev->smsclient = NULL; + + spin_unlock_irqrestore(&dev->lock, flags); + } +} + +/** + * queues incoming buffers into buffers queue + * + * @param context pointer to the client context (smschar parameters block) + * @param cb pointer to incoming buffer descriptor + * + * @return 0 on success, <0 on queue overflow. + */ +int smschar_onresponse(void *context, smscore_buffer_t *cb) +{ + smschar_device_t *dev = context; + unsigned long flags; + + spin_lock_irqsave(&dev->lock, flags); + + if (dev->pending_count > SMS_CHR_MAX_Q_LEN) + { + spin_unlock_irqrestore(&dev->lock, flags); + return -EBUSY; + } + + dev->pending_count ++; + + // if data channel, remove header + if (dev->device_index) + { + cb->size -= sizeof(SmsMsgHdr_ST); + cb->offset += sizeof(SmsMsgHdr_ST); + } + + list_add_tail(&cb->entry, &dev->pending_data); + spin_unlock_irqrestore(&dev->lock, flags); + + if (waitqueue_active(&dev->waitq)) + wake_up_interruptible(&dev->waitq); + + return 0; +} + +/** + * handles device removal event + * + * @param context pointer to the client context (smschar parameters block) + * + */ +void smschar_onremove(void *context) +{ + smschar_device_t *dev = (smschar_device_t *) context; + + smschar_unregister_client(dev); + dev->coredev = NULL; +} + +/** + * registers client associated with the node + * + * @param inode Inode concerned. + * @param file File concerned. + * + * @return 0 on success, <0 on error. + */ +int smschar_open (struct inode *inode, struct file *file) +{ + smschar_device_t *dev = container_of(inode->i_cdev, smschar_device_t, cdev); + int rc = -ENODEV; + + PDEBUG("entering index %d\n", dev->device_index); + + if (dev->coredev) + { + smsclient_params_t params; + + params.initial_id = dev->device_index ? dev->device_index : SMS_HOST_LIB; + params.data_type = dev->device_index ? MSG_SMS_DAB_CHANNEL : 0; + params.onresponse_handler = smschar_onresponse; + params.onremove_handler = smschar_onremove; + params.context = dev; + + rc = smscore_register_client(dev->coredev, ¶ms, &dev->smsclient); + if (!rc) + { + file->private_data = dev; + } + } + + PDEBUG("exiting, rc %d\n", rc); + + return rc; +} + +/** + * unregisters client associated with the node + * + * @param inode Inode concerned. + * @param file File concerned. + * + */ +int smschar_release(struct inode *inode, struct file *file) +{ + smschar_unregister_client(file->private_data); + + PDEBUG("exiting\n"); + + return 0; +} + +/** + * copies data from buffers in incoming queue into a user buffer + * + * @param file File structure. + * @param buf Source buffer. + * @param count Size of source buffer. + * @param f_pos Position in file (ignored). + * + * @return Number of bytes read, or <0 on error. + */ +ssize_t smschar_read ( struct file * file, char __user * buf, size_t count, loff_t * f_pos ) +{ + smschar_device_t *dev = file->private_data; + unsigned long flags; + int copied = 0; + + if (!dev->coredev || !dev->smsclient) + { + PERROR("no client\n"); + return -ENODEV; + } + + while (copied != count) + { + if (0 > wait_event_interruptible(dev->waitq, !list_empty(&dev->pending_data))) + { + PERROR("wait_event_interruptible error\n"); + return -ENODEV; + } + + if (!dev->smsclient) + { + PERROR("no client\n"); + return -ENODEV; + } + + spin_lock_irqsave(&dev->lock, flags); + + while (!list_empty(&dev->pending_data) && (copied != count)) + { + smscore_buffer_t *cb = (smscore_buffer_t *) dev->pending_data.next; + int actual_size = min(((int) count - copied), cb->size); + + copy_to_user(&buf[copied], &((char*)cb->p)[cb->offset], actual_size); + + copied += actual_size; + cb->offset += actual_size; + cb->size -= actual_size; + + if (!cb->size) + { + list_del(&cb->entry); + smscore_putbuffer(dev->coredev, cb); + + dev->pending_count --; + } + } + + spin_unlock_irqrestore(&dev->lock, flags); + } + + return copied; +} + +/** + * sends the buffer to the associated device + * + * @param file File structure. + * @param buf Source buffer. + * @param count Size of source buffer. + * @param f_pos Position in file (ignored). + * + * @return Number of bytes read, or <0 on error. + */ +ssize_t smschar_write(struct file *file, const char __user *buf, size_t count, loff_t *f_pos) +{ + smschar_device_t *dev = file->private_data; + void *buffer; + + if (!dev->smsclient) + { + PERROR("no client\n"); + return -ENODEV; + } + + buffer = kmalloc(ALIGN(count, SMS_ALLOC_ALIGNMENT) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); + if (buffer) + { + void *msg_buffer = (void*) SMS_ALIGN_ADDRESS(buffer); + + if (!copy_from_user(msg_buffer, buf, count)) + smsclient_sendrequest(dev->smsclient, msg_buffer, count); + else + count = 0; + + kfree(buffer); + } + + return count; +} + +int smschar_mmap(struct file *file, struct vm_area_struct *vma) +{ + smschar_device_t *dev = file->private_data; + return smscore_map_common_buffer(dev->coredev, vma); +} + +/** + * waits until buffer inserted into a queue. when inserted buffer offset are reported + * to the calling process. previously reported buffer is returned to smscore pool + * + * @param dev pointer to smschar parameters block + * @param touser pointer to a structure that receives incoming buffer offsets + * + * @return 0 on success, <0 on error. + */ +int smschar_wait_get_buffer(smschar_device_t* dev, smschar_buffer_t* touser) +{ + unsigned long flags; + int rc; + + spin_lock_irqsave(&dev->lock, flags); + + if (dev->currentcb) + { + smscore_putbuffer(dev->coredev, dev->currentcb); + dev->currentcb = NULL; + dev->pending_count --; + } + + spin_unlock_irqrestore(&dev->lock, flags); + + rc = wait_event_interruptible(dev->waitq, !list_empty(&dev->pending_data)); + if (rc < 0) + { + PERROR("wait_event_interruptible error\n"); + return rc; + } + + if (!dev->smsclient) + { + PERROR("no client\n"); + return -ENODEV; + } + + spin_lock_irqsave(&dev->lock, flags); + + if (!list_empty(&dev->pending_data)) + { + smscore_buffer_t *cb = (smscore_buffer_t *) dev->pending_data.next; + + touser->offset = cb->offset_in_common + cb->offset; + touser->size = cb->size; + + list_del(&cb->entry); + + dev->currentcb = cb; + } + else + { + touser->offset = 0; + touser->size = 0; + } + + spin_unlock_irqrestore(&dev->lock, flags); + + return 0; +} + +int smschar_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) +{ + smschar_device_t *dev = file->private_data; + void __user *up = (void __user *) arg; + + if (!dev->coredev || !dev->smsclient) + { + PERROR("no client\n"); + return -ENODEV; + } + + switch(cmd) + { + case SMSCHAR_SET_DEVICE_MODE: + return smscore_set_device_mode(dev->coredev, (int) arg); + + case SMSCHAR_GET_DEVICE_MODE: + { + if (put_user(smscore_get_device_mode(dev->coredev), (int*) up)) + return -EFAULT; + + break; + } + + case SMSCHAR_GET_BUFFER_SIZE: + { + if (put_user(smscore_get_common_buffer_size(dev->coredev), (int*) up)) + return -EFAULT; + + break; + } + + case SMSCHAR_WAIT_GET_BUFFER: + { + smschar_buffer_t touser; + int rc; + + rc = smschar_wait_get_buffer(dev, &touser); + if (rc < 0) + return rc; + + if (copy_to_user(up, &touser, sizeof(smschar_buffer_t))) + return -EFAULT; + + break; + } + + default: + return -ENOIOCTLCMD; + } + + return 0; +} + +struct file_operations smschar_fops = +{ + .owner = THIS_MODULE, + .read = smschar_read, + .write = smschar_write, + .open = smschar_open, + .release = smschar_release, + .mmap = smschar_mmap, + .ioctl = smschar_ioctl, +}; + +static int smschar_setup_cdev ( smschar_device_t *dev, int index ) +{ + int rc, devno = MKDEV ( smschar_major, smschar_minor + index ); + + cdev_init ( &dev->cdev, &smschar_fops ); + + dev->cdev.owner = THIS_MODULE; + dev->cdev.ops = &smschar_fops; + + kobject_set_name(&dev->cdev.kobj, "Siano_sms%d", index); + + rc = cdev_add ( &dev->cdev, devno, 1 ); + + PDEBUG("exiting %p %d, rc %d\n", dev, index, rc); + + return rc; +} + +/** + * smschar callback that called when device plugged in/out. the function + * register or unregisters char device interface according to plug in/out + * + * @param coredev pointer to device that is being plugged in/out + * @param device pointer to system device object + * @param arrival 1 on plug-on, 0 othewise + * + * @return 0 on success, <0 on error. + */ +int smschar_hotplug(smscore_device_t* coredev, struct device* device, int arrival) +{ + int rc = 0, i; + + PDEBUG("entering %d\n", arrival); + + if (arrival) + { + // currently only 1 instance supported + if (!g_smschar_inuse) + { + /* data notification callbacks assignment */ + memset ( smschar_devices, 0, SMSCHAR_NR_DEVS * sizeof ( smschar_device_t ) ); + + /* Initialize each device. */ + for (i = 0; i < SMSCHAR_NR_DEVS; i++) + { + smschar_setup_cdev ( &smschar_devices[i], i ); + + INIT_LIST_HEAD(&smschar_devices[i].pending_data); + spin_lock_init(&smschar_devices[i].lock); + init_waitqueue_head(&smschar_devices[i].waitq); + + smschar_devices[i].coredev = coredev; + smschar_devices[i].device_index = i; + } + + g_smschar_inuse = 1; + } + } + else + { + // currently only 1 instance supported + if (g_smschar_inuse) + { + /* Get rid of our char dev entries */ + for(i = 0; i < SMSCHAR_NR_DEVS; i++) + cdev_del(&smschar_devices[i].cdev); + + g_smschar_inuse = 0; + } + } + + PDEBUG("exiting, rc %d\n", rc); + + return rc; /* succeed */ +} + +int smschar_initialize(void) +{ + dev_t devno = MKDEV ( smschar_major, smschar_minor ); + int rc; + + if(smschar_major) + { + rc = register_chrdev_region ( devno, SMSCHAR_NR_DEVS, "smschar" ); + } + else + { + rc = alloc_chrdev_region ( &devno, smschar_minor, SMSCHAR_NR_DEVS, "smschar" ); + smschar_major = MAJOR ( devno ); + } + + if (rc < 0) + { + PWARNING ( "smschar: can't get major %d\n", smschar_major ); + return rc; + } + + return smscore_register_hotplug(smschar_hotplug); +} + +void smschar_terminate(void) +{ + dev_t devno = MKDEV ( smschar_major, smschar_minor ); + + unregister_chrdev_region(devno, SMSCHAR_NR_DEVS); + smscore_unregister_hotplug(smschar_hotplug); +} diff --git a/linux/drivers/media/mdtv/smschar.h b/linux/drivers/media/mdtv/smschar.h new file mode 100644 index 000000000..1cd2f32a7 --- /dev/null +++ b/linux/drivers/media/mdtv/smschar.h @@ -0,0 +1,7 @@ +#ifndef __smschar_h__ +#define __smschar_h__ + +extern int smschar_initialize(void); +extern void smschar_terminate(void); + +#endif // __smschar_h__ diff --git a/linux/drivers/media/mdtv/smscharioctl.h b/linux/drivers/media/mdtv/smscharioctl.h new file mode 100644 index 000000000..e57b89efc --- /dev/null +++ b/linux/drivers/media/mdtv/smscharioctl.h @@ -0,0 +1,17 @@ +#ifndef __smscharioctl_h__ +#define __smscharioctl_h__ + +#include + +typedef struct _smschar_buffer_t +{ + unsigned long offset; // offset in common buffer (mapped to user space) + int size; +} smschar_buffer_t; + +#define SMSCHAR_SET_DEVICE_MODE _IOW('K', 0, int) +#define SMSCHAR_GET_DEVICE_MODE _IOR('K', 1, int) +#define SMSCHAR_GET_BUFFER_SIZE _IOR('K', 2, int) +#define SMSCHAR_WAIT_GET_BUFFER _IOR('K', 3, smschar_buffer_t) + +#endif // __smscharioctl_h__ diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c new file mode 100644 index 000000000..27572f04a --- /dev/null +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -0,0 +1,1225 @@ +/*! + + \file smscoreapi.c + + \brief Siano core API module + This file contains implementation for the interface to sms core component + + \par Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. + + \par This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License version 3 as + published by the Free Software Foundation; + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. + + \author Anatoly Greenblat + +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include "smskdefs.h" // device, page, scatterlist, kmutex + +#include + +#include "smscoreapi.h" +#include "smstypes.h" + +#include "smschar.h" + +typedef struct _smscore_device_notifyee +{ + struct list_head entry; + hotplug_t hotplug; +} smscore_device_notifyee_t; + +typedef struct _smscore_client +{ + struct list_head entry; + smscore_device_t *coredev; + + void *context; + + int data_type; + + onresponse_t onresponse_handler; + onremove_t onremove_handler; +} *psmscore_client_t; + +typedef struct _smscore_subclient +{ + struct list_head entry; + smscore_client_t *client; + + int id; +} smscore_subclient_t; + +typedef struct _smscore_device +{ + struct list_head entry; + + struct list_head clients; + struct list_head subclients; + spinlock_t clientslock; + + struct list_head buffers; + spinlock_t bufferslock; + int num_buffers; + + void *common_buffer; + int common_buffer_size; + dma_addr_t common_buffer_phys; + + void *context; + struct device *device; + + char devpath[32]; + unsigned long device_flags; + + setmode_t setmode_handler; + detectmode_t detectmode_handler; + sendrequest_t sendrequest_handler; + preload_t preload_handler; + postload_t postload_handler; + + int mode, modes_supported; + + struct completion version_ex_done, data_download_done, trigger_done; + struct completion init_device_done, reload_start_done, resume_done; +} *psmscore_device_t; + +typedef struct _smscore_registry_entry +{ + struct list_head entry; + char devpath[32]; + int mode; +} smscore_registry_entry_t; + +struct list_head g_smscore_notifyees; +struct list_head g_smscore_devices; +kmutex_t g_smscore_deviceslock; + +struct list_head g_smscore_registry; +kmutex_t g_smscore_registrylock; + +static int default_mode = 1; +module_param(default_mode, int, 0644); +MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); + +int smscore_registry_getmode(char* devpath) +{ + smscore_registry_entry_t *entry; + struct list_head *next; + + kmutex_lock(&g_smscore_registrylock); + + for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) + { + entry = (smscore_registry_entry_t *) next; + + if (!strcmp(entry->devpath, devpath)) + { + kmutex_unlock(&g_smscore_registrylock); + return entry->mode; + } + } + + entry = (smscore_registry_entry_t *) kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); + if (entry) + { + entry->mode = default_mode; + strcpy(entry->devpath, devpath); + + list_add(&entry->entry, &g_smscore_registry); + } + + kmutex_unlock(&g_smscore_registrylock); + + return default_mode; +} + +void smscore_registry_setmode(char* devpath, int mode) +{ + smscore_registry_entry_t *entry; + struct list_head *next; + + kmutex_lock(&g_smscore_registrylock); + + for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) + { + entry = (smscore_registry_entry_t *) next; + + if (!strcmp(entry->devpath, devpath)) + { + entry->mode = mode; + break; + } + } + + kmutex_unlock(&g_smscore_registrylock); +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) +void *kzalloc(size_t size, int flags) +{ + void *ret = kmalloc(size, flags); + if (ret) + memset(ret, 0, size); + return ret; +} + +static inline unsigned long kvirt_to_pa(unsigned long adr) +{ + unsigned long kva, ret; + + kva = (unsigned long) page_address(virt_to_page((void *)adr)); + kva |= adr & (PAGE_SIZE-1); /* restore the offset */ + ret = __pa(kva); + return ret; +} + +unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout) +{ + might_sleep(); + + spin_lock_irq(&x->wait.lock); + if (!x->done) { + DECLARE_WAITQUEUE(wait, current); + + wait.flags |= WQ_FLAG_EXCLUSIVE; + __add_wait_queue_tail(&x->wait, &wait); + do { + __set_current_state(TASK_UNINTERRUPTIBLE); + spin_unlock_irq(&x->wait.lock); + timeout = schedule_timeout(timeout); + spin_lock_irq(&x->wait.lock); + if (!timeout) { + __remove_wait_queue(&x->wait, &wait); + goto out; + } + } while (!x->done); + __remove_wait_queue(&x->wait, &wait); + } + x->done--; +out: + spin_unlock_irq(&x->wait.lock); + return timeout; +} +#endif + +void list_add_locked(struct list_head *new, struct list_head *head, spinlock_t* lock) +{ + unsigned long flags; + + spin_lock_irqsave(lock, flags); + + list_add(new, head); + + spin_unlock_irqrestore(lock, flags); +} + +/** + * register a client callback that called when device plugged in/unplugged + * NOTE: if devices exist callback is called immediately for each device + * + * @param hotplug callback + * + * @return 0 on success, <0 on error. + */ +int smscore_register_hotplug(hotplug_t hotplug) +{ + smscore_device_notifyee_t *notifyee; + struct list_head *next, *first; + int rc = 0; + + kmutex_lock(&g_smscore_deviceslock); + + notifyee = kmalloc(sizeof(smscore_device_notifyee_t), GFP_KERNEL); + if (notifyee) + { + // now notify callback about existing devices + first = &g_smscore_devices; + for (next = first->next; next != first && !rc; next = next->next) + { + smscore_device_t *coredev = (smscore_device_t *) next; + rc = hotplug(coredev, coredev->device, 1); + } + + if (rc >= 0) + { + notifyee->hotplug = hotplug; + list_add(¬ifyee->entry, &g_smscore_notifyees); + } + else + kfree(notifyee); + } + else + rc = -ENOMEM; + + kmutex_unlock(&g_smscore_deviceslock); + + return rc; +} + +/** + * unregister a client callback that called when device plugged in/unplugged + * + * @param hotplug callback + * + */ +void smscore_unregister_hotplug(hotplug_t hotplug) +{ + struct list_head *next, *first; + + kmutex_lock(&g_smscore_deviceslock); + + first = &g_smscore_notifyees; + + for (next = first->next; next != first;) + { + smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) next; + next = next->next; + + if (notifyee->hotplug == hotplug) + { + list_del(¬ifyee->entry); + kfree(notifyee); + } + } + + kmutex_unlock(&g_smscore_deviceslock); +} + +void smscore_notify_clients(smscore_device_t *coredev) +{ + smscore_client_t* client; + + // the client must call smscore_unregister_client from remove handler + while (!list_empty(&coredev->clients)) + { + client = (smscore_client_t *) coredev->clients.next; + client->onremove_handler(client->context); + } +} + +int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, int arrival) +{ + struct list_head *next, *first; + int rc = 0; + + // note: must be called under g_deviceslock + + first = &g_smscore_notifyees; + + for (next = first->next; next != first; next = next->next) + { + rc = ((smscore_device_notifyee_t *) next)->hotplug(coredev, device, arrival); + if (rc < 0) + break; + } + + return rc; +} + +smscore_buffer_t *smscore_createbuffer(u8* buffer, void* common_buffer, dma_addr_t common_buffer_phys) +{ + smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); + if (!cb) + { + printk(KERN_INFO "%s kmalloc(...) failed\n", __FUNCTION__); + return NULL; + } + + cb->p = buffer; + cb->offset_in_common = buffer - (u8*) common_buffer; + cb->phys = common_buffer_phys + cb->offset_in_common; + + return cb; +} + +/** + * creates coredev object for a device, prepares buffers, creates buffer mappings, notifies + * registered hotplugs about new device. + * + * @param params device pointer to struct with device specific parameters and handlers + * @param coredev pointer to a value that receives created coredev object + * + * @return 0 on success, <0 on error. + */ +int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev) +{ + smscore_device_t* dev; + u8 *buffer; + + dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); + if (!dev) + { + printk(KERN_INFO "%s kzalloc(...) failed\n", __FUNCTION__); + return -ENOMEM; + } + + // init list entry so it could be safe in smscore_unregister_device + INIT_LIST_HEAD(&dev->entry); + + // init queues + INIT_LIST_HEAD(&dev->clients); + INIT_LIST_HEAD(&dev->subclients); + INIT_LIST_HEAD(&dev->buffers); + + // init locks + spin_lock_init(&dev->clientslock); + spin_lock_init(&dev->bufferslock); + + // init completion events + init_completion(&dev->version_ex_done); + init_completion(&dev->data_download_done); + init_completion(&dev->trigger_done); + init_completion(&dev->init_device_done); + init_completion(&dev->reload_start_done); + init_completion(&dev->resume_done); + + // alloc common buffer + dev->common_buffer_size = params->buffer_size * params->num_buffers; + dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size, &dev->common_buffer_phys, GFP_KERNEL | GFP_DMA); + if (!dev->common_buffer) + { + smscore_unregister_device(dev); + return -ENOMEM; + } + + // prepare dma buffers + for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; dev->num_buffers ++, buffer += params->buffer_size) + { + smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); + if (!cb) + { + smscore_unregister_device(dev); + return -ENOMEM; + } + + smscore_putbuffer(dev, cb); + } + + printk(KERN_INFO "%s allocated %d buffers\n", __FUNCTION__, dev->num_buffers); + + dev->mode = DEVICE_MODE_NONE; + dev->context = params->context; + dev->device = params->device; + dev->setmode_handler = params->setmode_handler; + dev->detectmode_handler = params->detectmode_handler; + dev->sendrequest_handler = params->sendrequest_handler; + dev->preload_handler = params->preload_handler; + dev->postload_handler = params->postload_handler; + + dev->device_flags = params->flags; + strcpy(dev->devpath, params->devpath); + + // add device to devices list + kmutex_lock(&g_smscore_deviceslock); + list_add(&dev->entry, &g_smscore_devices); + kmutex_unlock(&g_smscore_deviceslock); + + *coredev = dev; + + printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); + + return 0; +} + +/** + * sets initial device mode and notifies client hotplugs that device is ready + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return 0 on success, <0 on error. + */ +int smscore_start_device(smscore_device_t *coredev) +{ + int rc = smscore_set_device_mode(coredev, smscore_registry_getmode(coredev->devpath)); + if (rc < 0) + return rc; + + kmutex_lock(&g_smscore_deviceslock); + + rc = smscore_notify_callbacks(coredev, coredev->device, 1); + + printk(KERN_INFO "%s device %p started, rc %d\n", __FUNCTION__, coredev, rc); + + kmutex_unlock(&g_smscore_deviceslock); + + return rc; +} + +int smscore_sendrequest_and_wait(smscore_device_t *coredev, void* buffer, size_t size, struct completion *completion) +{ + int rc = coredev->sendrequest_handler(coredev->context, buffer, size); + if (rc < 0) + return rc; + + return wait_for_completion_timeout(completion, msecs_to_jiffies(1000)) ? 0 : -ETIME; +} + +int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_t size) +{ + SmsFirmware_ST* firmware = (SmsFirmware_ST*) buffer; + SmsMsgHdr_ST *msg; + UINT32 mem_address = firmware->StartAddress; + u8* payload = firmware->Payload; + int rc = 0; + + if (coredev->preload_handler) + { + rc = coredev->preload_handler(coredev->context); + if (rc < 0) + return rc; + } + + // PAGE_SIZE buffer shall be enough and dma aligned + msg = (SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); + if (!msg) + return -ENOMEM; + + if (coredev->mode != DEVICE_MODE_NONE) + { + SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(SmsMsgHdr_ST)); + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); + mem_address = *(UINT32*) &payload[20]; + } + + while (size && rc >= 0) + { + SmsDataDownload_ST *DataMsg = (SmsDataDownload_ST *) msg; + int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); + + SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, (UINT16)(sizeof(SmsMsgHdr_ST) + sizeof(UINT32) + payload_size)); + + DataMsg->MemAddr = mem_address; + memcpy(DataMsg->Payload, payload, payload_size); + + if (coredev->device_flags & SMS_ROM_NO_RESPONSE && coredev->mode == DEVICE_MODE_NONE) + rc = coredev->sendrequest_handler(coredev->context, DataMsg, DataMsg->xMsgHeader.msgLength); + else + rc = smscore_sendrequest_and_wait(coredev, DataMsg, DataMsg->xMsgHeader.msgLength, &coredev->data_download_done); + + payload += payload_size; + size -= payload_size; + mem_address += payload_size; + } + + if (rc >= 0) + { + if (coredev->mode == DEVICE_MODE_NONE) + { + SmsMsgData_ST* TriggerMsg = (SmsMsgData_ST*) msg; + + SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, sizeof(SmsMsgHdr_ST) + sizeof(UINT32) * 5); + + TriggerMsg->msgData[0] = firmware->StartAddress; // Entry point + TriggerMsg->msgData[1] = 5; // Priority + TriggerMsg->msgData[2] = 0x200; // Stack size + TriggerMsg->msgData[3] = 0; // Parameter + TriggerMsg->msgData[4] = 4; // Task ID + + if (coredev->device_flags & SMS_ROM_NO_RESPONSE) + { + rc = coredev->sendrequest_handler(coredev->context, TriggerMsg, TriggerMsg->xMsgHeader.msgLength); + msleep(100); + } + else + rc = smscore_sendrequest_and_wait(coredev, TriggerMsg, TriggerMsg->xMsgHeader.msgLength, &coredev->trigger_done); + } + else + { + SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, sizeof(SmsMsgHdr_ST)); + + rc = coredev->sendrequest_handler(coredev->context, msg, msg->msgLength); + } + } + + printk("%s %d \n", __func__, rc); + + kfree(msg); + + return (rc >= 0 && coredev->postload_handler) ? + coredev->postload_handler(coredev->context) : + rc; +} + +/** + * loads specified firmware into a buffer and calls device loadfirmware_handler + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param filename null-terminated string specifies firmware file name + * @param loadfirmware_handler device handler that loads firmware + * + * @return 0 on success, <0 on error. + */ +int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler) +{ + int rc = -ENOENT; + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) + const struct firmware *fw; + u8* fw_buffer; + + if (loadfirmware_handler == NULL && !(coredev->device_flags & SMS_DEVICE_FAMILY2)) + return -EINVAL; + + rc = request_firmware(&fw, filename, coredev->device); + if (rc < 0) + { + printk(KERN_INFO "%s failed to open \"%s\"\n", __FUNCTION__, filename); + return rc; + } + + fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); + if (fw_buffer) + { + memcpy(fw_buffer, fw->data, fw->size); + + rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ? + smscore_load_firmware_family2(coredev, fw_buffer, fw->size) : + loadfirmware_handler(coredev->context, fw_buffer, fw->size); + + kfree(fw_buffer); + } + else + { + printk(KERN_INFO "%s failed to allocate firmware buffer\n", __FUNCTION__); + rc = -ENOMEM; + } + + release_firmware(fw); +#endif + + return rc; +} + +/** + * notifies all clients registered with the device, notifies hotplugs, frees all buffers and coredev object + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return 0 on success, <0 on error. + */ +void smscore_unregister_device(smscore_device_t *coredev) +{ + smscore_buffer_t *cb; + int num_buffers = 0; + + kmutex_lock(&g_smscore_deviceslock); + + smscore_notify_clients(coredev); + smscore_notify_callbacks(coredev, NULL, 0); + + // at this point all buffers should be back + // onresponse must no longer be called + + while (1) + { + while ((cb = smscore_getbuffer(coredev))) + { + kfree(cb); + num_buffers ++; + } + + if (num_buffers == coredev->num_buffers) + break; + + printk(KERN_INFO "%s waiting for %d buffer(s)\n", __FUNCTION__, coredev->num_buffers - num_buffers); + msleep(100); + } + + printk(KERN_INFO "%s freed %d buffers\n", __FUNCTION__, num_buffers); + + if (coredev->common_buffer) + dma_free_coherent(NULL, coredev->common_buffer_size, coredev->common_buffer, coredev->common_buffer_phys); + + list_del(&coredev->entry); + kfree(coredev); + + kmutex_unlock(&g_smscore_deviceslock); + + printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, coredev); +} + +int smscore_detect_mode(smscore_device_t *coredev) +{ + void *buffer = kmalloc(sizeof(SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); + SmsMsgHdr_ST *msg = (SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer); + int rc; + + if (!buffer) + return -ENOMEM; + + SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ, sizeof(SmsMsgHdr_ST)); + + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); + if (rc == -ETIME) + { + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __FUNCTION__); + + if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) + { + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); + if (rc < 0) + { + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __FUNCTION__, rc); + } + } + else + rc = -ETIME; + } + + kfree(buffer); + + return rc; +} + +char *smscore_fw_lkup[] = +{ + "dvb_nova_12mhz.inp", + "dvb_nova_12mhz.inp", + "tdmb_nova.inp", + "none", + "dvb_nova_12mhz.inp", + "isdbt_nova_12mhz.inp", + "isdbt_nova_12mhz.inp", + "cmmb_nova_12mhz.inp", + "none", +}; + +/** + * calls device handler to change mode of operation + * NOTE: stellar/usb may disconnect when changing mode + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param mode requested mode of operation + * + * @return 0 on success, <0 on error. + */ +int smscore_set_device_mode(smscore_device_t *coredev, int mode) +{ + void *buffer; + int rc = 0; + + if (coredev->device_flags & SMS_DEVICE_FAMILY2) + { + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) + { + printk(KERN_INFO "%s invalid mode specified %d\n", __FUNCTION__, mode); + return -EINVAL; + } + + if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) + { + rc = smscore_detect_mode(coredev); + if (rc < 0) + return rc; + } + + if (coredev->mode == mode) + { + printk(KERN_INFO "%s device mode %d already set\n", __FUNCTION__, mode); + return 0; + } + + if (!(coredev->modes_supported & (1 << mode))) + { + rc = smscore_load_firmware(coredev, smscore_fw_lkup[mode], NULL); + if (rc < 0) + return rc; + } + else + { + printk(KERN_INFO "%s mode %d supported by running firmware\n", __FUNCTION__, mode); + } + + buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); + if (buffer) + { + SmsMsgData_ST *msg = (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); + + SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, sizeof(SmsMsgData_ST)); + msg->msgData[0] = mode; + + rc = smscore_sendrequest_and_wait(coredev, msg, msg->xMsgHeader.msgLength, &coredev->init_device_done); + + kfree(buffer); + } + else + rc = -ENOMEM; + } + else + { + if (coredev->detectmode_handler) + coredev->detectmode_handler(coredev->context, &coredev->mode); + + if (coredev->mode != mode && coredev->setmode_handler) + rc = coredev->setmode_handler(coredev->context, mode); + } + + smscore_registry_setmode(coredev->devpath, mode); + + if (rc >= 0) + { + coredev->mode = mode; + coredev->device_flags &= ~SMS_DEVICE_NOT_READY; + } + + return rc; +} + +/** + * calls device handler to get current mode of operation + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return current mode + */ +int smscore_get_device_mode(smscore_device_t *coredev) +{ + return coredev->mode; +} + +smscore_client_t* smscore_getclient_by_type(smscore_device_t *coredev, int data_type) +{ + smscore_client_t *client = NULL; + struct list_head *next, *first; + unsigned long flags; + + if (!data_type) + return NULL; + + spin_lock_irqsave(&coredev->clientslock, flags); + + first = &coredev->clients; + + for (next = first->next; next != first; next = next->next) + { + if (((smscore_client_t*) next)->data_type == data_type) + { + client = (smscore_client_t*) next; + break; + } + } + + spin_unlock_irqrestore(&coredev->clientslock, flags); + + return client; +} + +smscore_client_t* smscore_getclient_by_id(smscore_device_t *coredev, int id) +{ + smscore_client_t *client = NULL; + struct list_head *next, *first; + unsigned long flags; + + spin_lock_irqsave(&coredev->clientslock, flags); + + first = &coredev->subclients; + + for (next = first->next; next != first; next = next->next) + { + if (((smscore_subclient_t*) next)->id == id) + { + client = ((smscore_subclient_t*) next)->client; + break; + } + } + + spin_unlock_irqrestore(&coredev->clientslock, flags); + + return client; +} + +/** + * find client by response id/type, call clients onresponse handler + * return buffer to pool on error + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param cb pointer to response buffer descriptor + * + */ +void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) +{ + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8*) cb->p + cb->offset); + smscore_client_t * client = smscore_getclient_by_type(coredev, phdr->msgType); + int rc = -EBUSY; + +#if 1 + static unsigned long last_sample_time = 0; + static int data_total = 0; + unsigned long time_now = jiffies_to_msecs(jiffies); + + if (!last_sample_time) + last_sample_time = time_now; + + if (time_now - last_sample_time > 10000) + { + printk("\n%s data rate %d bytes/secs\n", __func__, (int)((data_total * 1000) / (time_now - last_sample_time))); + + last_sample_time = time_now; + data_total = 0; + } + + data_total += cb->size; +#endif + + if (!client) + client = smscore_getclient_by_id(coredev, phdr->msgDstId); + + if (client) + rc = client->onresponse_handler(client->context, cb); + + if (rc < 0) + { + switch (phdr->msgType) + { + case MSG_SMS_GET_VERSION_EX_RES: + { + SmsVersionRes_ST *ver = (SmsVersionRes_ST*) phdr; + printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d prots 0x%x ver %d.%d\n", __FUNCTION__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); + + coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; + coredev->modes_supported = ver->SupportedProtocols; + + complete(&coredev->version_ex_done); + break; + } + + case MSG_SMS_INIT_DEVICE_RES: + printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __FUNCTION__); + complete(&coredev->init_device_done); + break; + + case MSG_SW_RELOAD_START_RES: + printk("%s: MSG_SW_RELOAD_START_RES\n", __FUNCTION__); + complete(&coredev->reload_start_done); + break; + + case MSG_SMS_DATA_DOWNLOAD_RES: + complete(&coredev->data_download_done); + break; + + case MSG_SW_RELOAD_EXEC_RES: + printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __FUNCTION__); + break; + + case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: + printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __FUNCTION__); + complete(&coredev->trigger_done); + break; + + case MSG_SMS_SLEEP_RESUME_COMP_IND: + complete(&coredev->resume_done); + break; + + default: + printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __FUNCTION__, client, rc, phdr->msgType, phdr->msgDstId); + } + + smscore_putbuffer(coredev, cb); + } +} + +/** + * return pointer to next free buffer descriptor from core pool + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return pointer to descriptor on success, NULL on error. + */ +smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) +{ + smscore_buffer_t *cb = NULL; + unsigned long flags; + + spin_lock_irqsave(&coredev->bufferslock, flags); + + if (!list_empty(&coredev->buffers)) + { + cb = (smscore_buffer_t *) coredev->buffers.next; + list_del(&cb->entry); + } + + spin_unlock_irqrestore(&coredev->bufferslock, flags); + + return cb; +} + +/** + * return buffer descriptor to a pool + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param cb pointer buffer descriptor + * + */ +void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb) +{ + list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); +} + +int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int id) +{ + smscore_client_t *existing_client; + smscore_subclient_t *subclient; + + if (!id) + return 0; + + existing_client = smscore_getclient_by_id(coredev, id); + if (existing_client == client) + return 0; + + if (existing_client) + return -EBUSY; + + subclient = kzalloc(sizeof(smscore_subclient_t), GFP_KERNEL); + if (!subclient) + return -ENOMEM; + + subclient->client = client; + subclient->id = id; + + list_add_locked(&subclient->entry, &coredev->subclients, &coredev->clientslock); + + return 0; +} + +/** + * creates smsclient object, check that id is taken by another client + * + * @param coredev pointer to a coredev object from clients hotplug + * @param initial_id all messages with this id would be sent to this client + * @param data_type all messages of this type would be sent to this client + * @param onresponse_handler client handler that is called to process incoming messages + * @param onremove_handler client handler that is called when device is removed + * @param context client-specific context + * @param client pointer to a value that receives created smsclient object + * + * @return 0 on success, <0 on error. + */ +int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) +{ + smscore_client_t* newclient; + int rc; + + // check that no other channel with same data type exists + if (params->data_type && smscore_getclient_by_type(coredev, params->data_type)) + return -EEXIST; + + newclient = kzalloc(sizeof(smscore_client_t), GFP_KERNEL); + if (!newclient) + return -ENOMEM; + + // check that no other channel with same id exists + rc = smscore_validate_client(coredev, newclient, params->initial_id); + if (rc < 0) + { + kfree(newclient); + return rc; + } + + newclient->coredev = coredev; + newclient->data_type = params->data_type; + newclient->onresponse_handler = params->onresponse_handler; + newclient->onremove_handler = params->onremove_handler; + newclient->context = params->context; + + list_add_locked(&newclient->entry, &coredev->clients, &coredev->clientslock); + + *client = newclient; + + printk(KERN_INFO "%s %p %d %d\n", __FUNCTION__, params->context, params->data_type, params->initial_id); + + return 0; +} + +/** + * frees smsclient object and all subclients associated with it + * + * @param client pointer to smsclient object returned by smscore_register_client + * + */ +void smscore_unregister_client(smscore_client_t *client) +{ + smscore_device_t *coredev = client->coredev; + struct list_head *next, *first; + unsigned long flags; + + spin_lock_irqsave(&coredev->clientslock, flags); + + first = &coredev->subclients; + + for (next = first->next; next != first;) + { + smscore_subclient_t *subclient = (smscore_subclient_t *) next; + next = next->next; + + if (subclient->client == client) + { + list_del(&subclient->entry); + kfree(subclient); + } + } + + printk(KERN_INFO "%s %p %d\n", __FUNCTION__, client->context, client->data_type); + + list_del(&client->entry); + kfree(client); + + spin_unlock_irqrestore(&coredev->clientslock, flags); +} + +/** + * verifies that source id is not taken by another client, + * calls device handler to send requests to the device + * + * @param client pointer to smsclient object returned by smscore_register_client + * @param buffer pointer to a request buffer + * @param size size (in bytes) of request buffer + * + * @return 0 on success, <0 on error. + */ +int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) +{ + smscore_device_t* coredev = client->coredev; + SmsMsgHdr_ST* phdr = (SmsMsgHdr_ST*) buffer; + + // check that no other channel with same id exists + int rc = smscore_validate_client(client->coredev, client, phdr->msgSrcId); + if (rc < 0) + return rc; + + return coredev->sendrequest_handler(coredev->context, buffer, size); +} + +/** + * return the size of large (common) buffer + * + * @param coredev pointer to a coredev object from clients hotplug + * + * @return size (in bytes) of the buffer + */ +int smscore_get_common_buffer_size(smscore_device_t *coredev) +{ + return coredev->common_buffer_size; +} + +/** + * maps common buffer (if supported by platform) + * + * @param coredev pointer to a coredev object from clients hotplug + * @param vma pointer to vma struct from mmap handler + * + * @return 0 on success, <0 on error. + */ +int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma) +{ + unsigned long end = vma->vm_end, start = vma->vm_start, size = PAGE_ALIGN(coredev->common_buffer_size); + + if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) + { + printk(KERN_INFO "%s invalid vm flags\n", __FUNCTION__); + return -EINVAL; + } + + if ((end - start) != size) + { + printk(KERN_INFO "%s invalid size %d expected %d\n", __FUNCTION__, (int)(end - start), (int) size); + return -EINVAL; + } + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) + if (remap_page_range(vma, start, coredev->common_buffer_phys, size, vma->vm_page_prot)) +#else + if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) +#endif + { + printk(KERN_INFO "%s remap_page_range failed\n", __FUNCTION__); + return -EAGAIN; + } + + return 0; +} + +int smscore_module_init(void) +{ + int rc; + + INIT_LIST_HEAD(&g_smscore_notifyees); + INIT_LIST_HEAD(&g_smscore_devices); + kmutex_init(&g_smscore_deviceslock); + + INIT_LIST_HEAD(&g_smscore_registry); + kmutex_init(&g_smscore_registrylock); + + rc = smschar_initialize(); + + printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); + + return rc; +} + +void smscore_module_exit(void) +{ + smschar_terminate(); + + kmutex_lock(&g_smscore_deviceslock); + while (!list_empty(&g_smscore_notifyees)) + { + smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) g_smscore_notifyees.next; + + list_del(¬ifyee->entry); + kfree(notifyee); + } + kmutex_unlock(&g_smscore_deviceslock); + + kmutex_lock(&g_smscore_registrylock); + while (!list_empty(&g_smscore_registry)) + { + smscore_registry_entry_t *entry = (smscore_registry_entry_t *) g_smscore_registry.next; + + list_del(&entry->entry); + kfree(entry); + } + kmutex_unlock(&g_smscore_registrylock); + + printk(KERN_INFO "%s\n", __FUNCTION__); +} + +module_init(smscore_module_init); +module_exit(smscore_module_exit); + +MODULE_DESCRIPTION("smscore"); +MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); +MODULE_LICENSE("GPL"); + +EXPORT_SYMBOL(smscore_registry_setmode); +EXPORT_SYMBOL(smscore_registry_getmode); +EXPORT_SYMBOL(smscore_register_hotplug); +EXPORT_SYMBOL(smscore_unregister_hotplug); +EXPORT_SYMBOL(smscore_register_device); +EXPORT_SYMBOL(smscore_unregister_device); +EXPORT_SYMBOL(smscore_start_device); +EXPORT_SYMBOL(smscore_load_firmware); +EXPORT_SYMBOL(smscore_set_device_mode); +EXPORT_SYMBOL(smscore_get_device_mode); +EXPORT_SYMBOL(smscore_register_client); +EXPORT_SYMBOL(smscore_unregister_client); +EXPORT_SYMBOL(smsclient_sendrequest); +EXPORT_SYMBOL(smscore_onresponse); +EXPORT_SYMBOL(smscore_get_common_buffer_size); +EXPORT_SYMBOL(smscore_map_common_buffer); +EXPORT_SYMBOL(smscore_getbuffer); +EXPORT_SYMBOL(smscore_putbuffer); diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h new file mode 100644 index 000000000..a8c025f74 --- /dev/null +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -0,0 +1,101 @@ +#ifndef __smscoreapi_h__ +#define __smscoreapi_h__ + +#ifndef min +#define min(a,b) (((a) < (b)) ? (a) : (b)) +#endif + +#define SMS_ALLOC_ALIGNMENT 128 +#define SMS_DMA_ALIGNMENT 16 +#define SMS_ALIGN_ADDRESS(addr) ((((u32)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) + +#define SMS_DEVICE_FAMILY2 1 +#define SMS_ROM_NO_RESPONSE 2 +#define SMS_DEVICE_NOT_READY 0x8000000 + +typedef struct _smscore_device smscore_device_t; +typedef struct _smscore_client smscore_client_t; +typedef struct _smscore_buffer smscore_buffer_t; + +typedef int (*hotplug_t)(smscore_device_t *coredev, struct device *device, int arrival); + +typedef int (*setmode_t)(void *context, int mode); +typedef void (*detectmode_t)(void *context, int *mode); +typedef int (*sendrequest_t)(void *context, void *buffer, size_t size); +typedef int (*loadfirmware_t)(void *context, void *buffer, size_t size); +typedef int (*preload_t)(void *context); +typedef int (*postload_t)(void *context); + +typedef int (*onresponse_t)(void *context, smscore_buffer_t *cb); +typedef void (*onremove_t)(void *context); + +typedef struct _smscore_buffer +{ + // public members, once passed to clients can be changed freely + struct list_head entry; + int size; + int offset; + + // private members, read-only for clients + void *p; + dma_addr_t phys; + unsigned long offset_in_common; +} *psmscore_buffer_t; + +typedef struct _smsdevice_params +{ + struct device *device; + + int buffer_size; + int num_buffers; + + char devpath[32]; + unsigned long flags; + + setmode_t setmode_handler; + detectmode_t detectmode_handler; + sendrequest_t sendrequest_handler; + preload_t preload_handler; + postload_t postload_handler; + + void *context; +} smsdevice_params_t; + +typedef struct _smsclient_params +{ + int initial_id; + int data_type; + onresponse_t onresponse_handler; + onremove_t onremove_handler; + + void *context; +} smsclient_params_t; + +extern void smscore_registry_setmode(char *devpath, int mode); +extern int smscore_registry_getmode(char *devpath); + +extern int smscore_register_hotplug(hotplug_t hotplug); +extern void smscore_unregister_hotplug(hotplug_t hotplug); + +extern int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev); +extern void smscore_unregister_device(smscore_device_t *coredev); + +extern int smscore_start_device(smscore_device_t *coredev); +extern int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler); + +extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); +extern int smscore_get_device_mode(smscore_device_t *coredev); + +extern int smscore_register_client(smscore_device_t *coredev, smsclient_params_t* params, smscore_client_t **client); +extern void smscore_unregister_client(smscore_client_t *client); + +extern int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size); +extern void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb); + +extern int smscore_get_common_buffer_size(smscore_device_t *coredev); +extern int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma); + +extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); +extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); + +#endif // __smscoreapi_h__ diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c new file mode 100644 index 000000000..f2ed1718d --- /dev/null +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -0,0 +1,438 @@ +#include +#include + +#include "dmxdev.h" +#include "dvbdev.h" +#include "dvb_demux.h" +#include "dvb_frontend.h" + +#include "smskdefs.h" // page, scatterlist, kmutex +#include "smscoreapi.h" +#include "smstypes.h" + +typedef struct _smsdvb_client +{ + struct list_head entry; + + smscore_device_t *coredev; + smscore_client_t *smsclient; + + struct dvb_adapter adapter; + struct dvb_demux demux; + struct dmxdev dmxdev; + struct dvb_frontend frontend; + + fe_status_t fe_status; + int fe_ber, fe_snr, fe_signal_strength; + + struct completion tune_done, stat_done; + + // todo: save freq/band instead whole struct + struct dvb_frontend_parameters fe_params; + +} smsdvb_client_t; + +struct list_head g_smsdvb_clients; +kmutex_t g_smsdvb_clientslock; + +int smsdvb_onresponse(void *context, smscore_buffer_t *cb) +{ + smsdvb_client_t *client = (smsdvb_client_t *) context; + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8*) cb->p) + cb->offset); + + switch(phdr->msgType) + { + case MSG_SMS_DVBT_BDA_DATA: + dvb_dmx_swfilter(&client->demux, (u8*)(phdr + 1), cb->size - sizeof(SmsMsgHdr_ST)); + break; + + case MSG_SMS_RF_TUNE_RES: + complete(&client->tune_done); + break; + + case MSG_SMS_GET_STATISTICS_RES: + { + SmsMsgStatisticsInfo_ST* p = (SmsMsgStatisticsInfo_ST*)(phdr + 1); + + if (p->Stat.IsDemodLocked) + { + client->fe_status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK; + client->fe_snr = p->Stat.SNR; + client->fe_ber = p->Stat.BER; + + if (p->Stat.InBandPwr < -95) + client->fe_signal_strength = 0; + else if (p->Stat.InBandPwr > -29) + client->fe_signal_strength = 100; + else + client->fe_signal_strength = (p->Stat.InBandPwr + 95) * 3 / 2; + } + else + { + client->fe_status = 0; + client->fe_snr = + client->fe_ber = + client->fe_signal_strength = 0; + } + + complete(&client->stat_done); + break; + } + } + + smscore_putbuffer(client->coredev, cb); + + return 0; +} + +void smsdvb_unregister_client(smsdvb_client_t* client) +{ + // must be called under clientslock + + list_del(&client->entry); + + smscore_unregister_client(client->smsclient); + dvb_unregister_frontend(&client->frontend); + dvb_dmxdev_release(&client->dmxdev); + dvb_dmx_release(&client->demux); + dvb_unregister_adapter(&client->adapter); + kfree(client); +} + +void smsdvb_onremove(void *context) +{ + kmutex_lock(&g_smsdvb_clientslock); + + smsdvb_unregister_client((smsdvb_client_t*) context); + + kmutex_unlock(&g_smsdvb_clientslock); +} + +static int smsdvb_start_feed(struct dvb_demux_feed *feed) +{ + smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); + SmsMsgData_ST PidMsg; + + printk("%s add pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); + + PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; + PidMsg.xMsgHeader.msgDstId = HIF_TASK; + PidMsg.xMsgHeader.msgFlags = 0; + PidMsg.xMsgHeader.msgType = MSG_SMS_ADD_PID_FILTER_REQ; + PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); + PidMsg.msgData[0] = feed->pid; + + return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); +} + +static int smsdvb_stop_feed(struct dvb_demux_feed *feed) +{ + smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); + SmsMsgData_ST PidMsg; + + printk("%s remove pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); + + PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; + PidMsg.xMsgHeader.msgDstId = HIF_TASK; + PidMsg.xMsgHeader.msgFlags = 0; + PidMsg.xMsgHeader.msgType = MSG_SMS_REMOVE_PID_FILTER_REQ; + PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); + PidMsg.msgData[0] = feed->pid; + + return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); +} + +static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, void* buffer, size_t size, struct completion *completion) +{ + int rc = smsclient_sendrequest(client->smsclient, buffer, size); + if (rc < 0) + return rc; + + return wait_for_completion_timeout(completion, msecs_to_jiffies(2000)) ? 0 : -ETIME; +} + +static int smsdvb_send_statistics_request(smsdvb_client_t *client) +{ + SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, DVBT_BDA_CONTROL_MSG_ID, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->stat_done); +} + +static int smsdvb_read_status(struct dvb_frontend *fe, fe_status_t *stat) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *stat = client->fe_status; + + return rc; +} + +static int smsdvb_read_ber(struct dvb_frontend *fe, u32 *ber) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *ber = client->fe_ber; + + return rc; +} + +static int smsdvb_read_signal_strength(struct dvb_frontend *fe, u16 *strength) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *strength = client->fe_signal_strength; + + return rc; +} + +static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *snr = client->fe_snr; + + return rc; +} + +static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) +{ + printk("%s\n", __FUNCTION__); + + tune->min_delay_ms = 400; + tune->step_size = 250000; + tune->max_drift = 0; + return 0; +} + +static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + + struct + { + SmsMsgHdr_ST Msg; + u32 Data[3]; + } Msg; + + Msg.Msg.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; + Msg.Msg.msgDstId = HIF_TASK; + Msg.Msg.msgFlags = 0; + Msg.Msg.msgType = MSG_SMS_RF_TUNE_REQ; + Msg.Msg.msgLength = sizeof(Msg); + Msg.Data[0] = fep->frequency; + Msg.Data[2] = 12000000; + + printk("%s freq %d band %d\n", __FUNCTION__, fep->frequency, fep->u.ofdm.bandwidth); + + switch(fep->u.ofdm.bandwidth) + { + case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; + case BANDWIDTH_7_MHZ: Msg.Data[1] = BW_7_MHZ; break; + case BANDWIDTH_6_MHZ: Msg.Data[1] = BW_6_MHZ; break; +// case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; + case BANDWIDTH_AUTO: return -EOPNOTSUPP; + default: return -EINVAL; + } + + return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->tune_done); +} + +static int smsdvb_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + + printk("%s\n", __FUNCTION__); + + // todo: + memcpy(fep, &client->fe_params, sizeof(struct dvb_frontend_parameters)); + return 0; +} + +static void smsdvb_release(struct dvb_frontend *fe) +{ + // do nothing +} + +static struct dvb_frontend_ops smsdvb_fe_ops = { + .info = { + .name = "Siano Mobile Digital SMS10xx", + .type = FE_OFDM, + .frequency_min = 44250000, + .frequency_max = 867250000, + .frequency_stepsize = 250000, + .caps = FE_CAN_INVERSION_AUTO | + FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | + FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | + FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO | + FE_CAN_TRANSMISSION_MODE_AUTO | + FE_CAN_GUARD_INTERVAL_AUTO | + FE_CAN_RECOVER | + FE_CAN_HIERARCHY_AUTO, + }, + + .release = smsdvb_release, + + .set_frontend = smsdvb_set_frontend, + .get_frontend = smsdvb_get_frontend, + .get_tune_settings = smsdvb_get_tune_settings, + + .read_status = smsdvb_read_status, + .read_ber = smsdvb_read_ber, + .read_signal_strength = smsdvb_read_signal_strength, + .read_snr = smsdvb_read_snr, +}; + +int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival) +{ + smsclient_params_t params; + smsdvb_client_t* client; + int rc; + + // device removal handled by onremove callback + if (!arrival) + return 0; + + if (smscore_get_device_mode(coredev) != 4) + { + rc = smscore_set_device_mode(coredev, 4); + if (rc < 0) + return rc; + } + + client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); + if (!client) + { + printk(KERN_INFO "%s kmalloc() failed\n", __FUNCTION__); + return -ENOMEM; + } + + // register dvb adapter + rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device); + if (rc < 0) + { + printk("%s dvb_register_adapter() failed %d\n", __func__, rc); + goto adapter_error; + } + + // init dvb demux + client->demux.dmx.capabilities = DMX_TS_FILTERING; + client->demux.filternum = 32; // todo: nova ??? + client->demux.feednum = 32; + client->demux.start_feed = smsdvb_start_feed; + client->demux.stop_feed = smsdvb_stop_feed; + + rc = dvb_dmx_init(&client->demux); + if (rc < 0) + { + printk("%s dvb_dmx_init failed %d\n\n", __FUNCTION__, rc); + goto dvbdmx_error; + } + + // init dmxdev + client->dmxdev.filternum = 32; + client->dmxdev.demux = &client->demux.dmx; + client->dmxdev.capabilities = 0; + + rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); + if (rc < 0) + { + printk("%s dvb_dmxdev_init failed %d\n", __FUNCTION__, rc); + goto dmxdev_error; + } + + // init and register frontend + memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); + + rc = dvb_register_frontend(&client->adapter, &client->frontend); + if (rc < 0) + { + printk("%s frontend registration failed %d\n", __FUNCTION__, rc); + goto frontend_error; + } + + params.initial_id = 0; + params.data_type = MSG_SMS_DVBT_BDA_DATA; + params.onresponse_handler = smsdvb_onresponse; + params.onremove_handler = smsdvb_onremove; + params.context = client; + + rc = smscore_register_client(coredev, ¶ms, &client->smsclient); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_register_client() failed %d\n", __FUNCTION__, rc); + goto client_error; + } + + client->coredev = coredev; + + init_completion(&client->tune_done); + init_completion(&client->stat_done); + + kmutex_lock(&g_smsdvb_clientslock); + + list_add(&client->entry, &g_smsdvb_clients); + + kmutex_unlock(&g_smsdvb_clientslock); + + printk(KERN_INFO "%s success\n", __FUNCTION__); + + return 0; + +client_error: + dvb_unregister_frontend(&client->frontend); + +frontend_error: + dvb_dmxdev_release(&client->dmxdev); + +dmxdev_error: + dvb_dmx_release(&client->demux); + +dvbdmx_error: + dvb_unregister_adapter(&client->adapter); + +adapter_error: + kfree(client); + return rc; +} + +int smsdvb_module_init(void) +{ + int rc; + + INIT_LIST_HEAD(&g_smsdvb_clients); + kmutex_init(&g_smsdvb_clientslock); + + rc = smscore_register_hotplug(smsdvb_hotplug); + + printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); + + return rc; +} + +void smsdvb_module_exit(void) +{ + smscore_unregister_hotplug(smsdvb_hotplug); + + kmutex_lock(&g_smsdvb_clientslock); + + while (!list_empty(&g_smsdvb_clients)) + smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); + + kmutex_unlock(&g_smsdvb_clientslock); + + printk(KERN_INFO "%s\n", __FUNCTION__); +} + +module_init(smsdvb_module_init); +module_exit(smsdvb_module_exit); + +MODULE_DESCRIPTION("smsdvb dvb-api module"); +MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); +MODULE_LICENSE("GPL"); diff --git a/linux/drivers/media/mdtv/smskdefs.h b/linux/drivers/media/mdtv/smskdefs.h new file mode 100644 index 000000000..e2483d81c --- /dev/null +++ b/linux/drivers/media/mdtv/smskdefs.h @@ -0,0 +1,36 @@ +#ifndef __smskdefs_h__ +#define __smskdefs_h__ + +#include +#include +#include +#include +#include +#include + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) +#include + +typedef struct mutex kmutex_t; + +#define kmutex_init(_p_) mutex_init(_p_) +#define kmutex_lock(_p_) mutex_lock(_p_) +#define kmutex_trylock(_p_) mutex_trylock(_p_) +#define kmutex_unlock(_p_) mutex_unlock(_p_) + +#else +#include + +typedef struct semaphore kmutex_t; + +#define kmutex_init(_p_) init_MUTEX(_p_) +#define kmutex_lock(_p_) down(_p_) +#define kmutex_trylock(_p_) (!down_trylock(_p_)) +#define kmutex_unlock(_p_) up(_p_) + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) +void *kzalloc(size_t size, int flags); +#endif +#endif // LINUX_VERSION + +#endif // __smskdefs_h__ diff --git a/linux/drivers/media/mdtv/smsnet.c b/linux/drivers/media/mdtv/smsnet.c new file mode 100644 index 000000000..5b70d1261 --- /dev/null +++ b/linux/drivers/media/mdtv/smsnet.c @@ -0,0 +1,447 @@ +#include +#include +#include /* struct device, and other headers */ +#include /* eth_type_trans */ +#include /* struct iphdr */ +#include /* struct ipv6hdr */ +#include + +#include "smskdefs.h" // page, scatterlist, kmutex +#include "smscoreapi.h" +#include "smstypes.h" + +#define IPV4VERSION 0x40 +#define IPV6VERSION 0x60 +#define GETIPVERSION(_x_) ((_x_) & 0xf0) + +typedef struct _smsnet_client +{ + struct list_head entry; + + smscore_device_t *coredev; + smscore_client_t *smsclient; + + int packet_length, splitpacket_length; + int header_length, splitheader_length; + u8 splitpacket[ETH_DATA_LEN]; +} smsnet_client_t; + +struct list_head g_smsnet_clients; +kmutex_t g_smsnet_clientslock; + +struct net_device *g_smsnet_device = NULL; +struct net_device_stats g_smsnet_stats; + +int g_smsnet_inuse = 0; + +void smsnet_send_packet(u8* buffer, int length) +{ + u8 *eth; + struct sk_buff *skb = dev_alloc_skb(length + ETH_HLEN + NET_IP_ALIGN); + + if (!skb) + { + g_smsnet_stats.rx_dropped++; + return; + } + + skb_reserve(skb, NET_IP_ALIGN); + + eth = (u8 *) skb_put(skb, length + ETH_HLEN); + memcpy(eth + ETH_HLEN, buffer, length); + + eth[6] = 0; + eth[7] = 1; + eth[8] = 1; + eth[9] = 3; + eth[10] = 4; + eth[11] = 5; + + if (GETIPVERSION(*buffer) == IPV4VERSION) + { + eth[0] = 1; + eth[1] = 0; + eth[2] = 0x5e; + eth[3] = buffer[17] & 0x7f; + eth[4] = buffer[18]; + eth[5] = buffer[19]; + + eth[12] = 0x08; + eth[13] = 0x00; + } + else + { + // todo: ip6 mcast address + + eth[12] = 0x86; + eth[13] = 0xdd; + } + + skb->dev = g_smsnet_device; + skb->protocol = eth_type_trans(skb, g_smsnet_device); + skb->ip_summed = CHECKSUM_UNNECESSARY; + + g_smsnet_stats.rx_packets ++; + g_smsnet_stats.rx_bytes += skb->len; + + netif_rx(skb); +} + +int check_header(smsnet_client_t* client, u8* buffer) +{ + struct iphdr *ip4_hdr; + struct ipv6hdr *ip6_hdr; + struct udphdr *udp_hdr; + u16 csum; + + // check if packet header is valid and it is a UDP + if (GETIPVERSION(*buffer) == IPV4VERSION) + { + ip4_hdr = (struct iphdr*) buffer; + csum = ip4_hdr->check; + + ip4_hdr->check = 0; + + // check header checksum for IPv4 packets + if(ip4_hdr->protocol != IPPROTO_UDP || csum != ip_fast_csum(buffer, ip4_hdr->ihl)) + { + ip4_hdr->check = csum; + return 0; + } + + ip4_hdr->check = csum; + client->packet_length = ntohs(ip4_hdr->tot_len); + } + else + { + ip6_hdr = (struct ipv6hdr *) buffer; + udp_hdr = (struct udphdr *)(ip6_hdr + 1); + + if ((ip6_hdr->nexthdr != IPPROTO_UDP) || + (ip6_hdr->payload_len != udp_hdr->len)) + { + return 0; + } + + client->packet_length = ntohs(ip6_hdr->payload_len) + sizeof(struct ipv6hdr); + } + + // check for abnormal packet length + if (client->packet_length > ETH_DATA_LEN) + return 0; + + return 1; +} + +int smsnet_onresponse(void *context, smscore_buffer_t *cb) +{ + smsnet_client_t *client = (smsnet_client_t *) context; + int length, rest; + u8 ip_ver, *buffer; + + buffer = ((u8*) cb->p) + cb->offset + sizeof(SmsMsgHdr_ST); + length = cb->size - sizeof(SmsMsgHdr_ST); + + if (client->splitheader_length) + { + // how much data is missing ? + rest = client->header_length - client->splitheader_length; + + // do we have enough in this buffer ? + rest = min(rest, length); + + memcpy(&client->splitpacket[client->splitheader_length], buffer, rest); + + client->splitheader_length += rest; + + if (client->splitheader_length != client->header_length) + goto exit; + + if (check_header(client, client->splitpacket)) + { + buffer += rest; + length -= rest; + + client->splitpacket_length = client->header_length; + } + + client->splitheader_length = 0; + } + + if (client->splitpacket_length) + { + // how much data is missing ? + rest = client->packet_length - client->splitpacket_length; + + // do we have enough in this buffer ? + rest = min(rest, length); + + memcpy(&client->splitpacket[client->splitpacket_length], buffer, rest); + + client->splitpacket_length += rest; + + if (client->splitpacket_length != client->packet_length) + goto exit; + + client->splitpacket_length = 0; + + smsnet_send_packet(client->splitpacket, client->packet_length); + + buffer += rest; + length -= rest; + } + + while (length > 0) + { + ip_ver = GETIPVERSION(*buffer); + while (length && (ip_ver != IPV4VERSION) && (ip_ver != IPV6VERSION)) + { + buffer++; + length--; + ip_ver = GETIPVERSION(*buffer); + } + + // No more data in section + if (!length) + break; + + // Set the header length at start of packet according to the version + // no problem with the IP header cast, since we have at least 1 byte (we use only the first byte) + client->header_length = (ip_ver == IPV4VERSION) ? (((struct iphdr *) buffer)->ihl * 4) : (sizeof(struct ipv6hdr) + sizeof(struct udphdr)); + + // Check that Header length is at least 20 (min IPv4 length) + if (client->header_length < 20) + { + length--; + buffer++; + continue; + } + + // check split header case + if (client->header_length > length) + { + memcpy(client->splitpacket, buffer, length); + client->splitheader_length = length; + break; + } + + if (check_header(client, buffer)) + { + // check split packet case + if (client->packet_length > length) + { + memcpy(client->splitpacket, buffer, length); + client->splitpacket_length = length; + break; + } + } + else + { + length --; + buffer ++; + continue; + } + + smsnet_send_packet(buffer, client->packet_length); + + buffer += client->packet_length; + length -= client->packet_length; + } + +exit: + smscore_putbuffer(client->coredev, cb); + + return 0; +} + +void smsnet_unregister_client(smsnet_client_t* client) +{ + // must be called under clientslock + + list_del(&client->entry); + + smscore_unregister_client(client->smsclient); + kfree(client); +} + +void smsnet_onremove(void *context) +{ + kmutex_lock(&g_smsnet_clientslock); + + smsnet_unregister_client((smsnet_client_t*) context); + + kmutex_unlock(&g_smsnet_clientslock); +} + +int smsnet_hotplug(smscore_device_t *coredev, struct device* device, int arrival) +{ + smsclient_params_t params; + smsnet_client_t* client; + int rc; + + // device removal handled by onremove callback + if (!arrival) + return 0; + + client = kzalloc(sizeof(smsnet_client_t), GFP_KERNEL); + if (!client) + { + printk(KERN_INFO "%s kmalloc() failed\n", __FUNCTION__); + return -ENOMEM; + } + + params.initial_id = 0; + params.data_type = MSG_SMS_DATA_MSG; + params.onresponse_handler = smsnet_onresponse; + params.onremove_handler = smsnet_onremove; + params.context = client; + + rc = smscore_register_client(coredev, ¶ms, &client->smsclient); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_register_client() failed %d\n", __FUNCTION__, rc); + kfree(client); + return rc; + } + + client->coredev = coredev; + + kmutex_lock(&g_smsnet_clientslock); + + list_add(&client->entry, &g_smsnet_clients); + + kmutex_unlock(&g_smsnet_clientslock); + + printk(KERN_INFO "%s success\n", __FUNCTION__); + + return 0; +} + +static int smsnet_open(struct net_device *dev) +{ + g_smsnet_inuse ++; + + netif_start_queue(dev); + + printk(KERN_INFO "%s, %d\n", __FUNCTION__, g_smsnet_inuse); + + return 0; +} + +static int smsnet_stop(struct net_device *dev) +{ + netif_stop_queue(dev); + + g_smsnet_inuse --; + + printk(KERN_INFO "%s, %d\n", __FUNCTION__, g_smsnet_inuse); + + return 0; +} + +static int smsnet_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) +{ + printk(KERN_INFO "%s\n", __FUNCTION__); + + dev_kfree_skb(skb); + return 0; +} + +static struct net_device_stats * smsnet_get_stats(struct net_device *dev) +{ + return &g_smsnet_stats; +} + +static void smsnet_set_multicast_list(struct net_device *dev) +{ + printk(KERN_INFO "%s %d\n", __FUNCTION__, dev->mc_count); + if (dev->mc_count) + { + struct dev_mc_list *p; + + for (p = dev->mc_list; p; p = p->next) + printk(KERN_INFO "%s %d %02x %02x %02x %02x %02x %02x %02x %02x\n", __FUNCTION__, p->dmi_addrlen, + p->dmi_addr[0], p->dmi_addr[1], p->dmi_addr[2], p->dmi_addr[3], + p->dmi_addr[4], p->dmi_addr[5], p->dmi_addr[6], p->dmi_addr[7] + ); + } +} + +static void smsnet_setup_device(struct net_device *dev) +{ + ether_setup(dev); + + dev->open = smsnet_open; + dev->stop = smsnet_stop; + dev->hard_start_xmit = smsnet_hard_start_xmit; + dev->get_stats = smsnet_get_stats; + dev->set_multicast_list = smsnet_set_multicast_list; + + dev->mc_count = 0; + dev->hard_header_cache = NULL; + + memcpy(dev->dev_addr, "\0SIANO", ETH_ALEN); + + dev->flags |= IFF_NOARP; + dev->features |= NETIF_F_NO_CSUM; +} + +int smsnet_module_init(void) +{ + int rc; + + INIT_LIST_HEAD(&g_smsnet_clients); + kmutex_init(&g_smsnet_clientslock); + + memset(&g_smsnet_stats, 0, sizeof(g_smsnet_stats)); + + g_smsnet_device = alloc_netdev(0, "sms", smsnet_setup_device); + if (!g_smsnet_device) + { + printk(KERN_INFO "%s alloc_netdev() failed\n", __FUNCTION__); + return -ENOMEM; + } + + rc = register_netdev(g_smsnet_device); + if (rc < 0) + { + printk(KERN_INFO "%s register_netdev() failed %d\n", __FUNCTION__, rc); + free_netdev(g_smsnet_device); + return rc; + } + + rc = smscore_register_hotplug(smsnet_hotplug); + + printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); + + return rc; +} + +void smsnet_module_exit(void) +{ + if (g_smsnet_device) + { + unregister_netdev(g_smsnet_device); + free_netdev(g_smsnet_device); + + g_smsnet_device = NULL; + } + + smscore_unregister_hotplug(smsnet_hotplug); + + kmutex_lock(&g_smsnet_clientslock); + + while (!list_empty(&g_smsnet_clients)) + smsnet_unregister_client((smsnet_client_t*) g_smsnet_clients.next); + + kmutex_unlock(&g_smsnet_clientslock); + + printk(KERN_INFO "%s\n", __FUNCTION__); +} + +module_init(smsnet_module_init); +module_exit(smsnet_module_exit); + +MODULE_DESCRIPTION("smsnet dvb-h ip sink module"); +MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); +MODULE_LICENSE("GPL"); diff --git a/linux/drivers/media/mdtv/smstypes.h b/linux/drivers/media/mdtv/smstypes.h new file mode 100644 index 000000000..011cd904d --- /dev/null +++ b/linux/drivers/media/mdtv/smstypes.h @@ -0,0 +1,361 @@ +#ifndef __smstypes_h__ +#define __smstypes_h__ + +// GPIO definitions for antenna frequency domain control (SMS8021) +#define SMS_ANTENNA_GPIO_0 1 +#define SMS_ANTENNA_GPIO_1 0 + +#define BW_8_MHZ 0 +#define BW_7_MHZ 1 +#define BW_6_MHZ 2 +#define BW_5_MHZ 3 +#define BW_ISDBT_1SEG 4 +#define BW_ISDBT_3SEG 5 + +#define MSG_HDR_FLAG_SPLIT_MSG 4 + +#define MAX_GPIO_PIN_NUMBER 31 + +#define HIF_TASK 11 +#define SMS_HOST_LIB 150 +#define DVBT_BDA_CONTROL_MSG_ID 201 + +#define SMS_MAX_PAYLOAD_SIZE 240 +#define SMS_TUNE_TIMEOUT 500 + +#define MSG_SMS_GPIO_CONFIG_REQ 507 +#define MSG_SMS_GPIO_CONFIG_RES 508 +#define MSG_SMS_GPIO_SET_LEVEL_REQ 509 +#define MSG_SMS_GPIO_SET_LEVEL_RES 510 +#define MSG_SMS_GPIO_GET_LEVEL_REQ 511 +#define MSG_SMS_GPIO_GET_LEVEL_RES 512 +#define MSG_SMS_RF_TUNE_REQ 561 +#define MSG_SMS_RF_TUNE_RES 562 +#define MSG_SMS_INIT_DEVICE_REQ 578 +#define MSG_SMS_INIT_DEVICE_RES 579 +#define MSG_SMS_ADD_PID_FILTER_REQ 601 +#define MSG_SMS_ADD_PID_FILTER_RES 602 +#define MSG_SMS_REMOVE_PID_FILTER_REQ 603 +#define MSG_SMS_REMOVE_PID_FILTER_RES 604 +#define MSG_SMS_DAB_CHANNEL 607 +#define MSG_SMS_GET_PID_FILTER_LIST_REQ 608 +#define MSG_SMS_GET_PID_FILTER_LIST_RES 609 +#define MSG_SMS_GET_STATISTICS_REQ 615 +#define MSG_SMS_GET_STATISTICS_RES 616 +#define MSG_SMS_SET_ANTENNA_CONFIG_REQ 651 +#define MSG_SMS_SET_ANTENNA_CONFIG_RES 652 +#define MSG_SMS_GET_STATISTICS_EX_REQ 653 +#define MSG_SMS_GET_STATISTICS_EX_RES 654 +#define MSG_SMS_SLEEP_RESUME_COMP_IND 655 +#define MSG_SMS_DATA_DOWNLOAD_REQ 660 +#define MSG_SMS_DATA_DOWNLOAD_RES 661 +#define MSG_SMS_SWDOWNLOAD_TRIGGER_REQ 664 +#define MSG_SMS_SWDOWNLOAD_TRIGGER_RES 665 +#define MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ 666 +#define MSG_SMS_SWDOWNLOAD_BACKDOOR_RES 667 +#define MSG_SMS_GET_VERSION_EX_REQ 668 +#define MSG_SMS_GET_VERSION_EX_RES 669 +#define MSG_SMS_SET_CLOCK_OUTPUT_REQ 670 +#define MSG_SMS_I2C_SET_FREQ_REQ 685 +#define MSG_SMS_GENERIC_I2C_REQ 687 +#define MSG_SMS_GENERIC_I2C_RES 688 +#define MSG_SMS_DVBT_BDA_DATA 693 +#define MSG_SW_RELOAD_REQ 697 +#define MSG_SMS_DATA_MSG 699 +#define MSG_SW_RELOAD_START_REQ 702 +#define MSG_SW_RELOAD_START_RES 703 +#define MSG_SW_RELOAD_EXEC_REQ 704 +#define MSG_SW_RELOAD_EXEC_RES 705 +#define MSG_SMS_SPI_INT_LINE_SET_REQ 710 +#define MSG_SMS_ISDBT_TUNE_REQ 776 +#define MSG_SMS_ISDBT_TUNE_RES 777 + +#define SMS_INIT_MSG_EX(ptr, type, src, dst, len) do { \ + (ptr)->msgType = type; (ptr)->msgSrcId = src; (ptr)->msgDstId = dst; \ + (ptr)->msgLength = len; (ptr)->msgFlags = 0; \ +} while (0) +#define SMS_INIT_MSG(ptr, type, len) SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) + +typedef enum +{ + DEVICE_MODE_NONE = -1, + DEVICE_MODE_DVBT = 0, + DEVICE_MODE_DVBH, + DEVICE_MODE_DAB_TDMB, + DEVICE_MODE_DAB_TDMB_DABIP, + DEVICE_MODE_DVBT_BDA, + DEVICE_MODE_ISDBT, + DEVICE_MODE_ISDBT_BDA, + DEVICE_MODE_CMMB, + DEVICE_MODE_RAW_TUNER, + DEVICE_MODE_MAX, +} SMS_DEVICE_MODE; + +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned int UINT32; +typedef int INT32; + +typedef struct SmsMsgHdr_S +{ + UINT16 msgType; + UINT8 msgSrcId; + UINT8 msgDstId; + UINT16 msgLength; // Length is of the entire message, including header + UINT16 msgFlags; +} SmsMsgHdr_ST; + +typedef struct SmsMsgData_S +{ + SmsMsgHdr_ST xMsgHeader; + UINT32 msgData[1]; +} SmsMsgData_ST; + +typedef struct SmsDataDownload_S +{ + SmsMsgHdr_ST xMsgHeader; + UINT32 MemAddr; + UINT8 Payload[SMS_MAX_PAYLOAD_SIZE]; +} SmsDataDownload_ST; + +typedef struct SmsVersionRes_S +{ + SmsMsgHdr_ST xMsgHeader; + + UINT16 ChipModel; // e.g. 0x1102 for SMS-1102 "Nova" + UINT8 Step; // 0 - Step A + UINT8 MetalFix; // 0 - Metal 0 + + UINT8 FirmwareId; // 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E + UINT8 SupportedProtocols; // Bitwise OR combination of supported protocols + + UINT8 VersionMajor; + UINT8 VersionMinor; + UINT8 VersionPatch; + UINT8 VersionFieldPatch; + + UINT8 RomVersionMajor; + UINT8 RomVersionMinor; + UINT8 RomVersionPatch; + UINT8 RomVersionFieldPatch; + + UINT8 TextLabel[34]; +} SmsVersionRes_ST; + +typedef struct SmsFirmware_S +{ + UINT32 CheckSum; + UINT32 Length; + UINT32 StartAddress; + UINT8 Payload[1]; +} SmsFirmware_ST; + +typedef struct SMSHOSTLIB_STATISTICS_S +{ + UINT32 Reserved; //!< Reserved + + /// Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + /// Reception quality + INT32 SNR; //!< dB + UINT32 BER; //!< Post Viterbi BER [1E-5] + UINT32 FIB_CRC; //!< CRC errors percentage, valid only for DAB + UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H + UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in bin/1024 + + /// Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz, valid only for DVB-T/H + UINT32 TransmissionMode; //!< Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos + UINT32 ModemState; //!< from SMS_DvbModemState_ET , valid only for DVB-T/H + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value , valid only for DVB-T/H + UINT32 CodeRate; //!< Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H + UINT32 LPCodeRate; //!< Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H + UINT32 Hierarchy; //!< Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H + UINT32 Constellation; //!< Constellation from SMS_Constellation_ET, valid only for DVB-T/H + + /// Burst parameters, valid only for DVB-H + UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H + UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H + UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H + UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H + UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H + UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H + UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding + UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding + UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding + /// Common params + UINT32 BERErrorCount; //!< Number of errornous SYNC bits. + UINT32 BERBitCount; //!< Total number of SYNC bits. + + /// Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + + /// DAB/T-DMB + UINT32 PreBER; //!< DAB/T-DMB only: Pre Viterbi BER [1E-5] + + /// DVB-H TPS parameters + UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + +} SMSHOSTLIB_STATISTICS_ST; + +typedef struct +{ + UINT32 RequestResult; + + SMSHOSTLIB_STATISTICS_ST Stat; + + // Split the calc of the SNR in DAB + UINT32 Signal; //!< dB + UINT32 Noise; //!< dB + +} SmsMsgStatisticsInfo_ST; + +typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S +{ + // Per-layer information + UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist + UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist + UINT32 BER; //!< Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A + UINT32 BERErrorCount; //!< Post Viterbi Error Bits Count + UINT32 BERBitCount; //!< Post Viterbi Total Bits Count + UINT32 PreBER; //!< Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A + UINT32 TS_PER; //!< Transport stream PER [%], 0xFFFFFFFF indicate N/A + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 TILdepthI; //!< Time interleaver depth I parameter, 255 means layer does not exist + UINT32 NumberOfSegments; //!< Number of segments in layer A, 255 means layer does not exist + UINT32 TMCCErrors; //!< TMCC errors +} SMSHOSTLIB_ISDBT_LAYER_STAT_ST; + +typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S +{ + UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + //!< This fiels MUST always first in any statistics structure + + UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by + //!< the host is smaller than FullSize, the struct will be truncated + + // Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + // Reception quality + INT32 SNR; //!< dB + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in Hz + + // Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz + UINT32 TransmissionMode; //!< ISDB-T transmission mode + UINT32 ModemState; //!< 0 - Acquisition, 1 - Locked + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value + UINT32 SystemType; //!< ISDB-T system type (ISDB-T / ISDB-Tsb) + UINT32 PartialReception; //!< TRUE - partial reception, FALSE otherwise + UINT32 NumOfLayers; //!< Number of ISDB-T layers in the network + + // Per-layer information + // Layers A, B and C + SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; //!< Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST + + // Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + +} SMSHOSTLIB_STATISTICS_ISDBT_ST; + +typedef struct SMSHOSTLIB_STATISTICS_DVB_S +{ + UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + //!< This fiels MUST always first in any statistics structure + + UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by + //!< the host is smaller than FullSize, the struct will be truncated + // Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + // Reception quality + INT32 SNR; //!< dB + UINT32 BER; //!< Post Viterbi BER [1E-5] + UINT32 BERErrorCount; //!< Number of errornous SYNC bits. + UINT32 BERBitCount; //!< Total number of SYNC bits. + UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A + UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in bin/1024 + + // Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz + UINT32 ModemState; //!< from SMSHOSTLIB_DVB_MODEM_STATE_ET + UINT32 TransmissionMode; //!< FFT mode carriers in Kilos + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value + UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET + UINT32 LPCodeRate; //!< Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET + UINT32 Hierarchy; //!< Hierarchy from SMSHOSTLIB_HIERARCHY_ET + UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET + + // Burst parameters, valid only for DVB-H + UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H + UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H + UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H + UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H + UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H + UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H + UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H + UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H + UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H + UINT32 NumMPEReceived; //!< DVB-H, Num MPE section received + + // DVB-H TPS parameters + UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + UINT32 DvbhSrvIndHP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator + UINT32 DvbhSrvIndLP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator + + // Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + +} SMSHOSTLIB_STATISTICS_DVB_ST; + +typedef struct SMSHOSTLIB_GPIO_CONFIG_S +{ + UINT8 Direction; //!< GPIO direction: Input - 0, Output - 1 + UINT8 PullUpDown; //!< PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 + UINT8 InputCharacteristics; //!< Input Characteristics: Normal - 0, Schmitt trigger - 1 + UINT8 OutputSlewRate; //!< Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 + UINT8 OutputDriving; //!< Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 +} SMSHOSTLIB_GPIO_CONFIG_ST; + +typedef struct SMSHOSTLIB_I2C_REQ_S +{ + UINT32 DeviceAddress; // I2c device address + UINT32 WriteCount; // number of bytes to write + UINT32 ReadCount; // number of bytes to read + UINT8 Data[1]; +} SMSHOSTLIB_I2C_REQ_ST; + +typedef struct SMSHOSTLIB_I2C_RES_S +{ + UINT32 Status; // non-zero value in case of failure + UINT32 ReadCount; // number of bytes read + UINT8 Data[1]; +} SMSHOSTLIB_I2C_RES_ST; + +#endif // __smstypes_h__ diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c new file mode 100644 index 000000000..cda0581e3 --- /dev/null +++ b/linux/drivers/media/mdtv/smsusb.c @@ -0,0 +1,432 @@ +#include +#include +#include +#include +#include + +#include "smskdefs.h" // page, scatterlist, kmutex +#include "smscoreapi.h" +#include "smstypes.h" + +#define USB_VID_SIANO 0x187f +#define USB_PID_0010 0x0010 +#define USB_PID_0100 0x0100 +#define USB_PID_0200 0x0200 + +#define USB1_BUFFER_SIZE 0x1000 +#define USB2_BUFFER_SIZE 0x4000 + +#define MAX_BUFFERS 50 +#define MAX_URBS 10 + +typedef struct _smsusb_device smsusb_device_t; + +typedef struct _smsusb_urb +{ + smscore_buffer_t *cb; + smsusb_device_t *dev; + + struct urb urb; +} smsusb_urb_t; + +typedef struct _smsusb_device +{ + struct usb_device* udev; + smscore_device_t *coredev; + + smsusb_urb_t surbs[MAX_URBS]; + + int response_alignment; + int buffer_size; +} *psmsusb_device_t; + +static struct usb_device_id smsusb_id_table [] = { + { USB_DEVICE(USB_VID_SIANO, USB_PID_0010) }, + { USB_DEVICE(USB_VID_SIANO, USB_PID_0100) }, + { USB_DEVICE(USB_VID_SIANO, USB_PID_0200) }, + { } /* Terminating entry */ +}; +MODULE_DEVICE_TABLE (usb, smsusb_id_table); + +int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb); + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) +void smsusb_onresponse(struct urb *urb) +#else +void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) +#endif +{ + smsusb_urb_t *surb = (smsusb_urb_t *) urb->context; + smsusb_device_t *dev = surb->dev; + + if (urb->status < 0) + { + printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __FUNCTION__, urb->status, urb->actual_length); + return; + } + + if (urb->actual_length > 0) + { + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) surb->cb->p; + + if (urb->actual_length >= phdr->msgLength) + { + surb->cb->size = phdr->msgLength; + + if (dev->response_alignment && (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) + { + surb->cb->offset = dev->response_alignment + ((phdr->msgFlags >> 8) & 3); + + // sanity check + if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) + { + printk("%s: invalid response msglen %d offset %d size %d\n", __FUNCTION__, phdr->msgLength, surb->cb->offset, urb->actual_length); + goto exit_and_resubmit; + } + + // move buffer pointer and copy header to its new location + memcpy((char*) phdr + surb->cb->offset, phdr, sizeof(SmsMsgHdr_ST)); + } + else + surb->cb->offset = 0; + + smscore_onresponse(dev->coredev, surb->cb); + surb->cb = NULL; + } + else + { + printk("%s invalid response msglen %d actual %d\n", __FUNCTION__, phdr->msgLength, urb->actual_length); + } + } + +exit_and_resubmit: + smsusb_submit_urb(dev, surb); +} + +int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb) +{ + if (!surb->cb) + { + surb->cb = smscore_getbuffer(dev->coredev); + if (!surb->cb) + { + printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __FUNCTION__); + return -ENOMEM; + } + } + + usb_fill_bulk_urb( + &surb->urb, + dev->udev, + usb_rcvbulkpipe(dev->udev, 0x81), + surb->cb->p, + dev->buffer_size, + smsusb_onresponse, + surb + ); + surb->urb.transfer_dma = surb->cb->phys; + surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + + return usb_submit_urb(&surb->urb, GFP_ATOMIC); +} + +void smsusb_stop_streaming(smsusb_device_t* dev) +{ + int i; + + for (i = 0; i < MAX_URBS; i ++) + { + usb_kill_urb(&dev->surbs[i].urb); + + if (dev->surbs[i].cb) + { + smscore_putbuffer(dev->coredev, dev->surbs[i].cb); + dev->surbs[i].cb = NULL; + } + } +} + +int smsusb_start_streaming(smsusb_device_t* dev) +{ + int i, rc; + + for (i = 0; i < MAX_URBS; i ++) + { + rc = smsusb_submit_urb(dev, &dev->surbs[i]); + if (rc < 0) + { + printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __FUNCTION__); + smsusb_stop_streaming(dev); + break; + } + } + + return rc; +} + +int smsusb_sendrequest(void *context, void *buffer, size_t size) +{ + smsusb_device_t* dev = (smsusb_device_t*) context; + int dummy; + + return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buffer, size, &dummy, 1000); +} + +char *smsusb1_fw_lkup[] = +{ + "dvbt_stellar_usb.inp", + "dvbh_stellar_usb.inp", + "tdmb_stellar_usb.inp", + "none", + "dvbt_bda_stellar_usb.inp", +}; + +int smsusb1_load_firmware(struct usb_device *udev, int id) +{ + const struct firmware *fw; + u8* fw_buffer; + int rc, dummy; + + if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) + { + printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, id); + return -EINVAL; + } + + rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); + if (rc < 0) + { + printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __FUNCTION__, smsusb1_fw_lkup[id], id); + return rc; + } + + fw_buffer = kmalloc(fw->size, GFP_KERNEL); + if (fw_buffer) + { + memcpy(fw_buffer, fw->data, fw->size); + + rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); + + printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __FUNCTION__, fw->size, dummy, rc); + + kfree(fw_buffer); + } + else + { + printk(KERN_INFO "failed to allocate firmware buffer\n"); + rc = -ENOMEM; + } + + release_firmware(fw); + + return rc; +} + +void smsusb1_detectmode(void *context, int *mode) +{ + char *product_string = ((smsusb_device_t *) context)->udev->product; + + *mode = DEVICE_MODE_NONE; + + if (!product_string) + { + product_string = "none"; + printk("%s product string not found\n", __FUNCTION__); + } + else + { + if (strstr(product_string, "DVBH")) + *mode = 1; + else if (strstr(product_string, "BDA")) + *mode = 4; + else if (strstr(product_string, "DVBT")) + *mode = 0; + else if (strstr(product_string, "TDMB")) + *mode = 2; + } + + printk("%s: %d \"%s\"\n", __FUNCTION__, *mode, product_string); +} + +int smsusb1_setmode(void *context, int mode) +{ + SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) + { + printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, mode); + return -EINVAL; + } + + return smsusb_sendrequest(context, &Msg, sizeof(Msg)); +} + +void smsusb_term_device(struct usb_interface *intf) +{ + smsusb_device_t *dev = (smsusb_device_t*) usb_get_intfdata(intf); + + if (dev) + { + smsusb_stop_streaming(dev); + + // unregister from smscore + if (dev->coredev) + smscore_unregister_device(dev->coredev); + + kfree(dev); + + printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, dev); + } + + usb_set_intfdata(intf, NULL); +} + +int smsusb_init_device(struct usb_interface *intf) +{ + smsdevice_params_t params; + smsusb_device_t* dev; + int i, rc; + + // create device object + dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); + if (!dev) + { + printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __FUNCTION__); + return -ENOMEM; + } + + memset(¶ms, 0, sizeof(params)); + usb_set_intfdata(intf, dev); + dev->udev = interface_to_usbdev(intf); + + switch (dev->udev->descriptor.idProduct) + { + case USB_PID_0100: + dev->buffer_size = USB1_BUFFER_SIZE; + + params.setmode_handler = smsusb1_setmode; + params.detectmode_handler = smsusb1_detectmode; + break; + + default: + dev->buffer_size = USB2_BUFFER_SIZE; + dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST); + + params.flags |= SMS_DEVICE_FAMILY2; + break; + } + + params.device = &dev->udev->dev; + params.buffer_size = dev->buffer_size; + params.num_buffers = MAX_BUFFERS; + params.sendrequest_handler = smsusb_sendrequest; + params.context = dev; + snprintf(params.devpath, sizeof(params.devpath), "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath); + + // register in smscore + rc = smscore_register_device(¶ms, &dev->coredev); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __FUNCTION__, rc); + smsusb_term_device(intf); + return rc; + } + + // initialize urbs + for (i = 0; i < MAX_URBS; i ++) + { + dev->surbs[i].dev = dev; + usb_init_urb(&dev->surbs[i].urb); + } + + rc = smsusb_start_streaming(dev); + if (rc < 0) + { + printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __FUNCTION__); + smsusb_term_device(intf); + return rc; + } + + rc = smscore_start_device(dev->coredev); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_start_device(...) failed\n", __FUNCTION__); + smsusb_term_device(intf); + return rc; + } + + printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); + + return rc; +} + +int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(intf); + char devpath[32]; + int i, rc; + + if (intf->num_altsetting > 0) + { + rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); + if (rc < 0) + { + printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __FUNCTION__, rc); + return rc; + } + } + + printk(KERN_INFO "smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber); + for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i ++) + printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); + + if (udev->actconfig->desc.bNumInterfaces == 2 && intf->cur_altsetting->desc.bInterfaceNumber == 0) + { + printk(KERN_INFO "rom interface 0 is not used\n"); + return -ENODEV; + } + + if (intf->cur_altsetting->desc.bInterfaceNumber == 1) + { + snprintf(devpath, 32, "%d:%s", udev->bus->busnum, udev->devpath); + return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath)); + } + + return smsusb_init_device(intf); +} + +void smsusb_disconnect(struct usb_interface *intf) +{ + smsusb_term_device(intf); +} + +static struct usb_driver smsusb_driver = { + .name = "smsusb", + .probe = smsusb_probe, + .disconnect = smsusb_disconnect, + .id_table = smsusb_id_table, +}; + +int smsusb_module_init(void) +{ + int rc = usb_register(&smsusb_driver); + if (rc) + printk(KERN_INFO "usb_register failed. Error number %d\n", rc); + + printk(KERN_INFO "%s\n", __FUNCTION__); + + return rc; +} + +void smsusb_module_exit(void) +{ + usb_deregister(&smsusb_driver); + printk(KERN_INFO "%s\n", __FUNCTION__); +} + +module_init(smsusb_module_init); +module_exit(smsusb_module_exit); + +MODULE_DESCRIPTION("smsusb"); +MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); +MODULE_LICENSE("GPL"); -- cgit v1.2.3 From ad675c6b61b80e9283aa2d8c829ba3b55160d848 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 19 May 2008 14:57:12 -0400 Subject: sms1xxx: pass adapter_nr into dvb_register_adapter From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smsdvb.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c index f2ed1718d..ecba51c8b 100644 --- a/linux/drivers/media/mdtv/smsdvb.c +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -10,6 +10,8 @@ #include "smscoreapi.h" #include "smstypes.h" +DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); + typedef struct _smsdvb_client { struct list_head entry; @@ -314,7 +316,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival } // register dvb adapter - rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device); + rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device, adapter_nr); if (rc < 0) { printk("%s dvb_register_adapter() failed %d\n", __func__, rc); -- cgit v1.2.3 From b2ae2588f545f7a7f5ce880ea3f63f44a675eaad Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 19 May 2008 14:58:40 -0400 Subject: sms1xxx: build fixes From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/Makefile | 7 ++++--- linux/drivers/media/mdtv/smschar.c | 2 ++ 2 files changed, 6 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile index 1e54d8f79..9798657c7 100644 --- a/linux/drivers/media/mdtv/Makefile +++ b/linux/drivers/media/mdtv/Makefile @@ -2,7 +2,8 @@ # Makefile for the kernel MDTV driver # -obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smschar.o smsnet.o -obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsusb.o +smscore-objs := smschar.o smscoreapi.o -EXTRA_CFLAGS += +obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smscore.o smsnet.o +obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsusb.o +obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsdvb.o diff --git a/linux/drivers/media/mdtv/smschar.c b/linux/drivers/media/mdtv/smschar.c index 0477ad0ed..15ebecd59 100644 --- a/linux/drivers/media/mdtv/smschar.c +++ b/linux/drivers/media/mdtv/smschar.c @@ -565,6 +565,7 @@ int smschar_initialize(void) return smscore_register_hotplug(smschar_hotplug); } +EXPORT_SYMBOL(smschar_initialize); void smschar_terminate(void) { @@ -573,3 +574,4 @@ void smschar_terminate(void) unregister_chrdev_region(devno, SMSCHAR_NR_DEVS); smscore_unregister_hotplug(smschar_hotplug); } +EXPORT_SYMBOL(smschar_terminate); -- cgit v1.2.3 From 23c1df9d4f6015ceea5483588f7ecde1c647f5bb Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 19 May 2008 15:01:25 -0400 Subject: sms1xxx: remove smsnet.o From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/Makefile | 2 +- linux/drivers/media/mdtv/smsnet.c | 447 -------------------------------------- 2 files changed, 1 insertion(+), 448 deletions(-) delete mode 100644 linux/drivers/media/mdtv/smsnet.c (limited to 'linux') diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile index 9798657c7..c3cf917d7 100644 --- a/linux/drivers/media/mdtv/Makefile +++ b/linux/drivers/media/mdtv/Makefile @@ -4,6 +4,6 @@ smscore-objs := smschar.o smscoreapi.o -obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smscore.o smsnet.o +obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smscore.o obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsusb.o obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsdvb.o diff --git a/linux/drivers/media/mdtv/smsnet.c b/linux/drivers/media/mdtv/smsnet.c deleted file mode 100644 index 5b70d1261..000000000 --- a/linux/drivers/media/mdtv/smsnet.c +++ /dev/null @@ -1,447 +0,0 @@ -#include -#include -#include /* struct device, and other headers */ -#include /* eth_type_trans */ -#include /* struct iphdr */ -#include /* struct ipv6hdr */ -#include - -#include "smskdefs.h" // page, scatterlist, kmutex -#include "smscoreapi.h" -#include "smstypes.h" - -#define IPV4VERSION 0x40 -#define IPV6VERSION 0x60 -#define GETIPVERSION(_x_) ((_x_) & 0xf0) - -typedef struct _smsnet_client -{ - struct list_head entry; - - smscore_device_t *coredev; - smscore_client_t *smsclient; - - int packet_length, splitpacket_length; - int header_length, splitheader_length; - u8 splitpacket[ETH_DATA_LEN]; -} smsnet_client_t; - -struct list_head g_smsnet_clients; -kmutex_t g_smsnet_clientslock; - -struct net_device *g_smsnet_device = NULL; -struct net_device_stats g_smsnet_stats; - -int g_smsnet_inuse = 0; - -void smsnet_send_packet(u8* buffer, int length) -{ - u8 *eth; - struct sk_buff *skb = dev_alloc_skb(length + ETH_HLEN + NET_IP_ALIGN); - - if (!skb) - { - g_smsnet_stats.rx_dropped++; - return; - } - - skb_reserve(skb, NET_IP_ALIGN); - - eth = (u8 *) skb_put(skb, length + ETH_HLEN); - memcpy(eth + ETH_HLEN, buffer, length); - - eth[6] = 0; - eth[7] = 1; - eth[8] = 1; - eth[9] = 3; - eth[10] = 4; - eth[11] = 5; - - if (GETIPVERSION(*buffer) == IPV4VERSION) - { - eth[0] = 1; - eth[1] = 0; - eth[2] = 0x5e; - eth[3] = buffer[17] & 0x7f; - eth[4] = buffer[18]; - eth[5] = buffer[19]; - - eth[12] = 0x08; - eth[13] = 0x00; - } - else - { - // todo: ip6 mcast address - - eth[12] = 0x86; - eth[13] = 0xdd; - } - - skb->dev = g_smsnet_device; - skb->protocol = eth_type_trans(skb, g_smsnet_device); - skb->ip_summed = CHECKSUM_UNNECESSARY; - - g_smsnet_stats.rx_packets ++; - g_smsnet_stats.rx_bytes += skb->len; - - netif_rx(skb); -} - -int check_header(smsnet_client_t* client, u8* buffer) -{ - struct iphdr *ip4_hdr; - struct ipv6hdr *ip6_hdr; - struct udphdr *udp_hdr; - u16 csum; - - // check if packet header is valid and it is a UDP - if (GETIPVERSION(*buffer) == IPV4VERSION) - { - ip4_hdr = (struct iphdr*) buffer; - csum = ip4_hdr->check; - - ip4_hdr->check = 0; - - // check header checksum for IPv4 packets - if(ip4_hdr->protocol != IPPROTO_UDP || csum != ip_fast_csum(buffer, ip4_hdr->ihl)) - { - ip4_hdr->check = csum; - return 0; - } - - ip4_hdr->check = csum; - client->packet_length = ntohs(ip4_hdr->tot_len); - } - else - { - ip6_hdr = (struct ipv6hdr *) buffer; - udp_hdr = (struct udphdr *)(ip6_hdr + 1); - - if ((ip6_hdr->nexthdr != IPPROTO_UDP) || - (ip6_hdr->payload_len != udp_hdr->len)) - { - return 0; - } - - client->packet_length = ntohs(ip6_hdr->payload_len) + sizeof(struct ipv6hdr); - } - - // check for abnormal packet length - if (client->packet_length > ETH_DATA_LEN) - return 0; - - return 1; -} - -int smsnet_onresponse(void *context, smscore_buffer_t *cb) -{ - smsnet_client_t *client = (smsnet_client_t *) context; - int length, rest; - u8 ip_ver, *buffer; - - buffer = ((u8*) cb->p) + cb->offset + sizeof(SmsMsgHdr_ST); - length = cb->size - sizeof(SmsMsgHdr_ST); - - if (client->splitheader_length) - { - // how much data is missing ? - rest = client->header_length - client->splitheader_length; - - // do we have enough in this buffer ? - rest = min(rest, length); - - memcpy(&client->splitpacket[client->splitheader_length], buffer, rest); - - client->splitheader_length += rest; - - if (client->splitheader_length != client->header_length) - goto exit; - - if (check_header(client, client->splitpacket)) - { - buffer += rest; - length -= rest; - - client->splitpacket_length = client->header_length; - } - - client->splitheader_length = 0; - } - - if (client->splitpacket_length) - { - // how much data is missing ? - rest = client->packet_length - client->splitpacket_length; - - // do we have enough in this buffer ? - rest = min(rest, length); - - memcpy(&client->splitpacket[client->splitpacket_length], buffer, rest); - - client->splitpacket_length += rest; - - if (client->splitpacket_length != client->packet_length) - goto exit; - - client->splitpacket_length = 0; - - smsnet_send_packet(client->splitpacket, client->packet_length); - - buffer += rest; - length -= rest; - } - - while (length > 0) - { - ip_ver = GETIPVERSION(*buffer); - while (length && (ip_ver != IPV4VERSION) && (ip_ver != IPV6VERSION)) - { - buffer++; - length--; - ip_ver = GETIPVERSION(*buffer); - } - - // No more data in section - if (!length) - break; - - // Set the header length at start of packet according to the version - // no problem with the IP header cast, since we have at least 1 byte (we use only the first byte) - client->header_length = (ip_ver == IPV4VERSION) ? (((struct iphdr *) buffer)->ihl * 4) : (sizeof(struct ipv6hdr) + sizeof(struct udphdr)); - - // Check that Header length is at least 20 (min IPv4 length) - if (client->header_length < 20) - { - length--; - buffer++; - continue; - } - - // check split header case - if (client->header_length > length) - { - memcpy(client->splitpacket, buffer, length); - client->splitheader_length = length; - break; - } - - if (check_header(client, buffer)) - { - // check split packet case - if (client->packet_length > length) - { - memcpy(client->splitpacket, buffer, length); - client->splitpacket_length = length; - break; - } - } - else - { - length --; - buffer ++; - continue; - } - - smsnet_send_packet(buffer, client->packet_length); - - buffer += client->packet_length; - length -= client->packet_length; - } - -exit: - smscore_putbuffer(client->coredev, cb); - - return 0; -} - -void smsnet_unregister_client(smsnet_client_t* client) -{ - // must be called under clientslock - - list_del(&client->entry); - - smscore_unregister_client(client->smsclient); - kfree(client); -} - -void smsnet_onremove(void *context) -{ - kmutex_lock(&g_smsnet_clientslock); - - smsnet_unregister_client((smsnet_client_t*) context); - - kmutex_unlock(&g_smsnet_clientslock); -} - -int smsnet_hotplug(smscore_device_t *coredev, struct device* device, int arrival) -{ - smsclient_params_t params; - smsnet_client_t* client; - int rc; - - // device removal handled by onremove callback - if (!arrival) - return 0; - - client = kzalloc(sizeof(smsnet_client_t), GFP_KERNEL); - if (!client) - { - printk(KERN_INFO "%s kmalloc() failed\n", __FUNCTION__); - return -ENOMEM; - } - - params.initial_id = 0; - params.data_type = MSG_SMS_DATA_MSG; - params.onresponse_handler = smsnet_onresponse; - params.onremove_handler = smsnet_onremove; - params.context = client; - - rc = smscore_register_client(coredev, ¶ms, &client->smsclient); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_register_client() failed %d\n", __FUNCTION__, rc); - kfree(client); - return rc; - } - - client->coredev = coredev; - - kmutex_lock(&g_smsnet_clientslock); - - list_add(&client->entry, &g_smsnet_clients); - - kmutex_unlock(&g_smsnet_clientslock); - - printk(KERN_INFO "%s success\n", __FUNCTION__); - - return 0; -} - -static int smsnet_open(struct net_device *dev) -{ - g_smsnet_inuse ++; - - netif_start_queue(dev); - - printk(KERN_INFO "%s, %d\n", __FUNCTION__, g_smsnet_inuse); - - return 0; -} - -static int smsnet_stop(struct net_device *dev) -{ - netif_stop_queue(dev); - - g_smsnet_inuse --; - - printk(KERN_INFO "%s, %d\n", __FUNCTION__, g_smsnet_inuse); - - return 0; -} - -static int smsnet_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) -{ - printk(KERN_INFO "%s\n", __FUNCTION__); - - dev_kfree_skb(skb); - return 0; -} - -static struct net_device_stats * smsnet_get_stats(struct net_device *dev) -{ - return &g_smsnet_stats; -} - -static void smsnet_set_multicast_list(struct net_device *dev) -{ - printk(KERN_INFO "%s %d\n", __FUNCTION__, dev->mc_count); - if (dev->mc_count) - { - struct dev_mc_list *p; - - for (p = dev->mc_list; p; p = p->next) - printk(KERN_INFO "%s %d %02x %02x %02x %02x %02x %02x %02x %02x\n", __FUNCTION__, p->dmi_addrlen, - p->dmi_addr[0], p->dmi_addr[1], p->dmi_addr[2], p->dmi_addr[3], - p->dmi_addr[4], p->dmi_addr[5], p->dmi_addr[6], p->dmi_addr[7] - ); - } -} - -static void smsnet_setup_device(struct net_device *dev) -{ - ether_setup(dev); - - dev->open = smsnet_open; - dev->stop = smsnet_stop; - dev->hard_start_xmit = smsnet_hard_start_xmit; - dev->get_stats = smsnet_get_stats; - dev->set_multicast_list = smsnet_set_multicast_list; - - dev->mc_count = 0; - dev->hard_header_cache = NULL; - - memcpy(dev->dev_addr, "\0SIANO", ETH_ALEN); - - dev->flags |= IFF_NOARP; - dev->features |= NETIF_F_NO_CSUM; -} - -int smsnet_module_init(void) -{ - int rc; - - INIT_LIST_HEAD(&g_smsnet_clients); - kmutex_init(&g_smsnet_clientslock); - - memset(&g_smsnet_stats, 0, sizeof(g_smsnet_stats)); - - g_smsnet_device = alloc_netdev(0, "sms", smsnet_setup_device); - if (!g_smsnet_device) - { - printk(KERN_INFO "%s alloc_netdev() failed\n", __FUNCTION__); - return -ENOMEM; - } - - rc = register_netdev(g_smsnet_device); - if (rc < 0) - { - printk(KERN_INFO "%s register_netdev() failed %d\n", __FUNCTION__, rc); - free_netdev(g_smsnet_device); - return rc; - } - - rc = smscore_register_hotplug(smsnet_hotplug); - - printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); - - return rc; -} - -void smsnet_module_exit(void) -{ - if (g_smsnet_device) - { - unregister_netdev(g_smsnet_device); - free_netdev(g_smsnet_device); - - g_smsnet_device = NULL; - } - - smscore_unregister_hotplug(smsnet_hotplug); - - kmutex_lock(&g_smsnet_clientslock); - - while (!list_empty(&g_smsnet_clients)) - smsnet_unregister_client((smsnet_client_t*) g_smsnet_clients.next); - - kmutex_unlock(&g_smsnet_clientslock); - - printk(KERN_INFO "%s\n", __FUNCTION__); -} - -module_init(smsnet_module_init); -module_exit(smsnet_module_exit); - -MODULE_DESCRIPTION("smsnet dvb-h ip sink module"); -MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); -MODULE_LICENSE("GPL"); -- cgit v1.2.3 From ac971eee3fdc04962b491168bae7ca76c48620d6 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 19 May 2008 15:09:21 -0400 Subject: sms1xxx: remove smschar.o From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/Makefile | 2 +- linux/drivers/media/mdtv/smschar.c | 577 -------------------------------- linux/drivers/media/mdtv/smschar.h | 7 - linux/drivers/media/mdtv/smscharioctl.h | 17 - linux/drivers/media/mdtv/smscoreapi.c | 8 +- 5 files changed, 2 insertions(+), 609 deletions(-) delete mode 100644 linux/drivers/media/mdtv/smschar.c delete mode 100644 linux/drivers/media/mdtv/smschar.h delete mode 100644 linux/drivers/media/mdtv/smscharioctl.h (limited to 'linux') diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile index c3cf917d7..0af1b3827 100644 --- a/linux/drivers/media/mdtv/Makefile +++ b/linux/drivers/media/mdtv/Makefile @@ -2,7 +2,7 @@ # Makefile for the kernel MDTV driver # -smscore-objs := smschar.o smscoreapi.o +smscore-objs := smscoreapi.o obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smscore.o obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsusb.o diff --git a/linux/drivers/media/mdtv/smschar.c b/linux/drivers/media/mdtv/smschar.c deleted file mode 100644 index 15ebecd59..000000000 --- a/linux/drivers/media/mdtv/smschar.c +++ /dev/null @@ -1,577 +0,0 @@ -/*! - - \file smschar.c - - \brief Implementation of smscore client for cdev based access - - \par Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. - - \par This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License version 3 as - published by the Free Software Foundation; - - Software distributed under the License is distributed on an "AS - IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - implied. - - \author Anatoly Greenblat - -*/ - -#include -#include -#include - -#include /* printk() */ -#include /* everything... */ -#include /* size_t */ -#include -#include -#include /* cli(), *_flags */ -#include /* copy_*_user */ - -#include "smskdefs.h" // page, scatterlist, kmutex -#include "smscoreapi.h" -#include "smstypes.h" - -#include "smscharioctl.h" - -#define SMS_CHR_MAX_Q_LEN 10 // max number of packets allowed to be pending on queue -#define SMSCHAR_NR_DEVS 7 - -typedef struct _smschar_device -{ - struct cdev cdev; //!< Char device structure - kernel's device model representation - - wait_queue_head_t waitq; /* Processes waiting */ - spinlock_t lock; //!< critical section - int pending_count; - struct list_head pending_data; //!< list of pending data - - smscore_buffer_t *currentcb; - - int device_index; - - smscore_device_t *coredev; - smscore_client_t *smsclient; -} smschar_device_t; - -//! Holds the major number of the device node. may be changed at load time. -int smschar_major = 251; - -//! Holds the first minor number of the device node. may be changed at load time. -int smschar_minor = 0; - -// macros that allow the load time parameters change -module_param ( smschar_major, int, S_IRUGO ); -module_param ( smschar_minor, int, S_IRUGO ); - -#ifdef SMSCHAR_DEBUG - - #undef PERROR -# define PERROR(fmt, args...) printk( KERN_INFO "smschar error: line %d- %s(): " fmt,__LINE__, __FUNCTION__, ## args) - #undef PWARNING -# define PWARNING(fmt, args...) printk( KERN_INFO "smschar warning: line %d- %s(): " fmt,__LINE__, __FUNCTION__, ## args) - #undef PDEBUG /* undef it, just in case */ -# define PDEBUG(fmt, args...) printk( KERN_INFO "smschar - %s(): " fmt, __FUNCTION__, ## args) - -#else /* not debugging: nothing */ - - #define PDEBUG(fmt, args...) - #define PERROR(fmt, args...) - #define PWARNING(fmt, args...) - -#endif - -smschar_device_t smschar_devices[SMSCHAR_NR_DEVS]; -static int g_smschar_inuse = 0; - -/** - * unregisters sms client and returns all queued buffers - * - * @param dev pointer to the client context (smschar parameters block) - * - */ -void smschar_unregister_client(smschar_device_t* dev) -{ - unsigned long flags; - - if (dev->coredev && dev->smsclient) - { - wake_up_interruptible(&dev->waitq); - - spin_lock_irqsave(&dev->lock, flags); - - while (!list_empty(&dev->pending_data)) - { - smscore_buffer_t *cb = (smscore_buffer_t *) dev->pending_data.next; - list_del(&cb->entry); - - smscore_putbuffer(dev->coredev, cb); - - dev->pending_count --; - } - - if (dev->currentcb) - { - smscore_putbuffer(dev->coredev, dev->currentcb); - dev->currentcb = NULL; - dev->pending_count --; - } - - smscore_unregister_client(dev->smsclient); - dev->smsclient = NULL; - - spin_unlock_irqrestore(&dev->lock, flags); - } -} - -/** - * queues incoming buffers into buffers queue - * - * @param context pointer to the client context (smschar parameters block) - * @param cb pointer to incoming buffer descriptor - * - * @return 0 on success, <0 on queue overflow. - */ -int smschar_onresponse(void *context, smscore_buffer_t *cb) -{ - smschar_device_t *dev = context; - unsigned long flags; - - spin_lock_irqsave(&dev->lock, flags); - - if (dev->pending_count > SMS_CHR_MAX_Q_LEN) - { - spin_unlock_irqrestore(&dev->lock, flags); - return -EBUSY; - } - - dev->pending_count ++; - - // if data channel, remove header - if (dev->device_index) - { - cb->size -= sizeof(SmsMsgHdr_ST); - cb->offset += sizeof(SmsMsgHdr_ST); - } - - list_add_tail(&cb->entry, &dev->pending_data); - spin_unlock_irqrestore(&dev->lock, flags); - - if (waitqueue_active(&dev->waitq)) - wake_up_interruptible(&dev->waitq); - - return 0; -} - -/** - * handles device removal event - * - * @param context pointer to the client context (smschar parameters block) - * - */ -void smschar_onremove(void *context) -{ - smschar_device_t *dev = (smschar_device_t *) context; - - smschar_unregister_client(dev); - dev->coredev = NULL; -} - -/** - * registers client associated with the node - * - * @param inode Inode concerned. - * @param file File concerned. - * - * @return 0 on success, <0 on error. - */ -int smschar_open (struct inode *inode, struct file *file) -{ - smschar_device_t *dev = container_of(inode->i_cdev, smschar_device_t, cdev); - int rc = -ENODEV; - - PDEBUG("entering index %d\n", dev->device_index); - - if (dev->coredev) - { - smsclient_params_t params; - - params.initial_id = dev->device_index ? dev->device_index : SMS_HOST_LIB; - params.data_type = dev->device_index ? MSG_SMS_DAB_CHANNEL : 0; - params.onresponse_handler = smschar_onresponse; - params.onremove_handler = smschar_onremove; - params.context = dev; - - rc = smscore_register_client(dev->coredev, ¶ms, &dev->smsclient); - if (!rc) - { - file->private_data = dev; - } - } - - PDEBUG("exiting, rc %d\n", rc); - - return rc; -} - -/** - * unregisters client associated with the node - * - * @param inode Inode concerned. - * @param file File concerned. - * - */ -int smschar_release(struct inode *inode, struct file *file) -{ - smschar_unregister_client(file->private_data); - - PDEBUG("exiting\n"); - - return 0; -} - -/** - * copies data from buffers in incoming queue into a user buffer - * - * @param file File structure. - * @param buf Source buffer. - * @param count Size of source buffer. - * @param f_pos Position in file (ignored). - * - * @return Number of bytes read, or <0 on error. - */ -ssize_t smschar_read ( struct file * file, char __user * buf, size_t count, loff_t * f_pos ) -{ - smschar_device_t *dev = file->private_data; - unsigned long flags; - int copied = 0; - - if (!dev->coredev || !dev->smsclient) - { - PERROR("no client\n"); - return -ENODEV; - } - - while (copied != count) - { - if (0 > wait_event_interruptible(dev->waitq, !list_empty(&dev->pending_data))) - { - PERROR("wait_event_interruptible error\n"); - return -ENODEV; - } - - if (!dev->smsclient) - { - PERROR("no client\n"); - return -ENODEV; - } - - spin_lock_irqsave(&dev->lock, flags); - - while (!list_empty(&dev->pending_data) && (copied != count)) - { - smscore_buffer_t *cb = (smscore_buffer_t *) dev->pending_data.next; - int actual_size = min(((int) count - copied), cb->size); - - copy_to_user(&buf[copied], &((char*)cb->p)[cb->offset], actual_size); - - copied += actual_size; - cb->offset += actual_size; - cb->size -= actual_size; - - if (!cb->size) - { - list_del(&cb->entry); - smscore_putbuffer(dev->coredev, cb); - - dev->pending_count --; - } - } - - spin_unlock_irqrestore(&dev->lock, flags); - } - - return copied; -} - -/** - * sends the buffer to the associated device - * - * @param file File structure. - * @param buf Source buffer. - * @param count Size of source buffer. - * @param f_pos Position in file (ignored). - * - * @return Number of bytes read, or <0 on error. - */ -ssize_t smschar_write(struct file *file, const char __user *buf, size_t count, loff_t *f_pos) -{ - smschar_device_t *dev = file->private_data; - void *buffer; - - if (!dev->smsclient) - { - PERROR("no client\n"); - return -ENODEV; - } - - buffer = kmalloc(ALIGN(count, SMS_ALLOC_ALIGNMENT) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); - if (buffer) - { - void *msg_buffer = (void*) SMS_ALIGN_ADDRESS(buffer); - - if (!copy_from_user(msg_buffer, buf, count)) - smsclient_sendrequest(dev->smsclient, msg_buffer, count); - else - count = 0; - - kfree(buffer); - } - - return count; -} - -int smschar_mmap(struct file *file, struct vm_area_struct *vma) -{ - smschar_device_t *dev = file->private_data; - return smscore_map_common_buffer(dev->coredev, vma); -} - -/** - * waits until buffer inserted into a queue. when inserted buffer offset are reported - * to the calling process. previously reported buffer is returned to smscore pool - * - * @param dev pointer to smschar parameters block - * @param touser pointer to a structure that receives incoming buffer offsets - * - * @return 0 on success, <0 on error. - */ -int smschar_wait_get_buffer(smschar_device_t* dev, smschar_buffer_t* touser) -{ - unsigned long flags; - int rc; - - spin_lock_irqsave(&dev->lock, flags); - - if (dev->currentcb) - { - smscore_putbuffer(dev->coredev, dev->currentcb); - dev->currentcb = NULL; - dev->pending_count --; - } - - spin_unlock_irqrestore(&dev->lock, flags); - - rc = wait_event_interruptible(dev->waitq, !list_empty(&dev->pending_data)); - if (rc < 0) - { - PERROR("wait_event_interruptible error\n"); - return rc; - } - - if (!dev->smsclient) - { - PERROR("no client\n"); - return -ENODEV; - } - - spin_lock_irqsave(&dev->lock, flags); - - if (!list_empty(&dev->pending_data)) - { - smscore_buffer_t *cb = (smscore_buffer_t *) dev->pending_data.next; - - touser->offset = cb->offset_in_common + cb->offset; - touser->size = cb->size; - - list_del(&cb->entry); - - dev->currentcb = cb; - } - else - { - touser->offset = 0; - touser->size = 0; - } - - spin_unlock_irqrestore(&dev->lock, flags); - - return 0; -} - -int smschar_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) -{ - smschar_device_t *dev = file->private_data; - void __user *up = (void __user *) arg; - - if (!dev->coredev || !dev->smsclient) - { - PERROR("no client\n"); - return -ENODEV; - } - - switch(cmd) - { - case SMSCHAR_SET_DEVICE_MODE: - return smscore_set_device_mode(dev->coredev, (int) arg); - - case SMSCHAR_GET_DEVICE_MODE: - { - if (put_user(smscore_get_device_mode(dev->coredev), (int*) up)) - return -EFAULT; - - break; - } - - case SMSCHAR_GET_BUFFER_SIZE: - { - if (put_user(smscore_get_common_buffer_size(dev->coredev), (int*) up)) - return -EFAULT; - - break; - } - - case SMSCHAR_WAIT_GET_BUFFER: - { - smschar_buffer_t touser; - int rc; - - rc = smschar_wait_get_buffer(dev, &touser); - if (rc < 0) - return rc; - - if (copy_to_user(up, &touser, sizeof(smschar_buffer_t))) - return -EFAULT; - - break; - } - - default: - return -ENOIOCTLCMD; - } - - return 0; -} - -struct file_operations smschar_fops = -{ - .owner = THIS_MODULE, - .read = smschar_read, - .write = smschar_write, - .open = smschar_open, - .release = smschar_release, - .mmap = smschar_mmap, - .ioctl = smschar_ioctl, -}; - -static int smschar_setup_cdev ( smschar_device_t *dev, int index ) -{ - int rc, devno = MKDEV ( smschar_major, smschar_minor + index ); - - cdev_init ( &dev->cdev, &smschar_fops ); - - dev->cdev.owner = THIS_MODULE; - dev->cdev.ops = &smschar_fops; - - kobject_set_name(&dev->cdev.kobj, "Siano_sms%d", index); - - rc = cdev_add ( &dev->cdev, devno, 1 ); - - PDEBUG("exiting %p %d, rc %d\n", dev, index, rc); - - return rc; -} - -/** - * smschar callback that called when device plugged in/out. the function - * register or unregisters char device interface according to plug in/out - * - * @param coredev pointer to device that is being plugged in/out - * @param device pointer to system device object - * @param arrival 1 on plug-on, 0 othewise - * - * @return 0 on success, <0 on error. - */ -int smschar_hotplug(smscore_device_t* coredev, struct device* device, int arrival) -{ - int rc = 0, i; - - PDEBUG("entering %d\n", arrival); - - if (arrival) - { - // currently only 1 instance supported - if (!g_smschar_inuse) - { - /* data notification callbacks assignment */ - memset ( smschar_devices, 0, SMSCHAR_NR_DEVS * sizeof ( smschar_device_t ) ); - - /* Initialize each device. */ - for (i = 0; i < SMSCHAR_NR_DEVS; i++) - { - smschar_setup_cdev ( &smschar_devices[i], i ); - - INIT_LIST_HEAD(&smschar_devices[i].pending_data); - spin_lock_init(&smschar_devices[i].lock); - init_waitqueue_head(&smschar_devices[i].waitq); - - smschar_devices[i].coredev = coredev; - smschar_devices[i].device_index = i; - } - - g_smschar_inuse = 1; - } - } - else - { - // currently only 1 instance supported - if (g_smschar_inuse) - { - /* Get rid of our char dev entries */ - for(i = 0; i < SMSCHAR_NR_DEVS; i++) - cdev_del(&smschar_devices[i].cdev); - - g_smschar_inuse = 0; - } - } - - PDEBUG("exiting, rc %d\n", rc); - - return rc; /* succeed */ -} - -int smschar_initialize(void) -{ - dev_t devno = MKDEV ( smschar_major, smschar_minor ); - int rc; - - if(smschar_major) - { - rc = register_chrdev_region ( devno, SMSCHAR_NR_DEVS, "smschar" ); - } - else - { - rc = alloc_chrdev_region ( &devno, smschar_minor, SMSCHAR_NR_DEVS, "smschar" ); - smschar_major = MAJOR ( devno ); - } - - if (rc < 0) - { - PWARNING ( "smschar: can't get major %d\n", smschar_major ); - return rc; - } - - return smscore_register_hotplug(smschar_hotplug); -} -EXPORT_SYMBOL(smschar_initialize); - -void smschar_terminate(void) -{ - dev_t devno = MKDEV ( smschar_major, smschar_minor ); - - unregister_chrdev_region(devno, SMSCHAR_NR_DEVS); - smscore_unregister_hotplug(smschar_hotplug); -} -EXPORT_SYMBOL(smschar_terminate); diff --git a/linux/drivers/media/mdtv/smschar.h b/linux/drivers/media/mdtv/smschar.h deleted file mode 100644 index 1cd2f32a7..000000000 --- a/linux/drivers/media/mdtv/smschar.h +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef __smschar_h__ -#define __smschar_h__ - -extern int smschar_initialize(void); -extern void smschar_terminate(void); - -#endif // __smschar_h__ diff --git a/linux/drivers/media/mdtv/smscharioctl.h b/linux/drivers/media/mdtv/smscharioctl.h deleted file mode 100644 index e57b89efc..000000000 --- a/linux/drivers/media/mdtv/smscharioctl.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef __smscharioctl_h__ -#define __smscharioctl_h__ - -#include - -typedef struct _smschar_buffer_t -{ - unsigned long offset; // offset in common buffer (mapped to user space) - int size; -} smschar_buffer_t; - -#define SMSCHAR_SET_DEVICE_MODE _IOW('K', 0, int) -#define SMSCHAR_GET_DEVICE_MODE _IOR('K', 1, int) -#define SMSCHAR_GET_BUFFER_SIZE _IOR('K', 2, int) -#define SMSCHAR_WAIT_GET_BUFFER _IOR('K', 3, smschar_buffer_t) - -#endif // __smscharioctl_h__ diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c index 27572f04a..9358c04a2 100644 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -34,8 +34,6 @@ #include "smscoreapi.h" #include "smstypes.h" -#include "smschar.h" - typedef struct _smscore_device_notifyee { struct list_head entry; @@ -1155,7 +1153,7 @@ int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * int smscore_module_init(void) { - int rc; + int rc = 0; INIT_LIST_HEAD(&g_smscore_notifyees); INIT_LIST_HEAD(&g_smscore_devices); @@ -1164,8 +1162,6 @@ int smscore_module_init(void) INIT_LIST_HEAD(&g_smscore_registry); kmutex_init(&g_smscore_registrylock); - rc = smschar_initialize(); - printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); return rc; @@ -1173,8 +1169,6 @@ int smscore_module_init(void) void smscore_module_exit(void) { - smschar_terminate(); - kmutex_lock(&g_smscore_deviceslock); while (!list_empty(&g_smscore_notifyees)) { -- cgit v1.2.3 From c4602328a0543f0d593f700b5526b2cbc4dfdba6 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 11:46:32 -0400 Subject: sms1xxx: merge ksyms From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smscoreapi.c | 2 -- linux/drivers/media/mdtv/smscoreapi.h | 36 +++++++++++++++++++++++++++++++++++ linux/drivers/media/mdtv/smsdvb.c | 1 - linux/drivers/media/mdtv/smskdefs.h | 36 ----------------------------------- linux/drivers/media/mdtv/smsusb.c | 1 - 5 files changed, 36 insertions(+), 40 deletions(-) delete mode 100644 linux/drivers/media/mdtv/smskdefs.h (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c index 9358c04a2..f3cdb80a8 100644 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -27,8 +27,6 @@ #include #include -#include "smskdefs.h" // device, page, scatterlist, kmutex - #include #include "smscoreapi.h" diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h index a8c025f74..c72789acf 100644 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -1,6 +1,42 @@ #ifndef __smscoreapi_h__ #define __smscoreapi_h__ +/* From sysksyms.h */ + +#include +#include +#include +#include +#include +#include + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) +#include + +typedef struct mutex kmutex_t; + +#define kmutex_init(_p_) mutex_init(_p_) +#define kmutex_lock(_p_) mutex_lock(_p_) +#define kmutex_trylock(_p_) mutex_trylock(_p_) +#define kmutex_unlock(_p_) mutex_unlock(_p_) + +#else +#include + +typedef struct semaphore kmutex_t; + +#define kmutex_init(_p_) init_MUTEX(_p_) +#define kmutex_lock(_p_) down(_p_) +#define kmutex_trylock(_p_) (!down_trylock(_p_)) +#define kmutex_unlock(_p_) up(_p_) + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) +void *kzalloc(size_t size, int flags); +#endif +#endif // LINUX_VERSION + +/* End sysksyms.h */ + #ifndef min #define min(a,b) (((a) < (b)) ? (a) : (b)) #endif diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c index ecba51c8b..11a9b0b11 100644 --- a/linux/drivers/media/mdtv/smsdvb.c +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -6,7 +6,6 @@ #include "dvb_demux.h" #include "dvb_frontend.h" -#include "smskdefs.h" // page, scatterlist, kmutex #include "smscoreapi.h" #include "smstypes.h" diff --git a/linux/drivers/media/mdtv/smskdefs.h b/linux/drivers/media/mdtv/smskdefs.h deleted file mode 100644 index e2483d81c..000000000 --- a/linux/drivers/media/mdtv/smskdefs.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef __smskdefs_h__ -#define __smskdefs_h__ - -#include -#include -#include -#include -#include -#include - -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) -#include - -typedef struct mutex kmutex_t; - -#define kmutex_init(_p_) mutex_init(_p_) -#define kmutex_lock(_p_) mutex_lock(_p_) -#define kmutex_trylock(_p_) mutex_trylock(_p_) -#define kmutex_unlock(_p_) mutex_unlock(_p_) - -#else -#include - -typedef struct semaphore kmutex_t; - -#define kmutex_init(_p_) init_MUTEX(_p_) -#define kmutex_lock(_p_) down(_p_) -#define kmutex_trylock(_p_) (!down_trylock(_p_)) -#define kmutex_unlock(_p_) up(_p_) - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) -void *kzalloc(size_t size, int flags); -#endif -#endif // LINUX_VERSION - -#endif // __smskdefs_h__ diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c index cda0581e3..98e3a077e 100644 --- a/linux/drivers/media/mdtv/smsusb.c +++ b/linux/drivers/media/mdtv/smsusb.c @@ -4,7 +4,6 @@ #include #include -#include "smskdefs.h" // page, scatterlist, kmutex #include "smscoreapi.h" #include "smstypes.h" -- cgit v1.2.3 From af5bc455eec073546291cb3b94ea111a540320af Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 11:48:54 -0400 Subject: sms1xxx: remove smstypes.h From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smscoreapi.c | 1 - linux/drivers/media/mdtv/smscoreapi.h | 361 ++++++++++++++++++++++++++++++++++ linux/drivers/media/mdtv/smsdvb.c | 1 - linux/drivers/media/mdtv/smstypes.h | 361 ---------------------------------- linux/drivers/media/mdtv/smsusb.c | 1 - 5 files changed, 361 insertions(+), 364 deletions(-) delete mode 100644 linux/drivers/media/mdtv/smstypes.h (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c index f3cdb80a8..1f4171b1e 100644 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -30,7 +30,6 @@ #include #include "smscoreapi.h" -#include "smstypes.h" typedef struct _smscore_device_notifyee { diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h index c72789acf..92e5c6379 100644 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -107,6 +107,367 @@ typedef struct _smsclient_params void *context; } smsclient_params_t; +/* Begin types.h */ + +// GPIO definitions for antenna frequency domain control (SMS8021) +#define SMS_ANTENNA_GPIO_0 1 +#define SMS_ANTENNA_GPIO_1 0 + +#define BW_8_MHZ 0 +#define BW_7_MHZ 1 +#define BW_6_MHZ 2 +#define BW_5_MHZ 3 +#define BW_ISDBT_1SEG 4 +#define BW_ISDBT_3SEG 5 + +#define MSG_HDR_FLAG_SPLIT_MSG 4 + +#define MAX_GPIO_PIN_NUMBER 31 + +#define HIF_TASK 11 +#define SMS_HOST_LIB 150 +#define DVBT_BDA_CONTROL_MSG_ID 201 + +#define SMS_MAX_PAYLOAD_SIZE 240 +#define SMS_TUNE_TIMEOUT 500 + +#define MSG_SMS_GPIO_CONFIG_REQ 507 +#define MSG_SMS_GPIO_CONFIG_RES 508 +#define MSG_SMS_GPIO_SET_LEVEL_REQ 509 +#define MSG_SMS_GPIO_SET_LEVEL_RES 510 +#define MSG_SMS_GPIO_GET_LEVEL_REQ 511 +#define MSG_SMS_GPIO_GET_LEVEL_RES 512 +#define MSG_SMS_RF_TUNE_REQ 561 +#define MSG_SMS_RF_TUNE_RES 562 +#define MSG_SMS_INIT_DEVICE_REQ 578 +#define MSG_SMS_INIT_DEVICE_RES 579 +#define MSG_SMS_ADD_PID_FILTER_REQ 601 +#define MSG_SMS_ADD_PID_FILTER_RES 602 +#define MSG_SMS_REMOVE_PID_FILTER_REQ 603 +#define MSG_SMS_REMOVE_PID_FILTER_RES 604 +#define MSG_SMS_DAB_CHANNEL 607 +#define MSG_SMS_GET_PID_FILTER_LIST_REQ 608 +#define MSG_SMS_GET_PID_FILTER_LIST_RES 609 +#define MSG_SMS_GET_STATISTICS_REQ 615 +#define MSG_SMS_GET_STATISTICS_RES 616 +#define MSG_SMS_SET_ANTENNA_CONFIG_REQ 651 +#define MSG_SMS_SET_ANTENNA_CONFIG_RES 652 +#define MSG_SMS_GET_STATISTICS_EX_REQ 653 +#define MSG_SMS_GET_STATISTICS_EX_RES 654 +#define MSG_SMS_SLEEP_RESUME_COMP_IND 655 +#define MSG_SMS_DATA_DOWNLOAD_REQ 660 +#define MSG_SMS_DATA_DOWNLOAD_RES 661 +#define MSG_SMS_SWDOWNLOAD_TRIGGER_REQ 664 +#define MSG_SMS_SWDOWNLOAD_TRIGGER_RES 665 +#define MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ 666 +#define MSG_SMS_SWDOWNLOAD_BACKDOOR_RES 667 +#define MSG_SMS_GET_VERSION_EX_REQ 668 +#define MSG_SMS_GET_VERSION_EX_RES 669 +#define MSG_SMS_SET_CLOCK_OUTPUT_REQ 670 +#define MSG_SMS_I2C_SET_FREQ_REQ 685 +#define MSG_SMS_GENERIC_I2C_REQ 687 +#define MSG_SMS_GENERIC_I2C_RES 688 +#define MSG_SMS_DVBT_BDA_DATA 693 +#define MSG_SW_RELOAD_REQ 697 +#define MSG_SMS_DATA_MSG 699 +#define MSG_SW_RELOAD_START_REQ 702 +#define MSG_SW_RELOAD_START_RES 703 +#define MSG_SW_RELOAD_EXEC_REQ 704 +#define MSG_SW_RELOAD_EXEC_RES 705 +#define MSG_SMS_SPI_INT_LINE_SET_REQ 710 +#define MSG_SMS_ISDBT_TUNE_REQ 776 +#define MSG_SMS_ISDBT_TUNE_RES 777 + +#define SMS_INIT_MSG_EX(ptr, type, src, dst, len) do { \ + (ptr)->msgType = type; (ptr)->msgSrcId = src; (ptr)->msgDstId = dst; \ + (ptr)->msgLength = len; (ptr)->msgFlags = 0; \ +} while (0) +#define SMS_INIT_MSG(ptr, type, len) SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) + +typedef enum +{ + DEVICE_MODE_NONE = -1, + DEVICE_MODE_DVBT = 0, + DEVICE_MODE_DVBH, + DEVICE_MODE_DAB_TDMB, + DEVICE_MODE_DAB_TDMB_DABIP, + DEVICE_MODE_DVBT_BDA, + DEVICE_MODE_ISDBT, + DEVICE_MODE_ISDBT_BDA, + DEVICE_MODE_CMMB, + DEVICE_MODE_RAW_TUNER, + DEVICE_MODE_MAX, +} SMS_DEVICE_MODE; + +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned int UINT32; +typedef int INT32; + +typedef struct SmsMsgHdr_S +{ + UINT16 msgType; + UINT8 msgSrcId; + UINT8 msgDstId; + UINT16 msgLength; // Length is of the entire message, including header + UINT16 msgFlags; +} SmsMsgHdr_ST; + +typedef struct SmsMsgData_S +{ + SmsMsgHdr_ST xMsgHeader; + UINT32 msgData[1]; +} SmsMsgData_ST; + +typedef struct SmsDataDownload_S +{ + SmsMsgHdr_ST xMsgHeader; + UINT32 MemAddr; + UINT8 Payload[SMS_MAX_PAYLOAD_SIZE]; +} SmsDataDownload_ST; + +typedef struct SmsVersionRes_S +{ + SmsMsgHdr_ST xMsgHeader; + + UINT16 ChipModel; // e.g. 0x1102 for SMS-1102 "Nova" + UINT8 Step; // 0 - Step A + UINT8 MetalFix; // 0 - Metal 0 + + UINT8 FirmwareId; // 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E + UINT8 SupportedProtocols; // Bitwise OR combination of supported protocols + + UINT8 VersionMajor; + UINT8 VersionMinor; + UINT8 VersionPatch; + UINT8 VersionFieldPatch; + + UINT8 RomVersionMajor; + UINT8 RomVersionMinor; + UINT8 RomVersionPatch; + UINT8 RomVersionFieldPatch; + + UINT8 TextLabel[34]; +} SmsVersionRes_ST; + +typedef struct SmsFirmware_S +{ + UINT32 CheckSum; + UINT32 Length; + UINT32 StartAddress; + UINT8 Payload[1]; +} SmsFirmware_ST; + +typedef struct SMSHOSTLIB_STATISTICS_S +{ + UINT32 Reserved; //!< Reserved + + /// Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + /// Reception quality + INT32 SNR; //!< dB + UINT32 BER; //!< Post Viterbi BER [1E-5] + UINT32 FIB_CRC; //!< CRC errors percentage, valid only for DAB + UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H + UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in bin/1024 + + /// Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz, valid only for DVB-T/H + UINT32 TransmissionMode; //!< Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos + UINT32 ModemState; //!< from SMS_DvbModemState_ET , valid only for DVB-T/H + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value , valid only for DVB-T/H + UINT32 CodeRate; //!< Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H + UINT32 LPCodeRate; //!< Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H + UINT32 Hierarchy; //!< Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H + UINT32 Constellation; //!< Constellation from SMS_Constellation_ET, valid only for DVB-T/H + + /// Burst parameters, valid only for DVB-H + UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H + UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H + UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H + UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H + UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H + UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H + UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding + UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding + UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding + /// Common params + UINT32 BERErrorCount; //!< Number of errornous SYNC bits. + UINT32 BERBitCount; //!< Total number of SYNC bits. + + /// Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + + /// DAB/T-DMB + UINT32 PreBER; //!< DAB/T-DMB only: Pre Viterbi BER [1E-5] + + /// DVB-H TPS parameters + UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + +} SMSHOSTLIB_STATISTICS_ST; + +typedef struct +{ + UINT32 RequestResult; + + SMSHOSTLIB_STATISTICS_ST Stat; + + // Split the calc of the SNR in DAB + UINT32 Signal; //!< dB + UINT32 Noise; //!< dB + +} SmsMsgStatisticsInfo_ST; + +typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S +{ + // Per-layer information + UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist + UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist + UINT32 BER; //!< Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A + UINT32 BERErrorCount; //!< Post Viterbi Error Bits Count + UINT32 BERBitCount; //!< Post Viterbi Total Bits Count + UINT32 PreBER; //!< Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A + UINT32 TS_PER; //!< Transport stream PER [%], 0xFFFFFFFF indicate N/A + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 TILdepthI; //!< Time interleaver depth I parameter, 255 means layer does not exist + UINT32 NumberOfSegments; //!< Number of segments in layer A, 255 means layer does not exist + UINT32 TMCCErrors; //!< TMCC errors +} SMSHOSTLIB_ISDBT_LAYER_STAT_ST; + +typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S +{ + UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + //!< This fiels MUST always first in any statistics structure + + UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by + //!< the host is smaller than FullSize, the struct will be truncated + + // Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + // Reception quality + INT32 SNR; //!< dB + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in Hz + + // Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz + UINT32 TransmissionMode; //!< ISDB-T transmission mode + UINT32 ModemState; //!< 0 - Acquisition, 1 - Locked + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value + UINT32 SystemType; //!< ISDB-T system type (ISDB-T / ISDB-Tsb) + UINT32 PartialReception; //!< TRUE - partial reception, FALSE otherwise + UINT32 NumOfLayers; //!< Number of ISDB-T layers in the network + + // Per-layer information + // Layers A, B and C + SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; //!< Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST + + // Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + +} SMSHOSTLIB_STATISTICS_ISDBT_ST; + +typedef struct SMSHOSTLIB_STATISTICS_DVB_S +{ + UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + //!< This fiels MUST always first in any statistics structure + + UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by + //!< the host is smaller than FullSize, the struct will be truncated + // Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + // Reception quality + INT32 SNR; //!< dB + UINT32 BER; //!< Post Viterbi BER [1E-5] + UINT32 BERErrorCount; //!< Number of errornous SYNC bits. + UINT32 BERBitCount; //!< Total number of SYNC bits. + UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A + UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in bin/1024 + + // Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz + UINT32 ModemState; //!< from SMSHOSTLIB_DVB_MODEM_STATE_ET + UINT32 TransmissionMode; //!< FFT mode carriers in Kilos + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value + UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET + UINT32 LPCodeRate; //!< Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET + UINT32 Hierarchy; //!< Hierarchy from SMSHOSTLIB_HIERARCHY_ET + UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET + + // Burst parameters, valid only for DVB-H + UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H + UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H + UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H + UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H + UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H + UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H + UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H + UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H + UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H + UINT32 NumMPEReceived; //!< DVB-H, Num MPE section received + + // DVB-H TPS parameters + UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + UINT32 DvbhSrvIndHP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator + UINT32 DvbhSrvIndLP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator + + // Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + +} SMSHOSTLIB_STATISTICS_DVB_ST; + +typedef struct SMSHOSTLIB_GPIO_CONFIG_S +{ + UINT8 Direction; //!< GPIO direction: Input - 0, Output - 1 + UINT8 PullUpDown; //!< PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 + UINT8 InputCharacteristics; //!< Input Characteristics: Normal - 0, Schmitt trigger - 1 + UINT8 OutputSlewRate; //!< Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 + UINT8 OutputDriving; //!< Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 +} SMSHOSTLIB_GPIO_CONFIG_ST; + +typedef struct SMSHOSTLIB_I2C_REQ_S +{ + UINT32 DeviceAddress; // I2c device address + UINT32 WriteCount; // number of bytes to write + UINT32 ReadCount; // number of bytes to read + UINT8 Data[1]; +} SMSHOSTLIB_I2C_REQ_ST; + +typedef struct SMSHOSTLIB_I2C_RES_S +{ + UINT32 Status; // non-zero value in case of failure + UINT32 ReadCount; // number of bytes read + UINT8 Data[1]; +} SMSHOSTLIB_I2C_RES_ST; + +/* End types.h */ + extern void smscore_registry_setmode(char *devpath, int mode); extern int smscore_registry_getmode(char *devpath); diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c index 11a9b0b11..e941a0b97 100644 --- a/linux/drivers/media/mdtv/smsdvb.c +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -7,7 +7,6 @@ #include "dvb_frontend.h" #include "smscoreapi.h" -#include "smstypes.h" DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); diff --git a/linux/drivers/media/mdtv/smstypes.h b/linux/drivers/media/mdtv/smstypes.h deleted file mode 100644 index 011cd904d..000000000 --- a/linux/drivers/media/mdtv/smstypes.h +++ /dev/null @@ -1,361 +0,0 @@ -#ifndef __smstypes_h__ -#define __smstypes_h__ - -// GPIO definitions for antenna frequency domain control (SMS8021) -#define SMS_ANTENNA_GPIO_0 1 -#define SMS_ANTENNA_GPIO_1 0 - -#define BW_8_MHZ 0 -#define BW_7_MHZ 1 -#define BW_6_MHZ 2 -#define BW_5_MHZ 3 -#define BW_ISDBT_1SEG 4 -#define BW_ISDBT_3SEG 5 - -#define MSG_HDR_FLAG_SPLIT_MSG 4 - -#define MAX_GPIO_PIN_NUMBER 31 - -#define HIF_TASK 11 -#define SMS_HOST_LIB 150 -#define DVBT_BDA_CONTROL_MSG_ID 201 - -#define SMS_MAX_PAYLOAD_SIZE 240 -#define SMS_TUNE_TIMEOUT 500 - -#define MSG_SMS_GPIO_CONFIG_REQ 507 -#define MSG_SMS_GPIO_CONFIG_RES 508 -#define MSG_SMS_GPIO_SET_LEVEL_REQ 509 -#define MSG_SMS_GPIO_SET_LEVEL_RES 510 -#define MSG_SMS_GPIO_GET_LEVEL_REQ 511 -#define MSG_SMS_GPIO_GET_LEVEL_RES 512 -#define MSG_SMS_RF_TUNE_REQ 561 -#define MSG_SMS_RF_TUNE_RES 562 -#define MSG_SMS_INIT_DEVICE_REQ 578 -#define MSG_SMS_INIT_DEVICE_RES 579 -#define MSG_SMS_ADD_PID_FILTER_REQ 601 -#define MSG_SMS_ADD_PID_FILTER_RES 602 -#define MSG_SMS_REMOVE_PID_FILTER_REQ 603 -#define MSG_SMS_REMOVE_PID_FILTER_RES 604 -#define MSG_SMS_DAB_CHANNEL 607 -#define MSG_SMS_GET_PID_FILTER_LIST_REQ 608 -#define MSG_SMS_GET_PID_FILTER_LIST_RES 609 -#define MSG_SMS_GET_STATISTICS_REQ 615 -#define MSG_SMS_GET_STATISTICS_RES 616 -#define MSG_SMS_SET_ANTENNA_CONFIG_REQ 651 -#define MSG_SMS_SET_ANTENNA_CONFIG_RES 652 -#define MSG_SMS_GET_STATISTICS_EX_REQ 653 -#define MSG_SMS_GET_STATISTICS_EX_RES 654 -#define MSG_SMS_SLEEP_RESUME_COMP_IND 655 -#define MSG_SMS_DATA_DOWNLOAD_REQ 660 -#define MSG_SMS_DATA_DOWNLOAD_RES 661 -#define MSG_SMS_SWDOWNLOAD_TRIGGER_REQ 664 -#define MSG_SMS_SWDOWNLOAD_TRIGGER_RES 665 -#define MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ 666 -#define MSG_SMS_SWDOWNLOAD_BACKDOOR_RES 667 -#define MSG_SMS_GET_VERSION_EX_REQ 668 -#define MSG_SMS_GET_VERSION_EX_RES 669 -#define MSG_SMS_SET_CLOCK_OUTPUT_REQ 670 -#define MSG_SMS_I2C_SET_FREQ_REQ 685 -#define MSG_SMS_GENERIC_I2C_REQ 687 -#define MSG_SMS_GENERIC_I2C_RES 688 -#define MSG_SMS_DVBT_BDA_DATA 693 -#define MSG_SW_RELOAD_REQ 697 -#define MSG_SMS_DATA_MSG 699 -#define MSG_SW_RELOAD_START_REQ 702 -#define MSG_SW_RELOAD_START_RES 703 -#define MSG_SW_RELOAD_EXEC_REQ 704 -#define MSG_SW_RELOAD_EXEC_RES 705 -#define MSG_SMS_SPI_INT_LINE_SET_REQ 710 -#define MSG_SMS_ISDBT_TUNE_REQ 776 -#define MSG_SMS_ISDBT_TUNE_RES 777 - -#define SMS_INIT_MSG_EX(ptr, type, src, dst, len) do { \ - (ptr)->msgType = type; (ptr)->msgSrcId = src; (ptr)->msgDstId = dst; \ - (ptr)->msgLength = len; (ptr)->msgFlags = 0; \ -} while (0) -#define SMS_INIT_MSG(ptr, type, len) SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) - -typedef enum -{ - DEVICE_MODE_NONE = -1, - DEVICE_MODE_DVBT = 0, - DEVICE_MODE_DVBH, - DEVICE_MODE_DAB_TDMB, - DEVICE_MODE_DAB_TDMB_DABIP, - DEVICE_MODE_DVBT_BDA, - DEVICE_MODE_ISDBT, - DEVICE_MODE_ISDBT_BDA, - DEVICE_MODE_CMMB, - DEVICE_MODE_RAW_TUNER, - DEVICE_MODE_MAX, -} SMS_DEVICE_MODE; - -typedef unsigned char UINT8; -typedef unsigned short UINT16; -typedef unsigned int UINT32; -typedef int INT32; - -typedef struct SmsMsgHdr_S -{ - UINT16 msgType; - UINT8 msgSrcId; - UINT8 msgDstId; - UINT16 msgLength; // Length is of the entire message, including header - UINT16 msgFlags; -} SmsMsgHdr_ST; - -typedef struct SmsMsgData_S -{ - SmsMsgHdr_ST xMsgHeader; - UINT32 msgData[1]; -} SmsMsgData_ST; - -typedef struct SmsDataDownload_S -{ - SmsMsgHdr_ST xMsgHeader; - UINT32 MemAddr; - UINT8 Payload[SMS_MAX_PAYLOAD_SIZE]; -} SmsDataDownload_ST; - -typedef struct SmsVersionRes_S -{ - SmsMsgHdr_ST xMsgHeader; - - UINT16 ChipModel; // e.g. 0x1102 for SMS-1102 "Nova" - UINT8 Step; // 0 - Step A - UINT8 MetalFix; // 0 - Metal 0 - - UINT8 FirmwareId; // 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E - UINT8 SupportedProtocols; // Bitwise OR combination of supported protocols - - UINT8 VersionMajor; - UINT8 VersionMinor; - UINT8 VersionPatch; - UINT8 VersionFieldPatch; - - UINT8 RomVersionMajor; - UINT8 RomVersionMinor; - UINT8 RomVersionPatch; - UINT8 RomVersionFieldPatch; - - UINT8 TextLabel[34]; -} SmsVersionRes_ST; - -typedef struct SmsFirmware_S -{ - UINT32 CheckSum; - UINT32 Length; - UINT32 StartAddress; - UINT8 Payload[1]; -} SmsFirmware_ST; - -typedef struct SMSHOSTLIB_STATISTICS_S -{ - UINT32 Reserved; //!< Reserved - - /// Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - /// Reception quality - INT32 SNR; //!< dB - UINT32 BER; //!< Post Viterbi BER [1E-5] - UINT32 FIB_CRC; //!< CRC errors percentage, valid only for DAB - UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H - UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in bin/1024 - - /// Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz, valid only for DVB-T/H - UINT32 TransmissionMode; //!< Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos - UINT32 ModemState; //!< from SMS_DvbModemState_ET , valid only for DVB-T/H - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value , valid only for DVB-T/H - UINT32 CodeRate; //!< Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H - UINT32 LPCodeRate; //!< Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H - UINT32 Hierarchy; //!< Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H - UINT32 Constellation; //!< Constellation from SMS_Constellation_ET, valid only for DVB-T/H - - /// Burst parameters, valid only for DVB-H - UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H - UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H - UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H - UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H - UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H - UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H - UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding - UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding - UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding - /// Common params - UINT32 BERErrorCount; //!< Number of errornous SYNC bits. - UINT32 BERBitCount; //!< Total number of SYNC bits. - - /// Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - - /// DAB/T-DMB - UINT32 PreBER; //!< DAB/T-DMB only: Pre Viterbi BER [1E-5] - - /// DVB-H TPS parameters - UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered - -} SMSHOSTLIB_STATISTICS_ST; - -typedef struct -{ - UINT32 RequestResult; - - SMSHOSTLIB_STATISTICS_ST Stat; - - // Split the calc of the SNR in DAB - UINT32 Signal; //!< dB - UINT32 Noise; //!< dB - -} SmsMsgStatisticsInfo_ST; - -typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S -{ - // Per-layer information - UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist - UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist - UINT32 BER; //!< Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A - UINT32 BERErrorCount; //!< Post Viterbi Error Bits Count - UINT32 BERBitCount; //!< Post Viterbi Total Bits Count - UINT32 PreBER; //!< Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A - UINT32 TS_PER; //!< Transport stream PER [%], 0xFFFFFFFF indicate N/A - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 TILdepthI; //!< Time interleaver depth I parameter, 255 means layer does not exist - UINT32 NumberOfSegments; //!< Number of segments in layer A, 255 means layer does not exist - UINT32 TMCCErrors; //!< TMCC errors -} SMSHOSTLIB_ISDBT_LAYER_STAT_ST; - -typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S -{ - UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - //!< This fiels MUST always first in any statistics structure - - UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by - //!< the host is smaller than FullSize, the struct will be truncated - - // Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - // Reception quality - INT32 SNR; //!< dB - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in Hz - - // Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz - UINT32 TransmissionMode; //!< ISDB-T transmission mode - UINT32 ModemState; //!< 0 - Acquisition, 1 - Locked - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value - UINT32 SystemType; //!< ISDB-T system type (ISDB-T / ISDB-Tsb) - UINT32 PartialReception; //!< TRUE - partial reception, FALSE otherwise - UINT32 NumOfLayers; //!< Number of ISDB-T layers in the network - - // Per-layer information - // Layers A, B and C - SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; //!< Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST - - // Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - -} SMSHOSTLIB_STATISTICS_ISDBT_ST; - -typedef struct SMSHOSTLIB_STATISTICS_DVB_S -{ - UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - //!< This fiels MUST always first in any statistics structure - - UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by - //!< the host is smaller than FullSize, the struct will be truncated - // Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - // Reception quality - INT32 SNR; //!< dB - UINT32 BER; //!< Post Viterbi BER [1E-5] - UINT32 BERErrorCount; //!< Number of errornous SYNC bits. - UINT32 BERBitCount; //!< Total number of SYNC bits. - UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A - UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in bin/1024 - - // Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz - UINT32 ModemState; //!< from SMSHOSTLIB_DVB_MODEM_STATE_ET - UINT32 TransmissionMode; //!< FFT mode carriers in Kilos - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value - UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET - UINT32 LPCodeRate; //!< Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET - UINT32 Hierarchy; //!< Hierarchy from SMSHOSTLIB_HIERARCHY_ET - UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET - - // Burst parameters, valid only for DVB-H - UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H - UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H - UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H - UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H - UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H - UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H - UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H - UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H - UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H - UINT32 NumMPEReceived; //!< DVB-H, Num MPE section received - - // DVB-H TPS parameters - UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered - UINT32 DvbhSrvIndHP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator - UINT32 DvbhSrvIndLP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator - - // Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - -} SMSHOSTLIB_STATISTICS_DVB_ST; - -typedef struct SMSHOSTLIB_GPIO_CONFIG_S -{ - UINT8 Direction; //!< GPIO direction: Input - 0, Output - 1 - UINT8 PullUpDown; //!< PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 - UINT8 InputCharacteristics; //!< Input Characteristics: Normal - 0, Schmitt trigger - 1 - UINT8 OutputSlewRate; //!< Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 - UINT8 OutputDriving; //!< Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 -} SMSHOSTLIB_GPIO_CONFIG_ST; - -typedef struct SMSHOSTLIB_I2C_REQ_S -{ - UINT32 DeviceAddress; // I2c device address - UINT32 WriteCount; // number of bytes to write - UINT32 ReadCount; // number of bytes to read - UINT8 Data[1]; -} SMSHOSTLIB_I2C_REQ_ST; - -typedef struct SMSHOSTLIB_I2C_RES_S -{ - UINT32 Status; // non-zero value in case of failure - UINT32 ReadCount; // number of bytes read - UINT8 Data[1]; -} SMSHOSTLIB_I2C_RES_ST; - -#endif // __smstypes_h__ diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c index 98e3a077e..99e600c33 100644 --- a/linux/drivers/media/mdtv/smsusb.c +++ b/linux/drivers/media/mdtv/smsusb.c @@ -5,7 +5,6 @@ #include #include "smscoreapi.h" -#include "smstypes.h" #define USB_VID_SIANO 0x187f #define USB_PID_0010 0x0010 -- cgit v1.2.3 From 8372e1b08569d0fe1a1c18cbfea60edfef2872b6 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 12:43:04 -0400 Subject: sms1xxx: Kconfig / Makefile cleanups From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/Kconfig | 22 +--------------------- linux/drivers/media/mdtv/Makefile | 4 +--- 2 files changed, 2 insertions(+), 24 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/Kconfig b/linux/drivers/media/mdtv/Kconfig index f3bae4500..a7faca0b7 100644 --- a/linux/drivers/media/mdtv/Kconfig +++ b/linux/drivers/media/mdtv/Kconfig @@ -2,35 +2,15 @@ # Mobile Digital TV device configuration # -config MDTV_SIANO_STELLAR_COMMON - tristate "Siano SMS10xx adapter" - default m - ---help--- - Choose Y here if you have SMS10xx chipset. - - In order to control the SMS10xx chipset you will need SMS Host Control library. - - Further documentation on this driver can be found on the WWW at - . - - To compile this driver as a module, choose M here: the - modules will be called smschar and smsnet. - config MDTV_SIANO_STELLAR_USB tristate "Siano SMS10xx USB dongle support" - depends on MDTV_SIANO_STELLAR_COMMON default m ---help--- Choose Y here if you have USB dongle with SMS10xx chipset. - In order to control the SMS10xx chipset you will need SMS Host Control library. - Further documentation on this driver can be found on the WWW at . To compile this driver as a module, choose M here: the - module will be called smsusb. - - - + modules will be called smschar and smsnet. diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile index 0af1b3827..e3d727d0a 100644 --- a/linux/drivers/media/mdtv/Makefile +++ b/linux/drivers/media/mdtv/Makefile @@ -4,6 +4,4 @@ smscore-objs := smscoreapi.o -obj-$(CONFIG_MDTV_SIANO_STELLAR_COMMON) += smscore.o -obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsusb.o -obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smsdvb.o +obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smscore.o smsusb.o smsdvb.o -- cgit v1.2.3 From a3391d3fb1b84d88cf59801bbbb1a9ede64e4d15 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:01:02 -0400 Subject: sms1xxx: merge modules From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smscoreapi.h | 31 ++++++++++++++++++ linux/drivers/media/mdtv/smsdvb.c | 61 ----------------------------------- linux/drivers/media/mdtv/smsusb.c | 20 ++++++++++++ 3 files changed, 51 insertions(+), 61 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h index 92e5c6379..166379262 100644 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -1,6 +1,11 @@ #ifndef __smscoreapi_h__ #define __smscoreapi_h__ +#include "dmxdev.h" +#include "dvbdev.h" +#include "dvb_demux.h" +#include "dvb_frontend.h" + /* From sysksyms.h */ #include @@ -468,6 +473,28 @@ typedef struct SMSHOSTLIB_I2C_RES_S /* End types.h */ +typedef struct _smsdvb_client +{ + struct list_head entry; + + smscore_device_t *coredev; + smscore_client_t *smsclient; + + struct dvb_adapter adapter; + struct dvb_demux demux; + struct dmxdev dmxdev; + struct dvb_frontend frontend; + + fe_status_t fe_status; + int fe_ber, fe_snr, fe_signal_strength; + + struct completion tune_done, stat_done; + + // todo: save freq/band instead whole struct + struct dvb_frontend_parameters fe_params; + +} smsdvb_client_t; + extern void smscore_registry_setmode(char *devpath, int mode); extern int smscore_registry_getmode(char *devpath); @@ -495,4 +522,8 @@ extern int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_s extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); +/* smsdvb.c */ +int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival); +void smsdvb_unregister_client(smsdvb_client_t* client); + #endif // __smscoreapi_h__ diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c index e941a0b97..166f218ca 100644 --- a/linux/drivers/media/mdtv/smsdvb.c +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -1,37 +1,10 @@ #include #include -#include "dmxdev.h" -#include "dvbdev.h" -#include "dvb_demux.h" -#include "dvb_frontend.h" - #include "smscoreapi.h" DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); -typedef struct _smsdvb_client -{ - struct list_head entry; - - smscore_device_t *coredev; - smscore_client_t *smsclient; - - struct dvb_adapter adapter; - struct dvb_demux demux; - struct dmxdev dmxdev; - struct dvb_frontend frontend; - - fe_status_t fe_status; - int fe_ber, fe_snr, fe_signal_strength; - - struct completion tune_done, stat_done; - - // todo: save freq/band instead whole struct - struct dvb_frontend_parameters fe_params; - -} smsdvb_client_t; - struct list_head g_smsdvb_clients; kmutex_t g_smsdvb_clientslock; @@ -402,37 +375,3 @@ adapter_error: return rc; } -int smsdvb_module_init(void) -{ - int rc; - - INIT_LIST_HEAD(&g_smsdvb_clients); - kmutex_init(&g_smsdvb_clientslock); - - rc = smscore_register_hotplug(smsdvb_hotplug); - - printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); - - return rc; -} - -void smsdvb_module_exit(void) -{ - smscore_unregister_hotplug(smsdvb_hotplug); - - kmutex_lock(&g_smsdvb_clientslock); - - while (!list_empty(&g_smsdvb_clients)) - smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); - - kmutex_unlock(&g_smsdvb_clientslock); - - printk(KERN_INFO "%s\n", __FUNCTION__); -} - -module_init(smsdvb_module_init); -module_exit(smsdvb_module_exit); - -MODULE_DESCRIPTION("smsdvb dvb-api module"); -MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); -MODULE_LICENSE("GPL"); diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c index 99e600c33..df2b82801 100644 --- a/linux/drivers/media/mdtv/smsusb.c +++ b/linux/drivers/media/mdtv/smsusb.c @@ -405,12 +405,21 @@ static struct usb_driver smsusb_driver = { .id_table = smsusb_id_table, }; +extern struct list_head g_smsdvb_clients; +kmutex_t g_smsdvb_clientslock; + int smsusb_module_init(void) { int rc = usb_register(&smsusb_driver); if (rc) printk(KERN_INFO "usb_register failed. Error number %d\n", rc); + /* Bring up the dvb componenets */ + INIT_LIST_HEAD(&g_smsdvb_clients); + kmutex_init(&g_smsdvb_clientslock); + + rc = smscore_register_hotplug(smsdvb_hotplug); + printk(KERN_INFO "%s\n", __FUNCTION__); return rc; @@ -418,6 +427,17 @@ int smsusb_module_init(void) void smsusb_module_exit(void) { + /* Tear down the DVB components */ + smscore_unregister_hotplug(smsdvb_hotplug); + + kmutex_lock(&g_smsdvb_clientslock); + + while (!list_empty(&g_smsdvb_clients)) + smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); + + kmutex_unlock(&g_smsdvb_clientslock); + + /* Regular USB Cleanup */ usb_deregister(&smsusb_driver); printk(KERN_INFO "%s\n", __FUNCTION__); } -- cgit v1.2.3 From 75598b2f3a5ddf1c210e0d332ffbdac2acb87354 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:01:42 -0400 Subject: sms1xxx: Makefile cleanup From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/Makefile | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile index e3d727d0a..16b9c488c 100644 --- a/linux/drivers/media/mdtv/Makefile +++ b/linux/drivers/media/mdtv/Makefile @@ -1,7 +1,10 @@ -# -# Makefile for the kernel MDTV driver -# +smscore-objs := smscoreapi.o smsusb.o smsdvb.o -smscore-objs := smscoreapi.o +obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smscore.o + +EXTRA_CFLAGS += -Idrivers/media/video +EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core +EXTRA_CFLAGS += -Idrivers/media/dvb/frontends + +EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m) -obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smscore.o smsusb.o smsdvb.o -- cgit v1.2.3 From 9ec225c1fc9e6dc062f30aceb9df8c6cee086bf2 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:04:36 -0400 Subject: sms1xxx: usb cleanup From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smscoreapi.c | 13 +++++++++++++ linux/drivers/media/mdtv/smscoreapi.h | 8 ++++++-- linux/drivers/media/mdtv/smsdvb.c | 27 +++++++++++++++++++++++++++ linux/drivers/media/mdtv/smsusb.c | 30 ++---------------------------- 4 files changed, 48 insertions(+), 30 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c index 1f4171b1e..3e00c8b5a 100644 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -1159,6 +1159,12 @@ int smscore_module_init(void) INIT_LIST_HEAD(&g_smscore_registry); kmutex_init(&g_smscore_registrylock); + /* USB Register */ + rc = smsusb_register(); + + /* DVB Register */ + rc = smsdvb_register(); + printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); return rc; @@ -1166,6 +1172,7 @@ int smscore_module_init(void) void smscore_module_exit(void) { + kmutex_lock(&g_smscore_deviceslock); while (!list_empty(&g_smscore_notifyees)) { @@ -1186,6 +1193,12 @@ void smscore_module_exit(void) } kmutex_unlock(&g_smscore_registrylock); + /* DVB UnRegister */ + smsdvb_unregister(); + + /* Unregister USB */ + smsusb_unregister(); + printk(KERN_INFO "%s\n", __FUNCTION__); } diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h index 166379262..c6b5cad85 100644 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -523,7 +523,11 @@ extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); /* smsdvb.c */ -int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival); -void smsdvb_unregister_client(smsdvb_client_t* client); +int smsdvb_register(void); +void smsdvb_unregister(void); + +/* smsusb.c */ +int smsusb_register(void); +void smsusb_unregister(void); #endif // __smscoreapi_h__ diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c index 166f218ca..7a1e6c33b 100644 --- a/linux/drivers/media/mdtv/smsdvb.c +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -375,3 +375,30 @@ adapter_error: return rc; } +int smsdvb_register(void) +{ + int rc; + + INIT_LIST_HEAD(&g_smsdvb_clients); + kmutex_init(&g_smsdvb_clientslock); + + rc = smscore_register_hotplug(smsdvb_hotplug); + + printk(KERN_INFO "%s\n", __FUNCTION__); + + return rc; +} + +void smsdvb_unregister(void) +{ + smscore_unregister_hotplug(smsdvb_hotplug); + + kmutex_lock(&g_smsdvb_clientslock); + + while (!list_empty(&g_smsdvb_clients)) + smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); + + kmutex_unlock(&g_smsdvb_clientslock); + +} + diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c index df2b82801..0d94cc45f 100644 --- a/linux/drivers/media/mdtv/smsusb.c +++ b/linux/drivers/media/mdtv/smsusb.c @@ -1,6 +1,5 @@ #include #include -#include #include #include @@ -405,46 +404,21 @@ static struct usb_driver smsusb_driver = { .id_table = smsusb_id_table, }; -extern struct list_head g_smsdvb_clients; -kmutex_t g_smsdvb_clientslock; - -int smsusb_module_init(void) +int smsusb_register(void) { int rc = usb_register(&smsusb_driver); if (rc) printk(KERN_INFO "usb_register failed. Error number %d\n", rc); - /* Bring up the dvb componenets */ - INIT_LIST_HEAD(&g_smsdvb_clients); - kmutex_init(&g_smsdvb_clientslock); - - rc = smscore_register_hotplug(smsdvb_hotplug); - printk(KERN_INFO "%s\n", __FUNCTION__); return rc; } -void smsusb_module_exit(void) +void smsusb_unregister(void) { - /* Tear down the DVB components */ - smscore_unregister_hotplug(smsdvb_hotplug); - - kmutex_lock(&g_smsdvb_clientslock); - - while (!list_empty(&g_smsdvb_clients)) - smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); - - kmutex_unlock(&g_smsdvb_clientslock); - /* Regular USB Cleanup */ usb_deregister(&smsusb_driver); printk(KERN_INFO "%s\n", __FUNCTION__); } -module_init(smsusb_module_init); -module_exit(smsusb_module_exit); - -MODULE_DESCRIPTION("smsusb"); -MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); -MODULE_LICENSE("GPL"); -- cgit v1.2.3 From 05b97eeab57500308503f9d7f1c1a106a14a3fe9 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:05:26 -0400 Subject: sms1xxx: copyrights From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smscoreapi.c | 22 ++++++++++++++++++++++ linux/drivers/media/mdtv/smscoreapi.h | 21 +++++++++++++++++++++ linux/drivers/media/mdtv/smsdvb.c | 21 +++++++++++++++++++++ linux/drivers/media/mdtv/smsusb.c | 21 +++++++++++++++++++++ 4 files changed, 85 insertions(+) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c index 3e00c8b5a..30e800624 100644 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -1,3 +1,25 @@ + +/* + * Driver for the Siano SMS10xx USB dongle + * + * Copyright (c) 2008 + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + /*! \file smscoreapi.c diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h index c6b5cad85..acc34c5ca 100644 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -1,3 +1,24 @@ +/* + * Driver for the Siano SMS10xx USB dongle + * + * Copyright (c) 2008 + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + #ifndef __smscoreapi_h__ #define __smscoreapi_h__ diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c index 7a1e6c33b..f56658c55 100644 --- a/linux/drivers/media/mdtv/smsdvb.c +++ b/linux/drivers/media/mdtv/smsdvb.c @@ -1,3 +1,24 @@ +/* + * Driver for the Siano SMS10xx USB dongle + * + * Copyright (c) 2008 + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + #include #include diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c index 0d94cc45f..d922e006c 100644 --- a/linux/drivers/media/mdtv/smsusb.c +++ b/linux/drivers/media/mdtv/smsusb.c @@ -1,3 +1,24 @@ +/* + * Driver for the Siano SMS10xx USB dongle + * + * Copyright (c) 2008 + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + #include #include #include -- cgit v1.2.3 From dd8e248756061b7f7500ad016e8e8873d9a3098a Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:06:41 -0400 Subject: sms1xxx: header include cleanups and unexport symbols From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smscoreapi.c | 18 ------------------ linux/drivers/media/mdtv/smscoreapi.h | 18 +++++------------- 2 files changed, 5 insertions(+), 31 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c index 30e800624..9553d08ff 100644 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ b/linux/drivers/media/mdtv/smscoreapi.c @@ -1231,21 +1231,3 @@ MODULE_DESCRIPTION("smscore"); MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); MODULE_LICENSE("GPL"); -EXPORT_SYMBOL(smscore_registry_setmode); -EXPORT_SYMBOL(smscore_registry_getmode); -EXPORT_SYMBOL(smscore_register_hotplug); -EXPORT_SYMBOL(smscore_unregister_hotplug); -EXPORT_SYMBOL(smscore_register_device); -EXPORT_SYMBOL(smscore_unregister_device); -EXPORT_SYMBOL(smscore_start_device); -EXPORT_SYMBOL(smscore_load_firmware); -EXPORT_SYMBOL(smscore_set_device_mode); -EXPORT_SYMBOL(smscore_get_device_mode); -EXPORT_SYMBOL(smscore_register_client); -EXPORT_SYMBOL(smscore_unregister_client); -EXPORT_SYMBOL(smsclient_sendrequest); -EXPORT_SYMBOL(smscore_onresponse); -EXPORT_SYMBOL(smscore_get_common_buffer_size); -EXPORT_SYMBOL(smscore_map_common_buffer); -EXPORT_SYMBOL(smscore_getbuffer); -EXPORT_SYMBOL(smscore_putbuffer); diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h index acc34c5ca..9b50a9cff 100644 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ b/linux/drivers/media/mdtv/smscoreapi.h @@ -22,13 +22,6 @@ #ifndef __smscoreapi_h__ #define __smscoreapi_h__ -#include "dmxdev.h" -#include "dvbdev.h" -#include "dvb_demux.h" -#include "dvb_frontend.h" - -/* From sysksyms.h */ - #include #include #include @@ -36,6 +29,11 @@ #include #include +#include "dmxdev.h" +#include "dvbdev.h" +#include "dvb_demux.h" +#include "dvb_frontend.h" + #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) #include @@ -61,8 +59,6 @@ void *kzalloc(size_t size, int flags); #endif #endif // LINUX_VERSION -/* End sysksyms.h */ - #ifndef min #define min(a,b) (((a) < (b)) ? (a) : (b)) #endif @@ -133,8 +129,6 @@ typedef struct _smsclient_params void *context; } smsclient_params_t; -/* Begin types.h */ - // GPIO definitions for antenna frequency domain control (SMS8021) #define SMS_ANTENNA_GPIO_0 1 #define SMS_ANTENNA_GPIO_1 0 @@ -492,8 +486,6 @@ typedef struct SMSHOSTLIB_I2C_RES_S UINT8 Data[1]; } SMSHOSTLIB_I2C_RES_ST; -/* End types.h */ - typedef struct _smsdvb_client { struct list_head entry; -- cgit v1.2.3 From 09bb1a3f4b7108e4ccb5e23cf44a95ec055a4858 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:07:39 -0400 Subject: sms1xxx: usbvid table From: Steven Toth Signed-off-by: Steven Toth Signed-off-by: Michael Krufky --- linux/drivers/media/mdtv/smsusb.c | 23 +++++++++-------------- 1 file changed, 9 insertions(+), 14 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c index d922e006c..fd7e3eb55 100644 --- a/linux/drivers/media/mdtv/smsusb.c +++ b/linux/drivers/media/mdtv/smsusb.c @@ -26,11 +26,6 @@ #include "smscoreapi.h" -#define USB_VID_SIANO 0x187f -#define USB_PID_0010 0x0010 -#define USB_PID_0100 0x0100 -#define USB_PID_0200 0x0200 - #define USB1_BUFFER_SIZE 0x1000 #define USB2_BUFFER_SIZE 0x4000 @@ -58,14 +53,6 @@ typedef struct _smsusb_device int buffer_size; } *psmsusb_device_t; -static struct usb_device_id smsusb_id_table [] = { - { USB_DEVICE(USB_VID_SIANO, USB_PID_0010) }, - { USB_DEVICE(USB_VID_SIANO, USB_PID_0100) }, - { USB_DEVICE(USB_VID_SIANO, USB_PID_0200) }, - { } /* Terminating entry */ -}; -MODULE_DEVICE_TABLE (usb, smsusb_id_table); - int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb); #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) @@ -319,7 +306,7 @@ int smsusb_init_device(struct usb_interface *intf) switch (dev->udev->descriptor.idProduct) { - case USB_PID_0100: + case 0x100: dev->buffer_size = USB1_BUFFER_SIZE; params.setmode_handler = smsusb1_setmode; @@ -418,6 +405,14 @@ void smsusb_disconnect(struct usb_interface *intf) smsusb_term_device(intf); } +static struct usb_device_id smsusb_id_table [] = { + { USB_DEVICE(0x187F, 0x0010) }, + { USB_DEVICE(0x187F, 0x0100) }, + { USB_DEVICE(0x187F, 0x0200) }, + { } /* Terminating entry */ +}; +MODULE_DEVICE_TABLE (usb, smsusb_id_table); + static struct usb_driver smsusb_driver = { .name = "smsusb", .probe = smsusb_probe, -- cgit v1.2.3 From 0f3c06c4426ece47776ea890d635a3b0dad377c8 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:29:20 -0400 Subject: sms1xxx: move driver from media/mdtv/ to media/dvb/siano/ From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/Kconfig | 1 + linux/drivers/media/dvb/Makefile | 2 +- linux/drivers/media/dvb/siano/Kconfig | 16 + linux/drivers/media/dvb/siano/Makefile | 8 + linux/drivers/media/dvb/siano/smscoreapi.c | 1213 +++++++++++++++++++++++++++ linux/drivers/media/dvb/siano/smscoreapi.h | 546 ++++++++++++ linux/drivers/media/dvb/siano/smsdvb.c | 425 ++++++++++ linux/drivers/media/dvb/siano/smsusb.c | 440 ++++++++++ linux/drivers/media/mdtv/Kconfig | 16 - linux/drivers/media/mdtv/Makefile | 10 - linux/drivers/media/mdtv/smscoreapi.c | 1233 ---------------------------- linux/drivers/media/mdtv/smscoreapi.h | 546 ------------ linux/drivers/media/mdtv/smsdvb.c | 425 ---------- linux/drivers/media/mdtv/smsusb.c | 440 ---------- 14 files changed, 2650 insertions(+), 2671 deletions(-) create mode 100644 linux/drivers/media/dvb/siano/Kconfig create mode 100644 linux/drivers/media/dvb/siano/Makefile create mode 100644 linux/drivers/media/dvb/siano/smscoreapi.c create mode 100644 linux/drivers/media/dvb/siano/smscoreapi.h create mode 100644 linux/drivers/media/dvb/siano/smsdvb.c create mode 100644 linux/drivers/media/dvb/siano/smsusb.c delete mode 100644 linux/drivers/media/mdtv/Kconfig delete mode 100644 linux/drivers/media/mdtv/Makefile delete mode 100644 linux/drivers/media/mdtv/smscoreapi.c delete mode 100644 linux/drivers/media/mdtv/smscoreapi.h delete mode 100644 linux/drivers/media/mdtv/smsdvb.c delete mode 100644 linux/drivers/media/mdtv/smsusb.c (limited to 'linux') diff --git a/linux/drivers/media/dvb/Kconfig b/linux/drivers/media/dvb/Kconfig index 7b21b49f1..8bc1445bd 100644 --- a/linux/drivers/media/dvb/Kconfig +++ b/linux/drivers/media/dvb/Kconfig @@ -21,6 +21,7 @@ source "drivers/media/dvb/dvb-usb/Kconfig" source "drivers/media/dvb/ttusb-budget/Kconfig" source "drivers/media/dvb/ttusb-dec/Kconfig" source "drivers/media/dvb/cinergyT2/Kconfig" +source "drivers/media/dvb/siano/Kconfig" comment "Supported FlexCopII (B2C2) Adapters" depends on DVB_CORE && (PCI || USB) && I2C diff --git a/linux/drivers/media/dvb/Makefile b/linux/drivers/media/dvb/Makefile index a7ad0841e..d6ba4d195 100644 --- a/linux/drivers/media/dvb/Makefile +++ b/linux/drivers/media/dvb/Makefile @@ -2,4 +2,4 @@ # Makefile for the kernel multimedia device drivers. # -obj-y := dvb-core/ frontends/ ttpci/ ttusb-dec/ ttusb-budget/ b2c2/ bt8xx/ cinergyT2/ dvb-usb/ pluto2/ +obj-y := dvb-core/ frontends/ ttpci/ ttusb-dec/ ttusb-budget/ b2c2/ bt8xx/ cinergyT2/ dvb-usb/ pluto2/ siano/ diff --git a/linux/drivers/media/dvb/siano/Kconfig b/linux/drivers/media/dvb/siano/Kconfig new file mode 100644 index 000000000..878d48c1c --- /dev/null +++ b/linux/drivers/media/dvb/siano/Kconfig @@ -0,0 +1,16 @@ +# +# Siano Mobile Silicon Digital TV device configuration +# + +config DVB_SIANO_SMS1XXX + tristate "Siano SMS1xxx USB dongle support" + depends on DVB_CORE && USB + ---help--- + Choose Y here if you have USB dongle with SMS1xxx chipset. + + Further documentation on this driver can be found on the WWW at + . + + To compile this driver as a module, choose M here: the + module will be called sms1xxx. + diff --git a/linux/drivers/media/dvb/siano/Makefile b/linux/drivers/media/dvb/siano/Makefile new file mode 100644 index 000000000..e549c4e2b --- /dev/null +++ b/linux/drivers/media/dvb/siano/Makefile @@ -0,0 +1,8 @@ +sms1xxx-objs := smscoreapi.o smsusb.o smsdvb.o + +obj-$(CONFIG_DVB_SIANO_SMS1XXX) += sms1xxx.o + +EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core + +EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m) + diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c new file mode 100644 index 000000000..b3f2c7866 --- /dev/null +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -0,0 +1,1213 @@ +/* + * Siano core API module + * + * This file contains implementation for the interface to sms core component + * + * author: Anatoly Greenblat + * + * Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation; + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "smscoreapi.h" + +typedef struct _smscore_device_notifyee +{ + struct list_head entry; + hotplug_t hotplug; +} smscore_device_notifyee_t; + +typedef struct _smscore_client +{ + struct list_head entry; + smscore_device_t *coredev; + + void *context; + + int data_type; + + onresponse_t onresponse_handler; + onremove_t onremove_handler; +} *psmscore_client_t; + +typedef struct _smscore_subclient +{ + struct list_head entry; + smscore_client_t *client; + + int id; +} smscore_subclient_t; + +typedef struct _smscore_device +{ + struct list_head entry; + + struct list_head clients; + struct list_head subclients; + spinlock_t clientslock; + + struct list_head buffers; + spinlock_t bufferslock; + int num_buffers; + + void *common_buffer; + int common_buffer_size; + dma_addr_t common_buffer_phys; + + void *context; + struct device *device; + + char devpath[32]; + unsigned long device_flags; + + setmode_t setmode_handler; + detectmode_t detectmode_handler; + sendrequest_t sendrequest_handler; + preload_t preload_handler; + postload_t postload_handler; + + int mode, modes_supported; + + struct completion version_ex_done, data_download_done, trigger_done; + struct completion init_device_done, reload_start_done, resume_done; +} *psmscore_device_t; + +typedef struct _smscore_registry_entry +{ + struct list_head entry; + char devpath[32]; + int mode; +} smscore_registry_entry_t; + +struct list_head g_smscore_notifyees; +struct list_head g_smscore_devices; +kmutex_t g_smscore_deviceslock; + +struct list_head g_smscore_registry; +kmutex_t g_smscore_registrylock; + +static int default_mode = 1; +module_param(default_mode, int, 0644); +MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); + +int smscore_registry_getmode(char* devpath) +{ + smscore_registry_entry_t *entry; + struct list_head *next; + + kmutex_lock(&g_smscore_registrylock); + + for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) + { + entry = (smscore_registry_entry_t *) next; + + if (!strcmp(entry->devpath, devpath)) + { + kmutex_unlock(&g_smscore_registrylock); + return entry->mode; + } + } + + entry = (smscore_registry_entry_t *) kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); + if (entry) + { + entry->mode = default_mode; + strcpy(entry->devpath, devpath); + + list_add(&entry->entry, &g_smscore_registry); + } + + kmutex_unlock(&g_smscore_registrylock); + + return default_mode; +} + +void smscore_registry_setmode(char* devpath, int mode) +{ + smscore_registry_entry_t *entry; + struct list_head *next; + + kmutex_lock(&g_smscore_registrylock); + + for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) + { + entry = (smscore_registry_entry_t *) next; + + if (!strcmp(entry->devpath, devpath)) + { + entry->mode = mode; + break; + } + } + + kmutex_unlock(&g_smscore_registrylock); +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) +void *kzalloc(size_t size, int flags) +{ + void *ret = kmalloc(size, flags); + if (ret) + memset(ret, 0, size); + return ret; +} + +static inline unsigned long kvirt_to_pa(unsigned long adr) +{ + unsigned long kva, ret; + + kva = (unsigned long) page_address(virt_to_page((void *)adr)); + kva |= adr & (PAGE_SIZE-1); /* restore the offset */ + ret = __pa(kva); + return ret; +} + +unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout) +{ + might_sleep(); + + spin_lock_irq(&x->wait.lock); + if (!x->done) { + DECLARE_WAITQUEUE(wait, current); + + wait.flags |= WQ_FLAG_EXCLUSIVE; + __add_wait_queue_tail(&x->wait, &wait); + do { + __set_current_state(TASK_UNINTERRUPTIBLE); + spin_unlock_irq(&x->wait.lock); + timeout = schedule_timeout(timeout); + spin_lock_irq(&x->wait.lock); + if (!timeout) { + __remove_wait_queue(&x->wait, &wait); + goto out; + } + } while (!x->done); + __remove_wait_queue(&x->wait, &wait); + } + x->done--; +out: + spin_unlock_irq(&x->wait.lock); + return timeout; +} +#endif + +void list_add_locked(struct list_head *new, struct list_head *head, spinlock_t* lock) +{ + unsigned long flags; + + spin_lock_irqsave(lock, flags); + + list_add(new, head); + + spin_unlock_irqrestore(lock, flags); +} + +/** + * register a client callback that called when device plugged in/unplugged + * NOTE: if devices exist callback is called immediately for each device + * + * @param hotplug callback + * + * @return 0 on success, <0 on error. + */ +int smscore_register_hotplug(hotplug_t hotplug) +{ + smscore_device_notifyee_t *notifyee; + struct list_head *next, *first; + int rc = 0; + + kmutex_lock(&g_smscore_deviceslock); + + notifyee = kmalloc(sizeof(smscore_device_notifyee_t), GFP_KERNEL); + if (notifyee) + { + // now notify callback about existing devices + first = &g_smscore_devices; + for (next = first->next; next != first && !rc; next = next->next) + { + smscore_device_t *coredev = (smscore_device_t *) next; + rc = hotplug(coredev, coredev->device, 1); + } + + if (rc >= 0) + { + notifyee->hotplug = hotplug; + list_add(¬ifyee->entry, &g_smscore_notifyees); + } + else + kfree(notifyee); + } + else + rc = -ENOMEM; + + kmutex_unlock(&g_smscore_deviceslock); + + return rc; +} + +/** + * unregister a client callback that called when device plugged in/unplugged + * + * @param hotplug callback + * + */ +void smscore_unregister_hotplug(hotplug_t hotplug) +{ + struct list_head *next, *first; + + kmutex_lock(&g_smscore_deviceslock); + + first = &g_smscore_notifyees; + + for (next = first->next; next != first;) + { + smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) next; + next = next->next; + + if (notifyee->hotplug == hotplug) + { + list_del(¬ifyee->entry); + kfree(notifyee); + } + } + + kmutex_unlock(&g_smscore_deviceslock); +} + +void smscore_notify_clients(smscore_device_t *coredev) +{ + smscore_client_t* client; + + // the client must call smscore_unregister_client from remove handler + while (!list_empty(&coredev->clients)) + { + client = (smscore_client_t *) coredev->clients.next; + client->onremove_handler(client->context); + } +} + +int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, int arrival) +{ + struct list_head *next, *first; + int rc = 0; + + // note: must be called under g_deviceslock + + first = &g_smscore_notifyees; + + for (next = first->next; next != first; next = next->next) + { + rc = ((smscore_device_notifyee_t *) next)->hotplug(coredev, device, arrival); + if (rc < 0) + break; + } + + return rc; +} + +smscore_buffer_t *smscore_createbuffer(u8* buffer, void* common_buffer, dma_addr_t common_buffer_phys) +{ + smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); + if (!cb) + { + printk(KERN_INFO "%s kmalloc(...) failed\n", __FUNCTION__); + return NULL; + } + + cb->p = buffer; + cb->offset_in_common = buffer - (u8*) common_buffer; + cb->phys = common_buffer_phys + cb->offset_in_common; + + return cb; +} + +/** + * creates coredev object for a device, prepares buffers, creates buffer mappings, notifies + * registered hotplugs about new device. + * + * @param params device pointer to struct with device specific parameters and handlers + * @param coredev pointer to a value that receives created coredev object + * + * @return 0 on success, <0 on error. + */ +int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev) +{ + smscore_device_t* dev; + u8 *buffer; + + dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); + if (!dev) + { + printk(KERN_INFO "%s kzalloc(...) failed\n", __FUNCTION__); + return -ENOMEM; + } + + // init list entry so it could be safe in smscore_unregister_device + INIT_LIST_HEAD(&dev->entry); + + // init queues + INIT_LIST_HEAD(&dev->clients); + INIT_LIST_HEAD(&dev->subclients); + INIT_LIST_HEAD(&dev->buffers); + + // init locks + spin_lock_init(&dev->clientslock); + spin_lock_init(&dev->bufferslock); + + // init completion events + init_completion(&dev->version_ex_done); + init_completion(&dev->data_download_done); + init_completion(&dev->trigger_done); + init_completion(&dev->init_device_done); + init_completion(&dev->reload_start_done); + init_completion(&dev->resume_done); + + // alloc common buffer + dev->common_buffer_size = params->buffer_size * params->num_buffers; + dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size, &dev->common_buffer_phys, GFP_KERNEL | GFP_DMA); + if (!dev->common_buffer) + { + smscore_unregister_device(dev); + return -ENOMEM; + } + + // prepare dma buffers + for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; dev->num_buffers ++, buffer += params->buffer_size) + { + smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); + if (!cb) + { + smscore_unregister_device(dev); + return -ENOMEM; + } + + smscore_putbuffer(dev, cb); + } + + printk(KERN_INFO "%s allocated %d buffers\n", __FUNCTION__, dev->num_buffers); + + dev->mode = DEVICE_MODE_NONE; + dev->context = params->context; + dev->device = params->device; + dev->setmode_handler = params->setmode_handler; + dev->detectmode_handler = params->detectmode_handler; + dev->sendrequest_handler = params->sendrequest_handler; + dev->preload_handler = params->preload_handler; + dev->postload_handler = params->postload_handler; + + dev->device_flags = params->flags; + strcpy(dev->devpath, params->devpath); + + // add device to devices list + kmutex_lock(&g_smscore_deviceslock); + list_add(&dev->entry, &g_smscore_devices); + kmutex_unlock(&g_smscore_deviceslock); + + *coredev = dev; + + printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); + + return 0; +} + +/** + * sets initial device mode and notifies client hotplugs that device is ready + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return 0 on success, <0 on error. + */ +int smscore_start_device(smscore_device_t *coredev) +{ + int rc = smscore_set_device_mode(coredev, smscore_registry_getmode(coredev->devpath)); + if (rc < 0) + return rc; + + kmutex_lock(&g_smscore_deviceslock); + + rc = smscore_notify_callbacks(coredev, coredev->device, 1); + + printk(KERN_INFO "%s device %p started, rc %d\n", __FUNCTION__, coredev, rc); + + kmutex_unlock(&g_smscore_deviceslock); + + return rc; +} + +int smscore_sendrequest_and_wait(smscore_device_t *coredev, void* buffer, size_t size, struct completion *completion) +{ + int rc = coredev->sendrequest_handler(coredev->context, buffer, size); + if (rc < 0) + return rc; + + return wait_for_completion_timeout(completion, msecs_to_jiffies(1000)) ? 0 : -ETIME; +} + +int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_t size) +{ + SmsFirmware_ST* firmware = (SmsFirmware_ST*) buffer; + SmsMsgHdr_ST *msg; + UINT32 mem_address = firmware->StartAddress; + u8* payload = firmware->Payload; + int rc = 0; + + if (coredev->preload_handler) + { + rc = coredev->preload_handler(coredev->context); + if (rc < 0) + return rc; + } + + // PAGE_SIZE buffer shall be enough and dma aligned + msg = (SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); + if (!msg) + return -ENOMEM; + + if (coredev->mode != DEVICE_MODE_NONE) + { + SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(SmsMsgHdr_ST)); + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); + mem_address = *(UINT32*) &payload[20]; + } + + while (size && rc >= 0) + { + SmsDataDownload_ST *DataMsg = (SmsDataDownload_ST *) msg; + int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); + + SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, (UINT16)(sizeof(SmsMsgHdr_ST) + sizeof(UINT32) + payload_size)); + + DataMsg->MemAddr = mem_address; + memcpy(DataMsg->Payload, payload, payload_size); + + if (coredev->device_flags & SMS_ROM_NO_RESPONSE && coredev->mode == DEVICE_MODE_NONE) + rc = coredev->sendrequest_handler(coredev->context, DataMsg, DataMsg->xMsgHeader.msgLength); + else + rc = smscore_sendrequest_and_wait(coredev, DataMsg, DataMsg->xMsgHeader.msgLength, &coredev->data_download_done); + + payload += payload_size; + size -= payload_size; + mem_address += payload_size; + } + + if (rc >= 0) + { + if (coredev->mode == DEVICE_MODE_NONE) + { + SmsMsgData_ST* TriggerMsg = (SmsMsgData_ST*) msg; + + SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, sizeof(SmsMsgHdr_ST) + sizeof(UINT32) * 5); + + TriggerMsg->msgData[0] = firmware->StartAddress; // Entry point + TriggerMsg->msgData[1] = 5; // Priority + TriggerMsg->msgData[2] = 0x200; // Stack size + TriggerMsg->msgData[3] = 0; // Parameter + TriggerMsg->msgData[4] = 4; // Task ID + + if (coredev->device_flags & SMS_ROM_NO_RESPONSE) + { + rc = coredev->sendrequest_handler(coredev->context, TriggerMsg, TriggerMsg->xMsgHeader.msgLength); + msleep(100); + } + else + rc = smscore_sendrequest_and_wait(coredev, TriggerMsg, TriggerMsg->xMsgHeader.msgLength, &coredev->trigger_done); + } + else + { + SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, sizeof(SmsMsgHdr_ST)); + + rc = coredev->sendrequest_handler(coredev->context, msg, msg->msgLength); + } + } + + printk("%s %d \n", __func__, rc); + + kfree(msg); + + return (rc >= 0 && coredev->postload_handler) ? + coredev->postload_handler(coredev->context) : + rc; +} + +/** + * loads specified firmware into a buffer and calls device loadfirmware_handler + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param filename null-terminated string specifies firmware file name + * @param loadfirmware_handler device handler that loads firmware + * + * @return 0 on success, <0 on error. + */ +int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler) +{ + int rc = -ENOENT; + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) + const struct firmware *fw; + u8* fw_buffer; + + if (loadfirmware_handler == NULL && !(coredev->device_flags & SMS_DEVICE_FAMILY2)) + return -EINVAL; + + rc = request_firmware(&fw, filename, coredev->device); + if (rc < 0) + { + printk(KERN_INFO "%s failed to open \"%s\"\n", __FUNCTION__, filename); + return rc; + } + + fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); + if (fw_buffer) + { + memcpy(fw_buffer, fw->data, fw->size); + + rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ? + smscore_load_firmware_family2(coredev, fw_buffer, fw->size) : + loadfirmware_handler(coredev->context, fw_buffer, fw->size); + + kfree(fw_buffer); + } + else + { + printk(KERN_INFO "%s failed to allocate firmware buffer\n", __FUNCTION__); + rc = -ENOMEM; + } + + release_firmware(fw); +#endif + + return rc; +} + +/** + * notifies all clients registered with the device, notifies hotplugs, frees all buffers and coredev object + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return 0 on success, <0 on error. + */ +void smscore_unregister_device(smscore_device_t *coredev) +{ + smscore_buffer_t *cb; + int num_buffers = 0; + + kmutex_lock(&g_smscore_deviceslock); + + smscore_notify_clients(coredev); + smscore_notify_callbacks(coredev, NULL, 0); + + // at this point all buffers should be back + // onresponse must no longer be called + + while (1) + { + while ((cb = smscore_getbuffer(coredev))) + { + kfree(cb); + num_buffers ++; + } + + if (num_buffers == coredev->num_buffers) + break; + + printk(KERN_INFO "%s waiting for %d buffer(s)\n", __FUNCTION__, coredev->num_buffers - num_buffers); + msleep(100); + } + + printk(KERN_INFO "%s freed %d buffers\n", __FUNCTION__, num_buffers); + + if (coredev->common_buffer) + dma_free_coherent(NULL, coredev->common_buffer_size, coredev->common_buffer, coredev->common_buffer_phys); + + list_del(&coredev->entry); + kfree(coredev); + + kmutex_unlock(&g_smscore_deviceslock); + + printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, coredev); +} + +int smscore_detect_mode(smscore_device_t *coredev) +{ + void *buffer = kmalloc(sizeof(SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); + SmsMsgHdr_ST *msg = (SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer); + int rc; + + if (!buffer) + return -ENOMEM; + + SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ, sizeof(SmsMsgHdr_ST)); + + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); + if (rc == -ETIME) + { + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __FUNCTION__); + + if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) + { + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); + if (rc < 0) + { + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __FUNCTION__, rc); + } + } + else + rc = -ETIME; + } + + kfree(buffer); + + return rc; +} + +char *smscore_fw_lkup[] = +{ + "dvb_nova_12mhz.inp", + "dvb_nova_12mhz.inp", + "tdmb_nova.inp", + "none", + "dvb_nova_12mhz.inp", + "isdbt_nova_12mhz.inp", + "isdbt_nova_12mhz.inp", + "cmmb_nova_12mhz.inp", + "none", +}; + +/** + * calls device handler to change mode of operation + * NOTE: stellar/usb may disconnect when changing mode + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param mode requested mode of operation + * + * @return 0 on success, <0 on error. + */ +int smscore_set_device_mode(smscore_device_t *coredev, int mode) +{ + void *buffer; + int rc = 0; + + if (coredev->device_flags & SMS_DEVICE_FAMILY2) + { + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) + { + printk(KERN_INFO "%s invalid mode specified %d\n", __FUNCTION__, mode); + return -EINVAL; + } + + if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) + { + rc = smscore_detect_mode(coredev); + if (rc < 0) + return rc; + } + + if (coredev->mode == mode) + { + printk(KERN_INFO "%s device mode %d already set\n", __FUNCTION__, mode); + return 0; + } + + if (!(coredev->modes_supported & (1 << mode))) + { + rc = smscore_load_firmware(coredev, smscore_fw_lkup[mode], NULL); + if (rc < 0) + return rc; + } + else + { + printk(KERN_INFO "%s mode %d supported by running firmware\n", __FUNCTION__, mode); + } + + buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); + if (buffer) + { + SmsMsgData_ST *msg = (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); + + SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, sizeof(SmsMsgData_ST)); + msg->msgData[0] = mode; + + rc = smscore_sendrequest_and_wait(coredev, msg, msg->xMsgHeader.msgLength, &coredev->init_device_done); + + kfree(buffer); + } + else + rc = -ENOMEM; + } + else + { + if (coredev->detectmode_handler) + coredev->detectmode_handler(coredev->context, &coredev->mode); + + if (coredev->mode != mode && coredev->setmode_handler) + rc = coredev->setmode_handler(coredev->context, mode); + } + + smscore_registry_setmode(coredev->devpath, mode); + + if (rc >= 0) + { + coredev->mode = mode; + coredev->device_flags &= ~SMS_DEVICE_NOT_READY; + } + + return rc; +} + +/** + * calls device handler to get current mode of operation + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return current mode + */ +int smscore_get_device_mode(smscore_device_t *coredev) +{ + return coredev->mode; +} + +smscore_client_t* smscore_getclient_by_type(smscore_device_t *coredev, int data_type) +{ + smscore_client_t *client = NULL; + struct list_head *next, *first; + unsigned long flags; + + if (!data_type) + return NULL; + + spin_lock_irqsave(&coredev->clientslock, flags); + + first = &coredev->clients; + + for (next = first->next; next != first; next = next->next) + { + if (((smscore_client_t*) next)->data_type == data_type) + { + client = (smscore_client_t*) next; + break; + } + } + + spin_unlock_irqrestore(&coredev->clientslock, flags); + + return client; +} + +smscore_client_t* smscore_getclient_by_id(smscore_device_t *coredev, int id) +{ + smscore_client_t *client = NULL; + struct list_head *next, *first; + unsigned long flags; + + spin_lock_irqsave(&coredev->clientslock, flags); + + first = &coredev->subclients; + + for (next = first->next; next != first; next = next->next) + { + if (((smscore_subclient_t*) next)->id == id) + { + client = ((smscore_subclient_t*) next)->client; + break; + } + } + + spin_unlock_irqrestore(&coredev->clientslock, flags); + + return client; +} + +/** + * find client by response id/type, call clients onresponse handler + * return buffer to pool on error + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param cb pointer to response buffer descriptor + * + */ +void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) +{ + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8*) cb->p + cb->offset); + smscore_client_t * client = smscore_getclient_by_type(coredev, phdr->msgType); + int rc = -EBUSY; + +#if 1 + static unsigned long last_sample_time = 0; + static int data_total = 0; + unsigned long time_now = jiffies_to_msecs(jiffies); + + if (!last_sample_time) + last_sample_time = time_now; + + if (time_now - last_sample_time > 10000) + { + printk("\n%s data rate %d bytes/secs\n", __func__, (int)((data_total * 1000) / (time_now - last_sample_time))); + + last_sample_time = time_now; + data_total = 0; + } + + data_total += cb->size; +#endif + + if (!client) + client = smscore_getclient_by_id(coredev, phdr->msgDstId); + + if (client) + rc = client->onresponse_handler(client->context, cb); + + if (rc < 0) + { + switch (phdr->msgType) + { + case MSG_SMS_GET_VERSION_EX_RES: + { + SmsVersionRes_ST *ver = (SmsVersionRes_ST*) phdr; + printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d prots 0x%x ver %d.%d\n", __FUNCTION__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); + + coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; + coredev->modes_supported = ver->SupportedProtocols; + + complete(&coredev->version_ex_done); + break; + } + + case MSG_SMS_INIT_DEVICE_RES: + printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __FUNCTION__); + complete(&coredev->init_device_done); + break; + + case MSG_SW_RELOAD_START_RES: + printk("%s: MSG_SW_RELOAD_START_RES\n", __FUNCTION__); + complete(&coredev->reload_start_done); + break; + + case MSG_SMS_DATA_DOWNLOAD_RES: + complete(&coredev->data_download_done); + break; + + case MSG_SW_RELOAD_EXEC_RES: + printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __FUNCTION__); + break; + + case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: + printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __FUNCTION__); + complete(&coredev->trigger_done); + break; + + case MSG_SMS_SLEEP_RESUME_COMP_IND: + complete(&coredev->resume_done); + break; + + default: + printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __FUNCTION__, client, rc, phdr->msgType, phdr->msgDstId); + } + + smscore_putbuffer(coredev, cb); + } +} + +/** + * return pointer to next free buffer descriptor from core pool + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * + * @return pointer to descriptor on success, NULL on error. + */ +smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) +{ + smscore_buffer_t *cb = NULL; + unsigned long flags; + + spin_lock_irqsave(&coredev->bufferslock, flags); + + if (!list_empty(&coredev->buffers)) + { + cb = (smscore_buffer_t *) coredev->buffers.next; + list_del(&cb->entry); + } + + spin_unlock_irqrestore(&coredev->bufferslock, flags); + + return cb; +} + +/** + * return buffer descriptor to a pool + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param cb pointer buffer descriptor + * + */ +void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb) +{ + list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); +} + +int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int id) +{ + smscore_client_t *existing_client; + smscore_subclient_t *subclient; + + if (!id) + return 0; + + existing_client = smscore_getclient_by_id(coredev, id); + if (existing_client == client) + return 0; + + if (existing_client) + return -EBUSY; + + subclient = kzalloc(sizeof(smscore_subclient_t), GFP_KERNEL); + if (!subclient) + return -ENOMEM; + + subclient->client = client; + subclient->id = id; + + list_add_locked(&subclient->entry, &coredev->subclients, &coredev->clientslock); + + return 0; +} + +/** + * creates smsclient object, check that id is taken by another client + * + * @param coredev pointer to a coredev object from clients hotplug + * @param initial_id all messages with this id would be sent to this client + * @param data_type all messages of this type would be sent to this client + * @param onresponse_handler client handler that is called to process incoming messages + * @param onremove_handler client handler that is called when device is removed + * @param context client-specific context + * @param client pointer to a value that receives created smsclient object + * + * @return 0 on success, <0 on error. + */ +int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) +{ + smscore_client_t* newclient; + int rc; + + // check that no other channel with same data type exists + if (params->data_type && smscore_getclient_by_type(coredev, params->data_type)) + return -EEXIST; + + newclient = kzalloc(sizeof(smscore_client_t), GFP_KERNEL); + if (!newclient) + return -ENOMEM; + + // check that no other channel with same id exists + rc = smscore_validate_client(coredev, newclient, params->initial_id); + if (rc < 0) + { + kfree(newclient); + return rc; + } + + newclient->coredev = coredev; + newclient->data_type = params->data_type; + newclient->onresponse_handler = params->onresponse_handler; + newclient->onremove_handler = params->onremove_handler; + newclient->context = params->context; + + list_add_locked(&newclient->entry, &coredev->clients, &coredev->clientslock); + + *client = newclient; + + printk(KERN_INFO "%s %p %d %d\n", __FUNCTION__, params->context, params->data_type, params->initial_id); + + return 0; +} + +/** + * frees smsclient object and all subclients associated with it + * + * @param client pointer to smsclient object returned by smscore_register_client + * + */ +void smscore_unregister_client(smscore_client_t *client) +{ + smscore_device_t *coredev = client->coredev; + struct list_head *next, *first; + unsigned long flags; + + spin_lock_irqsave(&coredev->clientslock, flags); + + first = &coredev->subclients; + + for (next = first->next; next != first;) + { + smscore_subclient_t *subclient = (smscore_subclient_t *) next; + next = next->next; + + if (subclient->client == client) + { + list_del(&subclient->entry); + kfree(subclient); + } + } + + printk(KERN_INFO "%s %p %d\n", __FUNCTION__, client->context, client->data_type); + + list_del(&client->entry); + kfree(client); + + spin_unlock_irqrestore(&coredev->clientslock, flags); +} + +/** + * verifies that source id is not taken by another client, + * calls device handler to send requests to the device + * + * @param client pointer to smsclient object returned by smscore_register_client + * @param buffer pointer to a request buffer + * @param size size (in bytes) of request buffer + * + * @return 0 on success, <0 on error. + */ +int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) +{ + smscore_device_t* coredev = client->coredev; + SmsMsgHdr_ST* phdr = (SmsMsgHdr_ST*) buffer; + + // check that no other channel with same id exists + int rc = smscore_validate_client(client->coredev, client, phdr->msgSrcId); + if (rc < 0) + return rc; + + return coredev->sendrequest_handler(coredev->context, buffer, size); +} + +/** + * return the size of large (common) buffer + * + * @param coredev pointer to a coredev object from clients hotplug + * + * @return size (in bytes) of the buffer + */ +int smscore_get_common_buffer_size(smscore_device_t *coredev) +{ + return coredev->common_buffer_size; +} + +/** + * maps common buffer (if supported by platform) + * + * @param coredev pointer to a coredev object from clients hotplug + * @param vma pointer to vma struct from mmap handler + * + * @return 0 on success, <0 on error. + */ +int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma) +{ + unsigned long end = vma->vm_end, start = vma->vm_start, size = PAGE_ALIGN(coredev->common_buffer_size); + + if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) + { + printk(KERN_INFO "%s invalid vm flags\n", __FUNCTION__); + return -EINVAL; + } + + if ((end - start) != size) + { + printk(KERN_INFO "%s invalid size %d expected %d\n", __FUNCTION__, (int)(end - start), (int) size); + return -EINVAL; + } + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) + if (remap_page_range(vma, start, coredev->common_buffer_phys, size, vma->vm_page_prot)) +#else + if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) +#endif + { + printk(KERN_INFO "%s remap_page_range failed\n", __FUNCTION__); + return -EAGAIN; + } + + return 0; +} + +int smscore_module_init(void) +{ + int rc = 0; + + INIT_LIST_HEAD(&g_smscore_notifyees); + INIT_LIST_HEAD(&g_smscore_devices); + kmutex_init(&g_smscore_deviceslock); + + INIT_LIST_HEAD(&g_smscore_registry); + kmutex_init(&g_smscore_registrylock); + + /* USB Register */ + rc = smsusb_register(); + + /* DVB Register */ + rc = smsdvb_register(); + + printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); + + return rc; +} + +void smscore_module_exit(void) +{ + + kmutex_lock(&g_smscore_deviceslock); + while (!list_empty(&g_smscore_notifyees)) + { + smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) g_smscore_notifyees.next; + + list_del(¬ifyee->entry); + kfree(notifyee); + } + kmutex_unlock(&g_smscore_deviceslock); + + kmutex_lock(&g_smscore_registrylock); + while (!list_empty(&g_smscore_registry)) + { + smscore_registry_entry_t *entry = (smscore_registry_entry_t *) g_smscore_registry.next; + + list_del(&entry->entry); + kfree(entry); + } + kmutex_unlock(&g_smscore_registrylock); + + /* DVB UnRegister */ + smsdvb_unregister(); + + /* Unregister USB */ + smsusb_unregister(); + + printk(KERN_INFO "%s\n", __FUNCTION__); +} + +module_init(smscore_module_init); +module_exit(smscore_module_exit); + +MODULE_DESCRIPTION("smscore"); +MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); +MODULE_LICENSE("GPL"); + diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h new file mode 100644 index 000000000..39182ef9d --- /dev/null +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -0,0 +1,546 @@ +/* + * Driver for the Siano SMS1xxx USB dongle + * + * author: Anatoly Greenblat + * + * Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation; + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef __smscoreapi_h__ +#define __smscoreapi_h__ + +#include +#include +#include +#include +#include +#include + +#include "dmxdev.h" +#include "dvbdev.h" +#include "dvb_demux.h" +#include "dvb_frontend.h" + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) +#include + +typedef struct mutex kmutex_t; + +#define kmutex_init(_p_) mutex_init(_p_) +#define kmutex_lock(_p_) mutex_lock(_p_) +#define kmutex_trylock(_p_) mutex_trylock(_p_) +#define kmutex_unlock(_p_) mutex_unlock(_p_) + +#else +#include + +typedef struct semaphore kmutex_t; + +#define kmutex_init(_p_) init_MUTEX(_p_) +#define kmutex_lock(_p_) down(_p_) +#define kmutex_trylock(_p_) (!down_trylock(_p_)) +#define kmutex_unlock(_p_) up(_p_) + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) +void *kzalloc(size_t size, int flags); +#endif +#endif // LINUX_VERSION + +#ifndef min +#define min(a,b) (((a) < (b)) ? (a) : (b)) +#endif + +#define SMS_ALLOC_ALIGNMENT 128 +#define SMS_DMA_ALIGNMENT 16 +#define SMS_ALIGN_ADDRESS(addr) ((((u32)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) + +#define SMS_DEVICE_FAMILY2 1 +#define SMS_ROM_NO_RESPONSE 2 +#define SMS_DEVICE_NOT_READY 0x8000000 + +typedef struct _smscore_device smscore_device_t; +typedef struct _smscore_client smscore_client_t; +typedef struct _smscore_buffer smscore_buffer_t; + +typedef int (*hotplug_t)(smscore_device_t *coredev, struct device *device, int arrival); + +typedef int (*setmode_t)(void *context, int mode); +typedef void (*detectmode_t)(void *context, int *mode); +typedef int (*sendrequest_t)(void *context, void *buffer, size_t size); +typedef int (*loadfirmware_t)(void *context, void *buffer, size_t size); +typedef int (*preload_t)(void *context); +typedef int (*postload_t)(void *context); + +typedef int (*onresponse_t)(void *context, smscore_buffer_t *cb); +typedef void (*onremove_t)(void *context); + +typedef struct _smscore_buffer +{ + // public members, once passed to clients can be changed freely + struct list_head entry; + int size; + int offset; + + // private members, read-only for clients + void *p; + dma_addr_t phys; + unsigned long offset_in_common; +} *psmscore_buffer_t; + +typedef struct _smsdevice_params +{ + struct device *device; + + int buffer_size; + int num_buffers; + + char devpath[32]; + unsigned long flags; + + setmode_t setmode_handler; + detectmode_t detectmode_handler; + sendrequest_t sendrequest_handler; + preload_t preload_handler; + postload_t postload_handler; + + void *context; +} smsdevice_params_t; + +typedef struct _smsclient_params +{ + int initial_id; + int data_type; + onresponse_t onresponse_handler; + onremove_t onremove_handler; + + void *context; +} smsclient_params_t; + +// GPIO definitions for antenna frequency domain control (SMS8021) +#define SMS_ANTENNA_GPIO_0 1 +#define SMS_ANTENNA_GPIO_1 0 + +#define BW_8_MHZ 0 +#define BW_7_MHZ 1 +#define BW_6_MHZ 2 +#define BW_5_MHZ 3 +#define BW_ISDBT_1SEG 4 +#define BW_ISDBT_3SEG 5 + +#define MSG_HDR_FLAG_SPLIT_MSG 4 + +#define MAX_GPIO_PIN_NUMBER 31 + +#define HIF_TASK 11 +#define SMS_HOST_LIB 150 +#define DVBT_BDA_CONTROL_MSG_ID 201 + +#define SMS_MAX_PAYLOAD_SIZE 240 +#define SMS_TUNE_TIMEOUT 500 + +#define MSG_SMS_GPIO_CONFIG_REQ 507 +#define MSG_SMS_GPIO_CONFIG_RES 508 +#define MSG_SMS_GPIO_SET_LEVEL_REQ 509 +#define MSG_SMS_GPIO_SET_LEVEL_RES 510 +#define MSG_SMS_GPIO_GET_LEVEL_REQ 511 +#define MSG_SMS_GPIO_GET_LEVEL_RES 512 +#define MSG_SMS_RF_TUNE_REQ 561 +#define MSG_SMS_RF_TUNE_RES 562 +#define MSG_SMS_INIT_DEVICE_REQ 578 +#define MSG_SMS_INIT_DEVICE_RES 579 +#define MSG_SMS_ADD_PID_FILTER_REQ 601 +#define MSG_SMS_ADD_PID_FILTER_RES 602 +#define MSG_SMS_REMOVE_PID_FILTER_REQ 603 +#define MSG_SMS_REMOVE_PID_FILTER_RES 604 +#define MSG_SMS_DAB_CHANNEL 607 +#define MSG_SMS_GET_PID_FILTER_LIST_REQ 608 +#define MSG_SMS_GET_PID_FILTER_LIST_RES 609 +#define MSG_SMS_GET_STATISTICS_REQ 615 +#define MSG_SMS_GET_STATISTICS_RES 616 +#define MSG_SMS_SET_ANTENNA_CONFIG_REQ 651 +#define MSG_SMS_SET_ANTENNA_CONFIG_RES 652 +#define MSG_SMS_GET_STATISTICS_EX_REQ 653 +#define MSG_SMS_GET_STATISTICS_EX_RES 654 +#define MSG_SMS_SLEEP_RESUME_COMP_IND 655 +#define MSG_SMS_DATA_DOWNLOAD_REQ 660 +#define MSG_SMS_DATA_DOWNLOAD_RES 661 +#define MSG_SMS_SWDOWNLOAD_TRIGGER_REQ 664 +#define MSG_SMS_SWDOWNLOAD_TRIGGER_RES 665 +#define MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ 666 +#define MSG_SMS_SWDOWNLOAD_BACKDOOR_RES 667 +#define MSG_SMS_GET_VERSION_EX_REQ 668 +#define MSG_SMS_GET_VERSION_EX_RES 669 +#define MSG_SMS_SET_CLOCK_OUTPUT_REQ 670 +#define MSG_SMS_I2C_SET_FREQ_REQ 685 +#define MSG_SMS_GENERIC_I2C_REQ 687 +#define MSG_SMS_GENERIC_I2C_RES 688 +#define MSG_SMS_DVBT_BDA_DATA 693 +#define MSG_SW_RELOAD_REQ 697 +#define MSG_SMS_DATA_MSG 699 +#define MSG_SW_RELOAD_START_REQ 702 +#define MSG_SW_RELOAD_START_RES 703 +#define MSG_SW_RELOAD_EXEC_REQ 704 +#define MSG_SW_RELOAD_EXEC_RES 705 +#define MSG_SMS_SPI_INT_LINE_SET_REQ 710 +#define MSG_SMS_ISDBT_TUNE_REQ 776 +#define MSG_SMS_ISDBT_TUNE_RES 777 + +#define SMS_INIT_MSG_EX(ptr, type, src, dst, len) do { \ + (ptr)->msgType = type; (ptr)->msgSrcId = src; (ptr)->msgDstId = dst; \ + (ptr)->msgLength = len; (ptr)->msgFlags = 0; \ +} while (0) +#define SMS_INIT_MSG(ptr, type, len) SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) + +typedef enum +{ + DEVICE_MODE_NONE = -1, + DEVICE_MODE_DVBT = 0, + DEVICE_MODE_DVBH, + DEVICE_MODE_DAB_TDMB, + DEVICE_MODE_DAB_TDMB_DABIP, + DEVICE_MODE_DVBT_BDA, + DEVICE_MODE_ISDBT, + DEVICE_MODE_ISDBT_BDA, + DEVICE_MODE_CMMB, + DEVICE_MODE_RAW_TUNER, + DEVICE_MODE_MAX, +} SMS_DEVICE_MODE; + +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned int UINT32; +typedef int INT32; + +typedef struct SmsMsgHdr_S +{ + UINT16 msgType; + UINT8 msgSrcId; + UINT8 msgDstId; + UINT16 msgLength; // Length is of the entire message, including header + UINT16 msgFlags; +} SmsMsgHdr_ST; + +typedef struct SmsMsgData_S +{ + SmsMsgHdr_ST xMsgHeader; + UINT32 msgData[1]; +} SmsMsgData_ST; + +typedef struct SmsDataDownload_S +{ + SmsMsgHdr_ST xMsgHeader; + UINT32 MemAddr; + UINT8 Payload[SMS_MAX_PAYLOAD_SIZE]; +} SmsDataDownload_ST; + +typedef struct SmsVersionRes_S +{ + SmsMsgHdr_ST xMsgHeader; + + UINT16 ChipModel; // e.g. 0x1102 for SMS-1102 "Nova" + UINT8 Step; // 0 - Step A + UINT8 MetalFix; // 0 - Metal 0 + + UINT8 FirmwareId; // 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E + UINT8 SupportedProtocols; // Bitwise OR combination of supported protocols + + UINT8 VersionMajor; + UINT8 VersionMinor; + UINT8 VersionPatch; + UINT8 VersionFieldPatch; + + UINT8 RomVersionMajor; + UINT8 RomVersionMinor; + UINT8 RomVersionPatch; + UINT8 RomVersionFieldPatch; + + UINT8 TextLabel[34]; +} SmsVersionRes_ST; + +typedef struct SmsFirmware_S +{ + UINT32 CheckSum; + UINT32 Length; + UINT32 StartAddress; + UINT8 Payload[1]; +} SmsFirmware_ST; + +typedef struct SMSHOSTLIB_STATISTICS_S +{ + UINT32 Reserved; //!< Reserved + + /// Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + /// Reception quality + INT32 SNR; //!< dB + UINT32 BER; //!< Post Viterbi BER [1E-5] + UINT32 FIB_CRC; //!< CRC errors percentage, valid only for DAB + UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H + UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in bin/1024 + + /// Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz, valid only for DVB-T/H + UINT32 TransmissionMode; //!< Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos + UINT32 ModemState; //!< from SMS_DvbModemState_ET , valid only for DVB-T/H + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value , valid only for DVB-T/H + UINT32 CodeRate; //!< Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H + UINT32 LPCodeRate; //!< Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H + UINT32 Hierarchy; //!< Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H + UINT32 Constellation; //!< Constellation from SMS_Constellation_ET, valid only for DVB-T/H + + /// Burst parameters, valid only for DVB-H + UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H + UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H + UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H + UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H + UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H + UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H + UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding + UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding + UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding + /// Common params + UINT32 BERErrorCount; //!< Number of errornous SYNC bits. + UINT32 BERBitCount; //!< Total number of SYNC bits. + + /// Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + + /// DAB/T-DMB + UINT32 PreBER; //!< DAB/T-DMB only: Pre Viterbi BER [1E-5] + + /// DVB-H TPS parameters + UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + +} SMSHOSTLIB_STATISTICS_ST; + +typedef struct +{ + UINT32 RequestResult; + + SMSHOSTLIB_STATISTICS_ST Stat; + + // Split the calc of the SNR in DAB + UINT32 Signal; //!< dB + UINT32 Noise; //!< dB + +} SmsMsgStatisticsInfo_ST; + +typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S +{ + // Per-layer information + UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist + UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist + UINT32 BER; //!< Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A + UINT32 BERErrorCount; //!< Post Viterbi Error Bits Count + UINT32 BERBitCount; //!< Post Viterbi Total Bits Count + UINT32 PreBER; //!< Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A + UINT32 TS_PER; //!< Transport stream PER [%], 0xFFFFFFFF indicate N/A + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 TILdepthI; //!< Time interleaver depth I parameter, 255 means layer does not exist + UINT32 NumberOfSegments; //!< Number of segments in layer A, 255 means layer does not exist + UINT32 TMCCErrors; //!< TMCC errors +} SMSHOSTLIB_ISDBT_LAYER_STAT_ST; + +typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S +{ + UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + //!< This fiels MUST always first in any statistics structure + + UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by + //!< the host is smaller than FullSize, the struct will be truncated + + // Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + // Reception quality + INT32 SNR; //!< dB + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in Hz + + // Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz + UINT32 TransmissionMode; //!< ISDB-T transmission mode + UINT32 ModemState; //!< 0 - Acquisition, 1 - Locked + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value + UINT32 SystemType; //!< ISDB-T system type (ISDB-T / ISDB-Tsb) + UINT32 PartialReception; //!< TRUE - partial reception, FALSE otherwise + UINT32 NumOfLayers; //!< Number of ISDB-T layers in the network + + // Per-layer information + // Layers A, B and C + SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; //!< Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST + + // Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + +} SMSHOSTLIB_STATISTICS_ISDBT_ST; + +typedef struct SMSHOSTLIB_STATISTICS_DVB_S +{ + UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + //!< This fiels MUST always first in any statistics structure + + UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by + //!< the host is smaller than FullSize, the struct will be truncated + // Common parameters + UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked + UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked + UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on + + // Reception quality + INT32 SNR; //!< dB + UINT32 BER; //!< Post Viterbi BER [1E-5] + UINT32 BERErrorCount; //!< Number of errornous SYNC bits. + UINT32 BERBitCount; //!< Total number of SYNC bits. + UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A + UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H + INT32 RSSI; //!< dBm + INT32 InBandPwr; //!< In band power in dBM + INT32 CarrierOffset; //!< Carrier Offset in bin/1024 + + // Transmission parameters + UINT32 Frequency; //!< Frequency in Hz + UINT32 Bandwidth; //!< Bandwidth in MHz + UINT32 ModemState; //!< from SMSHOSTLIB_DVB_MODEM_STATE_ET + UINT32 TransmissionMode; //!< FFT mode carriers in Kilos + UINT32 GuardInterval; //!< Guard Interval, 1 divided by value + UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET + UINT32 LPCodeRate; //!< Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET + UINT32 Hierarchy; //!< Hierarchy from SMSHOSTLIB_HIERARCHY_ET + UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET + + // Burst parameters, valid only for DVB-H + UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H + UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H + UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H + UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H + UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H + UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H + UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H + UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets + UINT32 TotalTSPackets; //!< Total number of transport-stream packets + UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H + UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H + UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H + UINT32 NumMPEReceived; //!< DVB-H, Num MPE section received + + // DVB-H TPS parameters + UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + UINT32 DvbhSrvIndHP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator + UINT32 DvbhSrvIndLP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator + + // Interface information + UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + +} SMSHOSTLIB_STATISTICS_DVB_ST; + +typedef struct SMSHOSTLIB_GPIO_CONFIG_S +{ + UINT8 Direction; //!< GPIO direction: Input - 0, Output - 1 + UINT8 PullUpDown; //!< PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 + UINT8 InputCharacteristics; //!< Input Characteristics: Normal - 0, Schmitt trigger - 1 + UINT8 OutputSlewRate; //!< Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 + UINT8 OutputDriving; //!< Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 +} SMSHOSTLIB_GPIO_CONFIG_ST; + +typedef struct SMSHOSTLIB_I2C_REQ_S +{ + UINT32 DeviceAddress; // I2c device address + UINT32 WriteCount; // number of bytes to write + UINT32 ReadCount; // number of bytes to read + UINT8 Data[1]; +} SMSHOSTLIB_I2C_REQ_ST; + +typedef struct SMSHOSTLIB_I2C_RES_S +{ + UINT32 Status; // non-zero value in case of failure + UINT32 ReadCount; // number of bytes read + UINT8 Data[1]; +} SMSHOSTLIB_I2C_RES_ST; + +typedef struct _smsdvb_client +{ + struct list_head entry; + + smscore_device_t *coredev; + smscore_client_t *smsclient; + + struct dvb_adapter adapter; + struct dvb_demux demux; + struct dmxdev dmxdev; + struct dvb_frontend frontend; + + fe_status_t fe_status; + int fe_ber, fe_snr, fe_signal_strength; + + struct completion tune_done, stat_done; + + // todo: save freq/band instead whole struct + struct dvb_frontend_parameters fe_params; + +} smsdvb_client_t; + +extern void smscore_registry_setmode(char *devpath, int mode); +extern int smscore_registry_getmode(char *devpath); + +extern int smscore_register_hotplug(hotplug_t hotplug); +extern void smscore_unregister_hotplug(hotplug_t hotplug); + +extern int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev); +extern void smscore_unregister_device(smscore_device_t *coredev); + +extern int smscore_start_device(smscore_device_t *coredev); +extern int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler); + +extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); +extern int smscore_get_device_mode(smscore_device_t *coredev); + +extern int smscore_register_client(smscore_device_t *coredev, smsclient_params_t* params, smscore_client_t **client); +extern void smscore_unregister_client(smscore_client_t *client); + +extern int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size); +extern void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb); + +extern int smscore_get_common_buffer_size(smscore_device_t *coredev); +extern int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma); + +extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); +extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); + +/* smsdvb.c */ +int smsdvb_register(void); +void smsdvb_unregister(void); + +/* smsusb.c */ +int smsusb_register(void); +void smsusb_unregister(void); + +#endif // __smscoreapi_h__ diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c new file mode 100644 index 000000000..e1a14a812 --- /dev/null +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -0,0 +1,425 @@ +/* + * Driver for the Siano SMS10xx USB dongle + * + * author: Anatoly Greenblat + * + * Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation; + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include + +#include "smscoreapi.h" + +DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); + +struct list_head g_smsdvb_clients; +kmutex_t g_smsdvb_clientslock; + +int smsdvb_onresponse(void *context, smscore_buffer_t *cb) +{ + smsdvb_client_t *client = (smsdvb_client_t *) context; + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8*) cb->p) + cb->offset); + + switch(phdr->msgType) + { + case MSG_SMS_DVBT_BDA_DATA: + dvb_dmx_swfilter(&client->demux, (u8*)(phdr + 1), cb->size - sizeof(SmsMsgHdr_ST)); + break; + + case MSG_SMS_RF_TUNE_RES: + complete(&client->tune_done); + break; + + case MSG_SMS_GET_STATISTICS_RES: + { + SmsMsgStatisticsInfo_ST* p = (SmsMsgStatisticsInfo_ST*)(phdr + 1); + + if (p->Stat.IsDemodLocked) + { + client->fe_status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK; + client->fe_snr = p->Stat.SNR; + client->fe_ber = p->Stat.BER; + + if (p->Stat.InBandPwr < -95) + client->fe_signal_strength = 0; + else if (p->Stat.InBandPwr > -29) + client->fe_signal_strength = 100; + else + client->fe_signal_strength = (p->Stat.InBandPwr + 95) * 3 / 2; + } + else + { + client->fe_status = 0; + client->fe_snr = + client->fe_ber = + client->fe_signal_strength = 0; + } + + complete(&client->stat_done); + break; + } + } + + smscore_putbuffer(client->coredev, cb); + + return 0; +} + +void smsdvb_unregister_client(smsdvb_client_t* client) +{ + // must be called under clientslock + + list_del(&client->entry); + + smscore_unregister_client(client->smsclient); + dvb_unregister_frontend(&client->frontend); + dvb_dmxdev_release(&client->dmxdev); + dvb_dmx_release(&client->demux); + dvb_unregister_adapter(&client->adapter); + kfree(client); +} + +void smsdvb_onremove(void *context) +{ + kmutex_lock(&g_smsdvb_clientslock); + + smsdvb_unregister_client((smsdvb_client_t*) context); + + kmutex_unlock(&g_smsdvb_clientslock); +} + +static int smsdvb_start_feed(struct dvb_demux_feed *feed) +{ + smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); + SmsMsgData_ST PidMsg; + + printk("%s add pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); + + PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; + PidMsg.xMsgHeader.msgDstId = HIF_TASK; + PidMsg.xMsgHeader.msgFlags = 0; + PidMsg.xMsgHeader.msgType = MSG_SMS_ADD_PID_FILTER_REQ; + PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); + PidMsg.msgData[0] = feed->pid; + + return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); +} + +static int smsdvb_stop_feed(struct dvb_demux_feed *feed) +{ + smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); + SmsMsgData_ST PidMsg; + + printk("%s remove pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); + + PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; + PidMsg.xMsgHeader.msgDstId = HIF_TASK; + PidMsg.xMsgHeader.msgFlags = 0; + PidMsg.xMsgHeader.msgType = MSG_SMS_REMOVE_PID_FILTER_REQ; + PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); + PidMsg.msgData[0] = feed->pid; + + return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); +} + +static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, void* buffer, size_t size, struct completion *completion) +{ + int rc = smsclient_sendrequest(client->smsclient, buffer, size); + if (rc < 0) + return rc; + + return wait_for_completion_timeout(completion, msecs_to_jiffies(2000)) ? 0 : -ETIME; +} + +static int smsdvb_send_statistics_request(smsdvb_client_t *client) +{ + SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, DVBT_BDA_CONTROL_MSG_ID, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->stat_done); +} + +static int smsdvb_read_status(struct dvb_frontend *fe, fe_status_t *stat) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *stat = client->fe_status; + + return rc; +} + +static int smsdvb_read_ber(struct dvb_frontend *fe, u32 *ber) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *ber = client->fe_ber; + + return rc; +} + +static int smsdvb_read_signal_strength(struct dvb_frontend *fe, u16 *strength) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *strength = client->fe_signal_strength; + + return rc; +} + +static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + int rc = smsdvb_send_statistics_request(client); + + if (!rc) + *snr = client->fe_snr; + + return rc; +} + +static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) +{ + printk("%s\n", __FUNCTION__); + + tune->min_delay_ms = 400; + tune->step_size = 250000; + tune->max_drift = 0; + return 0; +} + +static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + + struct + { + SmsMsgHdr_ST Msg; + u32 Data[3]; + } Msg; + + Msg.Msg.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; + Msg.Msg.msgDstId = HIF_TASK; + Msg.Msg.msgFlags = 0; + Msg.Msg.msgType = MSG_SMS_RF_TUNE_REQ; + Msg.Msg.msgLength = sizeof(Msg); + Msg.Data[0] = fep->frequency; + Msg.Data[2] = 12000000; + + printk("%s freq %d band %d\n", __FUNCTION__, fep->frequency, fep->u.ofdm.bandwidth); + + switch(fep->u.ofdm.bandwidth) + { + case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; + case BANDWIDTH_7_MHZ: Msg.Data[1] = BW_7_MHZ; break; + case BANDWIDTH_6_MHZ: Msg.Data[1] = BW_6_MHZ; break; +// case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; + case BANDWIDTH_AUTO: return -EOPNOTSUPP; + default: return -EINVAL; + } + + return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->tune_done); +} + +static int smsdvb_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) +{ + smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + + printk("%s\n", __FUNCTION__); + + // todo: + memcpy(fep, &client->fe_params, sizeof(struct dvb_frontend_parameters)); + return 0; +} + +static void smsdvb_release(struct dvb_frontend *fe) +{ + // do nothing +} + +static struct dvb_frontend_ops smsdvb_fe_ops = { + .info = { + .name = "Siano Mobile Digital SMS10xx", + .type = FE_OFDM, + .frequency_min = 44250000, + .frequency_max = 867250000, + .frequency_stepsize = 250000, + .caps = FE_CAN_INVERSION_AUTO | + FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | + FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | + FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO | + FE_CAN_TRANSMISSION_MODE_AUTO | + FE_CAN_GUARD_INTERVAL_AUTO | + FE_CAN_RECOVER | + FE_CAN_HIERARCHY_AUTO, + }, + + .release = smsdvb_release, + + .set_frontend = smsdvb_set_frontend, + .get_frontend = smsdvb_get_frontend, + .get_tune_settings = smsdvb_get_tune_settings, + + .read_status = smsdvb_read_status, + .read_ber = smsdvb_read_ber, + .read_signal_strength = smsdvb_read_signal_strength, + .read_snr = smsdvb_read_snr, +}; + +int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival) +{ + smsclient_params_t params; + smsdvb_client_t* client; + int rc; + + // device removal handled by onremove callback + if (!arrival) + return 0; + + if (smscore_get_device_mode(coredev) != 4) + { + rc = smscore_set_device_mode(coredev, 4); + if (rc < 0) + return rc; + } + + client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); + if (!client) + { + printk(KERN_INFO "%s kmalloc() failed\n", __FUNCTION__); + return -ENOMEM; + } + + // register dvb adapter + rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device, adapter_nr); + if (rc < 0) + { + printk("%s dvb_register_adapter() failed %d\n", __func__, rc); + goto adapter_error; + } + + // init dvb demux + client->demux.dmx.capabilities = DMX_TS_FILTERING; + client->demux.filternum = 32; // todo: nova ??? + client->demux.feednum = 32; + client->demux.start_feed = smsdvb_start_feed; + client->demux.stop_feed = smsdvb_stop_feed; + + rc = dvb_dmx_init(&client->demux); + if (rc < 0) + { + printk("%s dvb_dmx_init failed %d\n\n", __FUNCTION__, rc); + goto dvbdmx_error; + } + + // init dmxdev + client->dmxdev.filternum = 32; + client->dmxdev.demux = &client->demux.dmx; + client->dmxdev.capabilities = 0; + + rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); + if (rc < 0) + { + printk("%s dvb_dmxdev_init failed %d\n", __FUNCTION__, rc); + goto dmxdev_error; + } + + // init and register frontend + memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); + + rc = dvb_register_frontend(&client->adapter, &client->frontend); + if (rc < 0) + { + printk("%s frontend registration failed %d\n", __FUNCTION__, rc); + goto frontend_error; + } + + params.initial_id = 0; + params.data_type = MSG_SMS_DVBT_BDA_DATA; + params.onresponse_handler = smsdvb_onresponse; + params.onremove_handler = smsdvb_onremove; + params.context = client; + + rc = smscore_register_client(coredev, ¶ms, &client->smsclient); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_register_client() failed %d\n", __FUNCTION__, rc); + goto client_error; + } + + client->coredev = coredev; + + init_completion(&client->tune_done); + init_completion(&client->stat_done); + + kmutex_lock(&g_smsdvb_clientslock); + + list_add(&client->entry, &g_smsdvb_clients); + + kmutex_unlock(&g_smsdvb_clientslock); + + printk(KERN_INFO "%s success\n", __FUNCTION__); + + return 0; + +client_error: + dvb_unregister_frontend(&client->frontend); + +frontend_error: + dvb_dmxdev_release(&client->dmxdev); + +dmxdev_error: + dvb_dmx_release(&client->demux); + +dvbdmx_error: + dvb_unregister_adapter(&client->adapter); + +adapter_error: + kfree(client); + return rc; +} + +int smsdvb_register(void) +{ + int rc; + + INIT_LIST_HEAD(&g_smsdvb_clients); + kmutex_init(&g_smsdvb_clientslock); + + rc = smscore_register_hotplug(smsdvb_hotplug); + + printk(KERN_INFO "%s\n", __FUNCTION__); + + return rc; +} + +void smsdvb_unregister(void) +{ + smscore_unregister_hotplug(smsdvb_hotplug); + + kmutex_lock(&g_smsdvb_clientslock); + + while (!list_empty(&g_smsdvb_clients)) + smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); + + kmutex_unlock(&g_smsdvb_clientslock); + +} + diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c new file mode 100644 index 000000000..b0bf8ac1a --- /dev/null +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -0,0 +1,440 @@ +/* + * Driver for the Siano SMS10xx USB dongle + * + * author: Anatoly Greenblat + * + * Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation; + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include + +#include "smscoreapi.h" + +#define USB1_BUFFER_SIZE 0x1000 +#define USB2_BUFFER_SIZE 0x4000 + +#define MAX_BUFFERS 50 +#define MAX_URBS 10 + +typedef struct _smsusb_device smsusb_device_t; + +typedef struct _smsusb_urb +{ + smscore_buffer_t *cb; + smsusb_device_t *dev; + + struct urb urb; +} smsusb_urb_t; + +typedef struct _smsusb_device +{ + struct usb_device* udev; + smscore_device_t *coredev; + + smsusb_urb_t surbs[MAX_URBS]; + + int response_alignment; + int buffer_size; +} *psmsusb_device_t; + +int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb); + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) +void smsusb_onresponse(struct urb *urb) +#else +void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) +#endif +{ + smsusb_urb_t *surb = (smsusb_urb_t *) urb->context; + smsusb_device_t *dev = surb->dev; + + if (urb->status < 0) + { + printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __FUNCTION__, urb->status, urb->actual_length); + return; + } + + if (urb->actual_length > 0) + { + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) surb->cb->p; + + if (urb->actual_length >= phdr->msgLength) + { + surb->cb->size = phdr->msgLength; + + if (dev->response_alignment && (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) + { + surb->cb->offset = dev->response_alignment + ((phdr->msgFlags >> 8) & 3); + + // sanity check + if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) + { + printk("%s: invalid response msglen %d offset %d size %d\n", __FUNCTION__, phdr->msgLength, surb->cb->offset, urb->actual_length); + goto exit_and_resubmit; + } + + // move buffer pointer and copy header to its new location + memcpy((char*) phdr + surb->cb->offset, phdr, sizeof(SmsMsgHdr_ST)); + } + else + surb->cb->offset = 0; + + smscore_onresponse(dev->coredev, surb->cb); + surb->cb = NULL; + } + else + { + printk("%s invalid response msglen %d actual %d\n", __FUNCTION__, phdr->msgLength, urb->actual_length); + } + } + +exit_and_resubmit: + smsusb_submit_urb(dev, surb); +} + +int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb) +{ + if (!surb->cb) + { + surb->cb = smscore_getbuffer(dev->coredev); + if (!surb->cb) + { + printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __FUNCTION__); + return -ENOMEM; + } + } + + usb_fill_bulk_urb( + &surb->urb, + dev->udev, + usb_rcvbulkpipe(dev->udev, 0x81), + surb->cb->p, + dev->buffer_size, + smsusb_onresponse, + surb + ); + surb->urb.transfer_dma = surb->cb->phys; + surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + + return usb_submit_urb(&surb->urb, GFP_ATOMIC); +} + +void smsusb_stop_streaming(smsusb_device_t* dev) +{ + int i; + + for (i = 0; i < MAX_URBS; i ++) + { + usb_kill_urb(&dev->surbs[i].urb); + + if (dev->surbs[i].cb) + { + smscore_putbuffer(dev->coredev, dev->surbs[i].cb); + dev->surbs[i].cb = NULL; + } + } +} + +int smsusb_start_streaming(smsusb_device_t* dev) +{ + int i, rc; + + for (i = 0; i < MAX_URBS; i ++) + { + rc = smsusb_submit_urb(dev, &dev->surbs[i]); + if (rc < 0) + { + printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __FUNCTION__); + smsusb_stop_streaming(dev); + break; + } + } + + return rc; +} + +int smsusb_sendrequest(void *context, void *buffer, size_t size) +{ + smsusb_device_t* dev = (smsusb_device_t*) context; + int dummy; + + return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buffer, size, &dummy, 1000); +} + +char *smsusb1_fw_lkup[] = +{ + "dvbt_stellar_usb.inp", + "dvbh_stellar_usb.inp", + "tdmb_stellar_usb.inp", + "none", + "dvbt_bda_stellar_usb.inp", +}; + +int smsusb1_load_firmware(struct usb_device *udev, int id) +{ + const struct firmware *fw; + u8* fw_buffer; + int rc, dummy; + + if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) + { + printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, id); + return -EINVAL; + } + + rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); + if (rc < 0) + { + printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __FUNCTION__, smsusb1_fw_lkup[id], id); + return rc; + } + + fw_buffer = kmalloc(fw->size, GFP_KERNEL); + if (fw_buffer) + { + memcpy(fw_buffer, fw->data, fw->size); + + rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); + + printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __FUNCTION__, fw->size, dummy, rc); + + kfree(fw_buffer); + } + else + { + printk(KERN_INFO "failed to allocate firmware buffer\n"); + rc = -ENOMEM; + } + + release_firmware(fw); + + return rc; +} + +void smsusb1_detectmode(void *context, int *mode) +{ + char *product_string = ((smsusb_device_t *) context)->udev->product; + + *mode = DEVICE_MODE_NONE; + + if (!product_string) + { + product_string = "none"; + printk("%s product string not found\n", __FUNCTION__); + } + else + { + if (strstr(product_string, "DVBH")) + *mode = 1; + else if (strstr(product_string, "BDA")) + *mode = 4; + else if (strstr(product_string, "DVBT")) + *mode = 0; + else if (strstr(product_string, "TDMB")) + *mode = 2; + } + + printk("%s: %d \"%s\"\n", __FUNCTION__, *mode, product_string); +} + +int smsusb1_setmode(void *context, int mode) +{ + SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) + { + printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, mode); + return -EINVAL; + } + + return smsusb_sendrequest(context, &Msg, sizeof(Msg)); +} + +void smsusb_term_device(struct usb_interface *intf) +{ + smsusb_device_t *dev = (smsusb_device_t*) usb_get_intfdata(intf); + + if (dev) + { + smsusb_stop_streaming(dev); + + // unregister from smscore + if (dev->coredev) + smscore_unregister_device(dev->coredev); + + kfree(dev); + + printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, dev); + } + + usb_set_intfdata(intf, NULL); +} + +int smsusb_init_device(struct usb_interface *intf) +{ + smsdevice_params_t params; + smsusb_device_t* dev; + int i, rc; + + // create device object + dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); + if (!dev) + { + printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __FUNCTION__); + return -ENOMEM; + } + + memset(¶ms, 0, sizeof(params)); + usb_set_intfdata(intf, dev); + dev->udev = interface_to_usbdev(intf); + + switch (dev->udev->descriptor.idProduct) + { + case 0x100: + dev->buffer_size = USB1_BUFFER_SIZE; + + params.setmode_handler = smsusb1_setmode; + params.detectmode_handler = smsusb1_detectmode; + break; + + default: + dev->buffer_size = USB2_BUFFER_SIZE; + dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST); + + params.flags |= SMS_DEVICE_FAMILY2; + break; + } + + params.device = &dev->udev->dev; + params.buffer_size = dev->buffer_size; + params.num_buffers = MAX_BUFFERS; + params.sendrequest_handler = smsusb_sendrequest; + params.context = dev; + snprintf(params.devpath, sizeof(params.devpath), "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath); + + // register in smscore + rc = smscore_register_device(¶ms, &dev->coredev); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __FUNCTION__, rc); + smsusb_term_device(intf); + return rc; + } + + // initialize urbs + for (i = 0; i < MAX_URBS; i ++) + { + dev->surbs[i].dev = dev; + usb_init_urb(&dev->surbs[i].urb); + } + + rc = smsusb_start_streaming(dev); + if (rc < 0) + { + printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __FUNCTION__); + smsusb_term_device(intf); + return rc; + } + + rc = smscore_start_device(dev->coredev); + if (rc < 0) + { + printk(KERN_INFO "%s smscore_start_device(...) failed\n", __FUNCTION__); + smsusb_term_device(intf); + return rc; + } + + printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); + + return rc; +} + +int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(intf); + char devpath[32]; + int i, rc; + + if (intf->num_altsetting > 0) + { + rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); + if (rc < 0) + { + printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __FUNCTION__, rc); + return rc; + } + } + + printk(KERN_INFO "smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber); + for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i ++) + printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); + + if (udev->actconfig->desc.bNumInterfaces == 2 && intf->cur_altsetting->desc.bInterfaceNumber == 0) + { + printk(KERN_INFO "rom interface 0 is not used\n"); + return -ENODEV; + } + + if (intf->cur_altsetting->desc.bInterfaceNumber == 1) + { + snprintf(devpath, 32, "%d:%s", udev->bus->busnum, udev->devpath); + return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath)); + } + + return smsusb_init_device(intf); +} + +void smsusb_disconnect(struct usb_interface *intf) +{ + smsusb_term_device(intf); +} + +static struct usb_device_id smsusb_id_table [] = { + { USB_DEVICE(0x187F, 0x0010) }, + { USB_DEVICE(0x187F, 0x0100) }, + { USB_DEVICE(0x187F, 0x0200) }, + { } /* Terminating entry */ +}; +MODULE_DEVICE_TABLE (usb, smsusb_id_table); + +static struct usb_driver smsusb_driver = { + .name = "smsusb", + .probe = smsusb_probe, + .disconnect = smsusb_disconnect, + .id_table = smsusb_id_table, +}; + +int smsusb_register(void) +{ + int rc = usb_register(&smsusb_driver); + if (rc) + printk(KERN_INFO "usb_register failed. Error number %d\n", rc); + + printk(KERN_INFO "%s\n", __FUNCTION__); + + return rc; +} + +void smsusb_unregister(void) +{ + /* Regular USB Cleanup */ + usb_deregister(&smsusb_driver); + printk(KERN_INFO "%s\n", __FUNCTION__); +} + diff --git a/linux/drivers/media/mdtv/Kconfig b/linux/drivers/media/mdtv/Kconfig deleted file mode 100644 index a7faca0b7..000000000 --- a/linux/drivers/media/mdtv/Kconfig +++ /dev/null @@ -1,16 +0,0 @@ -# -# Mobile Digital TV device configuration -# - -config MDTV_SIANO_STELLAR_USB - tristate "Siano SMS10xx USB dongle support" - default m - ---help--- - Choose Y here if you have USB dongle with SMS10xx chipset. - - Further documentation on this driver can be found on the WWW at - . - - To compile this driver as a module, choose M here: the - modules will be called smschar and smsnet. - diff --git a/linux/drivers/media/mdtv/Makefile b/linux/drivers/media/mdtv/Makefile deleted file mode 100644 index 16b9c488c..000000000 --- a/linux/drivers/media/mdtv/Makefile +++ /dev/null @@ -1,10 +0,0 @@ -smscore-objs := smscoreapi.o smsusb.o smsdvb.o - -obj-$(CONFIG_MDTV_SIANO_STELLAR_USB) += smscore.o - -EXTRA_CFLAGS += -Idrivers/media/video -EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core -EXTRA_CFLAGS += -Idrivers/media/dvb/frontends - -EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m) - diff --git a/linux/drivers/media/mdtv/smscoreapi.c b/linux/drivers/media/mdtv/smscoreapi.c deleted file mode 100644 index 9553d08ff..000000000 --- a/linux/drivers/media/mdtv/smscoreapi.c +++ /dev/null @@ -1,1233 +0,0 @@ - -/* - * Driver for the Siano SMS10xx USB dongle - * - * Copyright (c) 2008 - * - * 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, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -/*! - - \file smscoreapi.c - - \brief Siano core API module - This file contains implementation for the interface to sms core component - - \par Copyright (c), 2005-2008 Siano Mobile Silicon, Inc. - - \par This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License version 3 as - published by the Free Software Foundation; - - Software distributed under the License is distributed on an "AS - IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - implied. - - \author Anatoly Greenblat - -*/ - -#include -#include -#include -#include -#include -#include -#include - -#include - -#include "smscoreapi.h" - -typedef struct _smscore_device_notifyee -{ - struct list_head entry; - hotplug_t hotplug; -} smscore_device_notifyee_t; - -typedef struct _smscore_client -{ - struct list_head entry; - smscore_device_t *coredev; - - void *context; - - int data_type; - - onresponse_t onresponse_handler; - onremove_t onremove_handler; -} *psmscore_client_t; - -typedef struct _smscore_subclient -{ - struct list_head entry; - smscore_client_t *client; - - int id; -} smscore_subclient_t; - -typedef struct _smscore_device -{ - struct list_head entry; - - struct list_head clients; - struct list_head subclients; - spinlock_t clientslock; - - struct list_head buffers; - spinlock_t bufferslock; - int num_buffers; - - void *common_buffer; - int common_buffer_size; - dma_addr_t common_buffer_phys; - - void *context; - struct device *device; - - char devpath[32]; - unsigned long device_flags; - - setmode_t setmode_handler; - detectmode_t detectmode_handler; - sendrequest_t sendrequest_handler; - preload_t preload_handler; - postload_t postload_handler; - - int mode, modes_supported; - - struct completion version_ex_done, data_download_done, trigger_done; - struct completion init_device_done, reload_start_done, resume_done; -} *psmscore_device_t; - -typedef struct _smscore_registry_entry -{ - struct list_head entry; - char devpath[32]; - int mode; -} smscore_registry_entry_t; - -struct list_head g_smscore_notifyees; -struct list_head g_smscore_devices; -kmutex_t g_smscore_deviceslock; - -struct list_head g_smscore_registry; -kmutex_t g_smscore_registrylock; - -static int default_mode = 1; -module_param(default_mode, int, 0644); -MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); - -int smscore_registry_getmode(char* devpath) -{ - smscore_registry_entry_t *entry; - struct list_head *next; - - kmutex_lock(&g_smscore_registrylock); - - for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) - { - entry = (smscore_registry_entry_t *) next; - - if (!strcmp(entry->devpath, devpath)) - { - kmutex_unlock(&g_smscore_registrylock); - return entry->mode; - } - } - - entry = (smscore_registry_entry_t *) kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); - if (entry) - { - entry->mode = default_mode; - strcpy(entry->devpath, devpath); - - list_add(&entry->entry, &g_smscore_registry); - } - - kmutex_unlock(&g_smscore_registrylock); - - return default_mode; -} - -void smscore_registry_setmode(char* devpath, int mode) -{ - smscore_registry_entry_t *entry; - struct list_head *next; - - kmutex_lock(&g_smscore_registrylock); - - for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) - { - entry = (smscore_registry_entry_t *) next; - - if (!strcmp(entry->devpath, devpath)) - { - entry->mode = mode; - break; - } - } - - kmutex_unlock(&g_smscore_registrylock); -} - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) -void *kzalloc(size_t size, int flags) -{ - void *ret = kmalloc(size, flags); - if (ret) - memset(ret, 0, size); - return ret; -} - -static inline unsigned long kvirt_to_pa(unsigned long adr) -{ - unsigned long kva, ret; - - kva = (unsigned long) page_address(virt_to_page((void *)adr)); - kva |= adr & (PAGE_SIZE-1); /* restore the offset */ - ret = __pa(kva); - return ret; -} - -unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout) -{ - might_sleep(); - - spin_lock_irq(&x->wait.lock); - if (!x->done) { - DECLARE_WAITQUEUE(wait, current); - - wait.flags |= WQ_FLAG_EXCLUSIVE; - __add_wait_queue_tail(&x->wait, &wait); - do { - __set_current_state(TASK_UNINTERRUPTIBLE); - spin_unlock_irq(&x->wait.lock); - timeout = schedule_timeout(timeout); - spin_lock_irq(&x->wait.lock); - if (!timeout) { - __remove_wait_queue(&x->wait, &wait); - goto out; - } - } while (!x->done); - __remove_wait_queue(&x->wait, &wait); - } - x->done--; -out: - spin_unlock_irq(&x->wait.lock); - return timeout; -} -#endif - -void list_add_locked(struct list_head *new, struct list_head *head, spinlock_t* lock) -{ - unsigned long flags; - - spin_lock_irqsave(lock, flags); - - list_add(new, head); - - spin_unlock_irqrestore(lock, flags); -} - -/** - * register a client callback that called when device plugged in/unplugged - * NOTE: if devices exist callback is called immediately for each device - * - * @param hotplug callback - * - * @return 0 on success, <0 on error. - */ -int smscore_register_hotplug(hotplug_t hotplug) -{ - smscore_device_notifyee_t *notifyee; - struct list_head *next, *first; - int rc = 0; - - kmutex_lock(&g_smscore_deviceslock); - - notifyee = kmalloc(sizeof(smscore_device_notifyee_t), GFP_KERNEL); - if (notifyee) - { - // now notify callback about existing devices - first = &g_smscore_devices; - for (next = first->next; next != first && !rc; next = next->next) - { - smscore_device_t *coredev = (smscore_device_t *) next; - rc = hotplug(coredev, coredev->device, 1); - } - - if (rc >= 0) - { - notifyee->hotplug = hotplug; - list_add(¬ifyee->entry, &g_smscore_notifyees); - } - else - kfree(notifyee); - } - else - rc = -ENOMEM; - - kmutex_unlock(&g_smscore_deviceslock); - - return rc; -} - -/** - * unregister a client callback that called when device plugged in/unplugged - * - * @param hotplug callback - * - */ -void smscore_unregister_hotplug(hotplug_t hotplug) -{ - struct list_head *next, *first; - - kmutex_lock(&g_smscore_deviceslock); - - first = &g_smscore_notifyees; - - for (next = first->next; next != first;) - { - smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) next; - next = next->next; - - if (notifyee->hotplug == hotplug) - { - list_del(¬ifyee->entry); - kfree(notifyee); - } - } - - kmutex_unlock(&g_smscore_deviceslock); -} - -void smscore_notify_clients(smscore_device_t *coredev) -{ - smscore_client_t* client; - - // the client must call smscore_unregister_client from remove handler - while (!list_empty(&coredev->clients)) - { - client = (smscore_client_t *) coredev->clients.next; - client->onremove_handler(client->context); - } -} - -int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, int arrival) -{ - struct list_head *next, *first; - int rc = 0; - - // note: must be called under g_deviceslock - - first = &g_smscore_notifyees; - - for (next = first->next; next != first; next = next->next) - { - rc = ((smscore_device_notifyee_t *) next)->hotplug(coredev, device, arrival); - if (rc < 0) - break; - } - - return rc; -} - -smscore_buffer_t *smscore_createbuffer(u8* buffer, void* common_buffer, dma_addr_t common_buffer_phys) -{ - smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); - if (!cb) - { - printk(KERN_INFO "%s kmalloc(...) failed\n", __FUNCTION__); - return NULL; - } - - cb->p = buffer; - cb->offset_in_common = buffer - (u8*) common_buffer; - cb->phys = common_buffer_phys + cb->offset_in_common; - - return cb; -} - -/** - * creates coredev object for a device, prepares buffers, creates buffer mappings, notifies - * registered hotplugs about new device. - * - * @param params device pointer to struct with device specific parameters and handlers - * @param coredev pointer to a value that receives created coredev object - * - * @return 0 on success, <0 on error. - */ -int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev) -{ - smscore_device_t* dev; - u8 *buffer; - - dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); - if (!dev) - { - printk(KERN_INFO "%s kzalloc(...) failed\n", __FUNCTION__); - return -ENOMEM; - } - - // init list entry so it could be safe in smscore_unregister_device - INIT_LIST_HEAD(&dev->entry); - - // init queues - INIT_LIST_HEAD(&dev->clients); - INIT_LIST_HEAD(&dev->subclients); - INIT_LIST_HEAD(&dev->buffers); - - // init locks - spin_lock_init(&dev->clientslock); - spin_lock_init(&dev->bufferslock); - - // init completion events - init_completion(&dev->version_ex_done); - init_completion(&dev->data_download_done); - init_completion(&dev->trigger_done); - init_completion(&dev->init_device_done); - init_completion(&dev->reload_start_done); - init_completion(&dev->resume_done); - - // alloc common buffer - dev->common_buffer_size = params->buffer_size * params->num_buffers; - dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size, &dev->common_buffer_phys, GFP_KERNEL | GFP_DMA); - if (!dev->common_buffer) - { - smscore_unregister_device(dev); - return -ENOMEM; - } - - // prepare dma buffers - for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; dev->num_buffers ++, buffer += params->buffer_size) - { - smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); - if (!cb) - { - smscore_unregister_device(dev); - return -ENOMEM; - } - - smscore_putbuffer(dev, cb); - } - - printk(KERN_INFO "%s allocated %d buffers\n", __FUNCTION__, dev->num_buffers); - - dev->mode = DEVICE_MODE_NONE; - dev->context = params->context; - dev->device = params->device; - dev->setmode_handler = params->setmode_handler; - dev->detectmode_handler = params->detectmode_handler; - dev->sendrequest_handler = params->sendrequest_handler; - dev->preload_handler = params->preload_handler; - dev->postload_handler = params->postload_handler; - - dev->device_flags = params->flags; - strcpy(dev->devpath, params->devpath); - - // add device to devices list - kmutex_lock(&g_smscore_deviceslock); - list_add(&dev->entry, &g_smscore_devices); - kmutex_unlock(&g_smscore_deviceslock); - - *coredev = dev; - - printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); - - return 0; -} - -/** - * sets initial device mode and notifies client hotplugs that device is ready - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * - * @return 0 on success, <0 on error. - */ -int smscore_start_device(smscore_device_t *coredev) -{ - int rc = smscore_set_device_mode(coredev, smscore_registry_getmode(coredev->devpath)); - if (rc < 0) - return rc; - - kmutex_lock(&g_smscore_deviceslock); - - rc = smscore_notify_callbacks(coredev, coredev->device, 1); - - printk(KERN_INFO "%s device %p started, rc %d\n", __FUNCTION__, coredev, rc); - - kmutex_unlock(&g_smscore_deviceslock); - - return rc; -} - -int smscore_sendrequest_and_wait(smscore_device_t *coredev, void* buffer, size_t size, struct completion *completion) -{ - int rc = coredev->sendrequest_handler(coredev->context, buffer, size); - if (rc < 0) - return rc; - - return wait_for_completion_timeout(completion, msecs_to_jiffies(1000)) ? 0 : -ETIME; -} - -int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_t size) -{ - SmsFirmware_ST* firmware = (SmsFirmware_ST*) buffer; - SmsMsgHdr_ST *msg; - UINT32 mem_address = firmware->StartAddress; - u8* payload = firmware->Payload; - int rc = 0; - - if (coredev->preload_handler) - { - rc = coredev->preload_handler(coredev->context); - if (rc < 0) - return rc; - } - - // PAGE_SIZE buffer shall be enough and dma aligned - msg = (SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); - if (!msg) - return -ENOMEM; - - if (coredev->mode != DEVICE_MODE_NONE) - { - SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(SmsMsgHdr_ST)); - rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); - mem_address = *(UINT32*) &payload[20]; - } - - while (size && rc >= 0) - { - SmsDataDownload_ST *DataMsg = (SmsDataDownload_ST *) msg; - int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); - - SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, (UINT16)(sizeof(SmsMsgHdr_ST) + sizeof(UINT32) + payload_size)); - - DataMsg->MemAddr = mem_address; - memcpy(DataMsg->Payload, payload, payload_size); - - if (coredev->device_flags & SMS_ROM_NO_RESPONSE && coredev->mode == DEVICE_MODE_NONE) - rc = coredev->sendrequest_handler(coredev->context, DataMsg, DataMsg->xMsgHeader.msgLength); - else - rc = smscore_sendrequest_and_wait(coredev, DataMsg, DataMsg->xMsgHeader.msgLength, &coredev->data_download_done); - - payload += payload_size; - size -= payload_size; - mem_address += payload_size; - } - - if (rc >= 0) - { - if (coredev->mode == DEVICE_MODE_NONE) - { - SmsMsgData_ST* TriggerMsg = (SmsMsgData_ST*) msg; - - SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, sizeof(SmsMsgHdr_ST) + sizeof(UINT32) * 5); - - TriggerMsg->msgData[0] = firmware->StartAddress; // Entry point - TriggerMsg->msgData[1] = 5; // Priority - TriggerMsg->msgData[2] = 0x200; // Stack size - TriggerMsg->msgData[3] = 0; // Parameter - TriggerMsg->msgData[4] = 4; // Task ID - - if (coredev->device_flags & SMS_ROM_NO_RESPONSE) - { - rc = coredev->sendrequest_handler(coredev->context, TriggerMsg, TriggerMsg->xMsgHeader.msgLength); - msleep(100); - } - else - rc = smscore_sendrequest_and_wait(coredev, TriggerMsg, TriggerMsg->xMsgHeader.msgLength, &coredev->trigger_done); - } - else - { - SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, sizeof(SmsMsgHdr_ST)); - - rc = coredev->sendrequest_handler(coredev->context, msg, msg->msgLength); - } - } - - printk("%s %d \n", __func__, rc); - - kfree(msg); - - return (rc >= 0 && coredev->postload_handler) ? - coredev->postload_handler(coredev->context) : - rc; -} - -/** - * loads specified firmware into a buffer and calls device loadfirmware_handler - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * @param filename null-terminated string specifies firmware file name - * @param loadfirmware_handler device handler that loads firmware - * - * @return 0 on success, <0 on error. - */ -int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler) -{ - int rc = -ENOENT; - -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) - const struct firmware *fw; - u8* fw_buffer; - - if (loadfirmware_handler == NULL && !(coredev->device_flags & SMS_DEVICE_FAMILY2)) - return -EINVAL; - - rc = request_firmware(&fw, filename, coredev->device); - if (rc < 0) - { - printk(KERN_INFO "%s failed to open \"%s\"\n", __FUNCTION__, filename); - return rc; - } - - fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); - if (fw_buffer) - { - memcpy(fw_buffer, fw->data, fw->size); - - rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ? - smscore_load_firmware_family2(coredev, fw_buffer, fw->size) : - loadfirmware_handler(coredev->context, fw_buffer, fw->size); - - kfree(fw_buffer); - } - else - { - printk(KERN_INFO "%s failed to allocate firmware buffer\n", __FUNCTION__); - rc = -ENOMEM; - } - - release_firmware(fw); -#endif - - return rc; -} - -/** - * notifies all clients registered with the device, notifies hotplugs, frees all buffers and coredev object - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * - * @return 0 on success, <0 on error. - */ -void smscore_unregister_device(smscore_device_t *coredev) -{ - smscore_buffer_t *cb; - int num_buffers = 0; - - kmutex_lock(&g_smscore_deviceslock); - - smscore_notify_clients(coredev); - smscore_notify_callbacks(coredev, NULL, 0); - - // at this point all buffers should be back - // onresponse must no longer be called - - while (1) - { - while ((cb = smscore_getbuffer(coredev))) - { - kfree(cb); - num_buffers ++; - } - - if (num_buffers == coredev->num_buffers) - break; - - printk(KERN_INFO "%s waiting for %d buffer(s)\n", __FUNCTION__, coredev->num_buffers - num_buffers); - msleep(100); - } - - printk(KERN_INFO "%s freed %d buffers\n", __FUNCTION__, num_buffers); - - if (coredev->common_buffer) - dma_free_coherent(NULL, coredev->common_buffer_size, coredev->common_buffer, coredev->common_buffer_phys); - - list_del(&coredev->entry); - kfree(coredev); - - kmutex_unlock(&g_smscore_deviceslock); - - printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, coredev); -} - -int smscore_detect_mode(smscore_device_t *coredev) -{ - void *buffer = kmalloc(sizeof(SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); - SmsMsgHdr_ST *msg = (SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer); - int rc; - - if (!buffer) - return -ENOMEM; - - SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ, sizeof(SmsMsgHdr_ST)); - - rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); - if (rc == -ETIME) - { - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __FUNCTION__); - - if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) - { - rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); - if (rc < 0) - { - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __FUNCTION__, rc); - } - } - else - rc = -ETIME; - } - - kfree(buffer); - - return rc; -} - -char *smscore_fw_lkup[] = -{ - "dvb_nova_12mhz.inp", - "dvb_nova_12mhz.inp", - "tdmb_nova.inp", - "none", - "dvb_nova_12mhz.inp", - "isdbt_nova_12mhz.inp", - "isdbt_nova_12mhz.inp", - "cmmb_nova_12mhz.inp", - "none", -}; - -/** - * calls device handler to change mode of operation - * NOTE: stellar/usb may disconnect when changing mode - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * @param mode requested mode of operation - * - * @return 0 on success, <0 on error. - */ -int smscore_set_device_mode(smscore_device_t *coredev, int mode) -{ - void *buffer; - int rc = 0; - - if (coredev->device_flags & SMS_DEVICE_FAMILY2) - { - if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) - { - printk(KERN_INFO "%s invalid mode specified %d\n", __FUNCTION__, mode); - return -EINVAL; - } - - if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) - { - rc = smscore_detect_mode(coredev); - if (rc < 0) - return rc; - } - - if (coredev->mode == mode) - { - printk(KERN_INFO "%s device mode %d already set\n", __FUNCTION__, mode); - return 0; - } - - if (!(coredev->modes_supported & (1 << mode))) - { - rc = smscore_load_firmware(coredev, smscore_fw_lkup[mode], NULL); - if (rc < 0) - return rc; - } - else - { - printk(KERN_INFO "%s mode %d supported by running firmware\n", __FUNCTION__, mode); - } - - buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); - if (buffer) - { - SmsMsgData_ST *msg = (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); - - SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, sizeof(SmsMsgData_ST)); - msg->msgData[0] = mode; - - rc = smscore_sendrequest_and_wait(coredev, msg, msg->xMsgHeader.msgLength, &coredev->init_device_done); - - kfree(buffer); - } - else - rc = -ENOMEM; - } - else - { - if (coredev->detectmode_handler) - coredev->detectmode_handler(coredev->context, &coredev->mode); - - if (coredev->mode != mode && coredev->setmode_handler) - rc = coredev->setmode_handler(coredev->context, mode); - } - - smscore_registry_setmode(coredev->devpath, mode); - - if (rc >= 0) - { - coredev->mode = mode; - coredev->device_flags &= ~SMS_DEVICE_NOT_READY; - } - - return rc; -} - -/** - * calls device handler to get current mode of operation - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * - * @return current mode - */ -int smscore_get_device_mode(smscore_device_t *coredev) -{ - return coredev->mode; -} - -smscore_client_t* smscore_getclient_by_type(smscore_device_t *coredev, int data_type) -{ - smscore_client_t *client = NULL; - struct list_head *next, *first; - unsigned long flags; - - if (!data_type) - return NULL; - - spin_lock_irqsave(&coredev->clientslock, flags); - - first = &coredev->clients; - - for (next = first->next; next != first; next = next->next) - { - if (((smscore_client_t*) next)->data_type == data_type) - { - client = (smscore_client_t*) next; - break; - } - } - - spin_unlock_irqrestore(&coredev->clientslock, flags); - - return client; -} - -smscore_client_t* smscore_getclient_by_id(smscore_device_t *coredev, int id) -{ - smscore_client_t *client = NULL; - struct list_head *next, *first; - unsigned long flags; - - spin_lock_irqsave(&coredev->clientslock, flags); - - first = &coredev->subclients; - - for (next = first->next; next != first; next = next->next) - { - if (((smscore_subclient_t*) next)->id == id) - { - client = ((smscore_subclient_t*) next)->client; - break; - } - } - - spin_unlock_irqrestore(&coredev->clientslock, flags); - - return client; -} - -/** - * find client by response id/type, call clients onresponse handler - * return buffer to pool on error - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * @param cb pointer to response buffer descriptor - * - */ -void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) -{ - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8*) cb->p + cb->offset); - smscore_client_t * client = smscore_getclient_by_type(coredev, phdr->msgType); - int rc = -EBUSY; - -#if 1 - static unsigned long last_sample_time = 0; - static int data_total = 0; - unsigned long time_now = jiffies_to_msecs(jiffies); - - if (!last_sample_time) - last_sample_time = time_now; - - if (time_now - last_sample_time > 10000) - { - printk("\n%s data rate %d bytes/secs\n", __func__, (int)((data_total * 1000) / (time_now - last_sample_time))); - - last_sample_time = time_now; - data_total = 0; - } - - data_total += cb->size; -#endif - - if (!client) - client = smscore_getclient_by_id(coredev, phdr->msgDstId); - - if (client) - rc = client->onresponse_handler(client->context, cb); - - if (rc < 0) - { - switch (phdr->msgType) - { - case MSG_SMS_GET_VERSION_EX_RES: - { - SmsVersionRes_ST *ver = (SmsVersionRes_ST*) phdr; - printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d prots 0x%x ver %d.%d\n", __FUNCTION__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); - - coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; - coredev->modes_supported = ver->SupportedProtocols; - - complete(&coredev->version_ex_done); - break; - } - - case MSG_SMS_INIT_DEVICE_RES: - printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __FUNCTION__); - complete(&coredev->init_device_done); - break; - - case MSG_SW_RELOAD_START_RES: - printk("%s: MSG_SW_RELOAD_START_RES\n", __FUNCTION__); - complete(&coredev->reload_start_done); - break; - - case MSG_SMS_DATA_DOWNLOAD_RES: - complete(&coredev->data_download_done); - break; - - case MSG_SW_RELOAD_EXEC_RES: - printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __FUNCTION__); - break; - - case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __FUNCTION__); - complete(&coredev->trigger_done); - break; - - case MSG_SMS_SLEEP_RESUME_COMP_IND: - complete(&coredev->resume_done); - break; - - default: - printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __FUNCTION__, client, rc, phdr->msgType, phdr->msgDstId); - } - - smscore_putbuffer(coredev, cb); - } -} - -/** - * return pointer to next free buffer descriptor from core pool - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * - * @return pointer to descriptor on success, NULL on error. - */ -smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) -{ - smscore_buffer_t *cb = NULL; - unsigned long flags; - - spin_lock_irqsave(&coredev->bufferslock, flags); - - if (!list_empty(&coredev->buffers)) - { - cb = (smscore_buffer_t *) coredev->buffers.next; - list_del(&cb->entry); - } - - spin_unlock_irqrestore(&coredev->bufferslock, flags); - - return cb; -} - -/** - * return buffer descriptor to a pool - * - * @param coredev pointer to a coredev object returned by smscore_register_device - * @param cb pointer buffer descriptor - * - */ -void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb) -{ - list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); -} - -int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int id) -{ - smscore_client_t *existing_client; - smscore_subclient_t *subclient; - - if (!id) - return 0; - - existing_client = smscore_getclient_by_id(coredev, id); - if (existing_client == client) - return 0; - - if (existing_client) - return -EBUSY; - - subclient = kzalloc(sizeof(smscore_subclient_t), GFP_KERNEL); - if (!subclient) - return -ENOMEM; - - subclient->client = client; - subclient->id = id; - - list_add_locked(&subclient->entry, &coredev->subclients, &coredev->clientslock); - - return 0; -} - -/** - * creates smsclient object, check that id is taken by another client - * - * @param coredev pointer to a coredev object from clients hotplug - * @param initial_id all messages with this id would be sent to this client - * @param data_type all messages of this type would be sent to this client - * @param onresponse_handler client handler that is called to process incoming messages - * @param onremove_handler client handler that is called when device is removed - * @param context client-specific context - * @param client pointer to a value that receives created smsclient object - * - * @return 0 on success, <0 on error. - */ -int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) -{ - smscore_client_t* newclient; - int rc; - - // check that no other channel with same data type exists - if (params->data_type && smscore_getclient_by_type(coredev, params->data_type)) - return -EEXIST; - - newclient = kzalloc(sizeof(smscore_client_t), GFP_KERNEL); - if (!newclient) - return -ENOMEM; - - // check that no other channel with same id exists - rc = smscore_validate_client(coredev, newclient, params->initial_id); - if (rc < 0) - { - kfree(newclient); - return rc; - } - - newclient->coredev = coredev; - newclient->data_type = params->data_type; - newclient->onresponse_handler = params->onresponse_handler; - newclient->onremove_handler = params->onremove_handler; - newclient->context = params->context; - - list_add_locked(&newclient->entry, &coredev->clients, &coredev->clientslock); - - *client = newclient; - - printk(KERN_INFO "%s %p %d %d\n", __FUNCTION__, params->context, params->data_type, params->initial_id); - - return 0; -} - -/** - * frees smsclient object and all subclients associated with it - * - * @param client pointer to smsclient object returned by smscore_register_client - * - */ -void smscore_unregister_client(smscore_client_t *client) -{ - smscore_device_t *coredev = client->coredev; - struct list_head *next, *first; - unsigned long flags; - - spin_lock_irqsave(&coredev->clientslock, flags); - - first = &coredev->subclients; - - for (next = first->next; next != first;) - { - smscore_subclient_t *subclient = (smscore_subclient_t *) next; - next = next->next; - - if (subclient->client == client) - { - list_del(&subclient->entry); - kfree(subclient); - } - } - - printk(KERN_INFO "%s %p %d\n", __FUNCTION__, client->context, client->data_type); - - list_del(&client->entry); - kfree(client); - - spin_unlock_irqrestore(&coredev->clientslock, flags); -} - -/** - * verifies that source id is not taken by another client, - * calls device handler to send requests to the device - * - * @param client pointer to smsclient object returned by smscore_register_client - * @param buffer pointer to a request buffer - * @param size size (in bytes) of request buffer - * - * @return 0 on success, <0 on error. - */ -int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) -{ - smscore_device_t* coredev = client->coredev; - SmsMsgHdr_ST* phdr = (SmsMsgHdr_ST*) buffer; - - // check that no other channel with same id exists - int rc = smscore_validate_client(client->coredev, client, phdr->msgSrcId); - if (rc < 0) - return rc; - - return coredev->sendrequest_handler(coredev->context, buffer, size); -} - -/** - * return the size of large (common) buffer - * - * @param coredev pointer to a coredev object from clients hotplug - * - * @return size (in bytes) of the buffer - */ -int smscore_get_common_buffer_size(smscore_device_t *coredev) -{ - return coredev->common_buffer_size; -} - -/** - * maps common buffer (if supported by platform) - * - * @param coredev pointer to a coredev object from clients hotplug - * @param vma pointer to vma struct from mmap handler - * - * @return 0 on success, <0 on error. - */ -int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma) -{ - unsigned long end = vma->vm_end, start = vma->vm_start, size = PAGE_ALIGN(coredev->common_buffer_size); - - if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) - { - printk(KERN_INFO "%s invalid vm flags\n", __FUNCTION__); - return -EINVAL; - } - - if ((end - start) != size) - { - printk(KERN_INFO "%s invalid size %d expected %d\n", __FUNCTION__, (int)(end - start), (int) size); - return -EINVAL; - } - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) - if (remap_page_range(vma, start, coredev->common_buffer_phys, size, vma->vm_page_prot)) -#else - if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) -#endif - { - printk(KERN_INFO "%s remap_page_range failed\n", __FUNCTION__); - return -EAGAIN; - } - - return 0; -} - -int smscore_module_init(void) -{ - int rc = 0; - - INIT_LIST_HEAD(&g_smscore_notifyees); - INIT_LIST_HEAD(&g_smscore_devices); - kmutex_init(&g_smscore_deviceslock); - - INIT_LIST_HEAD(&g_smscore_registry); - kmutex_init(&g_smscore_registrylock); - - /* USB Register */ - rc = smsusb_register(); - - /* DVB Register */ - rc = smsdvb_register(); - - printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); - - return rc; -} - -void smscore_module_exit(void) -{ - - kmutex_lock(&g_smscore_deviceslock); - while (!list_empty(&g_smscore_notifyees)) - { - smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) g_smscore_notifyees.next; - - list_del(¬ifyee->entry); - kfree(notifyee); - } - kmutex_unlock(&g_smscore_deviceslock); - - kmutex_lock(&g_smscore_registrylock); - while (!list_empty(&g_smscore_registry)) - { - smscore_registry_entry_t *entry = (smscore_registry_entry_t *) g_smscore_registry.next; - - list_del(&entry->entry); - kfree(entry); - } - kmutex_unlock(&g_smscore_registrylock); - - /* DVB UnRegister */ - smsdvb_unregister(); - - /* Unregister USB */ - smsusb_unregister(); - - printk(KERN_INFO "%s\n", __FUNCTION__); -} - -module_init(smscore_module_init); -module_exit(smscore_module_exit); - -MODULE_DESCRIPTION("smscore"); -MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); -MODULE_LICENSE("GPL"); - diff --git a/linux/drivers/media/mdtv/smscoreapi.h b/linux/drivers/media/mdtv/smscoreapi.h deleted file mode 100644 index 9b50a9cff..000000000 --- a/linux/drivers/media/mdtv/smscoreapi.h +++ /dev/null @@ -1,546 +0,0 @@ -/* - * Driver for the Siano SMS10xx USB dongle - * - * Copyright (c) 2008 - * - * 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, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#ifndef __smscoreapi_h__ -#define __smscoreapi_h__ - -#include -#include -#include -#include -#include -#include - -#include "dmxdev.h" -#include "dvbdev.h" -#include "dvb_demux.h" -#include "dvb_frontend.h" - -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) -#include - -typedef struct mutex kmutex_t; - -#define kmutex_init(_p_) mutex_init(_p_) -#define kmutex_lock(_p_) mutex_lock(_p_) -#define kmutex_trylock(_p_) mutex_trylock(_p_) -#define kmutex_unlock(_p_) mutex_unlock(_p_) - -#else -#include - -typedef struct semaphore kmutex_t; - -#define kmutex_init(_p_) init_MUTEX(_p_) -#define kmutex_lock(_p_) down(_p_) -#define kmutex_trylock(_p_) (!down_trylock(_p_)) -#define kmutex_unlock(_p_) up(_p_) - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) -void *kzalloc(size_t size, int flags); -#endif -#endif // LINUX_VERSION - -#ifndef min -#define min(a,b) (((a) < (b)) ? (a) : (b)) -#endif - -#define SMS_ALLOC_ALIGNMENT 128 -#define SMS_DMA_ALIGNMENT 16 -#define SMS_ALIGN_ADDRESS(addr) ((((u32)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) - -#define SMS_DEVICE_FAMILY2 1 -#define SMS_ROM_NO_RESPONSE 2 -#define SMS_DEVICE_NOT_READY 0x8000000 - -typedef struct _smscore_device smscore_device_t; -typedef struct _smscore_client smscore_client_t; -typedef struct _smscore_buffer smscore_buffer_t; - -typedef int (*hotplug_t)(smscore_device_t *coredev, struct device *device, int arrival); - -typedef int (*setmode_t)(void *context, int mode); -typedef void (*detectmode_t)(void *context, int *mode); -typedef int (*sendrequest_t)(void *context, void *buffer, size_t size); -typedef int (*loadfirmware_t)(void *context, void *buffer, size_t size); -typedef int (*preload_t)(void *context); -typedef int (*postload_t)(void *context); - -typedef int (*onresponse_t)(void *context, smscore_buffer_t *cb); -typedef void (*onremove_t)(void *context); - -typedef struct _smscore_buffer -{ - // public members, once passed to clients can be changed freely - struct list_head entry; - int size; - int offset; - - // private members, read-only for clients - void *p; - dma_addr_t phys; - unsigned long offset_in_common; -} *psmscore_buffer_t; - -typedef struct _smsdevice_params -{ - struct device *device; - - int buffer_size; - int num_buffers; - - char devpath[32]; - unsigned long flags; - - setmode_t setmode_handler; - detectmode_t detectmode_handler; - sendrequest_t sendrequest_handler; - preload_t preload_handler; - postload_t postload_handler; - - void *context; -} smsdevice_params_t; - -typedef struct _smsclient_params -{ - int initial_id; - int data_type; - onresponse_t onresponse_handler; - onremove_t onremove_handler; - - void *context; -} smsclient_params_t; - -// GPIO definitions for antenna frequency domain control (SMS8021) -#define SMS_ANTENNA_GPIO_0 1 -#define SMS_ANTENNA_GPIO_1 0 - -#define BW_8_MHZ 0 -#define BW_7_MHZ 1 -#define BW_6_MHZ 2 -#define BW_5_MHZ 3 -#define BW_ISDBT_1SEG 4 -#define BW_ISDBT_3SEG 5 - -#define MSG_HDR_FLAG_SPLIT_MSG 4 - -#define MAX_GPIO_PIN_NUMBER 31 - -#define HIF_TASK 11 -#define SMS_HOST_LIB 150 -#define DVBT_BDA_CONTROL_MSG_ID 201 - -#define SMS_MAX_PAYLOAD_SIZE 240 -#define SMS_TUNE_TIMEOUT 500 - -#define MSG_SMS_GPIO_CONFIG_REQ 507 -#define MSG_SMS_GPIO_CONFIG_RES 508 -#define MSG_SMS_GPIO_SET_LEVEL_REQ 509 -#define MSG_SMS_GPIO_SET_LEVEL_RES 510 -#define MSG_SMS_GPIO_GET_LEVEL_REQ 511 -#define MSG_SMS_GPIO_GET_LEVEL_RES 512 -#define MSG_SMS_RF_TUNE_REQ 561 -#define MSG_SMS_RF_TUNE_RES 562 -#define MSG_SMS_INIT_DEVICE_REQ 578 -#define MSG_SMS_INIT_DEVICE_RES 579 -#define MSG_SMS_ADD_PID_FILTER_REQ 601 -#define MSG_SMS_ADD_PID_FILTER_RES 602 -#define MSG_SMS_REMOVE_PID_FILTER_REQ 603 -#define MSG_SMS_REMOVE_PID_FILTER_RES 604 -#define MSG_SMS_DAB_CHANNEL 607 -#define MSG_SMS_GET_PID_FILTER_LIST_REQ 608 -#define MSG_SMS_GET_PID_FILTER_LIST_RES 609 -#define MSG_SMS_GET_STATISTICS_REQ 615 -#define MSG_SMS_GET_STATISTICS_RES 616 -#define MSG_SMS_SET_ANTENNA_CONFIG_REQ 651 -#define MSG_SMS_SET_ANTENNA_CONFIG_RES 652 -#define MSG_SMS_GET_STATISTICS_EX_REQ 653 -#define MSG_SMS_GET_STATISTICS_EX_RES 654 -#define MSG_SMS_SLEEP_RESUME_COMP_IND 655 -#define MSG_SMS_DATA_DOWNLOAD_REQ 660 -#define MSG_SMS_DATA_DOWNLOAD_RES 661 -#define MSG_SMS_SWDOWNLOAD_TRIGGER_REQ 664 -#define MSG_SMS_SWDOWNLOAD_TRIGGER_RES 665 -#define MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ 666 -#define MSG_SMS_SWDOWNLOAD_BACKDOOR_RES 667 -#define MSG_SMS_GET_VERSION_EX_REQ 668 -#define MSG_SMS_GET_VERSION_EX_RES 669 -#define MSG_SMS_SET_CLOCK_OUTPUT_REQ 670 -#define MSG_SMS_I2C_SET_FREQ_REQ 685 -#define MSG_SMS_GENERIC_I2C_REQ 687 -#define MSG_SMS_GENERIC_I2C_RES 688 -#define MSG_SMS_DVBT_BDA_DATA 693 -#define MSG_SW_RELOAD_REQ 697 -#define MSG_SMS_DATA_MSG 699 -#define MSG_SW_RELOAD_START_REQ 702 -#define MSG_SW_RELOAD_START_RES 703 -#define MSG_SW_RELOAD_EXEC_REQ 704 -#define MSG_SW_RELOAD_EXEC_RES 705 -#define MSG_SMS_SPI_INT_LINE_SET_REQ 710 -#define MSG_SMS_ISDBT_TUNE_REQ 776 -#define MSG_SMS_ISDBT_TUNE_RES 777 - -#define SMS_INIT_MSG_EX(ptr, type, src, dst, len) do { \ - (ptr)->msgType = type; (ptr)->msgSrcId = src; (ptr)->msgDstId = dst; \ - (ptr)->msgLength = len; (ptr)->msgFlags = 0; \ -} while (0) -#define SMS_INIT_MSG(ptr, type, len) SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) - -typedef enum -{ - DEVICE_MODE_NONE = -1, - DEVICE_MODE_DVBT = 0, - DEVICE_MODE_DVBH, - DEVICE_MODE_DAB_TDMB, - DEVICE_MODE_DAB_TDMB_DABIP, - DEVICE_MODE_DVBT_BDA, - DEVICE_MODE_ISDBT, - DEVICE_MODE_ISDBT_BDA, - DEVICE_MODE_CMMB, - DEVICE_MODE_RAW_TUNER, - DEVICE_MODE_MAX, -} SMS_DEVICE_MODE; - -typedef unsigned char UINT8; -typedef unsigned short UINT16; -typedef unsigned int UINT32; -typedef int INT32; - -typedef struct SmsMsgHdr_S -{ - UINT16 msgType; - UINT8 msgSrcId; - UINT8 msgDstId; - UINT16 msgLength; // Length is of the entire message, including header - UINT16 msgFlags; -} SmsMsgHdr_ST; - -typedef struct SmsMsgData_S -{ - SmsMsgHdr_ST xMsgHeader; - UINT32 msgData[1]; -} SmsMsgData_ST; - -typedef struct SmsDataDownload_S -{ - SmsMsgHdr_ST xMsgHeader; - UINT32 MemAddr; - UINT8 Payload[SMS_MAX_PAYLOAD_SIZE]; -} SmsDataDownload_ST; - -typedef struct SmsVersionRes_S -{ - SmsMsgHdr_ST xMsgHeader; - - UINT16 ChipModel; // e.g. 0x1102 for SMS-1102 "Nova" - UINT8 Step; // 0 - Step A - UINT8 MetalFix; // 0 - Metal 0 - - UINT8 FirmwareId; // 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E - UINT8 SupportedProtocols; // Bitwise OR combination of supported protocols - - UINT8 VersionMajor; - UINT8 VersionMinor; - UINT8 VersionPatch; - UINT8 VersionFieldPatch; - - UINT8 RomVersionMajor; - UINT8 RomVersionMinor; - UINT8 RomVersionPatch; - UINT8 RomVersionFieldPatch; - - UINT8 TextLabel[34]; -} SmsVersionRes_ST; - -typedef struct SmsFirmware_S -{ - UINT32 CheckSum; - UINT32 Length; - UINT32 StartAddress; - UINT8 Payload[1]; -} SmsFirmware_ST; - -typedef struct SMSHOSTLIB_STATISTICS_S -{ - UINT32 Reserved; //!< Reserved - - /// Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - /// Reception quality - INT32 SNR; //!< dB - UINT32 BER; //!< Post Viterbi BER [1E-5] - UINT32 FIB_CRC; //!< CRC errors percentage, valid only for DAB - UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H - UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in bin/1024 - - /// Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz, valid only for DVB-T/H - UINT32 TransmissionMode; //!< Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos - UINT32 ModemState; //!< from SMS_DvbModemState_ET , valid only for DVB-T/H - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value , valid only for DVB-T/H - UINT32 CodeRate; //!< Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H - UINT32 LPCodeRate; //!< Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H - UINT32 Hierarchy; //!< Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H - UINT32 Constellation; //!< Constellation from SMS_Constellation_ET, valid only for DVB-T/H - - /// Burst parameters, valid only for DVB-H - UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H - UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H - UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H - UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H - UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H - UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H - UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding - UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding - UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding - /// Common params - UINT32 BERErrorCount; //!< Number of errornous SYNC bits. - UINT32 BERBitCount; //!< Total number of SYNC bits. - - /// Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - - /// DAB/T-DMB - UINT32 PreBER; //!< DAB/T-DMB only: Pre Viterbi BER [1E-5] - - /// DVB-H TPS parameters - UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered - -} SMSHOSTLIB_STATISTICS_ST; - -typedef struct -{ - UINT32 RequestResult; - - SMSHOSTLIB_STATISTICS_ST Stat; - - // Split the calc of the SNR in DAB - UINT32 Signal; //!< dB - UINT32 Noise; //!< dB - -} SmsMsgStatisticsInfo_ST; - -typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S -{ - // Per-layer information - UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist - UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist - UINT32 BER; //!< Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A - UINT32 BERErrorCount; //!< Post Viterbi Error Bits Count - UINT32 BERBitCount; //!< Post Viterbi Total Bits Count - UINT32 PreBER; //!< Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A - UINT32 TS_PER; //!< Transport stream PER [%], 0xFFFFFFFF indicate N/A - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 TILdepthI; //!< Time interleaver depth I parameter, 255 means layer does not exist - UINT32 NumberOfSegments; //!< Number of segments in layer A, 255 means layer does not exist - UINT32 TMCCErrors; //!< TMCC errors -} SMSHOSTLIB_ISDBT_LAYER_STAT_ST; - -typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S -{ - UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - //!< This fiels MUST always first in any statistics structure - - UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by - //!< the host is smaller than FullSize, the struct will be truncated - - // Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - // Reception quality - INT32 SNR; //!< dB - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in Hz - - // Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz - UINT32 TransmissionMode; //!< ISDB-T transmission mode - UINT32 ModemState; //!< 0 - Acquisition, 1 - Locked - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value - UINT32 SystemType; //!< ISDB-T system type (ISDB-T / ISDB-Tsb) - UINT32 PartialReception; //!< TRUE - partial reception, FALSE otherwise - UINT32 NumOfLayers; //!< Number of ISDB-T layers in the network - - // Per-layer information - // Layers A, B and C - SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; //!< Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST - - // Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - -} SMSHOSTLIB_STATISTICS_ISDBT_ST; - -typedef struct SMSHOSTLIB_STATISTICS_DVB_S -{ - UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - //!< This fiels MUST always first in any statistics structure - - UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by - //!< the host is smaller than FullSize, the struct will be truncated - // Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - // Reception quality - INT32 SNR; //!< dB - UINT32 BER; //!< Post Viterbi BER [1E-5] - UINT32 BERErrorCount; //!< Number of errornous SYNC bits. - UINT32 BERBitCount; //!< Total number of SYNC bits. - UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A - UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in bin/1024 - - // Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz - UINT32 ModemState; //!< from SMSHOSTLIB_DVB_MODEM_STATE_ET - UINT32 TransmissionMode; //!< FFT mode carriers in Kilos - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value - UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET - UINT32 LPCodeRate; //!< Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET - UINT32 Hierarchy; //!< Hierarchy from SMSHOSTLIB_HIERARCHY_ET - UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET - - // Burst parameters, valid only for DVB-H - UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H - UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H - UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H - UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H - UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H - UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H - UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H - UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H - UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H - UINT32 NumMPEReceived; //!< DVB-H, Num MPE section received - - // DVB-H TPS parameters - UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered - UINT32 DvbhSrvIndHP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator - UINT32 DvbhSrvIndLP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator - - // Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - -} SMSHOSTLIB_STATISTICS_DVB_ST; - -typedef struct SMSHOSTLIB_GPIO_CONFIG_S -{ - UINT8 Direction; //!< GPIO direction: Input - 0, Output - 1 - UINT8 PullUpDown; //!< PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 - UINT8 InputCharacteristics; //!< Input Characteristics: Normal - 0, Schmitt trigger - 1 - UINT8 OutputSlewRate; //!< Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 - UINT8 OutputDriving; //!< Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 -} SMSHOSTLIB_GPIO_CONFIG_ST; - -typedef struct SMSHOSTLIB_I2C_REQ_S -{ - UINT32 DeviceAddress; // I2c device address - UINT32 WriteCount; // number of bytes to write - UINT32 ReadCount; // number of bytes to read - UINT8 Data[1]; -} SMSHOSTLIB_I2C_REQ_ST; - -typedef struct SMSHOSTLIB_I2C_RES_S -{ - UINT32 Status; // non-zero value in case of failure - UINT32 ReadCount; // number of bytes read - UINT8 Data[1]; -} SMSHOSTLIB_I2C_RES_ST; - -typedef struct _smsdvb_client -{ - struct list_head entry; - - smscore_device_t *coredev; - smscore_client_t *smsclient; - - struct dvb_adapter adapter; - struct dvb_demux demux; - struct dmxdev dmxdev; - struct dvb_frontend frontend; - - fe_status_t fe_status; - int fe_ber, fe_snr, fe_signal_strength; - - struct completion tune_done, stat_done; - - // todo: save freq/band instead whole struct - struct dvb_frontend_parameters fe_params; - -} smsdvb_client_t; - -extern void smscore_registry_setmode(char *devpath, int mode); -extern int smscore_registry_getmode(char *devpath); - -extern int smscore_register_hotplug(hotplug_t hotplug); -extern void smscore_unregister_hotplug(hotplug_t hotplug); - -extern int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev); -extern void smscore_unregister_device(smscore_device_t *coredev); - -extern int smscore_start_device(smscore_device_t *coredev); -extern int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler); - -extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); -extern int smscore_get_device_mode(smscore_device_t *coredev); - -extern int smscore_register_client(smscore_device_t *coredev, smsclient_params_t* params, smscore_client_t **client); -extern void smscore_unregister_client(smscore_client_t *client); - -extern int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size); -extern void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb); - -extern int smscore_get_common_buffer_size(smscore_device_t *coredev); -extern int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma); - -extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); -extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); - -/* smsdvb.c */ -int smsdvb_register(void); -void smsdvb_unregister(void); - -/* smsusb.c */ -int smsusb_register(void); -void smsusb_unregister(void); - -#endif // __smscoreapi_h__ diff --git a/linux/drivers/media/mdtv/smsdvb.c b/linux/drivers/media/mdtv/smsdvb.c deleted file mode 100644 index f56658c55..000000000 --- a/linux/drivers/media/mdtv/smsdvb.c +++ /dev/null @@ -1,425 +0,0 @@ -/* - * Driver for the Siano SMS10xx USB dongle - * - * Copyright (c) 2008 - * - * 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, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include -#include - -#include "smscoreapi.h" - -DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); - -struct list_head g_smsdvb_clients; -kmutex_t g_smsdvb_clientslock; - -int smsdvb_onresponse(void *context, smscore_buffer_t *cb) -{ - smsdvb_client_t *client = (smsdvb_client_t *) context; - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8*) cb->p) + cb->offset); - - switch(phdr->msgType) - { - case MSG_SMS_DVBT_BDA_DATA: - dvb_dmx_swfilter(&client->demux, (u8*)(phdr + 1), cb->size - sizeof(SmsMsgHdr_ST)); - break; - - case MSG_SMS_RF_TUNE_RES: - complete(&client->tune_done); - break; - - case MSG_SMS_GET_STATISTICS_RES: - { - SmsMsgStatisticsInfo_ST* p = (SmsMsgStatisticsInfo_ST*)(phdr + 1); - - if (p->Stat.IsDemodLocked) - { - client->fe_status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK; - client->fe_snr = p->Stat.SNR; - client->fe_ber = p->Stat.BER; - - if (p->Stat.InBandPwr < -95) - client->fe_signal_strength = 0; - else if (p->Stat.InBandPwr > -29) - client->fe_signal_strength = 100; - else - client->fe_signal_strength = (p->Stat.InBandPwr + 95) * 3 / 2; - } - else - { - client->fe_status = 0; - client->fe_snr = - client->fe_ber = - client->fe_signal_strength = 0; - } - - complete(&client->stat_done); - break; - } - } - - smscore_putbuffer(client->coredev, cb); - - return 0; -} - -void smsdvb_unregister_client(smsdvb_client_t* client) -{ - // must be called under clientslock - - list_del(&client->entry); - - smscore_unregister_client(client->smsclient); - dvb_unregister_frontend(&client->frontend); - dvb_dmxdev_release(&client->dmxdev); - dvb_dmx_release(&client->demux); - dvb_unregister_adapter(&client->adapter); - kfree(client); -} - -void smsdvb_onremove(void *context) -{ - kmutex_lock(&g_smsdvb_clientslock); - - smsdvb_unregister_client((smsdvb_client_t*) context); - - kmutex_unlock(&g_smsdvb_clientslock); -} - -static int smsdvb_start_feed(struct dvb_demux_feed *feed) -{ - smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); - SmsMsgData_ST PidMsg; - - printk("%s add pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); - - PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; - PidMsg.xMsgHeader.msgDstId = HIF_TASK; - PidMsg.xMsgHeader.msgFlags = 0; - PidMsg.xMsgHeader.msgType = MSG_SMS_ADD_PID_FILTER_REQ; - PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); - PidMsg.msgData[0] = feed->pid; - - return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); -} - -static int smsdvb_stop_feed(struct dvb_demux_feed *feed) -{ - smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); - SmsMsgData_ST PidMsg; - - printk("%s remove pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); - - PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; - PidMsg.xMsgHeader.msgDstId = HIF_TASK; - PidMsg.xMsgHeader.msgFlags = 0; - PidMsg.xMsgHeader.msgType = MSG_SMS_REMOVE_PID_FILTER_REQ; - PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); - PidMsg.msgData[0] = feed->pid; - - return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); -} - -static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, void* buffer, size_t size, struct completion *completion) -{ - int rc = smsclient_sendrequest(client->smsclient, buffer, size); - if (rc < 0) - return rc; - - return wait_for_completion_timeout(completion, msecs_to_jiffies(2000)) ? 0 : -ETIME; -} - -static int smsdvb_send_statistics_request(smsdvb_client_t *client) -{ - SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, DVBT_BDA_CONTROL_MSG_ID, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; - return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->stat_done); -} - -static int smsdvb_read_status(struct dvb_frontend *fe, fe_status_t *stat) -{ - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - int rc = smsdvb_send_statistics_request(client); - - if (!rc) - *stat = client->fe_status; - - return rc; -} - -static int smsdvb_read_ber(struct dvb_frontend *fe, u32 *ber) -{ - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - int rc = smsdvb_send_statistics_request(client); - - if (!rc) - *ber = client->fe_ber; - - return rc; -} - -static int smsdvb_read_signal_strength(struct dvb_frontend *fe, u16 *strength) -{ - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - int rc = smsdvb_send_statistics_request(client); - - if (!rc) - *strength = client->fe_signal_strength; - - return rc; -} - -static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) -{ - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - int rc = smsdvb_send_statistics_request(client); - - if (!rc) - *snr = client->fe_snr; - - return rc; -} - -static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) -{ - printk("%s\n", __FUNCTION__); - - tune->min_delay_ms = 400; - tune->step_size = 250000; - tune->max_drift = 0; - return 0; -} - -static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) -{ - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - - struct - { - SmsMsgHdr_ST Msg; - u32 Data[3]; - } Msg; - - Msg.Msg.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; - Msg.Msg.msgDstId = HIF_TASK; - Msg.Msg.msgFlags = 0; - Msg.Msg.msgType = MSG_SMS_RF_TUNE_REQ; - Msg.Msg.msgLength = sizeof(Msg); - Msg.Data[0] = fep->frequency; - Msg.Data[2] = 12000000; - - printk("%s freq %d band %d\n", __FUNCTION__, fep->frequency, fep->u.ofdm.bandwidth); - - switch(fep->u.ofdm.bandwidth) - { - case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; - case BANDWIDTH_7_MHZ: Msg.Data[1] = BW_7_MHZ; break; - case BANDWIDTH_6_MHZ: Msg.Data[1] = BW_6_MHZ; break; -// case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; - case BANDWIDTH_AUTO: return -EOPNOTSUPP; - default: return -EINVAL; - } - - return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->tune_done); -} - -static int smsdvb_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) -{ - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - - printk("%s\n", __FUNCTION__); - - // todo: - memcpy(fep, &client->fe_params, sizeof(struct dvb_frontend_parameters)); - return 0; -} - -static void smsdvb_release(struct dvb_frontend *fe) -{ - // do nothing -} - -static struct dvb_frontend_ops smsdvb_fe_ops = { - .info = { - .name = "Siano Mobile Digital SMS10xx", - .type = FE_OFDM, - .frequency_min = 44250000, - .frequency_max = 867250000, - .frequency_stepsize = 250000, - .caps = FE_CAN_INVERSION_AUTO | - FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | - FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | - FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO | - FE_CAN_TRANSMISSION_MODE_AUTO | - FE_CAN_GUARD_INTERVAL_AUTO | - FE_CAN_RECOVER | - FE_CAN_HIERARCHY_AUTO, - }, - - .release = smsdvb_release, - - .set_frontend = smsdvb_set_frontend, - .get_frontend = smsdvb_get_frontend, - .get_tune_settings = smsdvb_get_tune_settings, - - .read_status = smsdvb_read_status, - .read_ber = smsdvb_read_ber, - .read_signal_strength = smsdvb_read_signal_strength, - .read_snr = smsdvb_read_snr, -}; - -int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival) -{ - smsclient_params_t params; - smsdvb_client_t* client; - int rc; - - // device removal handled by onremove callback - if (!arrival) - return 0; - - if (smscore_get_device_mode(coredev) != 4) - { - rc = smscore_set_device_mode(coredev, 4); - if (rc < 0) - return rc; - } - - client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); - if (!client) - { - printk(KERN_INFO "%s kmalloc() failed\n", __FUNCTION__); - return -ENOMEM; - } - - // register dvb adapter - rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device, adapter_nr); - if (rc < 0) - { - printk("%s dvb_register_adapter() failed %d\n", __func__, rc); - goto adapter_error; - } - - // init dvb demux - client->demux.dmx.capabilities = DMX_TS_FILTERING; - client->demux.filternum = 32; // todo: nova ??? - client->demux.feednum = 32; - client->demux.start_feed = smsdvb_start_feed; - client->demux.stop_feed = smsdvb_stop_feed; - - rc = dvb_dmx_init(&client->demux); - if (rc < 0) - { - printk("%s dvb_dmx_init failed %d\n\n", __FUNCTION__, rc); - goto dvbdmx_error; - } - - // init dmxdev - client->dmxdev.filternum = 32; - client->dmxdev.demux = &client->demux.dmx; - client->dmxdev.capabilities = 0; - - rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); - if (rc < 0) - { - printk("%s dvb_dmxdev_init failed %d\n", __FUNCTION__, rc); - goto dmxdev_error; - } - - // init and register frontend - memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); - - rc = dvb_register_frontend(&client->adapter, &client->frontend); - if (rc < 0) - { - printk("%s frontend registration failed %d\n", __FUNCTION__, rc); - goto frontend_error; - } - - params.initial_id = 0; - params.data_type = MSG_SMS_DVBT_BDA_DATA; - params.onresponse_handler = smsdvb_onresponse; - params.onremove_handler = smsdvb_onremove; - params.context = client; - - rc = smscore_register_client(coredev, ¶ms, &client->smsclient); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_register_client() failed %d\n", __FUNCTION__, rc); - goto client_error; - } - - client->coredev = coredev; - - init_completion(&client->tune_done); - init_completion(&client->stat_done); - - kmutex_lock(&g_smsdvb_clientslock); - - list_add(&client->entry, &g_smsdvb_clients); - - kmutex_unlock(&g_smsdvb_clientslock); - - printk(KERN_INFO "%s success\n", __FUNCTION__); - - return 0; - -client_error: - dvb_unregister_frontend(&client->frontend); - -frontend_error: - dvb_dmxdev_release(&client->dmxdev); - -dmxdev_error: - dvb_dmx_release(&client->demux); - -dvbdmx_error: - dvb_unregister_adapter(&client->adapter); - -adapter_error: - kfree(client); - return rc; -} - -int smsdvb_register(void) -{ - int rc; - - INIT_LIST_HEAD(&g_smsdvb_clients); - kmutex_init(&g_smsdvb_clientslock); - - rc = smscore_register_hotplug(smsdvb_hotplug); - - printk(KERN_INFO "%s\n", __FUNCTION__); - - return rc; -} - -void smsdvb_unregister(void) -{ - smscore_unregister_hotplug(smsdvb_hotplug); - - kmutex_lock(&g_smsdvb_clientslock); - - while (!list_empty(&g_smsdvb_clients)) - smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); - - kmutex_unlock(&g_smsdvb_clientslock); - -} - diff --git a/linux/drivers/media/mdtv/smsusb.c b/linux/drivers/media/mdtv/smsusb.c deleted file mode 100644 index fd7e3eb55..000000000 --- a/linux/drivers/media/mdtv/smsusb.c +++ /dev/null @@ -1,440 +0,0 @@ -/* - * Driver for the Siano SMS10xx USB dongle - * - * Copyright (c) 2008 - * - * 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, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include -#include -#include -#include - -#include "smscoreapi.h" - -#define USB1_BUFFER_SIZE 0x1000 -#define USB2_BUFFER_SIZE 0x4000 - -#define MAX_BUFFERS 50 -#define MAX_URBS 10 - -typedef struct _smsusb_device smsusb_device_t; - -typedef struct _smsusb_urb -{ - smscore_buffer_t *cb; - smsusb_device_t *dev; - - struct urb urb; -} smsusb_urb_t; - -typedef struct _smsusb_device -{ - struct usb_device* udev; - smscore_device_t *coredev; - - smsusb_urb_t surbs[MAX_URBS]; - - int response_alignment; - int buffer_size; -} *psmsusb_device_t; - -int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb); - -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) -void smsusb_onresponse(struct urb *urb) -#else -void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) -#endif -{ - smsusb_urb_t *surb = (smsusb_urb_t *) urb->context; - smsusb_device_t *dev = surb->dev; - - if (urb->status < 0) - { - printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __FUNCTION__, urb->status, urb->actual_length); - return; - } - - if (urb->actual_length > 0) - { - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) surb->cb->p; - - if (urb->actual_length >= phdr->msgLength) - { - surb->cb->size = phdr->msgLength; - - if (dev->response_alignment && (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) - { - surb->cb->offset = dev->response_alignment + ((phdr->msgFlags >> 8) & 3); - - // sanity check - if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) - { - printk("%s: invalid response msglen %d offset %d size %d\n", __FUNCTION__, phdr->msgLength, surb->cb->offset, urb->actual_length); - goto exit_and_resubmit; - } - - // move buffer pointer and copy header to its new location - memcpy((char*) phdr + surb->cb->offset, phdr, sizeof(SmsMsgHdr_ST)); - } - else - surb->cb->offset = 0; - - smscore_onresponse(dev->coredev, surb->cb); - surb->cb = NULL; - } - else - { - printk("%s invalid response msglen %d actual %d\n", __FUNCTION__, phdr->msgLength, urb->actual_length); - } - } - -exit_and_resubmit: - smsusb_submit_urb(dev, surb); -} - -int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb) -{ - if (!surb->cb) - { - surb->cb = smscore_getbuffer(dev->coredev); - if (!surb->cb) - { - printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __FUNCTION__); - return -ENOMEM; - } - } - - usb_fill_bulk_urb( - &surb->urb, - dev->udev, - usb_rcvbulkpipe(dev->udev, 0x81), - surb->cb->p, - dev->buffer_size, - smsusb_onresponse, - surb - ); - surb->urb.transfer_dma = surb->cb->phys; - surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - - return usb_submit_urb(&surb->urb, GFP_ATOMIC); -} - -void smsusb_stop_streaming(smsusb_device_t* dev) -{ - int i; - - for (i = 0; i < MAX_URBS; i ++) - { - usb_kill_urb(&dev->surbs[i].urb); - - if (dev->surbs[i].cb) - { - smscore_putbuffer(dev->coredev, dev->surbs[i].cb); - dev->surbs[i].cb = NULL; - } - } -} - -int smsusb_start_streaming(smsusb_device_t* dev) -{ - int i, rc; - - for (i = 0; i < MAX_URBS; i ++) - { - rc = smsusb_submit_urb(dev, &dev->surbs[i]); - if (rc < 0) - { - printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __FUNCTION__); - smsusb_stop_streaming(dev); - break; - } - } - - return rc; -} - -int smsusb_sendrequest(void *context, void *buffer, size_t size) -{ - smsusb_device_t* dev = (smsusb_device_t*) context; - int dummy; - - return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buffer, size, &dummy, 1000); -} - -char *smsusb1_fw_lkup[] = -{ - "dvbt_stellar_usb.inp", - "dvbh_stellar_usb.inp", - "tdmb_stellar_usb.inp", - "none", - "dvbt_bda_stellar_usb.inp", -}; - -int smsusb1_load_firmware(struct usb_device *udev, int id) -{ - const struct firmware *fw; - u8* fw_buffer; - int rc, dummy; - - if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) - { - printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, id); - return -EINVAL; - } - - rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); - if (rc < 0) - { - printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __FUNCTION__, smsusb1_fw_lkup[id], id); - return rc; - } - - fw_buffer = kmalloc(fw->size, GFP_KERNEL); - if (fw_buffer) - { - memcpy(fw_buffer, fw->data, fw->size); - - rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); - - printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __FUNCTION__, fw->size, dummy, rc); - - kfree(fw_buffer); - } - else - { - printk(KERN_INFO "failed to allocate firmware buffer\n"); - rc = -ENOMEM; - } - - release_firmware(fw); - - return rc; -} - -void smsusb1_detectmode(void *context, int *mode) -{ - char *product_string = ((smsusb_device_t *) context)->udev->product; - - *mode = DEVICE_MODE_NONE; - - if (!product_string) - { - product_string = "none"; - printk("%s product string not found\n", __FUNCTION__); - } - else - { - if (strstr(product_string, "DVBH")) - *mode = 1; - else if (strstr(product_string, "BDA")) - *mode = 4; - else if (strstr(product_string, "DVBT")) - *mode = 0; - else if (strstr(product_string, "TDMB")) - *mode = 2; - } - - printk("%s: %d \"%s\"\n", __FUNCTION__, *mode, product_string); -} - -int smsusb1_setmode(void *context, int mode) -{ - SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; - - if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) - { - printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, mode); - return -EINVAL; - } - - return smsusb_sendrequest(context, &Msg, sizeof(Msg)); -} - -void smsusb_term_device(struct usb_interface *intf) -{ - smsusb_device_t *dev = (smsusb_device_t*) usb_get_intfdata(intf); - - if (dev) - { - smsusb_stop_streaming(dev); - - // unregister from smscore - if (dev->coredev) - smscore_unregister_device(dev->coredev); - - kfree(dev); - - printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, dev); - } - - usb_set_intfdata(intf, NULL); -} - -int smsusb_init_device(struct usb_interface *intf) -{ - smsdevice_params_t params; - smsusb_device_t* dev; - int i, rc; - - // create device object - dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); - if (!dev) - { - printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __FUNCTION__); - return -ENOMEM; - } - - memset(¶ms, 0, sizeof(params)); - usb_set_intfdata(intf, dev); - dev->udev = interface_to_usbdev(intf); - - switch (dev->udev->descriptor.idProduct) - { - case 0x100: - dev->buffer_size = USB1_BUFFER_SIZE; - - params.setmode_handler = smsusb1_setmode; - params.detectmode_handler = smsusb1_detectmode; - break; - - default: - dev->buffer_size = USB2_BUFFER_SIZE; - dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST); - - params.flags |= SMS_DEVICE_FAMILY2; - break; - } - - params.device = &dev->udev->dev; - params.buffer_size = dev->buffer_size; - params.num_buffers = MAX_BUFFERS; - params.sendrequest_handler = smsusb_sendrequest; - params.context = dev; - snprintf(params.devpath, sizeof(params.devpath), "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath); - - // register in smscore - rc = smscore_register_device(¶ms, &dev->coredev); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __FUNCTION__, rc); - smsusb_term_device(intf); - return rc; - } - - // initialize urbs - for (i = 0; i < MAX_URBS; i ++) - { - dev->surbs[i].dev = dev; - usb_init_urb(&dev->surbs[i].urb); - } - - rc = smsusb_start_streaming(dev); - if (rc < 0) - { - printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __FUNCTION__); - smsusb_term_device(intf); - return rc; - } - - rc = smscore_start_device(dev->coredev); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_start_device(...) failed\n", __FUNCTION__); - smsusb_term_device(intf); - return rc; - } - - printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); - - return rc; -} - -int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) -{ - struct usb_device *udev = interface_to_usbdev(intf); - char devpath[32]; - int i, rc; - - if (intf->num_altsetting > 0) - { - rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); - if (rc < 0) - { - printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __FUNCTION__, rc); - return rc; - } - } - - printk(KERN_INFO "smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber); - for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i ++) - printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); - - if (udev->actconfig->desc.bNumInterfaces == 2 && intf->cur_altsetting->desc.bInterfaceNumber == 0) - { - printk(KERN_INFO "rom interface 0 is not used\n"); - return -ENODEV; - } - - if (intf->cur_altsetting->desc.bInterfaceNumber == 1) - { - snprintf(devpath, 32, "%d:%s", udev->bus->busnum, udev->devpath); - return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath)); - } - - return smsusb_init_device(intf); -} - -void smsusb_disconnect(struct usb_interface *intf) -{ - smsusb_term_device(intf); -} - -static struct usb_device_id smsusb_id_table [] = { - { USB_DEVICE(0x187F, 0x0010) }, - { USB_DEVICE(0x187F, 0x0100) }, - { USB_DEVICE(0x187F, 0x0200) }, - { } /* Terminating entry */ -}; -MODULE_DEVICE_TABLE (usb, smsusb_id_table); - -static struct usb_driver smsusb_driver = { - .name = "smsusb", - .probe = smsusb_probe, - .disconnect = smsusb_disconnect, - .id_table = smsusb_id_table, -}; - -int smsusb_register(void) -{ - int rc = usb_register(&smsusb_driver); - if (rc) - printk(KERN_INFO "usb_register failed. Error number %d\n", rc); - - printk(KERN_INFO "%s\n", __FUNCTION__); - - return rc; -} - -void smsusb_unregister(void) -{ - /* Regular USB Cleanup */ - usb_deregister(&smsusb_driver); - printk(KERN_INFO "%s\n", __FUNCTION__); -} - -- cgit v1.2.3 From 32e8b4c72809199a56de825ee3cd349e1716d558 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:30:17 -0400 Subject: sms1xxx: replace __FUNCTION__ with __func__ From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 56 +++++++++++++++--------------- linux/drivers/media/dvb/siano/smsdvb.c | 24 ++++++------- linux/drivers/media/dvb/siano/smsusb.c | 40 ++++++++++----------- 3 files changed, 60 insertions(+), 60 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index b3f2c7866..bd2743078 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -332,7 +332,7 @@ smscore_buffer_t *smscore_createbuffer(u8* buffer, void* common_buffer, dma_addr smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); if (!cb) { - printk(KERN_INFO "%s kmalloc(...) failed\n", __FUNCTION__); + printk(KERN_INFO "%s kmalloc(...) failed\n", __func__); return NULL; } @@ -360,7 +360,7 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); if (!dev) { - printk(KERN_INFO "%s kzalloc(...) failed\n", __FUNCTION__); + printk(KERN_INFO "%s kzalloc(...) failed\n", __func__); return -ENOMEM; } @@ -406,7 +406,7 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored smscore_putbuffer(dev, cb); } - printk(KERN_INFO "%s allocated %d buffers\n", __FUNCTION__, dev->num_buffers); + printk(KERN_INFO "%s allocated %d buffers\n", __func__, dev->num_buffers); dev->mode = DEVICE_MODE_NONE; dev->context = params->context; @@ -427,7 +427,7 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored *coredev = dev; - printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); + printk(KERN_INFO "%s device %p created\n", __func__, dev); return 0; } @@ -449,7 +449,7 @@ int smscore_start_device(smscore_device_t *coredev) rc = smscore_notify_callbacks(coredev, coredev->device, 1); - printk(KERN_INFO "%s device %p started, rc %d\n", __FUNCTION__, coredev, rc); + printk(KERN_INFO "%s device %p started, rc %d\n", __func__, coredev, rc); kmutex_unlock(&g_smscore_deviceslock); @@ -574,7 +574,7 @@ int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmwar rc = request_firmware(&fw, filename, coredev->device); if (rc < 0) { - printk(KERN_INFO "%s failed to open \"%s\"\n", __FUNCTION__, filename); + printk(KERN_INFO "%s failed to open \"%s\"\n", __func__, filename); return rc; } @@ -591,7 +591,7 @@ int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmwar } else { - printk(KERN_INFO "%s failed to allocate firmware buffer\n", __FUNCTION__); + printk(KERN_INFO "%s failed to allocate firmware buffer\n", __func__); rc = -ENOMEM; } @@ -632,11 +632,11 @@ void smscore_unregister_device(smscore_device_t *coredev) if (num_buffers == coredev->num_buffers) break; - printk(KERN_INFO "%s waiting for %d buffer(s)\n", __FUNCTION__, coredev->num_buffers - num_buffers); + printk(KERN_INFO "%s waiting for %d buffer(s)\n", __func__, coredev->num_buffers - num_buffers); msleep(100); } - printk(KERN_INFO "%s freed %d buffers\n", __FUNCTION__, num_buffers); + printk(KERN_INFO "%s freed %d buffers\n", __func__, num_buffers); if (coredev->common_buffer) dma_free_coherent(NULL, coredev->common_buffer_size, coredev->common_buffer, coredev->common_buffer_phys); @@ -646,7 +646,7 @@ void smscore_unregister_device(smscore_device_t *coredev) kmutex_unlock(&g_smscore_deviceslock); - printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, coredev); + printk(KERN_INFO "%s device %p destroyed\n", __func__, coredev); } int smscore_detect_mode(smscore_device_t *coredev) @@ -663,14 +663,14 @@ int smscore_detect_mode(smscore_device_t *coredev) rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc == -ETIME) { - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __FUNCTION__); + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __func__); if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) { rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc < 0) { - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __FUNCTION__, rc); + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __func__, rc); } } else @@ -713,7 +713,7 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) { - printk(KERN_INFO "%s invalid mode specified %d\n", __FUNCTION__, mode); + printk(KERN_INFO "%s invalid mode specified %d\n", __func__, mode); return -EINVAL; } @@ -726,7 +726,7 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) if (coredev->mode == mode) { - printk(KERN_INFO "%s device mode %d already set\n", __FUNCTION__, mode); + printk(KERN_INFO "%s device mode %d already set\n", __func__, mode); return 0; } @@ -738,7 +738,7 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) } else { - printk(KERN_INFO "%s mode %d supported by running firmware\n", __FUNCTION__, mode); + printk(KERN_INFO "%s mode %d supported by running firmware\n", __func__, mode); } buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); @@ -885,7 +885,7 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) case MSG_SMS_GET_VERSION_EX_RES: { SmsVersionRes_ST *ver = (SmsVersionRes_ST*) phdr; - printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d prots 0x%x ver %d.%d\n", __FUNCTION__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); + printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d prots 0x%x ver %d.%d\n", __func__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; coredev->modes_supported = ver->SupportedProtocols; @@ -895,12 +895,12 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) } case MSG_SMS_INIT_DEVICE_RES: - printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __FUNCTION__); + printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __func__); complete(&coredev->init_device_done); break; case MSG_SW_RELOAD_START_RES: - printk("%s: MSG_SW_RELOAD_START_RES\n", __FUNCTION__); + printk("%s: MSG_SW_RELOAD_START_RES\n", __func__); complete(&coredev->reload_start_done); break; @@ -909,11 +909,11 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) break; case MSG_SW_RELOAD_EXEC_RES: - printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __FUNCTION__); + printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __func__); break; case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __FUNCTION__); + printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __func__); complete(&coredev->trigger_done); break; @@ -922,7 +922,7 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) break; default: - printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __FUNCTION__, client, rc, phdr->msgType, phdr->msgDstId); + printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __func__, client, rc, phdr->msgType, phdr->msgDstId); } smscore_putbuffer(coredev, cb); @@ -1037,7 +1037,7 @@ int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *param *client = newclient; - printk(KERN_INFO "%s %p %d %d\n", __FUNCTION__, params->context, params->data_type, params->initial_id); + printk(KERN_INFO "%s %p %d %d\n", __func__, params->context, params->data_type, params->initial_id); return 0; } @@ -1070,7 +1070,7 @@ void smscore_unregister_client(smscore_client_t *client) } } - printk(KERN_INFO "%s %p %d\n", __FUNCTION__, client->context, client->data_type); + printk(KERN_INFO "%s %p %d\n", __func__, client->context, client->data_type); list_del(&client->entry); kfree(client); @@ -1127,13 +1127,13 @@ int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) { - printk(KERN_INFO "%s invalid vm flags\n", __FUNCTION__); + printk(KERN_INFO "%s invalid vm flags\n", __func__); return -EINVAL; } if ((end - start) != size) { - printk(KERN_INFO "%s invalid size %d expected %d\n", __FUNCTION__, (int)(end - start), (int) size); + printk(KERN_INFO "%s invalid size %d expected %d\n", __func__, (int)(end - start), (int) size); return -EINVAL; } @@ -1143,7 +1143,7 @@ int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) #endif { - printk(KERN_INFO "%s remap_page_range failed\n", __FUNCTION__); + printk(KERN_INFO "%s remap_page_range failed\n", __func__); return -EAGAIN; } @@ -1167,7 +1167,7 @@ int smscore_module_init(void) /* DVB Register */ rc = smsdvb_register(); - printk(KERN_INFO "%s, rc %d\n", __FUNCTION__, rc); + printk(KERN_INFO "%s, rc %d\n", __func__, rc); return rc; } @@ -1201,7 +1201,7 @@ void smscore_module_exit(void) /* Unregister USB */ smsusb_unregister(); - printk(KERN_INFO "%s\n", __FUNCTION__); + printk(KERN_INFO "%s\n", __func__); } module_init(smscore_module_init); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index e1a14a812..1a75033c3 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -107,7 +107,7 @@ static int smsdvb_start_feed(struct dvb_demux_feed *feed) smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); SmsMsgData_ST PidMsg; - printk("%s add pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); + printk("%s add pid %d(%x)\n", __func__, feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; PidMsg.xMsgHeader.msgDstId = HIF_TASK; @@ -124,7 +124,7 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); SmsMsgData_ST PidMsg; - printk("%s remove pid %d(%x)\n", __FUNCTION__, feed->pid, feed->pid); + printk("%s remove pid %d(%x)\n", __func__, feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; PidMsg.xMsgHeader.msgDstId = HIF_TASK; @@ -197,7 +197,7 @@ static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) { - printk("%s\n", __FUNCTION__); + printk("%s\n", __func__); tune->min_delay_ms = 400; tune->step_size = 250000; @@ -223,7 +223,7 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_para Msg.Data[0] = fep->frequency; Msg.Data[2] = 12000000; - printk("%s freq %d band %d\n", __FUNCTION__, fep->frequency, fep->u.ofdm.bandwidth); + printk("%s freq %d band %d\n", __func__, fep->frequency, fep->u.ofdm.bandwidth); switch(fep->u.ofdm.bandwidth) { @@ -242,7 +242,7 @@ static int smsdvb_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_para { smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - printk("%s\n", __FUNCTION__); + printk("%s\n", __func__); // todo: memcpy(fep, &client->fe_params, sizeof(struct dvb_frontend_parameters)); @@ -303,7 +303,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); if (!client) { - printk(KERN_INFO "%s kmalloc() failed\n", __FUNCTION__); + printk(KERN_INFO "%s kmalloc() failed\n", __func__); return -ENOMEM; } @@ -325,7 +325,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival rc = dvb_dmx_init(&client->demux); if (rc < 0) { - printk("%s dvb_dmx_init failed %d\n\n", __FUNCTION__, rc); + printk("%s dvb_dmx_init failed %d\n\n", __func__, rc); goto dvbdmx_error; } @@ -337,7 +337,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { - printk("%s dvb_dmxdev_init failed %d\n", __FUNCTION__, rc); + printk("%s dvb_dmxdev_init failed %d\n", __func__, rc); goto dmxdev_error; } @@ -347,7 +347,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { - printk("%s frontend registration failed %d\n", __FUNCTION__, rc); + printk("%s frontend registration failed %d\n", __func__, rc); goto frontend_error; } @@ -360,7 +360,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { - printk(KERN_INFO "%s smscore_register_client() failed %d\n", __FUNCTION__, rc); + printk(KERN_INFO "%s smscore_register_client() failed %d\n", __func__, rc); goto client_error; } @@ -375,7 +375,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival kmutex_unlock(&g_smsdvb_clientslock); - printk(KERN_INFO "%s success\n", __FUNCTION__); + printk(KERN_INFO "%s success\n", __func__); return 0; @@ -405,7 +405,7 @@ int smsdvb_register(void) rc = smscore_register_hotplug(smsdvb_hotplug); - printk(KERN_INFO "%s\n", __FUNCTION__); + printk(KERN_INFO "%s\n", __func__); return rc; } diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index b0bf8ac1a..8aff377c4 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -66,7 +66,7 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) if (urb->status < 0) { - printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __FUNCTION__, urb->status, urb->actual_length); + printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __func__, urb->status, urb->actual_length); return; } @@ -85,7 +85,7 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) // sanity check if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) { - printk("%s: invalid response msglen %d offset %d size %d\n", __FUNCTION__, phdr->msgLength, surb->cb->offset, urb->actual_length); + printk("%s: invalid response msglen %d offset %d size %d\n", __func__, phdr->msgLength, surb->cb->offset, urb->actual_length); goto exit_and_resubmit; } @@ -100,7 +100,7 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) } else { - printk("%s invalid response msglen %d actual %d\n", __FUNCTION__, phdr->msgLength, urb->actual_length); + printk("%s invalid response msglen %d actual %d\n", __func__, phdr->msgLength, urb->actual_length); } } @@ -115,7 +115,7 @@ int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb) surb->cb = smscore_getbuffer(dev->coredev); if (!surb->cb) { - printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __FUNCTION__); + printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __func__); return -ENOMEM; } } @@ -160,7 +160,7 @@ int smsusb_start_streaming(smsusb_device_t* dev) rc = smsusb_submit_urb(dev, &dev->surbs[i]); if (rc < 0) { - printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __FUNCTION__); + printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __func__); smsusb_stop_streaming(dev); break; } @@ -194,14 +194,14 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) { - printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, id); + printk(KERN_INFO "%s invalid firmware id specified %d\n", __func__, id); return -EINVAL; } rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); if (rc < 0) { - printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __FUNCTION__, smsusb1_fw_lkup[id], id); + printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __func__, smsusb1_fw_lkup[id], id); return rc; } @@ -212,7 +212,7 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); - printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __FUNCTION__, fw->size, dummy, rc); + printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __func__, fw->size, dummy, rc); kfree(fw_buffer); } @@ -236,7 +236,7 @@ void smsusb1_detectmode(void *context, int *mode) if (!product_string) { product_string = "none"; - printk("%s product string not found\n", __FUNCTION__); + printk("%s product string not found\n", __func__); } else { @@ -250,7 +250,7 @@ void smsusb1_detectmode(void *context, int *mode) *mode = 2; } - printk("%s: %d \"%s\"\n", __FUNCTION__, *mode, product_string); + printk("%s: %d \"%s\"\n", __func__, *mode, product_string); } int smsusb1_setmode(void *context, int mode) @@ -259,7 +259,7 @@ int smsusb1_setmode(void *context, int mode) if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - printk(KERN_INFO "%s invalid firmware id specified %d\n", __FUNCTION__, mode); + printk(KERN_INFO "%s invalid firmware id specified %d\n", __func__, mode); return -EINVAL; } @@ -280,7 +280,7 @@ void smsusb_term_device(struct usb_interface *intf) kfree(dev); - printk(KERN_INFO "%s device %p destroyed\n", __FUNCTION__, dev); + printk(KERN_INFO "%s device %p destroyed\n", __func__, dev); } usb_set_intfdata(intf, NULL); @@ -296,7 +296,7 @@ int smsusb_init_device(struct usb_interface *intf) dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); if (!dev) { - printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __FUNCTION__); + printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __func__); return -ENOMEM; } @@ -332,7 +332,7 @@ int smsusb_init_device(struct usb_interface *intf) rc = smscore_register_device(¶ms, &dev->coredev); if (rc < 0) { - printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __FUNCTION__, rc); + printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __func__, rc); smsusb_term_device(intf); return rc; } @@ -347,7 +347,7 @@ int smsusb_init_device(struct usb_interface *intf) rc = smsusb_start_streaming(dev); if (rc < 0) { - printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __FUNCTION__); + printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __func__); smsusb_term_device(intf); return rc; } @@ -355,12 +355,12 @@ int smsusb_init_device(struct usb_interface *intf) rc = smscore_start_device(dev->coredev); if (rc < 0) { - printk(KERN_INFO "%s smscore_start_device(...) failed\n", __FUNCTION__); + printk(KERN_INFO "%s smscore_start_device(...) failed\n", __func__); smsusb_term_device(intf); return rc; } - printk(KERN_INFO "%s device %p created\n", __FUNCTION__, dev); + printk(KERN_INFO "%s device %p created\n", __func__, dev); return rc; } @@ -376,7 +376,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); if (rc < 0) { - printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __FUNCTION__, rc); + printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __func__, rc); return rc; } } @@ -426,7 +426,7 @@ int smsusb_register(void) if (rc) printk(KERN_INFO "usb_register failed. Error number %d\n", rc); - printk(KERN_INFO "%s\n", __FUNCTION__); + printk(KERN_INFO "%s\n", __func__); return rc; } @@ -435,6 +435,6 @@ void smsusb_unregister(void) { /* Regular USB Cleanup */ usb_deregister(&smsusb_driver); - printk(KERN_INFO "%s\n", __FUNCTION__); + printk(KERN_INFO "%s\n", __func__); } -- cgit v1.2.3 From 0f1a76fc2bd8cf2742ea855c345ea2d395195804 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 22 May 2008 14:32:40 -0400 Subject: sms1xxx: build cleanup after driver relocation From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/Kconfig | 14 -------------- linux/drivers/media/Makefile | 1 - 2 files changed, 15 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/Kconfig b/linux/drivers/media/Kconfig index e6a5879ea..7a7803b5d 100644 --- a/linux/drivers/media/Kconfig +++ b/linux/drivers/media/Kconfig @@ -115,20 +115,6 @@ source "drivers/media/radio/Kconfig" source "drivers/media/dvb/Kconfig" -# -# Mobile Digital TV devices (DVB-H, T-DMB, etc.) -# -menuconfig MDTV_ADAPTERS - bool "Mobile Digital TV adapter" - default y - -if MDTV_ADAPTERS - -source "drivers/media/mdtv/Kconfig" - -endif # MDTV_ADAPTERS - - config DAB boolean "DAB adapters" ---help--- diff --git a/linux/drivers/media/Makefile b/linux/drivers/media/Makefile index ec2102bcb..09a829d8a 100644 --- a/linux/drivers/media/Makefile +++ b/linux/drivers/media/Makefile @@ -6,4 +6,3 @@ obj-y += common/ video/ obj-$(CONFIG_VIDEO_DEV) += radio/ obj-$(CONFIG_DVB_CORE) += dvb/ -obj-$(CONFIG_MDTV_ADAPTERS) += mdtv/ \ No newline at end of file -- cgit v1.2.3 From 57f76e3bf19a6b6c01191b072729b6f0b2686669 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 5 May 2008 23:11:51 -0400 Subject: sms1xxx: codingstyle cleanup: "foo* bar"/"foo * bar" should be "foo *bar" From: Michael Krufky ERROR: "foo* bar" should be "foo *bar" ERROR: "foo * bar" should be "foo *bar" Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 39 ++++++++++++++++++------------ linux/drivers/media/dvb/siano/smscoreapi.h | 10 +++++--- linux/drivers/media/dvb/siano/smsdvb.c | 11 ++++++--- linux/drivers/media/dvb/siano/smsusb.c | 18 +++++++------- 4 files changed, 46 insertions(+), 32 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index bd2743078..c1d6c193c 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -112,7 +112,7 @@ static int default_mode = 1; module_param(default_mode, int, 0644); MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); -int smscore_registry_getmode(char* devpath) +int smscore_registry_getmode(char *devpath) { smscore_registry_entry_t *entry; struct list_head *next; @@ -144,7 +144,7 @@ int smscore_registry_getmode(char* devpath) return default_mode; } -void smscore_registry_setmode(char* devpath, int mode) +void smscore_registry_setmode(char *devpath, int mode) { smscore_registry_entry_t *entry; struct list_head *next; @@ -213,7 +213,8 @@ out: } #endif -void list_add_locked(struct list_head *new, struct list_head *head, spinlock_t* lock) +void list_add_locked(struct list_head *new, struct list_head *head, + spinlock_t *lock) { unsigned long flags; @@ -298,7 +299,7 @@ void smscore_unregister_hotplug(hotplug_t hotplug) void smscore_notify_clients(smscore_device_t *coredev) { - smscore_client_t* client; + smscore_client_t *client; // the client must call smscore_unregister_client from remove handler while (!list_empty(&coredev->clients)) @@ -327,7 +328,8 @@ int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, i return rc; } -smscore_buffer_t *smscore_createbuffer(u8* buffer, void* common_buffer, dma_addr_t common_buffer_phys) +smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, + dma_addr_t common_buffer_phys) { smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); if (!cb) @@ -354,7 +356,7 @@ smscore_buffer_t *smscore_createbuffer(u8* buffer, void* common_buffer, dma_addr */ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev) { - smscore_device_t* dev; + smscore_device_t *dev; u8 *buffer; dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); @@ -456,7 +458,8 @@ int smscore_start_device(smscore_device_t *coredev) return rc; } -int smscore_sendrequest_and_wait(smscore_device_t *coredev, void* buffer, size_t size, struct completion *completion) +int smscore_sendrequest_and_wait(smscore_device_t *coredev, void *buffer, + size_t size, struct completion *completion) { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); if (rc < 0) @@ -470,7 +473,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ SmsFirmware_ST* firmware = (SmsFirmware_ST*) buffer; SmsMsgHdr_ST *msg; UINT32 mem_address = firmware->StartAddress; - u8* payload = firmware->Payload; + u8 *payload = firmware->Payload; int rc = 0; if (coredev->preload_handler) @@ -560,13 +563,14 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ * * @return 0 on success, <0 on error. */ -int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler) +int smscore_load_firmware(smscore_device_t *coredev, char *filename, + loadfirmware_t loadfirmware_handler) { int rc = -ENOENT; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) const struct firmware *fw; - u8* fw_buffer; + u8 *fw_buffer; if (loadfirmware_handler == NULL && !(coredev->device_flags & SMS_DEVICE_FAMILY2)) return -EINVAL; @@ -788,7 +792,8 @@ int smscore_get_device_mode(smscore_device_t *coredev) return coredev->mode; } -smscore_client_t* smscore_getclient_by_type(smscore_device_t *coredev, int data_type) +smscore_client_t *smscore_getclient_by_type(smscore_device_t *coredev, + int data_type) { smscore_client_t *client = NULL; struct list_head *next, *first; @@ -815,7 +820,7 @@ smscore_client_t* smscore_getclient_by_type(smscore_device_t *coredev, int data_ return client; } -smscore_client_t* smscore_getclient_by_id(smscore_device_t *coredev, int id) +smscore_client_t *smscore_getclient_by_id(smscore_device_t *coredev, int id) { smscore_client_t *client = NULL; struct list_head *next, *first; @@ -850,7 +855,8 @@ smscore_client_t* smscore_getclient_by_id(smscore_device_t *coredev, int id) void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) { SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8*) cb->p + cb->offset); - smscore_client_t * client = smscore_getclient_by_type(coredev, phdr->msgType); + smscore_client_t *client = smscore_getclient_by_type(coredev, + phdr->msgType); int rc = -EBUSY; #if 1 @@ -1008,7 +1014,7 @@ int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, */ int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) { - smscore_client_t* newclient; + smscore_client_t *newclient; int rc; // check that no other channel with same data type exists @@ -1090,7 +1096,7 @@ void smscore_unregister_client(smscore_client_t *client) */ int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) { - smscore_device_t* coredev = client->coredev; + smscore_device_t *coredev = client->coredev; SmsMsgHdr_ST* phdr = (SmsMsgHdr_ST*) buffer; // check that no other channel with same id exists @@ -1121,7 +1127,8 @@ int smscore_get_common_buffer_size(smscore_device_t *coredev) * * @return 0 on success, <0 on error. */ -int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma) +int smscore_map_common_buffer(smscore_device_t *coredev, + struct vm_area_struct *vma) { unsigned long end = vma->vm_end, start = vma->vm_start, size = PAGE_ALIGN(coredev->common_buffer_size); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 39182ef9d..3a7d21a03 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -518,19 +518,23 @@ extern int smscore_register_device(smsdevice_params_t *params, smscore_device_t extern void smscore_unregister_device(smscore_device_t *coredev); extern int smscore_start_device(smscore_device_t *coredev); -extern int smscore_load_firmware(smscore_device_t *coredev, char* filename, loadfirmware_t loadfirmware_handler); +extern int smscore_load_firmware(smscore_device_t *coredev, char *filename, + loadfirmware_t loadfirmware_handler); extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); extern int smscore_get_device_mode(smscore_device_t *coredev); -extern int smscore_register_client(smscore_device_t *coredev, smsclient_params_t* params, smscore_client_t **client); +extern int smscore_register_client(smscore_device_t *coredev, + smsclient_params_t *params, + smscore_client_t **client); extern void smscore_unregister_client(smscore_client_t *client); extern int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size); extern void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb); extern int smscore_get_common_buffer_size(smscore_device_t *coredev); -extern int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct * vma); +extern int smscore_map_common_buffer(smscore_device_t *coredev, + struct vm_area_struct *vma); extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 1a75033c3..717e0e97f 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -79,7 +79,7 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) return 0; } -void smsdvb_unregister_client(smsdvb_client_t* client) +void smsdvb_unregister_client(smsdvb_client_t *client) { // must be called under clientslock @@ -136,7 +136,9 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); } -static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, void* buffer, size_t size, struct completion *completion) +static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, + void *buffer, size_t size, + struct completion *completion) { int rc = smsclient_sendrequest(client->smsclient, buffer, size); if (rc < 0) @@ -283,10 +285,11 @@ static struct dvb_frontend_ops smsdvb_fe_ops = { .read_snr = smsdvb_read_snr, }; -int smsdvb_hotplug(smscore_device_t *coredev, struct device* device, int arrival) +int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, + int arrival) { smsclient_params_t params; - smsdvb_client_t* client; + smsdvb_client_t *client; int rc; // device removal handled by onremove callback diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 8aff377c4..9acbae190 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -44,7 +44,7 @@ typedef struct _smsusb_urb typedef struct _smsusb_device { - struct usb_device* udev; + struct usb_device *udev; smscore_device_t *coredev; smsusb_urb_t surbs[MAX_URBS]; @@ -53,12 +53,12 @@ typedef struct _smsusb_device int buffer_size; } *psmsusb_device_t; -int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb); +int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb); #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) void smsusb_onresponse(struct urb *urb) #else -void smsusb_onresponse(struct urb *urb, struct pt_regs * regs) +void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) #endif { smsusb_urb_t *surb = (smsusb_urb_t *) urb->context; @@ -108,7 +108,7 @@ exit_and_resubmit: smsusb_submit_urb(dev, surb); } -int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb) +int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb) { if (!surb->cb) { @@ -135,7 +135,7 @@ int smsusb_submit_urb(smsusb_device_t* dev, smsusb_urb_t* surb) return usb_submit_urb(&surb->urb, GFP_ATOMIC); } -void smsusb_stop_streaming(smsusb_device_t* dev) +void smsusb_stop_streaming(smsusb_device_t *dev) { int i; @@ -151,7 +151,7 @@ void smsusb_stop_streaming(smsusb_device_t* dev) } } -int smsusb_start_streaming(smsusb_device_t* dev) +int smsusb_start_streaming(smsusb_device_t *dev) { int i, rc; @@ -171,7 +171,7 @@ int smsusb_start_streaming(smsusb_device_t* dev) int smsusb_sendrequest(void *context, void *buffer, size_t size) { - smsusb_device_t* dev = (smsusb_device_t*) context; + smsusb_device_t *dev = (smsusb_device_t *) context; int dummy; return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buffer, size, &dummy, 1000); @@ -189,7 +189,7 @@ char *smsusb1_fw_lkup[] = int smsusb1_load_firmware(struct usb_device *udev, int id) { const struct firmware *fw; - u8* fw_buffer; + u8 *fw_buffer; int rc, dummy; if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) @@ -289,7 +289,7 @@ void smsusb_term_device(struct usb_interface *intf) int smsusb_init_device(struct usb_interface *intf) { smsdevice_params_t params; - smsusb_device_t* dev; + smsusb_device_t *dev; int i, rc; // create device object -- cgit v1.2.3 From 6d140732833c2c9db484133f00c798d63fedc243 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 5 May 2008 23:52:44 -0400 Subject: sms1xxx: codingstyle cleanup: "(foo*)" should be "(foo *)" From: Michael Krufky ERROR: "(foo*)" should be "(foo *)" Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smsdvb.c | 12 +++++++----- linux/drivers/media/dvb/siano/smsusb.c | 5 +++-- 2 files changed, 10 insertions(+), 7 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 717e0e97f..6975e7c61 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -32,12 +32,13 @@ kmutex_t g_smsdvb_clientslock; int smsdvb_onresponse(void *context, smscore_buffer_t *cb) { smsdvb_client_t *client = (smsdvb_client_t *) context; - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8*) cb->p) + cb->offset); + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8 *) cb->p) + cb->offset); switch(phdr->msgType) { case MSG_SMS_DVBT_BDA_DATA: - dvb_dmx_swfilter(&client->demux, (u8*)(phdr + 1), cb->size - sizeof(SmsMsgHdr_ST)); + dvb_dmx_swfilter(&client->demux, (u8 *)(phdr + 1), + cb->size - sizeof(SmsMsgHdr_ST)); break; case MSG_SMS_RF_TUNE_RES: @@ -46,7 +47,8 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) case MSG_SMS_GET_STATISTICS_RES: { - SmsMsgStatisticsInfo_ST* p = (SmsMsgStatisticsInfo_ST*)(phdr + 1); + SmsMsgStatisticsInfo_ST *p = + (SmsMsgStatisticsInfo_ST *)(phdr + 1); if (p->Stat.IsDemodLocked) { @@ -97,7 +99,7 @@ void smsdvb_onremove(void *context) { kmutex_lock(&g_smsdvb_clientslock); - smsdvb_unregister_client((smsdvb_client_t*) context); + smsdvb_unregister_client((smsdvb_client_t *) context); kmutex_unlock(&g_smsdvb_clientslock); } @@ -420,7 +422,7 @@ void smsdvb_unregister(void) kmutex_lock(&g_smsdvb_clientslock); while (!list_empty(&g_smsdvb_clients)) - smsdvb_unregister_client((smsdvb_client_t*) g_smsdvb_clients.next); + smsdvb_unregister_client((smsdvb_client_t *) g_smsdvb_clients.next); kmutex_unlock(&g_smsdvb_clientslock); diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 9acbae190..e227bb79c 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -90,7 +90,8 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) } // move buffer pointer and copy header to its new location - memcpy((char*) phdr + surb->cb->offset, phdr, sizeof(SmsMsgHdr_ST)); + memcpy((char *) phdr + surb->cb->offset, + phdr, sizeof(SmsMsgHdr_ST)); } else surb->cb->offset = 0; @@ -268,7 +269,7 @@ int smsusb1_setmode(void *context, int mode) void smsusb_term_device(struct usb_interface *intf) { - smsusb_device_t *dev = (smsusb_device_t*) usb_get_intfdata(intf); + smsusb_device_t *dev = (smsusb_device_t *) usb_get_intfdata(intf); if (dev) { -- cgit v1.2.3 From e8885cf665a7e8976f2fe47997becf1321d0bb23 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Fri, 13 Jun 2008 20:43:26 -0400 Subject: sms1xxx: update latest siano drop to 1.2.17 From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 375 ++++++++++++++++++----------- linux/drivers/media/dvb/siano/smscoreapi.h | 11 + linux/drivers/media/dvb/siano/smsdvb.c | 7 +- linux/drivers/media/dvb/siano/smsusb.c | 48 ++-- 4 files changed, 284 insertions(+), 157 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index c1d6c193c..2395710e4 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -33,32 +33,47 @@ #include "smscoreapi.h" +#define PERROR(fmt, args...) printk( KERN_ERR "smscore error: line %d- %s(): " fmt,__LINE__, __func__, ## args) + +#ifdef SMSCORE_DEBUG + +#undef PWARNING +# define PWARNING(fmt, args...) printk( KERN_INFO "smscore warning: line %d- %s(): " fmt,__LINE__, __func__, ## args) +#undef PDEBUG /* undef it, just in case */ +# define PDEBUG(fmt, args...) printk( KERN_INFO "smscore - %s(): " fmt, __func__, ## args) + +#else /*SMSCORE_DEBUG*/ + +#define PDEBUG(fmt, args...) +#define PWARNING(fmt, args...) + +#endif + + typedef struct _smscore_device_notifyee { struct list_head entry; hotplug_t hotplug; } smscore_device_notifyee_t; +typedef struct _smscore_subclient +{ + struct list_head entry; + int id; + int data_type; +} smscore_idlist_t; + typedef struct _smscore_client { struct list_head entry; smscore_device_t *coredev; - void *context; - - int data_type; - + struct list_head idlist; onresponse_t onresponse_handler; onremove_t onremove_handler; } *psmscore_client_t; -typedef struct _smscore_subclient -{ - struct list_head entry; - smscore_client_t *client; - int id; -} smscore_subclient_t; typedef struct _smscore_device { @@ -99,6 +114,7 @@ typedef struct _smscore_registry_entry struct list_head entry; char devpath[32]; int mode; + sms_device_type_st type; } smscore_registry_entry_t; struct list_head g_smscore_notifyees; @@ -109,62 +125,101 @@ struct list_head g_smscore_registry; kmutex_t g_smscore_registrylock; static int default_mode = 1; + module_param(default_mode, int, 0644); MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); -int smscore_registry_getmode(char *devpath) +static smscore_registry_entry_t *smscore_find_registry ( char *devpath ) { smscore_registry_entry_t *entry; struct list_head *next; kmutex_lock(&g_smscore_registrylock); - for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) { entry = (smscore_registry_entry_t *) next; - if (!strcmp(entry->devpath, devpath)) { kmutex_unlock(&g_smscore_registrylock); - return entry->mode; + return entry; } } - entry = (smscore_registry_entry_t *) kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); if (entry) { entry->mode = default_mode; strcpy(entry->devpath, devpath); - list_add(&entry->entry, &g_smscore_registry); } - + else + printk ( KERN_ERR "%s failed to create smscore_registry.\n", __func__ ); kmutex_unlock(&g_smscore_registrylock); + return entry; +} +int smscore_registry_getmode ( char *devpath ) +{ + smscore_registry_entry_t *entry; + + entry = smscore_find_registry ( devpath ); + if ( entry ) + { + return entry->mode; + } + else + { + printk ( KERN_ERR "%s No registry found.\n", __func__ ); + } return default_mode; } -void smscore_registry_setmode(char *devpath, int mode) +sms_device_type_st smscore_registry_gettype ( char *devpath ) { smscore_registry_entry_t *entry; - struct list_head *next; - kmutex_lock(&g_smscore_registrylock); + entry = smscore_find_registry ( devpath ); + if ( entry ) + { + return entry->type; + } + else + { + printk ( KERN_ERR "%s No registry found.\n", __func__ ); + } + return -1; +} - for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) +void smscore_registry_setmode ( char *devpath, int mode ) { - entry = (smscore_registry_entry_t *) next; + smscore_registry_entry_t *entry; - if (!strcmp(entry->devpath, devpath)) + entry = smscore_find_registry ( devpath ); + if ( entry ) { entry->mode = mode; - break; + } + else + { + printk ( KERN_ERR "%s No registry found.\n", __func__ ); } } - kmutex_unlock(&g_smscore_registrylock); +void smscore_registry_settype ( char *devpath, sms_device_type_st type ) +{ + smscore_registry_entry_t *entry; + + entry = smscore_find_registry ( devpath ); + if ( entry ) + { + entry->type = type; + } + else + { + printk ( KERN_ERR "%s No registry found.\n", __func__ ); +} } + #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) void *kzalloc(size_t size, int flags) { @@ -189,21 +244,25 @@ unsigned long wait_for_completion_timeout(struct completion *x, unsigned long ti might_sleep(); spin_lock_irq(&x->wait.lock); - if (!x->done) { + if ( !x->done ) + { DECLARE_WAITQUEUE(wait, current); wait.flags |= WQ_FLAG_EXCLUSIVE; __add_wait_queue_tail(&x->wait, &wait); - do { + do + { __set_current_state(TASK_UNINTERRUPTIBLE); spin_unlock_irq(&x->wait.lock); timeout = schedule_timeout(timeout); spin_lock_irq(&x->wait.lock); - if (!timeout) { + if ( !timeout ) + { __remove_wait_queue(&x->wait, &wait); goto out; } - } while (!x->done); + } + while ( !x->done ); __remove_wait_queue(&x->wait, &wait); } x->done--; @@ -371,7 +430,6 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored // init queues INIT_LIST_HEAD(&dev->clients); - INIT_LIST_HEAD(&dev->subclients); INIT_LIST_HEAD(&dev->buffers); // init locks @@ -422,6 +480,8 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored dev->device_flags = params->flags; strcpy(dev->devpath, params->devpath); + smscore_registry_settype ( dev->devpath, params->device_type ); + // add device to devices list kmutex_lock(&g_smscore_deviceslock); list_add(&dev->entry, &g_smscore_devices); @@ -445,7 +505,10 @@ int smscore_start_device(smscore_device_t *coredev) { int rc = smscore_set_device_mode(coredev, smscore_registry_getmode(coredev->devpath)); if (rc < 0) + { + printk ( KERN_INFO "%s set device mode faile , rc %d\n", __func__, rc ); return rc; + } kmutex_lock(&g_smscore_deviceslock); @@ -463,9 +526,12 @@ int smscore_sendrequest_and_wait(smscore_device_t *coredev, void *buffer, { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); if (rc < 0) + { + printk(KERN_INFO "%s sendrequest returned error %d\n", __func__, rc); return rc; + } - return wait_for_completion_timeout(completion, msecs_to_jiffies(1000)) ? 0 : -ETIME; + return wait_for_completion_timeout(completion, msecs_to_jiffies(10000)) ? 0 : -ETIME; } int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_t size) @@ -476,6 +542,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ u8 *payload = firmware->Payload; int rc = 0; + printk(KERN_INFO "%s loading FW to addr 0x%x size %d\n", __func__, mem_address,firmware->Length); if (coredev->preload_handler) { rc = coredev->preload_handler(coredev->context); @@ -490,6 +557,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ if (coredev->mode != DEVICE_MODE_NONE) { + PDEBUG("Sending reload command\n"); SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(SmsMsgHdr_ST)); rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); mem_address = *(UINT32*) &payload[20]; @@ -543,13 +611,14 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ rc = coredev->sendrequest_handler(coredev->context, msg, msg->msgLength); } + msleep ( 500 ); } - printk("%s %d \n", __func__, rc); + printk("%s rc=%d, postload=%p \n", __func__, rc, coredev->postload_handler); kfree(msg); - return (rc >= 0 && coredev->postload_handler) ? + return ((rc >= 0) && coredev->postload_handler) ? coredev->postload_handler(coredev->context) : rc; } @@ -563,8 +632,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ * * @return 0 on success, <0 on error. */ -int smscore_load_firmware(smscore_device_t *coredev, char *filename, - loadfirmware_t loadfirmware_handler) +int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, loadfirmware_t loadfirmware_handler) { int rc = -ENOENT; @@ -581,7 +649,7 @@ int smscore_load_firmware(smscore_device_t *coredev, char *filename, printk(KERN_INFO "%s failed to open \"%s\"\n", __func__, filename); return rc; } - + printk(KERN_INFO "%s read FW %s, size=%d\"\n", __func__, filename, fw->size); fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); if (fw_buffer) { @@ -605,6 +673,12 @@ int smscore_load_firmware(smscore_device_t *coredev, char *filename, return rc; } +int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8* buffer, int size, int new_mode) +{ + PERROR("Feature not implemented yet\n"); + return -EFAULT; +} + /** * notifies all clients registered with the device, notifies hotplugs, frees all buffers and coredev object * @@ -616,6 +690,7 @@ void smscore_unregister_device(smscore_device_t *coredev) { smscore_buffer_t *cb; int num_buffers = 0; + int retry = 0; kmutex_lock(&g_smscore_deviceslock); @@ -632,9 +707,13 @@ void smscore_unregister_device(smscore_device_t *coredev) kfree(cb); num_buffers ++; } - if (num_buffers == coredev->num_buffers) break; + if (++retry > 10) + { + printk(KERN_INFO "%s exiting although not all buffers released.\n", __func__); + break; + } printk(KERN_INFO "%s waiting for %d buffer(s)\n", __func__, coredev->num_buffers - num_buffers); msleep(100); @@ -686,19 +765,20 @@ int smscore_detect_mode(smscore_device_t *coredev) return rc; } -char *smscore_fw_lkup[] = +char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { - "dvb_nova_12mhz.inp", - "dvb_nova_12mhz.inp", - "tdmb_nova.inp", - "none", - "dvb_nova_12mhz.inp", - "isdbt_nova_12mhz.inp", - "isdbt_nova_12mhz.inp", - "cmmb_nova_12mhz.inp", - "none", + /*Stellar NOVA A0 Nova B0 VEGA*/ + /*DVBT*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*DVBH*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*TDMB*/ {"none", "tdmb_nova_12mhz.inp", "none" "none"}, + /*DABIP*/ {"none", "none", "none", "none"}, + /*BDA*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*ISDBT*/ {"none", "isdbt_nova_12mhz.inp", "dvb_nova_12mhz.inp", "none"}, + /*ISDBTBDA*/{"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"}, + /*CMMB*/ {"none", "none", "none", "cmmb_vega_12mhz.inp"} }; + /** * calls device handler to change mode of operation * NOTE: stellar/usb may disconnect when changing mode @@ -712,7 +792,9 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) { void *buffer; int rc = 0; + sms_device_type_st type; + PDEBUG("set device mode to %d\n", mode ); if (coredev->device_flags & SMS_DEVICE_FAMILY2) { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) @@ -721,12 +803,17 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) return -EINVAL; } + smscore_registry_setmode(coredev->devpath, mode); + if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) { rc = smscore_detect_mode(coredev); if (rc < 0) + { + printk(KERN_INFO "%s mode detect failed %d\n", __func__, rc); return rc; } + } if (coredev->mode == mode) { @@ -736,10 +823,14 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) if (!(coredev->modes_supported & (1 << mode))) { - rc = smscore_load_firmware(coredev, smscore_fw_lkup[mode], NULL); + type = smscore_registry_gettype ( coredev->devpath ); + rc = smscore_load_firmware_from_file ( coredev, smscore_fw_lkup[mode][type], NULL ); if (rc < 0) + { + printk(KERN_INFO "%s load firmware failed %d\n", __func__, rc); return rc; } + } else { printk(KERN_INFO "%s mode %d supported by running firmware\n", __func__, mode); @@ -758,10 +849,21 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) kfree(buffer); } else + { + printk(KERN_INFO "%s Could not allocate buffer for init device message.\n", __func__); rc = -ENOMEM; } + } else { + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) + { + printk(KERN_INFO "%s invalid mode specified %d\n", __func__, mode); + return -EINVAL; + } + + smscore_registry_setmode(coredev->devpath, mode); + if (coredev->detectmode_handler) coredev->detectmode_handler(coredev->context, &coredev->mode); @@ -769,14 +871,14 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) rc = coredev->setmode_handler(coredev->context, mode); } - smscore_registry_setmode(coredev->devpath, mode); - if (rc >= 0) { coredev->mode = mode; coredev->device_flags &= ~SMS_DEVICE_NOT_READY; } + if (rc != 0) + printk(KERN_INFO "%s return error code %d.\n", __func__, rc); return rc; } @@ -792,55 +894,40 @@ int smscore_get_device_mode(smscore_device_t *coredev) return coredev->mode; } -smscore_client_t *smscore_getclient_by_type(smscore_device_t *coredev, - int data_type) +/** + * find client by response id & type within the clients list. + * return client handle or NULL. + * + * @param coredev pointer to a coredev object returned by smscore_register_device + * @param data_type client data type (SMS_DONT_CARE for all types) + * @param id client id (SMS_DONT_CARE for all id ) + * + */ +smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, int id) { smscore_client_t *client = NULL; struct list_head *next, *first; unsigned long flags; + struct list_head *firstid, *nextid; - if (!data_type) - return NULL; spin_lock_irqsave(&coredev->clientslock, flags); - first = &coredev->clients; - - for (next = first->next; next != first; next = next->next) + for (next = first->next; (next != first) && !client; next = next->next) + { + firstid = &((smscore_client_t*)next )->idlist; + for (nextid = firstid->next ; nextid != firstid ; nextid = nextid->next) { - if (((smscore_client_t*) next)->data_type == data_type) + if ((((smscore_idlist_t*)nextid)->id == id) && + (((smscore_idlist_t*)nextid)->data_type == data_type || + (((smscore_idlist_t*)nextid)->data_type == 0))) { client = (smscore_client_t*) next; break; } } - - spin_unlock_irqrestore(&coredev->clientslock, flags); - - return client; -} - -smscore_client_t *smscore_getclient_by_id(smscore_device_t *coredev, int id) -{ - smscore_client_t *client = NULL; - struct list_head *next, *first; - unsigned long flags; - - spin_lock_irqsave(&coredev->clientslock, flags); - - first = &coredev->subclients; - - for (next = first->next; next != first; next = next->next) - { - if (((smscore_subclient_t*) next)->id == id) - { - client = ((smscore_subclient_t*) next)->client; - break; - } } - spin_unlock_irqrestore(&coredev->clientslock, flags); - return client; } @@ -855,8 +942,7 @@ smscore_client_t *smscore_getclient_by_id(smscore_device_t *coredev, int id) void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) { SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8*) cb->p + cb->offset); - smscore_client_t *client = smscore_getclient_by_type(coredev, - phdr->msgType); + smscore_client_t *client = smscore_find_client(coredev, phdr->msgType, phdr->msgDstId); int rc = -EBUSY; #if 1 @@ -877,10 +963,9 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) data_total += cb->size; #endif - - if (!client) - client = smscore_getclient_by_id(coredev, phdr->msgDstId); - + /* If no client registered for type & id, check for control client where type is not registered*/ +// if (!client) +// client = smscore_find_client( coredev, 0, phdr->msgDstId); if (client) rc = client->onresponse_handler(client->context, cb); @@ -928,7 +1013,8 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) break; default: - printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __func__, client, rc, phdr->msgType, phdr->msgDstId); + //printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __func__, client, rc, phdr->msgType, phdr->msgDstId); + break; } smscore_putbuffer(coredev, cb); @@ -972,30 +1058,35 @@ void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb) list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); } -int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int id) +int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int data_type, int id) { - smscore_client_t *existing_client; - smscore_subclient_t *subclient; - - if (!id) - return 0; + smscore_idlist_t *listentry; + smscore_client_t *registered_client; - existing_client = smscore_getclient_by_id(coredev, id); - if (existing_client == client) + if ( !client ) + { + PERROR("bad parameter.\n"); + return -EFAULT; + } + registered_client = smscore_find_client(coredev, data_type, id); + if (registered_client == client) + { return 0; - - if (existing_client) - return -EBUSY; - - subclient = kzalloc(sizeof(smscore_subclient_t), GFP_KERNEL); - if (!subclient) + } + if (registered_client) + { + PERROR("The msg ID already registered to another client.\n"); + return -EEXIST; + } + listentry = kzalloc ( sizeof ( smscore_idlist_t ), GFP_KERNEL ); + if ( !listentry ) + { + PERROR("Can't allocate memory for client id.\n"); return -ENOMEM; - - subclient->client = client; - subclient->id = id; - - list_add_locked(&subclient->entry, &coredev->subclients, &coredev->clientslock); - + } + listentry->id = id; + listentry->data_type = data_type; + list_add_locked ( &listentry->entry, &client->idlist, &coredev->clientslock ); return 0; } @@ -1015,35 +1106,29 @@ int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) { smscore_client_t *newclient; - int rc; - - // check that no other channel with same data type exists - if (params->data_type && smscore_getclient_by_type(coredev, params->data_type)) + // check that no other channel with same parameters exists + if (smscore_find_client(coredev, params->data_type, params->initial_id)) + { + PERROR("Client already exist.\n"); return -EEXIST; + } newclient = kzalloc(sizeof(smscore_client_t), GFP_KERNEL); if (!newclient) - return -ENOMEM; - - // check that no other channel with same id exists - rc = smscore_validate_client(coredev, newclient, params->initial_id); - if (rc < 0) { - kfree(newclient); - return rc; + PERROR("Failed to allocate memory for client.\n"); + return -ENOMEM; } + INIT_LIST_HEAD ( &newclient->idlist); newclient->coredev = coredev; - newclient->data_type = params->data_type; newclient->onresponse_handler = params->onresponse_handler; newclient->onremove_handler = params->onremove_handler; newclient->context = params->context; - list_add_locked(&newclient->entry, &coredev->clients, &coredev->clientslock); - + smscore_validate_client(coredev, newclient, params->data_type, params->initial_id); *client = newclient; - - printk(KERN_INFO "%s %p %d %d\n", __func__, params->context, params->data_type, params->initial_id); + PDEBUG ( "%p %d %d\n", params->context, params->data_type, params->initial_id ); return 0; } @@ -1057,26 +1142,19 @@ int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *param void smscore_unregister_client(smscore_client_t *client) { smscore_device_t *coredev = client->coredev; - struct list_head *next, *first; unsigned long flags; spin_lock_irqsave(&coredev->clientslock, flags); - first = &coredev->subclients; - for (next = first->next; next != first;) - { - smscore_subclient_t *subclient = (smscore_subclient_t *) next; - next = next->next; - - if (subclient->client == client) + while (!list_empty( &client->idlist)) { - list_del(&subclient->entry); - kfree(subclient); - } + smscore_idlist_t *identry = (smscore_idlist_t*)client->idlist.next; + list_del ( &identry->entry ); + kfree ( identry ); } - printk(KERN_INFO "%s %p %d\n", __func__, client->context, client->data_type); + printk(KERN_INFO "%s %p\n", __func__, client->context); list_del(&client->entry); kfree(client); @@ -1096,11 +1174,26 @@ void smscore_unregister_client(smscore_client_t *client) */ int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) { - smscore_device_t *coredev = client->coredev; + smscore_device_t *coredev; SmsMsgHdr_ST* phdr = (SmsMsgHdr_ST*) buffer; + int rc; + + if ( client == NULL ) + { + printk(KERN_ERR "%s Got NULL client\n", __func__ ); + return -EINVAL; + } + + coredev = client->coredev; // check that no other channel with same id exists - int rc = smscore_validate_client(client->coredev, client, phdr->msgSrcId); + if ( coredev == NULL ) + { + printk(KERN_ERR "%s Got NULL coredev\n", __func__ ); + return -EINVAL; + } + + rc = smscore_validate_client(client->coredev, client, 0, phdr->msgSrcId); if (rc < 0) return rc; @@ -1215,6 +1308,6 @@ module_init(smscore_module_init); module_exit(smscore_module_exit); MODULE_DESCRIPTION("smscore"); -MODULE_AUTHOR("Anatoly Greenblatt,,, (anatolyg@siano-ms.com)"); +MODULE_AUTHOR ( "Siano Mobile Silicon,,, (doronc@siano-ms.com)" ); MODULE_LICENSE("GPL"); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 3a7d21a03..0add43b02 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -71,6 +71,14 @@ void *kzalloc(size_t size, int flags); #define SMS_ROM_NO_RESPONSE 2 #define SMS_DEVICE_NOT_READY 0x8000000 +typedef enum { + SMS_STELLAR= 0, + SMS_NOVA_A0, + SMS_NOVA_B0, + SMS_VEGA, + SMS_NUM_OF_DEVICE_TYPES +} sms_device_type_st; + typedef struct _smscore_device smscore_device_t; typedef struct _smscore_client smscore_client_t; typedef struct _smscore_buffer smscore_buffer_t; @@ -117,6 +125,7 @@ typedef struct _smsdevice_params postload_t postload_handler; void *context; + sms_device_type_st device_type; } smsdevice_params_t; typedef struct _smsclient_params @@ -521,6 +530,8 @@ extern int smscore_start_device(smscore_device_t *coredev); extern int smscore_load_firmware(smscore_device_t *coredev, char *filename, loadfirmware_t loadfirmware_handler); +extern int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8* buffer, int size, int new_mode); + extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); extern int smscore_get_device_mode(smscore_device_t *coredev); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 6975e7c61..e02e011df 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -300,9 +300,14 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, if (smscore_get_device_mode(coredev) != 4) { +#if 1 // new siano drop (1.2.17) does this -- yuck + printk(KERN_ERR "%sSMS Device mode is not set for DVB operation.\n", __func__); + return 0; +#else rc = smscore_set_device_mode(coredev, 4); if (rc < 0) return rc; +#endif } client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); @@ -356,7 +361,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, goto frontend_error; } - params.initial_id = 0; + params.initial_id = 1; params.data_type = MSG_SMS_DVBT_BDA_DATA; params.onresponse_handler = smsdvb_onresponse; params.onremove_handler = smsdvb_onremove; diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index e227bb79c..8d16a6853 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -305,21 +305,32 @@ int smsusb_init_device(struct usb_interface *intf) usb_set_intfdata(intf, dev); dev->udev = interface_to_usbdev(intf); - switch (dev->udev->descriptor.idProduct) - { - case 0x100: - dev->buffer_size = USB1_BUFFER_SIZE; - - params.setmode_handler = smsusb1_setmode; - params.detectmode_handler = smsusb1_detectmode; - break; + switch (dev->udev->descriptor.idProduct) { + case 0x100: + dev->buffer_size = USB1_BUFFER_SIZE; + + params.setmode_handler = smsusb1_setmode; + params.detectmode_handler = smsusb1_detectmode; + params.device_type = SMS_STELLAR; + printk(KERN_INFO "%s stellar device found\n", __func__ ); + break; + default: + if (dev->udev->descriptor.idProduct == 0x200) { + params.device_type = SMS_NOVA_A0; + printk(KERN_INFO "%s nova A0 found\n", __FUNCTION__ ); + } else if (dev->udev->descriptor.idProduct == 0x201) { + params.device_type = SMS_NOVA_B0; + printk(KERN_INFO "%s nova B0 found\n", __FUNCTION__); + } else { + params.device_type = SMS_VEGA; + printk(KERN_INFO "%s Vega found\n", __FUNCTION__); + } - default: - dev->buffer_size = USB2_BUFFER_SIZE; - dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST); + dev->buffer_size = USB2_BUFFER_SIZE; + dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST); - params.flags |= SMS_DEVICE_FAMILY2; - break; + params.flags |= SMS_DEVICE_FAMILY2; + break; } params.device = &dev->udev->dev; @@ -345,6 +356,7 @@ int smsusb_init_device(struct usb_interface *intf) usb_init_urb(&dev->surbs[i].urb); } + printk(KERN_INFO "%s smsusb_start_streaming(...).\n", __func__); rc = smsusb_start_streaming(dev); if (rc < 0) { @@ -372,6 +384,9 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) char devpath[32]; int i, rc; + rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81)); + rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02)); + if (intf->num_altsetting > 0) { rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); @@ -394,11 +409,14 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) if (intf->cur_altsetting->desc.bInterfaceNumber == 1) { - snprintf(devpath, 32, "%d:%s", udev->bus->busnum, udev->devpath); + snprintf(devpath, sizeof(devpath), "usb\\%d-%s", udev->bus->busnum, udev->devpath); + printk(KERN_INFO "stellar device was found.\n"); return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath)); } - return smsusb_init_device(intf); + rc = smsusb_init_device(intf); + printk(KERN_INFO "%s rc %d\n", __FUNCTION__, rc); + return rc; } void smsusb_disconnect(struct usb_interface *intf) -- cgit v1.2.3 From 8634fb0e1864ee846d16148881c50654f699b677 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 14 Jun 2008 03:40:41 -0400 Subject: sms1xxx: more codingstyle cleanups From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 8 ++++---- linux/drivers/media/dvb/siano/smscoreapi.h | 2 +- linux/drivers/media/dvb/siano/smsusb.c | 8 ++++---- 3 files changed, 9 insertions(+), 9 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 2395710e4..55422d242 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -398,7 +398,7 @@ smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, } cb->p = buffer; - cb->offset_in_common = buffer - (u8*) common_buffer; + cb->offset_in_common = buffer - (u8 *) common_buffer; cb->phys = common_buffer_phys + cb->offset_in_common; return cb; @@ -673,7 +673,7 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, l return rc; } -int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8* buffer, int size, int new_mode) +int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, int size, int new_mode) { PERROR("Feature not implemented yet\n"); return -EFAULT; @@ -941,7 +941,7 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, */ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) { - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8*) cb->p + cb->offset); + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8 *) cb->p + cb->offset); smscore_client_t *client = smscore_find_client(coredev, phdr->msgType, phdr->msgDstId); int rc = -EBUSY; @@ -1175,7 +1175,7 @@ void smscore_unregister_client(smscore_client_t *client) int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) { smscore_device_t *coredev; - SmsMsgHdr_ST* phdr = (SmsMsgHdr_ST*) buffer; + SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) buffer; int rc; if ( client == NULL ) diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 0add43b02..ce317adb0 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -530,7 +530,7 @@ extern int smscore_start_device(smscore_device_t *coredev); extern int smscore_load_firmware(smscore_device_t *coredev, char *filename, loadfirmware_t loadfirmware_handler); -extern int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8* buffer, int size, int new_mode); +extern int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, int size, int new_mode); extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); extern int smscore_get_device_mode(smscore_device_t *coredev); diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 8d16a6853..0393aa22c 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -317,13 +317,13 @@ int smsusb_init_device(struct usb_interface *intf) default: if (dev->udev->descriptor.idProduct == 0x200) { params.device_type = SMS_NOVA_A0; - printk(KERN_INFO "%s nova A0 found\n", __FUNCTION__ ); + printk(KERN_INFO "%s nova A0 found\n", __func__ ); } else if (dev->udev->descriptor.idProduct == 0x201) { params.device_type = SMS_NOVA_B0; - printk(KERN_INFO "%s nova B0 found\n", __FUNCTION__); + printk(KERN_INFO "%s nova B0 found\n", __func__); } else { params.device_type = SMS_VEGA; - printk(KERN_INFO "%s Vega found\n", __FUNCTION__); + printk(KERN_INFO "%s Vega found\n", __func__); } dev->buffer_size = USB2_BUFFER_SIZE; @@ -415,7 +415,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) } rc = smsusb_init_device(intf); - printk(KERN_INFO "%s rc %d\n", __FUNCTION__, rc); + printk(KERN_INFO "%s rc %d\n", __func__, rc); return rc; } -- cgit v1.2.3 From 6df8f7346f42a67e11f29b312d80cb31a79f663a Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 14 Jun 2008 14:27:18 -0400 Subject: sms1xxx: #define usb vid:pid's From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smsusb.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 0393aa22c..4a2f02247 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -32,6 +32,14 @@ #define MAX_BUFFERS 50 #define MAX_URBS 10 +/* TO DO: move these to a header file */ +#define USB_VID_SIANO 0x187f + +#define USB_PID_STELLAR 0x0100 +#define USB_PID_NOVA_A 0x0200 +#define USB_PID_NOVA_B 0x0201 +#define USB_PID_VEGA 0x0300 + typedef struct _smsusb_device smsusb_device_t; typedef struct _smsusb_urb @@ -306,7 +314,8 @@ int smsusb_init_device(struct usb_interface *intf) dev->udev = interface_to_usbdev(intf); switch (dev->udev->descriptor.idProduct) { - case 0x100: + + case USB_PID_STELLAR: dev->buffer_size = USB1_BUFFER_SIZE; params.setmode_handler = smsusb1_setmode; @@ -315,13 +324,17 @@ int smsusb_init_device(struct usb_interface *intf) printk(KERN_INFO "%s stellar device found\n", __func__ ); break; default: - if (dev->udev->descriptor.idProduct == 0x200) { + switch (dev->udev->descriptor.idProduct) { + case USB_PID_NOVA_A: params.device_type = SMS_NOVA_A0; printk(KERN_INFO "%s nova A0 found\n", __func__ ); - } else if (dev->udev->descriptor.idProduct == 0x201) { + break; + default: + case USB_PID_NOVA_B: params.device_type = SMS_NOVA_B0; printk(KERN_INFO "%s nova B0 found\n", __func__); - } else { + break; + case USB_PID_VEGA: params.device_type = SMS_VEGA; printk(KERN_INFO "%s Vega found\n", __func__); } @@ -425,9 +438,9 @@ void smsusb_disconnect(struct usb_interface *intf) } static struct usb_device_id smsusb_id_table [] = { - { USB_DEVICE(0x187F, 0x0010) }, - { USB_DEVICE(0x187F, 0x0100) }, - { USB_DEVICE(0x187F, 0x0200) }, + { USB_DEVICE(USB_VID_SIANO, 0x0010) }, + { USB_DEVICE(USB_VID_SIANO, USB_PID_STELLAR) }, + { USB_DEVICE(USB_VID_SIANO, USB_PID_NOVA_A) }, { } /* Terminating entry */ }; MODULE_DEVICE_TABLE (usb, smsusb_id_table); -- cgit v1.2.3 From c9b4b656aa09d63e1beeb45c498841180e8dbaf6 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 11:14:13 -0400 Subject: sms1xxx: more codingstyle cleanups From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 675 ++++++++++++++--------------- linux/drivers/media/dvb/siano/smscoreapi.h | 396 ++++++++--------- linux/drivers/media/dvb/siano/smsdvb.c | 178 ++++---- linux/drivers/media/dvb/siano/smsusb.c | 209 ++++----- 4 files changed, 733 insertions(+), 725 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 55422d242..98422879d 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -33,23 +33,23 @@ #include "smscoreapi.h" -#define PERROR(fmt, args...) printk( KERN_ERR "smscore error: line %d- %s(): " fmt,__LINE__, __func__, ## args) +#define PERROR(fmt, args...)\ + printk(KERN_ERR "smscore error: line %d- %s(): " fmt, \ + __LINE__, __func__, ## args) #ifdef SMSCORE_DEBUG - #undef PWARNING -# define PWARNING(fmt, args...) printk( KERN_INFO "smscore warning: line %d- %s(): " fmt,__LINE__, __func__, ## args) +# define PWARNING(fmt, args...) printk(KERN_INFO "smscore warning: " \ + "line %d- %s(): " fmt, \ + __LINE__, __func__, ## args) #undef PDEBUG /* undef it, just in case */ -# define PDEBUG(fmt, args...) printk( KERN_INFO "smscore - %s(): " fmt, __func__, ## args) - +# define PDEBUG(fmt, args...) printk(KERN_INFO "smscore - %s(): " fmt, \ + __func__, ## args) #else /*SMSCORE_DEBUG*/ - #define PDEBUG(fmt, args...) #define PWARNING(fmt, args...) - #endif - typedef struct _smscore_device_notifyee { struct list_head entry; @@ -129,94 +129,80 @@ static int default_mode = 1; module_param(default_mode, int, 0644); MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); -static smscore_registry_entry_t *smscore_find_registry ( char *devpath ) +static smscore_registry_entry_t *smscore_find_registry(char *devpath) { smscore_registry_entry_t *entry; struct list_head *next; kmutex_lock(&g_smscore_registrylock); - for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) - { + for (next = g_smscore_registry.next; + next != &g_smscore_registry; + next = next->next) { entry = (smscore_registry_entry_t *) next; - if (!strcmp(entry->devpath, devpath)) - { + if (!strcmp(entry->devpath, devpath)) { kmutex_unlock(&g_smscore_registrylock); return entry; } } - entry = (smscore_registry_entry_t *) kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); - if (entry) - { + entry = (smscore_registry_entry_t *) + kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); + if (entry) { entry->mode = default_mode; strcpy(entry->devpath, devpath); list_add(&entry->entry, &g_smscore_registry); - } - else - printk ( KERN_ERR "%s failed to create smscore_registry.\n", __func__ ); + } else + printk(KERN_ERR "%s failed to create smscore_registry.\n", + __func__); kmutex_unlock(&g_smscore_registrylock); return entry; } -int smscore_registry_getmode ( char *devpath ) +int smscore_registry_getmode(char *devpath) { smscore_registry_entry_t *entry; - entry = smscore_find_registry ( devpath ); - if ( entry ) - { + entry = smscore_find_registry(devpath); + if (entry) return entry->mode; - } else - { - printk ( KERN_ERR "%s No registry found.\n", __func__ ); - } + printk(KERN_ERR "%s No registry found.\n", __func__); + return default_mode; } -sms_device_type_st smscore_registry_gettype ( char *devpath ) +sms_device_type_st smscore_registry_gettype(char *devpath) { smscore_registry_entry_t *entry; - entry = smscore_find_registry ( devpath ); - if ( entry ) - { + entry = smscore_find_registry(devpath); + if (entry) return entry->type; - } else - { - printk ( KERN_ERR "%s No registry found.\n", __func__ ); - } + printk(KERN_ERR "%s No registry found.\n", __func__); + return -1; } -void smscore_registry_setmode ( char *devpath, int mode ) - { +void smscore_registry_setmode(char *devpath, int mode) +{ smscore_registry_entry_t *entry; - entry = smscore_find_registry ( devpath ); - if ( entry ) - { - entry->mode = mode; - } + entry = smscore_find_registry(devpath); + if (entry) + entry->mode = mode; else - { - printk ( KERN_ERR "%s No registry found.\n", __func__ ); - } - } + printk(KERN_ERR "%s No registry found.\n", __func__); +} -void smscore_registry_settype ( char *devpath, sms_device_type_st type ) +void smscore_registry_settype(char *devpath, sms_device_type_st type) { smscore_registry_entry_t *entry; - entry = smscore_find_registry ( devpath ); - if ( entry ) - { + entry = smscore_find_registry(devpath); + if (entry) entry->type = type; - } else - { - printk ( KERN_ERR "%s No registry found.\n", __func__ ); -} + printk(KERN_ERR "%s No registry found.\n", __func__); } @@ -239,30 +225,27 @@ static inline unsigned long kvirt_to_pa(unsigned long adr) return ret; } -unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout) +unsigned long wait_for_completion_timeout(struct completion *x, + unsigned long timeout) { might_sleep(); spin_lock_irq(&x->wait.lock); - if ( !x->done ) - { + if (!x->done) { DECLARE_WAITQUEUE(wait, current); wait.flags |= WQ_FLAG_EXCLUSIVE; __add_wait_queue_tail(&x->wait, &wait); - do - { + do { __set_current_state(TASK_UNINTERRUPTIBLE); spin_unlock_irq(&x->wait.lock); timeout = schedule_timeout(timeout); spin_lock_irq(&x->wait.lock); - if ( !timeout ) - { + if (!timeout) { __remove_wait_queue(&x->wait, &wait); goto out; } - } - while ( !x->done ); + } while (!x->done); __remove_wait_queue(&x->wait, &wait); } x->done--; @@ -273,7 +256,7 @@ out: #endif void list_add_locked(struct list_head *new, struct list_head *head, - spinlock_t *lock) + spinlock_t *lock) { unsigned long flags; @@ -301,25 +284,22 @@ int smscore_register_hotplug(hotplug_t hotplug) kmutex_lock(&g_smscore_deviceslock); notifyee = kmalloc(sizeof(smscore_device_notifyee_t), GFP_KERNEL); - if (notifyee) - { - // now notify callback about existing devices + if (notifyee) { + /* now notify callback about existing devices */ first = &g_smscore_devices; - for (next = first->next; next != first && !rc; next = next->next) - { + for (next = first->next; + next != first && !rc; + next = next->next) { smscore_device_t *coredev = (smscore_device_t *) next; rc = hotplug(coredev, coredev->device, 1); } - if (rc >= 0) - { + if (rc >= 0) { notifyee->hotplug = hotplug; list_add(¬ifyee->entry, &g_smscore_notifyees); - } - else + } else kfree(notifyee); - } - else + } else rc = -ENOMEM; kmutex_unlock(&g_smscore_deviceslock); @@ -341,13 +321,12 @@ void smscore_unregister_hotplug(hotplug_t hotplug) first = &g_smscore_notifyees; - for (next = first->next; next != first;) - { - smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) next; + for (next = first->next; next != first;) { + smscore_device_notifyee_t *notifyee = + (smscore_device_notifyee_t *) next; next = next->next; - if (notifyee->hotplug == hotplug) - { + if (notifyee->hotplug == hotplug) { list_del(¬ifyee->entry); kfree(notifyee); } @@ -360,25 +339,24 @@ void smscore_notify_clients(smscore_device_t *coredev) { smscore_client_t *client; - // the client must call smscore_unregister_client from remove handler - while (!list_empty(&coredev->clients)) - { + /* the client must call smscore_unregister_client from remove handler */ + while (!list_empty(&coredev->clients)) { client = (smscore_client_t *) coredev->clients.next; client->onremove_handler(client->context); } } -int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, int arrival) +int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, + int arrival) { struct list_head *next, *first; int rc = 0; - // note: must be called under g_deviceslock + /* note: must be called under g_deviceslock */ first = &g_smscore_notifyees; - for (next = first->next; next != first; next = next->next) - { + for (next = first->next; next != first; next = next->next) { rc = ((smscore_device_notifyee_t *) next)->hotplug(coredev, device, arrival); if (rc < 0) break; @@ -391,8 +369,7 @@ smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, dma_addr_t common_buffer_phys) { smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); - if (!cb) - { + if (!cb) { printk(KERN_INFO "%s kmalloc(...) failed\n", __func__); return NULL; } @@ -405,38 +382,38 @@ smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, } /** - * creates coredev object for a device, prepares buffers, creates buffer mappings, notifies - * registered hotplugs about new device. + * creates coredev object for a device, prepares buffers, + * creates buffer mappings, notifies registered hotplugs about new device. * * @param params device pointer to struct with device specific parameters and handlers * @param coredev pointer to a value that receives created coredev object * * @return 0 on success, <0 on error. */ -int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev) +int smscore_register_device(smsdevice_params_t *params, + smscore_device_t **coredev) { smscore_device_t *dev; u8 *buffer; dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); - if (!dev) - { + if (!dev) { printk(KERN_INFO "%s kzalloc(...) failed\n", __func__); return -ENOMEM; } - // init list entry so it could be safe in smscore_unregister_device + /* init list entry so it could be safe in smscore_unregister_device */ INIT_LIST_HEAD(&dev->entry); - // init queues + /* init queues */ INIT_LIST_HEAD(&dev->clients); INIT_LIST_HEAD(&dev->buffers); - // init locks + /* init locks */ spin_lock_init(&dev->clientslock); spin_lock_init(&dev->bufferslock); - // init completion events + /* init completion events */ init_completion(&dev->version_ex_done); init_completion(&dev->data_download_done); init_completion(&dev->trigger_done); @@ -444,21 +421,22 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored init_completion(&dev->reload_start_done); init_completion(&dev->resume_done); - // alloc common buffer + /* alloc common buffer */ dev->common_buffer_size = params->buffer_size * params->num_buffers; - dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size, &dev->common_buffer_phys, GFP_KERNEL | GFP_DMA); - if (!dev->common_buffer) - { + dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size, + &dev->common_buffer_phys, + GFP_KERNEL | GFP_DMA); + if (!dev->common_buffer) { smscore_unregister_device(dev); return -ENOMEM; } - // prepare dma buffers - for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; dev->num_buffers ++, buffer += params->buffer_size) - { + /* prepare dma buffers */ + for (buffer = dev->common_buffer; + dev->num_buffers < params->num_buffers; + dev->num_buffers ++, buffer += params->buffer_size) { smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); - if (!cb) - { + if (!cb) { smscore_unregister_device(dev); return -ENOMEM; } @@ -466,7 +444,8 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored smscore_putbuffer(dev, cb); } - printk(KERN_INFO "%s allocated %d buffers\n", __func__, dev->num_buffers); + printk(KERN_INFO "%s allocated %d buffers\n", + __func__, dev->num_buffers); dev->mode = DEVICE_MODE_NONE; dev->context = params->context; @@ -480,9 +459,9 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored dev->device_flags = params->flags; strcpy(dev->devpath, params->devpath); - smscore_registry_settype ( dev->devpath, params->device_type ); + smscore_registry_settype(dev->devpath, params->device_type); - // add device to devices list + /* add device to devices list */ kmutex_lock(&g_smscore_deviceslock); list_add(&dev->entry, &g_smscore_devices); kmutex_unlock(&g_smscore_deviceslock); @@ -504,9 +483,8 @@ int smscore_register_device(smsdevice_params_t *params, smscore_device_t **cored int smscore_start_device(smscore_device_t *coredev) { int rc = smscore_set_device_mode(coredev, smscore_registry_getmode(coredev->devpath)); - if (rc < 0) - { - printk ( KERN_INFO "%s set device mode faile , rc %d\n", __func__, rc ); + if (rc < 0) { + printk(KERN_INFO "%s set device mode faile , rc %d\n", __func__, rc); return rc; } @@ -514,7 +492,8 @@ int smscore_start_device(smscore_device_t *coredev) rc = smscore_notify_callbacks(coredev, coredev->device, 1); - printk(KERN_INFO "%s device %p started, rc %d\n", __func__, coredev, rc); + printk(KERN_INFO "%s device %p started, rc %d\n", + __func__, coredev, rc); kmutex_unlock(&g_smscore_deviceslock); @@ -522,44 +501,49 @@ int smscore_start_device(smscore_device_t *coredev) } int smscore_sendrequest_and_wait(smscore_device_t *coredev, void *buffer, - size_t size, struct completion *completion) + size_t size, struct completion *completion) { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); - if (rc < 0) - { - printk(KERN_INFO "%s sendrequest returned error %d\n", __func__, rc); + if (rc < 0) { + printk(KERN_INFO "%s sendrequest returned error %d\n", + __func__, rc); return rc; } - return wait_for_completion_timeout(completion, msecs_to_jiffies(10000)) ? 0 : -ETIME; + return wait_for_completion_timeout(completion, + msecs_to_jiffies(10000)) ? + 0 : -ETIME; } -int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_t size) +int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, + size_t size) { - SmsFirmware_ST* firmware = (SmsFirmware_ST*) buffer; + SmsFirmware_ST *firmware = (SmsFirmware_ST *) buffer; SmsMsgHdr_ST *msg; UINT32 mem_address = firmware->StartAddress; u8 *payload = firmware->Payload; int rc = 0; - printk(KERN_INFO "%s loading FW to addr 0x%x size %d\n", __func__, mem_address,firmware->Length); - if (coredev->preload_handler) - { + printk(KERN_INFO "%s loading FW to addr 0x%x size %d\n", + __func__, mem_address, firmware->Length); + if (coredev->preload_handler) { rc = coredev->preload_handler(coredev->context); if (rc < 0) return rc; } - // PAGE_SIZE buffer shall be enough and dma aligned + /* PAGE_SIZE buffer shall be enough and dma aligned */ msg = (SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); if (!msg) return -ENOMEM; - if (coredev->mode != DEVICE_MODE_NONE) - { + if (coredev->mode != DEVICE_MODE_NONE) { PDEBUG("Sending reload command\n"); - SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(SmsMsgHdr_ST)); - rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); + SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, + sizeof(SmsMsgHdr_ST)); + rc = smscore_sendrequest_and_wait(coredev, msg, + msg->msgLength, + &coredev->reload_start_done); mem_address = *(UINT32*) &payload[20]; } @@ -568,12 +552,15 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ SmsDataDownload_ST *DataMsg = (SmsDataDownload_ST *) msg; int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); - SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, (UINT16)(sizeof(SmsMsgHdr_ST) + sizeof(UINT32) + payload_size)); + SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, + (UINT16)(sizeof(SmsMsgHdr_ST) + + sizeof(UINT32) + payload_size)); DataMsg->MemAddr = mem_address; memcpy(DataMsg->Payload, payload, payload_size); - if (coredev->device_flags & SMS_ROM_NO_RESPONSE && coredev->mode == DEVICE_MODE_NONE) + if ((coredev->device_flags & SMS_ROM_NO_RESPONSE) && + (coredev->mode == DEVICE_MODE_NONE)) rc = coredev->sendrequest_handler(coredev->context, DataMsg, DataMsg->xMsgHeader.msgLength); else rc = smscore_sendrequest_and_wait(coredev, DataMsg, DataMsg->xMsgHeader.msgLength, &coredev->data_download_done); @@ -583,13 +570,13 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ mem_address += payload_size; } - if (rc >= 0) - { - if (coredev->mode == DEVICE_MODE_NONE) - { - SmsMsgData_ST* TriggerMsg = (SmsMsgData_ST*) msg; + if (rc >= 0) { + if (coredev->mode == DEVICE_MODE_NONE) { + SmsMsgData_ST *TriggerMsg = (SmsMsgData_ST *) msg; - SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, sizeof(SmsMsgHdr_ST) + sizeof(UINT32) * 5); + SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, + sizeof(SmsMsgHdr_ST) + + sizeof(UINT32) * 5); TriggerMsg->msgData[0] = firmware->StartAddress; // Entry point TriggerMsg->msgData[1] = 5; // Priority @@ -597,24 +584,23 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ TriggerMsg->msgData[3] = 0; // Parameter TriggerMsg->msgData[4] = 4; // Task ID - if (coredev->device_flags & SMS_ROM_NO_RESPONSE) - { + if (coredev->device_flags & SMS_ROM_NO_RESPONSE) { rc = coredev->sendrequest_handler(coredev->context, TriggerMsg, TriggerMsg->xMsgHeader.msgLength); msleep(100); - } - else + } else rc = smscore_sendrequest_and_wait(coredev, TriggerMsg, TriggerMsg->xMsgHeader.msgLength, &coredev->trigger_done); - } - else - { - SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, sizeof(SmsMsgHdr_ST)); + } else { + SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, + sizeof(SmsMsgHdr_ST)); - rc = coredev->sendrequest_handler(coredev->context, msg, msg->msgLength); + rc = coredev->sendrequest_handler(coredev->context, + msg, msg->msgLength); } - msleep ( 500 ); + msleep(500); } - printk("%s rc=%d, postload=%p \n", __func__, rc, coredev->postload_handler); + printk("%s rc=%d, postload=%p \n", __func__, rc, + coredev->postload_handler); kfree(msg); @@ -632,7 +618,8 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, size_ * * @return 0 on success, <0 on error. */ -int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, loadfirmware_t loadfirmware_handler) +int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, + loadfirmware_t loadfirmware_handler) { int rc = -ENOENT; @@ -640,30 +627,31 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, l const struct firmware *fw; u8 *fw_buffer; - if (loadfirmware_handler == NULL && !(coredev->device_flags & SMS_DEVICE_FAMILY2)) + if (loadfirmware_handler == NULL && !(coredev->device_flags & + SMS_DEVICE_FAMILY2)) return -EINVAL; rc = request_firmware(&fw, filename, coredev->device); - if (rc < 0) - { - printk(KERN_INFO "%s failed to open \"%s\"\n", __func__, filename); + if (rc < 0) { + printk(KERN_INFO "%s failed to open \"%s\"\n", + __func__, filename); return rc; } - printk(KERN_INFO "%s read FW %s, size=%d\"\n", __func__, filename, fw->size); - fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); - if (fw_buffer) - { + printk(KERN_INFO "%s read FW %s, size=%d\"\n", __func__, + filename, fw->size); + fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), + GFP_KERNEL | GFP_DMA); + if (fw_buffer) { memcpy(fw_buffer, fw->data, fw->size); rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ? - smscore_load_firmware_family2(coredev, fw_buffer, fw->size) : + smscore_load_firmware_family2(coredev, fw_buffer, fw->size) : loadfirmware_handler(coredev->context, fw_buffer, fw->size); kfree(fw_buffer); - } - else - { - printk(KERN_INFO "%s failed to allocate firmware buffer\n", __func__); + } else { + printk(KERN_INFO "%s failed to allocate firmware buffer\n", + __func__); rc = -ENOMEM; } @@ -673,7 +661,8 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, l return rc; } -int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, int size, int new_mode) +int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, + int size, int new_mode) { PERROR("Feature not implemented yet\n"); return -EFAULT; @@ -697,32 +686,33 @@ void smscore_unregister_device(smscore_device_t *coredev) smscore_notify_clients(coredev); smscore_notify_callbacks(coredev, NULL, 0); - // at this point all buffers should be back - // onresponse must no longer be called + /* at this point all buffers should be back + * onresponse must no longer be called */ - while (1) - { - while ((cb = smscore_getbuffer(coredev))) - { + while (1) { + while ((cb = smscore_getbuffer(coredev))) { kfree(cb); num_buffers ++; } if (num_buffers == coredev->num_buffers) break; - if (++retry > 10) - { - printk(KERN_INFO "%s exiting although not all buffers released.\n", __func__); + if (++retry > 10) { + printk(KERN_INFO "%s exiting although " + "not all buffers released.\n", __func__); break; } - printk(KERN_INFO "%s waiting for %d buffer(s)\n", __func__, coredev->num_buffers - num_buffers); + printk(KERN_INFO "%s waiting for %d buffer(s)\n", __func__, + coredev->num_buffers - num_buffers); msleep(100); } printk(KERN_INFO "%s freed %d buffers\n", __func__, num_buffers); if (coredev->common_buffer) - dma_free_coherent(NULL, coredev->common_buffer_size, coredev->common_buffer, coredev->common_buffer_phys); + dma_free_coherent(NULL, coredev->common_buffer_size, + coredev->common_buffer, + coredev->common_buffer_phys); list_del(&coredev->entry); kfree(coredev); @@ -734,7 +724,8 @@ void smscore_unregister_device(smscore_device_t *coredev) int smscore_detect_mode(smscore_device_t *coredev) { - void *buffer = kmalloc(sizeof(SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); + void *buffer = kmalloc(sizeof(SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, + GFP_KERNEL | GFP_DMA); SmsMsgHdr_ST *msg = (SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer); int rc; @@ -743,20 +734,17 @@ int smscore_detect_mode(smscore_device_t *coredev) SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ, sizeof(SmsMsgHdr_ST)); - rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); - if (rc == -ETIME) - { + rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, + &coredev->version_ex_done); + if (rc == -ETIME) { printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __func__); - if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) - { + if (wait_for_completion_timeout(&coredev->resume_done, + msecs_to_jiffies(5000))) { rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc < 0) - { printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __func__, rc); - } - } - else + } else rc = -ETIME; } @@ -765,17 +753,16 @@ int smscore_detect_mode(smscore_device_t *coredev) return rc; } -char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = -{ +char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { /*Stellar NOVA A0 Nova B0 VEGA*/ - /*DVBT*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, - /*DVBH*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, - /*TDMB*/ {"none", "tdmb_nova_12mhz.inp", "none" "none"}, - /*DABIP*/ {"none", "none", "none", "none"}, - /*BDA*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, - /*ISDBT*/ {"none", "isdbt_nova_12mhz.inp", "dvb_nova_12mhz.inp", "none"}, - /*ISDBTBDA*/{"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"}, - /*CMMB*/ {"none", "none", "none", "cmmb_vega_12mhz.inp"} + /*DVBT*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*DVBH*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*TDMB*/ {"none", "tdmb_nova_12mhz.inp", "none", "none"}, + /*DABIP*/ {"none", "none", "none", "none"}, + /*BDA*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*ISDBT*/ {"none", "isdbt_nova_12mhz.inp", "dvb_nova_12mhz.inp", "none"}, + /*ISDBTBDA*/{"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"}, + /*CMMB*/ {"none", "none", "none", "cmmb_vega_12mhz.inp"} }; @@ -794,51 +781,44 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) int rc = 0; sms_device_type_st type; - PDEBUG("set device mode to %d\n", mode ); - if (coredev->device_flags & SMS_DEVICE_FAMILY2) - { - if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) - { - printk(KERN_INFO "%s invalid mode specified %d\n", __func__, mode); + PDEBUG("set device mode to %d\n", mode); + if (coredev->device_flags & SMS_DEVICE_FAMILY2) { + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) { + printk(KERN_INFO "%s invalid mode specified %d\n", + __func__, mode); return -EINVAL; } smscore_registry_setmode(coredev->devpath, mode); - if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) - { + if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) { rc = smscore_detect_mode(coredev); - if (rc < 0) - { - printk(KERN_INFO "%s mode detect failed %d\n", __func__, rc); + if (rc < 0) { + printk(KERN_INFO "%s mode detect failed %d\n", + __func__, rc); return rc; - } + } } - if (coredev->mode == mode) - { - printk(KERN_INFO "%s device mode %d already set\n", __func__, mode); + if (coredev->mode == mode) { + printk(KERN_INFO "%s device mode %d already set\n", + __func__, mode); return 0; } - if (!(coredev->modes_supported & (1 << mode))) - { - type = smscore_registry_gettype ( coredev->devpath ); - rc = smscore_load_firmware_from_file ( coredev, smscore_fw_lkup[mode][type], NULL ); - if (rc < 0) - { + if (!(coredev->modes_supported & (1 << mode))) { + type = smscore_registry_gettype(coredev->devpath); + rc = smscore_load_firmware_from_file(coredev, smscore_fw_lkup[mode][type], NULL); + if (rc < 0) { printk(KERN_INFO "%s load firmware failed %d\n", __func__, rc); return rc; - } - } - else - { + } + } else printk(KERN_INFO "%s mode %d supported by running firmware\n", __func__, mode); - } - buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); - if (buffer) - { + buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, + GFP_KERNEL | GFP_DMA); + if (buffer) { SmsMsgData_ST *msg = (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, sizeof(SmsMsgData_ST)); @@ -847,32 +827,28 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) rc = smscore_sendrequest_and_wait(coredev, msg, msg->xMsgHeader.msgLength, &coredev->init_device_done); kfree(buffer); - } - else - { + } else { printk(KERN_INFO "%s Could not allocate buffer for init device message.\n", __func__); rc = -ENOMEM; - } - } - else - { - if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) - { - printk(KERN_INFO "%s invalid mode specified %d\n", __func__, mode); + } + } else { + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { + printk(KERN_INFO "%s invalid mode specified %d\n", + __func__, mode); return -EINVAL; } smscore_registry_setmode(coredev->devpath, mode); if (coredev->detectmode_handler) - coredev->detectmode_handler(coredev->context, &coredev->mode); + coredev->detectmode_handler(coredev->context, + &coredev->mode); if (coredev->mode != mode && coredev->setmode_handler) rc = coredev->setmode_handler(coredev->context, mode); } - if (rc >= 0) - { + if (rc >= 0) { coredev->mode = mode; coredev->device_flags &= ~SMS_DEVICE_NOT_READY; } @@ -900,7 +876,7 @@ int smscore_get_device_mode(smscore_device_t *coredev) * * @param coredev pointer to a coredev object returned by smscore_register_device * @param data_type client data type (SMS_DONT_CARE for all types) - * @param id client id (SMS_DONT_CARE for all id ) + * @param id client id (SMS_DONT_CARE for all id) * */ smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, int id) @@ -913,20 +889,21 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, spin_lock_irqsave(&coredev->clientslock, flags); first = &coredev->clients; - for (next = first->next; (next != first) && !client; next = next->next) - { - firstid = &((smscore_client_t*)next )->idlist; - for (nextid = firstid->next ; nextid != firstid ; nextid = nextid->next) - { + for (next = first->next; + (next != first) && !client; + next = next->next) { + firstid = &((smscore_client_t*)next)->idlist; + for (nextid = firstid->next; + nextid != firstid; + nextid = nextid->next) { if ((((smscore_idlist_t*)nextid)->id == id) && (((smscore_idlist_t*)nextid)->data_type == data_type || - (((smscore_idlist_t*)nextid)->data_type == 0))) - { - client = (smscore_client_t*) next; - break; + (((smscore_idlist_t*)nextid)->data_type == 0))) { + client = (smscore_client_t*) next; + break; + } } } - } spin_unlock_irqrestore(&coredev->clientslock, flags); return client; } @@ -942,7 +919,8 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) { SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8 *) cb->p + cb->offset); - smscore_client_t *client = smscore_find_client(coredev, phdr->msgType, phdr->msgDstId); + smscore_client_t *client = smscore_find_client(coredev, phdr->msgType, + phdr->msgDstId); int rc = -EBUSY; #if 1 @@ -955,7 +933,9 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) if (time_now - last_sample_time > 10000) { - printk("\n%s data rate %d bytes/secs\n", __func__, (int)((data_total * 1000) / (time_now - last_sample_time))); + printk("\n%s data rate %d bytes/secs\n", __func__, + (int)((data_total * 1000) / + (time_now - last_sample_time))); last_sample_time = time_now; data_total = 0; @@ -963,60 +943,62 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) data_total += cb->size; #endif - /* If no client registered for type & id, check for control client where type is not registered*/ -// if (!client) -// client = smscore_find_client( coredev, 0, phdr->msgDstId); + /* If no client registered for type & id, + * check for control client where type is not registered */ +#if 0 + if (!client) + client = smscore_find_client(coredev, 0, phdr->msgDstId); +#endif if (client) rc = client->onresponse_handler(client->context, cb); - if (rc < 0) - { - switch (phdr->msgType) + if (rc < 0) { + switch (phdr->msgType) { + case MSG_SMS_GET_VERSION_EX_RES: { - case MSG_SMS_GET_VERSION_EX_RES: - { - SmsVersionRes_ST *ver = (SmsVersionRes_ST*) phdr; - printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d prots 0x%x ver %d.%d\n", __func__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); - - coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; - coredev->modes_supported = ver->SupportedProtocols; - - complete(&coredev->version_ex_done); - break; - } - - case MSG_SMS_INIT_DEVICE_RES: - printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __func__); - complete(&coredev->init_device_done); - break; - - case MSG_SW_RELOAD_START_RES: - printk("%s: MSG_SW_RELOAD_START_RES\n", __func__); - complete(&coredev->reload_start_done); - break; - - case MSG_SMS_DATA_DOWNLOAD_RES: - complete(&coredev->data_download_done); - break; - - case MSG_SW_RELOAD_EXEC_RES: - printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __func__); - break; + SmsVersionRes_ST *ver = (SmsVersionRes_ST *) phdr; + printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d " + "prots 0x%x ver %d.%d\n", __func__, + ver->FirmwareId, ver->SupportedProtocols, + ver->RomVersionMajor, ver->RomVersionMinor); - case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __func__); - complete(&coredev->trigger_done); - break; - - case MSG_SMS_SLEEP_RESUME_COMP_IND: - complete(&coredev->resume_done); - break; + coredev->mode = ver->FirmwareId == 255 ? + DEVICE_MODE_NONE : ver->FirmwareId; + coredev->modes_supported = ver->SupportedProtocols; - default: - //printk(KERN_INFO "%s no client (%p) or error (%d), type:%d dstid:%d\n", __func__, client, rc, phdr->msgType, phdr->msgDstId); - break; + complete(&coredev->version_ex_done); + break; + } + case MSG_SMS_INIT_DEVICE_RES: + printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __func__); + complete(&coredev->init_device_done); + break; + case MSG_SW_RELOAD_START_RES: + printk("%s: MSG_SW_RELOAD_START_RES\n", __func__); + complete(&coredev->reload_start_done); + break; + case MSG_SMS_DATA_DOWNLOAD_RES: + complete(&coredev->data_download_done); + break; + case MSG_SW_RELOAD_EXEC_RES: + printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __func__); + break; + case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: + printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", + __func__); + complete(&coredev->trigger_done); + break; + case MSG_SMS_SLEEP_RESUME_COMP_IND: + complete(&coredev->resume_done); + break; + default: +#if 0 + printk(KERN_INFO "%s no client (%p) or error (%d), " + "type:%d dstid:%d\n", __func__, client, rc, + phdr->msgType, phdr->msgDstId); +#endif + break; } - smscore_putbuffer(coredev, cb); } } @@ -1035,8 +1017,7 @@ smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) spin_lock_irqsave(&coredev->bufferslock, flags); - if (!list_empty(&coredev->buffers)) - { + if (!list_empty(&coredev->buffers)) { cb = (smscore_buffer_t *) coredev->buffers.next; list_del(&cb->entry); } @@ -1058,35 +1039,33 @@ void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb) list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); } -int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int data_type, int id) +int smscore_validate_client(smscore_device_t *coredev, + smscore_client_t *client, int data_type, int id) { smscore_idlist_t *listentry; smscore_client_t *registered_client; - if ( !client ) - { + if (!client) { PERROR("bad parameter.\n"); return -EFAULT; } registered_client = smscore_find_client(coredev, data_type, id); - if (registered_client == client) - { + if (registered_client == client) { return 0; } - if (registered_client) - { + if (registered_client) { PERROR("The msg ID already registered to another client.\n"); return -EEXIST; } - listentry = kzalloc ( sizeof ( smscore_idlist_t ), GFP_KERNEL ); - if ( !listentry ) - { + listentry = kzalloc(sizeof(smscore_idlist_t), GFP_KERNEL); + if (!listentry) { PERROR("Can't allocate memory for client id.\n"); return -ENOMEM; } listentry->id = id; listentry->data_type = data_type; - list_add_locked ( &listentry->entry, &client->idlist, &coredev->clientslock ); + list_add_locked(&listentry->entry, &client->idlist, + &coredev->clientslock); return 0; } @@ -1106,29 +1085,31 @@ int smscore_validate_client(smscore_device_t *coredev, smscore_client_t *client, int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) { smscore_client_t *newclient; - // check that no other channel with same parameters exists - if (smscore_find_client(coredev, params->data_type, params->initial_id)) - { + /* check that no other channel with same parameters exists */ + if (smscore_find_client(coredev, params->data_type, + params->initial_id)) { PERROR("Client already exist.\n"); return -EEXIST; } newclient = kzalloc(sizeof(smscore_client_t), GFP_KERNEL); - if (!newclient) - { + if (!newclient) { PERROR("Failed to allocate memory for client.\n"); return -ENOMEM; } - INIT_LIST_HEAD ( &newclient->idlist); + INIT_LIST_HEAD(&newclient->idlist); newclient->coredev = coredev; newclient->onresponse_handler = params->onresponse_handler; newclient->onremove_handler = params->onremove_handler; newclient->context = params->context; - list_add_locked(&newclient->entry, &coredev->clients, &coredev->clientslock); - smscore_validate_client(coredev, newclient, params->data_type, params->initial_id); + list_add_locked(&newclient->entry, &coredev->clients, + &coredev->clientslock); + smscore_validate_client(coredev, newclient, params->data_type, + params->initial_id); *client = newclient; - PDEBUG ( "%p %d %d\n", params->context, params->data_type, params->initial_id ); + PDEBUG("%p %d %d\n", params->context, params->data_type, + params->initial_id); return 0; } @@ -1147,11 +1128,11 @@ void smscore_unregister_client(smscore_client_t *client) spin_lock_irqsave(&coredev->clientslock, flags); - while (!list_empty( &client->idlist)) - { - smscore_idlist_t *identry = (smscore_idlist_t*)client->idlist.next; - list_del ( &identry->entry ); - kfree ( identry ); + while (!list_empty(&client->idlist)) { + smscore_idlist_t *identry = + (smscore_idlist_t*) client->idlist.next; + list_del(&identry->entry); + kfree(identry); } printk(KERN_INFO "%s %p\n", __func__, client->context); @@ -1178,22 +1159,21 @@ int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) buffer; int rc; - if ( client == NULL ) - { - printk(KERN_ERR "%s Got NULL client\n", __func__ ); + if (client == NULL) { + printk(KERN_ERR "%s Got NULL client\n", __func__); return -EINVAL; } coredev = client->coredev; - // check that no other channel with same id exists - if ( coredev == NULL ) - { - printk(KERN_ERR "%s Got NULL coredev\n", __func__ ); + /* check that no other channel with same id exists */ + if (coredev == NULL) { + printk(KERN_ERR "%s Got NULL coredev\n", __func__); return -EINVAL; } - rc = smscore_validate_client(client->coredev, client, 0, phdr->msgSrcId); + rc = smscore_validate_client(client->coredev, client, 0, + phdr->msgSrcId); if (rc < 0) return rc; @@ -1223,24 +1203,28 @@ int smscore_get_common_buffer_size(smscore_device_t *coredev) int smscore_map_common_buffer(smscore_device_t *coredev, struct vm_area_struct *vma) { - unsigned long end = vma->vm_end, start = vma->vm_start, size = PAGE_ALIGN(coredev->common_buffer_size); + unsigned long end = vma->vm_end, + start = vma->vm_start, + size = PAGE_ALIGN(coredev->common_buffer_size); - if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) - { + if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || + (vma->vm_flags & VM_WRITE)) { printk(KERN_INFO "%s invalid vm flags\n", __func__); return -EINVAL; } - if ((end - start) != size) - { - printk(KERN_INFO "%s invalid size %d expected %d\n", __func__, (int)(end - start), (int) size); + if ((end - start) != size) { + printk(KERN_INFO "%s invalid size %d expected %d\n", + __func__, (int)(end - start), (int) size); return -EINVAL; } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) if (remap_page_range(vma, start, coredev->common_buffer_phys, size, vma->vm_page_prot)) #else - if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) + if (remap_pfn_range(vma, start, + coredev->common_buffer_phys >> PAGE_SHIFT, + size, pgprot_noncached(vma->vm_page_prot))) #endif { printk(KERN_INFO "%s remap_page_range failed\n", __func__); @@ -1276,9 +1260,9 @@ void smscore_module_exit(void) { kmutex_lock(&g_smscore_deviceslock); - while (!list_empty(&g_smscore_notifyees)) - { - smscore_device_notifyee_t *notifyee = (smscore_device_notifyee_t *) g_smscore_notifyees.next; + while (!list_empty(&g_smscore_notifyees)) { + smscore_device_notifyee_t *notifyee = + (smscore_device_notifyee_t *) g_smscore_notifyees.next; list_del(¬ifyee->entry); kfree(notifyee); @@ -1286,9 +1270,9 @@ void smscore_module_exit(void) kmutex_unlock(&g_smscore_deviceslock); kmutex_lock(&g_smscore_registrylock); - while (!list_empty(&g_smscore_registry)) - { - smscore_registry_entry_t *entry = (smscore_registry_entry_t *) g_smscore_registry.next; + while (!list_empty(&g_smscore_registry)) { + smscore_registry_entry_t *entry = + (smscore_registry_entry_t *) g_smscore_registry.next; list_del(&entry->entry); kfree(entry); @@ -1308,6 +1292,5 @@ module_init(smscore_module_init); module_exit(smscore_module_exit); MODULE_DESCRIPTION("smscore"); -MODULE_AUTHOR ( "Siano Mobile Silicon,,, (doronc@siano-ms.com)" ); +MODULE_AUTHOR("Siano Mobile Silicon,,, (doronc@siano-ms.com)"); MODULE_LICENSE("GPL"); - diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index ce317adb0..5ce04568a 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -57,7 +57,7 @@ typedef struct semaphore kmutex_t; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) void *kzalloc(size_t size, int flags); #endif -#endif // LINUX_VERSION +#endif /* LINUX_VERSION */ #ifndef min #define min(a,b) (((a) < (b)) ? (a) : (b)) @@ -97,12 +97,12 @@ typedef void (*onremove_t)(void *context); typedef struct _smscore_buffer { - // public members, once passed to clients can be changed freely + /* public members, once passed to clients can be changed freely */ struct list_head entry; int size; int offset; - // private members, read-only for clients + /* private members, read-only for clients */ void *p; dma_addr_t phys; unsigned long offset_in_common; @@ -138,7 +138,7 @@ typedef struct _smsclient_params void *context; } smsclient_params_t; -// GPIO definitions for antenna frequency domain control (SMS8021) +/* GPIO definitions for antenna frequency domain control (SMS8021) */ #define SMS_ANTENNA_GPIO_0 1 #define SMS_ANTENNA_GPIO_1 0 @@ -238,7 +238,7 @@ typedef struct SmsMsgHdr_S UINT16 msgType; UINT8 msgSrcId; UINT8 msgDstId; - UINT16 msgLength; // Length is of the entire message, including header + UINT16 msgLength; /* Length of entire message, including header */ UINT16 msgFlags; } SmsMsgHdr_ST; @@ -259,24 +259,24 @@ typedef struct SmsVersionRes_S { SmsMsgHdr_ST xMsgHeader; - UINT16 ChipModel; // e.g. 0x1102 for SMS-1102 "Nova" - UINT8 Step; // 0 - Step A - UINT8 MetalFix; // 0 - Metal 0 + UINT16 ChipModel; /* e.g. 0x1102 for SMS-1102 "Nova" */ + UINT8 Step; /* 0 - Step A */ + UINT8 MetalFix; /* 0 - Metal 0 */ - UINT8 FirmwareId; // 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E - UINT8 SupportedProtocols; // Bitwise OR combination of supported protocols + UINT8 FirmwareId; /* 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E */ + UINT8 SupportedProtocols; /* Bitwise OR combination of supported protocols */ - UINT8 VersionMajor; - UINT8 VersionMinor; - UINT8 VersionPatch; - UINT8 VersionFieldPatch; + UINT8 VersionMajor; + UINT8 VersionMinor; + UINT8 VersionPatch; + UINT8 VersionFieldPatch; - UINT8 RomVersionMajor; - UINT8 RomVersionMinor; - UINT8 RomVersionPatch; - UINT8 RomVersionFieldPatch; + UINT8 RomVersionMajor; + UINT8 RomVersionMinor; + UINT8 RomVersionPatch; + UINT8 RomVersionFieldPatch; - UINT8 TextLabel[34]; + UINT8 TextLabel[34]; } SmsVersionRes_ST; typedef struct SmsFirmware_S @@ -289,59 +289,60 @@ typedef struct SmsFirmware_S typedef struct SMSHOSTLIB_STATISTICS_S { - UINT32 Reserved; //!< Reserved - - /// Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - /// Reception quality - INT32 SNR; //!< dB - UINT32 BER; //!< Post Viterbi BER [1E-5] - UINT32 FIB_CRC; //!< CRC errors percentage, valid only for DAB - UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H - UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in bin/1024 - - /// Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz, valid only for DVB-T/H - UINT32 TransmissionMode; //!< Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos - UINT32 ModemState; //!< from SMS_DvbModemState_ET , valid only for DVB-T/H - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value , valid only for DVB-T/H - UINT32 CodeRate; //!< Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H - UINT32 LPCodeRate; //!< Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H - UINT32 Hierarchy; //!< Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H - UINT32 Constellation; //!< Constellation from SMS_Constellation_ET, valid only for DVB-T/H - - /// Burst parameters, valid only for DVB-H - UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H - UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H - UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H - UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H - UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H - UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H - UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding - UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding - UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding - /// Common params - UINT32 BERErrorCount; //!< Number of errornous SYNC bits. - UINT32 BERBitCount; //!< Total number of SYNC bits. - - /// Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. - - /// DAB/T-DMB - UINT32 PreBER; //!< DAB/T-DMB only: Pre Viterbi BER [1E-5] - - /// DVB-H TPS parameters - UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered + UINT32 Reserved; /* Reserved */ + + /* Common parameters */ + UINT32 IsRfLocked; /* 0 - not locked, 1 - locked */ + UINT32 IsDemodLocked; /* 0 - not locked, 1 - locked */ + UINT32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ + + /* Reception quality */ + INT32 SNR; /* dB */ + UINT32 BER; /* Post Viterbi BER [1E-5] */ + UINT32 FIB_CRC; /* CRC errors percentage, valid only for DAB */ + UINT32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H */ + UINT32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ + INT32 RSSI; /* dBm */ + INT32 InBandPwr; /* In band power in dBM */ + INT32 CarrierOffset; /* Carrier Offset in bin/1024 */ + + /* Transmission parameters */ + UINT32 Frequency; /* Frequency in Hz */ + UINT32 Bandwidth; /* Bandwidth in MHz, valid only for DVB-T/H */ + UINT32 TransmissionMode; /* Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos */ + UINT32 ModemState; /* from SMS_DvbModemState_ET , valid only for DVB-T/H */ + UINT32 GuardInterval; /* Guard Interval, 1 divided by value , valid only for DVB-T/H */ + UINT32 CodeRate; /* Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ + UINT32 LPCodeRate; /* Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ + UINT32 Hierarchy; /* Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H */ + UINT32 Constellation; /* Constellation from SMS_Constellation_ET, valid only for DVB-T/H */ + + /* Burst parameters, valid only for DVB-H */ + UINT32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ + UINT32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ + UINT32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ + UINT32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ + UINT32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ + UINT32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ + UINT32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ + UINT32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ + UINT32 TotalTSPackets; /* Total number of transport-stream packets */ + UINT32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding */ + UINT32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding */ + UINT32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding */ + + /* Common params */ + UINT32 BERErrorCount; /* Number of errornous SYNC bits. */ + UINT32 BERBitCount; /* Total number of SYNC bits. */ + + /* Interface information */ + UINT32 SmsToHostTxErrors; /* Total number of transmission errors. */ + + /* DAB/T-DMB */ + UINT32 PreBER; /* DAB/T-DMB only: Pre Viterbi BER [1E-5] */ + + /* DVB-H TPS parameters */ + UINT32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ } SMSHOSTLIB_STATISTICS_ST; @@ -351,147 +352,151 @@ typedef struct SMSHOSTLIB_STATISTICS_ST Stat; - // Split the calc of the SNR in DAB - UINT32 Signal; //!< dB - UINT32 Noise; //!< dB + /* Split the calc of the SNR in DAB */ + UINT32 Signal; /* dB */ + UINT32 Noise; /* dB */ } SmsMsgStatisticsInfo_ST; typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S { - // Per-layer information - UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist - UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist - UINT32 BER; //!< Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A - UINT32 BERErrorCount; //!< Post Viterbi Error Bits Count - UINT32 BERBitCount; //!< Post Viterbi Total Bits Count - UINT32 PreBER; //!< Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A - UINT32 TS_PER; //!< Transport stream PER [%], 0xFFFFFFFF indicate N/A - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 TILdepthI; //!< Time interleaver depth I parameter, 255 means layer does not exist - UINT32 NumberOfSegments; //!< Number of segments in layer A, 255 means layer does not exist - UINT32 TMCCErrors; //!< TMCC errors + /* Per-layer information */ + UINT32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist */ + UINT32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist */ + UINT32 BER; /* Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ + UINT32 BERErrorCount; /* Post Viterbi Error Bits Count */ + UINT32 BERBitCount; /* Post Viterbi Total Bits Count */ + UINT32 PreBER; /* Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ + UINT32 TS_PER; /* Transport stream PER [%], 0xFFFFFFFF indicate N/A */ + UINT32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ + UINT32 TotalTSPackets; /* Total number of transport-stream packets */ + UINT32 TILdepthI; /* Time interleaver depth I parameter, 255 means layer does not exist */ + UINT32 NumberOfSegments; /* Number of segments in layer A, 255 means layer does not exist */ + UINT32 TMCCErrors; /* TMCC errors */ } SMSHOSTLIB_ISDBT_LAYER_STAT_ST; typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S { - UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - //!< This fiels MUST always first in any statistics structure - - UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by - //!< the host is smaller than FullSize, the struct will be truncated - - // Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - // Reception quality - INT32 SNR; //!< dB - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in Hz - - // Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz - UINT32 TransmissionMode; //!< ISDB-T transmission mode - UINT32 ModemState; //!< 0 - Acquisition, 1 - Locked - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value - UINT32 SystemType; //!< ISDB-T system type (ISDB-T / ISDB-Tsb) - UINT32 PartialReception; //!< TRUE - partial reception, FALSE otherwise - UINT32 NumOfLayers; //!< Number of ISDB-T layers in the network - - // Per-layer information - // Layers A, B and C - SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; //!< Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST - - // Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + UINT32 StatisticsType; /* Enumerator identifying the type of the + * structure. Values are the same as + * SMSHOSTLIB_DEVICE_MODES_E + * + * This field MUST always be first in any + * statistics structure */ + + UINT32 FullSize; /* Total size of the structure returned by the modem. If the size requested by + * the host is smaller than FullSize, the struct will be truncated */ + + /* Common parameters */ + UINT32 IsRfLocked; /* 0 - not locked, 1 - locked */ + UINT32 IsDemodLocked; /* 0 - not locked, 1 - locked */ + UINT32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ + + /* Reception quality */ + INT32 SNR; /* dB */ + INT32 RSSI; /* dBm */ + INT32 InBandPwr; /* In band power in dBM */ + INT32 CarrierOffset; /* Carrier Offset in Hz */ + + /* Transmission parameters */ + UINT32 Frequency; /* Frequency in Hz */ + UINT32 Bandwidth; /* Bandwidth in MHz */ + UINT32 TransmissionMode; /* ISDB-T transmission mode */ + UINT32 ModemState; /* 0 - Acquisition, 1 - Locked */ + UINT32 GuardInterval; /* Guard Interval, 1 divided by value */ + UINT32 SystemType; /* ISDB-T system type (ISDB-T / ISDB-Tsb) */ + UINT32 PartialReception; /* TRUE - partial reception, FALSE otherwise */ + UINT32 NumOfLayers; /* Number of ISDB-T layers in the network */ + + /* Per-layer information */ + /* Layers A, B and C */ + SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; /* Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST */ + + /* Interface information */ + UINT32 SmsToHostTxErrors; /* Total number of transmission errors. */ } SMSHOSTLIB_STATISTICS_ISDBT_ST; typedef struct SMSHOSTLIB_STATISTICS_DVB_S { - UINT32 StatisticsType; //!< Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - //!< This fiels MUST always first in any statistics structure - - UINT32 FullSize; //!< Total size of the structure returned by the modem. If the size requested by - //!< the host is smaller than FullSize, the struct will be truncated - // Common parameters - UINT32 IsRfLocked; //!< 0 - not locked, 1 - locked - UINT32 IsDemodLocked; //!< 0 - not locked, 1 - locked - UINT32 IsExternalLNAOn; //!< 0 - external LNA off, 1 - external LNA on - - // Reception quality - INT32 SNR; //!< dB - UINT32 BER; //!< Post Viterbi BER [1E-5] - UINT32 BERErrorCount; //!< Number of errornous SYNC bits. - UINT32 BERBitCount; //!< Total number of SYNC bits. - UINT32 TS_PER; //!< Transport stream PER, 0xFFFFFFFF indicate N/A - UINT32 MFER; //!< DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H - INT32 RSSI; //!< dBm - INT32 InBandPwr; //!< In band power in dBM - INT32 CarrierOffset; //!< Carrier Offset in bin/1024 - - // Transmission parameters - UINT32 Frequency; //!< Frequency in Hz - UINT32 Bandwidth; //!< Bandwidth in MHz - UINT32 ModemState; //!< from SMSHOSTLIB_DVB_MODEM_STATE_ET - UINT32 TransmissionMode; //!< FFT mode carriers in Kilos - UINT32 GuardInterval; //!< Guard Interval, 1 divided by value - UINT32 CodeRate; //!< Code Rate from SMSHOSTLIB_CODE_RATE_ET - UINT32 LPCodeRate; //!< Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET - UINT32 Hierarchy; //!< Hierarchy from SMSHOSTLIB_HIERARCHY_ET - UINT32 Constellation; //!< Constellation from SMSHOSTLIB_CONSTELLATION_ET - - // Burst parameters, valid only for DVB-H - UINT32 BurstSize; //!< Current burst size in bytes, valid only for DVB-H - UINT32 BurstDuration; //!< Current burst duration in mSec, valid only for DVB-H - UINT32 BurstCycleTime; //!< Current burst cycle time in mSec, valid only for DVB-H - UINT32 CalculatedBurstCycleTime;//!< Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H - UINT32 NumOfRows; //!< Number of rows in MPE table, valid only for DVB-H - UINT32 NumOfPaddCols; //!< Number of padding columns in MPE table, valid only for DVB-H - UINT32 NumOfPunctCols; //!< Number of puncturing columns in MPE table, valid only for DVB-H - UINT32 ErrorTSPackets; //!< Number of erroneous transport-stream packets - UINT32 TotalTSPackets; //!< Total number of transport-stream packets - UINT32 NumOfValidMpeTlbs; //!< Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H - UINT32 NumOfInvalidMpeTlbs; //!< Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H - UINT32 NumOfCorrectedMpeTlbs; //!< Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H - UINT32 NumMPEReceived; //!< DVB-H, Num MPE section received - - // DVB-H TPS parameters - UINT32 CellId; //!< TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered - UINT32 DvbhSrvIndHP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator - UINT32 DvbhSrvIndLP; //!< DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator - - // Interface information - UINT32 SmsToHostTxErrors; //!< Total number of transmission errors. + UINT32 StatisticsType; /* Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + * This fiels MUST always first in any statistics structure */ + + UINT32 FullSize; /* Total size of the structure returned by the modem. If the size requested by + * the host is smaller than FullSize, the struct will be truncated */ + /* Common parameters */ + UINT32 IsRfLocked; /* 0 - not locked, 1 - locked */ + UINT32 IsDemodLocked; /* 0 - not locked, 1 - locked */ + UINT32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ + + /* Reception quality */ + INT32 SNR; /* dB */ + UINT32 BER; /* Post Viterbi BER [1E-5] */ + UINT32 BERErrorCount; /* Number of errornous SYNC bits. */ + UINT32 BERBitCount; /* Total number of SYNC bits. */ + UINT32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A */ + UINT32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ + INT32 RSSI; /* dBm */ + INT32 InBandPwr; /* In band power in dBM */ + INT32 CarrierOffset; /* Carrier Offset in bin/1024 */ + + /* Transmission parameters */ + UINT32 Frequency; /* Frequency in Hz */ + UINT32 Bandwidth; /* Bandwidth in MHz */ + UINT32 ModemState; /* from SMSHOSTLIB_DVB_MODEM_STATE_ET */ + UINT32 TransmissionMode; /* FFT mode carriers in Kilos */ + UINT32 GuardInterval; /* Guard Interval, 1 divided by value */ + UINT32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET */ + UINT32 LPCodeRate; /* Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET */ + UINT32 Hierarchy; /* Hierarchy from SMSHOSTLIB_HIERARCHY_ET */ + UINT32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET */ + + /* Burst parameters, valid only for DVB-H */ + UINT32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ + UINT32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ + UINT32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ + UINT32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ + UINT32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ + UINT32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ + UINT32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ + UINT32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ + UINT32 TotalTSPackets; /* Total number of transport-stream packets */ + UINT32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H */ + UINT32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H */ + UINT32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H */ + UINT32 NumMPEReceived; /* DVB-H, Num MPE section received */ + + /* DVB-H TPS parameters */ + UINT32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ + UINT32 DvbhSrvIndHP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ + UINT32 DvbhSrvIndLP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ + + /* Interface information */ + UINT32 SmsToHostTxErrors; /* Total number of transmission errors. */ } SMSHOSTLIB_STATISTICS_DVB_ST; typedef struct SMSHOSTLIB_GPIO_CONFIG_S { - UINT8 Direction; //!< GPIO direction: Input - 0, Output - 1 - UINT8 PullUpDown; //!< PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 - UINT8 InputCharacteristics; //!< Input Characteristics: Normal - 0, Schmitt trigger - 1 - UINT8 OutputSlewRate; //!< Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 - UINT8 OutputDriving; //!< Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 + UINT8 Direction; /* GPIO direction: Input - 0, Output - 1 */ + UINT8 PullUpDown; /* PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 */ + UINT8 InputCharacteristics; /* Input Characteristics: Normal - 0, Schmitt trigger - 1 */ + UINT8 OutputSlewRate; /* Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 */ + UINT8 OutputDriving; /* Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 */ } SMSHOSTLIB_GPIO_CONFIG_ST; typedef struct SMSHOSTLIB_I2C_REQ_S { - UINT32 DeviceAddress; // I2c device address - UINT32 WriteCount; // number of bytes to write - UINT32 ReadCount; // number of bytes to read + UINT32 DeviceAddress; /* I2c device address */ + UINT32 WriteCount; /* number of bytes to write */ + UINT32 ReadCount; /* number of bytes to read */ UINT8 Data[1]; } SMSHOSTLIB_I2C_REQ_ST; typedef struct SMSHOSTLIB_I2C_RES_S { - UINT32 Status; // non-zero value in case of failure - UINT32 ReadCount; // number of bytes read + UINT32 Status; /* non-zero value in case of failure */ + UINT32 ReadCount; /* number of bytes read */ UINT8 Data[1]; } SMSHOSTLIB_I2C_RES_ST; @@ -507,12 +512,12 @@ typedef struct _smsdvb_client struct dmxdev dmxdev; struct dvb_frontend frontend; - fe_status_t fe_status; - int fe_ber, fe_snr, fe_signal_strength; + fe_status_t fe_status; + int fe_ber, fe_snr, fe_signal_strength; struct completion tune_done, stat_done; - // todo: save freq/band instead whole struct + /* todo: save freq/band instead whole struct */ struct dvb_frontend_parameters fe_params; } smsdvb_client_t; @@ -523,14 +528,17 @@ extern int smscore_registry_getmode(char *devpath); extern int smscore_register_hotplug(hotplug_t hotplug); extern void smscore_unregister_hotplug(hotplug_t hotplug); -extern int smscore_register_device(smsdevice_params_t *params, smscore_device_t **coredev); +extern int smscore_register_device(smsdevice_params_t *params, + smscore_device_t **coredev); extern void smscore_unregister_device(smscore_device_t *coredev); extern int smscore_start_device(smscore_device_t *coredev); extern int smscore_load_firmware(smscore_device_t *coredev, char *filename, loadfirmware_t loadfirmware_handler); -extern int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, int size, int new_mode); +extern int smscore_load_firmware_from_buffer(smscore_device_t *coredev, + u8 *buffer, int size, + int new_mode); extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); extern int smscore_get_device_mode(smscore_device_t *coredev); @@ -540,8 +548,10 @@ extern int smscore_register_client(smscore_device_t *coredev, smscore_client_t **client); extern void smscore_unregister_client(smscore_client_t *client); -extern int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size); -extern void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb); +extern int smsclient_sendrequest(smscore_client_t *client, + void *buffer, size_t size); +extern void smscore_onresponse(smscore_device_t *coredev, + smscore_buffer_t *cb); extern int smscore_get_common_buffer_size(smscore_device_t *coredev); extern int smscore_map_common_buffer(smscore_device_t *coredev, @@ -558,4 +568,4 @@ void smsdvb_unregister(void); int smsusb_register(void); void smsusb_unregister(void); -#endif // __smscoreapi_h__ +#endif /* __smscoreapi_h__ */ diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index e02e011df..63b8f6a27 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -34,47 +34,49 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) smsdvb_client_t *client = (smsdvb_client_t *) context; SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8 *) cb->p) + cb->offset); - switch(phdr->msgType) - { - case MSG_SMS_DVBT_BDA_DATA: - dvb_dmx_swfilter(&client->demux, (u8 *)(phdr + 1), - cb->size - sizeof(SmsMsgHdr_ST)); - break; + switch(phdr->msgType) { + case MSG_SMS_DVBT_BDA_DATA: + dvb_dmx_swfilter(&client->demux, (u8 *)(phdr + 1), + cb->size - sizeof(SmsMsgHdr_ST)); + break; + + case MSG_SMS_RF_TUNE_RES: + complete(&client->tune_done); + break; - case MSG_SMS_RF_TUNE_RES: - complete(&client->tune_done); - break; + case MSG_SMS_GET_STATISTICS_RES: + { + SmsMsgStatisticsInfo_ST *p = + (SmsMsgStatisticsInfo_ST *)(phdr + 1); - case MSG_SMS_GET_STATISTICS_RES: + if (p->Stat.IsDemodLocked) { - SmsMsgStatisticsInfo_ST *p = - (SmsMsgStatisticsInfo_ST *)(phdr + 1); - - if (p->Stat.IsDemodLocked) - { - client->fe_status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK; - client->fe_snr = p->Stat.SNR; - client->fe_ber = p->Stat.BER; - - if (p->Stat.InBandPwr < -95) - client->fe_signal_strength = 0; - else if (p->Stat.InBandPwr > -29) - client->fe_signal_strength = 100; - else - client->fe_signal_strength = (p->Stat.InBandPwr + 95) * 3 / 2; - } - else - { - client->fe_status = 0; - client->fe_snr = - client->fe_ber = - client->fe_signal_strength = 0; - } + client->fe_status = FE_HAS_SIGNAL | + FE_HAS_CARRIER | + FE_HAS_VITERBI | + FE_HAS_SYNC | + FE_HAS_LOCK; + + client->fe_snr = p->Stat.SNR; + client->fe_ber = p->Stat.BER; - complete(&client->stat_done); - break; + if (p->Stat.InBandPwr < -95) + client->fe_signal_strength = 0; + else if (p->Stat.InBandPwr > -29) + client->fe_signal_strength = 100; + else + client->fe_signal_strength = + (p->Stat.InBandPwr + 95) * 3 / 2; + } else { + client->fe_status = 0; + client->fe_snr = + client->fe_ber = + client->fe_signal_strength = 0; } - } + + complete(&client->stat_done); + break; + } } smscore_putbuffer(client->coredev, cb); @@ -106,7 +108,8 @@ void smsdvb_onremove(void *context) static int smsdvb_start_feed(struct dvb_demux_feed *feed) { - smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); + smsdvb_client_t *client = + container_of(feed->demux, smsdvb_client_t, demux); SmsMsgData_ST PidMsg; printk("%s add pid %d(%x)\n", __func__, feed->pid, feed->pid); @@ -118,12 +121,14 @@ static int smsdvb_start_feed(struct dvb_demux_feed *feed) PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); PidMsg.msgData[0] = feed->pid; - return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); + return smsclient_sendrequest(client->smsclient, + &PidMsg, sizeof(PidMsg)); } static int smsdvb_stop_feed(struct dvb_demux_feed *feed) { - smsdvb_client_t *client = container_of(feed->demux, smsdvb_client_t, demux); + smsdvb_client_t *client = + container_of(feed->demux, smsdvb_client_t, demux); SmsMsgData_ST PidMsg; printk("%s remove pid %d(%x)\n", __func__, feed->pid, feed->pid); @@ -135,7 +140,8 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) PidMsg.xMsgHeader.msgLength = sizeof(PidMsg); PidMsg.msgData[0] = feed->pid; - return smsclient_sendrequest(client->smsclient, &PidMsg, sizeof(PidMsg)); + return smsclient_sendrequest(client->smsclient, + &PidMsg, sizeof(PidMsg)); } static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, @@ -146,13 +152,18 @@ static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, if (rc < 0) return rc; - return wait_for_completion_timeout(completion, msecs_to_jiffies(2000)) ? 0 : -ETIME; + return wait_for_completion_timeout(completion, + msecs_to_jiffies(2000)) ? + 0 : -ETIME; } static int smsdvb_send_statistics_request(smsdvb_client_t *client) { - SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, DVBT_BDA_CONTROL_MSG_ID, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; - return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->stat_done); + SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, + DVBT_BDA_CONTROL_MSG_ID, + HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), + &client->stat_done); } static int smsdvb_read_status(struct dvb_frontend *fe, fe_status_t *stat) @@ -199,7 +210,8 @@ static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) return rc; } -static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) +static int smsdvb_get_tune_settings(struct dvb_frontend *fe, + struct dvb_frontend_tune_settings *tune) { printk("%s\n", __func__); @@ -209,14 +221,15 @@ static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend return 0; } -static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) +static int smsdvb_set_frontend(struct dvb_frontend *fe, + struct dvb_frontend_parameters *fep) { smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); struct { SmsMsgHdr_ST Msg; - u32 Data[3]; + u32 Data[3]; } Msg; Msg.Msg.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; @@ -227,29 +240,35 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_para Msg.Data[0] = fep->frequency; Msg.Data[2] = 12000000; - printk("%s freq %d band %d\n", __func__, fep->frequency, fep->u.ofdm.bandwidth); + printk("%s freq %d band %d\n", __func__, + fep->frequency, fep->u.ofdm.bandwidth); switch(fep->u.ofdm.bandwidth) { case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; case BANDWIDTH_7_MHZ: Msg.Data[1] = BW_7_MHZ; break; case BANDWIDTH_6_MHZ: Msg.Data[1] = BW_6_MHZ; break; -// case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; +#if 0 + case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; +#endif case BANDWIDTH_AUTO: return -EOPNOTSUPP; default: return -EINVAL; } - return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->tune_done); + return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), + &client->tune_done); } -static int smsdvb_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) +static int smsdvb_get_frontend(struct dvb_frontend *fe, + struct dvb_frontend_parameters *fep) { smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); printk("%s\n", __func__); // todo: - memcpy(fep, &client->fe_params, sizeof(struct dvb_frontend_parameters)); + memcpy(fep, &client->fe_params, + sizeof(struct dvb_frontend_parameters)); return 0; } @@ -260,19 +279,19 @@ static void smsdvb_release(struct dvb_frontend *fe) static struct dvb_frontend_ops smsdvb_fe_ops = { .info = { - .name = "Siano Mobile Digital SMS10xx", - .type = FE_OFDM, + .name = "Siano Mobile Digital SMS10xx", + .type = FE_OFDM, .frequency_min = 44250000, .frequency_max = 867250000, .frequency_stepsize = 250000, .caps = FE_CAN_INVERSION_AUTO | - FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | - FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | - FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO | - FE_CAN_TRANSMISSION_MODE_AUTO | - FE_CAN_GUARD_INTERVAL_AUTO | - FE_CAN_RECOVER | - FE_CAN_HIERARCHY_AUTO, + FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | + FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO | + FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | + FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO | + FE_CAN_GUARD_INTERVAL_AUTO | + FE_CAN_RECOVER | + FE_CAN_HIERARCHY_AUTO, }, .release = smsdvb_release, @@ -287,8 +306,8 @@ static struct dvb_frontend_ops smsdvb_fe_ops = { .read_snr = smsdvb_read_snr, }; -int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, - int arrival) +int smsdvb_hotplug(smscore_device_t *coredev, + struct device *device, int arrival) { smsclient_params_t params; smsdvb_client_t *client; @@ -298,8 +317,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, if (!arrival) return 0; - if (smscore_get_device_mode(coredev) != 4) - { + if (smscore_get_device_mode(coredev) != 4) { #if 1 // new siano drop (1.2.17) does this -- yuck printk(KERN_ERR "%sSMS Device mode is not set for DVB operation.\n", __func__); return 0; @@ -311,16 +329,15 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, } client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); - if (!client) - { + if (!client) { printk(KERN_INFO "%s kmalloc() failed\n", __func__); return -ENOMEM; } // register dvb adapter - rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device, adapter_nr); - if (rc < 0) - { + rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", + THIS_MODULE, device, adapter_nr); + if (rc < 0) { printk("%s dvb_register_adapter() failed %d\n", __func__, rc); goto adapter_error; } @@ -333,8 +350,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, client->demux.stop_feed = smsdvb_stop_feed; rc = dvb_dmx_init(&client->demux); - if (rc < 0) - { + if (rc < 0) { printk("%s dvb_dmx_init failed %d\n\n", __func__, rc); goto dvbdmx_error; } @@ -345,18 +361,17 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, client->dmxdev.capabilities = 0; rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); - if (rc < 0) - { + if (rc < 0) { printk("%s dvb_dmxdev_init failed %d\n", __func__, rc); goto dmxdev_error; } // init and register frontend - memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); + memcpy(&client->frontend.ops, &smsdvb_fe_ops, + sizeof(struct dvb_frontend_ops)); rc = dvb_register_frontend(&client->adapter, &client->frontend); - if (rc < 0) - { + if (rc < 0) { printk("%s frontend registration failed %d\n", __func__, rc); goto frontend_error; } @@ -368,9 +383,9 @@ int smsdvb_hotplug(smscore_device_t *coredev, struct device *device, params.context = client; rc = smscore_register_client(coredev, ¶ms, &client->smsclient); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_register_client() failed %d\n", __func__, rc); + if (rc < 0) { + printk(KERN_INFO "%s smscore_register_client() failed %d\n", + __func__, rc); goto client_error; } @@ -427,9 +442,8 @@ void smsdvb_unregister(void) kmutex_lock(&g_smsdvb_clientslock); while (!list_empty(&g_smsdvb_clients)) - smsdvb_unregister_client((smsdvb_client_t *) g_smsdvb_clients.next); + smsdvb_unregister_client( + (smsdvb_client_t *) g_smsdvb_clients.next); kmutex_unlock(&g_smsdvb_clientslock); - } - diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 4a2f02247..9c2da903a 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -57,8 +57,8 @@ typedef struct _smsusb_device smsusb_urb_t surbs[MAX_URBS]; - int response_alignment; - int buffer_size; + int response_alignment; + int buffer_size; } *psmsusb_device_t; int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb); @@ -72,44 +72,50 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) smsusb_urb_t *surb = (smsusb_urb_t *) urb->context; smsusb_device_t *dev = surb->dev; - if (urb->status < 0) - { - printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __func__, urb->status, urb->actual_length); + if (urb->status < 0) { + printk(KERN_INFO "%s error, urb status %d, %d bytes\n", + __func__, urb->status, urb->actual_length); return; } - if (urb->actual_length > 0) - { + if (urb->actual_length > 0) { SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) surb->cb->p; - if (urb->actual_length >= phdr->msgLength) - { + if (urb->actual_length >= phdr->msgLength) { surb->cb->size = phdr->msgLength; - if (dev->response_alignment && (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) - { - surb->cb->offset = dev->response_alignment + ((phdr->msgFlags >> 8) & 3); - - // sanity check - if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) - { - printk("%s: invalid response msglen %d offset %d size %d\n", __func__, phdr->msgLength, surb->cb->offset, urb->actual_length); + if (dev->response_alignment && + (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) { + + surb->cb->offset = + dev->response_alignment + + ((phdr->msgFlags >> 8) & 3); + + /* sanity check */ + if (((int) phdr->msgLength + + surb->cb->offset) > urb->actual_length) { + printk(KERN_INFO "%s: invalid " + "response msglen %d offset %d " + "size %d\n", __func__, + phdr->msgLength, + surb->cb->offset, + urb->actual_length); goto exit_and_resubmit; } - // move buffer pointer and copy header to its new location + /* move buffer pointer and + * copy header to its new location */ memcpy((char *) phdr + surb->cb->offset, phdr, sizeof(SmsMsgHdr_ST)); - } - else + } else surb->cb->offset = 0; smscore_onresponse(dev->coredev, surb->cb); surb->cb = NULL; - } - else - { - printk("%s invalid response msglen %d actual %d\n", __func__, phdr->msgLength, urb->actual_length); + } else { + printk(KERN_INFO "%s invalid response " + "msglen %d actual %d\n", __func__, + phdr->msgLength, urb->actual_length); } } @@ -119,12 +125,11 @@ exit_and_resubmit: int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb) { - if (!surb->cb) - { + if (!surb->cb) { surb->cb = smscore_getbuffer(dev->coredev); - if (!surb->cb) - { - printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __func__); + if (!surb->cb) { + printk(KERN_INFO "%s smscore_getbuffer(...) " + "returned NULL\n", __func__); return -ENOMEM; } } @@ -148,12 +153,10 @@ void smsusb_stop_streaming(smsusb_device_t *dev) { int i; - for (i = 0; i < MAX_URBS; i ++) - { + for (i = 0; i < MAX_URBS; i ++) { usb_kill_urb(&dev->surbs[i].urb); - if (dev->surbs[i].cb) - { + if (dev->surbs[i].cb) { smscore_putbuffer(dev->coredev, dev->surbs[i].cb); dev->surbs[i].cb = NULL; } @@ -164,12 +167,11 @@ int smsusb_start_streaming(smsusb_device_t *dev) { int i, rc; - for (i = 0; i < MAX_URBS; i ++) - { + for (i = 0; i < MAX_URBS; i ++) { rc = smsusb_submit_urb(dev, &dev->surbs[i]); - if (rc < 0) - { - printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __func__); + if (rc < 0) { + printk(KERN_INFO "%s smsusb_submit_urb(...) " + "failed\n", __func__); smsusb_stop_streaming(dev); break; } @@ -183,11 +185,11 @@ int smsusb_sendrequest(void *context, void *buffer, size_t size) smsusb_device_t *dev = (smsusb_device_t *) context; int dummy; - return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buffer, size, &dummy, 1000); + return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), + buffer, size, &dummy, 1000); } -char *smsusb1_fw_lkup[] = -{ +char *smsusb1_fw_lkup[] = { "dvbt_stellar_usb.inp", "dvbh_stellar_usb.inp", "tdmb_stellar_usb.inp", @@ -201,32 +203,31 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) u8 *fw_buffer; int rc, dummy; - if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) - { - printk(KERN_INFO "%s invalid firmware id specified %d\n", __func__, id); + if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) { + printk(KERN_INFO "%s invalid firmware id specified %d\n", + __func__, id); return -EINVAL; } rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); - if (rc < 0) - { - printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __func__, smsusb1_fw_lkup[id], id); + if (rc < 0) { + printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", + __func__, smsusb1_fw_lkup[id], id); return rc; } fw_buffer = kmalloc(fw->size, GFP_KERNEL); - if (fw_buffer) - { + if (fw_buffer) { memcpy(fw_buffer, fw->data, fw->size); - rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); + rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), + fw_buffer, fw->size, &dummy, 1000); - printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __func__, fw->size, dummy, rc); + printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", + __func__, fw->size, dummy, rc); kfree(fw_buffer); - } - else - { + } else { printk(KERN_INFO "failed to allocate firmware buffer\n"); rc = -ENOMEM; } @@ -242,33 +243,29 @@ void smsusb1_detectmode(void *context, int *mode) *mode = DEVICE_MODE_NONE; - if (!product_string) - { + if (!product_string) { product_string = "none"; printk("%s product string not found\n", __func__); - } - else - { - if (strstr(product_string, "DVBH")) - *mode = 1; - else if (strstr(product_string, "BDA")) - *mode = 4; - else if (strstr(product_string, "DVBT")) - *mode = 0; - else if (strstr(product_string, "TDMB")) - *mode = 2; - } + } else if (strstr(product_string, "DVBH")) + *mode = 1; + else if (strstr(product_string, "BDA")) + *mode = 4; + else if (strstr(product_string, "DVBT")) + *mode = 0; + else if (strstr(product_string, "TDMB")) + *mode = 2; printk("%s: %d \"%s\"\n", __func__, *mode, product_string); } int smsusb1_setmode(void *context, int mode) { - SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, + sizeof(SmsMsgHdr_ST), 0 }; - if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) - { - printk(KERN_INFO "%s invalid firmware id specified %d\n", __func__, mode); + if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { + printk(KERN_INFO "%s invalid firmware id specified %d\n", + __func__, mode); return -EINVAL; } @@ -279,8 +276,7 @@ void smsusb_term_device(struct usb_interface *intf) { smsusb_device_t *dev = (smsusb_device_t *) usb_get_intfdata(intf); - if (dev) - { + if (dev) { smsusb_stop_streaming(dev); // unregister from smscore @@ -303,9 +299,9 @@ int smsusb_init_device(struct usb_interface *intf) // create device object dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); - if (!dev) - { - printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __func__); + if (!dev) { + printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", + __func__); return -ENOMEM; } @@ -340,7 +336,9 @@ int smsusb_init_device(struct usb_interface *intf) } dev->buffer_size = USB2_BUFFER_SIZE; - dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST); + dev->response_alignment = + dev->udev->ep_in[1]->desc.wMaxPacketSize - + sizeof(SmsMsgHdr_ST); params.flags |= SMS_DEVICE_FAMILY2; break; @@ -351,37 +349,37 @@ int smsusb_init_device(struct usb_interface *intf) params.num_buffers = MAX_BUFFERS; params.sendrequest_handler = smsusb_sendrequest; params.context = dev; - snprintf(params.devpath, sizeof(params.devpath), "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath); + snprintf(params.devpath, sizeof(params.devpath), + "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath); - // register in smscore + /* register in smscore */ rc = smscore_register_device(¶ms, &dev->coredev); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __func__, rc); + if (rc < 0) { + printk(KERN_INFO "%s smscore_register_device(...) failed, " + "rc %d\n", __func__, rc); smsusb_term_device(intf); return rc; } // initialize urbs - for (i = 0; i < MAX_URBS; i ++) - { + for (i = 0; i < MAX_URBS; i++) { dev->surbs[i].dev = dev; usb_init_urb(&dev->surbs[i].urb); } printk(KERN_INFO "%s smsusb_start_streaming(...).\n", __func__); rc = smsusb_start_streaming(dev); - if (rc < 0) - { - printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __func__); + if (rc < 0) { + printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", + __func__); smsusb_term_device(intf); return rc; } rc = smscore_start_device(dev->coredev); - if (rc < 0) - { - printk(KERN_INFO "%s smscore_start_device(...) failed\n", __func__); + if (rc < 0) { + printk(KERN_INFO "%s smscore_start_device(...) failed\n", + __func__); smsusb_term_device(intf); return rc; } @@ -400,29 +398,32 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81)); rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02)); - if (intf->num_altsetting > 0) - { + if (intf->num_altsetting > 0) { rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); - if (rc < 0) - { - printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __func__, rc); + if (rc < 0) { + printk(KERN_INFO "%s usb_set_interface failed, " + "rc %d\n", __func__, rc); return rc; } } - printk(KERN_INFO "smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber); + printk(KERN_INFO "smsusb_probe %d\n", + intf->cur_altsetting->desc.bInterfaceNumber); for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i ++) - printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); + printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, + intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, + intf->cur_altsetting->endpoint[i].desc.bmAttributes, + intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); - if (udev->actconfig->desc.bNumInterfaces == 2 && intf->cur_altsetting->desc.bInterfaceNumber == 0) - { + if ((udev->actconfig->desc.bNumInterfaces == 2) && + (intf->cur_altsetting->desc.bInterfaceNumber == 0)) { printk(KERN_INFO "rom interface 0 is not used\n"); return -ENODEV; } - if (intf->cur_altsetting->desc.bInterfaceNumber == 1) - { - snprintf(devpath, sizeof(devpath), "usb\\%d-%s", udev->bus->busnum, udev->devpath); + if (intf->cur_altsetting->desc.bInterfaceNumber == 1) { + snprintf(devpath, sizeof(devpath), "usb\\%d-%s", + udev->bus->busnum, udev->devpath); printk(KERN_INFO "stellar device was found.\n"); return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath)); } @@ -448,7 +449,7 @@ MODULE_DEVICE_TABLE (usb, smsusb_id_table); static struct usb_driver smsusb_driver = { .name = "smsusb", .probe = smsusb_probe, - .disconnect = smsusb_disconnect, + .disconnect = smsusb_disconnect, .id_table = smsusb_id_table, }; -- cgit v1.2.3 From f2aa3c590d42fba774c9c03387573f841266da7d Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 11:32:00 -0400 Subject: sms1xxx: remove INT / UINT typedefs From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 10 +- linux/drivers/media/dvb/siano/smscoreapi.h | 303 ++++++++++++++--------------- 2 files changed, 154 insertions(+), 159 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 98422879d..2619a0086 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -520,7 +520,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, { SmsFirmware_ST *firmware = (SmsFirmware_ST *) buffer; SmsMsgHdr_ST *msg; - UINT32 mem_address = firmware->StartAddress; + u32 mem_address = firmware->StartAddress; u8 *payload = firmware->Payload; int rc = 0; @@ -544,7 +544,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); - mem_address = *(UINT32*) &payload[20]; + mem_address = *(u32 *) &payload[20]; } while (size && rc >= 0) @@ -553,8 +553,8 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, - (UINT16)(sizeof(SmsMsgHdr_ST) + - sizeof(UINT32) + payload_size)); + (u16)(sizeof(SmsMsgHdr_ST) + + sizeof(u32) + payload_size)); DataMsg->MemAddr = mem_address; memcpy(DataMsg->Payload, payload, payload_size); @@ -576,7 +576,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, sizeof(SmsMsgHdr_ST) + - sizeof(UINT32) * 5); + sizeof(u32) * 5); TriggerMsg->msgData[0] = firmware->StartAddress; // Entry point TriggerMsg->msgData[1] = 5; // Priority diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 5ce04568a..a010562ba 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -228,276 +228,271 @@ typedef enum DEVICE_MODE_MAX, } SMS_DEVICE_MODE; -typedef unsigned char UINT8; -typedef unsigned short UINT16; -typedef unsigned int UINT32; -typedef int INT32; - typedef struct SmsMsgHdr_S { - UINT16 msgType; - UINT8 msgSrcId; - UINT8 msgDstId; - UINT16 msgLength; /* Length of entire message, including header */ - UINT16 msgFlags; + u16 msgType; + u8 msgSrcId; + u8 msgDstId; + u16 msgLength; /* Length of entire message, including header */ + u16 msgFlags; } SmsMsgHdr_ST; typedef struct SmsMsgData_S { SmsMsgHdr_ST xMsgHeader; - UINT32 msgData[1]; + u32 msgData[1]; } SmsMsgData_ST; typedef struct SmsDataDownload_S { SmsMsgHdr_ST xMsgHeader; - UINT32 MemAddr; - UINT8 Payload[SMS_MAX_PAYLOAD_SIZE]; + u32 MemAddr; + u8 Payload[SMS_MAX_PAYLOAD_SIZE]; } SmsDataDownload_ST; typedef struct SmsVersionRes_S { SmsMsgHdr_ST xMsgHeader; - UINT16 ChipModel; /* e.g. 0x1102 for SMS-1102 "Nova" */ - UINT8 Step; /* 0 - Step A */ - UINT8 MetalFix; /* 0 - Metal 0 */ + u16 ChipModel; /* e.g. 0x1102 for SMS-1102 "Nova" */ + u8 Step; /* 0 - Step A */ + u8 MetalFix; /* 0 - Metal 0 */ - UINT8 FirmwareId; /* 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E */ - UINT8 SupportedProtocols; /* Bitwise OR combination of supported protocols */ + u8 FirmwareId; /* 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E */ + u8 SupportedProtocols; /* Bitwise OR combination of supported protocols */ - UINT8 VersionMajor; - UINT8 VersionMinor; - UINT8 VersionPatch; - UINT8 VersionFieldPatch; + u8 VersionMajor; + u8 VersionMinor; + u8 VersionPatch; + u8 VersionFieldPatch; - UINT8 RomVersionMajor; - UINT8 RomVersionMinor; - UINT8 RomVersionPatch; - UINT8 RomVersionFieldPatch; + u8 RomVersionMajor; + u8 RomVersionMinor; + u8 RomVersionPatch; + u8 RomVersionFieldPatch; - UINT8 TextLabel[34]; + u8 TextLabel[34]; } SmsVersionRes_ST; typedef struct SmsFirmware_S { - UINT32 CheckSum; - UINT32 Length; - UINT32 StartAddress; - UINT8 Payload[1]; + u32 CheckSum; + u32 Length; + u32 StartAddress; + u8 Payload[1]; } SmsFirmware_ST; typedef struct SMSHOSTLIB_STATISTICS_S { - UINT32 Reserved; /* Reserved */ + u32 Reserved; /* Reserved */ /* Common parameters */ - UINT32 IsRfLocked; /* 0 - not locked, 1 - locked */ - UINT32 IsDemodLocked; /* 0 - not locked, 1 - locked */ - UINT32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ + u32 IsRfLocked; /* 0 - not locked, 1 - locked */ + u32 IsDemodLocked; /* 0 - not locked, 1 - locked */ + u32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ /* Reception quality */ - INT32 SNR; /* dB */ - UINT32 BER; /* Post Viterbi BER [1E-5] */ - UINT32 FIB_CRC; /* CRC errors percentage, valid only for DAB */ - UINT32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H */ - UINT32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ - INT32 RSSI; /* dBm */ - INT32 InBandPwr; /* In band power in dBM */ - INT32 CarrierOffset; /* Carrier Offset in bin/1024 */ + s32 SNR; /* dB */ + u32 BER; /* Post Viterbi BER [1E-5] */ + u32 FIB_CRC; /* CRC errors percentage, valid only for DAB */ + u32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H */ + u32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ + s32 RSSI; /* dBm */ + s32 InBandPwr; /* In band power in dBM */ + s32 CarrierOffset; /* Carrier Offset in bin/1024 */ /* Transmission parameters */ - UINT32 Frequency; /* Frequency in Hz */ - UINT32 Bandwidth; /* Bandwidth in MHz, valid only for DVB-T/H */ - UINT32 TransmissionMode; /* Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos */ - UINT32 ModemState; /* from SMS_DvbModemState_ET , valid only for DVB-T/H */ - UINT32 GuardInterval; /* Guard Interval, 1 divided by value , valid only for DVB-T/H */ - UINT32 CodeRate; /* Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ - UINT32 LPCodeRate; /* Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ - UINT32 Hierarchy; /* Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H */ - UINT32 Constellation; /* Constellation from SMS_Constellation_ET, valid only for DVB-T/H */ + u32 Frequency; /* Frequency in Hz */ + u32 Bandwidth; /* Bandwidth in MHz, valid only for DVB-T/H */ + u32 TransmissionMode; /* Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos */ + u32 ModemState; /* from SMS_DvbModemState_ET , valid only for DVB-T/H */ + u32 GuardInterval; /* Guard Interval, 1 divided by value , valid only for DVB-T/H */ + u32 CodeRate; /* Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ + u32 LPCodeRate; /* Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ + u32 Hierarchy; /* Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H */ + u32 Constellation; /* Constellation from SMS_Constellation_ET, valid only for DVB-T/H */ /* Burst parameters, valid only for DVB-H */ - UINT32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ - UINT32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ - UINT32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ - UINT32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ - UINT32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ - UINT32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ - UINT32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ - UINT32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ - UINT32 TotalTSPackets; /* Total number of transport-stream packets */ - UINT32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding */ - UINT32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding */ - UINT32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding */ + u32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ + u32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ + u32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ + u32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ + u32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ + u32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ + u32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ + u32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ + u32 TotalTSPackets; /* Total number of transport-stream packets */ + u32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding */ + u32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding */ + u32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding */ /* Common params */ - UINT32 BERErrorCount; /* Number of errornous SYNC bits. */ - UINT32 BERBitCount; /* Total number of SYNC bits. */ + u32 BERErrorCount; /* Number of errornous SYNC bits. */ + u32 BERBitCount; /* Total number of SYNC bits. */ /* Interface information */ - UINT32 SmsToHostTxErrors; /* Total number of transmission errors. */ + u32 SmsToHostTxErrors; /* Total number of transmission errors. */ /* DAB/T-DMB */ - UINT32 PreBER; /* DAB/T-DMB only: Pre Viterbi BER [1E-5] */ + u32 PreBER; /* DAB/T-DMB only: Pre Viterbi BER [1E-5] */ /* DVB-H TPS parameters */ - UINT32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ + u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ } SMSHOSTLIB_STATISTICS_ST; typedef struct { - UINT32 RequestResult; + u32 RequestResult; SMSHOSTLIB_STATISTICS_ST Stat; /* Split the calc of the SNR in DAB */ - UINT32 Signal; /* dB */ - UINT32 Noise; /* dB */ + u32 Signal; /* dB */ + u32 Noise; /* dB */ } SmsMsgStatisticsInfo_ST; typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S { /* Per-layer information */ - UINT32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist */ - UINT32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist */ - UINT32 BER; /* Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ - UINT32 BERErrorCount; /* Post Viterbi Error Bits Count */ - UINT32 BERBitCount; /* Post Viterbi Total Bits Count */ - UINT32 PreBER; /* Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ - UINT32 TS_PER; /* Transport stream PER [%], 0xFFFFFFFF indicate N/A */ - UINT32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ - UINT32 TotalTSPackets; /* Total number of transport-stream packets */ - UINT32 TILdepthI; /* Time interleaver depth I parameter, 255 means layer does not exist */ - UINT32 NumberOfSegments; /* Number of segments in layer A, 255 means layer does not exist */ - UINT32 TMCCErrors; /* TMCC errors */ + u32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist */ + u32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist */ + u32 BER; /* Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ + u32 BERErrorCount; /* Post Viterbi Error Bits Count */ + u32 BERBitCount; /* Post Viterbi Total Bits Count */ + u32 PreBER; /* Pre Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ + u32 TS_PER; /* Transport stream PER [%], 0xFFFFFFFF indicate N/A */ + u32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ + u32 TotalTSPackets; /* Total number of transport-stream packets */ + u32 TILdepthI; /* Time interleaver depth I parameter, 255 means layer does not exist */ + u32 NumberOfSegments; /* Number of segments in layer A, 255 means layer does not exist */ + u32 TMCCErrors; /* TMCC errors */ } SMSHOSTLIB_ISDBT_LAYER_STAT_ST; typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S { - UINT32 StatisticsType; /* Enumerator identifying the type of the + u32 StatisticsType; /* Enumerator identifying the type of the * structure. Values are the same as * SMSHOSTLIB_DEVICE_MODES_E * * This field MUST always be first in any * statistics structure */ - UINT32 FullSize; /* Total size of the structure returned by the modem. If the size requested by + u32 FullSize; /* Total size of the structure returned by the modem. If the size requested by * the host is smaller than FullSize, the struct will be truncated */ /* Common parameters */ - UINT32 IsRfLocked; /* 0 - not locked, 1 - locked */ - UINT32 IsDemodLocked; /* 0 - not locked, 1 - locked */ - UINT32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ + u32 IsRfLocked; /* 0 - not locked, 1 - locked */ + u32 IsDemodLocked; /* 0 - not locked, 1 - locked */ + u32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ /* Reception quality */ - INT32 SNR; /* dB */ - INT32 RSSI; /* dBm */ - INT32 InBandPwr; /* In band power in dBM */ - INT32 CarrierOffset; /* Carrier Offset in Hz */ + s32 SNR; /* dB */ + s32 RSSI; /* dBm */ + s32 InBandPwr; /* In band power in dBM */ + s32 CarrierOffset; /* Carrier Offset in Hz */ /* Transmission parameters */ - UINT32 Frequency; /* Frequency in Hz */ - UINT32 Bandwidth; /* Bandwidth in MHz */ - UINT32 TransmissionMode; /* ISDB-T transmission mode */ - UINT32 ModemState; /* 0 - Acquisition, 1 - Locked */ - UINT32 GuardInterval; /* Guard Interval, 1 divided by value */ - UINT32 SystemType; /* ISDB-T system type (ISDB-T / ISDB-Tsb) */ - UINT32 PartialReception; /* TRUE - partial reception, FALSE otherwise */ - UINT32 NumOfLayers; /* Number of ISDB-T layers in the network */ + u32 Frequency; /* Frequency in Hz */ + u32 Bandwidth; /* Bandwidth in MHz */ + u32 TransmissionMode; /* ISDB-T transmission mode */ + u32 ModemState; /* 0 - Acquisition, 1 - Locked */ + u32 GuardInterval; /* Guard Interval, 1 divided by value */ + u32 SystemType; /* ISDB-T system type (ISDB-T / ISDB-Tsb) */ + u32 PartialReception; /* TRUE - partial reception, FALSE otherwise */ + u32 NumOfLayers; /* Number of ISDB-T layers in the network */ /* Per-layer information */ /* Layers A, B and C */ SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; /* Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST */ /* Interface information */ - UINT32 SmsToHostTxErrors; /* Total number of transmission errors. */ + u32 SmsToHostTxErrors; /* Total number of transmission errors. */ } SMSHOSTLIB_STATISTICS_ISDBT_ST; typedef struct SMSHOSTLIB_STATISTICS_DVB_S { - UINT32 StatisticsType; /* Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E + u32 StatisticsType; /* Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E * This fiels MUST always first in any statistics structure */ - UINT32 FullSize; /* Total size of the structure returned by the modem. If the size requested by + u32 FullSize; /* Total size of the structure returned by the modem. If the size requested by * the host is smaller than FullSize, the struct will be truncated */ /* Common parameters */ - UINT32 IsRfLocked; /* 0 - not locked, 1 - locked */ - UINT32 IsDemodLocked; /* 0 - not locked, 1 - locked */ - UINT32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ + u32 IsRfLocked; /* 0 - not locked, 1 - locked */ + u32 IsDemodLocked; /* 0 - not locked, 1 - locked */ + u32 IsExternalLNAOn; /* 0 - external LNA off, 1 - external LNA on */ /* Reception quality */ - INT32 SNR; /* dB */ - UINT32 BER; /* Post Viterbi BER [1E-5] */ - UINT32 BERErrorCount; /* Number of errornous SYNC bits. */ - UINT32 BERBitCount; /* Total number of SYNC bits. */ - UINT32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A */ - UINT32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ - INT32 RSSI; /* dBm */ - INT32 InBandPwr; /* In band power in dBM */ - INT32 CarrierOffset; /* Carrier Offset in bin/1024 */ + s32 SNR; /* dB */ + u32 BER; /* Post Viterbi BER [1E-5] */ + u32 BERErrorCount; /* Number of errornous SYNC bits. */ + u32 BERBitCount; /* Total number of SYNC bits. */ + u32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A */ + u32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ + s32 RSSI; /* dBm */ + s32 InBandPwr; /* In band power in dBM */ + s32 CarrierOffset; /* Carrier Offset in bin/1024 */ /* Transmission parameters */ - UINT32 Frequency; /* Frequency in Hz */ - UINT32 Bandwidth; /* Bandwidth in MHz */ - UINT32 ModemState; /* from SMSHOSTLIB_DVB_MODEM_STATE_ET */ - UINT32 TransmissionMode; /* FFT mode carriers in Kilos */ - UINT32 GuardInterval; /* Guard Interval, 1 divided by value */ - UINT32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET */ - UINT32 LPCodeRate; /* Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET */ - UINT32 Hierarchy; /* Hierarchy from SMSHOSTLIB_HIERARCHY_ET */ - UINT32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET */ + u32 Frequency; /* Frequency in Hz */ + u32 Bandwidth; /* Bandwidth in MHz */ + u32 ModemState; /* from SMSHOSTLIB_DVB_MODEM_STATE_ET */ + u32 TransmissionMode; /* FFT mode carriers in Kilos */ + u32 GuardInterval; /* Guard Interval, 1 divided by value */ + u32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET */ + u32 LPCodeRate; /* Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET */ + u32 Hierarchy; /* Hierarchy from SMSHOSTLIB_HIERARCHY_ET */ + u32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET */ /* Burst parameters, valid only for DVB-H */ - UINT32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ - UINT32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ - UINT32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ - UINT32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ - UINT32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ - UINT32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ - UINT32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ - UINT32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ - UINT32 TotalTSPackets; /* Total number of transport-stream packets */ - UINT32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H */ - UINT32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H */ - UINT32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H */ - UINT32 NumMPEReceived; /* DVB-H, Num MPE section received */ + u32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ + u32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ + u32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ + u32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ + u32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ + u32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ + u32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ + u32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ + u32 TotalTSPackets; /* Total number of transport-stream packets */ + u32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H */ + u32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H */ + u32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H */ + u32 NumMPEReceived; /* DVB-H, Num MPE section received */ /* DVB-H TPS parameters */ - UINT32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ - UINT32 DvbhSrvIndHP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ - UINT32 DvbhSrvIndLP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ + u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ + u32 DvbhSrvIndHP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ + u32 DvbhSrvIndLP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ /* Interface information */ - UINT32 SmsToHostTxErrors; /* Total number of transmission errors. */ + u32 SmsToHostTxErrors; /* Total number of transmission errors. */ } SMSHOSTLIB_STATISTICS_DVB_ST; typedef struct SMSHOSTLIB_GPIO_CONFIG_S { - UINT8 Direction; /* GPIO direction: Input - 0, Output - 1 */ - UINT8 PullUpDown; /* PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 */ - UINT8 InputCharacteristics; /* Input Characteristics: Normal - 0, Schmitt trigger - 1 */ - UINT8 OutputSlewRate; /* Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 */ - UINT8 OutputDriving; /* Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 */ + u8 Direction; /* GPIO direction: Input - 0, Output - 1 */ + u8 PullUpDown; /* PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 */ + u8 InputCharacteristics; /* Input Characteristics: Normal - 0, Schmitt trigger - 1 */ + u8 OutputSlewRate; /* Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 */ + u8 OutputDriving; /* Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 */ } SMSHOSTLIB_GPIO_CONFIG_ST; typedef struct SMSHOSTLIB_I2C_REQ_S { - UINT32 DeviceAddress; /* I2c device address */ - UINT32 WriteCount; /* number of bytes to write */ - UINT32 ReadCount; /* number of bytes to read */ - UINT8 Data[1]; + u32 DeviceAddress; /* I2c device address */ + u32 WriteCount; /* number of bytes to write */ + u32 ReadCount; /* number of bytes to read */ + u8 Data[1]; } SMSHOSTLIB_I2C_REQ_ST; typedef struct SMSHOSTLIB_I2C_RES_S { - UINT32 Status; /* non-zero value in case of failure */ - UINT32 ReadCount; /* number of bytes read */ - UINT8 Data[1]; + u32 Status; /* non-zero value in case of failure */ + u32 ReadCount; /* number of bytes read */ + u8 Data[1]; } SMSHOSTLIB_I2C_RES_ST; typedef struct _smsdvb_client -- cgit v1.2.3 From bbdc222674cd21b02e30907cce29f7a8464303a5 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 11:52:43 -0400 Subject: sms1xxx: more codingstyle cleanups From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 36 +++++++++++++-------------- linux/drivers/media/dvb/siano/smscoreapi.h | 4 +-- linux/drivers/media/dvb/siano/smsdvb.c | 40 ++++++++++++++---------------- linux/drivers/media/dvb/siano/smsusb.c | 18 +++++++------- 4 files changed, 47 insertions(+), 51 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 2619a0086..573d182e7 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -434,7 +434,7 @@ int smscore_register_device(smsdevice_params_t *params, /* prepare dma buffers */ for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; - dev->num_buffers ++, buffer += params->buffer_size) { + dev->num_buffers++, buffer += params->buffer_size) { smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); if (!cb) { smscore_unregister_device(dev); @@ -547,8 +547,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, mem_address = *(u32 *) &payload[20]; } - while (size && rc >= 0) - { + while (size && rc >= 0) { SmsDataDownload_ST *DataMsg = (SmsDataDownload_ST *) msg; int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); @@ -578,11 +577,11 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, sizeof(SmsMsgHdr_ST) + sizeof(u32) * 5); - TriggerMsg->msgData[0] = firmware->StartAddress; // Entry point - TriggerMsg->msgData[1] = 5; // Priority - TriggerMsg->msgData[2] = 0x200; // Stack size - TriggerMsg->msgData[3] = 0; // Parameter - TriggerMsg->msgData[4] = 4; // Task ID + TriggerMsg->msgData[0] = firmware->StartAddress; /* Entry point */ + TriggerMsg->msgData[1] = 5; /* Priority */ + TriggerMsg->msgData[2] = 0x200; /* Stack size */ + TriggerMsg->msgData[3] = 0; /* Parameter */ + TriggerMsg->msgData[4] = 4; /* Task ID */ if (coredev->device_flags & SMS_ROM_NO_RESPONSE) { rc = coredev->sendrequest_handler(coredev->context, TriggerMsg, TriggerMsg->xMsgHeader.msgLength); @@ -692,7 +691,7 @@ void smscore_unregister_device(smscore_device_t *coredev) while (1) { while ((cb = smscore_getbuffer(coredev))) { kfree(cb); - num_buffers ++; + num_buffers++; } if (num_buffers == coredev->num_buffers) break; @@ -892,14 +891,14 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, for (next = first->next; (next != first) && !client; next = next->next) { - firstid = &((smscore_client_t*)next)->idlist; + firstid = &((smscore_client_t *)next)->idlist; for (nextid = firstid->next; nextid != firstid; nextid = nextid->next) { - if ((((smscore_idlist_t*)nextid)->id == id) && - (((smscore_idlist_t*)nextid)->data_type == data_type || - (((smscore_idlist_t*)nextid)->data_type == 0))) { - client = (smscore_client_t*) next; + if ((((smscore_idlist_t *)nextid)->id == id) && + (((smscore_idlist_t *)nextid)->data_type == data_type || + (((smscore_idlist_t *)nextid)->data_type == 0))) { + client = (smscore_client_t *) next; break; } } @@ -931,8 +930,7 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) if (!last_sample_time) last_sample_time = time_now; - if (time_now - last_sample_time > 10000) - { + if (time_now - last_sample_time > 10000) { printk("\n%s data rate %d bytes/secs\n", __func__, (int)((data_total * 1000) / (time_now - last_sample_time))); @@ -1050,9 +1048,9 @@ int smscore_validate_client(smscore_device_t *coredev, return -EFAULT; } registered_client = smscore_find_client(coredev, data_type, id); - if (registered_client == client) { + if (registered_client == client) return 0; - } + if (registered_client) { PERROR("The msg ID already registered to another client.\n"); return -EEXIST; @@ -1130,7 +1128,7 @@ void smscore_unregister_client(smscore_client_t *client) while (!list_empty(&client->idlist)) { smscore_idlist_t *identry = - (smscore_idlist_t*) client->idlist.next; + (smscore_idlist_t *) client->idlist.next; list_del(&identry->entry); kfree(identry); } diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index a010562ba..13e37b7b1 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -60,7 +60,7 @@ void *kzalloc(size_t size, int flags); #endif /* LINUX_VERSION */ #ifndef min -#define min(a,b) (((a) < (b)) ? (a) : (b)) +#define min(a, b) (((a) < (b)) ? (a) : (b)) #endif #define SMS_ALLOC_ALIGNMENT 128 @@ -72,7 +72,7 @@ void *kzalloc(size_t size, int flags); #define SMS_DEVICE_NOT_READY 0x8000000 typedef enum { - SMS_STELLAR= 0, + SMS_STELLAR = 0, SMS_NOVA_A0, SMS_NOVA_B0, SMS_VEGA, diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 63b8f6a27..81c42d1c9 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -34,7 +34,7 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) smsdvb_client_t *client = (smsdvb_client_t *) context; SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8 *) cb->p) + cb->offset); - switch(phdr->msgType) { + switch (phdr->msgType) { case MSG_SMS_DVBT_BDA_DATA: dvb_dmx_swfilter(&client->demux, (u8 *)(phdr + 1), cb->size - sizeof(SmsMsgHdr_ST)); @@ -49,8 +49,7 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) SmsMsgStatisticsInfo_ST *p = (SmsMsgStatisticsInfo_ST *)(phdr + 1); - if (p->Stat.IsDemodLocked) - { + if (p->Stat.IsDemodLocked) { client->fe_status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | @@ -85,7 +84,7 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) void smsdvb_unregister_client(smsdvb_client_t *client) { - // must be called under clientslock + /* must be called under clientslock */ list_del(&client->entry); @@ -243,16 +242,15 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, printk("%s freq %d band %d\n", __func__, fep->frequency, fep->u.ofdm.bandwidth); - switch(fep->u.ofdm.bandwidth) - { - case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; - case BANDWIDTH_7_MHZ: Msg.Data[1] = BW_7_MHZ; break; - case BANDWIDTH_6_MHZ: Msg.Data[1] = BW_6_MHZ; break; + switch (fep->u.ofdm.bandwidth) { + case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; + case BANDWIDTH_7_MHZ: Msg.Data[1] = BW_7_MHZ; break; + case BANDWIDTH_6_MHZ: Msg.Data[1] = BW_6_MHZ; break; #if 0 - case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; + case BANDWIDTH_5_MHZ: Msg.Data[1] = BW_5_MHZ; break; #endif - case BANDWIDTH_AUTO: return -EOPNOTSUPP; - default: return -EINVAL; + case BANDWIDTH_AUTO: return -EOPNOTSUPP; + default: return -EINVAL; } return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), @@ -266,7 +264,7 @@ static int smsdvb_get_frontend(struct dvb_frontend *fe, printk("%s\n", __func__); - // todo: + /* todo: */ memcpy(fep, &client->fe_params, sizeof(struct dvb_frontend_parameters)); return 0; @@ -274,7 +272,7 @@ static int smsdvb_get_frontend(struct dvb_frontend *fe, static void smsdvb_release(struct dvb_frontend *fe) { - // do nothing + /* do nothing */ } static struct dvb_frontend_ops smsdvb_fe_ops = { @@ -313,12 +311,12 @@ int smsdvb_hotplug(smscore_device_t *coredev, smsdvb_client_t *client; int rc; - // device removal handled by onremove callback + /* device removal handled by onremove callback */ if (!arrival) return 0; if (smscore_get_device_mode(coredev) != 4) { -#if 1 // new siano drop (1.2.17) does this -- yuck +#if 1 /* new siano drop (1.2.17) does this -- yuck */ printk(KERN_ERR "%sSMS Device mode is not set for DVB operation.\n", __func__); return 0; #else @@ -334,7 +332,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, return -ENOMEM; } - // register dvb adapter + /* register dvb adapter */ rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device, adapter_nr); if (rc < 0) { @@ -342,9 +340,9 @@ int smsdvb_hotplug(smscore_device_t *coredev, goto adapter_error; } - // init dvb demux + /* init dvb demux */ client->demux.dmx.capabilities = DMX_TS_FILTERING; - client->demux.filternum = 32; // todo: nova ??? + client->demux.filternum = 32; /* todo: nova ??? */ client->demux.feednum = 32; client->demux.start_feed = smsdvb_start_feed; client->demux.stop_feed = smsdvb_stop_feed; @@ -355,7 +353,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, goto dvbdmx_error; } - // init dmxdev + /* init dmxdev */ client->dmxdev.filternum = 32; client->dmxdev.demux = &client->demux.dmx; client->dmxdev.capabilities = 0; @@ -366,7 +364,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, goto dmxdev_error; } - // init and register frontend + /* init and register frontend */ memcpy(&client->frontend.ops, &smsdvb_fe_ops, sizeof(struct dvb_frontend_ops)); diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 9c2da903a..d5e2f9ce0 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -153,7 +153,7 @@ void smsusb_stop_streaming(smsusb_device_t *dev) { int i; - for (i = 0; i < MAX_URBS; i ++) { + for (i = 0; i < MAX_URBS; i++) { usb_kill_urb(&dev->surbs[i].urb); if (dev->surbs[i].cb) { @@ -167,7 +167,7 @@ int smsusb_start_streaming(smsusb_device_t *dev) { int i, rc; - for (i = 0; i < MAX_URBS; i ++) { + for (i = 0; i < MAX_URBS; i++) { rc = smsusb_submit_urb(dev, &dev->surbs[i]); if (rc < 0) { printk(KERN_INFO "%s smsusb_submit_urb(...) " @@ -279,7 +279,7 @@ void smsusb_term_device(struct usb_interface *intf) if (dev) { smsusb_stop_streaming(dev); - // unregister from smscore + /* unregister from smscore */ if (dev->coredev) smscore_unregister_device(dev->coredev); @@ -297,7 +297,7 @@ int smsusb_init_device(struct usb_interface *intf) smsusb_device_t *dev; int i, rc; - // create device object + /* create device object */ dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); if (!dev) { printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", @@ -317,13 +317,13 @@ int smsusb_init_device(struct usb_interface *intf) params.setmode_handler = smsusb1_setmode; params.detectmode_handler = smsusb1_detectmode; params.device_type = SMS_STELLAR; - printk(KERN_INFO "%s stellar device found\n", __func__ ); + printk(KERN_INFO "%s stellar device found\n", __func__); break; default: switch (dev->udev->descriptor.idProduct) { case USB_PID_NOVA_A: params.device_type = SMS_NOVA_A0; - printk(KERN_INFO "%s nova A0 found\n", __func__ ); + printk(KERN_INFO "%s nova A0 found\n", __func__); break; default: case USB_PID_NOVA_B: @@ -361,7 +361,7 @@ int smsusb_init_device(struct usb_interface *intf) return rc; } - // initialize urbs + /* initialize urbs */ for (i = 0; i < MAX_URBS; i++) { dev->surbs[i].dev = dev; usb_init_urb(&dev->surbs[i].urb); @@ -409,7 +409,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) printk(KERN_INFO "smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber); - for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i ++) + for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, @@ -444,7 +444,7 @@ static struct usb_device_id smsusb_id_table [] = { { USB_DEVICE(USB_VID_SIANO, USB_PID_NOVA_A) }, { } /* Terminating entry */ }; -MODULE_DEVICE_TABLE (usb, smsusb_id_table); +MODULE_DEVICE_TABLE(usb, smsusb_id_table); static struct usb_driver smsusb_driver = { .name = "smsusb", -- cgit v1.2.3 From 1805b4d8ac1ae6ca81f188b099e7703a5ff5560c Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 12:50:11 -0400 Subject: sms1xxx: 80-column cleanups From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 123 ++++++++++++++++------- linux/drivers/media/dvb/siano/smscoreapi.h | 156 ++++++++++++++++++----------- linux/drivers/media/dvb/siano/smsdvb.c | 3 +- linux/drivers/media/dvb/siano/smsusb.c | 6 +- 4 files changed, 190 insertions(+), 98 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 573d182e7..6611e9b53 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -357,7 +357,8 @@ int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, first = &g_smscore_notifyees; for (next = first->next; next != first; next = next->next) { - rc = ((smscore_device_notifyee_t *) next)->hotplug(coredev, device, arrival); + rc = ((smscore_device_notifyee_t *) next)-> + hotplug(coredev, device, arrival); if (rc < 0) break; } @@ -385,7 +386,8 @@ smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, * creates coredev object for a device, prepares buffers, * creates buffer mappings, notifies registered hotplugs about new device. * - * @param params device pointer to struct with device specific parameters and handlers + * @param params device pointer to struct with device specific parameters + * and handlers * @param coredev pointer to a value that receives created coredev object * * @return 0 on success, <0 on error. @@ -435,7 +437,9 @@ int smscore_register_device(smsdevice_params_t *params, for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; dev->num_buffers++, buffer += params->buffer_size) { - smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); + smscore_buffer_t *cb = + smscore_createbuffer(buffer, dev->common_buffer, + dev->common_buffer_phys); if (!cb) { smscore_unregister_device(dev); return -ENOMEM; @@ -476,15 +480,18 @@ int smscore_register_device(smsdevice_params_t *params, /** * sets initial device mode and notifies client hotplugs that device is ready * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * * @return 0 on success, <0 on error. */ int smscore_start_device(smscore_device_t *coredev) { - int rc = smscore_set_device_mode(coredev, smscore_registry_getmode(coredev->devpath)); + int rc = smscore_set_device_mode( + coredev, smscore_registry_getmode(coredev->devpath)); if (rc < 0) { - printk(KERN_INFO "%s set device mode faile , rc %d\n", __func__, rc); + printk(KERN_INFO "%s set device mode faile , rc %d\n", + __func__, rc); return rc; } @@ -560,9 +567,14 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, if ((coredev->device_flags & SMS_ROM_NO_RESPONSE) && (coredev->mode == DEVICE_MODE_NONE)) - rc = coredev->sendrequest_handler(coredev->context, DataMsg, DataMsg->xMsgHeader.msgLength); + rc = coredev->sendrequest_handler( + coredev->context, DataMsg, + DataMsg->xMsgHeader.msgLength); else - rc = smscore_sendrequest_and_wait(coredev, DataMsg, DataMsg->xMsgHeader.msgLength, &coredev->data_download_done); + rc = smscore_sendrequest_and_wait( + coredev, DataMsg, + DataMsg->xMsgHeader.msgLength, + &coredev->data_download_done); payload += payload_size; size -= payload_size; @@ -577,17 +589,23 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, sizeof(SmsMsgHdr_ST) + sizeof(u32) * 5); - TriggerMsg->msgData[0] = firmware->StartAddress; /* Entry point */ + TriggerMsg->msgData[0] = firmware->StartAddress; + /* Entry point */ TriggerMsg->msgData[1] = 5; /* Priority */ TriggerMsg->msgData[2] = 0x200; /* Stack size */ TriggerMsg->msgData[3] = 0; /* Parameter */ TriggerMsg->msgData[4] = 4; /* Task ID */ if (coredev->device_flags & SMS_ROM_NO_RESPONSE) { - rc = coredev->sendrequest_handler(coredev->context, TriggerMsg, TriggerMsg->xMsgHeader.msgLength); + rc = coredev->sendrequest_handler( + coredev->context, TriggerMsg, + TriggerMsg->xMsgHeader.msgLength); msleep(100); } else - rc = smscore_sendrequest_and_wait(coredev, TriggerMsg, TriggerMsg->xMsgHeader.msgLength, &coredev->trigger_done); + rc = smscore_sendrequest_and_wait( + coredev, TriggerMsg, + TriggerMsg->xMsgHeader.msgLength, + &coredev->trigger_done); } else { SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, sizeof(SmsMsgHdr_ST)); @@ -611,7 +629,8 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, /** * loads specified firmware into a buffer and calls device loadfirmware_handler * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * @param filename null-terminated string specifies firmware file name * @param loadfirmware_handler device handler that loads firmware * @@ -644,8 +663,11 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, memcpy(fw_buffer, fw->data, fw->size); rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ? - smscore_load_firmware_family2(coredev, fw_buffer, fw->size) : - loadfirmware_handler(coredev->context, fw_buffer, fw->size); + smscore_load_firmware_family2(coredev, + fw_buffer, + fw->size) : + loadfirmware_handler(coredev->context, + fw_buffer, fw->size); kfree(fw_buffer); } else { @@ -668,9 +690,11 @@ int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, } /** - * notifies all clients registered with the device, notifies hotplugs, frees all buffers and coredev object + * notifies all clients registered with the device, notifies hotplugs, + * frees all buffers and coredev object * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * * @return 0 on success, <0 on error. */ @@ -736,13 +760,17 @@ int smscore_detect_mode(smscore_device_t *coredev) rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc == -ETIME) { - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", __func__); + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", + __func__); if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) { - rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); + rc = smscore_sendrequest_and_wait( + coredev, msg, msg->msgLength, + &coredev->version_ex_done); if (rc < 0) - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n", __func__, rc); + printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed " + "second try, rc %d\n", __func__, rc); } else rc = -ETIME; } @@ -769,7 +797,8 @@ char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { * calls device handler to change mode of operation * NOTE: stellar/usb may disconnect when changing mode * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * @param mode requested mode of operation * * @return 0 on success, <0 on error. @@ -807,27 +836,35 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) if (!(coredev->modes_supported & (1 << mode))) { type = smscore_registry_gettype(coredev->devpath); - rc = smscore_load_firmware_from_file(coredev, smscore_fw_lkup[mode][type], NULL); + rc = smscore_load_firmware_from_file( + coredev, smscore_fw_lkup[mode][type], NULL); if (rc < 0) { - printk(KERN_INFO "%s load firmware failed %d\n", __func__, rc); + printk(KERN_INFO "%s load firmware " + "failed %d\n", __func__, rc); return rc; } } else - printk(KERN_INFO "%s mode %d supported by running firmware\n", __func__, mode); + printk(KERN_INFO "%s mode %d supported by running " + "firmware\n", __func__, mode); buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); if (buffer) { - SmsMsgData_ST *msg = (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); + SmsMsgData_ST *msg = + (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); - SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, sizeof(SmsMsgData_ST)); + SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, + sizeof(SmsMsgData_ST)); msg->msgData[0] = mode; - rc = smscore_sendrequest_and_wait(coredev, msg, msg->xMsgHeader.msgLength, &coredev->init_device_done); + rc = smscore_sendrequest_and_wait( + coredev, msg, msg->xMsgHeader.msgLength, + &coredev->init_device_done); kfree(buffer); } else { - printk(KERN_INFO "%s Could not allocate buffer for init device message.\n", __func__); + printk(KERN_INFO "%s Could not allocate buffer for " + "init device message.\n", __func__); rc = -ENOMEM; } } else { @@ -860,7 +897,8 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) /** * calls device handler to get current mode of operation * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * * @return current mode */ @@ -873,12 +911,14 @@ int smscore_get_device_mode(smscore_device_t *coredev) * find client by response id & type within the clients list. * return client handle or NULL. * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * @param data_type client data type (SMS_DONT_CARE for all types) * @param id client id (SMS_DONT_CARE for all id) * */ -smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, int id) +smscore_client_t *smscore_find_client(smscore_device_t *coredev, + int data_type, int id) { smscore_client_t *client = NULL; struct list_head *next, *first; @@ -911,15 +951,16 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, int data_type, * find client by response id/type, call clients onresponse handler * return buffer to pool on error * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * @param cb pointer to response buffer descriptor * */ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) { SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8 *) cb->p + cb->offset); - smscore_client_t *client = smscore_find_client(coredev, phdr->msgType, - phdr->msgDstId); + smscore_client_t *client = + smscore_find_client(coredev, phdr->msgType, phdr->msgDstId); int rc = -EBUSY; #if 1 @@ -1004,7 +1045,8 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) /** * return pointer to next free buffer descriptor from core pool * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * * @return pointer to descriptor on success, NULL on error. */ @@ -1028,7 +1070,8 @@ smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) /** * return buffer descriptor to a pool * - * @param coredev pointer to a coredev object returned by smscore_register_device + * @param coredev pointer to a coredev object returned by + * smscore_register_device * @param cb pointer buffer descriptor * */ @@ -1080,7 +1123,9 @@ int smscore_validate_client(smscore_device_t *coredev, * * @return 0 on success, <0 on error. */ -int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *params, smscore_client_t **client) +int smscore_register_client(smscore_device_t *coredev, + smsclient_params_t *params, + smscore_client_t **client) { smscore_client_t *newclient; /* check that no other channel with same parameters exists */ @@ -1115,7 +1160,8 @@ int smscore_register_client(smscore_device_t *coredev, smsclient_params_t *param /** * frees smsclient object and all subclients associated with it * - * @param client pointer to smsclient object returned by smscore_register_client + * @param client pointer to smsclient object returned by + * smscore_register_client * */ void smscore_unregister_client(smscore_client_t *client) @@ -1145,7 +1191,8 @@ void smscore_unregister_client(smscore_client_t *client) * verifies that source id is not taken by another client, * calls device handler to send requests to the device * - * @param client pointer to smsclient object returned by smscore_register_client + * @param client pointer to smsclient object returned by + * smscore_register_client * @param buffer pointer to a request buffer * @param size size (in bytes) of request buffer * diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 13e37b7b1..b4121f29a 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -65,7 +65,8 @@ void *kzalloc(size_t size, int flags); #define SMS_ALLOC_ALIGNMENT 128 #define SMS_DMA_ALIGNMENT 16 -#define SMS_ALIGN_ADDRESS(addr) ((((u32)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) +#define SMS_ALIGN_ADDRESS(addr) \ + ((((u32)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) #define SMS_DEVICE_FAMILY2 1 #define SMS_ROM_NO_RESPONSE 2 @@ -83,7 +84,8 @@ typedef struct _smscore_device smscore_device_t; typedef struct _smscore_client smscore_client_t; typedef struct _smscore_buffer smscore_buffer_t; -typedef int (*hotplug_t)(smscore_device_t *coredev, struct device *device, int arrival); +typedef int (*hotplug_t)(smscore_device_t *coredev, + struct device *device, int arrival); typedef int (*setmode_t)(void *context, int mode); typedef void (*detectmode_t)(void *context, int *mode); @@ -211,7 +213,8 @@ typedef struct _smsclient_params (ptr)->msgType = type; (ptr)->msgSrcId = src; (ptr)->msgDstId = dst; \ (ptr)->msgLength = len; (ptr)->msgFlags = 0; \ } while (0) -#define SMS_INIT_MSG(ptr, type, len) SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) +#define SMS_INIT_MSG(ptr, type, len) \ + SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) typedef enum { @@ -258,8 +261,11 @@ typedef struct SmsVersionRes_S u8 Step; /* 0 - Step A */ u8 MetalFix; /* 0 - Metal 0 */ - u8 FirmwareId; /* 0xFF � ROM, otherwise the value indicated by SMSHOSTLIB_DEVICE_MODES_E */ - u8 SupportedProtocols; /* Bitwise OR combination of supported protocols */ + u8 FirmwareId; /* 0xFF � ROM, otherwise the + * value indicated by + * SMSHOSTLIB_DEVICE_MODES_E */ + u8 SupportedProtocols; /* Bitwise OR combination of + * supported protocols */ u8 VersionMajor; u8 VersionMinor; @@ -295,36 +301,44 @@ typedef struct SMSHOSTLIB_STATISTICS_S s32 SNR; /* dB */ u32 BER; /* Post Viterbi BER [1E-5] */ u32 FIB_CRC; /* CRC errors percentage, valid only for DAB */ - u32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A, valid only for DVB-T/H */ - u32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ + u32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A, + * valid only for DVB-T/H */ + u32 MFER; /* DVB-H frame error rate in percentage, + * 0xFFFFFFFF indicate N/A, valid only for DVB-H */ s32 RSSI; /* dBm */ s32 InBandPwr; /* In band power in dBM */ s32 CarrierOffset; /* Carrier Offset in bin/1024 */ - /* Transmission parameters */ + /* Transmission parameters, valid only for DVB-T/H */ u32 Frequency; /* Frequency in Hz */ - u32 Bandwidth; /* Bandwidth in MHz, valid only for DVB-T/H */ - u32 TransmissionMode; /* Transmission Mode, for DAB modes 1-4, for DVB-T/H FFT mode carriers in Kilos */ - u32 ModemState; /* from SMS_DvbModemState_ET , valid only for DVB-T/H */ - u32 GuardInterval; /* Guard Interval, 1 divided by value , valid only for DVB-T/H */ - u32 CodeRate; /* Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ - u32 LPCodeRate; /* Low Priority Code Rate from SMS_DvbModemState_ET, valid only for DVB-T/H */ - u32 Hierarchy; /* Hierarchy from SMS_Hierarchy_ET, valid only for DVB-T/H */ - u32 Constellation; /* Constellation from SMS_Constellation_ET, valid only for DVB-T/H */ + u32 Bandwidth; /* Bandwidth in MHz */ + u32 TransmissionMode; /* Transmission Mode, for DAB modes 1-4, + * for DVB-T/H FFT mode carriers in Kilos */ + u32 ModemState; /* from SMS_DvbModemState_ET */ + u32 GuardInterval; /* Guard Interval, 1 divided by value */ + u32 CodeRate; /* Code Rate from SMS_DvbModemState_ET */ + u32 LPCodeRate; /* Low Priority Code Rate from SMS_DvbModemState_ET */ + u32 Hierarchy; /* Hierarchy from SMS_Hierarchy_ET */ + u32 Constellation; /* Constellation from SMS_Constellation_ET */ /* Burst parameters, valid only for DVB-H */ - u32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ - u32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ - u32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ - u32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ - u32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ - u32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ - u32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ + u32 BurstSize; /* Current burst size in bytes */ + u32 BurstDuration; /* Current burst duration in mSec */ + u32 BurstCycleTime; /* Current burst cycle time in mSec */ + u32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, + * as calculated by demodulator */ + u32 NumOfRows; /* Number of rows in MPE table */ + u32 NumOfPaddCols; /* Number of padding columns in MPE table */ + u32 NumOfPunctCols; /* Number of puncturing columns in MPE table */ + /* Burst parameters */ u32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ u32 TotalTSPackets; /* Total number of transport-stream packets */ - u32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding */ - u32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding */ - u32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding */ + u32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include + * errors after MPE RS decoding */ + u32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors + * after MPE RS decoding */ + u32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected + * by MPE RS decoding */ /* Common params */ u32 BERErrorCount; /* Number of errornous SYNC bits. */ @@ -337,7 +351,8 @@ typedef struct SMSHOSTLIB_STATISTICS_S u32 PreBER; /* DAB/T-DMB only: Pre Viterbi BER [1E-5] */ /* DVB-H TPS parameters */ - u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ + u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; + * if set to 0xFFFFFFFF cell_id not yet recovered */ } SMSHOSTLIB_STATISTICS_ST; @@ -356,8 +371,10 @@ typedef struct typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S { /* Per-layer information */ - u32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET, 255 means layer does not exist */ - u32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET, 255 means layer does not exist */ + u32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET, + * 255 means layer does not exist */ + u32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET, + * 255 means layer does not exist */ u32 BER; /* Post Viterbi BER [1E-5], 0xFFFFFFFF indicate N/A */ u32 BERErrorCount; /* Post Viterbi Error Bits Count */ u32 BERBitCount; /* Post Viterbi Total Bits Count */ @@ -365,8 +382,10 @@ typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S u32 TS_PER; /* Transport stream PER [%], 0xFFFFFFFF indicate N/A */ u32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ u32 TotalTSPackets; /* Total number of transport-stream packets */ - u32 TILdepthI; /* Time interleaver depth I parameter, 255 means layer does not exist */ - u32 NumberOfSegments; /* Number of segments in layer A, 255 means layer does not exist */ + u32 TILdepthI; /* Time interleaver depth I parameter, + * 255 means layer does not exist */ + u32 NumberOfSegments; /* Number of segments in layer A, + * 255 means layer does not exist */ u32 TMCCErrors; /* TMCC errors */ } SMSHOSTLIB_ISDBT_LAYER_STAT_ST; @@ -379,8 +398,9 @@ typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S * This field MUST always be first in any * statistics structure */ - u32 FullSize; /* Total size of the structure returned by the modem. If the size requested by - * the host is smaller than FullSize, the struct will be truncated */ + u32 FullSize; /* Total size of the structure returned by the modem. + * If the size requested by the host is smaller than + * FullSize, the struct will be truncated */ /* Common parameters */ u32 IsRfLocked; /* 0 - not locked, 1 - locked */ @@ -405,7 +425,8 @@ typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S /* Per-layer information */ /* Layers A, B and C */ - SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; /* Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST */ + SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; /* Per-layer statistics, + see SMSHOSTLIB_ISDBT_LAYER_STAT_ST */ /* Interface information */ u32 SmsToHostTxErrors; /* Total number of transmission errors. */ @@ -414,11 +435,15 @@ typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S typedef struct SMSHOSTLIB_STATISTICS_DVB_S { - u32 StatisticsType; /* Enumerator identifying the type of the structure. Values are the same as SMSHOSTLIB_DEVICE_MODES_E - * This fiels MUST always first in any statistics structure */ - - u32 FullSize; /* Total size of the structure returned by the modem. If the size requested by - * the host is smaller than FullSize, the struct will be truncated */ + u32 StatisticsType; /* Enumerator identifying the type of the + * structure. Values are the same as + * SMSHOSTLIB_DEVICE_MODES_E + * This field MUST always first in any + * statistics structure */ + + u32 FullSize; /* Total size of the structure returned by the modem. + * If the size requested by the host is smaller than + * FullSize, the struct will be truncated */ /* Common parameters */ u32 IsRfLocked; /* 0 - not locked, 1 - locked */ u32 IsDemodLocked; /* 0 - not locked, 1 - locked */ @@ -430,7 +455,8 @@ typedef struct SMSHOSTLIB_STATISTICS_DVB_S u32 BERErrorCount; /* Number of errornous SYNC bits. */ u32 BERBitCount; /* Total number of SYNC bits. */ u32 TS_PER; /* Transport stream PER, 0xFFFFFFFF indicate N/A */ - u32 MFER; /* DVB-H frame error rate in percentage, 0xFFFFFFFF indicate N/A, valid only for DVB-H */ + u32 MFER; /* DVB-H frame error rate in percentage, + * 0xFFFFFFFF indicate N/A, valid only for DVB-H */ s32 RSSI; /* dBm */ s32 InBandPwr; /* In band power in dBM */ s32 CarrierOffset; /* Carrier Offset in bin/1024 */ @@ -442,29 +468,41 @@ typedef struct SMSHOSTLIB_STATISTICS_DVB_S u32 TransmissionMode; /* FFT mode carriers in Kilos */ u32 GuardInterval; /* Guard Interval, 1 divided by value */ u32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET */ - u32 LPCodeRate; /* Low Priority Code Rate from SMSHOSTLIB_CODE_RATE_ET */ + u32 LPCodeRate; /* Low Priority Code Rate from + * SMSHOSTLIB_CODE_RATE_ET */ u32 Hierarchy; /* Hierarchy from SMSHOSTLIB_HIERARCHY_ET */ u32 Constellation; /* Constellation from SMSHOSTLIB_CONSTELLATION_ET */ /* Burst parameters, valid only for DVB-H */ - u32 BurstSize; /* Current burst size in bytes, valid only for DVB-H */ - u32 BurstDuration; /* Current burst duration in mSec, valid only for DVB-H */ - u32 BurstCycleTime; /* Current burst cycle time in mSec, valid only for DVB-H */ - u32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, as calculated by demodulator, valid only for DVB-H */ - u32 NumOfRows; /* Number of rows in MPE table, valid only for DVB-H */ - u32 NumOfPaddCols; /* Number of padding columns in MPE table, valid only for DVB-H */ - u32 NumOfPunctCols; /* Number of puncturing columns in MPE table, valid only for DVB-H */ + u32 BurstSize; /* Current burst size in bytes */ + u32 BurstDuration; /* Current burst duration in mSec */ + u32 BurstCycleTime; /* Current burst cycle time in mSec */ + u32 CalculatedBurstCycleTime; /* Current burst cycle time in mSec, + * as calculated by demodulator */ + u32 NumOfRows; /* Number of rows in MPE table */ + u32 NumOfPaddCols; /* Number of padding columns in MPE table */ + u32 NumOfPunctCols; /* Number of puncturing columns in MPE table */ + u32 ErrorTSPackets; /* Number of erroneous transport-stream packets */ u32 TotalTSPackets; /* Total number of transport-stream packets */ - u32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include errors after MPE RS decoding, valid only for DVB-H */ - u32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include errors after MPE RS decoding, valid only for DVB-H */ - u32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were corrected by MPE RS decoding, valid only for DVB-H */ + + u32 NumOfValidMpeTlbs; /* Number of MPE tables which do not include + * errors after MPE RS decoding */ + u32 NumOfInvalidMpeTlbs; /* Number of MPE tables which include + * errors after MPE RS decoding */ + u32 NumOfCorrectedMpeTlbs; /* Number of MPE tables which were + * corrected by MPE RS decoding */ + u32 NumMPEReceived; /* DVB-H, Num MPE section received */ /* DVB-H TPS parameters */ u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ - u32 DvbhSrvIndHP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ - u32 DvbhSrvIndLP; /* DVB-H service indication info, bit 1 - Time Slicing indicator, bit 0 - MPE-FEC indicator */ + u32 DvbhSrvIndHP; /* DVB-H service indication info, + * bit 1 - Time Slicing indicator, + * bit 0 - MPE-FEC indicator */ + u32 DvbhSrvIndLP; /* DVB-H service indication info, + * bit 1 - Time Slicing indicator, + * bit 0 - MPE-FEC indicator */ /* Interface information */ u32 SmsToHostTxErrors; /* Total number of transmission errors. */ @@ -474,10 +512,14 @@ typedef struct SMSHOSTLIB_STATISTICS_DVB_S typedef struct SMSHOSTLIB_GPIO_CONFIG_S { u8 Direction; /* GPIO direction: Input - 0, Output - 1 */ - u8 PullUpDown; /* PullUp/PullDown: None - 0, PullDown - 1, PullUp - 2, Keeper - 3 */ - u8 InputCharacteristics; /* Input Characteristics: Normal - 0, Schmitt trigger - 1 */ - u8 OutputSlewRate; /* Output Slew Rate: Fast slew rate - 0, Slow slew rate - 1 */ - u8 OutputDriving; /* Output driving capability: 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 */ + u8 PullUpDown; /* PullUp/PullDown: None - 0, + * PullDown - 1, PullUp - 2, Keeper - 3 */ + u8 InputCharacteristics; /* Input Characteristics: Normal - 0, + * Schmitt trigger - 1 */ + u8 OutputSlewRate; /* Output Slew Rate: + * Fast slew rate - 0, Slow slew rate - 1 */ + u8 OutputDriving; /* Output driving capability: + * 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 */ } SMSHOSTLIB_GPIO_CONFIG_ST; typedef struct SMSHOSTLIB_I2C_REQ_S diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 81c42d1c9..a8255c642 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -317,7 +317,8 @@ int smsdvb_hotplug(smscore_device_t *coredev, if (smscore_get_device_mode(coredev) != 4) { #if 1 /* new siano drop (1.2.17) does this -- yuck */ - printk(KERN_ERR "%sSMS Device mode is not set for DVB operation.\n", __func__); + printk(KERN_ERR "%sSMS Device mode is not set for " + "DVB operation.\n", __func__); return 0; #else rc = smscore_set_device_mode(coredev, 4); diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index d5e2f9ce0..878bdba86 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -399,7 +399,8 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02)); if (intf->num_altsetting > 0) { - rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); + rc = usb_set_interface( + udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); if (rc < 0) { printk(KERN_INFO "%s usb_set_interface failed, " "rc %d\n", __func__, rc); @@ -425,7 +426,8 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) snprintf(devpath, sizeof(devpath), "usb\\%d-%s", udev->bus->busnum, udev->devpath); printk(KERN_INFO "stellar device was found.\n"); - return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath)); + return smsusb1_load_firmware( + udev, smscore_registry_getmode(devpath)); } rc = smsusb_init_device(intf); -- cgit v1.2.3 From 213a09fbeb7f2c863fa01a4169d5e4268ea6e32f Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 13:26:42 -0400 Subject: sms1xxx: fix WARNING: printk() should include KERN_ facility level From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 26 +++++++++++++++----------- linux/drivers/media/dvb/siano/smsdvb.c | 24 +++++++++++++++--------- linux/drivers/media/dvb/siano/smsusb.c | 4 ++-- 3 files changed, 32 insertions(+), 22 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 6611e9b53..904a0da86 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -616,7 +616,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, msleep(500); } - printk("%s rc=%d, postload=%p \n", __func__, rc, + printk(KERN_DEBUG "%s rc=%d, postload=%p \n", __func__, rc, coredev->postload_handler); kfree(msg); @@ -760,8 +760,8 @@ int smscore_detect_mode(smscore_device_t *coredev) rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc == -ETIME) { - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed first try\n", - __func__); + printk(KERN_ERR "%s: MSG_SMS_GET_VERSION_EX_REQ " + "failed first try\n", __func__); if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) { @@ -769,7 +769,8 @@ int smscore_detect_mode(smscore_device_t *coredev) coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc < 0) - printk("%s: MSG_SMS_GET_VERSION_EX_REQ failed " + printk(KERN_ERR "%s: " + "MSG_SMS_GET_VERSION_EX_REQ failed " "second try, rc %d\n", __func__, rc); } else rc = -ETIME; @@ -972,7 +973,7 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) last_sample_time = time_now; if (time_now - last_sample_time > 10000) { - printk("\n%s data rate %d bytes/secs\n", __func__, + printk(KERN_DEBUG "\n%s data rate %d bytes/secs\n", __func__, (int)((data_total * 1000) / (time_now - last_sample_time))); @@ -996,8 +997,8 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) case MSG_SMS_GET_VERSION_EX_RES: { SmsVersionRes_ST *ver = (SmsVersionRes_ST *) phdr; - printk("%s: MSG_SMS_GET_VERSION_EX_RES id %d " - "prots 0x%x ver %d.%d\n", __func__, + printk(KERN_DEBUG "%s: MSG_SMS_GET_VERSION_EX_RES " + "id %d prots 0x%x ver %d.%d\n", __func__, ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); @@ -1009,21 +1010,24 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) break; } case MSG_SMS_INIT_DEVICE_RES: - printk("%s: MSG_SMS_INIT_DEVICE_RES\n", __func__); + printk(KERN_DEBUG "%s: MSG_SMS_INIT_DEVICE_RES\n", + __func__); complete(&coredev->init_device_done); break; case MSG_SW_RELOAD_START_RES: - printk("%s: MSG_SW_RELOAD_START_RES\n", __func__); + printk(KERN_DEBUG "%s: MSG_SW_RELOAD_START_RES\n", + __func__); complete(&coredev->reload_start_done); break; case MSG_SMS_DATA_DOWNLOAD_RES: complete(&coredev->data_download_done); break; case MSG_SW_RELOAD_EXEC_RES: - printk("%s: MSG_SW_RELOAD_EXEC_RES\n", __func__); + printk(KERN_DEBUG "%s: MSG_SW_RELOAD_EXEC_RES\n", + __func__); break; case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", + printk(KERN_DEBUG "%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __func__); complete(&coredev->trigger_done); break; diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index a8255c642..b8af76ab5 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -111,7 +111,8 @@ static int smsdvb_start_feed(struct dvb_demux_feed *feed) container_of(feed->demux, smsdvb_client_t, demux); SmsMsgData_ST PidMsg; - printk("%s add pid %d(%x)\n", __func__, feed->pid, feed->pid); + printk(KERN_DEBUG "%s add pid %d(%x)\n", __func__, + feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; PidMsg.xMsgHeader.msgDstId = HIF_TASK; @@ -130,7 +131,8 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) container_of(feed->demux, smsdvb_client_t, demux); SmsMsgData_ST PidMsg; - printk("%s remove pid %d(%x)\n", __func__, feed->pid, feed->pid); + printk(KERN_DEBUG "%s remove pid %d(%x)\n", __func__, + feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; PidMsg.xMsgHeader.msgDstId = HIF_TASK; @@ -212,7 +214,7 @@ static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) { - printk("%s\n", __func__); + printk(KERN_DEBUG "%s\n", __func__); tune->min_delay_ms = 400; tune->step_size = 250000; @@ -239,7 +241,7 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, Msg.Data[0] = fep->frequency; Msg.Data[2] = 12000000; - printk("%s freq %d band %d\n", __func__, + printk(KERN_DEBUG "%s freq %d band %d\n", __func__, fep->frequency, fep->u.ofdm.bandwidth); switch (fep->u.ofdm.bandwidth) { @@ -262,7 +264,7 @@ static int smsdvb_get_frontend(struct dvb_frontend *fe, { smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); - printk("%s\n", __func__); + printk(KERN_DEBUG "%s\n", __func__); /* todo: */ memcpy(fep, &client->fe_params, @@ -337,7 +339,8 @@ int smsdvb_hotplug(smscore_device_t *coredev, rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", THIS_MODULE, device, adapter_nr); if (rc < 0) { - printk("%s dvb_register_adapter() failed %d\n", __func__, rc); + printk(KERN_ERR "%s dvb_register_adapter() failed %d\n", + __func__, rc); goto adapter_error; } @@ -350,7 +353,8 @@ int smsdvb_hotplug(smscore_device_t *coredev, rc = dvb_dmx_init(&client->demux); if (rc < 0) { - printk("%s dvb_dmx_init failed %d\n\n", __func__, rc); + printk(KERN_ERR "%s dvb_dmx_init failed %d\n\n", + __func__, rc); goto dvbdmx_error; } @@ -361,7 +365,8 @@ int smsdvb_hotplug(smscore_device_t *coredev, rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { - printk("%s dvb_dmxdev_init failed %d\n", __func__, rc); + printk(KERN_ERR "%s dvb_dmxdev_init failed %d\n", + __func__, rc); goto dmxdev_error; } @@ -371,7 +376,8 @@ int smsdvb_hotplug(smscore_device_t *coredev, rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { - printk("%s frontend registration failed %d\n", __func__, rc); + printk(KERN_ERR "%s frontend registration failed %d\n", + __func__, rc); goto frontend_error; } diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 878bdba86..0c4776b4d 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -245,7 +245,7 @@ void smsusb1_detectmode(void *context, int *mode) if (!product_string) { product_string = "none"; - printk("%s product string not found\n", __func__); + printk(KERN_ERR "%s product string not found\n", __func__); } else if (strstr(product_string, "DVBH")) *mode = 1; else if (strstr(product_string, "BDA")) @@ -255,7 +255,7 @@ void smsusb1_detectmode(void *context, int *mode) else if (strstr(product_string, "TDMB")) *mode = 2; - printk("%s: %d \"%s\"\n", __func__, *mode, product_string); + printk(KERN_INFO "%s: %d \"%s\"\n", __func__, *mode, product_string); } int smsusb1_setmode(void *context, int mode) -- cgit v1.2.3 From 8d4d091ce0e9cd73abc0afe1a0db74aa48843421 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 13:36:00 -0400 Subject: sms1xxx: more 80-column cleanups From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 9 ++++++--- linux/drivers/media/dvb/siano/smscoreapi.h | 3 ++- 2 files changed, 8 insertions(+), 4 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 904a0da86..9a6287b59 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -1027,7 +1027,8 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) __func__); break; case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk(KERN_DEBUG "%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", + printk(KERN_DEBUG + "%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", __func__); complete(&coredev->trigger_done); break; @@ -1120,7 +1121,8 @@ int smscore_validate_client(smscore_device_t *coredev, * @param coredev pointer to a coredev object from clients hotplug * @param initial_id all messages with this id would be sent to this client * @param data_type all messages of this type would be sent to this client - * @param onresponse_handler client handler that is called to process incoming messages + * @param onresponse_handler client handler that is called to + * process incoming messages * @param onremove_handler client handler that is called when device is removed * @param context client-specific context * @param client pointer to a value that receives created smsclient object @@ -1269,7 +1271,8 @@ int smscore_map_common_buffer(smscore_device_t *coredev, } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) - if (remap_page_range(vma, start, coredev->common_buffer_phys, size, vma->vm_page_prot)) + if (remap_page_range(vma, start, coredev->common_buffer_phys, size, + vma->vm_page_prot)) #else if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index b4121f29a..6d04cbb08 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -496,7 +496,8 @@ typedef struct SMSHOSTLIB_STATISTICS_DVB_S u32 NumMPEReceived; /* DVB-H, Num MPE section received */ /* DVB-H TPS parameters */ - u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; if set to 0xFFFFFFFF cell_id not yet recovered */ + u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; + * if set to 0xFFFFFFFF cell_id not yet recovered */ u32 DvbhSrvIndHP; /* DVB-H service indication info, * bit 1 - Time Slicing indicator, * bit 0 - MPE-FEC indicator */ -- cgit v1.2.3 From 118d0c5c79b895c0954f2ffdbd860973a94f7579 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 13:52:24 -0400 Subject: sms1xxx: remove typedefs From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 243 +++++++++++++++-------------- linux/drivers/media/dvb/siano/smscoreapi.h | 166 +++++++++----------- linux/drivers/media/dvb/siano/smsdvb.c | 70 +++++---- linux/drivers/media/dvb/siano/smsusb.c | 62 ++++---- 4 files changed, 272 insertions(+), 269 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 9a6287b59..6858f7d99 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -50,33 +50,27 @@ #define PWARNING(fmt, args...) #endif -typedef struct _smscore_device_notifyee -{ +struct smscore_device_notifyee_t { struct list_head entry; hotplug_t hotplug; -} smscore_device_notifyee_t; +}; -typedef struct _smscore_subclient -{ +struct smscore_idlist_t { struct list_head entry; int id; int data_type; -} smscore_idlist_t; +}; -typedef struct _smscore_client -{ +struct smscore_client_t { struct list_head entry; - smscore_device_t *coredev; + struct smscore_device_t *coredev; void *context; struct list_head idlist; onresponse_t onresponse_handler; onremove_t onremove_handler; -} *psmscore_client_t; - - +}; -typedef struct _smscore_device -{ +struct smscore_device_t { struct list_head entry; struct list_head clients; @@ -107,15 +101,14 @@ typedef struct _smscore_device struct completion version_ex_done, data_download_done, trigger_done; struct completion init_device_done, reload_start_done, resume_done; -} *psmscore_device_t; +}; -typedef struct _smscore_registry_entry -{ +struct smscore_registry_entry_t { struct list_head entry; char devpath[32]; int mode; - sms_device_type_st type; -} smscore_registry_entry_t; + enum sms_device_type_st type; +}; struct list_head g_smscore_notifyees; struct list_head g_smscore_devices; @@ -129,23 +122,24 @@ static int default_mode = 1; module_param(default_mode, int, 0644); MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); -static smscore_registry_entry_t *smscore_find_registry(char *devpath) +static struct smscore_registry_entry_t *smscore_find_registry(char *devpath) { - smscore_registry_entry_t *entry; + struct smscore_registry_entry_t *entry; struct list_head *next; kmutex_lock(&g_smscore_registrylock); for (next = g_smscore_registry.next; next != &g_smscore_registry; next = next->next) { - entry = (smscore_registry_entry_t *) next; + entry = (struct smscore_registry_entry_t *) next; if (!strcmp(entry->devpath, devpath)) { kmutex_unlock(&g_smscore_registrylock); return entry; } } - entry = (smscore_registry_entry_t *) - kmalloc(sizeof(smscore_registry_entry_t), GFP_KERNEL); + entry = (struct smscore_registry_entry_t *) + kmalloc(sizeof(struct smscore_registry_entry_t), + GFP_KERNEL); if (entry) { entry->mode = default_mode; strcpy(entry->devpath, devpath); @@ -159,7 +153,7 @@ static smscore_registry_entry_t *smscore_find_registry(char *devpath) int smscore_registry_getmode(char *devpath) { - smscore_registry_entry_t *entry; + struct smscore_registry_entry_t *entry; entry = smscore_find_registry(devpath); if (entry) @@ -170,9 +164,9 @@ int smscore_registry_getmode(char *devpath) return default_mode; } -sms_device_type_st smscore_registry_gettype(char *devpath) +enum sms_device_type_st smscore_registry_gettype(char *devpath) { - smscore_registry_entry_t *entry; + struct smscore_registry_entry_t *entry; entry = smscore_find_registry(devpath); if (entry) @@ -185,7 +179,7 @@ sms_device_type_st smscore_registry_gettype(char *devpath) void smscore_registry_setmode(char *devpath, int mode) { - smscore_registry_entry_t *entry; + struct smscore_registry_entry_t *entry; entry = smscore_find_registry(devpath); if (entry) @@ -194,9 +188,9 @@ void smscore_registry_setmode(char *devpath, int mode) printk(KERN_ERR "%s No registry found.\n", __func__); } -void smscore_registry_settype(char *devpath, sms_device_type_st type) +void smscore_registry_settype(char *devpath, enum sms_device_type_st type) { - smscore_registry_entry_t *entry; + struct smscore_registry_entry_t *entry; entry = smscore_find_registry(devpath); if (entry) @@ -277,20 +271,22 @@ void list_add_locked(struct list_head *new, struct list_head *head, */ int smscore_register_hotplug(hotplug_t hotplug) { - smscore_device_notifyee_t *notifyee; + struct smscore_device_notifyee_t *notifyee; struct list_head *next, *first; int rc = 0; kmutex_lock(&g_smscore_deviceslock); - notifyee = kmalloc(sizeof(smscore_device_notifyee_t), GFP_KERNEL); + notifyee = kmalloc(sizeof(struct smscore_device_notifyee_t), + GFP_KERNEL); if (notifyee) { /* now notify callback about existing devices */ first = &g_smscore_devices; for (next = first->next; next != first && !rc; next = next->next) { - smscore_device_t *coredev = (smscore_device_t *) next; + struct smscore_device_t *coredev = + (struct smscore_device_t *) next; rc = hotplug(coredev, coredev->device, 1); } @@ -322,8 +318,8 @@ void smscore_unregister_hotplug(hotplug_t hotplug) first = &g_smscore_notifyees; for (next = first->next; next != first;) { - smscore_device_notifyee_t *notifyee = - (smscore_device_notifyee_t *) next; + struct smscore_device_notifyee_t *notifyee = + (struct smscore_device_notifyee_t *) next; next = next->next; if (notifyee->hotplug == hotplug) { @@ -335,19 +331,19 @@ void smscore_unregister_hotplug(hotplug_t hotplug) kmutex_unlock(&g_smscore_deviceslock); } -void smscore_notify_clients(smscore_device_t *coredev) +void smscore_notify_clients(struct smscore_device_t *coredev) { - smscore_client_t *client; + struct smscore_client_t *client; /* the client must call smscore_unregister_client from remove handler */ while (!list_empty(&coredev->clients)) { - client = (smscore_client_t *) coredev->clients.next; + client = (struct smscore_client_t *) coredev->clients.next; client->onremove_handler(client->context); } } -int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, - int arrival) +int smscore_notify_callbacks(struct smscore_device_t *coredev, + struct device *device, int arrival) { struct list_head *next, *first; int rc = 0; @@ -357,7 +353,7 @@ int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, first = &g_smscore_notifyees; for (next = first->next; next != first; next = next->next) { - rc = ((smscore_device_notifyee_t *) next)-> + rc = ((struct smscore_device_notifyee_t *) next)-> hotplug(coredev, device, arrival); if (rc < 0) break; @@ -366,10 +362,11 @@ int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, return rc; } -smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, +struct smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, dma_addr_t common_buffer_phys) { - smscore_buffer_t *cb = kmalloc(sizeof(smscore_buffer_t), GFP_KERNEL); + struct smscore_buffer_t *cb = + kmalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL); if (!cb) { printk(KERN_INFO "%s kmalloc(...) failed\n", __func__); return NULL; @@ -392,13 +389,13 @@ smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, * * @return 0 on success, <0 on error. */ -int smscore_register_device(smsdevice_params_t *params, - smscore_device_t **coredev) +int smscore_register_device(struct smsdevice_params_t *params, + struct smscore_device_t **coredev) { - smscore_device_t *dev; + struct smscore_device_t *dev; u8 *buffer; - dev = kzalloc(sizeof(smscore_device_t), GFP_KERNEL); + dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL); if (!dev) { printk(KERN_INFO "%s kzalloc(...) failed\n", __func__); return -ENOMEM; @@ -437,7 +434,7 @@ int smscore_register_device(smsdevice_params_t *params, for (buffer = dev->common_buffer; dev->num_buffers < params->num_buffers; dev->num_buffers++, buffer += params->buffer_size) { - smscore_buffer_t *cb = + struct smscore_buffer_t *cb = smscore_createbuffer(buffer, dev->common_buffer, dev->common_buffer_phys); if (!cb) { @@ -485,7 +482,7 @@ int smscore_register_device(smsdevice_params_t *params, * * @return 0 on success, <0 on error. */ -int smscore_start_device(smscore_device_t *coredev) +int smscore_start_device(struct smscore_device_t *coredev) { int rc = smscore_set_device_mode( coredev, smscore_registry_getmode(coredev->devpath)); @@ -507,7 +504,7 @@ int smscore_start_device(smscore_device_t *coredev) return rc; } -int smscore_sendrequest_and_wait(smscore_device_t *coredev, void *buffer, +int smscore_sendrequest_and_wait(struct smscore_device_t *coredev, void *buffer, size_t size, struct completion *completion) { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); @@ -522,11 +519,11 @@ int smscore_sendrequest_and_wait(smscore_device_t *coredev, void *buffer, 0 : -ETIME; } -int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, - size_t size) +int smscore_load_firmware_family2(struct smscore_device_t *coredev, + void *buffer, size_t size) { - SmsFirmware_ST *firmware = (SmsFirmware_ST *) buffer; - SmsMsgHdr_ST *msg; + struct SmsFirmware_ST *firmware = (struct SmsFirmware_ST *) buffer; + struct SmsMsgHdr_ST *msg; u32 mem_address = firmware->StartAddress; u8 *payload = firmware->Payload; int rc = 0; @@ -540,14 +537,14 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, } /* PAGE_SIZE buffer shall be enough and dma aligned */ - msg = (SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); + msg = (struct SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); if (!msg) return -ENOMEM; if (coredev->mode != DEVICE_MODE_NONE) { PDEBUG("Sending reload command\n"); SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, - sizeof(SmsMsgHdr_ST)); + sizeof(struct SmsMsgHdr_ST)); rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->reload_start_done); @@ -555,11 +552,12 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, } while (size && rc >= 0) { - SmsDataDownload_ST *DataMsg = (SmsDataDownload_ST *) msg; + struct SmsDataDownload_ST *DataMsg = + (struct SmsDataDownload_ST *) msg; int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE); SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ, - (u16)(sizeof(SmsMsgHdr_ST) + + (u16)(sizeof(struct SmsMsgHdr_ST) + sizeof(u32) + payload_size)); DataMsg->MemAddr = mem_address; @@ -583,10 +581,11 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, if (rc >= 0) { if (coredev->mode == DEVICE_MODE_NONE) { - SmsMsgData_ST *TriggerMsg = (SmsMsgData_ST *) msg; + struct SmsMsgData_ST *TriggerMsg = + (struct SmsMsgData_ST *) msg; SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ, - sizeof(SmsMsgHdr_ST) + + sizeof(struct SmsMsgHdr_ST) + sizeof(u32) * 5); TriggerMsg->msgData[0] = firmware->StartAddress; @@ -608,7 +607,7 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, &coredev->trigger_done); } else { SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ, - sizeof(SmsMsgHdr_ST)); + sizeof(struct SmsMsgHdr_ST)); rc = coredev->sendrequest_handler(coredev->context, msg, msg->msgLength); @@ -636,7 +635,8 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, * * @return 0 on success, <0 on error. */ -int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, +int smscore_load_firmware_from_file(struct smscore_device_t *coredev, + char *filename, loadfirmware_t loadfirmware_handler) { int rc = -ENOENT; @@ -682,8 +682,8 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, return rc; } -int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, - int size, int new_mode) +int smscore_load_firmware_from_buffer(struct smscore_device_t *coredev, + u8 *buffer, int size, int new_mode) { PERROR("Feature not implemented yet\n"); return -EFAULT; @@ -698,9 +698,9 @@ int smscore_load_firmware_from_buffer(smscore_device_t *coredev, u8 *buffer, * * @return 0 on success, <0 on error. */ -void smscore_unregister_device(smscore_device_t *coredev) +void smscore_unregister_device(struct smscore_device_t *coredev) { - smscore_buffer_t *cb; + struct smscore_buffer_t *cb; int num_buffers = 0; int retry = 0; @@ -745,17 +745,19 @@ void smscore_unregister_device(smscore_device_t *coredev) printk(KERN_INFO "%s device %p destroyed\n", __func__, coredev); } -int smscore_detect_mode(smscore_device_t *coredev) +int smscore_detect_mode(struct smscore_device_t *coredev) { - void *buffer = kmalloc(sizeof(SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, + void *buffer = kmalloc(sizeof(struct SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); - SmsMsgHdr_ST *msg = (SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer); + struct SmsMsgHdr_ST *msg = + (struct SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer); int rc; if (!buffer) return -ENOMEM; - SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ, sizeof(SmsMsgHdr_ST)); + SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ, + sizeof(struct SmsMsgHdr_ST)); rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); @@ -804,11 +806,11 @@ char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { * * @return 0 on success, <0 on error. */ -int smscore_set_device_mode(smscore_device_t *coredev, int mode) +int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) { void *buffer; int rc = 0; - sms_device_type_st type; + enum sms_device_type_st type; PDEBUG("set device mode to %d\n", mode); if (coredev->device_flags & SMS_DEVICE_FAMILY2) { @@ -848,14 +850,15 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) printk(KERN_INFO "%s mode %d supported by running " "firmware\n", __func__, mode); - buffer = kmalloc(sizeof(SmsMsgData_ST) + SMS_DMA_ALIGNMENT, - GFP_KERNEL | GFP_DMA); + buffer = kmalloc(sizeof(struct SmsMsgData_ST) + + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); if (buffer) { - SmsMsgData_ST *msg = - (SmsMsgData_ST *) SMS_ALIGN_ADDRESS(buffer); + struct SmsMsgData_ST *msg = + (struct SmsMsgData_ST *) + SMS_ALIGN_ADDRESS(buffer); SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ, - sizeof(SmsMsgData_ST)); + sizeof(struct SmsMsgData_ST)); msg->msgData[0] = mode; rc = smscore_sendrequest_and_wait( @@ -903,7 +906,7 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) * * @return current mode */ -int smscore_get_device_mode(smscore_device_t *coredev) +int smscore_get_device_mode(struct smscore_device_t *coredev) { return coredev->mode; } @@ -918,10 +921,10 @@ int smscore_get_device_mode(smscore_device_t *coredev) * @param id client id (SMS_DONT_CARE for all id) * */ -smscore_client_t *smscore_find_client(smscore_device_t *coredev, +struct smscore_client_t *smscore_find_client(struct smscore_device_t *coredev, int data_type, int id) { - smscore_client_t *client = NULL; + struct smscore_client_t *client = NULL; struct list_head *next, *first; unsigned long flags; struct list_head *firstid, *nextid; @@ -932,14 +935,14 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, for (next = first->next; (next != first) && !client; next = next->next) { - firstid = &((smscore_client_t *)next)->idlist; + firstid = &((struct smscore_client_t *)next)->idlist; for (nextid = firstid->next; nextid != firstid; nextid = nextid->next) { - if ((((smscore_idlist_t *)nextid)->id == id) && - (((smscore_idlist_t *)nextid)->data_type == data_type || - (((smscore_idlist_t *)nextid)->data_type == 0))) { - client = (smscore_client_t *) next; + if ((((struct smscore_idlist_t *)nextid)->id == id) && + (((struct smscore_idlist_t *)nextid)->data_type == data_type || + (((struct smscore_idlist_t *)nextid)->data_type == 0))) { + client = (struct smscore_client_t *) next; break; } } @@ -957,10 +960,12 @@ smscore_client_t *smscore_find_client(smscore_device_t *coredev, * @param cb pointer to response buffer descriptor * */ -void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) +void smscore_onresponse(struct smscore_device_t *coredev, + struct smscore_buffer_t *cb) { - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)((u8 *) cb->p + cb->offset); - smscore_client_t *client = + struct SmsMsgHdr_ST *phdr = + (struct SmsMsgHdr_ST *)((u8 *) cb->p + cb->offset); + struct smscore_client_t *client = smscore_find_client(coredev, phdr->msgType, phdr->msgDstId); int rc = -EBUSY; @@ -996,7 +1001,8 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) switch (phdr->msgType) { case MSG_SMS_GET_VERSION_EX_RES: { - SmsVersionRes_ST *ver = (SmsVersionRes_ST *) phdr; + struct SmsVersionRes_ST *ver = + (struct SmsVersionRes_ST *) phdr; printk(KERN_DEBUG "%s: MSG_SMS_GET_VERSION_EX_RES " "id %d prots 0x%x ver %d.%d\n", __func__, ver->FirmwareId, ver->SupportedProtocols, @@ -1055,15 +1061,15 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) * * @return pointer to descriptor on success, NULL on error. */ -smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) +struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev) { - smscore_buffer_t *cb = NULL; + struct smscore_buffer_t *cb = NULL; unsigned long flags; spin_lock_irqsave(&coredev->bufferslock, flags); if (!list_empty(&coredev->buffers)) { - cb = (smscore_buffer_t *) coredev->buffers.next; + cb = (struct smscore_buffer_t *) coredev->buffers.next; list_del(&cb->entry); } @@ -1080,16 +1086,18 @@ smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev) * @param cb pointer buffer descriptor * */ -void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb) +void smscore_putbuffer(struct smscore_device_t *coredev, + struct smscore_buffer_t *cb) { list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); } -int smscore_validate_client(smscore_device_t *coredev, - smscore_client_t *client, int data_type, int id) +int smscore_validate_client(struct smscore_device_t *coredev, + struct smscore_client_t *client, + int data_type, int id) { - smscore_idlist_t *listentry; - smscore_client_t *registered_client; + struct smscore_idlist_t *listentry; + struct smscore_client_t *registered_client; if (!client) { PERROR("bad parameter.\n"); @@ -1103,7 +1111,7 @@ int smscore_validate_client(smscore_device_t *coredev, PERROR("The msg ID already registered to another client.\n"); return -EEXIST; } - listentry = kzalloc(sizeof(smscore_idlist_t), GFP_KERNEL); + listentry = kzalloc(sizeof(struct smscore_idlist_t), GFP_KERNEL); if (!listentry) { PERROR("Can't allocate memory for client id.\n"); return -ENOMEM; @@ -1129,11 +1137,11 @@ int smscore_validate_client(smscore_device_t *coredev, * * @return 0 on success, <0 on error. */ -int smscore_register_client(smscore_device_t *coredev, - smsclient_params_t *params, - smscore_client_t **client) +int smscore_register_client(struct smscore_device_t *coredev, + struct smsclient_params_t *params, + struct smscore_client_t **client) { - smscore_client_t *newclient; + struct smscore_client_t *newclient; /* check that no other channel with same parameters exists */ if (smscore_find_client(coredev, params->data_type, params->initial_id)) { @@ -1141,7 +1149,7 @@ int smscore_register_client(smscore_device_t *coredev, return -EEXIST; } - newclient = kzalloc(sizeof(smscore_client_t), GFP_KERNEL); + newclient = kzalloc(sizeof(struct smscore_client_t), GFP_KERNEL); if (!newclient) { PERROR("Failed to allocate memory for client.\n"); return -ENOMEM; @@ -1170,17 +1178,17 @@ int smscore_register_client(smscore_device_t *coredev, * smscore_register_client * */ -void smscore_unregister_client(smscore_client_t *client) +void smscore_unregister_client(struct smscore_client_t *client) { - smscore_device_t *coredev = client->coredev; + struct smscore_device_t *coredev = client->coredev; unsigned long flags; spin_lock_irqsave(&coredev->clientslock, flags); while (!list_empty(&client->idlist)) { - smscore_idlist_t *identry = - (smscore_idlist_t *) client->idlist.next; + struct smscore_idlist_t *identry = + (struct smscore_idlist_t *) client->idlist.next; list_del(&identry->entry); kfree(identry); } @@ -1204,10 +1212,11 @@ void smscore_unregister_client(smscore_client_t *client) * * @return 0 on success, <0 on error. */ -int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) +int smsclient_sendrequest(struct smscore_client_t *client, + void *buffer, size_t size) { - smscore_device_t *coredev; - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) buffer; + struct smscore_device_t *coredev; + struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) buffer; int rc; if (client == NULL) { @@ -1238,7 +1247,7 @@ int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) * * @return size (in bytes) of the buffer */ -int smscore_get_common_buffer_size(smscore_device_t *coredev) +int smscore_get_common_buffer_size(struct smscore_device_t *coredev) { return coredev->common_buffer_size; } @@ -1251,7 +1260,7 @@ int smscore_get_common_buffer_size(smscore_device_t *coredev) * * @return 0 on success, <0 on error. */ -int smscore_map_common_buffer(smscore_device_t *coredev, +int smscore_map_common_buffer(struct smscore_device_t *coredev, struct vm_area_struct *vma) { unsigned long end = vma->vm_end, @@ -1313,8 +1322,9 @@ void smscore_module_exit(void) kmutex_lock(&g_smscore_deviceslock); while (!list_empty(&g_smscore_notifyees)) { - smscore_device_notifyee_t *notifyee = - (smscore_device_notifyee_t *) g_smscore_notifyees.next; + struct smscore_device_notifyee_t *notifyee = + (struct smscore_device_notifyee_t *) + g_smscore_notifyees.next; list_del(¬ifyee->entry); kfree(notifyee); @@ -1323,8 +1333,9 @@ void smscore_module_exit(void) kmutex_lock(&g_smscore_registrylock); while (!list_empty(&g_smscore_registry)) { - smscore_registry_entry_t *entry = - (smscore_registry_entry_t *) g_smscore_registry.next; + struct smscore_registry_entry_t *entry = + (struct smscore_registry_entry_t *) + g_smscore_registry.next; list_del(&entry->entry); kfree(entry); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 6d04cbb08..deeb4c2d7 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -72,19 +72,19 @@ void *kzalloc(size_t size, int flags); #define SMS_ROM_NO_RESPONSE 2 #define SMS_DEVICE_NOT_READY 0x8000000 -typedef enum { +enum sms_device_type_st { SMS_STELLAR = 0, SMS_NOVA_A0, SMS_NOVA_B0, SMS_VEGA, SMS_NUM_OF_DEVICE_TYPES -} sms_device_type_st; +}; -typedef struct _smscore_device smscore_device_t; -typedef struct _smscore_client smscore_client_t; -typedef struct _smscore_buffer smscore_buffer_t; +struct smscore_device_t; +struct smscore_client_t; +struct smscore_buffer_t; -typedef int (*hotplug_t)(smscore_device_t *coredev, +typedef int (*hotplug_t)(struct smscore_device_t *coredev, struct device *device, int arrival); typedef int (*setmode_t)(void *context, int mode); @@ -94,11 +94,10 @@ typedef int (*loadfirmware_t)(void *context, void *buffer, size_t size); typedef int (*preload_t)(void *context); typedef int (*postload_t)(void *context); -typedef int (*onresponse_t)(void *context, smscore_buffer_t *cb); +typedef int (*onresponse_t)(void *context, struct smscore_buffer_t *cb); typedef void (*onremove_t)(void *context); -typedef struct _smscore_buffer -{ +struct smscore_buffer_t { /* public members, once passed to clients can be changed freely */ struct list_head entry; int size; @@ -108,10 +107,9 @@ typedef struct _smscore_buffer void *p; dma_addr_t phys; unsigned long offset_in_common; -} *psmscore_buffer_t; +}; -typedef struct _smsdevice_params -{ +struct smsdevice_params_t { struct device *device; int buffer_size; @@ -127,18 +125,17 @@ typedef struct _smsdevice_params postload_t postload_handler; void *context; - sms_device_type_st device_type; -} smsdevice_params_t; + enum sms_device_type_st device_type; +}; -typedef struct _smsclient_params -{ +struct smsclient_params_t { int initial_id; int data_type; onresponse_t onresponse_handler; onremove_t onremove_handler; void *context; -} smsclient_params_t; +}; /* GPIO definitions for antenna frequency domain control (SMS8021) */ #define SMS_ANTENNA_GPIO_0 1 @@ -216,8 +213,7 @@ typedef struct _smsclient_params #define SMS_INIT_MSG(ptr, type, len) \ SMS_INIT_MSG_EX(ptr, type, 0, HIF_TASK, len) -typedef enum -{ +enum SMS_DEVICE_MODE { DEVICE_MODE_NONE = -1, DEVICE_MODE_DVBT = 0, DEVICE_MODE_DVBH, @@ -229,33 +225,29 @@ typedef enum DEVICE_MODE_CMMB, DEVICE_MODE_RAW_TUNER, DEVICE_MODE_MAX, -} SMS_DEVICE_MODE; +}; -typedef struct SmsMsgHdr_S -{ +struct SmsMsgHdr_ST { u16 msgType; u8 msgSrcId; u8 msgDstId; u16 msgLength; /* Length of entire message, including header */ u16 msgFlags; -} SmsMsgHdr_ST; +}; -typedef struct SmsMsgData_S -{ - SmsMsgHdr_ST xMsgHeader; +struct SmsMsgData_ST { + struct SmsMsgHdr_ST xMsgHeader; u32 msgData[1]; -} SmsMsgData_ST; +}; -typedef struct SmsDataDownload_S -{ - SmsMsgHdr_ST xMsgHeader; +struct SmsDataDownload_ST { + struct SmsMsgHdr_ST xMsgHeader; u32 MemAddr; u8 Payload[SMS_MAX_PAYLOAD_SIZE]; -} SmsDataDownload_ST; +}; -typedef struct SmsVersionRes_S -{ - SmsMsgHdr_ST xMsgHeader; +struct SmsVersionRes_ST { + struct SmsMsgHdr_ST xMsgHeader; u16 ChipModel; /* e.g. 0x1102 for SMS-1102 "Nova" */ u8 Step; /* 0 - Step A */ @@ -278,18 +270,16 @@ typedef struct SmsVersionRes_S u8 RomVersionFieldPatch; u8 TextLabel[34]; -} SmsVersionRes_ST; +}; -typedef struct SmsFirmware_S -{ +struct SmsFirmware_ST { u32 CheckSum; u32 Length; u32 StartAddress; u8 Payload[1]; -} SmsFirmware_ST; +}; -typedef struct SMSHOSTLIB_STATISTICS_S -{ +struct SMSHOSTLIB_STATISTICS_ST { u32 Reserved; /* Reserved */ /* Common parameters */ @@ -354,22 +344,21 @@ typedef struct SMSHOSTLIB_STATISTICS_S u32 CellId; /* TPS Cell ID in bits 15..0, bits 31..16 zero; * if set to 0xFFFFFFFF cell_id not yet recovered */ -} SMSHOSTLIB_STATISTICS_ST; +}; -typedef struct -{ +struct SmsMsgStatisticsInfo_ST { u32 RequestResult; - SMSHOSTLIB_STATISTICS_ST Stat; + struct SMSHOSTLIB_STATISTICS_ST Stat; /* Split the calc of the SNR in DAB */ u32 Signal; /* dB */ u32 Noise; /* dB */ -} SmsMsgStatisticsInfo_ST; +}; -typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S -{ +#if 0 +struct SMSHOSTLIB_ISDBT_LAYER_STAT_ST { /* Per-layer information */ u32 CodeRate; /* Code Rate from SMSHOSTLIB_CODE_RATE_ET, * 255 means layer does not exist */ @@ -387,10 +376,9 @@ typedef struct SMSHOSTLIB_ISDBT_LAYER_STAT_S u32 NumberOfSegments; /* Number of segments in layer A, * 255 means layer does not exist */ u32 TMCCErrors; /* TMCC errors */ -} SMSHOSTLIB_ISDBT_LAYER_STAT_ST; +}; -typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S -{ +struct SMSHOSTLIB_STATISTICS_ISDBT_ST { u32 StatisticsType; /* Enumerator identifying the type of the * structure. Values are the same as * SMSHOSTLIB_DEVICE_MODES_E @@ -425,16 +413,15 @@ typedef struct SMSHOSTLIB_STATISTICS_ISDBT_S /* Per-layer information */ /* Layers A, B and C */ - SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; /* Per-layer statistics, - see SMSHOSTLIB_ISDBT_LAYER_STAT_ST */ + struct SMSHOSTLIB_ISDBT_LAYER_STAT_ST LayerInfo[3]; + /* Per-layer statistics, see SMSHOSTLIB_ISDBT_LAYER_STAT_ST */ /* Interface information */ u32 SmsToHostTxErrors; /* Total number of transmission errors. */ -} SMSHOSTLIB_STATISTICS_ISDBT_ST; +}; -typedef struct SMSHOSTLIB_STATISTICS_DVB_S -{ +struct SMSHOSTLIB_STATISTICS_DVB_ST { u32 StatisticsType; /* Enumerator identifying the type of the * structure. Values are the same as * SMSHOSTLIB_DEVICE_MODES_E @@ -508,10 +495,9 @@ typedef struct SMSHOSTLIB_STATISTICS_DVB_S /* Interface information */ u32 SmsToHostTxErrors; /* Total number of transmission errors. */ -} SMSHOSTLIB_STATISTICS_DVB_ST; +}; -typedef struct SMSHOSTLIB_GPIO_CONFIG_S -{ +struct SMSHOSTLIB_GPIO_CONFIG_ST { u8 Direction; /* GPIO direction: Input - 0, Output - 1 */ u8 PullUpDown; /* PullUp/PullDown: None - 0, * PullDown - 1, PullUp - 2, Keeper - 3 */ @@ -521,29 +507,27 @@ typedef struct SMSHOSTLIB_GPIO_CONFIG_S * Fast slew rate - 0, Slow slew rate - 1 */ u8 OutputDriving; /* Output driving capability: * 4mA - 0, 8mA - 1, 12mA - 2, 16mA - 3 */ -} SMSHOSTLIB_GPIO_CONFIG_ST; +}; -typedef struct SMSHOSTLIB_I2C_REQ_S -{ +struct SMSHOSTLIB_I2C_REQ_ST { u32 DeviceAddress; /* I2c device address */ u32 WriteCount; /* number of bytes to write */ u32 ReadCount; /* number of bytes to read */ u8 Data[1]; -} SMSHOSTLIB_I2C_REQ_ST; +}; -typedef struct SMSHOSTLIB_I2C_RES_S -{ +struct SMSHOSTLIB_I2C_RES_ST { u32 Status; /* non-zero value in case of failure */ u32 ReadCount; /* number of bytes read */ u8 Data[1]; -} SMSHOSTLIB_I2C_RES_ST; +}; +#endif -typedef struct _smsdvb_client -{ +struct smsdvb_client_t { struct list_head entry; - smscore_device_t *coredev; - smscore_client_t *smsclient; + struct smscore_device_t *coredev; + struct smscore_client_t *smsclient; struct dvb_adapter adapter; struct dvb_demux demux; @@ -558,7 +542,7 @@ typedef struct _smsdvb_client /* todo: save freq/band instead whole struct */ struct dvb_frontend_parameters fe_params; -} smsdvb_client_t; +}; extern void smscore_registry_setmode(char *devpath, int mode); extern int smscore_registry_getmode(char *devpath); @@ -566,37 +550,39 @@ extern int smscore_registry_getmode(char *devpath); extern int smscore_register_hotplug(hotplug_t hotplug); extern void smscore_unregister_hotplug(hotplug_t hotplug); -extern int smscore_register_device(smsdevice_params_t *params, - smscore_device_t **coredev); -extern void smscore_unregister_device(smscore_device_t *coredev); +extern int smscore_register_device(struct smsdevice_params_t *params, + struct smscore_device_t **coredev); +extern void smscore_unregister_device(struct smscore_device_t *coredev); -extern int smscore_start_device(smscore_device_t *coredev); -extern int smscore_load_firmware(smscore_device_t *coredev, char *filename, - loadfirmware_t loadfirmware_handler); +extern int smscore_start_device(struct smscore_device_t *coredev); +extern int smscore_load_firmware(struct smscore_device_t *coredev, + char *filename, + loadfirmware_t loadfirmware_handler); -extern int smscore_load_firmware_from_buffer(smscore_device_t *coredev, +extern int smscore_load_firmware_from_buffer(struct smscore_device_t *coredev, u8 *buffer, int size, int new_mode); -extern int smscore_set_device_mode(smscore_device_t *coredev, int mode); -extern int smscore_get_device_mode(smscore_device_t *coredev); +extern int smscore_set_device_mode(struct smscore_device_t *coredev, int mode); +extern int smscore_get_device_mode(struct smscore_device_t *coredev); -extern int smscore_register_client(smscore_device_t *coredev, - smsclient_params_t *params, - smscore_client_t **client); -extern void smscore_unregister_client(smscore_client_t *client); +extern int smscore_register_client(struct smscore_device_t *coredev, + struct smsclient_params_t *params, + struct smscore_client_t **client); +extern void smscore_unregister_client(struct smscore_client_t *client); -extern int smsclient_sendrequest(smscore_client_t *client, +extern int smsclient_sendrequest(struct smscore_client_t *client, void *buffer, size_t size); -extern void smscore_onresponse(smscore_device_t *coredev, - smscore_buffer_t *cb); +extern void smscore_onresponse(struct smscore_device_t *coredev, + struct smscore_buffer_t *cb); -extern int smscore_get_common_buffer_size(smscore_device_t *coredev); -extern int smscore_map_common_buffer(smscore_device_t *coredev, +extern int smscore_get_common_buffer_size(struct smscore_device_t *coredev); +extern int smscore_map_common_buffer(struct smscore_device_t *coredev, struct vm_area_struct *vma); -extern smscore_buffer_t *smscore_getbuffer(smscore_device_t *coredev); -extern void smscore_putbuffer(smscore_device_t *coredev, smscore_buffer_t *cb); +extern struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev); +extern void smscore_putbuffer(struct smscore_device_t *coredev, + struct smscore_buffer_t *cb); /* smsdvb.c */ int smsdvb_register(void); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index b8af76ab5..a36a6c65e 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -29,15 +29,16 @@ DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); struct list_head g_smsdvb_clients; kmutex_t g_smsdvb_clientslock; -int smsdvb_onresponse(void *context, smscore_buffer_t *cb) +int smsdvb_onresponse(void *context, struct smscore_buffer_t *cb) { - smsdvb_client_t *client = (smsdvb_client_t *) context; - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *)(((u8 *) cb->p) + cb->offset); + struct smsdvb_client_t *client = (struct smsdvb_client_t *) context; + struct SmsMsgHdr_ST *phdr = + (struct SmsMsgHdr_ST *)(((u8 *) cb->p) + cb->offset); switch (phdr->msgType) { case MSG_SMS_DVBT_BDA_DATA: dvb_dmx_swfilter(&client->demux, (u8 *)(phdr + 1), - cb->size - sizeof(SmsMsgHdr_ST)); + cb->size - sizeof(struct SmsMsgHdr_ST)); break; case MSG_SMS_RF_TUNE_RES: @@ -46,8 +47,8 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) case MSG_SMS_GET_STATISTICS_RES: { - SmsMsgStatisticsInfo_ST *p = - (SmsMsgStatisticsInfo_ST *)(phdr + 1); + struct SmsMsgStatisticsInfo_ST *p = + (struct SmsMsgStatisticsInfo_ST *)(phdr + 1); if (p->Stat.IsDemodLocked) { client->fe_status = FE_HAS_SIGNAL | @@ -82,7 +83,7 @@ int smsdvb_onresponse(void *context, smscore_buffer_t *cb) return 0; } -void smsdvb_unregister_client(smsdvb_client_t *client) +void smsdvb_unregister_client(struct smsdvb_client_t *client) { /* must be called under clientslock */ @@ -100,16 +101,16 @@ void smsdvb_onremove(void *context) { kmutex_lock(&g_smsdvb_clientslock); - smsdvb_unregister_client((smsdvb_client_t *) context); + smsdvb_unregister_client((struct smsdvb_client_t *) context); kmutex_unlock(&g_smsdvb_clientslock); } static int smsdvb_start_feed(struct dvb_demux_feed *feed) { - smsdvb_client_t *client = - container_of(feed->demux, smsdvb_client_t, demux); - SmsMsgData_ST PidMsg; + struct smsdvb_client_t *client = + container_of(feed->demux, struct smsdvb_client_t, demux); + struct SmsMsgData_ST PidMsg; printk(KERN_DEBUG "%s add pid %d(%x)\n", __func__, feed->pid, feed->pid); @@ -127,9 +128,9 @@ static int smsdvb_start_feed(struct dvb_demux_feed *feed) static int smsdvb_stop_feed(struct dvb_demux_feed *feed) { - smsdvb_client_t *client = - container_of(feed->demux, smsdvb_client_t, demux); - SmsMsgData_ST PidMsg; + struct smsdvb_client_t *client = + container_of(feed->demux, struct smsdvb_client_t, demux); + struct SmsMsgData_ST PidMsg; printk(KERN_DEBUG "%s remove pid %d(%x)\n", __func__, feed->pid, feed->pid); @@ -145,7 +146,7 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) &PidMsg, sizeof(PidMsg)); } -static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, +static int smsdvb_sendrequest_and_wait(struct smsdvb_client_t *client, void *buffer, size_t size, struct completion *completion) { @@ -158,18 +159,19 @@ static int smsdvb_sendrequest_and_wait(smsdvb_client_t *client, 0 : -ETIME; } -static int smsdvb_send_statistics_request(smsdvb_client_t *client) +static int smsdvb_send_statistics_request(struct smsdvb_client_t *client) { - SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, + struct SmsMsgHdr_ST Msg = { MSG_SMS_GET_STATISTICS_REQ, DVBT_BDA_CONTROL_MSG_ID, - HIF_TASK, sizeof(SmsMsgHdr_ST), 0 }; + HIF_TASK, sizeof(struct SmsMsgHdr_ST), 0 }; return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg), &client->stat_done); } static int smsdvb_read_status(struct dvb_frontend *fe, fe_status_t *stat) { - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + struct smsdvb_client_t *client = + container_of(fe, struct smsdvb_client_t, frontend); int rc = smsdvb_send_statistics_request(client); if (!rc) @@ -180,7 +182,8 @@ static int smsdvb_read_status(struct dvb_frontend *fe, fe_status_t *stat) static int smsdvb_read_ber(struct dvb_frontend *fe, u32 *ber) { - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + struct smsdvb_client_t *client = + container_of(fe, struct smsdvb_client_t, frontend); int rc = smsdvb_send_statistics_request(client); if (!rc) @@ -191,7 +194,8 @@ static int smsdvb_read_ber(struct dvb_frontend *fe, u32 *ber) static int smsdvb_read_signal_strength(struct dvb_frontend *fe, u16 *strength) { - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + struct smsdvb_client_t *client = + container_of(fe, struct smsdvb_client_t, frontend); int rc = smsdvb_send_statistics_request(client); if (!rc) @@ -202,7 +206,8 @@ static int smsdvb_read_signal_strength(struct dvb_frontend *fe, u16 *strength) static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) { - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + struct smsdvb_client_t *client = + container_of(fe, struct smsdvb_client_t, frontend); int rc = smsdvb_send_statistics_request(client); if (!rc) @@ -225,11 +230,11 @@ static int smsdvb_get_tune_settings(struct dvb_frontend *fe, static int smsdvb_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) { - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + struct smsdvb_client_t *client = + container_of(fe, struct smsdvb_client_t, frontend); - struct - { - SmsMsgHdr_ST Msg; + struct { + struct SmsMsgHdr_ST Msg; u32 Data[3]; } Msg; @@ -262,7 +267,8 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, static int smsdvb_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) { - smsdvb_client_t *client = container_of(fe, smsdvb_client_t, frontend); + struct smsdvb_client_t *client = + container_of(fe, struct smsdvb_client_t, frontend); printk(KERN_DEBUG "%s\n", __func__); @@ -306,11 +312,11 @@ static struct dvb_frontend_ops smsdvb_fe_ops = { .read_snr = smsdvb_read_snr, }; -int smsdvb_hotplug(smscore_device_t *coredev, +int smsdvb_hotplug(struct smscore_device_t *coredev, struct device *device, int arrival) { - smsclient_params_t params; - smsdvb_client_t *client; + struct smsclient_params_t params; + struct smsdvb_client_t *client; int rc; /* device removal handled by onremove callback */ @@ -329,7 +335,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, #endif } - client = kzalloc(sizeof(smsdvb_client_t), GFP_KERNEL); + client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) { printk(KERN_INFO "%s kmalloc() failed\n", __func__); return -ENOMEM; @@ -448,7 +454,7 @@ void smsdvb_unregister(void) while (!list_empty(&g_smsdvb_clients)) smsdvb_unregister_client( - (smsdvb_client_t *) g_smsdvb_clients.next); + (struct smsdvb_client_t *) g_smsdvb_clients.next); kmutex_unlock(&g_smsdvb_clientslock); } diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 0c4776b4d..324444015 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -40,28 +40,26 @@ #define USB_PID_NOVA_B 0x0201 #define USB_PID_VEGA 0x0300 -typedef struct _smsusb_device smsusb_device_t; +struct smsusb_device_t; -typedef struct _smsusb_urb -{ - smscore_buffer_t *cb; - smsusb_device_t *dev; +struct smsusb_urb_t { + struct smscore_buffer_t *cb; + struct smsusb_device_t *dev; - struct urb urb; -} smsusb_urb_t; + struct urb urb; +}; -typedef struct _smsusb_device -{ +struct smsusb_device_t { struct usb_device *udev; - smscore_device_t *coredev; + struct smscore_device_t *coredev; - smsusb_urb_t surbs[MAX_URBS]; + struct smsusb_urb_t surbs[MAX_URBS]; int response_alignment; int buffer_size; -} *psmsusb_device_t; +}; -int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb); +int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb); #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) void smsusb_onresponse(struct urb *urb) @@ -69,8 +67,8 @@ void smsusb_onresponse(struct urb *urb) void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) #endif { - smsusb_urb_t *surb = (smsusb_urb_t *) urb->context; - smsusb_device_t *dev = surb->dev; + struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context; + struct smsusb_device_t *dev = surb->dev; if (urb->status < 0) { printk(KERN_INFO "%s error, urb status %d, %d bytes\n", @@ -79,7 +77,7 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) } if (urb->actual_length > 0) { - SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) surb->cb->p; + struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) surb->cb->p; if (urb->actual_length >= phdr->msgLength) { surb->cb->size = phdr->msgLength; @@ -106,7 +104,7 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) /* move buffer pointer and * copy header to its new location */ memcpy((char *) phdr + surb->cb->offset, - phdr, sizeof(SmsMsgHdr_ST)); + phdr, sizeof(struct SmsMsgHdr_ST)); } else surb->cb->offset = 0; @@ -123,7 +121,7 @@ exit_and_resubmit: smsusb_submit_urb(dev, surb); } -int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb) +int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb) { if (!surb->cb) { surb->cb = smscore_getbuffer(dev->coredev); @@ -149,7 +147,7 @@ int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb) return usb_submit_urb(&surb->urb, GFP_ATOMIC); } -void smsusb_stop_streaming(smsusb_device_t *dev) +void smsusb_stop_streaming(struct smsusb_device_t *dev) { int i; @@ -163,7 +161,7 @@ void smsusb_stop_streaming(smsusb_device_t *dev) } } -int smsusb_start_streaming(smsusb_device_t *dev) +int smsusb_start_streaming(struct smsusb_device_t *dev) { int i, rc; @@ -182,7 +180,7 @@ int smsusb_start_streaming(smsusb_device_t *dev) int smsusb_sendrequest(void *context, void *buffer, size_t size) { - smsusb_device_t *dev = (smsusb_device_t *) context; + struct smsusb_device_t *dev = (struct smsusb_device_t *) context; int dummy; return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), @@ -239,7 +237,8 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) void smsusb1_detectmode(void *context, int *mode) { - char *product_string = ((smsusb_device_t *) context)->udev->product; + char *product_string = + ((struct smsusb_device_t *) context)->udev->product; *mode = DEVICE_MODE_NONE; @@ -260,8 +259,8 @@ void smsusb1_detectmode(void *context, int *mode) int smsusb1_setmode(void *context, int mode) { - SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, - sizeof(SmsMsgHdr_ST), 0 }; + struct SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, + sizeof(struct SmsMsgHdr_ST), 0 }; if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { printk(KERN_INFO "%s invalid firmware id specified %d\n", @@ -274,7 +273,8 @@ int smsusb1_setmode(void *context, int mode) void smsusb_term_device(struct usb_interface *intf) { - smsusb_device_t *dev = (smsusb_device_t *) usb_get_intfdata(intf); + struct smsusb_device_t *dev = + (struct smsusb_device_t *) usb_get_intfdata(intf); if (dev) { smsusb_stop_streaming(dev); @@ -293,15 +293,15 @@ void smsusb_term_device(struct usb_interface *intf) int smsusb_init_device(struct usb_interface *intf) { - smsdevice_params_t params; - smsusb_device_t *dev; + struct smsdevice_params_t params; + struct smsusb_device_t *dev; int i, rc; /* create device object */ - dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL); + dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL); if (!dev) { - printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", - __func__); + printk(KERN_INFO "%s kzalloc(sizeof(struct smsusb_device_t) " + "failed\n", __func__); return -ENOMEM; } @@ -338,7 +338,7 @@ int smsusb_init_device(struct usb_interface *intf) dev->buffer_size = USB2_BUFFER_SIZE; dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - - sizeof(SmsMsgHdr_ST); + sizeof(struct SmsMsgHdr_ST); params.flags |= SMS_DEVICE_FAMILY2; break; -- cgit v1.2.3 From e38ff54020fb40fd2180707356377040a79c3efc Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 15:11:37 -0400 Subject: sms1xxx: fix WARNING: unnecessary cast may hide bugs From: Michael Krufky fix the following checkpatch.pl warning: WARNING: unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html 596: FILE: linux/drivers/media/dvb/siano/smscoreapi.c:540: + msg = (struct SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 6858f7d99..8d7ede0e8 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -537,7 +537,7 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, } /* PAGE_SIZE buffer shall be enough and dma aligned */ - msg = (struct SmsMsgHdr_ST *) kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); + msg = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); if (!msg) return -ENOMEM; -- cgit v1.2.3 From dca6d129e2f6f45454f71a73fdc216c8832052d6 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 15:27:35 -0400 Subject: sms1xxx: more cleanups From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 8d7ede0e8..dda3cf853 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -784,15 +784,23 @@ int smscore_detect_mode(struct smscore_device_t *coredev) } char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { - /*Stellar NOVA A0 Nova B0 VEGA*/ - /*DVBT*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, - /*DVBH*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, - /*TDMB*/ {"none", "tdmb_nova_12mhz.inp", "none", "none"}, - /*DABIP*/ {"none", "none", "none", "none"}, - /*BDA*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, - /*ISDBT*/ {"none", "isdbt_nova_12mhz.inp", "dvb_nova_12mhz.inp", "none"}, - /*ISDBTBDA*/{"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"}, - /*CMMB*/ {"none", "none", "none", "cmmb_vega_12mhz.inp"} + /*Stellar NOVA A0 Nova B0 VEGA*/ + /*DVBT*/ + {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*DVBH*/ + {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*TDMB*/ + {"none", "tdmb_nova_12mhz.inp", "none", "none"}, + /*DABIP*/ + {"none", "none", "none", "none"}, + /*BDA*/ + {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, + /*ISDBT*/ + {"none", "isdbt_nova_12mhz.inp", "dvb_nova_12mhz.inp", "none"}, + /*ISDBTBDA*/ + {"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"}, + /*CMMB*/ + {"none", "none", "none", "cmmb_vega_12mhz.inp"} }; @@ -970,8 +978,8 @@ void smscore_onresponse(struct smscore_device_t *coredev, int rc = -EBUSY; #if 1 - static unsigned long last_sample_time = 0; - static int data_total = 0; + static unsigned long last_sample_time; /* = 0; */ + static int data_total; /* = 0; */ unsigned long time_now = jiffies_to_msecs(jiffies); if (!last_sample_time) -- cgit v1.2.3 From 56e6595b318ac3a5b15f9e9c8048a2937ad287be Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 15 Jun 2008 15:39:55 -0400 Subject: sms1xxx: remove #if LINUX_VERSION_CODE checks From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 60 +----------------------------- linux/drivers/media/dvb/siano/smscoreapi.h | 16 -------- 2 files changed, 1 insertion(+), 75 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index dda3cf853..0589a4759 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -200,55 +200,6 @@ void smscore_registry_settype(char *devpath, enum sms_device_type_st type) } -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) -void *kzalloc(size_t size, int flags) -{ - void *ret = kmalloc(size, flags); - if (ret) - memset(ret, 0, size); - return ret; -} - -static inline unsigned long kvirt_to_pa(unsigned long adr) -{ - unsigned long kva, ret; - - kva = (unsigned long) page_address(virt_to_page((void *)adr)); - kva |= adr & (PAGE_SIZE-1); /* restore the offset */ - ret = __pa(kva); - return ret; -} - -unsigned long wait_for_completion_timeout(struct completion *x, - unsigned long timeout) -{ - might_sleep(); - - spin_lock_irq(&x->wait.lock); - if (!x->done) { - DECLARE_WAITQUEUE(wait, current); - - wait.flags |= WQ_FLAG_EXCLUSIVE; - __add_wait_queue_tail(&x->wait, &wait); - do { - __set_current_state(TASK_UNINTERRUPTIBLE); - spin_unlock_irq(&x->wait.lock); - timeout = schedule_timeout(timeout); - spin_lock_irq(&x->wait.lock); - if (!timeout) { - __remove_wait_queue(&x->wait, &wait); - goto out; - } - } while (!x->done); - __remove_wait_queue(&x->wait, &wait); - } - x->done--; -out: - spin_unlock_irq(&x->wait.lock); - return timeout; -} -#endif - void list_add_locked(struct list_head *new, struct list_head *head, spinlock_t *lock) { @@ -640,8 +591,6 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, loadfirmware_t loadfirmware_handler) { int rc = -ENOENT; - -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) const struct firmware *fw; u8 *fw_buffer; @@ -677,7 +626,6 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, } release_firmware(fw); -#endif return rc; } @@ -1287,15 +1235,9 @@ int smscore_map_common_buffer(struct smscore_device_t *coredev, return -EINVAL; } -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) - if (remap_page_range(vma, start, coredev->common_buffer_phys, size, - vma->vm_page_prot)) -#else if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, - size, pgprot_noncached(vma->vm_page_prot))) -#endif - { + size, pgprot_noncached(vma->vm_page_prot))) { printk(KERN_INFO "%s remap_page_range failed\n", __func__); return -EAGAIN; } diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index deeb4c2d7..b545ee0c1 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -34,7 +34,6 @@ #include "dvb_demux.h" #include "dvb_frontend.h" -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) #include typedef struct mutex kmutex_t; @@ -44,21 +43,6 @@ typedef struct mutex kmutex_t; #define kmutex_trylock(_p_) mutex_trylock(_p_) #define kmutex_unlock(_p_) mutex_unlock(_p_) -#else -#include - -typedef struct semaphore kmutex_t; - -#define kmutex_init(_p_) init_MUTEX(_p_) -#define kmutex_lock(_p_) down(_p_) -#define kmutex_trylock(_p_) (!down_trylock(_p_)) -#define kmutex_unlock(_p_) up(_p_) - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) -void *kzalloc(size_t size, int flags); -#endif -#endif /* LINUX_VERSION */ - #ifndef min #define min(a, b) (((a) < (b)) ? (a) : (b)) #endif -- cgit v1.2.3 From a30f8527123db86de852185b6c28459066d4db46 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Mon, 16 Jun 2008 08:37:05 -0400 Subject: sms1xxx: small cleanup From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smsusb.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 324444015..7c3a43bc7 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -431,7 +431,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) } rc = smsusb_init_device(intf); - printk(KERN_INFO "%s rc %d\n", __func__, rc); + printk(KERN_INFO "%s rc %d\n", __func__, rc); return rc; } @@ -441,9 +441,13 @@ void smsusb_disconnect(struct usb_interface *intf) } static struct usb_device_id smsusb_id_table [] = { +#if 0 { USB_DEVICE(USB_VID_SIANO, 0x0010) }, +#endif { USB_DEVICE(USB_VID_SIANO, USB_PID_STELLAR) }, { USB_DEVICE(USB_VID_SIANO, USB_PID_NOVA_A) }, + { USB_DEVICE(USB_VID_SIANO, USB_PID_NOVA_B) }, + { USB_DEVICE(USB_VID_SIANO, USB_PID_VEGA) }, { } /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, smsusb_id_table); @@ -468,8 +472,8 @@ int smsusb_register(void) void smsusb_unregister(void) { + printk(KERN_DEBUG "%s\n", __func__); /* Regular USB Cleanup */ usb_deregister(&smsusb_driver); - printk(KERN_INFO "%s\n", __func__); } -- cgit v1.2.3 From 7532998b0704e8cffabc134d9a21a26a31900fc8 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Wed, 18 Jun 2008 16:25:25 -0400 Subject: sms1xxx: change default_mode to 4 From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 0589a4759..49be2b7e9 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -117,7 +117,7 @@ kmutex_t g_smscore_deviceslock; struct list_head g_smscore_registry; kmutex_t g_smscore_registrylock; -static int default_mode = 1; +static int default_mode = 4; module_param(default_mode, int, 0644); MODULE_PARM_DESC(default_mode, "default firmware id (device mode)"); -- cgit v1.2.3 From 7d5659a08c72baad36584da3d7a86b2e7bc0d155 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Wed, 18 Jun 2008 18:09:55 -0400 Subject: sms1xxx: add code to allow device-specific functionality From: Michael Krufky Set board ID in the usb_device_id table's driver_info field. Use board name when registering the dvb adapter. Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/Makefile | 2 +- linux/drivers/media/dvb/siano/sms-cards.c | 69 ++++++++++++++++++++++++++++++ linux/drivers/media/dvb/siano/sms-cards.h | 42 ++++++++++++++++++ linux/drivers/media/dvb/siano/smscoreapi.c | 12 ++++++ linux/drivers/media/dvb/siano/smscoreapi.h | 3 ++ linux/drivers/media/dvb/siano/smsdvb.c | 7 ++- linux/drivers/media/dvb/siano/smsusb.c | 47 ++++++++------------ 7 files changed, 150 insertions(+), 32 deletions(-) create mode 100644 linux/drivers/media/dvb/siano/sms-cards.c create mode 100644 linux/drivers/media/dvb/siano/sms-cards.h (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/Makefile b/linux/drivers/media/dvb/siano/Makefile index e549c4e2b..ee0737af9 100644 --- a/linux/drivers/media/dvb/siano/Makefile +++ b/linux/drivers/media/dvb/siano/Makefile @@ -1,4 +1,4 @@ -sms1xxx-objs := smscoreapi.o smsusb.o smsdvb.o +sms1xxx-objs := smscoreapi.o smsusb.o smsdvb.o sms-cards.o obj-$(CONFIG_DVB_SIANO_SMS1XXX) += sms1xxx.o diff --git a/linux/drivers/media/dvb/siano/sms-cards.c b/linux/drivers/media/dvb/siano/sms-cards.c new file mode 100644 index 000000000..88fc2a4ed --- /dev/null +++ b/linux/drivers/media/dvb/siano/sms-cards.c @@ -0,0 +1,69 @@ +/* + * Card-specific functions for the Siano SMS1xxx USB dongle + * + * Copyright (c) 2008 Michael Krufky + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation; + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "sms-cards.h" + +struct usb_device_id smsusb_id_table[] = { + { USB_DEVICE(0x187f, 0x0010), + .driver_info = SMS1XXX_BOARD_SIANO_STELLAR }, + { USB_DEVICE(0x187f, 0x0100), + .driver_info = SMS1XXX_BOARD_SIANO_STELLAR }, + { USB_DEVICE(0x187f, 0x0200), + .driver_info = SMS1XXX_BOARD_SIANO_NOVA_A }, + { USB_DEVICE(0x187f, 0x0201), + .driver_info = SMS1XXX_BOARD_SIANO_NOVA_B }, + { USB_DEVICE(0x187f, 0x0300), + .driver_info = SMS1XXX_BOARD_SIANO_VEGA }, + { } /* Terminating entry */ +}; +MODULE_DEVICE_TABLE(usb, smsusb_id_table); + +static struct sms_board sms_boards[] = { + [SMS_BOARD_UNKNOWN] = { + .name = "Unknown board", + }, + [SMS1XXX_BOARD_SIANO_SMS1000] = { + .name = "Siano Digital Receiver", + .type = SMS_STELLAR, + }, + [SMS1XXX_BOARD_SIANO_STELLAR] = { + .name = "Siano Stellar reference board", + .type = SMS_STELLAR, + }, + [SMS1XXX_BOARD_SIANO_NOVA_A] = { + .name = "Siano Nova A reference board", + .type = SMS_NOVA_A0, + }, + [SMS1XXX_BOARD_SIANO_NOVA_B] = { + .name = "Siano Nova B reference board", + .type = SMS_NOVA_B0, + }, + [SMS1XXX_BOARD_SIANO_VEGA] = { + .name = "Siano Vega reference board", + .type = SMS_VEGA, + }, +}; + +struct sms_board *sms_get_board(int id) +{ + BUG_ON(id >= ARRAY_SIZE(sms_boards)); + + return &sms_boards[id]; +} + diff --git a/linux/drivers/media/dvb/siano/sms-cards.h b/linux/drivers/media/dvb/siano/sms-cards.h new file mode 100644 index 000000000..7ba3df63d --- /dev/null +++ b/linux/drivers/media/dvb/siano/sms-cards.h @@ -0,0 +1,42 @@ +/* + * Card-specific functions for the Siano SMS1xxx USB dongle + * + * Copyright (c) 2008 Michael Krufky + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation; + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. + * + * 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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef __SMS_CARDS_H__ +#define __SMS_CARDS_H__ + +#include +#include "smscoreapi.h" + +#define SMS_BOARD_UNKNOWN 0 +#define SMS1XXX_BOARD_SIANO_SMS1000 1 +#define SMS1XXX_BOARD_SIANO_STELLAR 2 +#define SMS1XXX_BOARD_SIANO_NOVA_A 3 +#define SMS1XXX_BOARD_SIANO_NOVA_B 4 +#define SMS1XXX_BOARD_SIANO_VEGA 5 + +struct sms_board { + char *name; + enum sms_device_type_st type; +}; + +struct sms_board *sms_get_board(int id); + +extern struct usb_device_id smsusb_id_table[]; + +#endif /* __SMS_CARDS_H__ */ diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 49be2b7e9..e918c02ba 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -101,8 +101,20 @@ struct smscore_device_t { struct completion version_ex_done, data_download_done, trigger_done; struct completion init_device_done, reload_start_done, resume_done; + + int board_id; }; +void smscore_set_board_id(struct smscore_device_t *core, int id) +{ + core->board_id = id; +} + +int smscore_get_board_id(struct smscore_device_t *core) +{ + return core->board_id; +} + struct smscore_registry_entry_t { struct list_head entry; char devpath[32]; diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index b545ee0c1..6f6db5f51 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -568,6 +568,9 @@ extern struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *cored extern void smscore_putbuffer(struct smscore_device_t *coredev, struct smscore_buffer_t *cb); +void smscore_set_board_id(struct smscore_device_t *core, int id); +int smscore_get_board_id(struct smscore_device_t *core); + /* smsdvb.c */ int smsdvb_register(void); void smsdvb_unregister(void); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index a36a6c65e..2de57ecad 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -23,6 +23,7 @@ #include #include "smscoreapi.h" +#include "sms-cards.h" DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); @@ -285,7 +286,7 @@ static void smsdvb_release(struct dvb_frontend *fe) static struct dvb_frontend_ops smsdvb_fe_ops = { .info = { - .name = "Siano Mobile Digital SMS10xx", + .name = "Siano Mobile Digital SMS1xxx", .type = FE_OFDM, .frequency_min = 44250000, .frequency_max = 867250000, @@ -342,7 +343,9 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, } /* register dvb adapter */ - rc = dvb_register_adapter(&client->adapter, "Siano Digital Receiver", + rc = dvb_register_adapter(&client->adapter, + sms_get_board( + smscore_get_board_id(coredev))->name, THIS_MODULE, device, adapter_nr); if (rc < 0) { printk(KERN_ERR "%s dvb_register_adapter() failed %d\n", diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 7c3a43bc7..54af3e5b5 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -25,6 +25,7 @@ #include #include "smscoreapi.h" +#include "sms-cards.h" #define USB1_BUFFER_SIZE 0x1000 #define USB2_BUFFER_SIZE 0x4000 @@ -32,14 +33,6 @@ #define MAX_BUFFERS 50 #define MAX_URBS 10 -/* TO DO: move these to a header file */ -#define USB_VID_SIANO 0x187f - -#define USB_PID_STELLAR 0x0100 -#define USB_PID_NOVA_A 0x0200 -#define USB_PID_NOVA_B 0x0201 -#define USB_PID_VEGA 0x0300 - struct smsusb_device_t; struct smsusb_urb_t { @@ -291,10 +284,11 @@ void smsusb_term_device(struct usb_interface *intf) usb_set_intfdata(intf, NULL); } -int smsusb_init_device(struct usb_interface *intf) +int smsusb_init_device(struct usb_interface *intf, int board_id) { struct smsdevice_params_t params; struct smsusb_device_t *dev; + struct sms_board *board; int i, rc; /* create device object */ @@ -309,9 +303,11 @@ int smsusb_init_device(struct usb_interface *intf) usb_set_intfdata(intf, dev); dev->udev = interface_to_usbdev(intf); - switch (dev->udev->descriptor.idProduct) { + board = sms_get_board(board_id); + + switch (board->type) { - case USB_PID_STELLAR: + case SMS_STELLAR: dev->buffer_size = USB1_BUFFER_SIZE; params.setmode_handler = smsusb1_setmode; @@ -320,19 +316,22 @@ int smsusb_init_device(struct usb_interface *intf) printk(KERN_INFO "%s stellar device found\n", __func__); break; default: - switch (dev->udev->descriptor.idProduct) { - case USB_PID_NOVA_A: + switch (board->type) { + case SMS_NOVA_A0: params.device_type = SMS_NOVA_A0; printk(KERN_INFO "%s nova A0 found\n", __func__); break; - default: - case USB_PID_NOVA_B: + case SMS_NOVA_B0: params.device_type = SMS_NOVA_B0; printk(KERN_INFO "%s nova B0 found\n", __func__); break; - case USB_PID_VEGA: + case SMS_VEGA: params.device_type = SMS_VEGA; printk(KERN_INFO "%s Vega found\n", __func__); + break; + default: + printk(KERN_ERR "%s Unspecified sms device type!\n", + __func__); } dev->buffer_size = USB2_BUFFER_SIZE; @@ -361,6 +360,8 @@ int smsusb_init_device(struct usb_interface *intf) return rc; } + smscore_set_board_id(dev->coredev, board_id); + /* initialize urbs */ for (i = 0; i < MAX_URBS; i++) { dev->surbs[i].dev = dev; @@ -430,7 +431,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) udev, smscore_registry_getmode(devpath)); } - rc = smsusb_init_device(intf); + rc = smsusb_init_device(intf, id->driver_info); printk(KERN_INFO "%s rc %d\n", __func__, rc); return rc; } @@ -440,18 +441,6 @@ void smsusb_disconnect(struct usb_interface *intf) smsusb_term_device(intf); } -static struct usb_device_id smsusb_id_table [] = { -#if 0 - { USB_DEVICE(USB_VID_SIANO, 0x0010) }, -#endif - { USB_DEVICE(USB_VID_SIANO, USB_PID_STELLAR) }, - { USB_DEVICE(USB_VID_SIANO, USB_PID_NOVA_A) }, - { USB_DEVICE(USB_VID_SIANO, USB_PID_NOVA_B) }, - { USB_DEVICE(USB_VID_SIANO, USB_PID_VEGA) }, - { } /* Terminating entry */ -}; -MODULE_DEVICE_TABLE(usb, smsusb_id_table); - static struct usb_driver smsusb_driver = { .name = "smsusb", .probe = smsusb_probe, -- cgit v1.2.3 From ee252d56b4825939020961a58b4a2a52e6222608 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Wed, 18 Jun 2008 21:15:46 -0400 Subject: sms1xxx: create printk macros From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 167 ++++++++++++++--------------- linux/drivers/media/dvb/siano/smscoreapi.h | 5 + linux/drivers/media/dvb/siano/smsdvb.c | 46 ++++---- linux/drivers/media/dvb/siano/smsusb.c | 106 +++++++++--------- 4 files changed, 164 insertions(+), 160 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index e918c02ba..db79b3f32 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -34,16 +34,16 @@ #include "smscoreapi.h" #define PERROR(fmt, args...)\ - printk(KERN_ERR "smscore error: line %d- %s(): " fmt, \ + sms_err("smscore error: line %d- %s(): " fmt, \ __LINE__, __func__, ## args) #ifdef SMSCORE_DEBUG #undef PWARNING -# define PWARNING(fmt, args...) printk(KERN_INFO "smscore warning: " \ +# define PWARNING(fmt, args...) sms_info("smscore warning: " \ "line %d- %s(): " fmt, \ __LINE__, __func__, ## args) #undef PDEBUG /* undef it, just in case */ -# define PDEBUG(fmt, args...) printk(KERN_INFO "smscore - %s(): " fmt, \ +# define PDEBUG(fmt, args...) sms_info("smscore - %s(): " fmt, \ __func__, ## args) #else /*SMSCORE_DEBUG*/ #define PDEBUG(fmt, args...) @@ -157,8 +157,8 @@ static struct smscore_registry_entry_t *smscore_find_registry(char *devpath) strcpy(entry->devpath, devpath); list_add(&entry->entry, &g_smscore_registry); } else - printk(KERN_ERR "%s failed to create smscore_registry.\n", - __func__); + sms_err("%s failed to create smscore_registry.\n", + __func__); kmutex_unlock(&g_smscore_registrylock); return entry; } @@ -171,7 +171,7 @@ int smscore_registry_getmode(char *devpath) if (entry) return entry->mode; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("%s No registry found.\n", __func__); return default_mode; } @@ -184,7 +184,7 @@ enum sms_device_type_st smscore_registry_gettype(char *devpath) if (entry) return entry->type; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("%s No registry found.\n", __func__); return -1; } @@ -197,7 +197,7 @@ void smscore_registry_setmode(char *devpath, int mode) if (entry) entry->mode = mode; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("%s No registry found.\n", __func__); } void smscore_registry_settype(char *devpath, enum sms_device_type_st type) @@ -208,7 +208,7 @@ void smscore_registry_settype(char *devpath, enum sms_device_type_st type) if (entry) entry->type = type; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("%s No registry found.\n", __func__); } @@ -331,7 +331,7 @@ struct smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, struct smscore_buffer_t *cb = kmalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL); if (!cb) { - printk(KERN_INFO "%s kmalloc(...) failed\n", __func__); + sms_info("%s kmalloc(...) failed\n", __func__); return NULL; } @@ -360,7 +360,7 @@ int smscore_register_device(struct smsdevice_params_t *params, dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL); if (!dev) { - printk(KERN_INFO "%s kzalloc(...) failed\n", __func__); + sms_info("%s kzalloc(...) failed\n", __func__); return -ENOMEM; } @@ -408,8 +408,8 @@ int smscore_register_device(struct smsdevice_params_t *params, smscore_putbuffer(dev, cb); } - printk(KERN_INFO "%s allocated %d buffers\n", - __func__, dev->num_buffers); + sms_info("%s allocated %d buffers\n", + __func__, dev->num_buffers); dev->mode = DEVICE_MODE_NONE; dev->context = params->context; @@ -432,7 +432,7 @@ int smscore_register_device(struct smsdevice_params_t *params, *coredev = dev; - printk(KERN_INFO "%s device %p created\n", __func__, dev); + sms_info("%s device %p created\n", __func__, dev); return 0; } @@ -450,8 +450,8 @@ int smscore_start_device(struct smscore_device_t *coredev) int rc = smscore_set_device_mode( coredev, smscore_registry_getmode(coredev->devpath)); if (rc < 0) { - printk(KERN_INFO "%s set device mode faile , rc %d\n", - __func__, rc); + sms_info("%s set device mode faile , rc %d\n", + __func__, rc); return rc; } @@ -459,8 +459,8 @@ int smscore_start_device(struct smscore_device_t *coredev) rc = smscore_notify_callbacks(coredev, coredev->device, 1); - printk(KERN_INFO "%s device %p started, rc %d\n", - __func__, coredev, rc); + sms_info("%s device %p started, rc %d\n", + __func__, coredev, rc); kmutex_unlock(&g_smscore_deviceslock); @@ -472,8 +472,8 @@ int smscore_sendrequest_and_wait(struct smscore_device_t *coredev, void *buffer, { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); if (rc < 0) { - printk(KERN_INFO "%s sendrequest returned error %d\n", - __func__, rc); + sms_info("%s sendrequest returned error %d\n", + __func__, rc); return rc; } @@ -491,8 +491,8 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, u8 *payload = firmware->Payload; int rc = 0; - printk(KERN_INFO "%s loading FW to addr 0x%x size %d\n", - __func__, mem_address, firmware->Length); + sms_info("%s loading FW to addr 0x%x size %d\n", + __func__, mem_address, firmware->Length); if (coredev->preload_handler) { rc = coredev->preload_handler(coredev->context); if (rc < 0) @@ -578,8 +578,8 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, msleep(500); } - printk(KERN_DEBUG "%s rc=%d, postload=%p \n", __func__, rc, - coredev->postload_handler); + sms_debug("%s rc=%d, postload=%p \n", __func__, rc, + coredev->postload_handler); kfree(msg); @@ -612,12 +612,12 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, rc = request_firmware(&fw, filename, coredev->device); if (rc < 0) { - printk(KERN_INFO "%s failed to open \"%s\"\n", - __func__, filename); + sms_info("%s failed to open \"%s\"\n", + __func__, filename); return rc; } - printk(KERN_INFO "%s read FW %s, size=%d\"\n", __func__, - filename, fw->size); + sms_info("%s read FW %s, size=%d\"\n", __func__, + filename, fw->size); fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); if (fw_buffer) { @@ -632,8 +632,8 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, kfree(fw_buffer); } else { - printk(KERN_INFO "%s failed to allocate firmware buffer\n", - __func__); + sms_info("%s failed to allocate firmware buffer\n", + __func__); rc = -ENOMEM; } @@ -680,17 +680,17 @@ void smscore_unregister_device(struct smscore_device_t *coredev) if (num_buffers == coredev->num_buffers) break; if (++retry > 10) { - printk(KERN_INFO "%s exiting although " - "not all buffers released.\n", __func__); + sms_info("%s exiting although " + "not all buffers released.\n", __func__); break; } - printk(KERN_INFO "%s waiting for %d buffer(s)\n", __func__, - coredev->num_buffers - num_buffers); + sms_info("%s waiting for %d buffer(s)\n", __func__, + coredev->num_buffers - num_buffers); msleep(100); } - printk(KERN_INFO "%s freed %d buffers\n", __func__, num_buffers); + sms_info("%s freed %d buffers\n", __func__, num_buffers); if (coredev->common_buffer) dma_free_coherent(NULL, coredev->common_buffer_size, @@ -702,7 +702,7 @@ void smscore_unregister_device(struct smscore_device_t *coredev) kmutex_unlock(&g_smscore_deviceslock); - printk(KERN_INFO "%s device %p destroyed\n", __func__, coredev); + sms_info("%s device %p destroyed\n", __func__, coredev); } int smscore_detect_mode(struct smscore_device_t *coredev) @@ -722,8 +722,8 @@ int smscore_detect_mode(struct smscore_device_t *coredev) rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc == -ETIME) { - printk(KERN_ERR "%s: MSG_SMS_GET_VERSION_EX_REQ " - "failed first try\n", __func__); + sms_err("%s: MSG_SMS_GET_VERSION_EX_REQ " + "failed first try\n", __func__); if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) { @@ -731,9 +731,9 @@ int smscore_detect_mode(struct smscore_device_t *coredev) coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc < 0) - printk(KERN_ERR "%s: " - "MSG_SMS_GET_VERSION_EX_REQ failed " - "second try, rc %d\n", __func__, rc); + sms_err("%s: " + "MSG_SMS_GET_VERSION_EX_REQ failed " + "second try, rc %d\n", __func__, rc); } else rc = -ETIME; } @@ -783,8 +783,8 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) PDEBUG("set device mode to %d\n", mode); if (coredev->device_flags & SMS_DEVICE_FAMILY2) { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) { - printk(KERN_INFO "%s invalid mode specified %d\n", - __func__, mode); + sms_info("%s invalid mode specified %d\n", + __func__, mode); return -EINVAL; } @@ -793,15 +793,15 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) { rc = smscore_detect_mode(coredev); if (rc < 0) { - printk(KERN_INFO "%s mode detect failed %d\n", - __func__, rc); + sms_info("%s mode detect failed %d\n", + __func__, rc); return rc; } } if (coredev->mode == mode) { - printk(KERN_INFO "%s device mode %d already set\n", - __func__, mode); + sms_info("%s device mode %d already set\n", + __func__, mode); return 0; } @@ -810,13 +810,13 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) rc = smscore_load_firmware_from_file( coredev, smscore_fw_lkup[mode][type], NULL); if (rc < 0) { - printk(KERN_INFO "%s load firmware " - "failed %d\n", __func__, rc); + sms_info("%s load firmware " + "failed %d\n", __func__, rc); return rc; } } else - printk(KERN_INFO "%s mode %d supported by running " - "firmware\n", __func__, mode); + sms_info("%s mode %d supported by running " + "firmware\n", __func__, mode); buffer = kmalloc(sizeof(struct SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); @@ -835,14 +835,14 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) kfree(buffer); } else { - printk(KERN_INFO "%s Could not allocate buffer for " - "init device message.\n", __func__); + sms_info("%s Could not allocate buffer for " + "init device message.\n", __func__); rc = -ENOMEM; } } else { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - printk(KERN_INFO "%s invalid mode specified %d\n", - __func__, mode); + sms_info("%s invalid mode specified %d\n", + __func__, mode); return -EINVAL; } @@ -862,7 +862,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) } if (rc != 0) - printk(KERN_INFO "%s return error code %d.\n", __func__, rc); + sms_info("%s return error code %d.\n", __func__, rc); return rc; } @@ -946,9 +946,9 @@ void smscore_onresponse(struct smscore_device_t *coredev, last_sample_time = time_now; if (time_now - last_sample_time > 10000) { - printk(KERN_DEBUG "\n%s data rate %d bytes/secs\n", __func__, - (int)((data_total * 1000) / - (time_now - last_sample_time))); + sms_debug("\n%s data rate %d bytes/secs\n", __func__, + (int)((data_total * 1000) / + (time_now - last_sample_time))); last_sample_time = time_now; data_total = 0; @@ -971,10 +971,10 @@ void smscore_onresponse(struct smscore_device_t *coredev, { struct SmsVersionRes_ST *ver = (struct SmsVersionRes_ST *) phdr; - printk(KERN_DEBUG "%s: MSG_SMS_GET_VERSION_EX_RES " - "id %d prots 0x%x ver %d.%d\n", __func__, - ver->FirmwareId, ver->SupportedProtocols, - ver->RomVersionMajor, ver->RomVersionMinor); + sms_debug("%s: MSG_SMS_GET_VERSION_EX_RES " + "id %d prots 0x%x ver %d.%d\n", __func__, + ver->FirmwareId, ver->SupportedProtocols, + ver->RomVersionMajor, ver->RomVersionMinor); coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; @@ -984,26 +984,25 @@ void smscore_onresponse(struct smscore_device_t *coredev, break; } case MSG_SMS_INIT_DEVICE_RES: - printk(KERN_DEBUG "%s: MSG_SMS_INIT_DEVICE_RES\n", - __func__); + sms_debug("%s: MSG_SMS_INIT_DEVICE_RES\n", + __func__); complete(&coredev->init_device_done); break; case MSG_SW_RELOAD_START_RES: - printk(KERN_DEBUG "%s: MSG_SW_RELOAD_START_RES\n", - __func__); + sms_debug("%s: MSG_SW_RELOAD_START_RES\n", + __func__); complete(&coredev->reload_start_done); break; case MSG_SMS_DATA_DOWNLOAD_RES: complete(&coredev->data_download_done); break; case MSG_SW_RELOAD_EXEC_RES: - printk(KERN_DEBUG "%s: MSG_SW_RELOAD_EXEC_RES\n", - __func__); + sms_debug("%s: MSG_SW_RELOAD_EXEC_RES\n", + __func__); break; case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk(KERN_DEBUG - "%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", - __func__); + sms_debug("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", + __func__); complete(&coredev->trigger_done); break; case MSG_SMS_SLEEP_RESUME_COMP_IND: @@ -1011,9 +1010,9 @@ void smscore_onresponse(struct smscore_device_t *coredev, break; default: #if 0 - printk(KERN_INFO "%s no client (%p) or error (%d), " - "type:%d dstid:%d\n", __func__, client, rc, - phdr->msgType, phdr->msgDstId); + sms_info("%s no client (%p) or error (%d), " + "type:%d dstid:%d\n", __func__, client, rc, + phdr->msgType, phdr->msgDstId); #endif break; } @@ -1161,7 +1160,7 @@ void smscore_unregister_client(struct smscore_client_t *client) kfree(identry); } - printk(KERN_INFO "%s %p\n", __func__, client->context); + sms_info("%s %p\n", __func__, client->context); list_del(&client->entry); kfree(client); @@ -1188,7 +1187,7 @@ int smsclient_sendrequest(struct smscore_client_t *client, int rc; if (client == NULL) { - printk(KERN_ERR "%s Got NULL client\n", __func__); + sms_err("%s Got NULL client\n", __func__); return -EINVAL; } @@ -1196,7 +1195,7 @@ int smsclient_sendrequest(struct smscore_client_t *client, /* check that no other channel with same id exists */ if (coredev == NULL) { - printk(KERN_ERR "%s Got NULL coredev\n", __func__); + sms_err("%s Got NULL coredev\n", __func__); return -EINVAL; } @@ -1237,20 +1236,20 @@ int smscore_map_common_buffer(struct smscore_device_t *coredev, if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) { - printk(KERN_INFO "%s invalid vm flags\n", __func__); + sms_info("%s invalid vm flags\n", __func__); return -EINVAL; } if ((end - start) != size) { - printk(KERN_INFO "%s invalid size %d expected %d\n", - __func__, (int)(end - start), (int) size); + sms_info("%s invalid size %d expected %d\n", + __func__, (int)(end - start), (int) size); return -EINVAL; } if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) { - printk(KERN_INFO "%s remap_page_range failed\n", __func__); + sms_info("%s remap_page_range failed\n", __func__); return -EAGAIN; } @@ -1274,7 +1273,7 @@ int smscore_module_init(void) /* DVB Register */ rc = smsdvb_register(); - printk(KERN_INFO "%s, rc %d\n", __func__, rc); + sms_info("%s, rc %d\n", __func__, rc); return rc; } @@ -1310,7 +1309,7 @@ void smscore_module_exit(void) /* Unregister USB */ smsusb_unregister(); - printk(KERN_INFO "%s\n", __func__); + sms_info("%s\n", __func__); } module_init(smscore_module_init); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 6f6db5f51..d49ea224e 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -579,4 +579,9 @@ void smsdvb_unregister(void); int smsusb_register(void); void smsusb_unregister(void); +#define sms_err(fmt, arg...) printk(KERN_ERR fmt, ##arg) +#define sms_info(fmt, arg...) printk(KERN_INFO fmt, ##arg) +#define sms_debug(fmt, arg...) printk(KERN_DEBUG fmt, ##arg) + + #endif /* __smscoreapi_h__ */ diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 2de57ecad..c66492b4c 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -113,8 +113,8 @@ static int smsdvb_start_feed(struct dvb_demux_feed *feed) container_of(feed->demux, struct smsdvb_client_t, demux); struct SmsMsgData_ST PidMsg; - printk(KERN_DEBUG "%s add pid %d(%x)\n", __func__, - feed->pid, feed->pid); + sms_debug("%s add pid %d(%x)\n", __func__, + feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; PidMsg.xMsgHeader.msgDstId = HIF_TASK; @@ -133,8 +133,8 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) container_of(feed->demux, struct smsdvb_client_t, demux); struct SmsMsgData_ST PidMsg; - printk(KERN_DEBUG "%s remove pid %d(%x)\n", __func__, - feed->pid, feed->pid); + sms_debug("%s remove pid %d(%x)\n", __func__, + feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; PidMsg.xMsgHeader.msgDstId = HIF_TASK; @@ -220,7 +220,7 @@ static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) { - printk(KERN_DEBUG "%s\n", __func__); + sms_debug("%s\n", __func__); tune->min_delay_ms = 400; tune->step_size = 250000; @@ -247,8 +247,8 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, Msg.Data[0] = fep->frequency; Msg.Data[2] = 12000000; - printk(KERN_DEBUG "%s freq %d band %d\n", __func__, - fep->frequency, fep->u.ofdm.bandwidth); + sms_debug("%s freq %d band %d\n", __func__, + fep->frequency, fep->u.ofdm.bandwidth); switch (fep->u.ofdm.bandwidth) { case BANDWIDTH_8_MHZ: Msg.Data[1] = BW_8_MHZ; break; @@ -271,7 +271,7 @@ static int smsdvb_get_frontend(struct dvb_frontend *fe, struct smsdvb_client_t *client = container_of(fe, struct smsdvb_client_t, frontend); - printk(KERN_DEBUG "%s\n", __func__); + sms_debug("%s\n", __func__); /* todo: */ memcpy(fep, &client->fe_params, @@ -326,8 +326,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, if (smscore_get_device_mode(coredev) != 4) { #if 1 /* new siano drop (1.2.17) does this -- yuck */ - printk(KERN_ERR "%sSMS Device mode is not set for " - "DVB operation.\n", __func__); + sms_err("%sSMS Device mode is not set for " + "DVB operation.\n", __func__); return 0; #else rc = smscore_set_device_mode(coredev, 4); @@ -338,7 +338,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) { - printk(KERN_INFO "%s kmalloc() failed\n", __func__); + sms_info("%s kmalloc() failed\n", __func__); return -ENOMEM; } @@ -348,8 +348,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, smscore_get_board_id(coredev))->name, THIS_MODULE, device, adapter_nr); if (rc < 0) { - printk(KERN_ERR "%s dvb_register_adapter() failed %d\n", - __func__, rc); + sms_err("%s dvb_register_adapter() failed %d\n", + __func__, rc); goto adapter_error; } @@ -362,8 +362,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = dvb_dmx_init(&client->demux); if (rc < 0) { - printk(KERN_ERR "%s dvb_dmx_init failed %d\n\n", - __func__, rc); + sms_err("%s dvb_dmx_init failed %d\n\n", + __func__, rc); goto dvbdmx_error; } @@ -374,8 +374,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { - printk(KERN_ERR "%s dvb_dmxdev_init failed %d\n", - __func__, rc); + sms_err("%s dvb_dmxdev_init failed %d\n", + __func__, rc); goto dmxdev_error; } @@ -385,8 +385,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { - printk(KERN_ERR "%s frontend registration failed %d\n", - __func__, rc); + sms_err("%s frontend registration failed %d\n", + __func__, rc); goto frontend_error; } @@ -398,8 +398,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { - printk(KERN_INFO "%s smscore_register_client() failed %d\n", - __func__, rc); + sms_info("%s smscore_register_client() failed %d\n", + __func__, rc); goto client_error; } @@ -414,7 +414,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, kmutex_unlock(&g_smsdvb_clientslock); - printk(KERN_INFO "%s success\n", __func__); + sms_info("%s success\n", __func__); return 0; @@ -444,7 +444,7 @@ int smsdvb_register(void) rc = smscore_register_hotplug(smsdvb_hotplug); - printk(KERN_INFO "%s\n", __func__); + sms_info("%s\n", __func__); return rc; } diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 54af3e5b5..de3629cb3 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -64,8 +64,8 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) struct smsusb_device_t *dev = surb->dev; if (urb->status < 0) { - printk(KERN_INFO "%s error, urb status %d, %d bytes\n", - __func__, urb->status, urb->actual_length); + sms_info("%s error, urb status %d, %d bytes\n", + __func__, urb->status, urb->actual_length); return; } @@ -85,12 +85,12 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) /* sanity check */ if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) { - printk(KERN_INFO "%s: invalid " - "response msglen %d offset %d " - "size %d\n", __func__, - phdr->msgLength, - surb->cb->offset, - urb->actual_length); + sms_info("%s: invalid response " + "msglen %d offset %d " + "size %d\n", __func__, + phdr->msgLength, + surb->cb->offset, + urb->actual_length); goto exit_and_resubmit; } @@ -104,9 +104,9 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) smscore_onresponse(dev->coredev, surb->cb); surb->cb = NULL; } else { - printk(KERN_INFO "%s invalid response " - "msglen %d actual %d\n", __func__, - phdr->msgLength, urb->actual_length); + sms_info("%s invalid response " + "msglen %d actual %d\n", __func__, + phdr->msgLength, urb->actual_length); } } @@ -119,8 +119,8 @@ int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb) if (!surb->cb) { surb->cb = smscore_getbuffer(dev->coredev); if (!surb->cb) { - printk(KERN_INFO "%s smscore_getbuffer(...) " - "returned NULL\n", __func__); + sms_info("%s smscore_getbuffer(...) " + "returned NULL\n", __func__); return -ENOMEM; } } @@ -161,8 +161,8 @@ int smsusb_start_streaming(struct smsusb_device_t *dev) for (i = 0; i < MAX_URBS; i++) { rc = smsusb_submit_urb(dev, &dev->surbs[i]); if (rc < 0) { - printk(KERN_INFO "%s smsusb_submit_urb(...) " - "failed\n", __func__); + sms_info("%s smsusb_submit_urb(...) " + "failed\n", __func__); smsusb_stop_streaming(dev); break; } @@ -195,15 +195,15 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) int rc, dummy; if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) { - printk(KERN_INFO "%s invalid firmware id specified %d\n", - __func__, id); + sms_info("%s invalid firmware id specified %d\n", + __func__, id); return -EINVAL; } rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); if (rc < 0) { - printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", - __func__, smsusb1_fw_lkup[id], id); + sms_info("%s failed to open \"%s\" mode %d\n", + __func__, smsusb1_fw_lkup[id], id); return rc; } @@ -214,12 +214,12 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); - printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", - __func__, fw->size, dummy, rc); + sms_info("%s: sent %d(%d) bytes, rc %d\n", + __func__, fw->size, dummy, rc); kfree(fw_buffer); } else { - printk(KERN_INFO "failed to allocate firmware buffer\n"); + sms_info("failed to allocate firmware buffer\n"); rc = -ENOMEM; } @@ -237,7 +237,7 @@ void smsusb1_detectmode(void *context, int *mode) if (!product_string) { product_string = "none"; - printk(KERN_ERR "%s product string not found\n", __func__); + sms_err("%s product string not found\n", __func__); } else if (strstr(product_string, "DVBH")) *mode = 1; else if (strstr(product_string, "BDA")) @@ -247,7 +247,7 @@ void smsusb1_detectmode(void *context, int *mode) else if (strstr(product_string, "TDMB")) *mode = 2; - printk(KERN_INFO "%s: %d \"%s\"\n", __func__, *mode, product_string); + sms_info("%s: %d \"%s\"\n", __func__, *mode, product_string); } int smsusb1_setmode(void *context, int mode) @@ -256,8 +256,8 @@ int smsusb1_setmode(void *context, int mode) sizeof(struct SmsMsgHdr_ST), 0 }; if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - printk(KERN_INFO "%s invalid firmware id specified %d\n", - __func__, mode); + sms_info("%s invalid firmware id specified %d\n", + __func__, mode); return -EINVAL; } @@ -278,7 +278,7 @@ void smsusb_term_device(struct usb_interface *intf) kfree(dev); - printk(KERN_INFO "%s device %p destroyed\n", __func__, dev); + sms_info("%s device %p destroyed\n", __func__, dev); } usb_set_intfdata(intf, NULL); @@ -294,8 +294,8 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) /* create device object */ dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL); if (!dev) { - printk(KERN_INFO "%s kzalloc(sizeof(struct smsusb_device_t) " - "failed\n", __func__); + sms_info("%s kzalloc(sizeof(struct smsusb_device_t) " + "failed\n", __func__); return -ENOMEM; } @@ -313,25 +313,25 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) params.setmode_handler = smsusb1_setmode; params.detectmode_handler = smsusb1_detectmode; params.device_type = SMS_STELLAR; - printk(KERN_INFO "%s stellar device found\n", __func__); + sms_info("%s stellar device found\n", __func__); break; default: switch (board->type) { case SMS_NOVA_A0: params.device_type = SMS_NOVA_A0; - printk(KERN_INFO "%s nova A0 found\n", __func__); + sms_info("%s nova A0 found\n", __func__); break; case SMS_NOVA_B0: params.device_type = SMS_NOVA_B0; - printk(KERN_INFO "%s nova B0 found\n", __func__); + sms_info("%s nova B0 found\n", __func__); break; case SMS_VEGA: params.device_type = SMS_VEGA; - printk(KERN_INFO "%s Vega found\n", __func__); + sms_info("%s Vega found\n", __func__); break; default: - printk(KERN_ERR "%s Unspecified sms device type!\n", - __func__); + sms_err("%s Unspecified sms device type!\n", + __func__); } dev->buffer_size = USB2_BUFFER_SIZE; @@ -354,8 +354,8 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) /* register in smscore */ rc = smscore_register_device(¶ms, &dev->coredev); if (rc < 0) { - printk(KERN_INFO "%s smscore_register_device(...) failed, " - "rc %d\n", __func__, rc); + sms_info("%s smscore_register_device(...) failed, " + "rc %d\n", __func__, rc); smsusb_term_device(intf); return rc; } @@ -368,24 +368,24 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) usb_init_urb(&dev->surbs[i].urb); } - printk(KERN_INFO "%s smsusb_start_streaming(...).\n", __func__); + sms_info("%s smsusb_start_streaming(...).\n", __func__); rc = smsusb_start_streaming(dev); if (rc < 0) { - printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", - __func__); + sms_info("%s smsusb_start_streaming(...) failed\n", + __func__); smsusb_term_device(intf); return rc; } rc = smscore_start_device(dev->coredev); if (rc < 0) { - printk(KERN_INFO "%s smscore_start_device(...) failed\n", - __func__); + sms_info("%s smscore_start_device(...) failed\n", + __func__); smsusb_term_device(intf); return rc; } - printk(KERN_INFO "%s device %p created\n", __func__, dev); + sms_info("%s device %p created\n", __func__, dev); return rc; } @@ -403,36 +403,36 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) rc = usb_set_interface( udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); if (rc < 0) { - printk(KERN_INFO "%s usb_set_interface failed, " - "rc %d\n", __func__, rc); + sms_info("%s usb_set_interface failed, " + "rc %d\n", __func__, rc); return rc; } } - printk(KERN_INFO "smsusb_probe %d\n", + sms_info("smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber); for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) - printk(KERN_INFO "endpoint %d %02x %02x %d\n", i, + sms_info("endpoint %d %02x %02x %d\n", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); if ((udev->actconfig->desc.bNumInterfaces == 2) && (intf->cur_altsetting->desc.bInterfaceNumber == 0)) { - printk(KERN_INFO "rom interface 0 is not used\n"); + sms_info("rom interface 0 is not used\n"); return -ENODEV; } if (intf->cur_altsetting->desc.bInterfaceNumber == 1) { snprintf(devpath, sizeof(devpath), "usb\\%d-%s", udev->bus->busnum, udev->devpath); - printk(KERN_INFO "stellar device was found.\n"); + sms_info("stellar device was found.\n"); return smsusb1_load_firmware( udev, smscore_registry_getmode(devpath)); } rc = smsusb_init_device(intf, id->driver_info); - printk(KERN_INFO "%s rc %d\n", __func__, rc); + sms_info("%s rc %d\n", __func__, rc); return rc; } @@ -452,16 +452,16 @@ int smsusb_register(void) { int rc = usb_register(&smsusb_driver); if (rc) - printk(KERN_INFO "usb_register failed. Error number %d\n", rc); + sms_info("usb_register failed. Error number %d\n", rc); - printk(KERN_INFO "%s\n", __func__); + sms_info("%s\n", __func__); return rc; } void smsusb_unregister(void) { - printk(KERN_DEBUG "%s\n", __func__); + sms_debug("%s\n", __func__); /* Regular USB Cleanup */ usb_deregister(&smsusb_driver); } -- cgit v1.2.3 From bcf9ebb39574d120560c3d9149a618e0e5b282d9 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 19 Jun 2008 16:35:21 -0400 Subject: sms1xxx: move message formatting into printk macros From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 146 +++++++++++++---------------- linux/drivers/media/dvb/siano/smscoreapi.h | 9 +- linux/drivers/media/dvb/siano/smsdvb.c | 35 +++---- linux/drivers/media/dvb/siano/smsusb.c | 90 +++++++++--------- 4 files changed, 127 insertions(+), 153 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index db79b3f32..12a058af5 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -157,8 +157,7 @@ static struct smscore_registry_entry_t *smscore_find_registry(char *devpath) strcpy(entry->devpath, devpath); list_add(&entry->entry, &g_smscore_registry); } else - sms_err("%s failed to create smscore_registry.\n", - __func__); + sms_err("failed to create smscore_registry."); kmutex_unlock(&g_smscore_registrylock); return entry; } @@ -171,7 +170,7 @@ int smscore_registry_getmode(char *devpath) if (entry) return entry->mode; else - sms_err("%s No registry found.\n", __func__); + sms_err("No registry found."); return default_mode; } @@ -184,7 +183,7 @@ enum sms_device_type_st smscore_registry_gettype(char *devpath) if (entry) return entry->type; else - sms_err("%s No registry found.\n", __func__); + sms_err("No registry found."); return -1; } @@ -197,7 +196,7 @@ void smscore_registry_setmode(char *devpath, int mode) if (entry) entry->mode = mode; else - sms_err("%s No registry found.\n", __func__); + sms_err("No registry found."); } void smscore_registry_settype(char *devpath, enum sms_device_type_st type) @@ -208,7 +207,7 @@ void smscore_registry_settype(char *devpath, enum sms_device_type_st type) if (entry) entry->type = type; else - sms_err("%s No registry found.\n", __func__); + sms_err("No registry found."); } @@ -331,7 +330,7 @@ struct smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, struct smscore_buffer_t *cb = kmalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL); if (!cb) { - sms_info("%s kmalloc(...) failed\n", __func__); + sms_info("kmalloc(...) failed"); return NULL; } @@ -360,7 +359,7 @@ int smscore_register_device(struct smsdevice_params_t *params, dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL); if (!dev) { - sms_info("%s kzalloc(...) failed\n", __func__); + sms_info("kzalloc(...) failed"); return -ENOMEM; } @@ -408,8 +407,7 @@ int smscore_register_device(struct smsdevice_params_t *params, smscore_putbuffer(dev, cb); } - sms_info("%s allocated %d buffers\n", - __func__, dev->num_buffers); + sms_info("allocated %d buffers", dev->num_buffers); dev->mode = DEVICE_MODE_NONE; dev->context = params->context; @@ -432,7 +430,7 @@ int smscore_register_device(struct smsdevice_params_t *params, *coredev = dev; - sms_info("%s device %p created\n", __func__, dev); + sms_info("device %p created", dev); return 0; } @@ -450,8 +448,7 @@ int smscore_start_device(struct smscore_device_t *coredev) int rc = smscore_set_device_mode( coredev, smscore_registry_getmode(coredev->devpath)); if (rc < 0) { - sms_info("%s set device mode faile , rc %d\n", - __func__, rc); + sms_info("set device mode faile , rc %d", rc); return rc; } @@ -459,8 +456,7 @@ int smscore_start_device(struct smscore_device_t *coredev) rc = smscore_notify_callbacks(coredev, coredev->device, 1); - sms_info("%s device %p started, rc %d\n", - __func__, coredev, rc); + sms_info("device %p started, rc %d", coredev, rc); kmutex_unlock(&g_smscore_deviceslock); @@ -472,8 +468,7 @@ int smscore_sendrequest_and_wait(struct smscore_device_t *coredev, void *buffer, { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); if (rc < 0) { - sms_info("%s sendrequest returned error %d\n", - __func__, rc); + sms_info("sendrequest returned error %d", rc); return rc; } @@ -491,8 +486,8 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, u8 *payload = firmware->Payload; int rc = 0; - sms_info("%s loading FW to addr 0x%x size %d\n", - __func__, mem_address, firmware->Length); + sms_info("loading FW to addr 0x%x size %d", + mem_address, firmware->Length); if (coredev->preload_handler) { rc = coredev->preload_handler(coredev->context); if (rc < 0) @@ -505,7 +500,7 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, return -ENOMEM; if (coredev->mode != DEVICE_MODE_NONE) { - PDEBUG("Sending reload command\n"); + PDEBUG("Sending reload command"); SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(struct SmsMsgHdr_ST)); rc = smscore_sendrequest_and_wait(coredev, msg, @@ -578,7 +573,7 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, msleep(500); } - sms_debug("%s rc=%d, postload=%p \n", __func__, rc, + sms_debug("rc=%d, postload=%p ", rc, coredev->postload_handler); kfree(msg); @@ -612,12 +607,10 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, rc = request_firmware(&fw, filename, coredev->device); if (rc < 0) { - sms_info("%s failed to open \"%s\"\n", - __func__, filename); + sms_info("failed to open \"%s\"", filename); return rc; } - sms_info("%s read FW %s, size=%d\"\n", __func__, - filename, fw->size); + sms_info("read FW %s, size=%d\"", filename, fw->size); fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); if (fw_buffer) { @@ -632,8 +625,7 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, kfree(fw_buffer); } else { - sms_info("%s failed to allocate firmware buffer\n", - __func__); + sms_info("failed to allocate firmware buffer"); rc = -ENOMEM; } @@ -645,7 +637,7 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, int smscore_load_firmware_from_buffer(struct smscore_device_t *coredev, u8 *buffer, int size, int new_mode) { - PERROR("Feature not implemented yet\n"); + PERROR("Feature not implemented yet"); return -EFAULT; } @@ -680,17 +672,17 @@ void smscore_unregister_device(struct smscore_device_t *coredev) if (num_buffers == coredev->num_buffers) break; if (++retry > 10) { - sms_info("%s exiting although " - "not all buffers released.\n", __func__); + sms_info("exiting although " + "not all buffers released."); break; } - sms_info("%s waiting for %d buffer(s)\n", __func__, + sms_info("waiting for %d buffer(s)", coredev->num_buffers - num_buffers); msleep(100); } - sms_info("%s freed %d buffers\n", __func__, num_buffers); + sms_info("freed %d buffers", num_buffers); if (coredev->common_buffer) dma_free_coherent(NULL, coredev->common_buffer_size, @@ -702,7 +694,7 @@ void smscore_unregister_device(struct smscore_device_t *coredev) kmutex_unlock(&g_smscore_deviceslock); - sms_info("%s device %p destroyed\n", __func__, coredev); + sms_info("device %p destroyed", coredev); } int smscore_detect_mode(struct smscore_device_t *coredev) @@ -722,8 +714,7 @@ int smscore_detect_mode(struct smscore_device_t *coredev) rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc == -ETIME) { - sms_err("%s: MSG_SMS_GET_VERSION_EX_REQ " - "failed first try\n", __func__); + sms_err("MSG_SMS_GET_VERSION_EX_REQ failed first try"); if (wait_for_completion_timeout(&coredev->resume_done, msecs_to_jiffies(5000))) { @@ -731,9 +722,8 @@ int smscore_detect_mode(struct smscore_device_t *coredev) coredev, msg, msg->msgLength, &coredev->version_ex_done); if (rc < 0) - sms_err("%s: " - "MSG_SMS_GET_VERSION_EX_REQ failed " - "second try, rc %d\n", __func__, rc); + sms_err("MSG_SMS_GET_VERSION_EX_REQ failed " + "second try, rc %d", rc); } else rc = -ETIME; } @@ -780,11 +770,10 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) int rc = 0; enum sms_device_type_st type; - PDEBUG("set device mode to %d\n", mode); + PDEBUG("set device mode to %d", mode); if (coredev->device_flags & SMS_DEVICE_FAMILY2) { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) { - sms_info("%s invalid mode specified %d\n", - __func__, mode); + sms_info("invalid mode specified %d", mode); return -EINVAL; } @@ -793,15 +782,13 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) { rc = smscore_detect_mode(coredev); if (rc < 0) { - sms_info("%s mode detect failed %d\n", - __func__, rc); + sms_info("mode detect failed %d", rc); return rc; } } if (coredev->mode == mode) { - sms_info("%s device mode %d already set\n", - __func__, mode); + sms_info("device mode %d already set", mode); return 0; } @@ -810,13 +797,13 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) rc = smscore_load_firmware_from_file( coredev, smscore_fw_lkup[mode][type], NULL); if (rc < 0) { - sms_info("%s load firmware " - "failed %d\n", __func__, rc); + sms_info("load firmware " + "failed %d", rc); return rc; } } else - sms_info("%s mode %d supported by running " - "firmware\n", __func__, mode); + sms_info("mode %d supported by running " + "firmware", mode); buffer = kmalloc(sizeof(struct SmsMsgData_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); @@ -835,14 +822,13 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) kfree(buffer); } else { - sms_info("%s Could not allocate buffer for " - "init device message.\n", __func__); + sms_info("Could not allocate buffer for " + "init device message."); rc = -ENOMEM; } } else { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - sms_info("%s invalid mode specified %d\n", - __func__, mode); + sms_info("invalid mode specified %d", mode); return -EINVAL; } @@ -862,7 +848,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) } if (rc != 0) - sms_info("%s return error code %d.\n", __func__, rc); + sms_info("return error code %d.", rc); return rc; } @@ -946,7 +932,7 @@ void smscore_onresponse(struct smscore_device_t *coredev, last_sample_time = time_now; if (time_now - last_sample_time > 10000) { - sms_debug("\n%s data rate %d bytes/secs\n", __func__, + sms_debug("\ndata rate %d bytes/secs", (int)((data_total * 1000) / (time_now - last_sample_time))); @@ -971,8 +957,8 @@ void smscore_onresponse(struct smscore_device_t *coredev, { struct SmsVersionRes_ST *ver = (struct SmsVersionRes_ST *) phdr; - sms_debug("%s: MSG_SMS_GET_VERSION_EX_RES " - "id %d prots 0x%x ver %d.%d\n", __func__, + sms_debug("MSG_SMS_GET_VERSION_EX_RES " + "id %d prots 0x%x ver %d.%d", ver->FirmwareId, ver->SupportedProtocols, ver->RomVersionMajor, ver->RomVersionMinor); @@ -984,25 +970,21 @@ void smscore_onresponse(struct smscore_device_t *coredev, break; } case MSG_SMS_INIT_DEVICE_RES: - sms_debug("%s: MSG_SMS_INIT_DEVICE_RES\n", - __func__); + sms_debug("MSG_SMS_INIT_DEVICE_RES"); complete(&coredev->init_device_done); break; case MSG_SW_RELOAD_START_RES: - sms_debug("%s: MSG_SW_RELOAD_START_RES\n", - __func__); + sms_debug("MSG_SW_RELOAD_START_RES"); complete(&coredev->reload_start_done); break; case MSG_SMS_DATA_DOWNLOAD_RES: complete(&coredev->data_download_done); break; case MSG_SW_RELOAD_EXEC_RES: - sms_debug("%s: MSG_SW_RELOAD_EXEC_RES\n", - __func__); + sms_debug("MSG_SW_RELOAD_EXEC_RES"); break; case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - sms_debug("%s: MSG_SMS_SWDOWNLOAD_TRIGGER_RES\n", - __func__); + sms_debug("MSG_SMS_SWDOWNLOAD_TRIGGER_RES"); complete(&coredev->trigger_done); break; case MSG_SMS_SLEEP_RESUME_COMP_IND: @@ -1010,8 +992,8 @@ void smscore_onresponse(struct smscore_device_t *coredev, break; default: #if 0 - sms_info("%s no client (%p) or error (%d), " - "type:%d dstid:%d\n", __func__, client, rc, + sms_info("no client (%p) or error (%d), " + "type:%d dstid:%d", client, rc, phdr->msgType, phdr->msgDstId); #endif break; @@ -1067,7 +1049,7 @@ int smscore_validate_client(struct smscore_device_t *coredev, struct smscore_client_t *registered_client; if (!client) { - PERROR("bad parameter.\n"); + PERROR("bad parameter."); return -EFAULT; } registered_client = smscore_find_client(coredev, data_type, id); @@ -1075,12 +1057,12 @@ int smscore_validate_client(struct smscore_device_t *coredev, return 0; if (registered_client) { - PERROR("The msg ID already registered to another client.\n"); + PERROR("The msg ID already registered to another client."); return -EEXIST; } listentry = kzalloc(sizeof(struct smscore_idlist_t), GFP_KERNEL); if (!listentry) { - PERROR("Can't allocate memory for client id.\n"); + PERROR("Can't allocate memory for client id."); return -ENOMEM; } listentry->id = id; @@ -1112,13 +1094,13 @@ int smscore_register_client(struct smscore_device_t *coredev, /* check that no other channel with same parameters exists */ if (smscore_find_client(coredev, params->data_type, params->initial_id)) { - PERROR("Client already exist.\n"); + PERROR("Client already exist."); return -EEXIST; } newclient = kzalloc(sizeof(struct smscore_client_t), GFP_KERNEL); if (!newclient) { - PERROR("Failed to allocate memory for client.\n"); + PERROR("Failed to allocate memory for client."); return -ENOMEM; } @@ -1132,7 +1114,7 @@ int smscore_register_client(struct smscore_device_t *coredev, smscore_validate_client(coredev, newclient, params->data_type, params->initial_id); *client = newclient; - PDEBUG("%p %d %d\n", params->context, params->data_type, + PDEBUG("%p %d %d", params->context, params->data_type, params->initial_id); return 0; @@ -1160,7 +1142,7 @@ void smscore_unregister_client(struct smscore_client_t *client) kfree(identry); } - sms_info("%s %p\n", __func__, client->context); + sms_info("%p", client->context); list_del(&client->entry); kfree(client); @@ -1187,7 +1169,7 @@ int smsclient_sendrequest(struct smscore_client_t *client, int rc; if (client == NULL) { - sms_err("%s Got NULL client\n", __func__); + sms_err("Got NULL client"); return -EINVAL; } @@ -1195,7 +1177,7 @@ int smsclient_sendrequest(struct smscore_client_t *client, /* check that no other channel with same id exists */ if (coredev == NULL) { - sms_err("%s Got NULL coredev\n", __func__); + sms_err("Got NULL coredev"); return -EINVAL; } @@ -1236,20 +1218,20 @@ int smscore_map_common_buffer(struct smscore_device_t *coredev, if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) { - sms_info("%s invalid vm flags\n", __func__); + sms_info("invalid vm flags"); return -EINVAL; } if ((end - start) != size) { - sms_info("%s invalid size %d expected %d\n", - __func__, (int)(end - start), (int) size); + sms_info("invalid size %d expected %d", + (int)(end - start), (int) size); return -EINVAL; } if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) { - sms_info("%s remap_page_range failed\n", __func__); + sms_info("remap_page_range failed"); return -EAGAIN; } @@ -1273,7 +1255,7 @@ int smscore_module_init(void) /* DVB Register */ rc = smsdvb_register(); - sms_info("%s, rc %d\n", __func__, rc); + sms_debug("rc %d", rc); return rc; } @@ -1309,7 +1291,7 @@ void smscore_module_exit(void) /* Unregister USB */ smsusb_unregister(); - sms_info("%s\n", __func__); + sms_debug(""); } module_init(smscore_module_init); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index d49ea224e..b9d216ebf 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -579,9 +579,12 @@ void smsdvb_unregister(void); int smsusb_register(void); void smsusb_unregister(void); -#define sms_err(fmt, arg...) printk(KERN_ERR fmt, ##arg) -#define sms_info(fmt, arg...) printk(KERN_INFO fmt, ##arg) -#define sms_debug(fmt, arg...) printk(KERN_DEBUG fmt, ##arg) +#define sms_err(fmt, arg...) \ + printk(KERN_ERR "%s " fmt "\n", __func__, ##arg) +#define sms_info(fmt, arg...) \ + printk(KERN_INFO "%s " fmt "\n", __func__, ##arg) +#define sms_debug(fmt, arg...) \ + printk(KERN_DEBUG "%s " fmt "\n", __func__, ##arg) #endif /* __smscoreapi_h__ */ diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index c66492b4c..3aa68b600 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -113,7 +113,7 @@ static int smsdvb_start_feed(struct dvb_demux_feed *feed) container_of(feed->demux, struct smsdvb_client_t, demux); struct SmsMsgData_ST PidMsg; - sms_debug("%s add pid %d(%x)\n", __func__, + sms_debug("add pid %d(%x)", feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; @@ -133,7 +133,7 @@ static int smsdvb_stop_feed(struct dvb_demux_feed *feed) container_of(feed->demux, struct smsdvb_client_t, demux); struct SmsMsgData_ST PidMsg; - sms_debug("%s remove pid %d(%x)\n", __func__, + sms_debug("remove pid %d(%x)", feed->pid, feed->pid); PidMsg.xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID; @@ -220,7 +220,7 @@ static int smsdvb_read_snr(struct dvb_frontend *fe, u16 *snr) static int smsdvb_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune) { - sms_debug("%s\n", __func__); + sms_debug(""); tune->min_delay_ms = 400; tune->step_size = 250000; @@ -247,7 +247,7 @@ static int smsdvb_set_frontend(struct dvb_frontend *fe, Msg.Data[0] = fep->frequency; Msg.Data[2] = 12000000; - sms_debug("%s freq %d band %d\n", __func__, + sms_debug("freq %d band %d", fep->frequency, fep->u.ofdm.bandwidth); switch (fep->u.ofdm.bandwidth) { @@ -271,7 +271,7 @@ static int smsdvb_get_frontend(struct dvb_frontend *fe, struct smsdvb_client_t *client = container_of(fe, struct smsdvb_client_t, frontend); - sms_debug("%s\n", __func__); + sms_debug(""); /* todo: */ memcpy(fep, &client->fe_params, @@ -326,8 +326,8 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, if (smscore_get_device_mode(coredev) != 4) { #if 1 /* new siano drop (1.2.17) does this -- yuck */ - sms_err("%sSMS Device mode is not set for " - "DVB operation.\n", __func__); + sms_err("SMS Device mode is not set for " + "DVB operation."); return 0; #else rc = smscore_set_device_mode(coredev, 4); @@ -338,7 +338,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) { - sms_info("%s kmalloc() failed\n", __func__); + sms_info("kmalloc() failed"); return -ENOMEM; } @@ -348,8 +348,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, smscore_get_board_id(coredev))->name, THIS_MODULE, device, adapter_nr); if (rc < 0) { - sms_err("%s dvb_register_adapter() failed %d\n", - __func__, rc); + sms_err("dvb_register_adapter() failed %d", rc); goto adapter_error; } @@ -362,8 +361,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = dvb_dmx_init(&client->demux); if (rc < 0) { - sms_err("%s dvb_dmx_init failed %d\n\n", - __func__, rc); + sms_err("dvb_dmx_init failed %d", rc); goto dvbdmx_error; } @@ -374,8 +372,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter); if (rc < 0) { - sms_err("%s dvb_dmxdev_init failed %d\n", - __func__, rc); + sms_err("dvb_dmxdev_init failed %d", rc); goto dmxdev_error; } @@ -385,8 +382,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = dvb_register_frontend(&client->adapter, &client->frontend); if (rc < 0) { - sms_err("%s frontend registration failed %d\n", - __func__, rc); + sms_err("frontend registration failed %d", rc); goto frontend_error; } @@ -398,8 +394,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { - sms_info("%s smscore_register_client() failed %d\n", - __func__, rc); + sms_info("smscore_register_client() failed %d", rc); goto client_error; } @@ -414,7 +409,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, kmutex_unlock(&g_smsdvb_clientslock); - sms_info("%s success\n", __func__); + sms_info("success"); return 0; @@ -444,7 +439,7 @@ int smsdvb_register(void) rc = smscore_register_hotplug(smsdvb_hotplug); - sms_info("%s\n", __func__); + sms_debug(""); return rc; } diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index de3629cb3..096397f83 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -64,8 +64,8 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) struct smsusb_device_t *dev = surb->dev; if (urb->status < 0) { - sms_info("%s error, urb status %d, %d bytes\n", - __func__, urb->status, urb->actual_length); + sms_info("error, urb status %d, %d bytes", + urb->status, urb->actual_length); return; } @@ -85,9 +85,9 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) /* sanity check */ if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) { - sms_info("%s: invalid response " + sms_info("invalid response " "msglen %d offset %d " - "size %d\n", __func__, + "size %d", phdr->msgLength, surb->cb->offset, urb->actual_length); @@ -104,8 +104,8 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) smscore_onresponse(dev->coredev, surb->cb); surb->cb = NULL; } else { - sms_info("%s invalid response " - "msglen %d actual %d\n", __func__, + sms_info("invalid response " + "msglen %d actual %d", phdr->msgLength, urb->actual_length); } } @@ -119,8 +119,8 @@ int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb) if (!surb->cb) { surb->cb = smscore_getbuffer(dev->coredev); if (!surb->cb) { - sms_info("%s smscore_getbuffer(...) " - "returned NULL\n", __func__); + sms_info("smscore_getbuffer(...) " + "returned NULL"); return -ENOMEM; } } @@ -161,8 +161,8 @@ int smsusb_start_streaming(struct smsusb_device_t *dev) for (i = 0; i < MAX_URBS; i++) { rc = smsusb_submit_urb(dev, &dev->surbs[i]); if (rc < 0) { - sms_info("%s smsusb_submit_urb(...) " - "failed\n", __func__); + sms_info("smsusb_submit_urb(...) " + "failed"); smsusb_stop_streaming(dev); break; } @@ -195,15 +195,14 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) int rc, dummy; if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) { - sms_info("%s invalid firmware id specified %d\n", - __func__, id); + sms_info("invalid firmware id specified %d", id); return -EINVAL; } rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); if (rc < 0) { - sms_info("%s failed to open \"%s\" mode %d\n", - __func__, smsusb1_fw_lkup[id], id); + sms_info("failed to open \"%s\" mode %d", + smsusb1_fw_lkup[id], id); return rc; } @@ -214,12 +213,11 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); - sms_info("%s: sent %d(%d) bytes, rc %d\n", - __func__, fw->size, dummy, rc); + sms_info("sent %d(%d) bytes, rc %d", fw->size, dummy, rc); kfree(fw_buffer); } else { - sms_info("failed to allocate firmware buffer\n"); + sms_info("failed to allocate firmware buffer"); rc = -ENOMEM; } @@ -237,7 +235,7 @@ void smsusb1_detectmode(void *context, int *mode) if (!product_string) { product_string = "none"; - sms_err("%s product string not found\n", __func__); + sms_err("product string not found"); } else if (strstr(product_string, "DVBH")) *mode = 1; else if (strstr(product_string, "BDA")) @@ -247,7 +245,7 @@ void smsusb1_detectmode(void *context, int *mode) else if (strstr(product_string, "TDMB")) *mode = 2; - sms_info("%s: %d \"%s\"\n", __func__, *mode, product_string); + sms_info("%d \"%s\"", *mode, product_string); } int smsusb1_setmode(void *context, int mode) @@ -256,8 +254,7 @@ int smsusb1_setmode(void *context, int mode) sizeof(struct SmsMsgHdr_ST), 0 }; if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - sms_info("%s invalid firmware id specified %d\n", - __func__, mode); + sms_info("invalid firmware id specified %d", mode); return -EINVAL; } @@ -278,7 +275,7 @@ void smsusb_term_device(struct usb_interface *intf) kfree(dev); - sms_info("%s device %p destroyed\n", __func__, dev); + sms_info("device %p destroyed", dev); } usb_set_intfdata(intf, NULL); @@ -294,8 +291,8 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) /* create device object */ dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL); if (!dev) { - sms_info("%s kzalloc(sizeof(struct smsusb_device_t) " - "failed\n", __func__); + sms_info("kzalloc(sizeof(struct smsusb_device_t) " + "failed"); return -ENOMEM; } @@ -313,25 +310,24 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) params.setmode_handler = smsusb1_setmode; params.detectmode_handler = smsusb1_detectmode; params.device_type = SMS_STELLAR; - sms_info("%s stellar device found\n", __func__); + sms_info("stellar device found"); break; default: switch (board->type) { case SMS_NOVA_A0: params.device_type = SMS_NOVA_A0; - sms_info("%s nova A0 found\n", __func__); + sms_info("nova A0 found"); break; case SMS_NOVA_B0: params.device_type = SMS_NOVA_B0; - sms_info("%s nova B0 found\n", __func__); + sms_info("nova B0 found"); break; case SMS_VEGA: params.device_type = SMS_VEGA; - sms_info("%s Vega found\n", __func__); + sms_info("Vega found"); break; default: - sms_err("%s Unspecified sms device type!\n", - __func__); + sms_err("Unspecified sms device type!"); } dev->buffer_size = USB2_BUFFER_SIZE; @@ -354,8 +350,8 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) /* register in smscore */ rc = smscore_register_device(¶ms, &dev->coredev); if (rc < 0) { - sms_info("%s smscore_register_device(...) failed, " - "rc %d\n", __func__, rc); + sms_info("smscore_register_device(...) failed, " + "rc %d", rc); smsusb_term_device(intf); return rc; } @@ -368,24 +364,22 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) usb_init_urb(&dev->surbs[i].urb); } - sms_info("%s smsusb_start_streaming(...).\n", __func__); + sms_info("smsusb_start_streaming(...)."); rc = smsusb_start_streaming(dev); if (rc < 0) { - sms_info("%s smsusb_start_streaming(...) failed\n", - __func__); + sms_info("smsusb_start_streaming(...) failed"); smsusb_term_device(intf); return rc; } rc = smscore_start_device(dev->coredev); if (rc < 0) { - sms_info("%s smscore_start_device(...) failed\n", - __func__); + sms_info("smscore_start_device(...) failed"); smsusb_term_device(intf); return rc; } - sms_info("%s device %p created\n", __func__, dev); + sms_info("device %p created", dev); return rc; } @@ -403,36 +397,36 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) rc = usb_set_interface( udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); if (rc < 0) { - sms_info("%s usb_set_interface failed, " - "rc %d\n", __func__, rc); + sms_info("usb_set_interface failed, " + "rc %d", rc); return rc; } } - sms_info("smsusb_probe %d\n", + sms_info("smsusb_probe %d", intf->cur_altsetting->desc.bInterfaceNumber); for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) - sms_info("endpoint %d %02x %02x %d\n", i, + sms_info("endpoint %d %02x %02x %d", i, intf->cur_altsetting->endpoint[i].desc.bEndpointAddress, intf->cur_altsetting->endpoint[i].desc.bmAttributes, intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize); if ((udev->actconfig->desc.bNumInterfaces == 2) && (intf->cur_altsetting->desc.bInterfaceNumber == 0)) { - sms_info("rom interface 0 is not used\n"); + sms_info("rom interface 0 is not used"); return -ENODEV; } if (intf->cur_altsetting->desc.bInterfaceNumber == 1) { snprintf(devpath, sizeof(devpath), "usb\\%d-%s", udev->bus->busnum, udev->devpath); - sms_info("stellar device was found.\n"); + sms_info("stellar device was found."); return smsusb1_load_firmware( udev, smscore_registry_getmode(devpath)); } rc = smsusb_init_device(intf, id->driver_info); - sms_info("%s rc %d\n", __func__, rc); + sms_info("rc %d", rc); return rc; } @@ -452,16 +446,16 @@ int smsusb_register(void) { int rc = usb_register(&smsusb_driver); if (rc) - sms_info("usb_register failed. Error number %d\n", rc); + sms_info("usb_register failed. Error number %d", rc); - sms_info("%s\n", __func__); + sms_debug(""); return rc; } void smsusb_unregister(void) { - sms_debug("%s\n", __func__); + sms_debug(""); /* Regular USB Cleanup */ usb_deregister(&smsusb_driver); } -- cgit v1.2.3 From 1e6dea12fc00f3da24a0ff566c0a7cfbe62998e4 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 19 Jun 2008 16:59:08 -0400 Subject: sms1xxx: add debug module option, to enable debug messages From: Michael Krufky All dmesg spam turned off by default, for now. Values for debug: (info=1, adv=2 (or-able) Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 4 ++++ linux/drivers/media/dvb/siano/smscoreapi.h | 20 +++++++++++++++++--- 2 files changed, 21 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 12a058af5..2e0c98a38 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -33,6 +33,10 @@ #include "smscoreapi.h" +int sms_debug; +module_param_named(debug, sms_debug, int, 0644); +MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))"); + #define PERROR(fmt, args...)\ sms_err("smscore error: line %d- %s(): " fmt, \ __LINE__, __func__, ## args) diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index b9d216ebf..65f492834 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -579,12 +579,26 @@ void smsdvb_unregister(void); int smsusb_register(void); void smsusb_unregister(void); +/* ------------------------------------------------------------------------ */ + +extern int sms_debug; + +#define DBG_INFO 1 +#define DBG_ADV 2 + +#define sms_printk(kern, fmt, arg...) \ + printk(kern "%s: " fmt "\n", __func__, ##arg) + +#define dprintk(kern, lvl, fmt, arg...) do {\ + if (sms_debug & lvl) \ + sms_printk(kern, fmt, ##arg); } while (0) + #define sms_err(fmt, arg...) \ - printk(KERN_ERR "%s " fmt "\n", __func__, ##arg) + sms_printk(KERN_ERR, "%s " fmt "\n", __func__, ##arg) #define sms_info(fmt, arg...) \ - printk(KERN_INFO "%s " fmt "\n", __func__, ##arg) + dprintk(KERN_INFO, DBG_INFO, fmt, ##arg) #define sms_debug(fmt, arg...) \ - printk(KERN_DEBUG "%s " fmt "\n", __func__, ##arg) + dprintk(KERN_DEBUG, DBG_ADV, fmt, ##arg) #endif /* __smscoreapi_h__ */ -- cgit v1.2.3 From b540ead0284ca67f95562426f86dec36103d3c30 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 19 Jun 2008 18:07:23 -0400 Subject: sms1xxx: always show error messages From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 21 ++++++------ linux/drivers/media/dvb/siano/smsdvb.c | 4 +-- linux/drivers/media/dvb/siano/smsusb.c | 55 ++++++++++++++---------------- 3 files changed, 37 insertions(+), 43 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 2e0c98a38..72567a767 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -777,7 +777,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) PDEBUG("set device mode to %d", mode); if (coredev->device_flags & SMS_DEVICE_FAMILY2) { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) { - sms_info("invalid mode specified %d", mode); + sms_err("invalid mode specified %d", mode); return -EINVAL; } @@ -786,7 +786,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) { rc = smscore_detect_mode(coredev); if (rc < 0) { - sms_info("mode detect failed %d", rc); + sms_err("mode detect failed %d", rc); return rc; } } @@ -801,8 +801,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) rc = smscore_load_firmware_from_file( coredev, smscore_fw_lkup[mode][type], NULL); if (rc < 0) { - sms_info("load firmware " - "failed %d", rc); + sms_err("load firmware failed %d", rc); return rc; } } else @@ -826,13 +825,13 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) kfree(buffer); } else { - sms_info("Could not allocate buffer for " - "init device message."); + sms_err("Could not allocate buffer for " + "init device message."); rc = -ENOMEM; } } else { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - sms_info("invalid mode specified %d", mode); + sms_err("invalid mode specified %d", mode); return -EINVAL; } @@ -852,7 +851,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) } if (rc != 0) - sms_info("return error code %d.", rc); + sms_err("return error code %d.", rc); return rc; } @@ -1222,12 +1221,12 @@ int smscore_map_common_buffer(struct smscore_device_t *coredev, if (!(vma->vm_flags & (VM_READ | VM_SHARED)) || (vma->vm_flags & VM_WRITE)) { - sms_info("invalid vm flags"); + sms_err("invalid vm flags"); return -EINVAL; } if ((end - start) != size) { - sms_info("invalid size %d expected %d", + sms_err("invalid size %d expected %d", (int)(end - start), (int) size); return -EINVAL; } @@ -1235,7 +1234,7 @@ int smscore_map_common_buffer(struct smscore_device_t *coredev, if (remap_pfn_range(vma, start, coredev->common_buffer_phys >> PAGE_SHIFT, size, pgprot_noncached(vma->vm_page_prot))) { - sms_info("remap_page_range failed"); + sms_err("remap_page_range failed"); return -EAGAIN; } diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 3aa68b600..d097e3940 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -338,7 +338,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL); if (!client) { - sms_info("kmalloc() failed"); + sms_err("kmalloc() failed"); return -ENOMEM; } @@ -394,7 +394,7 @@ int smsdvb_hotplug(struct smscore_device_t *coredev, rc = smscore_register_client(coredev, ¶ms, &client->smsclient); if (rc < 0) { - sms_info("smscore_register_client() failed %d", rc); + sms_err("smscore_register_client() failed %d", rc); goto client_error; } diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 096397f83..e05856895 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -64,8 +64,8 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) struct smsusb_device_t *dev = surb->dev; if (urb->status < 0) { - sms_info("error, urb status %d, %d bytes", - urb->status, urb->actual_length); + sms_err("error, urb status %d, %d bytes", + urb->status, urb->actual_length); return; } @@ -85,12 +85,12 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) /* sanity check */ if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length) { - sms_info("invalid response " - "msglen %d offset %d " - "size %d", - phdr->msgLength, - surb->cb->offset, - urb->actual_length); + sms_err("invalid response " + "msglen %d offset %d " + "size %d", + phdr->msgLength, + surb->cb->offset, + urb->actual_length); goto exit_and_resubmit; } @@ -104,9 +104,9 @@ void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) smscore_onresponse(dev->coredev, surb->cb); surb->cb = NULL; } else { - sms_info("invalid response " - "msglen %d actual %d", - phdr->msgLength, urb->actual_length); + sms_err("invalid response " + "msglen %d actual %d", + phdr->msgLength, urb->actual_length); } } @@ -119,8 +119,7 @@ int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb) if (!surb->cb) { surb->cb = smscore_getbuffer(dev->coredev); if (!surb->cb) { - sms_info("smscore_getbuffer(...) " - "returned NULL"); + sms_err("smscore_getbuffer(...) returned NULL"); return -ENOMEM; } } @@ -161,8 +160,7 @@ int smsusb_start_streaming(struct smsusb_device_t *dev) for (i = 0; i < MAX_URBS; i++) { rc = smsusb_submit_urb(dev, &dev->surbs[i]); if (rc < 0) { - sms_info("smsusb_submit_urb(...) " - "failed"); + sms_err("smsusb_submit_urb(...) failed"); smsusb_stop_streaming(dev); break; } @@ -195,14 +193,14 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) int rc, dummy; if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) { - sms_info("invalid firmware id specified %d", id); + sms_err("invalid firmware id specified %d", id); return -EINVAL; } rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); if (rc < 0) { - sms_info("failed to open \"%s\" mode %d", - smsusb1_fw_lkup[id], id); + sms_err("failed to open \"%s\" mode %d", + smsusb1_fw_lkup[id], id); return rc; } @@ -217,7 +215,7 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) kfree(fw_buffer); } else { - sms_info("failed to allocate firmware buffer"); + sms_err("failed to allocate firmware buffer"); rc = -ENOMEM; } @@ -254,7 +252,7 @@ int smsusb1_setmode(void *context, int mode) sizeof(struct SmsMsgHdr_ST), 0 }; if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) { - sms_info("invalid firmware id specified %d", mode); + sms_err("invalid firmware id specified %d", mode); return -EINVAL; } @@ -291,8 +289,7 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) /* create device object */ dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL); if (!dev) { - sms_info("kzalloc(sizeof(struct smsusb_device_t) " - "failed"); + sms_err("kzalloc(sizeof(struct smsusb_device_t) failed"); return -ENOMEM; } @@ -350,8 +347,7 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) /* register in smscore */ rc = smscore_register_device(¶ms, &dev->coredev); if (rc < 0) { - sms_info("smscore_register_device(...) failed, " - "rc %d", rc); + sms_err("smscore_register_device(...) failed, rc %d", rc); smsusb_term_device(intf); return rc; } @@ -367,14 +363,14 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) sms_info("smsusb_start_streaming(...)."); rc = smsusb_start_streaming(dev); if (rc < 0) { - sms_info("smsusb_start_streaming(...) failed"); + sms_err("smsusb_start_streaming(...) failed"); smsusb_term_device(intf); return rc; } rc = smscore_start_device(dev->coredev); if (rc < 0) { - sms_info("smscore_start_device(...) failed"); + sms_err("smscore_start_device(...) failed"); smsusb_term_device(intf); return rc; } @@ -397,8 +393,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) rc = usb_set_interface( udev, intf->cur_altsetting->desc.bInterfaceNumber, 0); if (rc < 0) { - sms_info("usb_set_interface failed, " - "rc %d", rc); + sms_err("usb_set_interface failed, rc %d", rc); return rc; } } @@ -413,7 +408,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) if ((udev->actconfig->desc.bNumInterfaces == 2) && (intf->cur_altsetting->desc.bInterfaceNumber == 0)) { - sms_info("rom interface 0 is not used"); + sms_err("rom interface 0 is not used"); return -ENODEV; } @@ -446,7 +441,7 @@ int smsusb_register(void) { int rc = usb_register(&smsusb_driver); if (rc) - sms_info("usb_register failed. Error number %d", rc); + sms_err("usb_register failed. Error number %d", rc); sms_debug(""); -- cgit v1.2.3 From 71cf59d5d6b453fbbbe1be9a1e9794f4b2dd330d Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 19 Jun 2008 18:15:38 -0400 Subject: sms1xxx: remove old printk macros From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 37 ++++++++---------------------- linux/drivers/media/dvb/siano/smscoreapi.h | 6 ++++- 2 files changed, 15 insertions(+), 28 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 72567a767..0f2f41e0e 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -37,23 +37,6 @@ int sms_debug; module_param_named(debug, sms_debug, int, 0644); MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))"); -#define PERROR(fmt, args...)\ - sms_err("smscore error: line %d- %s(): " fmt, \ - __LINE__, __func__, ## args) - -#ifdef SMSCORE_DEBUG -#undef PWARNING -# define PWARNING(fmt, args...) sms_info("smscore warning: " \ - "line %d- %s(): " fmt, \ - __LINE__, __func__, ## args) -#undef PDEBUG /* undef it, just in case */ -# define PDEBUG(fmt, args...) sms_info("smscore - %s(): " fmt, \ - __func__, ## args) -#else /*SMSCORE_DEBUG*/ -#define PDEBUG(fmt, args...) -#define PWARNING(fmt, args...) -#endif - struct smscore_device_notifyee_t { struct list_head entry; hotplug_t hotplug; @@ -504,7 +487,7 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, return -ENOMEM; if (coredev->mode != DEVICE_MODE_NONE) { - PDEBUG("Sending reload command"); + sms_debug("sending reload command."); SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ, sizeof(struct SmsMsgHdr_ST)); rc = smscore_sendrequest_and_wait(coredev, msg, @@ -641,7 +624,7 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, int smscore_load_firmware_from_buffer(struct smscore_device_t *coredev, u8 *buffer, int size, int new_mode) { - PERROR("Feature not implemented yet"); + sms_err("feature not yet implemented."); return -EFAULT; } @@ -774,7 +757,7 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) int rc = 0; enum sms_device_type_st type; - PDEBUG("set device mode to %d", mode); + sms_debug("set device mode to %d", mode); if (coredev->device_flags & SMS_DEVICE_FAMILY2) { if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) { sms_err("invalid mode specified %d", mode); @@ -1052,7 +1035,7 @@ int smscore_validate_client(struct smscore_device_t *coredev, struct smscore_client_t *registered_client; if (!client) { - PERROR("bad parameter."); + sms_err("bad parameter."); return -EFAULT; } registered_client = smscore_find_client(coredev, data_type, id); @@ -1060,12 +1043,12 @@ int smscore_validate_client(struct smscore_device_t *coredev, return 0; if (registered_client) { - PERROR("The msg ID already registered to another client."); + sms_err("The msg ID already registered to another client."); return -EEXIST; } listentry = kzalloc(sizeof(struct smscore_idlist_t), GFP_KERNEL); if (!listentry) { - PERROR("Can't allocate memory for client id."); + sms_err("Can't allocate memory for client id."); return -ENOMEM; } listentry->id = id; @@ -1097,13 +1080,13 @@ int smscore_register_client(struct smscore_device_t *coredev, /* check that no other channel with same parameters exists */ if (smscore_find_client(coredev, params->data_type, params->initial_id)) { - PERROR("Client already exist."); + sms_err("Client already exist."); return -EEXIST; } newclient = kzalloc(sizeof(struct smscore_client_t), GFP_KERNEL); if (!newclient) { - PERROR("Failed to allocate memory for client."); + sms_err("Failed to allocate memory for client."); return -ENOMEM; } @@ -1117,8 +1100,8 @@ int smscore_register_client(struct smscore_device_t *coredev, smscore_validate_client(coredev, newclient, params->data_type, params->initial_id); *client = newclient; - PDEBUG("%p %d %d", params->context, params->data_type, - params->initial_id); + sms_debug("%p %d %d", params->context, params->data_type, + params->initial_id); return 0; } diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 65f492834..972cbd1dc 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -594,7 +594,11 @@ extern int sms_debug; sms_printk(kern, fmt, ##arg); } while (0) #define sms_err(fmt, arg...) \ - sms_printk(KERN_ERR, "%s " fmt "\n", __func__, ##arg) + sms_printk(KERN_ERR, "%s() line: %d: " fmt "\n", \ + __func__, __LINE__, ##arg) +#define sms_warn(fmt, arg...) \ + sms_printk(KERN_WARNING, "%s() line: %d: " fmt "\n", \ + __func__, __LINE__, ##arg) #define sms_info(fmt, arg...) \ dprintk(KERN_INFO, DBG_INFO, fmt, ##arg) #define sms_debug(fmt, arg...) \ -- cgit v1.2.3 From 20b18e71474d66e2f17f5a993a20dc6a92321e70 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 19 Jun 2008 18:20:49 -0400 Subject: sms1xxx: remove redundant __func__ in sms_err macro From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.h | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 972cbd1dc..7fea03039 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -594,11 +594,9 @@ extern int sms_debug; sms_printk(kern, fmt, ##arg); } while (0) #define sms_err(fmt, arg...) \ - sms_printk(KERN_ERR, "%s() line: %d: " fmt "\n", \ - __func__, __LINE__, ##arg) + sms_printk(KERN_ERR, "line: %d: " fmt, __LINE__, ##arg) #define sms_warn(fmt, arg...) \ - sms_printk(KERN_WARNING, "%s() line: %d: " fmt "\n", \ - __func__, __LINE__, ##arg) + sms_printk(KERN_WARNING, "line: %d: " fmt, __LINE__, ##arg) #define sms_info(fmt, arg...) \ dprintk(KERN_INFO, DBG_INFO, fmt, ##arg) #define sms_debug(fmt, arg...) \ -- cgit v1.2.3 From 64705827cbd42718a7e2cadc3913a4f2cd4f81f6 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Fri, 20 Jun 2008 22:44:02 -0400 Subject: sms1xxx: mark functions static From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 59 +++++++++++++++--------------- linux/drivers/media/dvb/siano/smscoreapi.h | 6 +-- linux/drivers/media/dvb/siano/smsdvb.c | 10 ++--- linux/drivers/media/dvb/siano/smsusb.c | 33 +++++++++-------- 4 files changed, 54 insertions(+), 54 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 0f2f41e0e..1c68836e1 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -162,7 +162,7 @@ int smscore_registry_getmode(char *devpath) return default_mode; } -enum sms_device_type_st smscore_registry_gettype(char *devpath) +static enum sms_device_type_st smscore_registry_gettype(char *devpath) { struct smscore_registry_entry_t *entry; @@ -186,7 +186,8 @@ void smscore_registry_setmode(char *devpath, int mode) sms_err("No registry found."); } -void smscore_registry_settype(char *devpath, enum sms_device_type_st type) +static void smscore_registry_settype(char *devpath, + enum sms_device_type_st type) { struct smscore_registry_entry_t *entry; @@ -198,8 +199,8 @@ void smscore_registry_settype(char *devpath, enum sms_device_type_st type) } -void list_add_locked(struct list_head *new, struct list_head *head, - spinlock_t *lock) +static void list_add_locked(struct list_head *new, struct list_head *head, + spinlock_t *lock) { unsigned long flags; @@ -280,7 +281,7 @@ void smscore_unregister_hotplug(hotplug_t hotplug) kmutex_unlock(&g_smscore_deviceslock); } -void smscore_notify_clients(struct smscore_device_t *coredev) +static void smscore_notify_clients(struct smscore_device_t *coredev) { struct smscore_client_t *client; @@ -291,8 +292,8 @@ void smscore_notify_clients(struct smscore_device_t *coredev) } } -int smscore_notify_callbacks(struct smscore_device_t *coredev, - struct device *device, int arrival) +static int smscore_notify_callbacks(struct smscore_device_t *coredev, + struct device *device, int arrival) { struct list_head *next, *first; int rc = 0; @@ -311,7 +312,8 @@ int smscore_notify_callbacks(struct smscore_device_t *coredev, return rc; } -struct smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, +static struct +smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer, dma_addr_t common_buffer_phys) { struct smscore_buffer_t *cb = @@ -450,8 +452,9 @@ int smscore_start_device(struct smscore_device_t *coredev) return rc; } -int smscore_sendrequest_and_wait(struct smscore_device_t *coredev, void *buffer, - size_t size, struct completion *completion) +static int smscore_sendrequest_and_wait(struct smscore_device_t *coredev, + void *buffer, size_t size, + struct completion *completion) { int rc = coredev->sendrequest_handler(coredev->context, buffer, size); if (rc < 0) { @@ -464,8 +467,8 @@ int smscore_sendrequest_and_wait(struct smscore_device_t *coredev, void *buffer, 0 : -ETIME; } -int smscore_load_firmware_family2(struct smscore_device_t *coredev, - void *buffer, size_t size) +static int smscore_load_firmware_family2(struct smscore_device_t *coredev, + void *buffer, size_t size) { struct SmsFirmware_ST *firmware = (struct SmsFirmware_ST *) buffer; struct SmsMsgHdr_ST *msg; @@ -580,9 +583,9 @@ int smscore_load_firmware_family2(struct smscore_device_t *coredev, * * @return 0 on success, <0 on error. */ -int smscore_load_firmware_from_file(struct smscore_device_t *coredev, - char *filename, - loadfirmware_t loadfirmware_handler) +static int smscore_load_firmware_from_file(struct smscore_device_t *coredev, + char *filename, + loadfirmware_t loadfirmware_handler) { int rc = -ENOENT; const struct firmware *fw; @@ -621,13 +624,6 @@ int smscore_load_firmware_from_file(struct smscore_device_t *coredev, return rc; } -int smscore_load_firmware_from_buffer(struct smscore_device_t *coredev, - u8 *buffer, int size, int new_mode) -{ - sms_err("feature not yet implemented."); - return -EFAULT; -} - /** * notifies all clients registered with the device, notifies hotplugs, * frees all buffers and coredev object @@ -684,7 +680,7 @@ void smscore_unregister_device(struct smscore_device_t *coredev) sms_info("device %p destroyed", coredev); } -int smscore_detect_mode(struct smscore_device_t *coredev) +static int smscore_detect_mode(struct smscore_device_t *coredev) { void *buffer = kmalloc(sizeof(struct SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA); @@ -720,7 +716,7 @@ int smscore_detect_mode(struct smscore_device_t *coredev) return rc; } -char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { +static char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { /*Stellar NOVA A0 Nova B0 VEGA*/ /*DVBT*/ {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"}, @@ -861,7 +857,8 @@ int smscore_get_device_mode(struct smscore_device_t *coredev) * @param id client id (SMS_DONT_CARE for all id) * */ -struct smscore_client_t *smscore_find_client(struct smscore_device_t *coredev, +static struct +smscore_client_t *smscore_find_client(struct smscore_device_t *coredev, int data_type, int id) { struct smscore_client_t *client = NULL; @@ -1027,9 +1024,9 @@ void smscore_putbuffer(struct smscore_device_t *coredev, list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock); } -int smscore_validate_client(struct smscore_device_t *coredev, - struct smscore_client_t *client, - int data_type, int id) +static int smscore_validate_client(struct smscore_device_t *coredev, + struct smscore_client_t *client, + int data_type, int id) { struct smscore_idlist_t *listentry; struct smscore_client_t *registered_client; @@ -1175,6 +1172,7 @@ int smsclient_sendrequest(struct smscore_client_t *client, return coredev->sendrequest_handler(coredev->context, buffer, size); } +#if 0 /** * return the size of large (common) buffer * @@ -1195,8 +1193,8 @@ int smscore_get_common_buffer_size(struct smscore_device_t *coredev) * * @return 0 on success, <0 on error. */ -int smscore_map_common_buffer(struct smscore_device_t *coredev, - struct vm_area_struct *vma) +static int smscore_map_common_buffer(struct smscore_device_t *coredev, + struct vm_area_struct *vma) { unsigned long end = vma->vm_end, start = vma->vm_start, @@ -1223,6 +1221,7 @@ int smscore_map_common_buffer(struct smscore_device_t *coredev, return 0; } +#endif int smscore_module_init(void) { diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 7fea03039..78afcc913 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -543,10 +543,6 @@ extern int smscore_load_firmware(struct smscore_device_t *coredev, char *filename, loadfirmware_t loadfirmware_handler); -extern int smscore_load_firmware_from_buffer(struct smscore_device_t *coredev, - u8 *buffer, int size, - int new_mode); - extern int smscore_set_device_mode(struct smscore_device_t *coredev, int mode); extern int smscore_get_device_mode(struct smscore_device_t *coredev); @@ -560,9 +556,11 @@ extern int smsclient_sendrequest(struct smscore_client_t *client, extern void smscore_onresponse(struct smscore_device_t *coredev, struct smscore_buffer_t *cb); +#if 0 extern int smscore_get_common_buffer_size(struct smscore_device_t *coredev); extern int smscore_map_common_buffer(struct smscore_device_t *coredev, struct vm_area_struct *vma); +#endif extern struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev); extern void smscore_putbuffer(struct smscore_device_t *coredev, diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index d097e3940..4d65053f3 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -30,7 +30,7 @@ DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); struct list_head g_smsdvb_clients; kmutex_t g_smsdvb_clientslock; -int smsdvb_onresponse(void *context, struct smscore_buffer_t *cb) +static int smsdvb_onresponse(void *context, struct smscore_buffer_t *cb) { struct smsdvb_client_t *client = (struct smsdvb_client_t *) context; struct SmsMsgHdr_ST *phdr = @@ -84,7 +84,7 @@ int smsdvb_onresponse(void *context, struct smscore_buffer_t *cb) return 0; } -void smsdvb_unregister_client(struct smsdvb_client_t *client) +static void smsdvb_unregister_client(struct smsdvb_client_t *client) { /* must be called under clientslock */ @@ -98,7 +98,7 @@ void smsdvb_unregister_client(struct smsdvb_client_t *client) kfree(client); } -void smsdvb_onremove(void *context) +static void smsdvb_onremove(void *context) { kmutex_lock(&g_smsdvb_clientslock); @@ -313,8 +313,8 @@ static struct dvb_frontend_ops smsdvb_fe_ops = { .read_snr = smsdvb_read_snr, }; -int smsdvb_hotplug(struct smscore_device_t *coredev, - struct device *device, int arrival) +static int smsdvb_hotplug(struct smscore_device_t *coredev, + struct device *device, int arrival) { struct smsclient_params_t params; struct smsdvb_client_t *client; diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index e05856895..2f756d5d4 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -52,12 +52,13 @@ struct smsusb_device_t { int buffer_size; }; -int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb); +static int smsusb_submit_urb(struct smsusb_device_t *dev, + struct smsusb_urb_t *surb); #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15) -void smsusb_onresponse(struct urb *urb) +static void smsusb_onresponse(struct urb *urb) #else -void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) +static void smsusb_onresponse(struct urb *urb, struct pt_regs *regs) #endif { struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context; @@ -114,7 +115,8 @@ exit_and_resubmit: smsusb_submit_urb(dev, surb); } -int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb) +static int smsusb_submit_urb(struct smsusb_device_t *dev, + struct smsusb_urb_t *surb) { if (!surb->cb) { surb->cb = smscore_getbuffer(dev->coredev); @@ -139,7 +141,7 @@ int smsusb_submit_urb(struct smsusb_device_t *dev, struct smsusb_urb_t *surb) return usb_submit_urb(&surb->urb, GFP_ATOMIC); } -void smsusb_stop_streaming(struct smsusb_device_t *dev) +static void smsusb_stop_streaming(struct smsusb_device_t *dev) { int i; @@ -153,7 +155,7 @@ void smsusb_stop_streaming(struct smsusb_device_t *dev) } } -int smsusb_start_streaming(struct smsusb_device_t *dev) +static int smsusb_start_streaming(struct smsusb_device_t *dev) { int i, rc; @@ -169,7 +171,7 @@ int smsusb_start_streaming(struct smsusb_device_t *dev) return rc; } -int smsusb_sendrequest(void *context, void *buffer, size_t size) +static int smsusb_sendrequest(void *context, void *buffer, size_t size) { struct smsusb_device_t *dev = (struct smsusb_device_t *) context; int dummy; @@ -178,7 +180,7 @@ int smsusb_sendrequest(void *context, void *buffer, size_t size) buffer, size, &dummy, 1000); } -char *smsusb1_fw_lkup[] = { +static char *smsusb1_fw_lkup[] = { "dvbt_stellar_usb.inp", "dvbh_stellar_usb.inp", "tdmb_stellar_usb.inp", @@ -186,7 +188,7 @@ char *smsusb1_fw_lkup[] = { "dvbt_bda_stellar_usb.inp", }; -int smsusb1_load_firmware(struct usb_device *udev, int id) +static int smsusb1_load_firmware(struct usb_device *udev, int id) { const struct firmware *fw; u8 *fw_buffer; @@ -224,7 +226,7 @@ int smsusb1_load_firmware(struct usb_device *udev, int id) return rc; } -void smsusb1_detectmode(void *context, int *mode) +static void smsusb1_detectmode(void *context, int *mode) { char *product_string = ((struct smsusb_device_t *) context)->udev->product; @@ -246,7 +248,7 @@ void smsusb1_detectmode(void *context, int *mode) sms_info("%d \"%s\"", *mode, product_string); } -int smsusb1_setmode(void *context, int mode) +static int smsusb1_setmode(void *context, int mode) { struct SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, sizeof(struct SmsMsgHdr_ST), 0 }; @@ -259,7 +261,7 @@ int smsusb1_setmode(void *context, int mode) return smsusb_sendrequest(context, &Msg, sizeof(Msg)); } -void smsusb_term_device(struct usb_interface *intf) +static void smsusb_term_device(struct usb_interface *intf) { struct smsusb_device_t *dev = (struct smsusb_device_t *) usb_get_intfdata(intf); @@ -279,7 +281,7 @@ void smsusb_term_device(struct usb_interface *intf) usb_set_intfdata(intf, NULL); } -int smsusb_init_device(struct usb_interface *intf, int board_id) +static int smsusb_init_device(struct usb_interface *intf, int board_id) { struct smsdevice_params_t params; struct smsusb_device_t *dev; @@ -380,7 +382,8 @@ int smsusb_init_device(struct usb_interface *intf, int board_id) return rc; } -int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) +static int smsusb_probe(struct usb_interface *intf, + const struct usb_device_id *id) { struct usb_device *udev = interface_to_usbdev(intf); char devpath[32]; @@ -425,7 +428,7 @@ int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id) return rc; } -void smsusb_disconnect(struct usb_interface *intf) +static void smsusb_disconnect(struct usb_interface *intf) { smsusb_term_device(intf); } -- cgit v1.2.3 From 08c501abf1d2a3ba03b6daef19ed37a9dd8112de Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 21 Jun 2008 01:24:38 -0400 Subject: sms1xxx: simplify smsusb_init_device switch..case block From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smsusb.c | 30 +++++++----------------------- 1 file changed, 7 insertions(+), 23 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 2f756d5d4..ed080f8f1 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -285,7 +285,6 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id) { struct smsdevice_params_t params; struct smsusb_device_t *dev; - struct sms_board *board; int i, rc; /* create device object */ @@ -299,36 +298,21 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id) usb_set_intfdata(intf, dev); dev->udev = interface_to_usbdev(intf); - board = sms_get_board(board_id); - - switch (board->type) { + params.device_type = sms_get_board(board_id)->type; + switch (params.device_type) { case SMS_STELLAR: dev->buffer_size = USB1_BUFFER_SIZE; params.setmode_handler = smsusb1_setmode; params.detectmode_handler = smsusb1_detectmode; - params.device_type = SMS_STELLAR; - sms_info("stellar device found"); break; default: - switch (board->type) { - case SMS_NOVA_A0: - params.device_type = SMS_NOVA_A0; - sms_info("nova A0 found"); - break; - case SMS_NOVA_B0: - params.device_type = SMS_NOVA_B0; - sms_info("nova B0 found"); - break; - case SMS_VEGA: - params.device_type = SMS_VEGA; - sms_info("Vega found"); - break; - default: - sms_err("Unspecified sms device type!"); - } - + sms_err("Unspecified sms device type!"); + /* fall-thru */ + case SMS_NOVA_A0: + case SMS_NOVA_B0: + case SMS_VEGA: dev->buffer_size = USB2_BUFFER_SIZE; dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - -- cgit v1.2.3 From 86c5df2a06acdf0120627eb59377e38108d10708 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Thu, 26 Jun 2008 00:58:30 -0400 Subject: sms1xxx: add capability to define device-specific firmware filenames From: Michael Krufky Add the capability to define device-specific firmware filenames for the SMS1150, with a mechanism to fall back to the generic firmware if the device-specific firmware is not present. Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/sms-cards.h | 2 +- linux/drivers/media/dvb/siano/smscoreapi.c | 31 +++++++++++++++++++++++++----- linux/drivers/media/dvb/siano/smsusb.c | 1 + 3 files changed, 28 insertions(+), 6 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/sms-cards.h b/linux/drivers/media/dvb/siano/sms-cards.h index 7ba3df63d..9e93f0b5b 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.h +++ b/linux/drivers/media/dvb/siano/sms-cards.h @@ -31,8 +31,8 @@ #define SMS1XXX_BOARD_SIANO_VEGA 5 struct sms_board { - char *name; enum sms_device_type_st type; + char *name, *fw[DEVICE_MODE_MAX]; }; struct sms_board *sms_get_board(int id); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 1c68836e1..4948684d6 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -32,6 +32,7 @@ #include #include "smscoreapi.h" +#include "sms-cards.h" int sms_debug; module_param_named(debug, sms_debug, int, 0644); @@ -600,7 +601,7 @@ static int smscore_load_firmware_from_file(struct smscore_device_t *coredev, sms_info("failed to open \"%s\"", filename); return rc; } - sms_info("read FW %s, size=%d\"", filename, fw->size); + sms_info("read FW %s, size=%d", filename, fw->size); fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); if (fw_buffer) { @@ -736,6 +737,12 @@ static char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = { {"none", "none", "none", "cmmb_vega_12mhz.inp"} }; +static inline char *sms_get_fw_name(struct smscore_device_t *coredev, + int mode, enum sms_device_type_st type) +{ + char **fw = sms_get_board(smscore_get_board_id(coredev))->fw; + return (fw && fw[mode]) ? fw[mode] : smscore_fw_lkup[mode][type]; +} /** * calls device handler to change mode of operation @@ -776,12 +783,26 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) } if (!(coredev->modes_supported & (1 << mode))) { + char *fw_filename; + type = smscore_registry_gettype(coredev->devpath); - rc = smscore_load_firmware_from_file( - coredev, smscore_fw_lkup[mode][type], NULL); + fw_filename = sms_get_fw_name(coredev, mode, type); + + rc = smscore_load_firmware_from_file(coredev, + fw_filename, NULL); if (rc < 0) { - sms_err("load firmware failed %d", rc); - return rc; + sms_err("error %d loading firmware: %s, " + "trying again with default firmware", + rc, fw_filename); + + /* try again with the default firmware */ + rc = smscore_load_firmware_from_file(coredev, + smscore_fw_lkup[mode][type], NULL); + + if (rc < 0) { + sms_err("load firmware failed %d", rc); + return rc; + } } } else sms_info("mode %d supported by running " diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index ed080f8f1..41dad952b 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -220,6 +220,7 @@ static int smsusb1_load_firmware(struct usb_device *udev, int id) sms_err("failed to allocate firmware buffer"); rc = -ENOMEM; } + sms_info("read FW %s, size=%d", smsusb1_fw_lkup[id], fw->size); release_firmware(fw); -- cgit v1.2.3 From 7ab1058ebe47fdc6c5f944cc0eadf74f7bc23534 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 12:45:36 -0400 Subject: sms1xxx: fix Siano board names From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/sms-cards.c | 12 ++++-------- linux/drivers/media/dvb/siano/sms-cards.h | 9 ++++----- 2 files changed, 8 insertions(+), 13 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/sms-cards.c b/linux/drivers/media/dvb/siano/sms-cards.c index 88fc2a4ed..6a22ec10f 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.c +++ b/linux/drivers/media/dvb/siano/sms-cards.c @@ -38,24 +38,20 @@ static struct sms_board sms_boards[] = { [SMS_BOARD_UNKNOWN] = { .name = "Unknown board", }, - [SMS1XXX_BOARD_SIANO_SMS1000] = { - .name = "Siano Digital Receiver", - .type = SMS_STELLAR, - }, [SMS1XXX_BOARD_SIANO_STELLAR] = { - .name = "Siano Stellar reference board", + .name = "Siano Stellar Digital Receiver", .type = SMS_STELLAR, }, [SMS1XXX_BOARD_SIANO_NOVA_A] = { - .name = "Siano Nova A reference board", + .name = "Siano Nova A Digital Receiver", .type = SMS_NOVA_A0, }, [SMS1XXX_BOARD_SIANO_NOVA_B] = { - .name = "Siano Nova B reference board", + .name = "Siano Nova B Digital Receiver", .type = SMS_NOVA_B0, }, [SMS1XXX_BOARD_SIANO_VEGA] = { - .name = "Siano Vega reference board", + .name = "Siano Vega Digital Receiver", .type = SMS_VEGA, }, }; diff --git a/linux/drivers/media/dvb/siano/sms-cards.h b/linux/drivers/media/dvb/siano/sms-cards.h index 9e93f0b5b..262e3ffbc 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.h +++ b/linux/drivers/media/dvb/siano/sms-cards.h @@ -24,11 +24,10 @@ #include "smscoreapi.h" #define SMS_BOARD_UNKNOWN 0 -#define SMS1XXX_BOARD_SIANO_SMS1000 1 -#define SMS1XXX_BOARD_SIANO_STELLAR 2 -#define SMS1XXX_BOARD_SIANO_NOVA_A 3 -#define SMS1XXX_BOARD_SIANO_NOVA_B 4 -#define SMS1XXX_BOARD_SIANO_VEGA 5 +#define SMS1XXX_BOARD_SIANO_STELLAR 1 +#define SMS1XXX_BOARD_SIANO_NOVA_A 2 +#define SMS1XXX_BOARD_SIANO_NOVA_B 3 +#define SMS1XXX_BOARD_SIANO_VEGA 4 struct sms_board { enum sms_device_type_st type; -- cgit v1.2.3 From 3930ab58c2dccf277e2026e760abcff5f22a7a0c Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 13:09:28 -0400 Subject: sms1xxx: update MODULE_DESCRIPTION From: Michael Krufky set MODULE_DESCRIPTION to "Driver for the Siano SMS1XXX USB dongle" Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 2 +- linux/drivers/media/dvb/siano/smsdvb.c | 2 +- linux/drivers/media/dvb/siano/smsusb.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 4948684d6..449ef0f1e 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -1303,6 +1303,6 @@ void smscore_module_exit(void) module_init(smscore_module_init); module_exit(smscore_module_exit); -MODULE_DESCRIPTION("smscore"); +MODULE_DESCRIPTION("Driver for the Siano SMS1XXX USB dongle"); MODULE_AUTHOR("Siano Mobile Silicon,,, (doronc@siano-ms.com)"); MODULE_LICENSE("GPL"); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index 4d65053f3..c3b0fdf63 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -1,5 +1,5 @@ /* - * Driver for the Siano SMS10xx USB dongle + * Driver for the Siano SMS1xxx USB dongle * * author: Anatoly Greenblat * diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 41dad952b..ca9eb7820 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -1,5 +1,5 @@ /* - * Driver for the Siano SMS10xx USB dongle + * Driver for the Siano SMS1xxx USB dongle * * author: Anatoly Greenblat * -- cgit v1.2.3 From 6a92e20d0639ce172f0c7c28476a6c2b0d545ae5 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 16:53:45 -0400 Subject: sms1xxx: fix warning: format '%d' expects type 'int', but argument x has type 'size_t' From: Michael Krufky Fix the following 64bit build warning: make[2]: Entering directory `/usr/src/linux-headers-2.6.24-16-generic' CC [M] smscoreapi.o smscoreapi.c: In function 'smscore_load_firmware_from_file': smscoreapi.c:604: warning: format '%d' expects type 'int', but argument 4 has type 'size_t' CC [M] smsusb.o smsusb.c: In function 'smsusb1_load_firmware': smsusb.c:216: warning: format '%d' expects type 'int', but argument 3 has type 'size_t' smsusb.c:223: warning: format '%d' expects type 'int', but argument 4 has type 'size_t' Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 2 +- linux/drivers/media/dvb/siano/smsusb.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 449ef0f1e..73084f795 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -601,7 +601,7 @@ static int smscore_load_firmware_from_file(struct smscore_device_t *coredev, sms_info("failed to open \"%s\"", filename); return rc; } - sms_info("read FW %s, size=%d", filename, fw->size); + sms_info("read FW %s, size=%zd", filename, fw->size); fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT), GFP_KERNEL | GFP_DMA); if (fw_buffer) { diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index ca9eb7820..2e362c8aa 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -213,14 +213,14 @@ static int smsusb1_load_firmware(struct usb_device *udev, int id) rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000); - sms_info("sent %d(%d) bytes, rc %d", fw->size, dummy, rc); + sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc); kfree(fw_buffer); } else { sms_err("failed to allocate firmware buffer"); rc = -ENOMEM; } - sms_info("read FW %s, size=%d", smsusb1_fw_lkup[id], fw->size); + sms_info("read FW %s, size=%zd", smsusb1_fw_lkup[id], fw->size); release_firmware(fw); -- cgit v1.2.3 From d5adaf8e55c09e9cdbebdf118f9245a012d04650 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 19:27:19 -0400 Subject: sms1xxx: log firmware download process by default From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 14 +++++++++----- linux/drivers/media/dvb/siano/smscoreapi.h | 4 ++-- 2 files changed, 11 insertions(+), 7 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 73084f795..24de12f35 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -791,19 +791,23 @@ int smscore_set_device_mode(struct smscore_device_t *coredev, int mode) rc = smscore_load_firmware_from_file(coredev, fw_filename, NULL); if (rc < 0) { - sms_err("error %d loading firmware: %s, " - "trying again with default firmware", - rc, fw_filename); + sms_warn("error %d loading firmware: %s, " + "trying again with default firmware", + rc, fw_filename); /* try again with the default firmware */ + fw_filename = smscore_fw_lkup[mode][type]; rc = smscore_load_firmware_from_file(coredev, - smscore_fw_lkup[mode][type], NULL); + fw_filename, NULL); if (rc < 0) { - sms_err("load firmware failed %d", rc); + sms_warn("error %d loading " + "firmware: %s", rc, + fw_filename); return rc; } } + sms_log("firmware download success: %s", fw_filename); } else sms_info("mode %d supported by running " "firmware", mode); diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 78afcc913..ffac3fd09 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -591,10 +591,10 @@ extern int sms_debug; if (sms_debug & lvl) \ sms_printk(kern, fmt, ##arg); } while (0) +#define sms_log(fmt, arg...) sms_printk(KERN_INFO, fmt, ##arg) #define sms_err(fmt, arg...) \ sms_printk(KERN_ERR, "line: %d: " fmt, __LINE__, ##arg) -#define sms_warn(fmt, arg...) \ - sms_printk(KERN_WARNING, "line: %d: " fmt, __LINE__, ##arg) +#define sms_warn(fmt, arg...) sms_printk(KERN_WARNING, fmt, ##arg) #define sms_info(fmt, arg...) \ dprintk(KERN_INFO, DBG_INFO, fmt, ##arg) #define sms_debug(fmt, arg...) \ -- cgit v1.2.3 From 7e1badf9cce00a874b2a20d31a22f932576527c4 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 21:33:23 -0400 Subject: sms1xxx: change smsusb_driver.name to sms1xxx From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smsusb.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index 2e362c8aa..e8c3a11e9 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -419,7 +419,7 @@ static void smsusb_disconnect(struct usb_interface *intf) } static struct usb_driver smsusb_driver = { - .name = "smsusb", + .name = "sms1xxx", .probe = smsusb_probe, .disconnect = smsusb_disconnect, .id_table = smsusb_id_table, -- cgit v1.2.3 From fcf27330cc0a45714010bc4ad6f48501b445e833 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 19:53:51 -0400 Subject: sms1xxx: Provide option to support Siano default usb ids From: Michael Krufky Provide an option to enable / disable support for Siano's default usb ids. This allows the support for Siano's USB IDs to be disabled, so that Siano's external driver can be used, instead. Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/Kconfig | 20 +++++++++++++++----- linux/drivers/media/dvb/siano/sms-cards.c | 2 ++ 2 files changed, 17 insertions(+), 5 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/Kconfig b/linux/drivers/media/dvb/siano/Kconfig index 878d48c1c..dd863f261 100644 --- a/linux/drivers/media/dvb/siano/Kconfig +++ b/linux/drivers/media/dvb/siano/Kconfig @@ -3,14 +3,24 @@ # config DVB_SIANO_SMS1XXX - tristate "Siano SMS1xxx USB dongle support" + tristate "Siano SMS1XXX USB dongle support" depends on DVB_CORE && USB ---help--- - Choose Y here if you have USB dongle with SMS1xxx chipset. - - Further documentation on this driver can be found on the WWW at - . + Choose Y here if you have a USB dongle with a SMS1XXX chipset. To compile this driver as a module, choose M here: the module will be called sms1xxx. +config DVB_SIANO_SMS1XXX_SMS_IDS + bool "Enable support for Siano Mobile Silicon default USB IDs" + depends on DVB_SIANO_SMS1XXX + default y + ---help--- + Choose Y here if you have a USB dongle with a SMS1XXX chipset + that uses Siano Mobile Silicon's default usb vid:pid. + + Choose N here if you would prefer to use Siano's external driver. + + Further documentation on this driver can be found on the WWW at + . + diff --git a/linux/drivers/media/dvb/siano/sms-cards.c b/linux/drivers/media/dvb/siano/sms-cards.c index 6a22ec10f..c4c9ab023 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.c +++ b/linux/drivers/media/dvb/siano/sms-cards.c @@ -20,6 +20,7 @@ #include "sms-cards.h" struct usb_device_id smsusb_id_table[] = { +#ifdef CONFIG_DVB_SIANO_SMS1XXX_SMS_IDS { USB_DEVICE(0x187f, 0x0010), .driver_info = SMS1XXX_BOARD_SIANO_STELLAR }, { USB_DEVICE(0x187f, 0x0100), @@ -30,6 +31,7 @@ struct usb_device_id smsusb_id_table[] = { .driver_info = SMS1XXX_BOARD_SIANO_NOVA_B }, { USB_DEVICE(0x187f, 0x0300), .driver_info = SMS1XXX_BOARD_SIANO_VEGA }, +#endif { } /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, smsusb_id_table); -- cgit v1.2.3 From d4ccf4a32eb40353ac0e5f477f5cb5dbe61cfada Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 29 Jun 2008 10:45:37 -0400 Subject: sms1xxx: fix OOPS on 64 bit kernels due to a bad cast From: Michael Krufky Fix the following build warning: smscoreapi.c: In function 'smscore_detect_mode': smscoreapi.c:689: warning: cast from pointer to integer of different size smscoreapi.c:689: warning: cast to pointer from integer of different size smscoreapi.c: In function 'smscore_set_device_mode': smscoreapi.c:820: warning: cast from pointer to integer of different size smscoreapi.c:820: warning: cast to pointer from integer of different size ...and fix the following OOPS on 64bit kernels: [ 717.263667] usb 6-4: new high speed USB device using ehci_hcd and address 2 [ 717.396386] usb 6-4: configuration #1 chosen from 1 choice [ 717.473650] Unable to handle kernel paging request at 0000000000c02000 RIP: [ 717.473657] [] :sms1xxx:smscore_set_device_mode+0x22c/0x4a0 [ 717.473669] PGD 3c6f7067 PUD 3d484067 PMD 0 [ 717.473674] Oops: 0002 [1] SMP [ 717.473678] CPU 0 [Modules linked in snipped] [ 717.473773] Pid: 8380, comm: modprobe Tainted: P 2.6.24-16-generic #1 [ 717.473776] RIP: 0010:[] [] :sms1xxx:smscore_set_device_mode+0x22c/0x4a0 [ 717.473784] RSP: 0018:ffff81003d495ba8 EFLAGS: 00010206 [ 717.473786] RAX: ffff81003d8cd8d0 RBX: ffff81003d8cd800 RCX: ffff81003d8cd8d0 [ 717.473788] RDX: 0000000000000008 RSI: ffff81003f080070 RDI: ffff81003d8cd800 [ 717.473791] RBP: 0000000000000004 R08: ffff81003ec0104b R09: ffffffffffffffff [ 717.473793] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000c02000 [ 717.473796] R13: 00000000fffffff4 R14: ffff810000c02000 R15: ffff81003d8cd878 [ 717.473799] FS: 00007f70a680f6e0(0000) GS:ffffffff805b0000(0000) knlGS:0000000000000000 [ 717.473801] CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b [ 717.473804] CR2: 0000000000c02000 CR3: 000000003c68b000 CR4: 00000000000006e0 [ 717.473806] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 717.473809] DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400 [ 717.473812] Process modprobe (pid: 8380, threadinfo ffff81003d494000, task ffff81003d2fc000) [ 717.473814] Stack: ffff81003d8cd800 ffff81003d8cd800 0000000000000000 ffff81003c6d8000 [ 717.473820] ffff81003dcac800 0000000000000008 ffffc20000787bb0 ffffffff88dba16c [ 717.473825] ffff81003dcac800 000000000000000a 0000000000000000 ffffffff88dbb2fa [ 717.473829] Call Trace: [ 717.473866] [] :sms1xxx:smscore_start_device+0x1c/0xb0 [ 717.473885] [] :sms1xxx:smsusb_probe+0x29a/0x670 [ 717.473929] [] :sms1xxx:smsusb_sendrequest+0x0/0x30 [ 717.473965] [] mutex_lock+0x9/0x20 [ 717.473998] [] :usbcore:usb_autopm_do_device+0x8e/0x130 [ 717.474040] [] :usbcore:usb_probe_interface+0xda/0x160 [ 717.474067] [] driver_probe_device+0x9c/0x1b0 [ 717.474091] [] __driver_attach+0xc9/0xd0 [ 717.474107] [] __driver_attach+0x0/0xd0 [ 717.474115] [] bus_for_each_dev+0x4d/0x80 [ 717.474156] [] bus_add_driver+0xac/0x220 [ 717.474203] [] :usbcore:usb_register_driver+0xa9/0x120 [ 717.474232] [] :sms1xxx:smsusb_register+0x1b/0x70 [ 717.474243] [] :sms1xxx:smscore_module_init+0x7c/0xb0 [ 717.474253] [] sys_init_module+0x18e/0x1a90 [ 717.474426] [] system_call+0x7e/0x83 [ 717.474490] [ 717.474491] [ 717.474492] Code: 66 41 c7 04 24 9c 02 41 c6 44 24 02 00 4c 89 e6 41 c6 44 24 [ 717.474506] RIP [] :sms1xxx:smscore_set_device_mode+0x22c/0x4a0 [ 717.474513] RSP [ 717.474515] CR2: 0000000000c02000 [ 717.474521] ---[ end trace 52d9c6f207be106a ]--- Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index ffac3fd09..49e8936ff 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -50,7 +50,7 @@ typedef struct mutex kmutex_t; #define SMS_ALLOC_ALIGNMENT 128 #define SMS_DMA_ALIGNMENT 16 #define SMS_ALIGN_ADDRESS(addr) \ - ((((u32)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) + ((((uintptr_t)(addr)) + (SMS_DMA_ALIGNMENT-1)) & ~(SMS_DMA_ALIGNMENT-1)) #define SMS_DEVICE_FAMILY2 1 #define SMS_ROM_NO_RESPONSE 2 -- cgit v1.2.3 From e2049a567720df0a7865db90a946af608831faf4 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sun, 29 Jun 2008 11:15:19 -0400 Subject: sms1xxx: remove kmutex_t typedef From: Michael Krufky remove typedef struct mutex kmutex_t fix one line > 80 columns Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smscoreapi.c | 4 ++-- linux/drivers/media/dvb/siano/smscoreapi.h | 5 ++--- linux/drivers/media/dvb/siano/smsdvb.c | 2 +- 3 files changed, 5 insertions(+), 6 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smscoreapi.c b/linux/drivers/media/dvb/siano/smscoreapi.c index 24de12f35..549332b53 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.c +++ b/linux/drivers/media/dvb/siano/smscoreapi.c @@ -112,10 +112,10 @@ struct smscore_registry_entry_t { struct list_head g_smscore_notifyees; struct list_head g_smscore_devices; -kmutex_t g_smscore_deviceslock; +struct mutex g_smscore_deviceslock; struct list_head g_smscore_registry; -kmutex_t g_smscore_registrylock; +struct mutex g_smscore_registrylock; static int default_mode = 4; diff --git a/linux/drivers/media/dvb/siano/smscoreapi.h b/linux/drivers/media/dvb/siano/smscoreapi.h index 49e8936ff..d49bd5012 100644 --- a/linux/drivers/media/dvb/siano/smscoreapi.h +++ b/linux/drivers/media/dvb/siano/smscoreapi.h @@ -36,8 +36,6 @@ #include -typedef struct mutex kmutex_t; - #define kmutex_init(_p_) mutex_init(_p_) #define kmutex_lock(_p_) mutex_lock(_p_) #define kmutex_trylock(_p_) mutex_trylock(_p_) @@ -562,7 +560,8 @@ extern int smscore_map_common_buffer(struct smscore_device_t *coredev, struct vm_area_struct *vma); #endif -extern struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev); +extern +struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev); extern void smscore_putbuffer(struct smscore_device_t *coredev, struct smscore_buffer_t *cb); diff --git a/linux/drivers/media/dvb/siano/smsdvb.c b/linux/drivers/media/dvb/siano/smsdvb.c index c3b0fdf63..2da99f19e 100644 --- a/linux/drivers/media/dvb/siano/smsdvb.c +++ b/linux/drivers/media/dvb/siano/smsdvb.c @@ -28,7 +28,7 @@ DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); struct list_head g_smsdvb_clients; -kmutex_t g_smsdvb_clientslock; +struct mutex g_smsdvb_clientslock; static int smsdvb_onresponse(void *context, struct smscore_buffer_t *cb) { -- cgit v1.2.3 From c5b49b860f6d546b5c4c2a7d38d4d982d20d9c17 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Tue, 1 Jul 2008 00:35:26 -0400 Subject: sms1xxx: support device-specific firmware filenames on stellar usb1 sticks From: Michael Krufky Add the capability to define device-specific firmware filenames for the SMS1010, with a mechanism to fall back to the generic firmware if the device-specific firmware is not present. Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/smsusb.c | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/smsusb.c b/linux/drivers/media/dvb/siano/smsusb.c index e8c3a11e9..079deb2a1 100644 --- a/linux/drivers/media/dvb/siano/smsusb.c +++ b/linux/drivers/media/dvb/siano/smsusb.c @@ -188,22 +188,39 @@ static char *smsusb1_fw_lkup[] = { "dvbt_bda_stellar_usb.inp", }; -static int smsusb1_load_firmware(struct usb_device *udev, int id) +static inline char *sms_get_fw_name(int mode, int board_id) +{ + char **fw = sms_get_board(board_id)->fw; + return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode]; +} + +static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id) { const struct firmware *fw; u8 *fw_buffer; int rc, dummy; + char *fw_filename; if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) { sms_err("invalid firmware id specified %d", id); return -EINVAL; } - rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev); + fw_filename = sms_get_fw_name(id, board_id); + + rc = request_firmware(&fw, fw_filename, &udev->dev); if (rc < 0) { - sms_err("failed to open \"%s\" mode %d", - smsusb1_fw_lkup[id], id); - return rc; + sms_warn("failed to open \"%s\" mode %d, " + "trying again with default firmware", fw_filename, id); + + fw_filename = smsusb1_fw_lkup[id]; + rc = request_firmware(&fw, fw_filename, &udev->dev); + if (rc < 0) { + sms_warn("failed to open \"%s\" mode %d", + fw_filename, id); + + return rc; + } } fw_buffer = kmalloc(fw->size, GFP_KERNEL); @@ -220,7 +237,7 @@ static int smsusb1_load_firmware(struct usb_device *udev, int id) sms_err("failed to allocate firmware buffer"); rc = -ENOMEM; } - sms_info("read FW %s, size=%zd", smsusb1_fw_lkup[id], fw->size); + sms_info("read FW %s, size=%zd", fw_filename, fw->size); release_firmware(fw); @@ -405,7 +422,8 @@ static int smsusb_probe(struct usb_interface *intf, udev->bus->busnum, udev->devpath); sms_info("stellar device was found."); return smsusb1_load_firmware( - udev, smscore_registry_getmode(devpath)); + udev, smscore_registry_getmode(devpath), + id->driver_info); } rc = smsusb_init_device(intf, id->driver_info); -- cgit v1.2.3 From a795d540c3c53493b00302658a56c8a546d1a5d0 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Tue, 1 Jul 2008 00:47:10 -0400 Subject: sms1xxx: add firmware filenames to board properties for stellar and nova From: Michael Krufky Assign the following firmware filenames: sms1xxx-stellar-dvbt-01.fw sms1xxx-nova-a-dvbt-01.fw sms1xxx-nova-b-dvbt-01.fw Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/sms-cards.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/sms-cards.c b/linux/drivers/media/dvb/siano/sms-cards.c index c4c9ab023..c75c27c18 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.c +++ b/linux/drivers/media/dvb/siano/sms-cards.c @@ -43,14 +43,17 @@ static struct sms_board sms_boards[] = { [SMS1XXX_BOARD_SIANO_STELLAR] = { .name = "Siano Stellar Digital Receiver", .type = SMS_STELLAR, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-stellar-dvbt-01.fw", }, [SMS1XXX_BOARD_SIANO_NOVA_A] = { .name = "Siano Nova A Digital Receiver", .type = SMS_NOVA_A0, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-nova-a-dvbt-01.fw", }, [SMS1XXX_BOARD_SIANO_NOVA_B] = { .name = "Siano Nova B Digital Receiver", .type = SMS_NOVA_B0, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-nova-b-dvbt-01.fw", }, [SMS1XXX_BOARD_SIANO_VEGA] = { .name = "Siano Vega Digital Receiver", -- cgit v1.2.3 From 975dc74c7c82cd5225c78357f4a02f37b432b6f2 Mon Sep 17 00:00:00 2001 From: Michael Krufky Date: Sat, 28 Jun 2008 19:55:36 -0400 Subject: sms1xxx: add support for Hauppauge WinTV-Nova-T-MiniStick From: Michael Krufky Signed-off-by: Michael Krufky --- linux/drivers/media/dvb/siano/sms-cards.c | 32 +++++++++++++++++++++++++++++++ linux/drivers/media/dvb/siano/sms-cards.h | 4 ++++ 2 files changed, 36 insertions(+) (limited to 'linux') diff --git a/linux/drivers/media/dvb/siano/sms-cards.c b/linux/drivers/media/dvb/siano/sms-cards.c index c75c27c18..e7a8ac0c4 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.c +++ b/linux/drivers/media/dvb/siano/sms-cards.c @@ -32,6 +32,18 @@ struct usb_device_id smsusb_id_table[] = { { USB_DEVICE(0x187f, 0x0300), .driver_info = SMS1XXX_BOARD_SIANO_VEGA }, #endif + { USB_DEVICE(0x2040, 0x1700), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT }, + { USB_DEVICE(0x2040, 0x1800), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A }, + { USB_DEVICE(0x2040, 0x1801), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B }, + { USB_DEVICE(0x2040, 0x5500), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, + { USB_DEVICE(0x2040, 0x5580), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, + { USB_DEVICE(0x2040, 0x5590), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, { } /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, smsusb_id_table); @@ -59,6 +71,26 @@ static struct sms_board sms_boards[] = { .name = "Siano Vega Digital Receiver", .type = SMS_VEGA, }, + [SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT] = { + .name = "Hauppauge Catamount", + .type = SMS_STELLAR, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-stellar-dvbt-01.fw", + }, + [SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A] = { + .name = "Hauppauge Okemo-A", + .type = SMS_NOVA_A0, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-nova-a-dvbt-01.fw", + }, + [SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B] = { + .name = "Hauppauge Okemo-B", + .type = SMS_NOVA_B0, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-nova-b-dvbt-01.fw", + }, + [SMS1XXX_BOARD_HAUPPAUGE_WINDHAM] = { + .name = "Hauppauge WinTV-Nova-T-MiniStick", + .type = SMS_NOVA_B0, + .fw[DEVICE_MODE_DVBT_BDA] = "sms1xxx-hcw-55xxx-dvbt-01.fw", + }, }; struct sms_board *sms_get_board(int id) diff --git a/linux/drivers/media/dvb/siano/sms-cards.h b/linux/drivers/media/dvb/siano/sms-cards.h index 262e3ffbc..83b39bc20 100644 --- a/linux/drivers/media/dvb/siano/sms-cards.h +++ b/linux/drivers/media/dvb/siano/sms-cards.h @@ -28,6 +28,10 @@ #define SMS1XXX_BOARD_SIANO_NOVA_A 2 #define SMS1XXX_BOARD_SIANO_NOVA_B 3 #define SMS1XXX_BOARD_SIANO_VEGA 4 +#define SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT 5 +#define SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A 6 +#define SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B 7 +#define SMS1XXX_BOARD_HAUPPAUGE_WINDHAM 8 struct sms_board { enum sms_device_type_st type; -- cgit v1.2.3 From a5ceec5c035de3f849419096383b0ce46f8ff170 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Fri, 11 Jul 2008 10:48:02 -0300 Subject: saa7134: add support for AVerMedia M103 From: Massimo Piccioni The following patch updates saa7134 driver to add support for AVerMedia M103 MiniPCI DVB-T Hybrid card. Signed-off-by: Massimo Piccioni [mchehab@infradead.org: fixed merge conflicts and a small codingstyle] Signed-off-by: Mauro Carvalho Chehab --- linux/Documentation/video4linux/CARDLIST.saa7134 | 1 + linux/drivers/media/video/saa7134/saa7134-cards.c | 25 +++++++++++++++++++++++ linux/drivers/media/video/saa7134/saa7134-dvb.c | 10 +++++++++ linux/drivers/media/video/saa7134/saa7134.h | 1 + 4 files changed, 37 insertions(+) (limited to 'linux') diff --git a/linux/Documentation/video4linux/CARDLIST.saa7134 b/linux/Documentation/video4linux/CARDLIST.saa7134 index f58192276..171905e87 100644 --- a/linux/Documentation/video4linux/CARDLIST.saa7134 +++ b/linux/Documentation/video4linux/CARDLIST.saa7134 @@ -143,3 +143,4 @@ 142 -> Beholder BeholdTV H6 [5ace:6290] 143 -> Beholder BeholdTV M63 [5ace:6191] 144 -> Beholder BeholdTV M6 Extra [5ace:6193] +145 -> AVerMedia MiniPCI DVB-T Hybrid M103 [1461:f636] diff --git a/linux/drivers/media/video/saa7134/saa7134-cards.c b/linux/drivers/media/video/saa7134/saa7134-cards.c index f772e9da9..a2a4ca6f8 100644 --- a/linux/drivers/media/video/saa7134/saa7134-cards.c +++ b/linux/drivers/media/video/saa7134/saa7134-cards.c @@ -1287,6 +1287,22 @@ struct saa7134_board saa7134_boards[] = { .vmux = 8, }}, }, + [SAA7134_BOARD_AVERMEDIA_M103] = { + /* Massimo Piccioni */ + .name = "AVerMedia MiniPCI DVB-T Hybrid M103", + .audio_clock = 0x187de7, + .tuner_type = TUNER_XC2028, + .radio_type = UNSET, + .tuner_addr = ADDR_UNSET, + .radio_addr = ADDR_UNSET, + .mpeg = SAA7134_MPEG_DVB, + .inputs = {{ + .name = name_tv, + .vmux = 1, + .amux = TV, + .tv = 1, + } }, + }, [SAA7134_BOARD_NOVAC_PRIMETV7133] = { /* toshii@netbsd.org */ .name = "Noval Prime TV 7133", @@ -5415,6 +5431,12 @@ struct pci_device_id saa7134_pci_tbl[] = { .subvendor = 0x5ace, .subdevice = 0x6290, .driver_data = SAA7134_BOARD_BEHOLD_H6, + }, { + .vendor = PCI_VENDOR_ID_PHILIPS, + .device = PCI_DEVICE_ID_PHILIPS_SAA7133, + .subvendor = 0x1461, /* Avermedia Technologies Inc */ + .subdevice = 0xf636, + .driver_data = SAA7134_BOARD_AVERMEDIA_M103, }, { /* --- boards without eeprom + subsystem ID --- */ .vendor = PCI_VENDOR_ID_PHILIPS, @@ -5517,6 +5539,7 @@ static int saa7134_xc2028_callback(struct saa7134_dev *dev, saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00008000, 0x00008000); switch (dev->board) { case SAA7134_BOARD_AVERMEDIA_CARDBUS_506: + case SAA7134_BOARD_AVERMEDIA_M103: saa7134_set_gpio(dev, 23, 0); msleep(10); saa7134_set_gpio(dev, 23, 1); @@ -5750,6 +5773,7 @@ int saa7134_board_init1(struct saa7134_dev *dev) msleep(10); break; case SAA7134_BOARD_AVERMEDIA_CARDBUS_506: + case SAA7134_BOARD_AVERMEDIA_M103: saa7134_set_gpio(dev, 23, 0); msleep(10); saa7134_set_gpio(dev, 23, 1); @@ -5877,6 +5901,7 @@ static void saa7134_tuner_setup(struct saa7134_dev *dev) switch (dev->board) { case SAA7134_BOARD_AVERMEDIA_A16D: case SAA7134_BOARD_AVERMEDIA_CARDBUS_506: + case SAA7134_BOARD_AVERMEDIA_M103: ctl.demod = XC3028_FE_ZARLINK456; break; default: diff --git a/linux/drivers/media/video/saa7134/saa7134-dvb.c b/linux/drivers/media/video/saa7134/saa7134-dvb.c index 3cadbad1d..ef8baf5fe 100644 --- a/linux/drivers/media/video/saa7134/saa7134-dvb.c +++ b/linux/drivers/media/video/saa7134/saa7134-dvb.c @@ -1263,6 +1263,7 @@ static int dvb_init(struct saa7134_dev *dev) &avermedia_xc3028_mt352_dev, &dev->i2c_adap); attach_xc3028 = 1; + break; #if 0 /*FIXME: What frontend does Videomate T750 use? */ case SAA7134_BOARD_VIDEOMATE_T750: @@ -1294,6 +1295,15 @@ static int dvb_init(struct saa7134_dev *dev) fe->ops.enable_high_lnb_voltage = md8800_set_high_voltage; } break; + case SAA7134_BOARD_AVERMEDIA_M103: + saa7134_set_gpio(dev, 25, 0); + msleep(10); + saa7134_set_gpio(dev, 25, 1); + dev->dvb.frontend = dvb_attach(mt352_attach, + &avermedia_xc3028_mt352_dev, + &dev->i2c_adap); + attach_xc3028 = 1; + break; default: wprintk("Huh? unknown DVB card?\n"); break; diff --git a/linux/drivers/media/video/saa7134/saa7134.h b/linux/drivers/media/video/saa7134/saa7134.h index 6afbc0c57..4a9bebb2d 100644 --- a/linux/drivers/media/video/saa7134/saa7134.h +++ b/linux/drivers/media/video/saa7134/saa7134.h @@ -267,6 +267,7 @@ struct saa7134_format { #define SAA7134_BOARD_BEHOLD_H6 142 #define SAA7134_BOARD_BEHOLD_M63 143 #define SAA7134_BOARD_BEHOLD_M6_EXTRA 144 +#define SAA7134_BOARD_AVERMEDIA_M103 145 #define SAA7134_MAXBOARDS 8 #define SAA7134_INPUT_MAX 8 -- cgit v1.2.3 From 7c2a3644e8d27896e8a68605291abaa88e47a0a2 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Thu, 10 Jul 2008 11:04:10 +0000 Subject: ovcamchip: Delete stray I2C bus ID From: Jean Delvare I2C_HW_SMBUS_OVFX2 is referenced in ovcamchip_core.c, but no bus uses this driver ID, so we can remove the reference. As far as I can see, the Cypress FX2 webcam is handled by a different driver (dvb-usb). Signed-off-by: Jean Delvare Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/ovcamchip/ovcamchip_core.c | 1 - linux/include/linux/i2c-id.h | 1 - 2 files changed, 2 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/ovcamchip/ovcamchip_core.c b/linux/drivers/media/video/ovcamchip/ovcamchip_core.c index 8063e33f1..065c24541 100644 --- a/linux/drivers/media/video/ovcamchip/ovcamchip_core.c +++ b/linux/drivers/media/video/ovcamchip/ovcamchip_core.c @@ -297,7 +297,6 @@ static int ovcamchip_attach(struct i2c_adapter *adap) switch (adap->id) { case I2C_HW_SMBUS_OV511: case I2C_HW_SMBUS_OV518: - case I2C_HW_SMBUS_OVFX2: case I2C_HW_SMBUS_W9968CF: PDEBUG(1, "Adapter ID 0x%06x accepted", adap->id); break; diff --git a/linux/include/linux/i2c-id.h b/linux/include/linux/i2c-id.h index 580acc939..1a801a90a 100644 --- a/linux/include/linux/i2c-id.h +++ b/linux/include/linux/i2c-id.h @@ -161,7 +161,6 @@ #define I2C_HW_SMBUS_W9968CF 0x04000d #define I2C_HW_SMBUS_OV511 0x04000e /* OV511(+) USB 1.1 webcam ICs */ #define I2C_HW_SMBUS_OV518 0x04000f /* OV518(+) USB 1.1 webcam ICs */ -#define I2C_HW_SMBUS_OVFX2 0x040011 /* Cypress/OmniVision FX2 webcam */ #define I2C_HW_SMBUS_CAFE 0x040012 /* Marvell 88ALP01 "CAFE" cam */ #define I2C_HW_SMBUS_ALI1563 0x040013 -- cgit v1.2.3 From 4d7cdce47baec61a2baa0dcaf2253454cadfb284 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Thu, 10 Jul 2008 11:23:37 +0000 Subject: tvaudio: Stop I2C driver ID abuse From: Jean Delvare The tvaudio driver is using "official" I2C device IDs for internal purpose. There must be some historical reason behind this but anyway, it shouldn't do that. As the stored values are never used, the easiest way to fix the problem is simply to remove them altogether. Signed-off-by: Jean Delvare Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/tvaudio.c | 13 ------------- linux/include/linux/i2c-id.h | 7 ------- 2 files changed, 20 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/tvaudio.c b/linux/drivers/media/video/tvaudio.c index 84e2c43b7..53ece95db 100644 --- a/linux/drivers/media/video/tvaudio.c +++ b/linux/drivers/media/video/tvaudio.c @@ -72,7 +72,6 @@ typedef struct AUDIOCMD { /* chip description */ struct CHIPDESC { char *name; /* chip name */ - int id; /* ID */ int addr_lo, addr_hi; /* i2c address range */ int registers; /* # of registers */ @@ -1264,7 +1263,6 @@ module_param(ta8874z, int, 0444); static struct CHIPDESC chiplist[] = { { .name = "tda9840", - .id = I2C_DRIVERID_TDA9840, .insmodopt = &tda9840, .addr_lo = I2C_ADDR_TDA9840 >> 1, .addr_hi = I2C_ADDR_TDA9840 >> 1, @@ -1280,7 +1278,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tda9873h", - .id = I2C_DRIVERID_TDA9873, .checkit = tda9873_checkit, .insmodopt = &tda9873, .addr_lo = I2C_ADDR_TDA985x_L >> 1, @@ -1301,7 +1298,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tda9874h/a", - .id = I2C_DRIVERID_TDA9874, .checkit = tda9874a_checkit, .initialize = tda9874a_initialize, .insmodopt = &tda9874a, @@ -1314,7 +1310,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tda9850", - .id = I2C_DRIVERID_TDA9850, .insmodopt = &tda9850, .addr_lo = I2C_ADDR_TDA985x_L >> 1, .addr_hi = I2C_ADDR_TDA985x_H >> 1, @@ -1327,7 +1322,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tda9855", - .id = I2C_DRIVERID_TDA9855, .insmodopt = &tda9855, .addr_lo = I2C_ADDR_TDA985x_L >> 1, .addr_hi = I2C_ADDR_TDA985x_H >> 1, @@ -1352,7 +1346,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tea6300", - .id = I2C_DRIVERID_TEA6300, .insmodopt = &tea6300, .addr_lo = I2C_ADDR_TEA6300 >> 1, .addr_hi = I2C_ADDR_TEA6300 >> 1, @@ -1373,7 +1366,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tea6320", - .id = I2C_DRIVERID_TEA6300, .initialize = tea6320_initialize, .insmodopt = &tea6320, .addr_lo = I2C_ADDR_TEA6300 >> 1, @@ -1395,7 +1387,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tea6420", - .id = I2C_DRIVERID_TEA6420, .insmodopt = &tea6420, .addr_lo = I2C_ADDR_TEA6420 >> 1, .addr_hi = I2C_ADDR_TEA6420 >> 1, @@ -1408,7 +1399,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "tda8425", - .id = I2C_DRIVERID_TDA8425, .insmodopt = &tda8425, .addr_lo = I2C_ADDR_TDA8425 >> 1, .addr_hi = I2C_ADDR_TDA8425 >> 1, @@ -1432,7 +1422,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "pic16c54 (PV951)", - .id = I2C_DRIVERID_PIC16C54_PV9, .insmodopt = &pic16c54, .addr_lo = I2C_ADDR_PIC16C54 >> 1, .addr_hi = I2C_ADDR_PIC16C54>> 1, @@ -1448,8 +1437,6 @@ static struct CHIPDESC chiplist[] = { }, { .name = "ta8874z", - .id = -1, - /*.id = I2C_DRIVERID_TA8874Z, */ .checkit = ta8874z_checkit, .insmodopt = &ta8874z, .addr_lo = I2C_ADDR_TDA9840 >> 1, diff --git a/linux/include/linux/i2c-id.h b/linux/include/linux/i2c-id.h index 1a801a90a..3db09bc06 100644 --- a/linux/include/linux/i2c-id.h +++ b/linux/include/linux/i2c-id.h @@ -33,15 +33,11 @@ #define I2C_DRIVERID_MSP3400 1 #define I2C_DRIVERID_TUNER 2 -#define I2C_DRIVERID_TDA8425 4 /* stereo sound processor */ #define I2C_DRIVERID_TEA6420 5 /* audio matrix switch */ #define I2C_DRIVERID_TEA6415C 6 /* video matrix switch */ #define I2C_DRIVERID_TDA9840 7 /* stereo sound processor */ #define I2C_DRIVERID_SAA7111A 8 /* video input processor */ #define I2C_DRIVERID_SAA7185B 13 /* video encoder */ -#define I2C_DRIVERID_TEA6300 18 /* audio mixer */ -#define I2C_DRIVERID_TDA9850 20 /* audio mixer */ -#define I2C_DRIVERID_TDA9855 21 /* audio mixer */ #define I2C_DRIVERID_SAA7110 22 /* video decoder */ #define I2C_DRIVERID_MGATVO 23 /* Matrox TVOut */ #define I2C_DRIVERID_SAA5249 24 /* SAA5249 and compatibles */ @@ -50,9 +46,7 @@ #define I2C_DRIVERID_TDA7432 27 /* Stereo sound processor */ #define I2C_DRIVERID_TVMIXER 28 /* Mixer driver for tv cards */ #define I2C_DRIVERID_TVAUDIO 29 /* Generic TV sound driver */ -#define I2C_DRIVERID_TDA9873 31 /* TV sound decoder chip */ #define I2C_DRIVERID_TDA9875 32 /* TV sound decoder chip */ -#define I2C_DRIVERID_PIC16C54_PV9 33 /* Audio mux/ir receiver */ #define I2C_DRIVERID_BT819 40 /* video decoder */ #define I2C_DRIVERID_BT856 41 /* video encoder */ #define I2C_DRIVERID_VPX3220 42 /* video decoder+vbi/vtxt */ @@ -63,7 +57,6 @@ #define I2C_DRIVERID_INDYCAM 58 /* SGI IndyCam */ #define I2C_DRIVERID_OVCAMCHIP 61 /* OmniVision CMOS image sens. */ #define I2C_DRIVERID_MAX6900 63 /* MAX6900 real-time clock */ -#define I2C_DRIVERID_TDA9874 66 /* TV sound decoder */ #define I2C_DRIVERID_SAA6752HS 67 /* MPEG2 encoder */ #define I2C_DRIVERID_TVEEPROM 68 /* TV EEPROM */ #define I2C_DRIVERID_WM8775 69 /* wm8775 audio processor */ -- cgit v1.2.3 From 9a6778b1591ecd3b9013907a600859a5faf0da00 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Tue, 8 Jul 2008 15:56:04 +0000 Subject: Fix a const pointer assignment error in the drx397xD demodulator driver From: David Howells Fix an assignment of a const pointer to a non-const pointer in the drx397xD demodulator driver. This was introduced in patch eb9bd0e567365d4f607d32d8c41e201da65aa971. Signed-off-by: David Howells Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/dvb/frontends/drx397xD.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/frontends/drx397xD.c b/linux/drivers/media/dvb/frontends/drx397xD.c index 327fff4b8..52a9a6553 100644 --- a/linux/drivers/media/dvb/frontends/drx397xD.c +++ b/linux/drivers/media/dvb/frontends/drx397xD.c @@ -74,7 +74,7 @@ static struct { const struct firmware *file; rwlock_t lock; int refcnt; - u8 *data[ARRAY_SIZE(blob_name)]; + const u8 *data[ARRAY_SIZE(blob_name)]; } fw[] = { #define _FW_ENTRY(a, b) { \ .name = a, \ @@ -110,7 +110,7 @@ static void drx_release_fw(struct drx397xD_state *s) static int drx_load_fw(struct drx397xD_state *s, fw_ix_t ix) { - u8 *data; + const u8 *data; size_t size, len; int i = 0, j, rc = -EINVAL; @@ -194,7 +194,7 @@ static int drx_load_fw(struct drx397xD_state *s, fw_ix_t ix) static int write_fw(struct drx397xD_state *s, blob_ix_t ix) { struct i2c_msg msg = {.addr = s->config.demod_address,.flags = 0 }; - u8 *data; + const u8 *data; int len, rc = 0, i = 0; if (ix < 0 || ix >= ARRAY_SIZE(blob_name)) { @@ -215,7 +215,7 @@ static int write_fw(struct drx397xD_state *s, blob_ix_t ix) case 0: /* bytecode */ len = data[i++]; msg.len = len; - msg.buf = &data[i]; + msg.buf = (__u8 *) &data[i]; if (i2c_transfer(s->i2c, &msg, 1) != 1) { rc = -EIO; goto exit_rc; -- cgit v1.2.3 From 13a2a4d90910fc22d507fba16d54f6d5eb063013 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Tue, 8 Jul 2008 16:00:43 +0000 Subject: Fix a const pointer error in the Conexant cx23418 MPEG encoder driver From: David Howells Fix a const pointer to non-const pointer assignment error in the Conexant cx23418 MPEG encoder driver. This was introduces in patch 1c1e45d17b663d4749af456ab7c2fc1f36405ef8. Signed-off-by: David Howells Signed-off-by: Hans Verkuil Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/cx18/cx18-av-firmware.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/video/cx18/cx18-av-firmware.c b/linux/drivers/media/video/cx18/cx18-av-firmware.c index 6fa3b01a1..834b92482 100644 --- a/linux/drivers/media/video/cx18/cx18-av-firmware.c +++ b/linux/drivers/media/video/cx18/cx18-av-firmware.c @@ -30,7 +30,7 @@ int cx18_av_loadfw(struct cx18 *cx) const struct firmware *fw = NULL; u32 size; u32 v; - u8 *ptr; + const u8 *ptr; int i; int retries = 0; -- cgit v1.2.3 From b884d16928248c316903c9b1f1483a3586228f65 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Tue, 8 Jul 2008 16:04:38 +0000 Subject: Fix pointer cast warnings in the ivtv framebuffer driver From: David Howells Fix casts of pointers to integers of different sizes in the ivtv framebuffer driver. These were introduced in patch 38eb6ba5b8487d15b020fe391d324edd2b659b03. Signed-off-by: David Howells Signed-off-by: Hans Verkuil Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/ivtv/ivtvfb.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/ivtv/ivtvfb.c b/linux/drivers/media/video/ivtv/ivtvfb.c index 14f93341f..bdfda48e5 100644 --- a/linux/drivers/media/video/ivtv/ivtvfb.c +++ b/linux/drivers/media/video/ivtv/ivtvfb.c @@ -417,10 +417,11 @@ static ssize_t ivtvfb_write(struct fb_info *info, const char __user *buf, if (!err) { /* If transfer size > threshold and both src/dst addresses are aligned, use DMA */ - if (count >= 4096 && ((u32)buf & 3) == ((u32)dst & 3)) { + if (count >= 4096 && + ((unsigned long)buf & 3) == ((unsigned long)dst & 3)) { /* Odd address = can't DMA. Align */ - if ((u32)dst & 3) { - lead = 4 - ((u32)dst & 3); + if ((unsigned long)dst & 3) { + lead = 4 - ((unsigned long)dst & 3); memcpy(dst, buf, lead); buf += lead; dst += lead; -- cgit v1.2.3 From f03368d89250498c6d9f48b12972121c891e5fe2 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Fri, 4 Jul 2008 06:33:20 +0000 Subject: ttusb: use simple_read_from_buffer()() From: Akinobu Mita Signed-off-by: Akinobu Mita Signed-off-by: Andrew Morton Signed-off-by: Mauro Carvalho Chehab --- .../drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c b/linux/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c index 8786d3d6f..133648277 100644 --- a/linux/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c +++ b/linux/drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -988,22 +989,9 @@ static int stc_open(struct inode *inode, struct file *file) } static ssize_t stc_read(struct file *file, char *buf, size_t count, - loff_t * offset) + loff_t *offset) { - int tc = count; - - if ((tc + *offset) > 8192) - tc = 8192 - *offset; - - if (tc < 0) - return 0; - - if (copy_to_user(buf, stc_firmware + *offset, tc)) - return -EFAULT; - - *offset += tc; - - return tc; + return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192); } static int stc_release(struct inode *inode, struct file *file) -- cgit v1.2.3 From 2fac5bc7bdca8405f6dc8cd3f7dea4f9b4d4b1fa Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Fri, 4 Jul 2008 06:33:22 +0000 Subject: buf-dma-sg.c: avoid clearing memory twice From: Christophe Jaillet 1) Remove a useless initialisation of 'i' 2) Avoid clearing the memory allocated twice (once in 'kcalloc', once in 'sg_init_table') 3) Remove a test that can never trigger. The function returns NULL in such a case, so we know that at this point 'pages[0]' != NULL Signed-off-by: Christophe Jaillet Signed-off-by: Andrew Morton Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/videobuf-dma-sg.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/videobuf-dma-sg.c b/linux/drivers/media/video/videobuf-dma-sg.c index 39ae44bda..21194d6fe 100644 --- a/linux/drivers/media/video/videobuf-dma-sg.c +++ b/linux/drivers/media/video/videobuf-dma-sg.c @@ -81,17 +81,15 @@ struct scatterlist* videobuf_pages_to_sg(struct page **pages, int nr_pages, int offset) { struct scatterlist *sglist; - int i = 0; + int i; if (NULL == pages[0]) return NULL; - sglist = kcalloc(nr_pages, sizeof(*sglist), GFP_KERNEL); + sglist = kmalloc(nr_pages * sizeof(*sglist), GFP_KERNEL); if (NULL == sglist) return NULL; sg_init_table(sglist, nr_pages); - if (NULL == pages[0]) - goto nopage; if (PageHighMem(pages[0])) /* DMA to highmem pages might not work */ goto highmem; -- cgit v1.2.3 From eeffde08963e01cb0ba6d6c78932d077e56fb0d8 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Wed, 9 Jul 2008 05:26:26 +0000 Subject: gspca: fix warnings on x86_64 From: Mauro Carvalho Chehab /home/v4l/master/v4l/gspca.c: In function 'gspca_frame_add': /home/v4l/master/v4l/gspca.c:222: warning: format '%d' expects type 'int', but argument 2 has type 'long int' /home/v4l/master/v4l/gspca.c: In function 'dev_read': /home/v4l/master/v4l/gspca.c:1568: warning: format '%d' expects type 'int', but argument 2 has type 'size_t' /home/v4l/master/v4l/gspca.c:1618: warning: format '%d' expects type 'int', but argument 3 has type 'size_t' Acked-by: Jean-Francois Moine Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/gspca/gspca.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/gspca/gspca.c b/linux/drivers/media/video/gspca/gspca.c index 55d4af21e..943c5981f 100644 --- a/linux/drivers/media/video/gspca/gspca.c +++ b/linux/drivers/media/video/gspca/gspca.c @@ -219,7 +219,7 @@ struct gspca_frame *gspca_frame_add(struct gspca_dev *gspca_dev, if (len > 0) { if (frame->data_end - frame->data + len > frame->v4l2_buf.length) { - PDEBUG(D_ERR|D_PACK, "frame overflow %d > %d", + PDEBUG(D_ERR|D_PACK, "frame overflow %zd > %d", frame->data_end - frame->data + len, frame->v4l2_buf.length); packet_type = DISCARD_PACKET; @@ -1565,7 +1565,7 @@ static ssize_t dev_read(struct file *file, char __user *data, struct timeval timestamp; int n, ret, ret2; - PDEBUG(D_FRAM, "read (%d)", count); + PDEBUG(D_FRAM, "read (%zd)", count); if (!gspca_dev->present) return -ENODEV; switch (gspca_dev->memory) { @@ -1616,7 +1616,7 @@ static ssize_t dev_read(struct file *file, char __user *data, ret = copy_to_user(data, frame->data, count); if (ret != 0) { PDEBUG(D_ERR|D_STREAM, - "read cp to user lack %d / %d", ret, count); + "read cp to user lack %d / %zd", ret, count); ret = -EFAULT; goto out; } -- cgit v1.2.3 From f9bf244a99c60bc5c062682e996582f3ed109bad Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Wed, 9 Jul 2008 18:29:59 +0000 Subject: uvcvideo : Add support for Asus F9GS integrated webcam From: Laurent Pinchart Signed-off-by: Laurent Pinchart Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/uvc/uvc_driver.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'linux') diff --git a/linux/drivers/media/video/uvc/uvc_driver.c b/linux/drivers/media/video/uvc/uvc_driver.c index 2c0b16960..4deb04bc2 100644 --- a/linux/drivers/media/video/uvc/uvc_driver.c +++ b/linux/drivers/media/video/uvc/uvc_driver.c @@ -1826,6 +1826,15 @@ static struct usb_device_id uvc_ids[] = { .bInterfaceSubClass = 1, .bInterfaceProtocol = 0, .driver_info = UVC_QUIRK_STREAM_NO_FID }, + /* Asus F9SG */ + { .match_flags = USB_DEVICE_ID_MATCH_DEVICE + | USB_DEVICE_ID_MATCH_INT_INFO, + .idVendor = 0x174f, + .idProduct = 0x8a31, + .bInterfaceClass = USB_CLASS_VIDEO, + .bInterfaceSubClass = 1, + .bInterfaceProtocol = 0, + .driver_info = UVC_QUIRK_STREAM_NO_FID }, /* Syntek (Asus U3S) */ { .match_flags = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_INFO, -- cgit v1.2.3 From dabbb6b1c9d6df38c1f140b22303c9e8935bbc38 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Fri, 11 Jul 2008 20:52:16 +0000 Subject: ov7670: clean up ov7670_read semantics From: Andres Salomon Cortland Setlow pointed out a bug in ov7670.c where the result from ov7670_read() was just being checked for !0, rather than <0. This made me realize that ov7670_read's semantics were rather confusing; it both fills in 'value' with the result, and returns it. This is goes against general kernel convention; so rather than fixing callers, let's fix the function. This makes ov7670_read return <0 in the case of an error, and 0 upon success. Thus, code like: res = ov7670_read(...); if (!res) goto error; ..will work properly. Signed-off-by: Cortland Setlow Signed-off-by: Andres Salomon Acked-by: Jonathan Corbet Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/ov7670.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/video/ov7670.c b/linux/drivers/media/video/ov7670.c index fb8c607fc..f226161bc 100644 --- a/linux/drivers/media/video/ov7670.c +++ b/linux/drivers/media/video/ov7670.c @@ -407,8 +407,10 @@ static int ov7670_read(struct i2c_client *c, unsigned char reg, int ret; ret = i2c_smbus_read_byte_data(c, reg); - if (ret >= 0) + if (ret >= 0) { *value = (unsigned char) ret; + ret = 0; + } return ret; } -- cgit v1.2.3 From d1bf82421f80c8db6d7f59a38a974fc491736c3d Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Fri, 4 Jul 2008 06:33:23 +0000 Subject: uvc/uvc_v4l2.c: suppress uninitialized var warning From: Andrew Morton drivers/media/video/uvc/uvc_v4l2.c: In function `uvc_v4l2_mmap': drivers/media/video/uvc/uvc_v4l2.c:1035: warning: 'buffer' might be used uninitialized in this function Signed-off-by: Andrew Morton Signed-off-by: Laurent Pinchart Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/uvc/uvc_v4l2.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/video/uvc/uvc_v4l2.c b/linux/drivers/media/video/uvc/uvc_v4l2.c index 0456bbdcd..b5a11eb8f 100644 --- a/linux/drivers/media/video/uvc/uvc_v4l2.c +++ b/linux/drivers/media/video/uvc/uvc_v4l2.c @@ -1032,7 +1032,7 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma) { struct video_device *vdev = video_devdata(file); struct uvc_video_device *video = video_get_drvdata(vdev); - struct uvc_buffer *buffer; + struct uvc_buffer *uninitialized_var(buffer); struct page *page; unsigned long addr, start, size; unsigned int i; -- cgit v1.2.3 From 2bd8c87540e14e295c31b913f5a2905d3bd4b261 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Fri, 11 Jul 2008 19:32:15 +0000 Subject: uvcvideo: Fix possible AB-BA deadlock with videodev_lock and open_mutex From: Laurent Pinchart The uvcvideo driver's uvc_v4l2_open() method is called from videodev's video_open() function, which means it is called with the videodev_lock mutex held. uvc_v4l2_open() then takes uvc_driver.open_mutex to check dev->state and avoid racing against a device disconnect, which means that open_mutex must nest inside videodev_lock. However uvc_disconnect() takes the open_mutex around setting dev->state and also around putting its device reference. However, if uvc_disconnect() ends up dropping the last reference, it will call uvc_delete(), which calls into the videodev code to unregister its device, and this will end up taking videodev_lock. This opens a (unlikely in practice) window for an AB-BA deadlock and also causes a lockdep warning because of the lock misordering. Fortunately there is no apparent reason to hold open_mutex when doing kref_put() in uvc_disconnect(): if uvc_v4l2_open() runs before the state is set to UVC_DEV_DISCONNECTED, then it will take another reference to the device and kref_put() won't call uvc_delete; if uvc_v4l2_open() runs after the state is set, it will run before uvc_delete(), see the state, and return immediately -- uvc_delete() does uvc_unregister_video() (and hence video_unregister_device(), which is synchronized with videodev_lock) as its first thing, so there is no risk of use-after-free in uvc_v4l2_open(). Bug diagnosed based on a lockdep warning reported by Romano Giannetti . Signed-off-by: Roland Dreier Signed-off-by: Laurent Pinchart Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/uvc/uvc_driver.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/uvc/uvc_driver.c b/linux/drivers/media/video/uvc/uvc_driver.c index 4deb04bc2..f2b2983fe 100644 --- a/linux/drivers/media/video/uvc/uvc_driver.c +++ b/linux/drivers/media/video/uvc/uvc_driver.c @@ -1633,13 +1633,16 @@ static void uvc_disconnect(struct usb_interface *intf) * reference to the uvc_device instance after uvc_v4l2_open() received * the pointer to the device (video_devdata) but before it got the * chance to increase the reference count (kref_get). + * + * Note that the reference can't be released with the lock held, + * otherwise a AB-BA deadlock can occur with videodev_lock that + * videodev acquires in videodev_open() and video_unregister_device(). */ mutex_lock(&uvc_driver.open_mutex); - dev->state |= UVC_DEV_DISCONNECTED; - kref_put(&dev->kref, uvc_delete); - mutex_unlock(&uvc_driver.open_mutex); + + kref_put(&dev->kref, uvc_delete); } static int uvc_suspend(struct usb_interface *intf, pm_message_t message) -- cgit v1.2.3 From 6195da85a3c11b3c8ac195ff5ef08c69e6f968e8 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Wed, 2 Jul 2008 15:59:29 +0000 Subject: zr36067: Delete dead code From: Jean Delvare This has been commented out for years, it's about time to get rid of it. Signed-off-by: Jean Delvare Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/zoran_card.c | 11 ----------- 1 file changed, 11 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/zoran_card.c b/linux/drivers/media/video/zoran_card.c index 56d8edecc..cc45ae5cd 100644 --- a/linux/drivers/media/video/zoran_card.c +++ b/linux/drivers/media/video/zoran_card.c @@ -359,14 +359,6 @@ i2cid_to_modulename (u16 i2c_id) case I2C_DRIVERID_VPX3220: name = "vpx3220"; break; -/* case I2C_DRIVERID_VPX3224: - name = "vpx3224"; - break; - case I2C_DRIVERID_MSE3000: - name = "mse3000"; - break;*/ - default: - break; } return name; @@ -387,8 +379,6 @@ codecid_to_modulename (u16 codecid) case CODEC_TYPE_ZR36016: name = "zr36016"; break; - default: - break; } return name; @@ -429,7 +419,6 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = { .type = DC10_old, .name = "DC10(old)", .i2c_decoder = I2C_DRIVERID_VPX3220, - /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/ .video_codec = CODEC_TYPE_ZR36050, .video_vfe = CODEC_TYPE_ZR36016, -- cgit v1.2.3 From 09524e72d1ea817fdbbd18d7219b824588d66278 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Wed, 2 Jul 2008 16:01:21 +0000 Subject: bt819: Fix a debug message From: Jean Delvare Signed-off-by: Jean Delvare Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/bt819.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'linux') diff --git a/linux/drivers/media/video/bt819.c b/linux/drivers/media/video/bt819.c index 402bccaf7..90be239cc 100644 --- a/linux/drivers/media/video/bt819.c +++ b/linux/drivers/media/video/bt819.c @@ -517,7 +517,7 @@ bt819_detect_client (struct i2c_adapter *adapter, dprintk(1, KERN_INFO - "saa7111.c: detecting bt819 client on address 0x%x\n", + "bt819: detecting bt819 client on address 0x%x\n", address << 1); /* Check if the adapter supports the needed features */ -- cgit v1.2.3 From 40623bc5fb02d968ab90fbe4479458cda3ef6f52 Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Mon, 30 Jun 2008 21:28:34 +0000 Subject: Sensoray 2255 V4l driver checkpatch fixes From: Dean Anderson This patch fixes some coding style issues. It also fixes a NULL de-reference on driver unload. The permissions for the module parameters were changed to 0644. Signed-off-by: Dean Anderson Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/s2255drv.c | 61 +++++++++++++++++++++--------------- 1 file changed, 35 insertions(+), 26 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/s2255drv.c b/linux/drivers/media/video/s2255drv.c index aca8c3d90..6eb396ffc 100644 --- a/linux/drivers/media/video/s2255drv.c +++ b/linux/drivers/media/video/s2255drv.c @@ -68,17 +68,17 @@ /* maximum time for DSP to start responding after last FW word loaded(ms) */ #define S2255_DSP_BOOTTIME 400 /* maximum time to wait for firmware to load (ms) */ -#define S2255_LOAD_TIMEOUT (5000+S2255_DSP_BOOTTIME) +#define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME) #define S2255_DEF_BUFS 16 #define MAX_CHANNELS 4 #define FRAME_MARKER 0x2255DA4AL -#define MAX_PIPE_USBBLOCK (40*1024) -#define DEFAULT_PIPE_USBBLOCK (16*1024) +#define MAX_PIPE_USBBLOCK (40 * 1024) +#define DEFAULT_PIPE_USBBLOCK (16 * 1024) #define MAX_CHANNELS 4 #define MAX_PIPE_BUFFERS 1 #define SYS_FRAMES 4 /* maximum size is PAL full size plus room for the marker header(s) */ -#define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096) +#define SYS_FRAMES_MAXSIZE (720 * 288 * 2 * 2 + 4096) #define DEF_USB_BLOCK (4096) #define LINE_SZ_4CIFS_NTSC 640 #define LINE_SZ_2CIFS_NTSC 640 @@ -169,7 +169,7 @@ struct s2255_bufferi { #define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \ DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \ - DEF_HUE, 0, DEF_USB_BLOCK, 0 } + DEF_HUE, 0, DEF_USB_BLOCK, 0} struct s2255_dmaqueue { struct list_head active; @@ -276,6 +276,10 @@ struct s2255_fh { struct s2255_mode mode; }; +/* + * TODO: fixme S2255_MAX_USERS. Do not limit open driver handles. + * Limit V4L to one stream at a time. + */ #define S2255_MAX_USERS 1 #define CUR_USB_FWVER 774 /* current cypress EEPROM firmware version */ @@ -294,7 +298,7 @@ struct s2255_fh { #define PREFIX_SIZE 512 /* Channels on box are in reverse order */ -static unsigned long G_chnmap[MAX_CHANNELS] = { 3, 2, 1, 0 }; +static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0}; static LIST_HEAD(s2255_devlist); @@ -330,11 +334,11 @@ static unsigned int vid_limit = 16; /* Video memory limit, in Mb */ /* start video number */ static int video_nr = -1; /* /dev/videoN, -1 for autodetect */ -module_param(debug, int, 0); +module_param(debug, int, 0644); MODULE_PARM_DESC(debug, "Debug level(0-100) default 0"); -module_param(vid_limit, int, 0); +module_param(vid_limit, int, 0644); MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)"); -module_param(video_nr, int, 0); +module_param(video_nr, int, 0644); MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)"); /* USB device table */ @@ -438,7 +442,10 @@ static int norm_minh(struct video_device *vdev) } -/* converts 2255 planar format to yuyv or uyvy */ +/* + * TODO: fixme: move YUV reordering to hardware + * converts 2255 planar format to yuyv or uyvy + */ static void planar422p_to_yuv_packed(const unsigned char *in, unsigned char *out, int width, int height, @@ -503,7 +510,7 @@ static void s2255_fwchunk_complete(struct urb *urb) struct usb_device *udev = urb->dev; int len; dprintk(100, "udev %p urb %p", udev, urb); - + /* TODO: fixme. reflect change in status */ if (urb->status) { dev_err(&udev->dev, "URB failed with status %d", urb->status); return; @@ -683,7 +690,7 @@ static int buffer_setup(struct videobuf_queue *vq, unsigned int *count, if (0 == *count) *count = S2255_DEF_BUFS; - while (*size * *count > vid_limit * 1024 * 1024) + while (*size * (*count) > vid_limit * 1024 * 1024) (*count)--; return 0; @@ -790,7 +797,7 @@ static int res_get(struct s2255_dev *dev, struct s2255_fh *fh) static int res_locked(struct s2255_dev *dev, struct s2255_fh *fh) { - return (dev->resources[fh->channel]); + return dev->resources[fh->channel]; } static void res_free(struct s2255_dev *dev, struct s2255_fh *fh) @@ -807,7 +814,8 @@ static int vidioc_querycap(struct file *file, void *priv, struct s2255_dev *dev = fh->dev; strlcpy(cap->driver, "s2255", sizeof(cap->driver)); strlcpy(cap->card, "s2255", sizeof(cap->card)); - strlcpy(cap->bus_info, dev_name(&dev->udev->dev), sizeof(cap->bus_info)); + strlcpy(cap->bus_info, dev_name(&dev->udev->dev), + sizeof(cap->bus_info)); cap->version = S2255_VERSION; cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; return 0; @@ -840,8 +848,7 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, f->fmt.pix.pixelformat = fh->fmt->fourcc; f->fmt.pix.bytesperline = f->fmt.pix.width * (fh->fmt->depth >> 3); f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline; - - return (0); + return 0; } static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, @@ -962,7 +969,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, ret = vidioc_try_fmt_vid_cap(file, fh, f); if (ret < 0) - return (ret); + return ret; fmt = format_by_fourcc(f->fmt.pix.pixelformat); @@ -1337,7 +1344,7 @@ static int vidioc_enum_input(struct file *file, void *priv, inp->type = V4L2_INPUT_TYPE_CAMERA; inp->std = S2255_NORMS; strlcpy(inp->name, "Camera", sizeof(inp->name)); - return (0); + return 0; } static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) @@ -1361,7 +1368,7 @@ static int vidioc_queryctrl(struct file *file, void *priv, for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++) if (qc->id && qc->id == s2255_qctrl[i].id) { memcpy(qc, &(s2255_qctrl[i]), sizeof(*qc)); - return (0); + return 0; } dprintk(4, "query_ctrl -EINVAL %d\n", qc->id); @@ -1376,7 +1383,7 @@ static int vidioc_g_ctrl(struct file *file, void *priv, for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++) if (ctrl->id == s2255_qctrl[i].id) { ctrl->value = qctl_regs[i]; - return (0); + return 0; } dprintk(4, "g_ctrl -EINVAL\n"); @@ -1396,7 +1403,7 @@ static int vidioc_s_ctrl(struct file *file, void *priv, if (ctrl->id == s2255_qctrl[i].id) { if (ctrl->value < s2255_qctrl[i].minimum || ctrl->value > s2255_qctrl[i].maximum) - return (-ERANGE); + return -ERANGE; qctl_regs[i] = ctrl->value; /* update the mode to the corresponding value */ @@ -1572,6 +1579,11 @@ static void s2255_destroy(struct kref *kref) usb_free_urb(dev->fw_data->fw_urb); dev->fw_data->fw_urb = NULL; } + /* + * TODO: fixme(above, below): potentially leaving timers alive. + * do not ignore timeout below if + * it occurs. + */ /* make sure we aren't waiting for the DSP */ if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_LOADED_DSPWAIT) { @@ -1583,15 +1595,12 @@ static void s2255_destroy(struct kref *kref) } if (dev->fw_data) { + if (dev->fw_data->fw) + release_firmware(dev->fw_data->fw); kfree(dev->fw_data->pfw_data); kfree(dev->fw_data); } - if (dev->fw_data->fw) { - release_firmware(dev->fw_data->fw); - dev->fw_data->fw = NULL; - } - usb_put_dev(dev->udev); dprintk(1, "%s", __func__); kfree(dev); -- cgit v1.2.3 From 5d6597046c8d57aa650a06343c4d63ba7dbe57dc Mon Sep 17 00:00:00 2001 From: Mauro Carvalho Chehab Date: Mon, 30 Jun 2008 20:57:39 +0000 Subject: OV7670: don't reject unsupported settings From: Daniel Drake For VIDIOC_G_FMT/VIDIOC_TRY_FMT, the V4L2 API spec states: "Drivers should not return an error code unless the input is ambiguous" "Very simple, inflexible devices may even ignore all input and always return the default parameters." "When the requested buffer type is not supported drivers return an EINVAL error code." i.e. returning errors for unsupported fields is bad, and it's ok to unconditionally overwrite user-requested settings This patch makes ov7670 meet that behaviour, and brings it in line with other drivers e.g. stk-webcam. It also fixes compatibility with (unpatched) gstreamer. Signed-off-by: Daniel Drake Acked-by: Jonathan Corbet Signed-off-by: Mauro Carvalho Chehab --- linux/drivers/media/video/ov7670.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'linux') diff --git a/linux/drivers/media/video/ov7670.c b/linux/drivers/media/video/ov7670.c index f226161bc..dcf7678a8 100644 --- a/linux/drivers/media/video/ov7670.c +++ b/linux/drivers/media/video/ov7670.c @@ -704,17 +704,17 @@ static int ov7670_try_fmt(struct i2c_client *c, struct v4l2_format *fmt, for (index = 0; index < N_OV7670_FMTS; index++) if (ov7670_formats[index].pixelformat == pix->pixelformat) break; - if (index >= N_OV7670_FMTS) - return -EINVAL; + if (index >= N_OV7670_FMTS) { + /* default to first format */ + index = 0; + pix->pixelformat = ov7670_formats[0].pixelformat; + } if (ret_fmt != NULL) *ret_fmt = ov7670_formats + index; /* * Fields: the OV devices claim to be progressive. */ - if (pix->field == V4L2_FIELD_ANY) - pix->field = V4L2_FIELD_NONE; - else if (pix->field != V4L2_FIELD_NONE) - return -EINVAL; + pix->field = V4L2_FIELD_NONE; /* * Round requested image size down to the nearest * we support, but not below the smallest. -- cgit v1.2.3