Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 18245e18 authored by Michael Krufky's avatar Michael Krufky Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (8286): sms1xxx: remove typedefs 



Signed-off-by: default avatarMichael Krufky <mkrufky@linuxtv.org>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@infradead.org>
parent ca783736

drivers/media/dvb/siano/smscoreapi.c

+127 −116
Original line number Diff line number Diff line
@@ -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)
@@ -229,20 +223,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);

		}
@@ -274,8 +270,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) {
@@ -287,19 +283,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;
@@ -309,7 +305,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;
@@ -318,10 +314,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;
@@ -344,13 +341,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;
@@ -389,7 +386,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) {
@@ -437,7 +434,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));
@@ -459,7 +456,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);
@@ -474,11 +471,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;
@@ -492,14 +489,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);
@@ -507,11 +504,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;
@@ -535,10 +533,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;
@@ -560,7 +559,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);
@@ -588,7 +587,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;
@@ -632,8 +632,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;
@@ -648,9 +648,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;
@@ -695,17 +695,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);
@@ -754,11 +756,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) {
@@ -798,14 +800,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(
@@ -853,7 +856,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;

}
@@ -868,10 +871,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;
@@ -882,14 +885,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;

			}

		}
@@ -907,10 +910,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;
@@ -940,7 +945,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,
@@ -994,15 +1000,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);

	}
@@ -1019,16 +1025,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");
@@ -1042,7 +1050,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;
@@ -1068,11 +1076,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)) {
@@ -1080,7 +1088,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;
@@ -1109,17 +1117,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);

	}
@@ -1143,10 +1151,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) {
@@ -1177,7 +1186,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;

}
@@ -1190,7 +1199,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,
@@ -1247,8 +1256,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(&notifyee->entry);

		kfree(notifyee);
@@ -1257,8 +1267,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);

drivers/media/dvb/siano/smscoreapi.h

+60 −239

File changed.

Preview size limit exceeded, changes collapsed.

drivers/media/dvb/siano/smsdvb.c

+38 −32
Original line number Diff line number Diff line
@@ -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;
@@ -259,7 +264,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__);
@@ -303,11 +309,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 */
@@ -320,7 +326,7 @@ int smsdvb_hotplug(smscore_device_t *coredev, 
		return 0;

	}



	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;
@@ -439,7 +445,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);

}

drivers/media/dvb/siano/smsusb.c

+31 −31

File changed.

Preview size limit exceeded, changes collapsed.