Merge remote-tracking branch 'asoc/topic/tlv320aic26' into asoc-next

[deliverable/linux.git] / drivers / block / pktcdvd.c

diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 3dbe42fe1bdd6e7c6a1c46b42ac9d8b81ae49aa6..56188475cfd3e23f9fece3039deee7f721b8a2cf 100644 (file)
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -73,6 +73,10 @@
 
 #define pkt_err(pd, fmt, ...)                                          \
        pr_err("%s: " fmt, pd->name, ##__VA_ARGS__)
+#define pkt_notice(pd, fmt, ...)                                       \
+       pr_notice("%s: " fmt, pd->name, ##__VA_ARGS__)
+#define pkt_info(pd, fmt, ...)                                         \
+       pr_info("%s: " fmt, pd->name, ##__VA_ARGS__)
 
 #define pkt_dbg(level, pd, fmt, ...)                                   \
 do {                                                                   \
@@ -751,17 +755,18 @@ static const char *sense_key_string(__u8 index)
  * A generic sense dump / resolve mechanism should be implemented across
  * all ATAPI + SCSI devices.
  */
-static void pkt_dump_sense(struct packet_command *cgc)
+static void pkt_dump_sense(struct pktcdvd_device *pd,
+                          struct packet_command *cgc)
 {
        struct request_sense *sense = cgc->sense;
 
        if (sense)
-               pr_err("%*ph - sense %02x.%02x.%02x (%s)\n",
-                      CDROM_PACKET_SIZE, cgc->cmd,
-                      sense->sense_key, sense->asc, sense->ascq,
-                      sense_key_string(sense->sense_key));
+               pkt_err(pd, "%*ph - sense %02x.%02x.%02x (%s)\n",
+                       CDROM_PACKET_SIZE, cgc->cmd,
+                       sense->sense_key, sense->asc, sense->ascq,
+                       sense_key_string(sense->sense_key));
        else
-               pr_err("%*ph - no sense\n", CDROM_PACKET_SIZE, cgc->cmd);
+               pkt_err(pd, "%*ph - no sense\n", CDROM_PACKET_SIZE, cgc->cmd);
 }
 
 /*
@@ -804,7 +809,7 @@ static noinline_for_stack int pkt_set_speed(struct pktcdvd_device *pd,
        cgc.cmd[5] = write_speed & 0xff;
 
        if ((ret = pkt_generic_packet(pd, &cgc)))
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
 
        return ret;
 }
@@ -1559,10 +1564,10 @@ work_to_do:
 
 static void pkt_print_settings(struct pktcdvd_device *pd)
 {
-       pr_info("%s packets, %u blocks, Mode-%c disc\n",
-               pd->settings.fp ? "Fixed" : "Variable",
-               pd->settings.size >> 2,
-               pd->settings.block_mode == 8 ? '1' : '2');
+       pkt_info(pd, "%s packets, %u blocks, Mode-%c disc\n",
+                pd->settings.fp ? "Fixed" : "Variable",
+                pd->settings.size >> 2,
+                pd->settings.block_mode == 8 ? '1' : '2');
 }
 
 static int pkt_mode_sense(struct pktcdvd_device *pd, struct packet_command *cgc, int page_code, int page_control)
@@ -1696,7 +1701,7 @@ static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
        init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ);
        cgc.sense = &sense;
        if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0))) {
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
                return ret;
        }
 
@@ -1711,7 +1716,7 @@ static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
        init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ);
        cgc.sense = &sense;
        if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0))) {
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
                return ret;
        }
 
@@ -1753,7 +1758,7 @@ static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
 
        cgc.buflen = cgc.cmd[8] = size;
        if ((ret = pkt_mode_select(pd, &cgc))) {
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
                return ret;
        }
 
@@ -1818,7 +1823,7 @@ static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
         * but i'm not sure, should we leave this to user apps? probably.
         */
        if (di->disc_type == 0xff) {
-               pr_notice("unknown disc - no track?\n");
+               pkt_notice(pd, "unknown disc - no track?\n");
                return 0;
        }
 
@@ -1828,7 +1833,7 @@ static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
        }
 
        if (di->erasable == 0) {
-               pr_notice("disc not erasable\n");
+               pkt_notice(pd, "disc not erasable\n");
                return 0;
        }
 
@@ -1884,7 +1889,7 @@ static noinline_for_stack int pkt_probe_settings(struct pktcdvd_device *pd)
         */
        pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2;
        if (pd->settings.size == 0) {
-               pr_notice("detected zero packet size!\n");
+               pkt_notice(pd, "detected zero packet size!\n");
                return -ENXIO;
        }
        if (pd->settings.size > PACKET_MAX_SECTORS) {
@@ -1965,9 +1970,9 @@ static noinline_for_stack int pkt_write_caching(struct pktcdvd_device *pd,
        ret = pkt_mode_select(pd, &cgc);
        if (ret) {
                pkt_err(pd, "write caching control failed\n");
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
        } else if (!ret && set)
-               pr_notice("enabled write caching on %s\n", pd->name);
+               pkt_notice(pd, "enabled write caching\n");
        return ret;
 }
 
@@ -2003,7 +2008,7 @@ static noinline_for_stack int pkt_get_max_speed(struct pktcdvd_device *pd,
                             sizeof(struct mode_page_header);
                ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
                if (ret) {
-                       pkt_dump_sense(&cgc);
+                       pkt_dump_sense(pd, &cgc);
                        return ret;
                }
        }
@@ -2062,7 +2067,7 @@ static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
        cgc.cmd[8] = 2;
        ret = pkt_generic_packet(pd, &cgc);
        if (ret) {
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
                return ret;
        }
        size = ((unsigned int) buf[0]<<8) + buf[1] + 2;
@@ -2077,16 +2082,16 @@ static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
        cgc.cmd[8] = size;
        ret = pkt_generic_packet(pd, &cgc);
        if (ret) {
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
                return ret;
        }
 
        if (!(buf[6] & 0x40)) {
-               pr_notice("disc type is not CD-RW\n");
+               pkt_notice(pd, "disc type is not CD-RW\n");
                return 1;
        }
        if (!(buf[6] & 0x4)) {
-               pr_notice("A1 values on media are not valid, maybe not CDRW?\n");
+               pkt_notice(pd, "A1 values on media are not valid, maybe not CDRW?\n");
                return 1;
        }
 
@@ -2106,14 +2111,14 @@ static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
                        *speed = us_clv_to_speed[sp];
                        break;
                default:
-                       pr_notice("unknown disc sub-type %d\n", st);
+                       pkt_notice(pd, "unknown disc sub-type %d\n", st);
                        return 1;
        }
        if (*speed) {
-               pr_info("maximum media speed: %d\n", *speed);
+               pkt_info(pd, "maximum media speed: %d\n", *speed);
                return 0;
        } else {
-               pr_notice("unknown speed %d for sub-type %d\n", sp, st);
+               pkt_notice(pd, "unknown speed %d for sub-type %d\n", sp, st);
                return 1;
        }
 }
@@ -2132,7 +2137,7 @@ static noinline_for_stack int pkt_perform_opc(struct pktcdvd_device *pd)
        cgc.cmd[0] = GPCMD_SEND_OPC;
        cgc.cmd[1] = 1;
        if ((ret = pkt_generic_packet(pd, &cgc)))
-               pkt_dump_sense(&cgc);
+               pkt_dump_sense(pd, &cgc);
        return ret;
 }
 
@@ -2237,7 +2242,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
                        ret = -ENOMEM;
                        goto out_putdev;
                }
-               pr_info("%lukB available on disc\n", lba << 1);
+               pkt_info(pd, "%lukB available on disc\n", lba << 1);
        }
 
        return 0;
@@ -2355,8 +2360,8 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
 
        pd = q->queuedata;
        if (!pd) {
-               pkt_err(pd, "%s incorrect request queue\n",
-                       bdevname(bio->bi_bdev, b));
+               pr_err("%s incorrect request queue\n",
+                      bdevname(bio->bi_bdev, b));
                goto end_io;
        }
 
@@ -2378,8 +2383,8 @@ static void pkt_make_request(struct request_queue *q, struct bio *bio)
        }
 
        if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
-               pr_notice("WRITE for ro device %s (%llu)\n",
-                         pd->name, (unsigned long long)bio->bi_sector);
+               pkt_notice(pd, "WRITE for ro device (%llu)\n",
+                          (unsigned long long)bio->bi_sector);
                goto end_io;
        }
 
@@ -2836,7 +2841,7 @@ static int pkt_remove_dev(dev_t pkt_dev)
                        break;
        }
        if (idx == MAX_WRITERS) {
-               pkt_dbg(1, pd, "dev not setup\n");
+               pr_debug("dev not setup\n");
                ret = -ENXIO;
                goto out;
        }