struct smscore_buffer_t *cb;
 
        cb = kzalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL);
-       if (!cb) {
-               sms_info("kzalloc(...) failed");
+       if (!cb)
                return NULL;
-       }
 
        cb->p = buffer;
        cb->offset_in_common = buffer - (u8 *) common_buffer;
        u8 *buffer;
 
        dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL);
-       if (!dev) {
-               sms_info("kzalloc(...) failed");
+       if (!dev)
                return -ENOMEM;
-       }
 
        /* init list entry so it could be safe in smscore_unregister_device */
        INIT_LIST_HEAD(&dev->entry);
                smscore_putbuffer(dev, cb);
        }
 
-       sms_info("allocated %d buffers", dev->num_buffers);
+       pr_debug("allocated %d buffers\n", dev->num_buffers);
 
        dev->mode = DEVICE_MODE_NONE;
        dev->board_id = SMS_BOARD_UNKNOWN;
 
        *coredev = dev;
 
-       sms_info("device %p created", dev);
+       pr_debug("device %p created\n", dev);
 
        return 0;
 }
 
        rc = coredev->sendrequest_handler(coredev->context, buffer, size);
        if (rc < 0) {
-               sms_info("sendrequest returned error %d", rc);
+               pr_info("sendrequest returned error %d\n", rc);
                return rc;
        }
 
        coredev->ir.dev = NULL;
        ir_io = sms_get_board(smscore_get_board_id(coredev))->board_cfg.ir;
        if (ir_io) {/* only if IR port exist we use IR sub-module */
-               sms_info("IR loading");
+               pr_debug("IR loading\n");
                rc = sms_ir_init(coredev);
 
                if      (rc != 0)
                                pr_err("Sending IR initialization message failed\n");
                }
        } else
-               sms_info("IR port has not been detected");
+               pr_info("IR port has not been detected\n");
 
        return 0;
 }
 
        rc = smscore_set_device_mode(coredev, mode);
        if (rc < 0) {
-               sms_info("set device mode faile , rc %d", rc);
+               pr_info("set device mode failed , rc %d\n", rc);
                return rc;
        }
        rc = smscore_configure_board(coredev);
        if (rc < 0) {
-               sms_info("configure board failed , rc %d", rc);
+               pr_info("configure board failed , rc %d\n", rc);
                return rc;
        }
 
        rc = smscore_notify_callbacks(coredev, coredev->device, 1);
        smscore_init_ir(coredev);
 
-       sms_info("device %p started, rc %d", coredev, rc);
+       pr_debug("device %p started, rc %d\n", coredev, rc);
 
        kmutex_unlock(&g_smscore_deviceslock);
 
 
        mem_address = firmware->start_address;
 
-       sms_info("loading FW to addr 0x%x size %d",
+       pr_debug("loading FW to addr 0x%x size %d\n",
                 mem_address, firmware->length);
        if (coredev->preload_handler) {
                rc = coredev->preload_handler(coredev->context);
                pr_err("failed to open firmware file '%s'\n", fw_filename);
                return rc;
        }
-       sms_info("read fw %s, buffer size=0x%zx", fw_filename, fw->size);
+       pr_debug("read fw %s, buffer size=0x%zx\n", fw_filename, fw->size);
        fw_buf = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT),
                         GFP_KERNEL | GFP_DMA);
        if (!fw_buf) {
                if (num_buffers == coredev->num_buffers)
                        break;
                if (++retry > 10) {
-                       sms_info("exiting although not all buffers released.");
+                       pr_info("exiting although not all buffers released.\n");
                        break;
                }
 
-               sms_info("waiting for %d buffer(s)",
+               pr_debug("waiting for %d buffer(s)\n",
                         coredev->num_buffers - num_buffers);
                kmutex_unlock(&g_smscore_deviceslock);
                msleep(100);
                kmutex_lock(&g_smscore_deviceslock);
        }
 
-       sms_info("freed %d buffers", num_buffers);
+       pr_debug("freed %d buffers\n", num_buffers);
 
        if (coredev->common_buffer)
                dma_free_coherent(NULL, coredev->common_buffer_size,
 
        kmutex_unlock(&g_smscore_deviceslock);
 
-       sms_info("device %p destroyed", coredev);
+       pr_debug("device %p destroyed\n", coredev);
 }
 EXPORT_SYMBOL_GPL(smscore_unregister_device);
 
                }
 
                if (coredev->mode == mode) {
-                       sms_info("device mode %d already set", mode);
+                       pr_debug("device mode %d already set\n", mode);
                        return 0;
                }
 
                        rc = smscore_load_firmware_from_file(coredev,
                                                             mode, NULL);
                        if (rc >= 0)
