* Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
                status = -EIO;
 
        if (status < 0)
-               printk(KERN_ERR "drxk: i2c write error at addr 0x%02x\n", adr);
+               pr_err("i2c write error at addr 0x%02x\n", adr);
 
        return status;
 }
                if (status >= 0)
                        status = -EIO;
 
-               printk(KERN_ERR "drxk: i2c read error at addr 0x%02x\n", adr);
+               pr_err("i2c read error at addr 0x%02x\n", adr);
                return status;
        }
        if (debug > 2) {
                status = i2c_write(state, state->demod_address,
                                   &state->chunk[0], chunk + adr_length);
                if (status < 0) {
-                       printk(KERN_ERR "drxk: %s: i2c write error at addr 0x%02x\n",
+                       pr_err("%s: i2c write error at addr 0x%02x\n",
                               __func__, address);
                        break;
                }
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        status = write16(state, SIO_TOP_COMM_KEY__A, key);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                state->m_osc_clock_freq = 20250;
                break;
        default:
-               printk(KERN_ERR "drxk: Clock Frequency is unknown\n");
+               pr_err("Clock Frequency is unknown\n");
                return -EINVAL;
        }
        /*
        if (status < 0)
                goto error;
 
-       printk(KERN_INFO "drxk: status = 0x%08x\n", sio_top_jtagid_lo);
+       pr_info("status = 0x%08x\n", sio_top_jtagid_lo);
 
        /* driver 0.9.0 */
        switch ((sio_top_jtagid_lo >> 29) & 0xF) {
        default:
                state->m_device_spin = DRXK_SPIN_UNKNOWN;
                status = -EINVAL;
-               printk(KERN_ERR "drxk: Spin %d unknown\n",
-                      (sio_top_jtagid_lo >> 29) & 0xF);
+               pr_err("Spin %d unknown\n", (sio_top_jtagid_lo >> 29) & 0xF);
                goto error2;
        }
        switch ((sio_top_jtagid_lo >> 12) & 0xFF) {
                state->m_has_irqn = false;
                break;
        default:
-               printk(KERN_ERR "drxk: DeviceID 0x%02x not supported\n",
+               pr_err("DeviceID 0x%02x not supported\n",
                        ((sio_top_jtagid_lo >> 12) & 0xFF));
                status = -EINVAL;
                goto error2;
        }
 
-       printk(KERN_INFO
-              "drxk: detected a drx-39%02xk, spin %s, xtal %d.%03d MHz\n",
+       pr_info("detected a drx-39%02xk, spin %s, xtal %d.%03d MHz\n",
               ((sio_top_jtagid_lo >> 12) & 0xFF), spin,
               state->m_osc_clock_freq / 1000,
               state->m_osc_clock_freq % 1000);
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
 error2:
        return status;
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
 error:
        mutex_unlock(&state->mutex);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                        ((time_is_after_jiffies(end))));
 
        if (bl_status == 0x1) {
-               printk(KERN_ERR "drxk: SIO not ready\n");
+               pr_err("SIO not ready\n");
                status = -EINVAL;
                goto error2;
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 error2:
        mutex_unlock(&state->mutex);
        return status;
                offset += sizeof(u16);
 
                if (offset + block_size > length) {
-                       printk(KERN_ERR "drxk: Firmware is corrupted.\n");
+                       pr_err("Firmware is corrupted.\n");
                        return -EINVAL;
                }
 
                status = write_block(state, address, block_size, p_src);
                if (status < 0) {
-                       printk(KERN_ERR "drxk: Error %d while loading firmware\n", status);
+                       pr_err("Error %d while loading firmware\n", status);
                        break;
                }
                p_src += block_size;
                msleep(1);
        } while (1);
        if (data != desired_status) {
-               printk(KERN_ERR "drxk: SIO not ready\n");
+               pr_err("SIO not ready\n");
                return -EINVAL;
        }
        return status;
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
 
        if ((cmd == 0) || ((parameter_len > 0) && (parameter == NULL)) ||
            ((result_len > 0) && (result == NULL))) {
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
                return status;
        }
 
                        goto error;
        } while (!(cur_cmd == DRX_SCU_READY) && (time_is_after_jiffies(end)));
        if (cur_cmd != DRX_SCU_READY) {
-               printk(KERN_ERR "drxk: SCU not ready\n");
+               pr_err("SCU not ready\n");
                status = -EIO;
                goto error2;
        }
                        sprintf(errname, "ERROR: %d\n", err);
                        p = errname;
                }
