struct smscore_registry_entry_t *entry;
        struct list_head *next;
 
-       kmutex_lock(&g_smscore_registrylock);
+       mutex_lock(&g_smscore_registrylock);
        for (next = g_smscore_registry.next;
             next != &g_smscore_registry;
             next = next->next) {
                entry = (struct smscore_registry_entry_t *) next;
                if (!strncmp(entry->devpath, devpath, sizeof(entry->devpath))) {
-                       kmutex_unlock(&g_smscore_registrylock);
+                       mutex_unlock(&g_smscore_registrylock);
                        return entry;
                }
        }
                list_add(&entry->entry, &g_smscore_registry);
        } else
                pr_err("failed to create smscore_registry.\n");
-       kmutex_unlock(&g_smscore_registrylock);
+       mutex_unlock(&g_smscore_registrylock);
        return entry;
 }
 
        struct list_head *next, *first;
        int rc = 0;
 
-       kmutex_lock(&g_smscore_deviceslock);
+       mutex_lock(&g_smscore_deviceslock);
        notifyee = kmalloc(sizeof(*notifyee), GFP_KERNEL);
        if (notifyee) {
                /* now notify callback about existing devices */
        } else
                rc = -ENOMEM;
 
-       kmutex_unlock(&g_smscore_deviceslock);
+       mutex_unlock(&g_smscore_deviceslock);
 
        return rc;
 }
 {
        struct list_head *next, *first;
 
-       kmutex_lock(&g_smscore_deviceslock);
+       mutex_lock(&g_smscore_deviceslock);
 
        first = &g_smscore_notifyees;
 
                }
        }
 
-       kmutex_unlock(&g_smscore_deviceslock);
+       mutex_unlock(&g_smscore_deviceslock);
 }
 EXPORT_SYMBOL_GPL(smscore_unregister_hotplug);
 
        smscore_registry_settype(dev->devpath, params->device_type);
 
        /* add device to devices list */
-       kmutex_lock(&g_smscore_deviceslock);
+       mutex_lock(&g_smscore_deviceslock);
        list_add(&dev->entry, &g_smscore_devices);
-       kmutex_unlock(&g_smscore_deviceslock);
+       mutex_unlock(&g_smscore_deviceslock);
 
        *coredev = dev;
 
                return rc;
        }
 
-       kmutex_lock(&g_smscore_deviceslock);
+       mutex_lock(&g_smscore_deviceslock);
 
        rc = smscore_notify_callbacks(coredev, coredev->device, 1);
        smscore_init_ir(coredev);
 
        pr_debug("device %p started, rc %d\n", coredev, rc);
 
-       kmutex_unlock(&g_smscore_deviceslock);
+       mutex_unlock(&g_smscore_deviceslock);
 
        return rc;
 }
        int num_buffers = 0;
        int retry = 0;
 
-       kmutex_lock(&g_smscore_deviceslock);
+       mutex_lock(&g_smscore_deviceslock);
 
        /* Release input device (IR) resources */
        sms_ir_exit(coredev);
 
                pr_debug("waiting for %d buffer(s)\n",
                         coredev->num_buffers - num_buffers);
-               kmutex_unlock(&g_smscore_deviceslock);
+               mutex_unlock(&g_smscore_deviceslock);
                msleep(100);
-               kmutex_lock(&g_smscore_deviceslock);
+               mutex_lock(&g_smscore_deviceslock);
        }
 
        pr_debug("freed %d buffers\n", num_buffers);
        list_del(&coredev->entry);
        kfree(coredev);
 
-       kmutex_unlock(&g_smscore_deviceslock);
+       mutex_unlock(&g_smscore_deviceslock);
 
        pr_debug("device %p destroyed\n", coredev);
 }
 {
        INIT_LIST_HEAD(&g_smscore_notifyees);
        INIT_LIST_HEAD(&g_smscore_devices);
-       kmutex_init(&g_smscore_deviceslock);
+       mutex_init(&g_smscore_deviceslock);
 
        INIT_LIST_HEAD(&g_smscore_registry);
-       kmutex_init(&g_smscore_registrylock);
+       mutex_init(&g_smscore_registrylock);
 
        return 0;
 }
 
 static void __exit smscore_module_exit(void)
 {
-       kmutex_lock(&g_smscore_deviceslock);
+       mutex_lock(&g_smscore_deviceslock);
        while (!list_empty(&g_smscore_notifyees)) {
                struct smscore_device_notifyee_t *notifyee =
                        (struct smscore_device_notifyee_t *)
                list_del(¬ifyee->entry);
                kfree(notifyee);
        }
-       kmutex_unlock(&g_smscore_deviceslock);
+       mutex_unlock(&g_smscore_deviceslock);
 
-       kmutex_lock(&g_smscore_registrylock);
+       mutex_lock(&g_smscore_registrylock);
        while (!list_empty(&g_smscore_registry)) {
                struct smscore_registry_entry_t *entry =
                        (struct smscore_registry_entry_t *)
                list_del(&entry->entry);
                kfree(entry);
        }
-       kmutex_unlock(&g_smscore_registrylock);
+       mutex_unlock(&g_smscore_registrylock);
 
        pr_debug("\n");
 }
 
 
 static void smsdvb_onremove(void *context)
 {
-       kmutex_lock(&g_smsdvb_clientslock);
+       mutex_lock(&g_smsdvb_clientslock);
 
        smsdvb_unregister_client((struct smsdvb_client_t *) context);
 
-       kmutex_unlock(&g_smsdvb_clientslock);
+       mutex_unlock(&g_smsdvb_clientslock);
 }
 
 static int smsdvb_start_feed(struct dvb_demux_feed *feed)
        init_completion(&client->tune_done);
        init_completion(&client->stats_done);
 
-       kmutex_lock(&g_smsdvb_clientslock);
+       mutex_lock(&g_smsdvb_clientslock);
 
        list_add(&client->entry, &g_smsdvb_clients);
 
-       kmutex_unlock(&g_smsdvb_clientslock);
+       mutex_unlock(&g_smsdvb_clientslock);
 
        client->event_fe_state = -1;
        client->event_unc_state = -1;
        int rc;
 
        INIT_LIST_HEAD(&g_smsdvb_clients);
-       kmutex_init(&g_smsdvb_clientslock);
+       mutex_init(&g_smsdvb_clientslock);
 
        smsdvb_debugfs_register();
 
 {
        smscore_unregister_hotplug(smsdvb_hotplug);
 
-       kmutex_lock(&g_smsdvb_clientslock);
+       mutex_lock(&g_smsdvb_clientslock);
 
        while (!list_empty(&g_smsdvb_clients))
                smsdvb_unregister_client((struct smsdvb_client_t *)g_smsdvb_clients.next);
 
        smsdvb_debugfs_unregister();
 
-       kmutex_unlock(&g_smsdvb_clientslock);
+       mutex_unlock(&g_smsdvb_clientslock);
 }
 
 module_init(smsdvb_module_init);