Patchwork [RFC,2/3] atapi: implement GET_EVENT_STATUS_NOTIFICATION command

login
register
mail settings
Submitter Amit Shah
Date March 31, 2011, 7:44 p.m.
Message ID <c117bea4a89acf4d8b515d30cd9e9109160bb858.1301600598.git.amit.shah@redhat.com>
Download mbox | patch
Permalink /patch/89121/
State New
Headers show

Comments

Amit Shah - March 31, 2011, 7:44 p.m.
This commit could be split further; but the main thing it does is
implement this command.  Linux kernels (at least upto 2.6.38.2) need a
fix to the media change handling to recognise size changes.

Signed-off-by: Amit Shah <amit.shah@redhat.com>
---
 hw/ide/core.c     |  138 ++++++++++++++++++++++++++++++++++++++++++++++++----
 hw/ide/internal.h |    6 ++
 2 files changed, 133 insertions(+), 11 deletions(-)

Patch

diff --git a/hw/ide/core.c b/hw/ide/core.c
index e14f2d3..89e212b 100644
--- a/hw/ide/core.c
+++ b/hw/ide/core.c
@@ -1084,27 +1084,142 @@  static int ide_dvd_read_structure(IDEState *s, int format,
     }
 }
 
+static unsigned int event_status_media(IDEState *s,
+                                       uint8_t *buf,
+                                       unsigned int max_len)
+{
+    enum media_event_code {
+        no_change = 0,       /* Status unchanged */
+        eject_requested,     /* received a request from user to eject */
+        new_media,           /* new media inserted and ready for access */
+        media_removal,       /* only for media changers */
+        media_changed,       /* only for media changers */
+        bg_format_completed, /* MRW or DVD+RW b/g format completed */
+        bg_format_restarted, /* MRW or DVD+RW b/g format restarted */
+    };
+    uint8_t event_code, media_status;
+
+    /* TODO: ensure max_len is >= 6 */
+
+    /* Event notification descriptor */
+    event_code = no_change;
+    if (s->events.new_media) {
+        event_code = new_media;
+        s->events.new_media = false;
+    }
+    /*
+     * We never report a 'door or tray opened' state; it's assumed
+     * always closed.
+     */
+    media_status = bdrv_is_inserted(s->bs) ? 2 : 0;
+
+    buf[4] = event_code;
+    buf[5] = media_status;
+
+    return 6; /* We wrote to just 2 extra bytes from the header */
+}
+
+static unsigned int event_status_nea(uint8_t *buf, unsigned int max_len)
+{
+    unsigned int used_len;
+
+    /*
+     * Ensure we don't write on memory we don't have.
+     * max_len of 0 should not produce an error as well.
+     */
+    used_len = 0;
+
+    /* No event descriptor returned */
+    if (max_len > 0) {
+        buf[0] = 0;
+        used_len++;
+    }
+    if (max_len > 1) {
+        buf[1] = 0;
+        used_len++;
+    }
+
+    if (max_len > 3) {
+        buf[2] = 0x80;           /* No Event Available (NEA) */
+        used_len++;
+    }
+    if (max_len > 3) {
+        buf[3] = 0x00;           /* Empty supported event classes */
+        used_len++;
+    }
+    return used_len;
+}
+
 static void handle_get_event_status_notification(IDEState *s,
                                                  uint8_t *buf,
                                                  const uint8_t *packet)
 {
-    unsigned int max_len;
-
-    max_len = ube16_to_cpu(packet + 7);
-
-    if (!(packet[1] & 0x01)) { /* asynchronous mode */
+    enum cdb {
+        polled = 1,
+        request = 4,
+        allocation_length_msb = 7,
+        allocation_length_lsb = 8,
+        control = 9,
+    };
+    enum notification_class_request_type {
+        reserved1 = 1 << 0,
+        operational_change = 1 << 1,
+        power_management = 1 << 2,
+        external_request = 1 << 3,
+        media = 1 << 4,
+        multi_host = 1 << 5,
+        device_busy = 1 << 6,
+        reserved2 = 1 << 7,
+    };
+    enum event_notification_class_field {
+        enc_no_events = 0,
+        enc_operational_change,
+        enc_power_management,
+        enc_external_request,
+        enc_media,
+        enc_multiple_hosts,
+        enc_device_busy,
+        enc_reserved,
+    };
+    unsigned int max_len, used_len;
+    unsigned int supported_events;
+
+    max_len = ube16_to_cpu(packet + allocation_length_msb);
+
+    /* It is fine by the MMC spec to not support async mode operations */
+    if (!(packet[polled] & 0x01)) { /* asynchronous mode */
         /* Only polling is supported, asynchronous mode is not. */
         ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
                             ASC_INV_FIELD_IN_CMD_PACKET);
         return;
     }
 
-    /* polling */
-    /* We don't support any event class (yet). */
-    cpu_to_ube16(buf, 0x00); /* No event descriptor returned */
-    buf[2] = 0x80;           /* No Event Available (NEA) */
-    buf[3] = 0x00;           /* Empty supported event classes */
-    ide_atapi_cmd_reply(s, 4, max_len);
+    /* polling mode operation */
+
+    /*
+     * These are the supported events.
+     *
+     * We currently only support requests of the 'media' type.
+     */
+    supported_events = media;
+
+    /*
+     * Responses to requests are to be based on request priority.  The
+     * notification_class_request_type enum above specifies the
+     * priority: upper elements are higher prio than lower ones.
+     */
+    if (packet[request] & media) {
+
+        /* Event notification header */
+        cpu_to_ube16(buf, max_len);
+        buf[2] = enc_media;
+        buf[3] = supported_events;
+
+        used_len = event_status_media(s, buf, max_len);
+    } else {
+        used_len = event_status_nea(buf, max_len);
+    }
+    ide_atapi_cmd_reply(s, used_len, max_len);
 }
 
 static void ide_atapi_cmd(IDEState *s)
@@ -1623,6 +1738,7 @@  static void cdrom_change_cb(void *opaque, int reason)
     s->sense_key = SENSE_UNIT_ATTENTION;
     s->asc = ASC_MEDIUM_MAY_HAVE_CHANGED;
     s->cdrom_changed = 1;
+    s->events.new_media = true;
     ide_set_irq(s->bus);
 }
 
diff --git a/hw/ide/internal.h b/hw/ide/internal.h
index d533fb6..ba7e9a8 100644
--- a/hw/ide/internal.h
+++ b/hw/ide/internal.h
@@ -373,6 +373,11 @@  typedef int DMAFunc(IDEDMA *);
 typedef int DMAIntFunc(IDEDMA *, int);
 typedef void DMARestartFunc(void *, int, int);
 
+struct unreported_events {
+    bool eject_request;
+    bool new_media;
+};
+
 /* NOTE: IDEState represents in fact one drive */
 struct IDEState {
     IDEBus *bus;
@@ -408,6 +413,7 @@  struct IDEState {
     BlockDriverState *bs;
     char version[9];
     /* ATAPI specific */
+    struct unreported_events events;
     uint8_t sense_key;
     uint8_t asc;
     uint8_t cdrom_changed;