-               printk(KERN_ERR "drxk: %s while sending cmd 0x%04x with params:", p, cmd);
+               pr_err("%s while sending cmd 0x%04x with params:", p, cmd);
                print_hex_dump_bytes("drxk: ", DUMP_PREFIX_NONE, buffer, cnt);
                status = -EINVAL;
                goto error2;
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 error2:
        mutex_unlock(&state->mutex);
        return status;
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, FEC_OC_SNC_UNLOCK__A, 1);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, FEC_OC_SNC_HWM__A, 12);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        status = write16(state, FEC_OC_TMD_MODE__A, fec_oc_tmd_mode);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MIN__A, p_agc_cfg->top);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        /* get the register value needed for MER */
        status = read16(state, QAM_SL_ERR_POWER__A, &qam_sl_err_power);
        if (status < 0) {
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
                return -EINVAL;
        }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, IQM_AF_PDREF__A, p_pre_saw_cfg->reference);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                        goto error;
        } while ((bl_status == 0x1) && time_is_after_jiffies(end));
        if (bl_status == 0x1) {
-               printk(KERN_ERR "drxk: SIO not ready\n");
+               pr_err("SIO not ready\n");
                status = -EINVAL;
                goto error2;
        }
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 error2:
        mutex_unlock(&state->mutex);
        return status;
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                status = -EINVAL;
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write32(state, IQM_FS_RATE_OFS_LO__A,
                         state->m_iqm_fs_rate_ofs);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
 
        /* AGCInit() not available for DVBT; init done in microcode */
        if (!is_qam(state)) {
-               printk(KERN_ERR "drxk: %s: mode %d is not DVB-C\n", __func__, state->m_operation_mode);
+               pr_err("%s: mode %d is not DVB-C\n",
+                      __func__, state->m_operation_mode);
                return -EINVAL;
        }
 
        status = write16(state, SCU_RAM_AGC_KI__A, data);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        else
                status = read16(state, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, packet_err);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        }                       /* switch (cmd->cmd) */
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        dprintk(1, "\n");
        status = ctrl_power_mode(state, &power_mode);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        else
                status = write16(state, IQM_CF_BYPASSDET__A, 1);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                status = write16(state, OFDM_SC_RA_RAM_FR_THRES_8K__A, 0);
        }
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        status = write16(state, OFDM_SC_RA_RAM_ECHO_THRES__A, data);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                           (u16) *speed);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MAX__A, state->m_dvbt_if_agc_cfg.ingain_tgt_max);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                goto error;
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                status = dvbt_ctrl_set_sqi_speed(state, &state->m_sqi_speed);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
                *p_lock_status = NEVER_LOCK;
 end:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        dprintk(1, "\n");
        status = ctrl_power_mode(state, &power_mode);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        status = write16(state, FEC_OC_SNC_FAIL_PERIOD__A, fec_rs_period);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -86);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -80);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -23);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
        status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -8);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmd_result);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                        SCU_RAM_COMMAND_CMD_DEMOD_GET_LOCK, 0, NULL, 2,
                        result);
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        if (result[1] < SCU_RAM_QAM_LOCKED_LOCKED_DEMOD_LOCKED) {
                /* 0x0000 NOT LOCKED */
                                     number_of_parameters, set_param_parameters,
                                     1, &cmd_result);
        } else {
-               printk(KERN_WARNING "drxk: Unknown QAM demodulator parameter "
-                       "count %d\n", number_of_parameters);
+               pr_warn("Unknown QAM demodulator parameter count %d\n",
+                       number_of_parameters);
                status = -EINVAL;
        }
 
 error:
        if (status < 0)
-               printk(KERN_WARNING "drxk: Warning %d on %s\n",
-                      status, __func__);
+               pr_warn("Warning %d on %s\n", status, __func__);
        return status;
 }
 
 
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                status = write_gpio(state);
        }
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
                status = write_gpio(state);
        }
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        return status;
 }
 
        status = hi_cfg_command(state);
 error:
        if (status < 0)
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
 
        return status;
 }
                if (status < 0)
                        goto error;
 
-               printk(KERN_INFO "DRXK driver version %d.%d.%d\n",
+               pr_info("DRXK driver version %d.%d.%d\n",
                        DRXK_VERSION_MAJOR, DRXK_VERSION_MINOR,
                        DRXK_VERSION_PATCH);
 
        if (status < 0) {
                state->m_drxk_state = DRXK_NO_DEV;
                drxk_i2c_unlock(state);
-               printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
+               pr_err("Error %d on %s\n", status, __func__);
        }
 
        return status;
 
        dprintk(1, ": %s\n", fw ? "firmware loaded" : "firmware not loaded");
        if (!fw) {
-               printk(KERN_ERR
-                      "drxk: Could not load firmware file %s.\n",
+               pr_err("Could not load firmware file %s.\n",
                        state->microcode_name);
-               printk(KERN_INFO
-                      "drxk: Copy %s to your hotplug directory!\n",
+               pr_info("Copy %s to your hotplug directory!\n",
                        state->microcode_name);
                state->microcode_name = NULL;
 
                return -EAGAIN;
 
        if (!fe->ops.tuner_ops.get_if_frequency) {
-               printk(KERN_ERR
-                      "drxk: Error: get_if_frequency() not defined at tuner. Can't work without it!\n");
+               pr_err("Error: get_if_frequency() not defined at tuner. Can't work without it!\n");
                return -EINVAL;
        }
 
                                              GFP_KERNEL,
                                              state, load_firmware_cb);
                        if (status < 0) {
-                               printk(KERN_ERR
-                                      "drxk: failed to request a firmware\n");
+                               pr_err("failed to request a firmware\n");
                                return NULL;
                        }
                }
        p->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
        p->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 
-       printk(KERN_INFO "drxk: frontend initialized.\n");
+       pr_info("frontend initialized.\n");
        return &state->frontend;
 
 error:
-       printk(KERN_ERR "drxk: not found\n");
+       pr_err("not found\n");
        kfree(state);
        return NULL;
 }