-                               sms_info("firmware download success");
+                               pr_debug("firmware download success\n");
                } else {
-                       sms_info("mode %d is already supported by running firmware",
+                       pr_debug("mode %d is already supported by running firmware\n",
                                 mode);
                }
                if (coredev->fw_version >= 0x800) {
                kfree(identry);
        }
 
-       sms_info("%p", client->context);
+       pr_debug("%p\n", client->context);
 
        list_del(&client->entry);
        kfree(client);
 
 
 /* ------------------------------------------------------------------------ */
 
-#define DBG_INFO 1
-#define DBG_ADV  2
-
-#define sms_info(fmt, arg...) do {\
-       if (sms_dbg & DBG_INFO) \
-               pr_info(fmt "\n", ##arg); \
-} while (0)
-
 #endif /* __SMS_CORE_API_H__ */
 
                is_status_update = true;
                break;
        default:
-               sms_info("message not handled");
+               pr_debug("message not handled\n");
        }
        smscore_putbuffer(client->coredev, cb);
 
        msg.Data[0] = c->frequency;
        msg.Data[2] = 12000000;
 
-       sms_info("%s: freq %d band %d", __func__, c->frequency,
+       pr_debug("%s: freq %d band %d\n", __func__, c->frequency,
                 c->bandwidth_hz);
 
        switch (c->bandwidth_hz / 1000000) {
 
        c->bandwidth_hz = 6000000;
 
-       sms_info("%s: freq %d segwidth %d segindex %d", __func__,
+       pr_debug("freq %d segwidth %d segindex %d\n",
                 c->frequency, c->isdbt_sb_segment_count,
                 c->isdbt_sb_segment_idx);
 
        client->event_unc_state = -1;
        sms_board_dvb3_event(client, DVB3_EVENT_HOTPLUG);
 
-       sms_info("success");
+       pr_debug("success\n");
        sms_board_setup(coredev);
 
        if (smsdvb_debugfs_create(client) < 0)
-               sms_info("failed to create debugfs node");
+               pr_info("failed to create debugfs node\n");
 
        dvb_create_media_graph(coredev->media_dev);
 
 
                rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),
                                  fw_buffer, fw->size, &dummy, 1000);
 
-               sms_info("sent %zu(%d) bytes, rc %d", fw->size, dummy, rc);
+               pr_debug("sent %zu(%d) bytes, rc %d\n", fw->size, dummy, rc);
 
                kfree(fw_buffer);
        } else {
                pr_err("failed to allocate firmware buffer\n");
                rc = -ENOMEM;
        }
-       sms_info("read FW %s, size=%zu", fw_filename, fw->size);
+       pr_debug("read FW %s, size=%zu\n", fw_filename, fw->size);
 
        release_firmware(fw);
 
        else if (strstr(product_string, "TDMB"))
                *mode = 2;
 
-       sms_info("%d \"%s\"", *mode, product_string);
+       pr_debug("%d \"%s\"\n", *mode, product_string);
 }
 
 static int smsusb1_setmode(void *context, int mode)
                if (dev->coredev)
                        smscore_unregister_device(dev->coredev);
 
-               sms_info("device 0x%p destroyed", dev);
+               pr_debug("device 0x%p destroyed\n", dev);
                kfree(dev);
        }
 
 
        dev->coredev->media_dev = mdev;
 
-       sms_info("media controller created");
+       pr_info("media controller created\n");
 
 #endif
 }
                        dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
        }
 
-       sms_info("in_ep = %02x, out_ep = %02x",
+       pr_debug("in_ep = %02x, out_ep = %02x\n",
                dev->in_ep, dev->out_ep);
 
        params.device = &dev->udev->dev;
                usb_init_urb(&dev->surbs[i].urb);
        }
 
-       sms_info("smsusb_start_streaming(...).");
+       pr_debug("smsusb_start_streaming(...).\n");
        rc = smsusb_start_streaming(dev);
        if (rc < 0) {
                pr_err("smsusb_start_streaming(...) failed\n");
                return rc;
        }
 
-       sms_info("device 0x%p created", dev);
+       pr_debug("device 0x%p created\n", dev);
        siano_media_device_register(dev);
 
        return rc;
        char devpath[32];
        int i, rc;
 
-       sms_info("board id=%lu, interface number %d",
+       pr_info("board id=%lu, interface number %d\n",
                 id->driver_info,
                 intf->cur_altsetting->desc.bInterfaceNumber);
 
                }
        }
 
-       sms_info("smsusb_probe %d",
+       pr_debug("smsusb_probe %d\n",
               intf->cur_altsetting->desc.bInterfaceNumber);
        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
-               sms_info("endpoint %d %02x %02x %d", i,
+               pr_debug("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);
 
                snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
                         udev->bus->busnum, udev->devpath);
-               sms_info("stellar device in cold state was found at %s.", devpath);
+               pr_info("stellar device in cold state was found at %s.\n",
+                       devpath);
                rc = smsusb1_load_firmware(
                                udev, smscore_registry_getmode(devpath),
                                id->driver_info);
 
                /* This device will reset and gain another USB ID */
                if (!rc)
-                       sms_info("stellar device now in warm state");
+                       pr_info("stellar device now in warm state\n");
                else
                        pr_err("Failed to put stellar in warm state. Error: %d\n",
                               rc);
                rc = smsusb_init_device(intf, id->driver_info);
        }
 
-       sms_info("Device initialized with return code %d", rc);
+       pr_info("Device initialized with return code %d\n", rc);
        sms_board_load_modules(id->driver_info);
        return rc;
 }