X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=drivers%2Fmedia%2Fdvb%2Fsiano%2Fsmscoreapi.c;h=c5f45fed69dc41290a2300a5a90dfea701f87cdb;hb=f2d7499be1b1fe1cd8a5e6a01c1f44173894a241;hp=3c0e64286d4e695d92348c3cce931aa0ec749af8;hpb=9f2113975a7898c913c668bb709e95c27e51617b;p=linux-2.6 diff --git a/drivers/media/dvb/siano/smscoreapi.c b/drivers/media/dvb/siano/smscoreapi.c index 3c0e64286d..c5f45fed69 100644 --- a/drivers/media/dvb/siano/smscoreapi.c +++ b/drivers/media/dvb/siano/smscoreapi.c @@ -27,56 +27,38 @@ #include #include #include -#include +#include #include #include "smscoreapi.h" +#include "sms-cards.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 -{ +int sms_debug; +module_param_named(debug, sms_debug, int, 0644); +MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))"); + +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,108 +89,119 @@ 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 + 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]; 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; -kmutex_t g_smscore_deviceslock; +static struct list_head g_smscore_notifyees; +static struct list_head g_smscore_devices; +static struct mutex g_smscore_deviceslock; -struct list_head g_smscore_registry; -kmutex_t g_smscore_registrylock; +static struct list_head g_smscore_registry; +static struct mutex 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)"); -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); list_add(&entry->entry, &g_smscore_registry); } else - printk(KERN_ERR "%s failed to create smscore_registry.\n", - __func__); + sms_err("failed to create smscore_registry."); kmutex_unlock(&g_smscore_registrylock); return entry; } int smscore_registry_getmode(char *devpath) { - smscore_registry_entry_t *entry; + struct 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__); + sms_err("No registry found."); return default_mode; } -sms_device_type_st smscore_registry_gettype(char *devpath) +static 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) return entry->type; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("No registry found."); return -1; } 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) entry->mode = mode; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("No registry found."); } -void smscore_registry_settype(char *devpath, sms_device_type_st type) +static 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) entry->type = type; else - printk(KERN_ERR "%s No registry found.\n", __func__); + sms_err("No registry found."); } - -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; @@ -229,20 +222,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 +269,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 +282,19 @@ void smscore_unregister_hotplug(hotplug_t hotplug) kmutex_unlock(&g_smscore_deviceslock); } -void smscore_notify_clients(smscore_device_t *coredev) +static 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) +static int smscore_notify_callbacks(struct smscore_device_t *coredev, + struct device *device, int arrival) { struct list_head *next, *first; int rc = 0; @@ -309,7 +304,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,12 +313,14 @@ int smscore_notify_callbacks(smscore_device_t *coredev, struct device *device, return rc; } +static 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__); + sms_info("kmalloc(...) failed"); return NULL; } @@ -344,15 +341,15 @@ 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__); + sms_info("kzalloc(...) failed"); 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) { @@ -400,8 +397,7 @@ int smscore_register_device(smsdevice_params_t *params, smscore_putbuffer(dev, cb); } - printk(KERN_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; @@ -424,7 +420,7 @@ int smscore_register_device(smsdevice_params_t *params, *coredev = dev; - printk(KERN_INFO "%s device %p created\n", __func__, dev); + sms_info("device %p created", dev); return 0; } @@ -437,13 +433,12 @@ 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)); if (rc < 0) { - printk(KERN_INFO "%s set device mode faile , rc %d\n", - __func__, rc); + sms_info("set device mode faile , rc %d", rc); return rc; } @@ -451,21 +446,20 @@ 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); + sms_info("device %p started, rc %d", 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) +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) { - printk(KERN_INFO "%s sendrequest returned error %d\n", - __func__, rc); + sms_info("sendrequest returned error %d", rc); return rc; } @@ -474,17 +468,17 @@ 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) +static 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; - printk(KERN_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) @@ -492,14 +486,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 = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); if (!msg) return -ENOMEM; if (coredev->mode != DEVICE_MODE_NONE) { - PDEBUG("Sending reload command\n"); + sms_debug("sending reload command."); 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 +501,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 +530,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 +556,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); @@ -568,8 +564,8 @@ int smscore_load_firmware_family2(smscore_device_t *coredev, void *buffer, msleep(500); } - printk(KERN_DEBUG "%s rc=%d, postload=%p \n", __func__, rc, - coredev->postload_handler); + sms_debug("rc=%d, postload=%p ", rc, + coredev->postload_handler); kfree(msg); @@ -588,11 +584,11 @@ 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, - 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; u8 *fw_buffer; @@ -602,12 +598,10 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, rc = request_firmware(&fw, filename, coredev->device); if (rc < 0) { - printk(KERN_INFO "%s failed to open \"%s\"\n", - __func__, filename); + sms_info("failed to open \"%s\"", filename); return rc; } - printk(KERN_INFO "%s read FW %s, size=%d\"\n", __func__, - 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) { @@ -622,8 +616,7 @@ int smscore_load_firmware_from_file(smscore_device_t *coredev, char *filename, kfree(fw_buffer); } else { - printk(KERN_INFO "%s failed to allocate firmware buffer\n", - __func__); + sms_info("failed to allocate firmware buffer"); rc = -ENOMEM; } @@ -632,13 +625,6 @@ 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) -{ - PERROR("Feature not implemented yet\n"); - return -EFAULT; -} - /** * notifies all clients registered with the device, notifies hotplugs, * frees all buffers and coredev object @@ -648,9 +634,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; @@ -670,17 +656,17 @@ void smscore_unregister_device(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("exiting although " + "not all buffers released."); break; } - printk(KERN_INFO "%s waiting for %d buffer(s)\n", __func__, - coredev->num_buffers - num_buffers); + sms_info("waiting for %d buffer(s)", + coredev->num_buffers - num_buffers); msleep(100); } - printk(KERN_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, @@ -692,26 +678,27 @@ void smscore_unregister_device(smscore_device_t *coredev) kmutex_unlock(&g_smscore_deviceslock); - printk(KERN_INFO "%s device %p destroyed\n", __func__, coredev); + sms_info("device %p destroyed", coredev); } -int smscore_detect_mode(smscore_device_t *coredev) +static 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); if (rc == -ETIME) { - printk(KERN_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))) { @@ -719,9 +706,8 @@ int smscore_detect_mode(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("MSG_SMS_GET_VERSION_EX_REQ failed " + "second try, rc %d", rc); } else rc = -ETIME; } @@ -731,18 +717,32 @@ int smscore_detect_mode(smscore_device_t *coredev) return rc; } -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"} +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"}, + /*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"} }; +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 @@ -754,17 +754,16 @@ 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); + 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) { - printk(KERN_INFO "%s invalid mode specified %d\n", - __func__, mode); + sms_err("invalid mode specified %d", mode); return -EINVAL; } @@ -773,39 +772,55 @@ int smscore_set_device_mode(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_err("mode detect failed %d", rc); return rc; } } if (coredev->mode == mode) { - printk(KERN_INFO "%s device mode %d already set\n", - __func__, mode); + sms_info("device mode %d already set", mode); return 0; } 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) { - printk(KERN_INFO "%s load firmware " - "failed %d\n", __func__, rc); - return rc; + 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, + fw_filename, NULL); + + if (rc < 0) { + sms_warn("error %d loading " + "firmware: %s", rc, + fw_filename); + return rc; + } } + sms_log("firmware download success: %s", fw_filename); } else - printk(KERN_INFO "%s mode %d supported by running " - "firmware\n", __func__, mode); + sms_info("mode %d supported by running " + "firmware", 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( @@ -814,14 +829,13 @@ 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__); + sms_err("Could not allocate buffer for " + "init device message."); 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_err("invalid mode specified %d", mode); return -EINVAL; } @@ -841,7 +855,7 @@ int smscore_set_device_mode(smscore_device_t *coredev, int mode) } if (rc != 0) - printk(KERN_INFO "%s return error code %d.\n", __func__, rc); + sms_err("return error code %d.", rc); return rc; } @@ -853,7 +867,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 +882,11 @@ 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, +static 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 +897,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,24 +922,26 @@ 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; - 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) 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("\ndata rate %d bytes/secs", + (int)((data_total * 1000) / + (time_now - last_sample_time))); last_sample_time = time_now; data_total = 0; @@ -940,11 +957,12 @@ 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; - 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); + struct SmsVersionRes_ST *ver = + (struct SmsVersionRes_ST *) phdr; + sms_debug("MSG_SMS_GET_VERSION_EX_RES " + "id %d prots 0x%x ver %d.%d", + ver->FirmwareId, ver->SupportedProtocols, + ver->RomVersionMajor, ver->RomVersionMinor); coredev->mode = ver->FirmwareId == 255 ? DEVICE_MODE_NONE : ver->FirmwareId; @@ -954,25 +972,21 @@ void smscore_onresponse(smscore_device_t *coredev, smscore_buffer_t *cb) break; } case MSG_SMS_INIT_DEVICE_RES: - printk(KERN_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: - printk(KERN_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: - printk(KERN_DEBUG "%s: MSG_SW_RELOAD_EXEC_RES\n", - __func__); + sms_debug("MSG_SW_RELOAD_EXEC_RES"); break; case MSG_SMS_SWDOWNLOAD_TRIGGER_RES: - printk(KERN_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: @@ -993,15 +1007,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); } @@ -1018,19 +1032,21 @@ 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) +static 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"); + sms_err("bad parameter."); return -EFAULT; } registered_client = smscore_find_client(coredev, data_type, id); @@ -1038,12 +1054,12 @@ int smscore_validate_client(smscore_device_t *coredev, return 0; if (registered_client) { - PERROR("The msg ID already registered to another client.\n"); + sms_err("The msg ID already registered to another client."); 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"); + sms_err("Can't allocate memory for client id."); return -ENOMEM; } listentry->id = id; @@ -1059,28 +1075,29 @@ 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 * * @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)) { - PERROR("Client already exist.\n"); + sms_err("Client already exist."); 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"); + sms_err("Failed to allocate memory for client."); return -ENOMEM; } @@ -1094,8 +1111,8 @@ int smscore_register_client(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, - params->initial_id); + sms_debug("%p %d %d", params->context, params->data_type, + params->initial_id); return 0; } @@ -1107,22 +1124,22 @@ 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); } - printk(KERN_INFO "%s %p\n", __func__, client->context); + sms_info("%p", client->context); list_del(&client->entry); kfree(client); @@ -1141,14 +1158,15 @@ 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) { - printk(KERN_ERR "%s Got NULL client\n", __func__); + sms_err("Got NULL client"); return -EINVAL; } @@ -1156,7 +1174,7 @@ int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) /* check that no other channel with same id exists */ if (coredev == NULL) { - printk(KERN_ERR "%s Got NULL coredev\n", __func__); + sms_err("Got NULL coredev"); return -EINVAL; } @@ -1168,57 +1186,8 @@ int smsclient_sendrequest(smscore_client_t *client, void *buffer, size_t size) 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", __func__); - return -EINVAL; - } - - if ((end - start) != size) { - printk(KERN_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__); - return -EAGAIN; - } - - return 0; -} -int smscore_module_init(void) +static int __init smscore_module_init(void) { int rc = 0; @@ -1235,18 +1204,19 @@ int smscore_module_init(void) /* DVB Register */ rc = smsdvb_register(); - printk(KERN_INFO "%s, rc %d\n", __func__, rc); + sms_debug("rc %d", rc); return rc; } -void smscore_module_exit(void) +static void __exit 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); @@ -1255,8 +1225,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); @@ -1269,12 +1240,12 @@ void smscore_module_exit(void) /* Unregister USB */ smsusb_unregister(); - printk(KERN_INFO "%s\n", __func__); + sms_debug(""); } 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");