#ifndef BTRFS_SUPER_MAGIC
#define BTRFS_SUPER_MAGIC 0x9123683E
#endif
+#ifndef AT_REMOVEDIR
+#define AT_REMOVEDIR 0x200
+#endif
+#ifndef AT_EMPTY_PATH
+#define AT_EMPTY_PATH 0x1000 /* Allow empty relative pathname */
+#endif
+#ifndef O_PATH
+#define O_PATH 010000000
+#endif
+ #ifdef CONFIG_MARU // added by caramis
+ #ifndef AT_REMOVEDIR
+ #define AT_REMOVEDIR 0x200
+ #endif
+ #ifndef AT_EMPTY_PATH
+ #define AT_EMPTY_PATH 0x1000 /* Allow empty relative pathname */
+ #endif
+ #ifndef O_PATH
+ #define O_PATH 010000000
+ #endif
+ #endif
+
struct handle_data {
int mountfd;
int handle_bytes;
return s->smb.smbus;
}
-static PCIDeviceInfo piix4_pm_info = {
+static Property piix4_pm_properties[] = {
+ #if defined(CONFIG_MARU) && defined(__x86_64__)
+ .qdev.name = "MARU_PM",
+ #else
- .qdev.name = "PIIX4_PM",
+ #endif
- .qdev.desc = "PM",
- .qdev.size = sizeof(PIIX4PMState),
- .qdev.vmsd = &vmstate_acpi,
- .qdev.no_user = 1,
- .no_hotplug = 1,
- .init = piix4_pm_initfn,
- .config_write = pm_write_config,
- .vendor_id = PCI_VENDOR_ID_INTEL,
- .device_id = PCI_DEVICE_ID_INTEL_82371AB_3,
- .revision = 0x03,
- .class_id = PCI_CLASS_BRIDGE_OTHER,
- .qdev.props = (Property[]) {
- DEFINE_PROP_UINT32("smb_io_base", PIIX4PMState, smb_io_base, 0),
- DEFINE_PROP_END_OF_LIST(),
- }
+ DEFINE_PROP_UINT32("smb_io_base", PIIX4PMState, smb_io_base, 0),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void piix4_pm_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->no_hotplug = 1;
+ k->init = piix4_pm_initfn;
+ k->config_write = pm_write_config;
+ k->vendor_id = PCI_VENDOR_ID_INTEL;
+ k->device_id = PCI_DEVICE_ID_INTEL_82371AB_3;
+ k->revision = 0x03;
+ k->class_id = PCI_CLASS_BRIDGE_OTHER;
+ dc->desc = "PM";
+ dc->no_user = 1;
+ dc->vmsd = &vmstate_acpi;
+ dc->props = piix4_pm_properties;
+}
+
+static TypeInfo piix4_pm_info = {
+ .name = "PIIX4_PM",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(PIIX4PMState),
+ .class_init = piix4_pm_class_init,
};
-static void piix4_pm_register(void)
+static void piix4_pm_register_types(void)
{
- pci_qdev_register(&piix4_pm_info);
+ type_register_static(&piix4_pm_info);
}
-device_init(piix4_pm_register);
+type_init(piix4_pm_register_types)
static uint32_t gpe_readb(void *opaque, uint32_t addr)
{
--- /dev/null
- #ifndef CONFIG_MARU
+/*
+ * USB Mass Storage Device emulation
+ *
+ * Copyright (c) 2006 CodeSourcery.
+ * Written by Paul Brook
+ *
+ * This code is licensed under the LGPL.
+ */
+
+#include "qemu-common.h"
+#include "qemu-option.h"
+#include "qemu-config.h"
+#include "hw/usb.h"
+#include "hw/usb/desc.h"
+#include "hw/scsi.h"
+#include "console.h"
+#include "monitor.h"
+#include "sysemu.h"
+#include "blockdev.h"
+
+#ifdef CONFIG_MARU
+#include "../tizen/src/mloop_event.h"
+#endif
+
+//#define DEBUG_MSD
+
+#ifdef DEBUG_MSD
+#define DPRINTF(fmt, ...) \
+do { printf("usb-msd: " fmt , ## __VA_ARGS__); } while (0)
+#else
+#define DPRINTF(fmt, ...) do {} while(0)
+#endif
+
+/* USB requests. */
+#define MassStorageReset 0xff
+#define GetMaxLun 0xfe
+
+enum USBMSDMode {
+ USB_MSDM_CBW, /* Command Block. */
+ USB_MSDM_DATAOUT, /* Transfer data to device. */
+ USB_MSDM_DATAIN, /* Transfer data from device. */
+ USB_MSDM_CSW /* Command Status. */
+};
+
+struct usb_msd_csw {
+ uint32_t sig;
+ uint32_t tag;
+ uint32_t residue;
+ uint8_t status;
+};
+
+typedef struct {
+ USBDevice dev;
+ enum USBMSDMode mode;
+ uint32_t scsi_len;
+ uint8_t *scsi_buf;
+ uint32_t data_len;
+ uint32_t residue;
+ struct usb_msd_csw csw;
+ SCSIRequest *req;
+ SCSIBus bus;
+ BlockConf conf;
+ char *serial;
+ SCSIDevice *scsi_dev;
+ uint32_t removable;
+ /* For async completion. */
+ USBPacket *packet;
+} MSDState;
+
+struct usb_msd_cbw {
+ uint32_t sig;
+ uint32_t tag;
+ uint32_t data_len;
+ uint8_t flags;
+ uint8_t lun;
+ uint8_t cmd_len;
+ uint8_t cmd[16];
+};
+
+enum {
+ STR_MANUFACTURER = 1,
+ STR_PRODUCT,
+ STR_SERIALNUMBER,
+ STR_CONFIG_FULL,
+ STR_CONFIG_HIGH,
+};
+
+static const USBDescStrings desc_strings = {
+ [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
+ [STR_PRODUCT] = "QEMU USB HARDDRIVE",
+ [STR_SERIALNUMBER] = "1",
+ [STR_CONFIG_FULL] = "Full speed config (usb 1.1)",
+ [STR_CONFIG_HIGH] = "High speed config (usb 2.0)",
+};
+
+static const USBDescIface desc_iface_full = {
+ .bInterfaceNumber = 0,
+ .bNumEndpoints = 2,
+ .bInterfaceClass = USB_CLASS_MASS_STORAGE,
+ .bInterfaceSubClass = 0x06, /* SCSI */
+ .bInterfaceProtocol = 0x50, /* Bulk */
+ .eps = (USBDescEndpoint[]) {
+ {
+ .bEndpointAddress = USB_DIR_IN | 0x01,
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+ .wMaxPacketSize = 64,
+ },{
+ .bEndpointAddress = USB_DIR_OUT | 0x02,
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+ .wMaxPacketSize = 64,
+ },
+ }
+};
+
+static const USBDescDevice desc_device_full = {
+ .bcdUSB = 0x0200,
+ .bMaxPacketSize0 = 8,
+ .bNumConfigurations = 1,
+ .confs = (USBDescConfig[]) {
+ {
+ .bNumInterfaces = 1,
+ .bConfigurationValue = 1,
+ .iConfiguration = STR_CONFIG_FULL,
+ .bmAttributes = 0xc0,
+ .nif = 1,
+ .ifs = &desc_iface_full,
+ },
+ },
+};
+
+static const USBDescIface desc_iface_high = {
+ .bInterfaceNumber = 0,
+ .bNumEndpoints = 2,
+ .bInterfaceClass = USB_CLASS_MASS_STORAGE,
+ .bInterfaceSubClass = 0x06, /* SCSI */
+ .bInterfaceProtocol = 0x50, /* Bulk */
+ .eps = (USBDescEndpoint[]) {
+ {
+ .bEndpointAddress = USB_DIR_IN | 0x01,
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+ .wMaxPacketSize = 512,
+ },{
+ .bEndpointAddress = USB_DIR_OUT | 0x02,
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+ .wMaxPacketSize = 512,
+ },
+ }
+};
+
+static const USBDescDevice desc_device_high = {
+ .bcdUSB = 0x0200,
+ .bMaxPacketSize0 = 64,
+ .bNumConfigurations = 1,
+ .confs = (USBDescConfig[]) {
+ {
+ .bNumInterfaces = 1,
+ .bConfigurationValue = 1,
+ .iConfiguration = STR_CONFIG_HIGH,
+ .bmAttributes = 0xc0,
+ .nif = 1,
+ .ifs = &desc_iface_high,
+ },
+ },
+};
+
+static const USBDesc desc = {
+ .id = {
+ .idVendor = 0x46f4, /* CRC16() of "QEMU" */
+ .idProduct = 0x0001,
+ .bcdDevice = 0,
+ .iManufacturer = STR_MANUFACTURER,
+ .iProduct = STR_PRODUCT,
+ .iSerialNumber = STR_SERIALNUMBER,
+ },
+ .full = &desc_device_full,
+ .high = &desc_device_high,
+ .str = desc_strings,
+};
+
+static void usb_msd_copy_data(MSDState *s, USBPacket *p)
+{
+ uint32_t len;
+ len = p->iov.size - p->result;
+ if (len > s->scsi_len)
+ len = s->scsi_len;
+ usb_packet_copy(p, s->scsi_buf, len);
+ s->scsi_len -= len;
+ s->scsi_buf += len;
+ s->data_len -= len;
+ if (s->scsi_len == 0 || s->data_len == 0) {
+ scsi_req_continue(s->req);
+ }
+}
+
+static void usb_msd_send_status(MSDState *s, USBPacket *p)
+{
+ int len;
+
+ DPRINTF("Command status %d tag 0x%x, len %zd\n",
+ s->csw.status, le32_to_cpu(s->csw.tag), p->iov.size);
+
+ assert(s->csw.sig == cpu_to_le32(0x53425355));
+ len = MIN(sizeof(s->csw), p->iov.size);
+ usb_packet_copy(p, &s->csw, len);
+ memset(&s->csw, 0, sizeof(s->csw));
+}
+
+static void usb_msd_transfer_data(SCSIRequest *req, uint32_t len)
+{
+ MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
+ USBPacket *p = s->packet;
+
+ assert((s->mode == USB_MSDM_DATAOUT) == (req->cmd.mode == SCSI_XFER_TO_DEV));
+ s->scsi_len = len;
+ s->scsi_buf = scsi_req_get_buf(req);
+ if (p) {
+ usb_msd_copy_data(s, p);
+ p = s->packet;
+ if (p && p->result == p->iov.size) {
+ /* Set s->packet to NULL before calling usb_packet_complete
+ because another request may be issued before
+ usb_packet_complete returns. */
+ DPRINTF("Packet complete %p\n", p);
+ s->packet = NULL;
+ usb_packet_complete(&s->dev, p);
+ }
+ }
+}
+
+static void usb_msd_command_complete(SCSIRequest *req, uint32_t status, size_t resid)
+{
+ MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
+ USBPacket *p = s->packet;
+
+ DPRINTF("Command complete %d tag 0x%x\n", status, req->tag);
+ s->residue = s->data_len;
+
+ s->csw.sig = cpu_to_le32(0x53425355);
+ s->csw.tag = cpu_to_le32(req->tag);
+ s->csw.residue = cpu_to_le32(s->residue);
+ s->csw.status = status != 0;
+
+ if (s->packet) {
+ if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) {
+ /* A deferred packet with no write data remaining must be
+ the status read packet. */
+ usb_msd_send_status(s, p);
+ s->mode = USB_MSDM_CBW;
+ } else {
+ if (s->data_len) {
+ int len = (p->iov.size - p->result);
+ usb_packet_skip(p, len);
+ s->data_len -= len;
+ }
+ if (s->data_len == 0) {
+ s->mode = USB_MSDM_CSW;
+ }
+ }
+ s->packet = NULL;
+ usb_packet_complete(&s->dev, p);
+ } else if (s->data_len == 0) {
+ s->mode = USB_MSDM_CSW;
+ }
+ scsi_req_unref(req);
+ s->req = NULL;
+}
+
+static void usb_msd_request_cancelled(SCSIRequest *req)
+{
+ MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
+
+ if (req == s->req) {
+ scsi_req_unref(s->req);
+ s->req = NULL;
+ s->scsi_len = 0;
+ }
+}
+
+static void usb_msd_handle_reset(USBDevice *dev)
+{
+ MSDState *s = (MSDState *)dev;
+
+ DPRINTF("Reset\n");
+ if (s->req) {
+ scsi_req_cancel(s->req);
+ }
+ assert(s->req == NULL);
+
+ if (s->packet) {
+ USBPacket *p = s->packet;
+ s->packet = NULL;
+ p->result = USB_RET_STALL;
+ usb_packet_complete(dev, p);
+ }
+
+ s->mode = USB_MSDM_CBW;
+}
+
+static int usb_msd_handle_control(USBDevice *dev, USBPacket *p,
+ int request, int value, int index, int length, uint8_t *data)
+{
+ MSDState *s = (MSDState *)dev;
+ int ret;
+
+ ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
+ if (ret >= 0) {
+ return ret;
+ }
+
+ ret = 0;
+ switch (request) {
+ case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
+ ret = 0;
+ break;
+ /* Class specific requests. */
+ case ClassInterfaceOutRequest | MassStorageReset:
+ /* Reset state ready for the next CBW. */
+ s->mode = USB_MSDM_CBW;
+ ret = 0;
+ break;
+ case ClassInterfaceRequest | GetMaxLun:
+ data[0] = 0;
+ ret = 1;
+ break;
+ default:
+ ret = USB_RET_STALL;
+ break;
+ }
+ return ret;
+}
+
+static void usb_msd_cancel_io(USBDevice *dev, USBPacket *p)
+{
+ MSDState *s = DO_UPCAST(MSDState, dev, dev);
+
+ assert(s->packet == p);
+ s->packet = NULL;
+
+ if (s->req) {
+ scsi_req_cancel(s->req);
+ }
+}
+
+static int usb_msd_handle_data(USBDevice *dev, USBPacket *p)
+{
+ MSDState *s = (MSDState *)dev;
+ uint32_t tag;
+ int ret = 0;
+ struct usb_msd_cbw cbw;
+ uint8_t devep = p->ep->nr;
+
+ switch (p->pid) {
+ case USB_TOKEN_OUT:
+ if (devep != 2)
+ goto fail;
+
+ switch (s->mode) {
+ case USB_MSDM_CBW:
+ if (p->iov.size != 31) {
+ fprintf(stderr, "usb-msd: Bad CBW size");
+ goto fail;
+ }
+ usb_packet_copy(p, &cbw, 31);
+ if (le32_to_cpu(cbw.sig) != 0x43425355) {
+ fprintf(stderr, "usb-msd: Bad signature %08x\n",
+ le32_to_cpu(cbw.sig));
+ goto fail;
+ }
+ DPRINTF("Command on LUN %d\n", cbw.lun);
+ if (cbw.lun != 0) {
+ fprintf(stderr, "usb-msd: Bad LUN %d\n", cbw.lun);
+ goto fail;
+ }
+ tag = le32_to_cpu(cbw.tag);
+ s->data_len = le32_to_cpu(cbw.data_len);
+ if (s->data_len == 0) {
+ s->mode = USB_MSDM_CSW;
+ } else if (cbw.flags & 0x80) {
+ s->mode = USB_MSDM_DATAIN;
+ } else {
+ s->mode = USB_MSDM_DATAOUT;
+ }
+ DPRINTF("Command tag 0x%x flags %08x len %d data %d\n",
+ tag, cbw.flags, cbw.cmd_len, s->data_len);
+ s->residue = 0;
+ s->scsi_len = 0;
+ s->req = scsi_req_new(s->scsi_dev, tag, 0, cbw.cmd, NULL);
+ scsi_req_enqueue(s->req);
+ if (s->req && s->req->cmd.xfer != SCSI_XFER_NONE) {
+ scsi_req_continue(s->req);
+ }
+ ret = p->result;
+ break;
+
+ case USB_MSDM_DATAOUT:
+ DPRINTF("Data out %zd/%d\n", p->iov.size, s->data_len);
+ if (p->iov.size > s->data_len) {
+ goto fail;
+ }
+
+ if (s->scsi_len) {
+ usb_msd_copy_data(s, p);
+ }
+ if (s->residue) {
+ int len = p->iov.size - p->result;
+ if (len) {
+ usb_packet_skip(p, len);
+ s->data_len -= len;
+ if (s->data_len == 0) {
+ s->mode = USB_MSDM_CSW;
+ }
+ }
+ }
+ if (p->result < p->iov.size) {
+ DPRINTF("Deferring packet %p\n", p);
+ s->packet = p;
+ ret = USB_RET_ASYNC;
+ } else {
+ ret = p->result;
+ }
+ break;
+
+ default:
+ DPRINTF("Unexpected write (len %zd)\n", p->iov.size);
+ goto fail;
+ }
+ break;
+
+ case USB_TOKEN_IN:
+ if (devep != 1)
+ goto fail;
+
+ switch (s->mode) {
+ case USB_MSDM_DATAOUT:
+ if (s->data_len != 0 || p->iov.size < 13) {
+ goto fail;
+ }
+ /* Waiting for SCSI write to complete. */
+ s->packet = p;
+ ret = USB_RET_ASYNC;
+ break;
+
+ case USB_MSDM_CSW:
+ if (p->iov.size < 13) {
+ goto fail;
+ }
+
+ if (s->req) {
+ /* still in flight */
+ s->packet = p;
+ ret = USB_RET_ASYNC;
+ } else {
+ usb_msd_send_status(s, p);
+ s->mode = USB_MSDM_CBW;
+ ret = 13;
+ }
+ break;
+
+ case USB_MSDM_DATAIN:
+ DPRINTF("Data in %zd/%d, scsi_len %d\n",
+ p->iov.size, s->data_len, s->scsi_len);
+ if (s->scsi_len) {
+ usb_msd_copy_data(s, p);
+ }
+ if (s->residue) {
+ int len = p->iov.size - p->result;
+ if (len) {
+ usb_packet_skip(p, len);
+ s->data_len -= len;
+ if (s->data_len == 0) {
+ s->mode = USB_MSDM_CSW;
+ }
+ }
+ }
+ if (p->result < p->iov.size) {
+ DPRINTF("Deferring packet %p\n", p);
+ s->packet = p;
+ ret = USB_RET_ASYNC;
+ } else {
+ ret = p->result;
+ }
+ break;
+
+ default:
+ DPRINTF("Unexpected read (len %zd)\n", p->iov.size);
+ goto fail;
+ }
+ break;
+
+ default:
+ DPRINTF("Bad token\n");
+ fail:
+ ret = USB_RET_STALL;
+ break;
+ }
+
+ return ret;
+}
+
+#ifdef CONFIG_MARU
+static void usb_msd_handle_destroy(USBDevice *dev)
+{
+ mloop_evcmd_set_usbdisk(NULL);
+}
+#endif
+
+static void usb_msd_password_cb(void *opaque, int err)
+{
+ MSDState *s = opaque;
+
+ if (!err)
+ err = usb_device_attach(&s->dev);
+
+ if (err)
+ qdev_unplug(&s->dev.qdev, NULL);
+}
+
+static const struct SCSIBusInfo usb_msd_scsi_info = {
+ .tcq = false,
+ .max_target = 0,
+ .max_lun = 0,
+
+ .transfer_data = usb_msd_transfer_data,
+ .complete = usb_msd_command_complete,
+ .cancel = usb_msd_request_cancelled
+};
+
+static int usb_msd_initfn(USBDevice *dev)
+{
+ MSDState *s = DO_UPCAST(MSDState, dev, dev);
+ BlockDriverState *bs = s->conf.bs;
+ DriveInfo *dinfo;
+
+ if (!bs) {
+ error_report("drive property not set");
+ return -1;
+ }
+
+ /*
+ * Hack alert: this pretends to be a block device, but it's really
+ * a SCSI bus that can serve only a single device, which it
+ * creates automatically. But first it needs to detach from its
+ * blockdev, or else scsi_bus_legacy_add_drive() dies when it
+ * attaches again.
+ *
+ * The hack is probably a bad idea.
+ */
+ bdrv_detach_dev(bs, &s->dev.qdev);
+ s->conf.bs = NULL;
+
+ if (!s->serial) {
+ /* try to fall back to value set with legacy -drive serial=... */
+ dinfo = drive_get_by_blockdev(bs);
+ if (*dinfo->serial) {
+ s->serial = strdup(dinfo->serial);
+ }
+ }
+ if (s->serial) {
+ usb_desc_set_string(dev, STR_SERIALNUMBER, s->serial);
+ } else {
+ usb_desc_create_serial(dev);
+ }
+
+ usb_desc_init(dev);
+ scsi_bus_new(&s->bus, &s->dev.qdev, &usb_msd_scsi_info);
+ s->scsi_dev = scsi_bus_legacy_add_drive(&s->bus, bs, 0, !!s->removable,
+ s->conf.bootindex);
+ if (!s->scsi_dev) {
+ return -1;
+ }
+ s->bus.qbus.allow_hotplug = 0;
+ usb_msd_handle_reset(dev);
+
+ if (bdrv_key_required(bs)) {
+ if (cur_mon) {
+ monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb, s);
+ s->dev.auto_attach = 0;
+ } else {
+ autostart = 0;
+ }
+ }
+
+ return 0;
+}
+
+static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
+{
+ static int nr=0;
+ char id[8];
+ QemuOpts *opts;
+ DriveInfo *dinfo;
+ USBDevice *dev;
- #endif
+ const char *p1;
+ char fmt[32];
+
+ /* parse -usbdevice disk: syntax into drive opts */
+ snprintf(id, sizeof(id), "usb%d", nr++);
+ opts = qemu_opts_create(qemu_find_opts("drive"), id, 0);
+#ifndef CONFIG_MARU
+ p1 = strchr(filename, ':');
+ if (p1++) {
+ const char *p2;
+
+ if (strstart(filename, "format=", &p2)) {
+ int len = MIN(p1 - p2, sizeof(fmt));
+ pstrcpy(fmt, len, p2);
+ qemu_opt_set(opts, "format", fmt);
+ } else if (*filename != ':') {
+ printf("unrecognized USB mass-storage option %s\n", filename);
+ return NULL;
+ }
+ filename = p1;
+ }
+#endif
+ if (!*filename) {
+ printf("block device specification needed\n");
+ return NULL;
+ }
+ qemu_opt_set(opts, "file", filename);
+ qemu_opt_set(opts, "if", "none");
+
+ /* create host drive */
+ dinfo = drive_init(opts, 0);
+ if (!dinfo) {
+ qemu_opts_del(opts);
+ return NULL;
+ }
+
+ /* create guest device */
+ dev = usb_create(bus, "usb-storage");
+ if (!dev) {
+ return NULL;
+ }
+ if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) {
+ qdev_free(&dev->qdev);
+ return NULL;
+ }
+ if (qdev_init(&dev->qdev) < 0)
+ return NULL;
+
+#ifdef CONFIG_MARU
+ mloop_evcmd_set_usbdisk(dev);
+#endif
+
+ return dev;
+}
+
+static const VMStateDescription vmstate_usb_msd = {
+ .name = "usb-storage",
+ .unmigratable = 1, /* FIXME: handle transactions which are in flight */
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .fields = (VMStateField []) {
+ VMSTATE_USB_DEVICE(dev, MSDState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static Property msd_properties[] = {
+ DEFINE_BLOCK_PROPERTIES(MSDState, conf),
+ DEFINE_PROP_STRING("serial", MSDState, serial),
+ DEFINE_PROP_BIT("removable", MSDState, removable, 0, false),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void usb_msd_class_initfn(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
+
+ uc->init = usb_msd_initfn;
+ uc->product_desc = "QEMU USB MSD";
+ uc->usb_desc = &desc;
+ uc->cancel_packet = usb_msd_cancel_io;
+ uc->handle_attach = usb_desc_attach;
+ uc->handle_reset = usb_msd_handle_reset;
+ uc->handle_control = usb_msd_handle_control;
+ uc->handle_data = usb_msd_handle_data;
+#ifdef CONFIG_MARU
+ uc->handle_destroy = usb_msd_handle_destroy;
+#endif
+ dc->fw_name = "storage";
+ dc->vmsd = &vmstate_usb_msd;
+ dc->props = msd_properties;
+}
+
+static TypeInfo msd_info = {
+ .name = "usb-storage",
+ .parent = TYPE_USB_DEVICE,
+ .instance_size = sizeof(MSDState),
+ .class_init = usb_msd_class_initfn,
+};
+
+static void usb_msd_register_types(void)
+{
+ type_register_static(&msd_info);
+ usb_legacy_register("usb-storage", "disk", usb_msd_init);
+}
+
+type_init(usb_msd_register_types)
return 0;
}
#endif
+#endif
+ #ifdef CONFIG_MARU
+ static int maru_virtio_touchscreen_init_pci(PCIDevice *pci_dev)
+ {
+ VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
+ VirtIODevice *vdev;
+
+ vdev = maru_virtio_touchscreen_init(&pci_dev->qdev);
+ if (!vdev) {
+ return -1;
+ }
+ virtio_init_pci(proxy, vdev);
+ return 0;
+ }
+
+ static int maru_virtio_touchscreen_exit_pci(PCIDevice *pci_dev)
+ {
+ VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
+
+ virtio_pci_stop_ioeventfd(proxy);
+ maru_virtio_touchscreen_exit(proxy->vdev);
+ return virtio_exit_pci(pci_dev);
+ }
+ #endif
+
+static Property virtio_blk_properties[] = {
+ DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
+ DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, blk.conf),
+ DEFINE_PROP_STRING("serial", VirtIOPCIProxy, blk.serial),
+#ifdef __linux__
+ DEFINE_PROP_BIT("scsi", VirtIOPCIProxy, blk.scsi, 0, true),
+#endif
+ DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
+ DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
+ DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_blk_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = virtio_blk_init_pci;
+ k->exit = virtio_blk_exit_pci;
+ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+ k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
+ k->revision = VIRTIO_PCI_ABI_VERSION;
+ k->class_id = PCI_CLASS_STORAGE_SCSI;
+ dc->reset = virtio_pci_reset;
+ dc->props = virtio_blk_properties;
+}
+
+static TypeInfo virtio_blk_info = {
+ .name = "virtio-blk-pci",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(VirtIOPCIProxy),
+ .class_init = virtio_blk_class_init,
+};
+
+static Property virtio_net_properties[] = {
+ DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
+ DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
+ DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
+ DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
+ DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy, net.txtimer, TX_TIMER_INTERVAL),
+ DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy, net.txburst, TX_BURST),
+ DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_net_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = virtio_net_init_pci;
+ k->exit = virtio_net_exit_pci;
+ k->romfile = "pxe-virtio.rom";
+ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+ k->device_id = PCI_DEVICE_ID_VIRTIO_NET;
+ k->revision = VIRTIO_PCI_ABI_VERSION;
+ k->class_id = PCI_CLASS_NETWORK_ETHERNET;
+ dc->reset = virtio_pci_reset;
+ dc->props = virtio_net_properties;
+}
+
+static TypeInfo virtio_net_info = {
+ .name = "virtio-net-pci",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(VirtIOPCIProxy),
+ .class_init = virtio_net_class_init,
+};
+
+static Property virtio_serial_properties[] = {
+ DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
+ DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, DEV_NVECTORS_UNSPECIFIED),
+ DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
+ DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
+ DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy, serial.max_virtserial_ports, 31),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_serial_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = virtio_serial_init_pci;
+ k->exit = virtio_serial_exit_pci;
+ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+ k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
+ k->revision = VIRTIO_PCI_ABI_VERSION;
+ k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
+ dc->reset = virtio_pci_reset;
+ dc->props = virtio_serial_properties;
+}
+
+static TypeInfo virtio_serial_info = {
+ .name = "virtio-serial-pci",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(VirtIOPCIProxy),
+ .class_init = virtio_serial_class_init,
+};
+
+static Property virtio_balloon_properties[] = {
+ DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
+ DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_balloon_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = virtio_balloon_init_pci;
+ k->exit = virtio_balloon_exit_pci;
+ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+ k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON;
+ k->revision = VIRTIO_PCI_ABI_VERSION;
+ k->class_id = PCI_CLASS_OTHERS;
+ dc->reset = virtio_pci_reset;
+ dc->props = virtio_balloon_properties;
+}
+
+static TypeInfo virtio_balloon_info = {
+ .name = "virtio-balloon-pci",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(VirtIOPCIProxy),
+ .class_init = virtio_balloon_class_init,
+};
+
+static int virtio_scsi_init_pci(PCIDevice *pci_dev)
+{
+ VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
+ VirtIODevice *vdev;
+
+ vdev = virtio_scsi_init(&pci_dev->qdev, &proxy->scsi);
+ if (!vdev) {
+ return -EINVAL;
+ }
+
+ vdev->nvectors = proxy->nvectors;
+ virtio_init_pci(proxy, vdev);
+
+ /* make the actual value visible */
+ proxy->nvectors = vdev->nvectors;
+ return 0;
+}
+
+static int virtio_scsi_exit_pci(PCIDevice *pci_dev)
+{
+ VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
+
+ virtio_scsi_exit(proxy->vdev);
+ return virtio_exit_pci(pci_dev);
+}
+
+static Property virtio_scsi_properties[] = {
+ DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
+ DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOPCIProxy, host_features, scsi),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_scsi_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = virtio_scsi_init_pci;
+ k->exit = virtio_scsi_exit_pci;
+ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+ k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
+ k->revision = 0x00;
+ k->class_id = PCI_CLASS_STORAGE_SCSI;
+ dc->reset = virtio_pci_reset;
+ dc->props = virtio_scsi_properties;
+}
+
+static TypeInfo virtio_scsi_info = {
+ .name = "virtio-scsi-pci",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(VirtIOPCIProxy),
+ .class_init = virtio_scsi_class_init,
+};
-static PCIDeviceInfo virtio_info[] = {
- {
- .qdev.name = "virtio-blk-pci",
- .qdev.alias = "virtio-blk",
- .qdev.size = sizeof(VirtIOPCIProxy),
- .init = virtio_blk_init_pci,
- .exit = virtio_blk_exit_pci,
- .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
- .device_id = PCI_DEVICE_ID_VIRTIO_BLOCK,
- .revision = VIRTIO_PCI_ABI_VERSION,
- .class_id = PCI_CLASS_STORAGE_SCSI,
- .qdev.props = (Property[]) {
- DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
- DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, block),
- DEFINE_PROP_STRING("serial", VirtIOPCIProxy, block_serial),
- DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
- VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
- DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
- DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
- DEFINE_PROP_END_OF_LIST(),
- },
- .qdev.reset = virtio_pci_reset,
- },{
- .qdev.name = "virtio-net-pci",
- .qdev.alias = "virtio-net",
- .qdev.size = sizeof(VirtIOPCIProxy),
- .init = virtio_net_init_pci,
- .exit = virtio_net_exit_pci,
- .romfile = "pxe-virtio.rom",
- .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
- .device_id = PCI_DEVICE_ID_VIRTIO_NET,
- .revision = VIRTIO_PCI_ABI_VERSION,
- .class_id = PCI_CLASS_NETWORK_ETHERNET,
- .qdev.props = (Property[]) {
- DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
- VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
- DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
- DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
- DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
- DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy,
- net.txtimer, TX_TIMER_INTERVAL),
- DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy,
- net.txburst, TX_BURST),
- DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
- DEFINE_PROP_END_OF_LIST(),
- },
- .qdev.reset = virtio_pci_reset,
- },{
- .qdev.name = "virtio-serial-pci",
- .qdev.alias = "virtio-serial",
- .qdev.size = sizeof(VirtIOPCIProxy),
- .init = virtio_serial_init_pci,
- .exit = virtio_serial_exit_pci,
- .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
- .device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE,
- .revision = VIRTIO_PCI_ABI_VERSION,
- .class_id = PCI_CLASS_COMMUNICATION_OTHER,
- .qdev.props = (Property[]) {
- DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
- VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
- DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
- DEV_NVECTORS_UNSPECIFIED),
- DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
- DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
- DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy,
- serial.max_virtserial_ports, 31),
- DEFINE_PROP_END_OF_LIST(),
- },
- .qdev.reset = virtio_pci_reset,
- },{
- .qdev.name = "virtio-balloon-pci",
- .qdev.alias = "virtio-balloon",
- .qdev.size = sizeof(VirtIOPCIProxy),
- .init = virtio_balloon_init_pci,
- .exit = virtio_balloon_exit_pci,
- .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
- .device_id = PCI_DEVICE_ID_VIRTIO_BALLOON,
- .revision = VIRTIO_PCI_ABI_VERSION,
- .class_id = PCI_CLASS_MEMORY_RAM,
- .qdev.props = (Property[]) {
- DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
- DEFINE_PROP_END_OF_LIST(),
- },
- .qdev.reset = virtio_pci_reset,
- },{
#if defined(CONFIG_MARU) && (!defined(CONFIG_DARWIN))
- .qdev.name = "virtio-gl-pci",
- .qdev.alias = "virtio-gl",
- .qdev.size = sizeof(VirtIOPCIProxy),
- .init = virtio_gl_init_pci,
- .exit = virtio_exit_pci,
- .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
- .device_id = PCI_DEVICE_ID_VIRTIO_GL,
- .revision = VIRTIO_PCI_ABI_VERSION,
- .class_id = PCI_CLASS_OTHERS,
- .qdev.props = (Property[]) {
- DEFINE_PROP_END_OF_LIST(),
- },
- .qdev.reset = virtio_pci_reset,
- },{
+#ifdef CONFIG_VIRTIO_GL
+static void virtio_gl_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = virtio_gl_init_pci;
+ k->exit = virtio_exit_pci;
+ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
+ k->device_id = PCI_DEVICE_ID_VIRTIO_GL;
+ k->revision = VIRTIO_PCI_ABI_VERSION;
+ k->class_id = PCI_CLASS_OTHERS;
+ dc->reset = virtio_pci_reset;
+}
+
+static TypeInfo virtio_gl_info = {
+ .name = "virtio-gl-pci",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(VirtIOPCIProxy),
+ .class_init = virtio_gl_class_init,
+};
+#endif
#endif
- .qdev.name = "virtio-touchscreen-pci",
- .qdev.alias = "virtio-touchscreen",
- .qdev.size = sizeof(VirtIOPCIProxy),
- .init = maru_virtio_touchscreen_init_pci,
- .exit = maru_virtio_touchscreen_exit_pci,
- .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
- .device_id = PCI_DEVICE_ID_VIRTIO_TOUCHSCREEN,
- .revision = VIRTIO_PCI_ABI_VERSION,
- .class_id = PCI_CLASS_OTHERS,
- .qdev.props = (Property[]) {
- DEFINE_PROP_END_OF_LIST(),
- },
- .qdev.reset = virtio_pci_reset,
- },{
-#endif
+ #ifdef CONFIG_MARU
- /* end of list */
- }
++static void maru_virtio_touchscreen_class_init(ObjectClass *klass, void *data)
++{
++ DeviceClass *dc = DEVICE_CLASS(klass);
++ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
++
++ k->init = maru_virtio_touchscreen_init_pci;
++ k->exit = maru_virtio_touchscreen_exit_pci;
++ k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
++ k->device_id = PCI_DEVICE_ID_VIRTIO_TOUCHSCREEN;
++ k->revision = VIRTIO_PCI_ABI_VERSION;
++ k->class_id = PCI_CLASS_OTHERS;
++ dc->reset = virtio_pci_reset;
++}
+
-static void virtio_pci_register_devices(void)
++static TypeInfo maru_virtio_touchscreen_info = {
++ .name = "virtio-touchscreen-pci",
++ .parent = TYPE_PCI_DEVICE,
++ .instance_size = sizeof(VirtIOPCIProxy),
++ .class_init = maru_virtio_touchscreen_class_init,
+ };
++#endif
+
+static void virtio_pci_register_types(void)
{
- pci_qdev_register_many(virtio_info);
+ type_register_static(&virtio_blk_info);
+ type_register_static(&virtio_net_info);
+ type_register_static(&virtio_serial_info);
+ type_register_static(&virtio_balloon_info);
+ type_register_static(&virtio_scsi_info);
+#ifdef CONFIG_VIRTIO_GL
+ type_register_static(&virtio_gl_info);
+#endif
++#ifdef CONFIG_MARU
++ type_register_static(&maru_virtio_touchscreen_info);
++#endif
}
-device_init(virtio_pci_register_devices)
+type_init(virtio_pci_register_types)
void virtio_blk_exit(VirtIODevice *vdev);
void virtio_serial_exit(VirtIODevice *vdev);
void virtio_balloon_exit(VirtIODevice *vdev);
+void virtio_scsi_exit(VirtIODevice *vdev);
+ /* Maru devices */
+ #ifdef CONFIG_MARU
+ VirtIODevice *maru_virtio_touchscreen_init(DeviceState *dev);
+ void maru_virtio_touchscreen_exit(VirtIODevice *vdev);
+ #endif
+
+
#define DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) \
DEFINE_PROP_BIT("indirect_desc", _state, _field, \
VIRTIO_RING_F_INDIRECT_DESC, true), \
QEMU_CFLAGS += -L$(SRC_PATH)/tizen/distrib/libav/$(ARCH)/lib
QEMU_CFLAGS += $(SDL_CFLAGS)
QEMU_CFLAGS += $(GLIB_CFLAGS)
+ifndef CONFIG_DEBUG_EXEC
CFLAGS += -g -O2
+else
+CFLAGS += -g -O0
+endif
ifdef CONFIG_WIN32
- LIBS += -lavformat -lavcodec -lavutil -lm -lopengl32 -lglu32 -lgdi32
+ LIBS += -lavformat -lavcodec -lavutil -lm -lcurl -lopengl32 -lglu32 -lgdi32
endif
ifdef CONFIG_LINUX
- LIBS += -lavformat -lavcodec -lavutil -lm -lGL -lXcomposite -lXext
-LIBS += -lavformat -lavcodec -lavutil -lm -lcurl -lGL
++LIBS += -lavformat -lavcodec -lavutil -lm -lcurl -lGL -lXcomposite -lXext
endif
ifdef CONFIG_DARWIN
# FIXME: disabled codec on Mac now
# maru hardware
obj-i386-y += maru_board.o
obj-i386-y += maru_overlay.o
-ifndef CONFIG_DARWIN
-obj-i386-y += maru_codec.o
-endif
obj-i386-y += maru_pm.o
obj-i386-y += maru_vga.o
-obj-i386-y += maru_brightness.o
-obj-i386-y += maru_usb_touchscreen.o maru_virtio_touchscreen.o
-
-# FIXME: camera disabled
+obj-arm-y += maru_arm_soc.o
+obj-arm-y += maru_arm_board.o
+obj-arm-y += maru_arm_vpci.o
+obj-arm-y += maru_arm_pmu.o
+obj-y += maru_brightness.o
- obj-y += maru_touchscreen.o
++obj-y += maru_usb_touchscreen.o maru_virtio_touchscreen.o
ifndef CONFIG_DARWIN
-obj-i386-$(CONFIG_PCI) += maru_camera_common_pci.o
-obj-i386-$(CONFIG_LINUX) += maru_camera_linux_pci.o
-obj-i386-$(CONFIG_WIN32) += maru_camera_win32_pci.o
+obj-y += maru_codec.o
+obj-$(CONFIG_PCI) += maru_camera_common_pci.o
+obj-$(CONFIG_LINUX) += maru_camera_linux_pci.o
+obj-$(CONFIG_WIN32) += maru_camera_win32_pci.o
endif
ifdef CONFIG_LINUX # libs for maru camera on linux host
- /* \r
-/*
- * Emulator
- *
- * Copyright (C) 2011, 2012 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:
- * SeokYeon Hwang <syeon.hwang@samsung.com>
- * HyunJun Son <hj79.son@samsung.com>
- * MunKyu Im <munkyu.im@samsung.com>
- * GiWoong Kim <giwoong.kim@samsung.com>
- * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- *
- * Contributors:
- * - S-Core Co., Ltd
- *
- */
-
-
-#include "maru_common.h"
-#include <stdlib.h>
-#ifdef CONFIG_SDL
-#include <SDL.h>
-#endif
-#include "emulator.h"
-#include "guest_debug.h"
-#include "sdb.h"
-#include "string.h"
-#include "skin/maruskin_server.h"
-#include "skin/maruskin_client.h"
-#include "guest_server.h"
-#include "debug_ch.h"
-#include "option.h"
-#include "emul_state.h"
-#include "qemu_socket.h"
-#include "build_info.h"
-#include "maru_err_table.h"
-#include <glib.h>
-#include <glib/gstdio.h>
-
-#if defined(CONFIG_WIN32)
-#include <windows.h>
-#elif defined(CONFIG_LINUX)
-#include <linux/version.h>
-#include <sys/utsname.h>
-#include <sys/sysinfo.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#endif
-
-#include "mloop_event.h"
-
-MULTI_DEBUG_CHANNEL(qemu, main);
-
-#define QEMU_ARGS_PREFIX "--qemu-args"
-#define SKIN_ARGS_PREFIX "--skin-args"
-#define IMAGE_PATH_PREFIX "file="
-#define IMAGE_PATH_SUFFIX ",if=virtio"
-#define SDB_PORT_PREFIX "sdb_port="
-#define LOGS_SUFFIX "/logs/"
-#define LOGFILE "emulator.log"
-#define LCD_WIDTH_PREFIX "width="
-#define LCD_HEIGHT_PREFIX "height="
-
-#define MIDBUF 128
-
-int tizen_base_port;
-char tizen_target_path[MAXLEN];
-char logpath[MAXLEN];
-
-static int skin_argc;
-static char **skin_argv;
-static int qemu_argc;
-static char **qemu_argv;
-
-void maru_display_fini(void);
-
-char *get_logpath(void)
-{
- return logpath;
-}
-
-void exit_emulator(void)
-{
- mloop_ev_stop();
- shutdown_skin_server();
- shutdown_guest_server();
-
- maru_display_fini();
-}
-
-void check_shdmem(void)
-{
-#if defined(CONFIG_LINUX)
- int shm_id;
- void *shm_addr;
- u_int port;
- int val;
- struct shmid_ds shm_info;
-
- for (port = 26100; port < 26200; port += 10) {
- shm_id = shmget((key_t)port, 0, 0);
- if (shm_id != -1) {
- shm_addr = shmat(shm_id, (void *)0, 0);
- if ((void *)-1 == shm_addr) {
- ERR("error occured at shmat()\n");
- break;
- }
-
- val = shmctl(shm_id, IPC_STAT, &shm_info);
- if (val != -1) {
- INFO("count of process that use shared memory : %d\n",
- shm_info.shm_nattch);
- if ((shm_info.shm_nattch > 0) &&
- strcmp(tizen_target_path, (char *)shm_addr) == 0) {
- if (check_port_bind_listen(port + 1) > 0) {
- shmdt(shm_addr);
- continue;
- }
- shmdt(shm_addr);
- maru_register_exit_msg(MARU_EXIT_UNKNOWN,
- (char *)"Can not execute this VM.\n \
- The same name is running now.");
- exit(0);
- } else {
- shmdt(shm_addr);
- }
- }
- }
- }
-
-#elif defined(CONFIG_WIN32)
- u_int port;
- char *base_port = NULL;
- char *pBuf;
- HANDLE hMapFile;
- for (port = 26100; port < 26200; port += 10) {
- base_port = g_strdup_printf("%d", port);
- hMapFile = OpenFileMapping(FILE_MAP_READ, TRUE, base_port);
- if (hMapFile == NULL) {
- INFO("port %s is not used.\n", base_port);
- continue;
- } else {
- pBuf = (char *)MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 50);
- if (pBuf == NULL) {
- ERR("Could not map view of file (%d).\n", GetLastError());
- CloseHandle(hMapFile);
- }
-
- if (strcmp(pBuf, tizen_target_path) == 0) {
- maru_register_exit_msg(MARU_EXIT_UNKNOWN,
- "Can not execute this VM.\nThe same name is running now.");
- UnmapViewOfFile(pBuf);
- CloseHandle(hMapFile);
- free(base_port);
- exit(0);
- } else {
- UnmapViewOfFile(pBuf);
- }
- }
-
- CloseHandle(hMapFile);
- free(base_port);
- }
-#elif defined(CONFIG_DARWIN)
- /* TODO: */
-#endif
-}
-
-void make_shdmem(void)
-{
-#if defined(CONFIG_LINUX)
- int shmid;
- char *shared_memory;
-
- shmid = shmget((key_t)tizen_base_port, MAXLEN, 0666|IPC_CREAT);
- if (shmid == -1) {
- ERR("shmget failed\n");
- return;
- }
-
- shared_memory = shmat(shmid, (char *)0x00, 0);
- if (shared_memory == (void *)-1) {
- ERR("shmat failed\n");
- return;
- }
- sprintf(shared_memory, "%s", tizen_target_path);
- INFO("shared memory key: %d value: %s\n",
- tizen_base_port, (char *)shared_memory);
-#elif defined(CONFIG_WIN32)
- HANDLE hMapFile;
- char *pBuf;
- char *port_in_use;
- char *shared_memory;
-
- shared_memory = g_strdup_printf("%s", tizen_target_path);
- port_in_use = g_strdup_printf("%d", tizen_base_port);
- hMapFile = CreateFileMapping(
- INVALID_HANDLE_VALUE, /* use paging file */
- NULL, /* default security */
- PAGE_READWRITE, /* read/write access */
- 0, /* maximum object size (high-order DWORD) */
- 50, /* maximum object size (low-order DWORD) */
- port_in_use); /* name of mapping object */
- if (hMapFile == NULL) {
- ERR("Could not create file mapping object (%d).\n", GetLastError());
- return;
- }
- pBuf = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 50);
-
- if (pBuf == NULL) {
- ERR("Could not map view of file (%d).\n", GetLastError());
- CloseHandle(hMapFile);
- return;
- }
-
- CopyMemory((PVOID)pBuf, shared_memory, strlen(shared_memory));
- free(port_in_use);
- free(shared_memory);
-#elif defined(CONFIG_DARWIN)
- /* TODO: */
-#endif
- return;
-}
-
-static void construct_main_window(int skin_argc, char *skin_argv[],
- int qemu_argc, char *qemu_argv[])
-{
- INFO("construct main window\n");
-
- start_skin_server(skin_argc, skin_argv, qemu_argc, qemu_argv);
-
- /* the next line checks for debugging and etc.. */
- if (get_emul_skin_enable() == 1) {
- if (0 > start_skin_client(skin_argc, skin_argv)) {
- maru_register_exit_msg(MARU_EXIT_SKIN_SERVER_FAILED, NULL);
- exit(-1);
- }
- }
-
- set_emul_caps_lock_state(0);
- set_emul_num_lock_state(0);
-}
-
-static void parse_options(int argc, char *argv[], int *skin_argc,
- char ***skin_argv, int *qemu_argc, char ***qemu_argv)
-{
- int i = 0;
- int j = 0; //skin args index
-
- /* classification */
- for (i = 1; i < argc; ++i) {
- if (strstr(argv[i], SKIN_ARGS_PREFIX)) {
- *skin_argv = &(argv[i + 1]);
- break;
- }
- }
-
- for (j = i; j < argc; ++j) {
- if (strstr(argv[j], QEMU_ARGS_PREFIX)) {
- *skin_argc = j - i - 1;
-
- *qemu_argc = argc - j - i + 1;
- *qemu_argv = &(argv[j]);
-
- argv[j] = argv[0];
- }
- }
-}
-
-static void get_bin_dir(char *exec_argv)
-{
-
- if (!exec_argv) {
- return;
- }
-
- char *data = strdup(exec_argv);
- if (!data) {
- fprintf(stderr, "Fail to strdup for paring a binary directory.\n");
- return;
- }
-
- char *p = NULL;
-#ifdef _WIN32
- p = strrchr(data, '\\');
- if (!p) {
- p = strrchr(data, '/');
- }
-#else
- p = strrchr(data, '/');
-#endif
- if (!p) {
- free(data);
- return;
- }
-
- strncpy(bin_dir, data, strlen(data) - strlen(p));
-
- free(data);
-
-}
-
-void set_image_and_log_path(char *qemu_argv)
-{
- int i, j = 0;
- int name_len = 0;
- int prefix_len = 0;
- int suffix_len = 0;
- int max = 0;
- char *path = malloc(MAXLEN);
- name_len = strlen(qemu_argv);
- prefix_len = strlen(IMAGE_PATH_PREFIX);
- suffix_len = strlen(IMAGE_PATH_SUFFIX);
- max = name_len - suffix_len;
- for (i = prefix_len , j = 0; i < max; i++) {
- path[j++] = qemu_argv[i];
- }
- path[j] = '\0';
- if (!g_path_is_absolute(path)) {
- strcpy(tizen_target_path, g_get_current_dir());
- } else {
- strcpy(tizen_target_path, g_path_get_dirname(path));
- }
-
- strcpy(logpath, tizen_target_path);
- strcat(logpath, LOGS_SUFFIX);
-#ifdef CONFIG_WIN32
- if (access(g_win32_locale_filename_from_utf8(logpath), R_OK) != 0) {
- g_mkdir(g_win32_locale_filename_from_utf8(logpath), 0755);
- }
-#else
- if (access(logpath, R_OK) != 0) {
- g_mkdir(logpath, 0755);
- }
-#endif
- strcat(logpath, LOGFILE);
- set_log_path(logpath);
-}
-
-void redir_output(void)
-{
- FILE *fp;
-
- fp = freopen(logpath, "a+", stdout);
- if (fp == NULL) {
- fprintf(stderr, "log file open error\n");
- }
-
- fp = freopen(logpath, "a+", stderr);
- if (fp == NULL) {
- fprintf(stderr, "log file open error\n");
- }
- setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
- setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
-}
-
-void extract_qemu_info(int qemu_argc, char **qemu_argv)
-{
- int i = 0;
-
- for (i = 0; i < qemu_argc; ++i) {
- if (strstr(qemu_argv[i], IMAGE_PATH_PREFIX) != NULL) {
- set_image_and_log_path(qemu_argv[i]);
- break;
- }
- }
-
- tizen_base_port = get_sdb_base_port();
-}
-
-void extract_skin_info(int skin_argc, char **skin_argv)
-{
- int i = 0;
- int w = 0, h = 0;
-
- for (i = 0; i < skin_argc; ++i) {
- if (strstr(skin_argv[i], LCD_WIDTH_PREFIX) != NULL) {
- char *width_arg = skin_argv[i] + strlen(LCD_WIDTH_PREFIX);
- w = atoi(width_arg);
-
- INFO("lcd width option = %d\n", w);
- } else if (strstr(skin_argv[i], LCD_HEIGHT_PREFIX) != NULL) {
- char *height_arg = skin_argv[i] + strlen(LCD_HEIGHT_PREFIX);
- h = atoi(height_arg);
-
- INFO("lcd height option = %d\n", h);
- }
-
- if (w != 0 && h != 0) {
- set_emul_lcd_size(w, h);
- break;
- }
- }
-}
-
-
-static void system_info(void)
-{
-#define DIV 1024
-
- char timeinfo[64] = {0, };
- struct tm *tm_time;
- struct timeval tval;
-
- INFO("* SDK Version : %s\n", build_version);
- INFO("* Package %s\n", pkginfo_version);
- INFO("* Package %s\n", pkginfo_maintainer);
- INFO("* Git Head : %s\n", pkginfo_githead);
- INFO("* User name : %s\n", g_get_real_name());
- INFO("* Host name : %s\n", g_get_host_name());
-
- /* timestamp */
- INFO("* Build date : %s\n", build_date);
- gettimeofday(&tval, NULL);
- tm_time = localtime(&(tval.tv_sec));
- strftime(timeinfo, sizeof(timeinfo), "%Y/%m/%d %H:%M:%S", tm_time);
- INFO("* Current time : %s\n", timeinfo);
-
-#ifdef CONFIG_SDL
- /* Gets the version of the dynamically linked SDL library */
- INFO("* Host sdl version : (%d, %d, %d)\n",
- SDL_Linked_Version()->major,
- SDL_Linked_Version()->minor,
- SDL_Linked_Version()->patch);
-#endif
-
-#if defined(CONFIG_WIN32)
- /* Retrieves information about the current os */
- OSVERSIONINFO osvi;
- ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
- osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-
- if (GetVersionEx(&osvi)) {
- INFO("* MajorVersion : %d, MinorVersion : %d, BuildNumber : %d, \
- PlatformId : %d, CSDVersion : %s\n", osvi.dwMajorVersion,
- osvi.dwMinorVersion, osvi.dwBuildNumber,
- osvi.dwPlatformId, osvi.szCSDVersion);
- }
-
- /* Retrieves information about the current system */
- SYSTEM_INFO sysi;
- ZeroMemory(&sysi, sizeof(SYSTEM_INFO));
-
- GetSystemInfo(&sysi);
- INFO("* Processor type : %d, Number of processors : %d\n",
- sysi.dwProcessorType, sysi.dwNumberOfProcessors);
-
- MEMORYSTATUSEX memInfo;
- memInfo.dwLength = sizeof(MEMORYSTATUSEX);
- GlobalMemoryStatusEx(&memInfo);
- INFO("* Total Ram : %llu kB, Free: %lld kB\n",
- memInfo.ullTotalPhys / DIV, memInfo.ullAvailPhys / DIV);
-
-#elif defined(CONFIG_LINUX)
- /* depends on building */
- INFO("* Qemu build machine linux kernel version : (%d, %d, %d)\n",
- LINUX_VERSION_CODE >> 16,
- (LINUX_VERSION_CODE >> 8) & 0xff,
- LINUX_VERSION_CODE & 0xff);
-
- /* depends on launching */
- struct utsname host_uname_buf;
- if (uname(&host_uname_buf) == 0) {
- INFO("* Host machine uname : %s %s %s %s %s\n",
- host_uname_buf.sysname, host_uname_buf.nodename,
- host_uname_buf.release, host_uname_buf.version,
- host_uname_buf.machine);
- }
-
- struct sysinfo sys_info;
- if (sysinfo(&sys_info) == 0) {
- INFO("* Total Ram : %llu kB, Free: %llu kB\n",
- sys_info.totalram * (unsigned long long)sys_info.mem_unit / DIV,
- sys_info.freeram * (unsigned long long)sys_info.mem_unit / DIV);
- }
-
- /* pci device description */
- INFO("* Pci devices :\n");
- char lscmd[MAXLEN] = "lspci >> ";
- strcat(lscmd, logpath);
- int i = system(lscmd);
- INFO("system function command : %s, \
- system function returned value : %d\n", lscmd, i);
-
-#elif defined(CONFIG_DARWIN)
- /* TODO: */
-#endif
-
- INFO("\n");
-}
-
-void prepare_maru(void)
-{
- INFO("Prepare maru specified feature\n");
-
- INFO("call construct_main_window\n");
-
- construct_main_window(skin_argc, skin_argv, qemu_argc, qemu_argv);
-
- int guest_server_port = tizen_base_port + SDB_UDP_SENSOR_INDEX;
- start_guest_server(guest_server_port);
-
- mloop_ev_init();
-}
-
-int qemu_main(int argc, char **argv, char **envp);
-
-int main(int argc, char *argv[])
-{
- parse_options(argc, argv, &skin_argc, &skin_argv, &qemu_argc, &qemu_argv);
- get_bin_dir(qemu_argv[0]);
- socket_init();
- extract_qemu_info(qemu_argc, qemu_argv);
-
- INFO("Emulator start !!!\n");
- atexit(maru_atexit);
-
- extract_skin_info(skin_argc, skin_argv);
-
- check_shdmem();
- make_shdmem();
- sdb_setup();
-
- system_info();
-
- INFO("Prepare running...\n");
- /* Redirect stdout and stderr after debug_ch is initialized. */
- redir_output();
-
- int i;
-
- fprintf(stdout, "qemu args : =========================================\n");
- for (i = 0; i < qemu_argc; ++i) {
- fprintf(stdout, "%s ", qemu_argv[i]);
- }
- fprintf(stdout, "\n");
- fprintf(stdout, "=====================================================\n");
-
- fprintf(stdout, "skin args : =========================================\n");
- for (i = 0; i < skin_argc; ++i) {
- fprintf(stdout, "%s ", skin_argv[i]);
- }
- fprintf(stdout, "\n");
- fprintf(stdout, "=====================================================\n");
-
- INFO("qemu main start!\n");
- qemu_main(qemu_argc, qemu_argv, NULL);
-
- exit_emulator();
-
- return 0;
-}
-
++/*\r
+ * Emulator\r
+ *\r
+ * Copyright (C) 2011, 2012 Samsung Electronics Co., Ltd. All rights reserved.\r
+ *\r
- * Contact: \r
++ * Contact:\r
+ * SeokYeon Hwang <syeon.hwang@samsung.com>\r
+ * HyunJun Son <hj79.son@samsung.com>\r
+ * MunKyu Im <munkyu.im@samsung.com>\r
+ * GiWoong Kim <giwoong.kim@samsung.com>\r
+ * YeongKyoon Lee <yeongkyoon.lee@samsung.com>\r
+ *\r
+ * This program is free software; you can redistribute it and/or\r
+ * modify it under the terms of the GNU General Public License\r
+ * as published by the Free Software Foundation; either version 2\r
+ * of the License, or (at your option) any later version.\r
+ *\r
+ * This program is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ * GNU General Public License for more details.\r
+ *\r
+ * You should have received a copy of the GNU General Public License\r
+ * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\r
++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,\r
++ * MA 02110-1301, USA.\r
+ *\r
+ * Contributors:\r
+ * - S-Core Co., Ltd\r
+ *\r
+ */\r
+\r
+\r
++#include "maru_common.h"\r
+#include <stdlib.h>\r
++#ifdef CONFIG_SDL\r
+#include <SDL.h>\r
- #include "maru_common.h"\r
++#endif\r
+#include "emulator.h"\r
++#include "guest_debug.h"\r
+#include "sdb.h"\r
+#include "string.h"\r
+#include "skin/maruskin_server.h"\r
+#include "skin/maruskin_client.h"\r
+#include "guest_server.h"\r
+#include "debug_ch.h"\r
+#include "option.h"\r
+#include "emul_state.h"\r
+#include "qemu_socket.h"\r
+#include "build_info.h"\r
+#include "maru_err_table.h"\r
+#include <glib.h>\r
+#include <glib/gstdio.h>\r
+\r
- #if defined( _WIN32)\r
++#if defined(CONFIG_WIN32)\r
+#include <windows.h>\r
- #elif defined(__linux__)\r
++#elif defined(CONFIG_LINUX)\r
+#include <linux/version.h>\r
+#include <sys/utsname.h>\r
+#include <sys/sysinfo.h>\r
- #include <sys/ipc.h> \r
++#include <sys/ipc.h>\r
+#include <sys/shm.h>\r
- \r
+#endif\r
+\r
+#include "mloop_event.h"\r
+\r
+MULTI_DEBUG_CHANNEL(qemu, main);\r
+\r
- \r
++#define QEMU_ARGS_PREFIX "--qemu-args"\r
++#define SKIN_ARGS_PREFIX "--skin-args"\r
+#define IMAGE_PATH_PREFIX "file="\r
+#define IMAGE_PATH_SUFFIX ",if=virtio"\r
+#define SDB_PORT_PREFIX "sdb_port="\r
+#define LOGS_SUFFIX "/logs/"\r
+#define LOGFILE "emulator.log"\r
++#define LCD_WIDTH_PREFIX "width="\r
++#define LCD_HEIGHT_PREFIX "height="\r
++\r
+#define MIDBUF 128\r
- int tizen_base_port = 0;\r
- static pthread_mutex_t event_mutex = PTHREAD_MUTEX_INITIALIZER;\r
- char tizen_target_path[MAXLEN] = {0, };\r
- char logpath[MAXLEN] = { 0, };\r
+\r
- static int skin_argc = 0;\r
- static char** skin_argv = NULL;\r
- static int qemu_argc = 0;\r
- static char** qemu_argv = NULL;\r
++int tizen_base_port;\r
++char tizen_target_path[MAXLEN];\r
++char logpath[MAXLEN];\r
+\r
- extern void maruskin_sdl_quit(void);\r
++static int skin_argc;\r
++static char **skin_argv;\r
++static int qemu_argc;\r
++static char **qemu_argv;\r
+\r
- void exit_emulator(void)\r
++void maru_display_fini(void);\r
++\r
++char *get_logpath(void)\r
+{\r
- cleanup_multi_touch_state();\r
++ return logpath;\r
++}\r
+\r
++void exit_emulator(void)\r
++{\r
+ mloop_ev_stop();\r
+ shutdown_skin_server();\r
+ shutdown_guest_server();\r
+\r
- maruskin_sdl_quit();\r
++ maru_display_fini();\r
+}\r
+\r
+void check_shdmem(void)\r
+{\r
- #ifndef CONFIG_WIN32\r
++#if defined(CONFIG_LINUX)\r
+ int shm_id;\r
+ void *shm_addr;\r
+ u_int port;\r
+ int val;\r
+ struct shmid_ds shm_info;\r
+\r
- for(port=26100;port < 26200; port += 10)\r
- {\r
- if ( -1 != ( shm_id = shmget( (key_t)port, 0, 0)))\r
- {\r
- if((void *)-1 == (shm_addr = shmat(shm_id, (void *)0, 0)))\r
- {\r
- ERR( "error occured at shmat()\n");\r
++ for (port = 26100; port < 26200; port += 10) {\r
++ shm_id = shmget((key_t)port, 0, 0);\r
++ if (shm_id != -1) {\r
++ shm_addr = shmat(shm_id, (void *)0, 0);\r
++ if ((void *)-1 == shm_addr) {\r
++ ERR("error occured at shmat()\n");\r
+ break;\r
+ }\r
+\r
+ val = shmctl(shm_id, IPC_STAT, &shm_info);\r
- if(val != -1)\r
- {\r
- INFO( "count of process that use shared memory : %d\n", shm_info.shm_nattch);\r
- if(shm_info.shm_nattch > 0 && strcmp(tizen_target_path, (char*)shm_addr) == 0)\r
- {\r
- if(check_port_bind_listen(port+1) > 0){\r
++ if (val != -1) {\r
++ INFO("count of process that use shared memory : %d\n",\r
++ shm_info.shm_nattch);\r
++ if ((shm_info.shm_nattch > 0) &&\r
++ strcmp(tizen_target_path, (char *)shm_addr) == 0) {\r
++ if (check_port_bind_listen(port + 1) > 0) {\r
+ shmdt(shm_addr);\r
+ continue;\r
+ }\r
+ shmdt(shm_addr);\r
- maru_register_exit_msg(MARU_EXIT_UNKNOWN, (char*)"Can not execute this VM.\nThe same name is running now.");\r
++ maru_register_exit_msg(MARU_EXIT_UNKNOWN,\r
++ (char *)"Can not execute this VM.\n \\r
++ The same name is running now.");\r
+ exit(0);\r
- }\r
- else{\r
++ } else {\r
+ shmdt(shm_addr);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
- #else /* _WIN32*/\r
++#elif defined(CONFIG_WIN32)\r
+ u_int port;\r
- char* base_port = NULL;\r
- char* pBuf;\r
++ char *base_port = NULL;\r
++ char *pBuf;\r
+ HANDLE hMapFile;\r
- for(port=26100;port < 26200; port += 10)\r
- {\r
++ for (port = 26100; port < 26200; port += 10) {\r
+ base_port = g_strdup_printf("%d", port);\r
- hMapFile = OpenFileMapping(\r
- FILE_MAP_READ,\r
- TRUE,\r
- base_port);\r
- if(hMapFile == NULL)\r
- {\r
++ hMapFile = OpenFileMapping(FILE_MAP_READ, TRUE, base_port);\r
++ if (hMapFile == NULL) {\r
+ INFO("port %s is not used.\n", base_port);\r
+ continue;\r
- }\r
- else\r
- {\r
- pBuf = (char*)MapViewOfFile(hMapFile,\r
- FILE_MAP_READ,\r
- 0,\r
- 0,\r
- 50);\r
- if (pBuf == NULL)\r
- {\r
++ } else {\r
++ pBuf = (char *)MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 50);\r
++ if (pBuf == NULL) {\r
+ ERR("Could not map view of file (%d).\n", GetLastError());\r
+ CloseHandle(hMapFile);\r
+ }\r
+\r
- if(strcmp(pBuf, tizen_target_path) == 0)\r
- {\r
- /*\r
- if(check_port_bind_listen(port+1) > 0)\r
- {\r
- UnmapViewOfFile(pBuf);\r
- CloseHandle(hMapFile);\r
- continue;\r
- }\r
- */\r
- maru_register_exit_msg(MARU_EXIT_UNKNOWN, "Can not execute this VM.\nThe same name is running now.");\r
++ if (strcmp(pBuf, tizen_target_path) == 0) {\r
++ maru_register_exit_msg(MARU_EXIT_UNKNOWN,\r
++ "Can not execute this VM.\nThe same name is running now.");\r
+ UnmapViewOfFile(pBuf);\r
+ CloseHandle(hMapFile);\r
+ free(base_port);\r
+ exit(0);\r
- }\r
- else\r
++ } else {\r
+ UnmapViewOfFile(pBuf);\r
++ }\r
+ }\r
+\r
+ CloseHandle(hMapFile);\r
+ free(base_port);\r
+ }\r
++#elif defined(CONFIG_DARWIN)\r
++ /* TODO: */\r
+#endif\r
+}\r
+\r
+void make_shdmem(void)\r
+{\r
- #ifndef _WIN32\r
- int shmid; \r
- char *shared_memory;\r
- shmid = shmget((key_t)tizen_base_port, MAXLEN, 0666|IPC_CREAT); \r
- if (shmid == -1) \r
- { \r
- ERR("shmget failed\n"); \r
- return; \r
- } \r
- shared_memory = shmat(shmid, (char*)0x00, 0); \r
- if (shared_memory == (void *)-1) \r
- { \r
- ERR("shmat failed\n"); \r
- return; \r
- } \r
- sprintf(shared_memory, "%s", tizen_target_path);\r
- INFO( "shared memory key: %d value: %s\n", tizen_base_port, (char*)shared_memory);\r
- #else\r
- HANDLE hMapFile;\r
- char* pBuf;\r
- char* port_in_use;\r
- char *shared_memory;\r
- shared_memory = g_strdup_printf("%s", tizen_target_path);\r
- port_in_use = g_strdup_printf("%d", tizen_base_port);\r
++#if defined(CONFIG_LINUX)\r
++ int shmid;\r
++ char *shared_memory;\r
++\r
++ shmid = shmget((key_t)tizen_base_port, MAXLEN, 0666|IPC_CREAT);\r
++ if (shmid == -1) {\r
++ ERR("shmget failed\n");\r
++ return;\r
++ }\r
++\r
++ shared_memory = shmat(shmid, (char *)0x00, 0);\r
++ if (shared_memory == (void *)-1) {\r
++ ERR("shmat failed\n");\r
++ return;\r
++ }\r
++ sprintf(shared_memory, "%s", tizen_target_path);\r
++ INFO("shared memory key: %d value: %s\n",\r
++ tizen_base_port, (char *)shared_memory);\r
++#elif defined(CONFIG_WIN32)\r
++ HANDLE hMapFile;\r
++ char *pBuf;\r
++ char *port_in_use;\r
++ char *shared_memory;\r
++\r
++ shared_memory = g_strdup_printf("%s", tizen_target_path);\r
++ port_in_use = g_strdup_printf("%d", tizen_base_port);\r
+ hMapFile = CreateFileMapping(\r
- INVALID_HANDLE_VALUE, // use paging file\r
- NULL, // default security\r
- PAGE_READWRITE, // read/write access\r
- 0, // maximum object size (high-order DWORD)\r
- 50, // maximum object size (low-order DWORD)\r
- port_in_use); // name of mapping object\r
- if (hMapFile == NULL)\r
- {\r
- ERR("Could not create file mapping object (%d).\n", GetLastError());\r
- return;\r
++ INVALID_HANDLE_VALUE, /* use paging file */\r
++ NULL, /* default security */\r
++ PAGE_READWRITE, /* read/write access */\r
++ 0, /* maximum object size (high-order DWORD) */\r
++ 50, /* maximum object size (low-order DWORD) */\r
++ port_in_use); /* name of mapping object */\r
++ if (hMapFile == NULL) {\r
++ ERR("Could not create file mapping object (%d).\n", GetLastError());\r
++ return;\r
+ }\r
- pBuf = MapViewOfFile(hMapFile, // handle to map object\r
- FILE_MAP_ALL_ACCESS, // read/write permission\r
- 0,\r
- 0,\r
- 50);\r
- \r
- if (pBuf == NULL)\r
- {\r
- ERR("Could not map view of file (%d).\n", GetLastError());\r
- CloseHandle(hMapFile);\r
- return;\r
++ pBuf = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 50);\r
++\r
++ if (pBuf == NULL) {\r
++ ERR("Could not map view of file (%d).\n", GetLastError());\r
++ CloseHandle(hMapFile);\r
++ return;\r
+ }\r
- \r
- CopyMemory((PVOID)pBuf, shared_memory, strlen(shared_memory));\r
- free(port_in_use);\r
- free(shared_memory);\r
++\r
++ CopyMemory((PVOID)pBuf, shared_memory, strlen(shared_memory));\r
++ free(port_in_use);\r
++ free(shared_memory);\r
++#elif defined(CONFIG_DARWIN)\r
++ /* TODO: */\r
+#endif\r
- return;\r
++ return;\r
+}\r
+\r
- \r
- \r
- static void construct_main_window(int skin_argc, char* skin_argv[], int qemu_argc, char* qemu_argv[] )\r
++static void construct_main_window(int skin_argc, char *skin_argv[],\r
++ int qemu_argc, char *qemu_argv[])\r
+{\r
+ INFO("construct main window\n");\r
+\r
- start_skin_server( skin_argc, skin_argv, qemu_argc, qemu_argv );\r
++ start_skin_server(skin_argc, skin_argv, qemu_argc, qemu_argv);\r
+\r
- if (get_emul_skin_enable() == 1) { //this line is check for debugging, etc..\r
- if ( 0 > start_skin_client(skin_argc, skin_argv) ) {\r
++ /* the next line checks for debugging and etc.. */\r
++ if (get_emul_skin_enable() == 1) {\r
++ if (0 > start_skin_client(skin_argc, skin_argv)) {\r
+ maru_register_exit_msg(MARU_EXIT_SKIN_SERVER_FAILED, NULL);\r
- exit( -1 );\r
++ exit(-1);\r
+ }\r
+ }\r
+\r
+ set_emul_caps_lock_state(0);\r
+ set_emul_num_lock_state(0);\r
+}\r
+\r
- static void parse_options(int argc, char* argv[], int* skin_argc, char*** skin_argv, int* qemu_argc, char*** qemu_argv)\r
++static void parse_options(int argc, char *argv[], int *skin_argc,\r
++ char ***skin_argv, int *qemu_argc, char ***qemu_argv)\r
+{\r
- int i;\r
- int j;\r
- \r
- // FIXME !!!\r
- // TODO:\r
- \r
- for(i = 1; i < argc; ++i)\r
- {\r
- if(strncmp(argv[i], "--skin-args", 11) == 0)\r
- {\r
++ int i = 0;\r
++ int j = 0; //skin args index\r
++\r
++ /* classification */\r
++ for (i = 1; i < argc; ++i) {\r
++ if (strstr(argv[i], SKIN_ARGS_PREFIX)) {\r
+ *skin_argv = &(argv[i + 1]);\r
+ break;\r
+ }\r
+ }\r
- for(j = i; j < argc; ++j)\r
- {\r
- if(strncmp(argv[j], "--qemu-args", 11) == 0)\r
- {\r
++\r
++ for (j = i; j < argc; ++j) {\r
++ if (strstr(argv[j], QEMU_ARGS_PREFIX)) {\r
+ *skin_argc = j - i - 1;\r
+\r
+ *qemu_argc = argc - j - i + 1;\r
+ *qemu_argv = &(argv[j]);\r
+\r
+ argv[j] = argv[0];\r
+ }\r
+ }\r
+}\r
+\r
- static void get_bin_dir( char* exec_argv ) {\r
++static void get_bin_dir(char *exec_argv)\r
++{\r
+\r
- if ( !exec_argv ) {\r
++ if (!exec_argv) {\r
+ return;\r
+ }\r
+\r
- char* data = strdup( exec_argv );\r
- if ( !data ) {\r
- fprintf( stderr, "Fail to strdup for paring a binary directory.\n" );\r
++ char *data = strdup(exec_argv);\r
++ if (!data) {\r
++ fprintf(stderr, "Fail to strdup for paring a binary directory.\n");\r
+ return;\r
+ }\r
+\r
- char* p = NULL;\r
++ char *p = NULL;\r
+#ifdef _WIN32\r
- p = strrchr( data, '\\' );\r
- if ( !p ) {\r
- p = strrchr( data, '/' );\r
++ p = strrchr(data, '\\');\r
++ if (!p) {\r
++ p = strrchr(data, '/');\r
+ }\r
+#else\r
- p = strrchr( data, '/' );\r
++ p = strrchr(data, '/');\r
+#endif\r
- if ( !p ) {\r
- free( data );\r
++ if (!p) {\r
++ free(data);\r
+ return;\r
+ }\r
+\r
- strncpy( bin_dir, data, strlen( data ) - strlen( p ) );\r
++ strncpy(bin_dir, data, strlen(data) - strlen(p));\r
+\r
- free( data );\r
++ free(data);\r
+\r
+}\r
+\r
- void set_image_and_log_path(char* qemu_argv)\r
++void set_image_and_log_path(char *qemu_argv)\r
+{\r
- int i;\r
- int j = 0;\r
++ int i, j = 0;\r
+ int name_len = 0;\r
+ int prefix_len = 0;\r
+ int suffix_len = 0;\r
+ int max = 0;\r
+ char *path = malloc(MAXLEN);\r
+ name_len = strlen(qemu_argv);\r
+ prefix_len = strlen(IMAGE_PATH_PREFIX);\r
+ suffix_len = strlen(IMAGE_PATH_SUFFIX);\r
+ max = name_len - suffix_len;\r
- for(i = prefix_len , j = 0; i < max; i++)\r
- {\r
++ for (i = prefix_len , j = 0; i < max; i++) {\r
+ path[j++] = qemu_argv[i];\r
+ }\r
+ path[j] = '\0';\r
- if(!g_path_is_absolute(path))\r
++ if (!g_path_is_absolute(path)) {\r
+ strcpy(tizen_target_path, g_get_current_dir());\r
- else\r
++ } else {\r
+ strcpy(tizen_target_path, g_path_get_dirname(path));\r
++ }\r
+\r
+ strcpy(logpath, tizen_target_path);\r
+ strcat(logpath, LOGS_SUFFIX);\r
- #ifdef _WIN32\r
- if(access(g_win32_locale_filename_from_utf8(logpath), R_OK) != 0) {\r
- g_mkdir(g_win32_locale_filename_from_utf8(logpath), 0755); \r
++#ifdef CONFIG_WIN32\r
++ if (access(g_win32_locale_filename_from_utf8(logpath), R_OK) != 0) {\r
++ g_mkdir(g_win32_locale_filename_from_utf8(logpath), 0755);\r
+ }\r
+#else\r
- if(access(logpath, R_OK) != 0) {\r
- g_mkdir(logpath, 0755); \r
++ if (access(logpath, R_OK) != 0) {\r
++ g_mkdir(logpath, 0755);\r
+ }\r
+#endif\r
- strcat(logpath, LOGFILE);\r
++ strcat(logpath, LOGFILE);\r
+ set_log_path(logpath);\r
+}\r
+\r
+void redir_output(void)\r
+{\r
- FILE *fp;\r
++ FILE *fp;\r
+\r
- fp = freopen(logpath, "a+", stdout);\r
- if(fp ==NULL)\r
- fprintf(stderr, "log file open error\n");\r
- fp = freopen(logpath, "a+", stderr);\r
- if(fp ==NULL)\r
- fprintf(stderr, "log file open error\n");\r
++ fp = freopen(logpath, "a+", stdout);\r
++ if (fp == NULL) {\r
++ fprintf(stderr, "log file open error\n");\r
++ }\r
+\r
- setvbuf(stdout, NULL, _IOLBF, BUFSIZ);\r
- setvbuf(stderr, NULL, _IOLBF, BUFSIZ);\r
++ fp = freopen(logpath, "a+", stderr);\r
++ if (fp == NULL) {\r
++ fprintf(stderr, "log file open error\n");\r
++ }\r
++ setvbuf(stdout, NULL, _IOLBF, BUFSIZ);\r
++ setvbuf(stderr, NULL, _IOLBF, BUFSIZ);\r
+}\r
+\r
- void extract_info(int qemu_argc, char** qemu_argv)\r
++void extract_qemu_info(int qemu_argc, char **qemu_argv)\r
+{\r
- int i;\r
++ int i = 0;\r
+\r
- for(i = 0; i < qemu_argc; ++i)\r
- {\r
- if(strstr(qemu_argv[i], IMAGE_PATH_PREFIX) != NULL) {\r
++ for (i = 0; i < qemu_argc; ++i) {\r
++ if (strstr(qemu_argv[i], IMAGE_PATH_PREFIX) != NULL) {\r
+ set_image_and_log_path(qemu_argv[i]);\r
+ break;\r
+ }\r
+ }\r
- \r
++\r
+ tizen_base_port = get_sdb_base_port();\r
+}\r
+\r
++void extract_skin_info(int skin_argc, char **skin_argv)\r
++{\r
++ int i = 0;\r
++ int w = 0, h = 0;\r
++\r
++ for (i = 0; i < skin_argc; ++i) {\r
++ if (strstr(skin_argv[i], LCD_WIDTH_PREFIX) != NULL) {\r
++ char *width_arg = skin_argv[i] + strlen(LCD_WIDTH_PREFIX);\r
++ w = atoi(width_arg);\r
++\r
++ INFO("lcd width option = %d\n", w);\r
++ } else if (strstr(skin_argv[i], LCD_HEIGHT_PREFIX) != NULL) {\r
++ char *height_arg = skin_argv[i] + strlen(LCD_HEIGHT_PREFIX);\r
++ h = atoi(height_arg);\r
++\r
++ INFO("lcd height option = %d\n", h);\r
++ }\r
++\r
++ if (w != 0 && h != 0) {\r
++ set_emul_lcd_size(w, h);\r
++ break;\r
++ }\r
++ }\r
++}\r
++\r
++\r
+static void system_info(void)\r
+{\r
+#define DIV 1024\r
+\r
+ char timeinfo[64] = {0, };\r
+ struct tm *tm_time;\r
+ struct timeval tval;\r
+\r
+ INFO("* SDK Version : %s\n", build_version);\r
+ INFO("* Package %s\n", pkginfo_version);\r
++ INFO("* Package %s\n", pkginfo_maintainer);\r
++ INFO("* Git Head : %s\n", pkginfo_githead);\r
+ INFO("* User name : %s\n", g_get_real_name());\r
+ INFO("* Host name : %s\n", g_get_host_name());\r
+\r
+ /* timestamp */\r
+ INFO("* Build date : %s\n", build_date);\r
+ gettimeofday(&tval, NULL);\r
+ tm_time = localtime(&(tval.tv_sec));\r
+ strftime(timeinfo, sizeof(timeinfo), "%Y/%m/%d %H:%M:%S", tm_time);\r
+ INFO("* Current time : %s\n", timeinfo);\r
+\r
++#ifdef CONFIG_SDL\r
+ /* Gets the version of the dynamically linked SDL library */\r
+ INFO("* Host sdl version : (%d, %d, %d)\n",\r
- SDL_Linked_Version()->major, SDL_Linked_Version()->minor, SDL_Linked_Version()->patch);\r
++ SDL_Linked_Version()->major,\r
++ SDL_Linked_Version()->minor,\r
++ SDL_Linked_Version()->patch);\r
++#endif\r
+\r
+#if defined(CONFIG_WIN32)\r
+ /* Retrieves information about the current os */\r
+ OSVERSIONINFO osvi;\r
+ ZeroMemory(&osvi, sizeof(OSVERSIONINFO));\r
+ osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);\r
+\r
+ if (GetVersionEx(&osvi)) {\r
- INFO("* MajorVersion : %d, MinorVersion : %d, BuildNumber : %d, PlatformId : %d, CSDVersion : %s\n",\r
- osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber, osvi.dwPlatformId, osvi.szCSDVersion);\r
++ INFO("* MajorVersion : %d, MinorVersion : %d, BuildNumber : %d, \\r
++ PlatformId : %d, CSDVersion : %s\n", osvi.dwMajorVersion,\r
++ osvi.dwMinorVersion, osvi.dwBuildNumber,\r
++ osvi.dwPlatformId, osvi.szCSDVersion);\r
+ }\r
+\r
+ /* Retrieves information about the current system */\r
+ SYSTEM_INFO sysi;\r
+ ZeroMemory(&sysi, sizeof(SYSTEM_INFO));\r
+\r
+ GetSystemInfo(&sysi);\r
- INFO("* Processor type : %d, Number of processors : %d\n", sysi.dwProcessorType, sysi.dwNumberOfProcessors);\r
++ INFO("* Processor type : %d, Number of processors : %d\n",\r
++ sysi.dwProcessorType, sysi.dwNumberOfProcessors);\r
+\r
+ MEMORYSTATUSEX memInfo;\r
+ memInfo.dwLength = sizeof(MEMORYSTATUSEX);\r
+ GlobalMemoryStatusEx(&memInfo);\r
+ INFO("* Total Ram : %llu kB, Free: %lld kB\n",\r
- memInfo.ullTotalPhys / DIV, memInfo.ullAvailPhys / DIV);\r
++ memInfo.ullTotalPhys / DIV, memInfo.ullAvailPhys / DIV);\r
+\r
+#elif defined(CONFIG_LINUX)\r
+ /* depends on building */\r
+ INFO("* Qemu build machine linux kernel version : (%d, %d, %d)\n",\r
- LINUX_VERSION_CODE >> 16, (LINUX_VERSION_CODE >> 8) & 0xff, LINUX_VERSION_CODE & 0xff);\r
++ LINUX_VERSION_CODE >> 16,\r
++ (LINUX_VERSION_CODE >> 8) & 0xff,\r
++ LINUX_VERSION_CODE & 0xff);\r
+\r
+ /* depends on launching */\r
+ struct utsname host_uname_buf;\r
+ if (uname(&host_uname_buf) == 0) {\r
- INFO("* Host machine uname : %s %s %s %s %s\n", host_uname_buf.sysname, host_uname_buf.nodename,\r
- host_uname_buf.release, host_uname_buf.version, host_uname_buf.machine);\r
++ INFO("* Host machine uname : %s %s %s %s %s\n",\r
++ host_uname_buf.sysname, host_uname_buf.nodename,\r
++ host_uname_buf.release, host_uname_buf.version,\r
++ host_uname_buf.machine);\r
+ }\r
+\r
+ struct sysinfo sys_info;\r
+ if (sysinfo(&sys_info) == 0) {\r
+ INFO("* Total Ram : %llu kB, Free: %llu kB\n",\r
+ sys_info.totalram * (unsigned long long)sys_info.mem_unit / DIV,\r
+ sys_info.freeram * (unsigned long long)sys_info.mem_unit / DIV);\r
+ }\r
+\r
+ /* pci device description */\r
+ INFO("* Pci devices :\n");\r
+ char lscmd[MAXLEN] = "lspci >> ";\r
+ strcat(lscmd, logpath);\r
+ int i = system(lscmd);\r
- INFO("system function command : %s, system function returned value : %d\n", lscmd, i);\r
++ INFO("system function command : %s, \\r
++ system function returned value : %d\n", lscmd, i);\r
+\r
+#elif defined(CONFIG_DARWIN)\r
- //TODO:\r
++ /* TODO: */\r
+#endif\r
+\r
+ INFO("\n");\r
+}\r
+\r
+void prepare_maru(void)\r
+{\r
+ INFO("Prepare maru specified feature\n");\r
+\r
+ INFO("call construct_main_window\n");\r
+\r
+ construct_main_window(skin_argc, skin_argv, qemu_argc, qemu_argv);\r
+\r
+ int guest_server_port = tizen_base_port + SDB_UDP_SENSOR_INDEX;\r
- start_guest_server( guest_server_port );\r
++ start_guest_server(guest_server_port);\r
+\r
+ mloop_ev_init();\r
+}\r
+\r
- int qemu_main(int argc, char** argv, char** envp);\r
++int qemu_main(int argc, char **argv, char **envp);\r
+\r
- int main(int argc, char* argv[])\r
++int main(int argc, char *argv[])\r
+{\r
+ parse_options(argc, argv, &skin_argc, &skin_argv, &qemu_argc, &qemu_argv);\r
- get_bin_dir( qemu_argv[0] );\r
++ get_bin_dir(qemu_argv[0]);\r
+ socket_init();\r
- extract_info(qemu_argc, qemu_argv);\r
++ extract_qemu_info(qemu_argc, qemu_argv);\r
+\r
+ INFO("Emulator start !!!\n");\r
- \r
+ atexit(maru_atexit);\r
- \r
- check_shdmem();\r
++\r
++ extract_skin_info(skin_argc, skin_argv);\r
++\r
++ check_shdmem();\r
+ make_shdmem();\r
- sdb_setup();\r
- \r
- system_info();\r
++ sdb_setup();\r
++\r
++ system_info();\r
+\r
+ INFO("Prepare running...\n");\r
- redir_output(); // Redirect stdout, stderr after debug_ch is initialized...\r
++ /* Redirect stdout and stderr after debug_ch is initialized. */\r
++ redir_output();\r
+\r
+ int i;\r
+\r
- fprintf(stdout, "qemu args : ==========================================\n");\r
- for(i = 0; i < qemu_argc; ++i)\r
- {\r
++ fprintf(stdout, "qemu args : =========================================\n");\r
++ for (i = 0; i < qemu_argc; ++i) {\r
+ fprintf(stdout, "%s ", qemu_argv[i]);\r
+ }\r
+ fprintf(stdout, "\n");\r
- fprintf(stdout, "======================================================\n");\r
++ fprintf(stdout, "=====================================================\n");\r
+\r
- fprintf(stdout, "skin args : ==========================================\n");\r
- for(i = 0; i < skin_argc; ++i)\r
- {\r
++ fprintf(stdout, "skin args : =========================================\n");\r
++ for (i = 0; i < skin_argc; ++i) {\r
+ fprintf(stdout, "%s ", skin_argv[i]);\r
+ }\r
+ fprintf(stdout, "\n");\r
- fprintf(stdout, "======================================================\n");\r
++ fprintf(stdout, "=====================================================\n");\r
+\r
+ INFO("qemu main start!\n");\r
+ qemu_main(qemu_argc, qemu_argv, NULL);\r
+\r
+ exit_emulator();\r
+\r
+ return 0;\r
+}\r
+\r
printf("GL VENDOR %s\n", glGetString(GL_VENDOR));
printf("GL RENDERER %s\n", glGetString(GL_RENDERER));
printf("GL VERSION %s\n", glGetString(GL_VERSION));
+ //printf("GLSL VERSION %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
- if (strstr (glGetString(GL_RENDERER), "Software")) {
+ if (strstr((const char*)glGetString(GL_RENDERER), "Software")) {
printf ("Host does not have GL hardware acceleration!\n");
test_failure = 1;
goto TEST_END;
--- /dev/null
+/*
+ * TIZEN ARM base board
+ *
+ * Copyright (c) 2011 - 2012 Samsung Electronics Co., Ltd.
+ *
+ * Based on maru_board.c, exynos4210.c and exynos4210_boards.c
+ *
+ * Author:
+ * Evgeny Voevodin <e.voevodin@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <glib.h>
+
+#include "boards.h"
+#include "arm-misc.h"
+#include "sysbus.h"
+#include "pci.h"
+#include "maru_arm.h"
+#include "i2c.h"
+#include "exec-memory.h"
+#include "../tizen/src/hw/maru_brightness.h"
+#include "arch_init.h"
+
+#undef DEBUG
+//#define DEBUG
+#ifdef DEBUG
+ #undef PRINT_DEBUG
+ #define PRINT_DEBUG(fmt, args...) \
+ do { \
+ fprintf(stderr, " [%s:%d] "fmt, __func__, __LINE__, ##args); \
+ } while (0)
+#else
+ #define PRINT_DEBUG(fmt, args...) do {} while (0)
+#endif
+
+#ifndef DEBUG_LOG_PATH
+#define DEBUG_LOG_PATH "./debug.log"
+#endif
+
+#define EXYNOS4210_WM8994_ADDR 0x1A
+#define MARU_ARM_BOARD_ID 0xF3B
+#define MARU_ARM_BOARD_SMP_BOOTREG_ADDR EXYNOS4210_SECOND_CPU_BOOTREG
+#define MARU_ARM_BOARD_RAMSIZE_MIN 0x20000000
+#define MARU_ARM_BOARD_RAMSIZE_DEFAULT 0x40000000
+
+static struct arm_boot_info maru_arm_board_binfo = {
+ .loader_start = EXYNOS4210_BASE_BOOT_ADDR,
+ .smp_loader_start = EXYNOS4210_SMP_BOOT_ADDR,
+ .nb_cpus = EXYNOS4210_NCPUS,
+ .write_secondary_boot = maru_arm_write_secondary,
+};
+
++/* FIXME: This is a workaround to get get_ram_memory compiled for ARM */
++MemoryRegion *global_ram_memory;
++
++MemoryRegion *get_ram_memory(void)
++{
++ return global_ram_memory;
++}
++
+static void maru_arm_machine_init(ram_addr_t ram_size,
+ const char *boot_device,
+ const char *kernel_filename,
+ const char *kernel_cmdline,
+ const char *initrd_filename,
+ const char *cpu_model)
+{
+ Exynos4210State *s;
+ DeviceState *dev, *i2c_dev;
+ PCIBus *pci_bus;
+
+ if (ram_size < MARU_ARM_BOARD_RAMSIZE_MIN) {
+ ram_size = MARU_ARM_BOARD_RAMSIZE_DEFAULT;
+ fprintf(stderr, "RAM size is too small, setting to default value 0x%lx",
+ (long unsigned int)ram_size);
+ }
+
+ maru_arm_board_binfo.ram_size = ram_size;
+ maru_arm_board_binfo.board_id = MARU_ARM_BOARD_ID;
+ maru_arm_board_binfo.smp_bootreg_addr = MARU_ARM_BOARD_SMP_BOOTREG_ADDR;
+ maru_arm_board_binfo.kernel_filename = kernel_filename;
+ maru_arm_board_binfo.initrd_filename = initrd_filename;
+ maru_arm_board_binfo.kernel_cmdline = kernel_cmdline;
+ maru_arm_board_binfo.gic_cpu_if_addr =
+ EXYNOS4210_SMP_PRIVATE_BASE_ADDR + 0x100;
+
+ PRINT_DEBUG("\n ram_size: %luMiB [0x%08lx]\n"
+ " kernel_filename: %s\n"
+ " kernel_cmdline: %s\n"
+ " initrd_filename: %s\n",
+ (long unsigned int)ram_size / 1048576,
+ (long unsigned int)ram_size,
+ kernel_filename,
+ kernel_cmdline,
+ initrd_filename);
+ s = maru_arm_soc_init(get_system_memory(), ram_size);
+
+ /* PCI config */
+ dev = qdev_create(NULL, "tizen_vpci");
+ s->vpci_bus = sysbus_from_qdev(dev);
+ qdev_init_nofail(dev);
+ sysbus_mmio_map(s->vpci_bus, 0, EXYNOS4210_VPCI_CFG_BASE_ADDR);
+ sysbus_connect_irq(s->vpci_bus, 0, s->irq_table[exynos4210_get_irq(38, 0)]);
+ sysbus_connect_irq(s->vpci_bus, 1, s->irq_table[exynos4210_get_irq(38, 1)]);
+ sysbus_connect_irq(s->vpci_bus, 2, s->irq_table[exynos4210_get_irq(38, 2)]);
+ sysbus_connect_irq(s->vpci_bus, 3, s->irq_table[exynos4210_get_irq(38, 3)]);
+ pci_bus = (PCIBus *)qdev_get_child_bus(dev, "pci");
+
+ pci_create_simple(pci_bus, -1, "pci-ohci");
+ maru_camera_pci_init(pci_bus);
+ codec_init(pci_bus);
+ pci_maru_brightness_init(pci_bus);
+#ifdef CONFIG_YAGL
+ pci_create_simple(pci_bus, -1, "yagl");
+#endif
+
+ audio_init(NULL, pci_bus);
+
+ arm_load_kernel(first_cpu, &maru_arm_board_binfo);
+}
+
+static QEMUMachine maru_arm_machine = {
+ .name = "maru-arm-machine",
+ .desc = "maru board(ARM)",
+ .init = maru_arm_machine_init,
+ .max_cpus = 255,
+};
+
+static void maru_machine_init(void)
+{
+ qemu_register_machine(&maru_arm_machine);
+}
+
+machine_init(maru_machine_init);
# include <xen/hvm/hvm_info_table.h>
#endif
- int maru_camera_pci_init(PCIBus *bus);
+ #include "guest_debug.h"
+
+int codec_init(PCIBus *bus);
+i2c_bus *maru_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base,
+ qemu_irq sci_irq, qemu_irq smi_irq,
+ int kvm_enabled);
+
#define MAX_IDE_BUS 2
static const int ide_iobase[MAX_IDE_BUS] = { 0x1f0, 0x170 };
pci_enabled ? rom_memory : system_memory, &ram_memory);
}
+ // for ramdump...
+ global_ram_memory = ram_memory;
+
gsi_state = g_malloc0(sizeof(*gsi_state));
- gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
+ if (kvm_irqchip_in_kernel()) {
+ kvm_piix3_setup_irq_routing(pci_enabled);
+ gsi = qemu_allocate_irqs(kvm_piix3_gsi_handler, gsi_state,
+ GSI_NUM_PINS);
+ } else {
+ gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
+ }
if (pci_enabled) {
- pci_bus = i440fx_init(&i440fx_state, &piix3_devfn, gsi,
+ pci_bus = i440fx_init(&i440fx_state, &piix3_devfn, &isa_bus, gsi,
system_memory, system_io, ram_size,
below_4g_mem_size,
0x100000000ULL - below_4g_mem_size,
if (pci_enabled && acpi_enabled) {
i2c_bus *smbus;
- if (!xen_enabled()) {
- cmos_s3 = qemu_allocate_irqs(pc_cmos_set_s3_resume, rtc_state, 1);
- } else {
- cmos_s3 = qemu_allocate_irqs(xen_cmos_set_s3_resume, rtc_state, 1);
- }
smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);
/* TODO: Populate SPD eeprom data. */
+ #if defined(__x86_64__)
+ smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
++ gsi[9], *smi_irq, kvm_enabled());
++
+ #else
smbus = maru_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
- gsi[9], *cmos_s3, *smi_irq,
- kvm_enabled());
+ gsi[9], *smi_irq, kvm_enabled());
+ #endif
smbus_eeprom_init(smbus, 8, NULL, 0);
}
#include "pc.h"
+#ifdef TARGET_ARM
+#include "console.h"
+#endif
#include "pci.h"
- #include "maru_pci_ids.h"
+ #include "maru_device_ids.h"
#include "maru_brightness.h"
#include "debug_ch.h"
\r
pci_config_set_interrupt_pin(pci_conf, 0x03);\r
\r
- memory_region_init_ram(&s->vram, NULL, "marucamera.ram", MARUCAM_MEM_SIZE);\r
+ memory_region_init_ram(&s->vram, "marucamera.ram", MARUCAM_MEM_SIZE);\r
s->vaddr = memory_region_get_ram_ptr(&s->vram);\r
+ memset(s->vaddr, 0, MARUCAM_MEM_SIZE);\r
\r
- memory_region_init_io (&s->mmio, &maru_camera_mmio_ops, s, "maru-camera-mmio", MARUCAM_REG_SIZE);\r
+ memory_region_init_io (&s->mmio, &maru_camera_mmio_ops, s,\r
+ "maru-camera-mmio", MARUCAM_REG_SIZE);\r
pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->vram);\r
pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio);\r
\r
qemu_cond_destroy(&s->thread_cond);\r
qemu_mutex_destroy(&s->thread_mutex);\r
\r
- memory_region_destroy (&s->vram);\r
- memory_region_destroy (&s->mmio);\r
+ memory_region_destroy(&s->vram);\r
+ memory_region_destroy(&s->mmio);\r
+\r
+ \r
+ INFO("[%s] camera device was released.\n", __func__);\r
return 0;\r
}\r
\r
\r
void marucam_device_init(MaruCamState* state)\r
{\r
- qemu_thread_create(&state->thread_id, marucam_worker_thread, (void*)state);\r
+ qemu_thread_create(&state->thread_id, marucam_worker_thread, (void*)state,\r
+ QEMU_THREAD_JOINABLE);\r
}\r
\r
- // MARUCAM_CMD_OPEN\r
void marucam_device_open(MaruCamState* state)\r
{\r
- struct v4l2_capability cap;\r
MaruCamParam *param = state->param;\r
\r
param->top = 0;\r
/* define debug channel */
MULTI_DEBUG_CHANNEL(qemu, marucodec);
- static int paramCount = 0;
- static int ctxArrIndex = 0;
+ void codec_thread_init(SVCodecState *s)
+ {
+ TRACE("Enter, %s\n", __func__);
+
- qemu_thread_create(&s->thread_id, codec_worker_thread, (void *)s);
++ qemu_thread_create(&s->thread_id, codec_worker_thread, (void *)s,
++ QEMU_THREAD_JOINABLE);
+
+ TRACE("Leave, %s\n", __func__);
+ }
+
+ void codec_thread_exit(SVCodecState *s)
+ {
+ TRACE("Enter, %s\n", __func__);
+
+ TRACE("destroy mutex and conditional.\n");
+ qemu_mutex_destroy(&s->thread_mutex);
+ qemu_cond_destroy(&s->thread_cond);
+
+ /* qemu_thread_exit((void*)0); */
+ TRACE("Leave, %s\n", __func__);
+ }
+
+ void wake_codec_worker_thread(SVCodecState *s)
+ {
+ TRACE("Enter, %s\n", __func__);
+
+ qemu_cond_signal(&s->thread_cond);
+ TRACE("sent a conditional signal to a worker thread.\n");
+
+ TRACE("Leave, %s\n", __func__);
+ }
+
+ void *codec_worker_thread(void *opaque)
+ {
+ SVCodecState *s = (SVCodecState *)opaque;
+ AVCodecContext *avctx;
+
+ TRACE("Enter, %s\n", __func__);
+ qemu_mutex_lock(&s->thread_mutex);
+
+ while (1) {
+ TRACE("wait conditional signal.\n");
+ qemu_cond_wait(&s->thread_cond, &s->thread_mutex);
+
+ TRACE("wake up a worker thread.\n");
+ avctx = s->ctx_arr[s->codec_param.ctx_index].avctx;
+ /* decode and encode */
+ if (avctx) {
+ if (avctx->codec->decode) {
+ decode_codec(s);
+ } else {
+ encode_codec(s);
+ }
+ } else {
+ ERR("there is a synchrous problem "
+ "between each context.\n");
+ continue;
+ }
+
+ s->thread_state = CODEC_IRQ;
+ qemu_bh_schedule(s->tx_bh);
+ }
+ qemu_mutex_unlock(&s->thread_mutex);
+ TRACE("Leave, %s\n", __func__);
+ }
+
+ int decode_codec(SVCodecState *s)
+ {
+ AVCodecContext *avctx;
+ uint32_t len = 0, ctx_index;
+
+ TRACE("Enter, %s\n", __func__);
+ qemu_mutex_unlock(&s->thread_mutex);
+ /* qemu_mutex_lock(&s->thread_mutex); */
- #define CODEC_COPY_DATA
+ ctx_index = s->codec_param.ctx_index;
+ avctx = s->ctx_arr[ctx_index].avctx;
+ if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+ len = qemu_avcodec_decode_video(s, ctx_index);
+ } else {
+ len = qemu_avcodec_decode_audio(s, ctx_index);
+ }
+
+ /* qemu_mutex_unlock(&s->thread_mutex); */
+ qemu_mutex_lock(&s->thread_mutex);
+
+ TRACE("Leave, %s\n", __func__);
+ return len;
+ }
+
+ int encode_codec(SVCodecState *s)
+ {
+ AVCodecContext *avctx;
+ uint32_t len = 0, ctx_index;
+
+ TRACE("Enter, %s\n", __func__);
+
+ qemu_mutex_unlock(&s->thread_mutex);
+ /* qemu_mutex_lock(&s->thread_mutex); */
+
+ ctx_index = s->codec_param.ctx_index;
+ avctx = s->ctx_arr[ctx_index].avctx;
+ if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+ len = qemu_avcodec_encode_video(s, ctx_index);
+ } else {
+ len = qemu_avcodec_encode_audio(s, ctx_index);
+ }
- static int qemu_serialize_rational(const AVRational* elem, uint8_t* buff)
+ /* qemu_mutex_unlock(&s->thread_mutex); */
+ qemu_mutex_lock(&s->thread_mutex);
+
+ TRACE("Leave, %s\n", __func__);
+ return len;
+ }
+
+ static int qemu_serialize_rational(const AVRational *elem, uint8_t *buff)
{
int size = 0;
INFO("[%s] device init\n", __func__);
- memset(&s->codecParam, 0, sizeof(SVCodecParam));
- pthread_mutex_init(&s->codec_mutex, NULL);
+ memset(&s->codec_param, 0, sizeof(SVCodecParam));
+ /* pthread_mutex_init(&s->codec_mutex, NULL); */
+ #ifndef CODEC_THREAD
+ qemu_mutex_init(&s->thread_mutex);
+ qemu_cond_init(&s->thread_cond);
+
+ codec_thread_init(s);
- pci_config_set_interrupt_pin(pci_conf, 2);
+ s->tx_bh = qemu_bh_new(codec_tx_bh, s);
+ #endif
+
+ pci_config_set_interrupt_pin(pci_conf, 1);
- memory_region_init_ram(&s->vram, NULL, "codec.ram", MARU_CODEC_MEM_SIZE);
+ memory_region_init_ram(&s->vram, "codec.ram", MARU_CODEC_MEM_SIZE);
s->vaddr = memory_region_get_ram_ptr(&s->vram);
- memory_region_init_io (&s->mmio, &codec_mmio_ops, s, "codec-mmio", MARU_CODEC_REG_SIZE);
+ memory_region_init_io(&s->mmio, &codec_mmio_ops, s,
+ "codec-mmio", MARU_CODEC_REG_SIZE);
pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->vram);
pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio);
return 0;
}
-static PCIDeviceInfo codec_info = {
- .qdev.name = MARU_CODEC_DEV_NAME,
- .qdev.desc = "Virtual Codec device for Tizen emulator",
- .qdev.size = sizeof(SVCodecState),
- .init = codec_initfn,
- .exit = codec_exitfn,
- .vendor_id = PCI_VENDOR_ID_TIZEN,
- .device_id = PCI_DEVICE_ID_VIRTUAL_CODEC,
- .class_id = PCI_CLASS_MULTIMEDIA_AUDIO,
+static void codec_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->init = codec_initfn;
+ k->exit = codec_exitfn;
+ k->vendor_id = PCI_VENDOR_ID_TIZEN;
+ k->device_id = PCI_DEVICE_ID_VIRTUAL_CODEC;
+ k->class_id = PCI_CLASS_MULTIMEDIA_AUDIO;
+ dc->desc = "Virtual Codec device for Tizen emulator";
+}
+
+static TypeInfo codec_info = {
+ .name = MARU_CODEC_DEV_NAME,
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(SVCodecState),
+ .class_init = codec_class_init,
};
-static void codec_register(void)
+static void codec_register_types(void)
{
- pci_qdev_register(&codec_info);
+ type_register_static(&codec_info);
}
-device_init(codec_register);
+
+type_init(codec_register_types)
++
return 0;
}
-int pci_maru_overlay_init(PCIBus *bus)
+DeviceState *pci_maru_overlay_init(PCIBus *bus)
{
- pci_create_simple(bus, -1, QEMU_DEV_NAME);
- return 0;
+ INFO("Maru overlay was initailized!\n");
+ return &pci_create_simple(bus, -1, QEMU_DEV_NAME)->qdev;
+}
+
+static void overlay_classinit(ObjectClass *klass, void *data)
+{
+ PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
+
+ k->no_hotplug = 1;
+ k->init = overlay_initfn;
}
-static PCIDeviceInfo overlay_info = {
- .qdev.name = QEMU_DEV_NAME,
- .qdev.size = sizeof(OverlayState),
- .no_hotplug = 1,
- .init = overlay_initfn,
+static TypeInfo overlay_info = {
+ .name = QEMU_DEV_NAME,
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(OverlayState),
+ .class_init = overlay_classinit,
};
-static void overlay_register(void)
+static void overlay_register_types(void)
{
- pci_qdev_register(&overlay_info);
+ type_register_static(&overlay_info);
}
-device_init(overlay_register);
+type_init(overlay_register_types);
}
};
-static struct USBDeviceInfo touchscreen_info = {
- .product_desc = "Maru USB Touchscreen",
- .qdev.name = "usb-maru-touchscreen",
- .qdev.desc = "Maru USB Touchscreen",
- .usbdevice_name = "maru-touchscreen",
- .usb_desc = &desc_touchscreen,
- .qdev.size = sizeof(USBTouchscreenState),
- .qdev.vmsd = &vmsd,
- .init = usb_touchscreen_initfn,
- .handle_packet = usb_generic_handle_packet,
- .handle_reset = usb_touchscreen_handle_reset,
- .handle_control = usb_touchscreen_handle_control,
- .handle_data = usb_touchscreen_handle_data,
- .handle_destroy = usb_touchscreen_handle_destroy,
+static void usb_touchscreen_class_initfn(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
+
+ uc->handle_reset = usb_touchscreen_handle_reset;
+ uc->handle_control = usb_touchscreen_handle_control;
+ uc->handle_data = usb_touchscreen_handle_data;
+ uc->handle_destroy = usb_touchscreen_handle_destroy;
+ uc->init = usb_touchscreen_initfn;
- uc->product_desc = "QEMU Virtual Touchscreen";
++ uc->product_desc = "Maru USB Touchscreen";
+ uc->usb_desc = &desc_touchscreen;
+ dc->vmsd = &vmsd;
- dc->desc = "QEMU Virtual Touchscreen";
++ dc->desc = "Maru USB Touchscreen";
+}
+
+static TypeInfo touchscreen_info = {
+ .name = "usb-maru-touchscreen",
+ .parent = TYPE_USB_DEVICE,
+ .instance_size = sizeof(USBTouchscreenState),
+ .class_init = usb_touchscreen_class_initfn,
};
/**
#include "maru_finger.h"
#include "hw/maru_pm.h"
#include "debug_ch.h"
- #include "SDL_opengl.h"
+ //#include "SDL_opengl.h"
+#ifdef MANGLE_OPENGL_SYMBOLS
+#include "gl_mangled.h"
+#endif
+
MULTI_DEBUG_CHANNEL(tizen, maru_sdl);
-DisplaySurface* qemu_display_surface;
+DisplaySurface* qemu_display_surface = NULL;
- SDL_Surface *surface_screen;
- SDL_Surface *surface_qemu;
- GLuint texture;
+ static SDL_Surface *surface_screen;
+ static SDL_Surface *surface_qemu;
+ static SDL_Surface *processing_screen;
static double current_scale_factor = 1.0;
- static double current_screen_degree = 0.0;
+ static double current_screen_degree;
static int current_screen_width;
static int current_screen_height;
#define SDL_FLAGS (SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL | SDL_NOFRAME)
#define SDL_BPP 32
--
void qemu_ds_sdl_update(DisplayState *ds, int x, int y, int w, int h)
{
/* call sdl update */
break;
}
}
+
+ vga_hw_update();
+
+#ifdef TARGET_ARM
+#ifdef SDL_THREAD
+ pthread_mutex_lock(&sdl_mutex);
+#endif
+
+ /*
+ * It is necessary only for exynos4210 FIMD in connection with
+ * some WM (xfwm4, for example)
+ */
+
+ SDL_UpdateRect(surface_screen, 0, 0, 0, 0);
+
+#ifdef SDL_THREAD
+ pthread_mutex_unlock(&sdl_mutex);
+#endif
+#endif
}
-
-
-
-
- extern int capability_check_gl;
+ //extern int capability_check_gl;
static void _sdl_init(void)
{
int w, h, temp;
if (sdl_opengl == 1) {
glDeleteTextures(1, &texture);
}
+ #endif
+
+ sdl_alteration = -1;
+
+ SDL_Quit();
}
-/* Copyright (C) 2006-2010 The Android Open Source Project
-**
-** This software is licensed under the terms of the GNU General Public
-** License version 2, as published by the Free Software Foundation, and
-** may be copied, distributed, and modified under those terms.
-**
-** This program is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-** GNU General Public License for more details.
-*/
-
-
-#ifdef _WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else /* !_WIN32 */
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <netdb.h>
-#endif /* !_WIN32 */
-
-#include "emulator.h"
-#include "net/slirp.h"
-#include "qemu_socket.h"
-#include "sdb.h"
-#include "nbd.h"
-#include "tizen/src/debug_ch.h"
-
-//DEFAULT_DEBUG_CHANNEL(qemu);
-MULTI_DEBUG_CHANNEL(qemu, sdb);
-
-/* QSOCKET_CALL is used to deal with the fact that EINTR happens pretty
- * easily in QEMU since we use SIGALRM to implement periodic timers
- */
-
-#ifdef _WIN32
-# define QSOCKET_CALL(_ret,_cmd) \
- do { _ret = (_cmd); } while ( _ret < 0 && WSAGetLastError() == WSAEINTR )
-#else
-# define QSOCKET_CALL(_ret,_cmd) \
- do { \
- errno = 0; \
- do { _ret = (_cmd); } while ( _ret < 0 && errno == EINTR ); \
- } while (0);
-#endif
-
-#ifdef _WIN32
-
-#include <errno.h>
-
-static int winsock_error;
-
-#define WINSOCK_ERRORS_LIST \
- EE(WSA_INVALID_HANDLE,EINVAL,"invalid handle") \
-EE(WSA_NOT_ENOUGH_MEMORY,ENOMEM,"not enough memory") \
-EE(WSA_INVALID_PARAMETER,EINVAL,"invalid parameter") \
-EE(WSAEINTR,EINTR,"interrupted function call") \
-EE(WSAEALREADY,EALREADY,"operation already in progress") \
-EE(WSAEBADF,EBADF,"bad file descriptor") \
-EE(WSAEACCES,EACCES,"permission denied") \
-EE(WSAEFAULT,EFAULT,"bad address") \
-EE(WSAEINVAL,EINVAL,"invalid argument") \
-EE(WSAEMFILE,EMFILE,"too many opened files") \
-EE(WSAEWOULDBLOCK,EWOULDBLOCK,"resource temporarily unavailable") \
-EE(WSAEINPROGRESS,EINPROGRESS,"operation now in progress") \
-EE(WSAEALREADY,EAGAIN,"operation already in progress") \
-EE(WSAENOTSOCK,EBADF,"socket operation not on socket") \
-EE(WSAEDESTADDRREQ,EDESTADDRREQ,"destination address required") \
-EE(WSAEMSGSIZE,EMSGSIZE,"message too long") \
-EE(WSAEPROTOTYPE,EPROTOTYPE,"wrong protocol type for socket") \
-EE(WSAENOPROTOOPT,ENOPROTOOPT,"bad protocol option") \
-EE(WSAEADDRINUSE,EADDRINUSE,"address already in use") \
-EE(WSAEADDRNOTAVAIL,EADDRNOTAVAIL,"cannot assign requested address") \
-EE(WSAENETDOWN,ENETDOWN,"network is down") \
-EE(WSAENETUNREACH,ENETUNREACH,"network unreachable") \
-EE(WSAENETRESET,ENETRESET,"network dropped connection on reset") \
-EE(WSAECONNABORTED,ECONNABORTED,"software caused connection abort") \
-EE(WSAECONNRESET,ECONNRESET,"connection reset by peer") \
-EE(WSAENOBUFS,ENOBUFS,"no buffer space available") \
-EE(WSAEISCONN,EISCONN,"socket is already connected") \
-EE(WSAENOTCONN,ENOTCONN,"socket is not connected") \
-EE(WSAESHUTDOWN,ESHUTDOWN,"cannot send after socket shutdown") \
-EE(WSAETOOMANYREFS,ETOOMANYREFS,"too many references") \
-EE(WSAETIMEDOUT,ETIMEDOUT,"connection timed out") \
-EE(WSAECONNREFUSED,ECONNREFUSED,"connection refused") \
-EE(WSAELOOP,ELOOP,"cannot translate name") \
-EE(WSAENAMETOOLONG,ENAMETOOLONG,"name too long") \
-EE(WSAEHOSTDOWN,EHOSTDOWN,"host is down") \
-EE(WSAEHOSTUNREACH,EHOSTUNREACH,"no route to host") \
-
-typedef struct {
- int winsock;
- int unix;
- const char* string;
-} WinsockError;
-
-static const WinsockError _winsock_errors[] = {
-#define EE(w,u,s) { w, u, s },
- WINSOCK_ERRORS_LIST
-#undef EE
- { -1, -1, NULL }
-};
-
-/* this function reads the latest winsock error code and updates
- * errno to a matching value. It also returns the new value of
- * errno.
- */
-static int _fix_errno( void )
-{
- const WinsockError* werr = _winsock_errors;
- int unix = EINVAL; /* generic error code */
-
- winsock_error = WSAGetLastError();
-
- for ( ; werr->string != NULL; werr++ ) {
- if (werr->winsock == winsock_error) {
- unix = werr->unix;
- break;
- }
- }
- errno = unix;
- return -1;
-}
-
-#else
-static int _fix_errno( void )
-{
- return -1;
-}
-
-#endif
-
-#define SOCKET_CALL(cmd) \
- int ret; \
-QSOCKET_CALL(ret, (cmd)); \
-if (ret < 0) \
-return _fix_errno(); \
-return ret; \
-
-int socket_send(int fd, const void* buf, int buflen)
-{
- SOCKET_CALL(send(fd, buf, buflen, 0))
-}
-
-#ifdef _WIN32
-
- static void
-socket_close_handler( void* _fd )
-{
- int fd = (int)_fd;
- int ret;
- char buff[64];
-
- /* we want to drain the read side of the socket before closing it */
- do {
- ret = recv( fd, buff, sizeof(buff), 0 );
- } while (ret < 0 && WSAGetLastError() == WSAEINTR);
-
- if (ret < 0 && WSAGetLastError() == EWOULDBLOCK)
- return;
-
- qemu_set_fd_handler( fd, NULL, NULL, NULL );
- closesocket( fd );
-}
-
- void
-socket_close( int fd )
-{
- int old_errno = errno;
-
- shutdown( fd, SD_BOTH );
- /* we want to drain the socket before closing it */
- qemu_set_fd_handler( fd, socket_close_handler, NULL, (void*)fd );
-
- errno = old_errno;
-}
-
-#else /* !_WIN32 */
-
-#include <unistd.h>
-
- void
-socket_close( int fd )
-{
- int old_errno = errno;
-
- shutdown( fd, SHUT_RDWR );
- close( fd );
-
- errno = old_errno;
-}
-
-#endif /* !_WIN32 */
-
-int inet_strtoip(const char* str, uint32_t *ip)
-{
- int comp[4];
-
- if (sscanf(str, "%d.%d.%d.%d", &comp[0], &comp[1], &comp[2], &comp[3]) != 4)
- return -1;
-
- if ((unsigned)comp[0] >= 256 ||
- (unsigned)comp[1] >= 256 ||
- (unsigned)comp[2] >= 256 ||
- (unsigned)comp[3] >= 256)
- return -1;
-
- *ip = (uint32_t)((comp[0] << 24) | (comp[1] << 16) |
- (comp[2] << 8) | comp[3]);
- return 0;
-}
-
-int check_port_bind_listen(uint32_t port)
-{
- struct sockaddr_in addr;
- int s, opt = 1;
- int ret = -1;
- socklen_t addrlen = sizeof(addr);
- memset(&addr, 0, addrlen);
-
- addr.sin_family = AF_INET;
- addr.sin_addr.s_addr = INADDR_ANY;
- addr.sin_port = htons(port);
-
- if (((s = qemu_socket(AF_INET, SOCK_STREAM, 0)) < 0) ||
-#ifndef _WIN32
- (setsockopt(s, SOL_SOCKET,SO_REUSEADDR, (char *)&opt, sizeof(int)) < 0) ||
-#endif
- (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) ||
- (listen(s, 1) < 0)) {
-
- /* fail */
- ret = -1;
- ERR( "port(%d) listen fail \n", port);
- }else{
- /*fsucess*/
- ret = 1;
- INFO( "port(%d) listen ok \n", port);
- }
-
-#ifdef _WIN32
- closesocket(s);
-#else
- close(s);
-#endif
-
- return ret;
-}
-
-int get_sdb_base_port(void)
-{
- int tries = 10;
- int success = 0;
- uint32_t port = 26100;
-
- if(tizen_base_port == 0){
-
- for ( ; tries > 0; tries--, port += 10 ) {
- if(check_port_bind_listen(port + 1) < 0 )
- continue;
-
- success = 1;
- break;
- }
-
- if (!success) {
- ERR( "it seems too many emulator instances are running on this machine. Aborting\n" );
- exit(1);
- }
-
- tizen_base_port = port;
- INFO( "sdb port is %d \n", tizen_base_port);
- }
-
- return tizen_base_port;
-}
-
-void sdb_setup(void)
-{
- int tries = 10;
- int success = 0;
- uint32_t guest_ip;
- char buf[64] = {0,};
-
- inet_strtoip("10.0.2.16", &guest_ip);
-
- for ( ; tries > 0; tries--, tizen_base_port += 10 ) {
- // redir form [tcp:26101:10.0.2.16:26101]
- sprintf(buf, "tcp:%d:10.0.2.16:26101", tizen_base_port + 1);
- if(net_slirp_redir((char*)buf) < 0)
- continue;
-
- INFO( "SDBD established on port %d\n", tizen_base_port + 1);
- success = 1;
- break;
- }
-
- INFO("redirect [%s] success\n", buf);
- if (!success) {
- ERR( "it seems too many emulator instances are running on this machine. Aborting\n" );
- exit(1);
- }
-
- INFO( "Port(%d/tcp) listen for SDB \n", tizen_base_port + 1);
-
- /* for sensort */
- sprintf(buf, "tcp:%d:10.0.2.16:3577", tizen_base_port + SDB_TCP_EMULD_INDEX );
- if(net_slirp_redir((char*)buf) < 0){
- ERR( "redirect [%s] fail \n", buf);
- }else{
- INFO("redirect [%s] success\n", buf);
- }
-}
-
-int sdb_loopback_client(int port, int type)
-{
- struct sockaddr_in addr;
- int s;
-
- memset(&addr, 0, sizeof(addr));
- addr.sin_family = AF_INET;
- addr.sin_port = htons(port);
- addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-
- s = socket(AF_INET, type, 0);
- if(s < 0) return -1;
-
- if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- close(s);
- return -1;
- }
-
- return s;
-
-}
-
-void notify_sdb_daemon_start(void) {
-
- int s;
- /*
- * send a simple message to the SDB host server to tell it we just started.
- * it should be listening on port 26099.
- */
- char *targetname = g_path_get_basename(tizen_target_path);
- char tmp[MAXPACKETLEN] = { 0 };
- // when connecting to loopback:26099, do not use tcp_socket_outgoing function
- // tcp_socket_outgoing may occur "dns name service not known" in case of network unavaliable status.
- s = sdb_loopback_client(SDB_HOST_PORT, SOCK_STREAM);
- if (s < 0) {
- INFO("can not create socket to talk to the SDB server.\n");
- INFO("SDB server might not be started yet.\n");
- free(targetname);
- return;
- }
-
- /* length is hex host:emulator:port: -> 0x13 = 20 */
- sprintf(tmp, "00%2xhost:emulator:%d:%s", 20 + strlen(targetname), tizen_base_port + 1, targetname);
- INFO("message to send to SDB server: %s\n", tmp);
- if (socket_send(s, tmp, MAXPACKETLEN) < 0) {
- ERR( "message sending to SDB server error!\n");
- }
-
- if (s >= 0)
- socket_close(s);
-
- free(targetname);
-}
+/* Copyright (C) 2006-2010 The Android Open Source Project\r
+**\r
+** This software is licensed under the terms of the GNU General Public\r
+** License version 2, as published by the Free Software Foundation, and\r
+** may be copied, distributed, and modified under those terms.\r
+**\r
+** This program is distributed in the hope that it will be useful,\r
+** but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+** GNU General Public License for more details.\r
+*/\r
+\r
+\r
+#ifdef _WIN32\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#include <ws2tcpip.h>\r
+#else /* !_WIN32 */\r
+#include <sys/ioctl.h>\r
+#include <sys/socket.h>\r
+#include <netinet/in.h>\r
+#include <netinet/tcp.h>\r
+#include <netdb.h>\r
+#endif /* !_WIN32 */\r
+\r
++#include "emulator.h"\r
+#include "net/slirp.h"\r
+#include "qemu_socket.h"\r
+#include "sdb.h"\r
+#include "nbd.h"\r
+#include "tizen/src/debug_ch.h"\r
+\r
+//DEFAULT_DEBUG_CHANNEL(qemu);\r
+MULTI_DEBUG_CHANNEL(qemu, sdb);\r
+\r
+/* QSOCKET_CALL is used to deal with the fact that EINTR happens pretty\r
+ * easily in QEMU since we use SIGALRM to implement periodic timers\r
+ */\r
+\r
+#ifdef _WIN32\r
+# define QSOCKET_CALL(_ret,_cmd) \\r
+ do { _ret = (_cmd); } while ( _ret < 0 && WSAGetLastError() == WSAEINTR )\r
+#else\r
+# define QSOCKET_CALL(_ret,_cmd) \\r
+ do { \\r
+ errno = 0; \\r
+ do { _ret = (_cmd); } while ( _ret < 0 && errno == EINTR ); \\r
+ } while (0);\r
+#endif\r
+\r
+#ifdef _WIN32\r
+\r
+#include <errno.h>\r
+\r
+static int winsock_error;\r
+\r
+#define WINSOCK_ERRORS_LIST \\r
+ EE(WSA_INVALID_HANDLE,EINVAL,"invalid handle") \\r
+EE(WSA_NOT_ENOUGH_MEMORY,ENOMEM,"not enough memory") \\r
+EE(WSA_INVALID_PARAMETER,EINVAL,"invalid parameter") \\r
+EE(WSAEINTR,EINTR,"interrupted function call") \\r
+EE(WSAEALREADY,EALREADY,"operation already in progress") \\r
+EE(WSAEBADF,EBADF,"bad file descriptor") \\r
+EE(WSAEACCES,EACCES,"permission denied") \\r
+EE(WSAEFAULT,EFAULT,"bad address") \\r
+EE(WSAEINVAL,EINVAL,"invalid argument") \\r
+EE(WSAEMFILE,EMFILE,"too many opened files") \\r
+EE(WSAEWOULDBLOCK,EWOULDBLOCK,"resource temporarily unavailable") \\r
+EE(WSAEINPROGRESS,EINPROGRESS,"operation now in progress") \\r
+EE(WSAEALREADY,EAGAIN,"operation already in progress") \\r
+EE(WSAENOTSOCK,EBADF,"socket operation not on socket") \\r
+EE(WSAEDESTADDRREQ,EDESTADDRREQ,"destination address required") \\r
+EE(WSAEMSGSIZE,EMSGSIZE,"message too long") \\r
+EE(WSAEPROTOTYPE,EPROTOTYPE,"wrong protocol type for socket") \\r
+EE(WSAENOPROTOOPT,ENOPROTOOPT,"bad protocol option") \\r
+EE(WSAEADDRINUSE,EADDRINUSE,"address already in use") \\r
+EE(WSAEADDRNOTAVAIL,EADDRNOTAVAIL,"cannot assign requested address") \\r
+EE(WSAENETDOWN,ENETDOWN,"network is down") \\r
+EE(WSAENETUNREACH,ENETUNREACH,"network unreachable") \\r
+EE(WSAENETRESET,ENETRESET,"network dropped connection on reset") \\r
+EE(WSAECONNABORTED,ECONNABORTED,"software caused connection abort") \\r
+EE(WSAECONNRESET,ECONNRESET,"connection reset by peer") \\r
+EE(WSAENOBUFS,ENOBUFS,"no buffer space available") \\r
+EE(WSAEISCONN,EISCONN,"socket is already connected") \\r
+EE(WSAENOTCONN,ENOTCONN,"socket is not connected") \\r
+EE(WSAESHUTDOWN,ESHUTDOWN,"cannot send after socket shutdown") \\r
+EE(WSAETOOMANYREFS,ETOOMANYREFS,"too many references") \\r
+EE(WSAETIMEDOUT,ETIMEDOUT,"connection timed out") \\r
+EE(WSAECONNREFUSED,ECONNREFUSED,"connection refused") \\r
+EE(WSAELOOP,ELOOP,"cannot translate name") \\r
+EE(WSAENAMETOOLONG,ENAMETOOLONG,"name too long") \\r
+EE(WSAEHOSTDOWN,EHOSTDOWN,"host is down") \\r
+EE(WSAEHOSTUNREACH,EHOSTUNREACH,"no route to host") \\r
+\r
+typedef struct {\r
+ int winsock;\r
+ int unix;\r
+ const char* string;\r
+} WinsockError;\r
+\r
+static const WinsockError _winsock_errors[] = {\r
+#define EE(w,u,s) { w, u, s },\r
+ WINSOCK_ERRORS_LIST\r
+#undef EE\r
+ { -1, -1, NULL }\r
+};\r
+\r
+/* this function reads the latest winsock error code and updates\r
+ * errno to a matching value. It also returns the new value of\r
+ * errno.\r
+ */\r
+static int _fix_errno( void )\r
+{\r
+ const WinsockError* werr = _winsock_errors;\r
+ int unix = EINVAL; /* generic error code */\r
+\r
+ winsock_error = WSAGetLastError();\r
+\r
+ for ( ; werr->string != NULL; werr++ ) {\r
+ if (werr->winsock == winsock_error) {\r
+ unix = werr->unix;\r
+ break;\r
+ }\r
+ }\r
+ errno = unix;\r
+ return -1;\r
+}\r
+\r
+#else\r
+static int _fix_errno( void )\r
+{\r
+ return -1;\r
+}\r
+\r
+#endif\r
+\r
+#define SOCKET_CALL(cmd) \\r
+ int ret; \\r
+QSOCKET_CALL(ret, (cmd)); \\r
+if (ret < 0) \\r
+return _fix_errno(); \\r
+return ret; \\r
+\r
+int socket_send(int fd, const void* buf, int buflen)\r
+{\r
+ SOCKET_CALL(send(fd, buf, buflen, 0))\r
+}\r
+\r
+#ifdef _WIN32\r
+\r
+ static void\r
+socket_close_handler( void* _fd )\r
+{\r
+ int fd = (int)_fd;\r
+ int ret;\r
+ char buff[64];\r
+\r
+ /* we want to drain the read side of the socket before closing it */\r
+ do {\r
+ ret = recv( fd, buff, sizeof(buff), 0 );\r
+ } while (ret < 0 && WSAGetLastError() == WSAEINTR);\r
+\r
+ if (ret < 0 && WSAGetLastError() == EWOULDBLOCK)\r
+ return;\r
+\r
+ qemu_set_fd_handler( fd, NULL, NULL, NULL );\r
+ closesocket( fd );\r
+}\r
+\r
+ void\r
+socket_close( int fd )\r
+{\r
+ int old_errno = errno;\r
+\r
+ shutdown( fd, SD_BOTH );\r
+ /* we want to drain the socket before closing it */\r
+ qemu_set_fd_handler( fd, socket_close_handler, NULL, (void*)fd );\r
+\r
+ errno = old_errno;\r
+}\r
+\r
+#else /* !_WIN32 */\r
+\r
+#include <unistd.h>\r
+\r
+ void\r
+socket_close( int fd )\r
+{\r
+ int old_errno = errno;\r
+\r
+ shutdown( fd, SHUT_RDWR );\r
+ close( fd );\r
+\r
+ errno = old_errno;\r
+}\r
+\r
+#endif /* !_WIN32 */\r
+\r
+int inet_strtoip(const char* str, uint32_t *ip)\r
+{\r
+ int comp[4];\r
+\r
+ if (sscanf(str, "%d.%d.%d.%d", &comp[0], &comp[1], &comp[2], &comp[3]) != 4)\r
+ return -1;\r
+\r
+ if ((unsigned)comp[0] >= 256 ||\r
+ (unsigned)comp[1] >= 256 ||\r
+ (unsigned)comp[2] >= 256 ||\r
+ (unsigned)comp[3] >= 256)\r
+ return -1;\r
+\r
+ *ip = (uint32_t)((comp[0] << 24) | (comp[1] << 16) |\r
+ (comp[2] << 8) | comp[3]);\r
+ return 0;\r
+}\r
+\r
- int check_port_bind_listen(u_int port)\r
++int check_port_bind_listen(uint32_t port)\r
+{\r
+ struct sockaddr_in addr;\r
+ int s, opt = 1;\r
+ int ret = -1;\r
+ socklen_t addrlen = sizeof(addr);\r
+ memset(&addr, 0, addrlen);\r
+\r
+ addr.sin_family = AF_INET;\r
+ addr.sin_addr.s_addr = INADDR_ANY;\r
+ addr.sin_port = htons(port);\r
+\r
+ if (((s = qemu_socket(AF_INET, SOCK_STREAM, 0)) < 0) ||\r
+#ifndef _WIN32\r
+ (setsockopt(s, SOL_SOCKET,SO_REUSEADDR, (char *)&opt, sizeof(int)) < 0) ||\r
+#endif\r
+ (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) ||\r
+ (listen(s, 1) < 0)) {\r
+\r
+ /* fail */\r
+ ret = -1;\r
+ ERR( "port(%d) listen fail \n", port);\r
+ }else{\r
+ /*fsucess*/\r
+ ret = 1;\r
+ INFO( "port(%d) listen ok \n", port);\r
+ }\r
+\r
+#ifdef _WIN32\r
+ closesocket(s);\r
+#else\r
+ close(s);\r
+#endif\r
+\r
+ return ret;\r
+}\r
+\r
+int get_sdb_base_port(void)\r
+{\r
+ int tries = 10;\r
+ int success = 0;\r
- u_int port = 26100;\r
++ uint32_t port = 26100;\r
+\r
+ if(tizen_base_port == 0){\r
+\r
+ for ( ; tries > 0; tries--, port += 10 ) {\r
+ if(check_port_bind_listen(port + 1) < 0 )\r
+ continue;\r
+\r
+ success = 1;\r
+ break;\r
+ }\r
+\r
+ if (!success) {\r
+ ERR( "it seems too many emulator instances are running on this machine. Aborting\n" );\r
+ exit(1);\r
+ }\r
+\r
+ tizen_base_port = port;\r
+ INFO( "sdb port is %d \n", tizen_base_port);\r
+ }\r
+\r
+ return tizen_base_port;\r
+}\r
+\r
+void sdb_setup(void)\r
+{\r
+ int tries = 10;\r
+ int success = 0;\r
+ uint32_t guest_ip;\r
+ char buf[64] = {0,};\r
++\r
+ inet_strtoip("10.0.2.16", &guest_ip);\r
+\r
+ for ( ; tries > 0; tries--, tizen_base_port += 10 ) {\r
+ // redir form [tcp:26101:10.0.2.16:26101]\r
+ sprintf(buf, "tcp:%d:10.0.2.16:26101", tizen_base_port + 1);\r
+ if(net_slirp_redir((char*)buf) < 0)\r
+ continue;\r
+\r
+ INFO( "SDBD established on port %d\n", tizen_base_port + 1);\r
+ success = 1;\r
+ break;\r
+ }\r
+\r
+ INFO("redirect [%s] success\n", buf);\r
+ if (!success) {\r
+ ERR( "it seems too many emulator instances are running on this machine. Aborting\n" );\r
+ exit(1);\r
+ }\r
+\r
+ INFO( "Port(%d/tcp) listen for SDB \n", tizen_base_port + 1);\r
+\r
+ /* for sensort */\r
+ sprintf(buf, "tcp:%d:10.0.2.16:3577", tizen_base_port + SDB_TCP_EMULD_INDEX );\r
+ if(net_slirp_redir((char*)buf) < 0){\r
+ ERR( "redirect [%s] fail \n", buf);\r
+ }else{\r
+ INFO("redirect [%s] success\n", buf);\r
+ }\r
+}\r
+\r
+int sdb_loopback_client(int port, int type)\r
+{\r
+ struct sockaddr_in addr;\r
+ int s;\r
+\r
+ memset(&addr, 0, sizeof(addr));\r
+ addr.sin_family = AF_INET;\r
+ addr.sin_port = htons(port);\r
+ addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);\r
+\r
+ s = socket(AF_INET, type, 0);\r
+ if(s < 0) return -1;\r
+\r
+ if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {\r
+ close(s);\r
+ return -1;\r
+ }\r
+\r
+ return s;\r
+\r
+}\r
+\r
+void notify_sdb_daemon_start(void) {\r
++ \r
+ int s;\r
+ /* \r
+ * send a simple message to the SDB host server to tell it we just started.\r
+ * it should be listening on port 26099.\r
+ */\r
- do {\r
- char tmp[32] = { 0 };\r
- \r
- // when connecting to loopback:26099, do not use tcp_socket_outgoing function\r
- // tcp_socket_outgoing may occur "dns name service not known" in case of network unavaliable status.\r
- s = sdb_loopback_client(SDB_HOST_PORT, SOCK_STREAM);\r
- if (s < 0) {\r
- INFO("can't create socket to talk to the SDB server \n");\r
- INFO("This emulator will be scaned by the SDB server \n");\r
- break;\r
- }\r
- \r
- /* length is hex: 0x13 = 19 */\r
- sprintf(tmp, "0013host:emulator:%d", tizen_base_port + 1);\r
- \r
- if (socket_send(s, tmp, 30) < 0) {\r
- ERR( "message sending to sdb server error!\n");\r
- }\r
++ char *targetname = g_path_get_basename(tizen_target_path);\r
++ char tmp[MAXPACKETLEN] = { 0 };\r
++ // when connecting to loopback:26099, do not use tcp_socket_outgoing function\r
++ // tcp_socket_outgoing may occur "dns name service not known" in case of network unavaliable status.\r
++ s = sdb_loopback_client(SDB_HOST_PORT, SOCK_STREAM);\r
++ if (s < 0) {\r
++ INFO("can not create socket to talk to the SDB server.\n");\r
++ INFO("SDB server might not be started yet.\n");\r
++ free(targetname);\r
++ return;\r
++ }\r
+\r
- } while (0);\r
++ /* length is hex host:emulator:port: -> 0x13 = 20 */\r
++ sprintf(tmp, "00%2xhost:emulator:%d:%s", 20 + strlen(targetname), tizen_base_port + 1, targetname);\r
++ INFO("message to send to SDB server: %s\n", tmp);\r
++ if (socket_send(s, tmp, MAXPACKETLEN) < 0) {\r
++ ERR( "message sending to SDB server error!\n");\r
++ }\r
+\r
+ if (s >= 0)\r
+ socket_close(s);\r
++ \r
++ free(targetname);\r
+}\r
int socket_send(int fd, const void* buf, int buflen);
void socket_close(int fd);
void notify_sdb_daemon_start(void);
+ int check_port_bind_listen(uint32_t port);
int sdb_loopback_client(int port, int type);
+int check_port_bind_listen(u_int port);
+++ /dev/null
--<?xml version="1.0" encoding="UTF-8"?>
--<EmulatorUI xmlns="http://www.tizen.org/emulator/dbi" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-- <dbi version="2.0"/>
-- <rotations>
-- <rotation name="Portrait">
-- <lcd id="0">
-- <region left="26" top="70" width="320" height="480"/>
-- </lcd>
-- <imageList>
-- <mainImage>default_0.png</mainImage>
-- <keyPressedImage>default_0_p.png</keyPressedImage>
-- </imageList>
-- <keyMapList>
-- <keyMap>
-- <region left="159" top="552" width="54" height="54"/>
-- <eventInfo>
-- <keyCode>101</keyCode>
-- <keyName>HOME</keyName>
-- </eventInfo>
-- <tooltip>Home</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="362" top="487" width="15" height="70"/>
-- <eventInfo>
-- <keyCode>103</keyCode>
-- <keyName>POWER</keyName>
-- </eventInfo>
-- <tooltip>Power</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="362" top="63" width="15" height="70"/>
-- <eventInfo>
-- <keyCode>115</keyCode>
-- <keyName>VOLUME_UP</keyName>
-- </eventInfo>
-- <tooltip>Volume-up</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="362" top="140" width="15" height="70"/>
-- <eventInfo>
-- <keyCode>114</keyCode>
-- <keyName>VOLUME_DOWN</keyName>
-- </eventInfo>
-- <tooltip>Volume-down</tooltip>
-- </keyMap>
-- </keyMapList>
-- </rotation>
-- <rotation name="Landscape">
-- <lcd id="0">
-- <region left="70" top="34" width="480" height="320"/>
-- </lcd>
-- <imageList>
-- <mainImage>default_L90.png</mainImage>
-- <keyPressedImage>default_L90_p.png</keyPressedImage>
-- </imageList>
-- <keyMapList>
-- <keyMap>
-- <region left="552" top="167" width="54" height="54"/>
-- <eventInfo>
-- <keyCode>101</keyCode>
-- <keyName>HOME</keyName>
-- </eventInfo>
-- <tooltip>Home</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="486" top="3" width="70" height="15"/>
-- <eventInfo>
-- <keyCode>103</keyCode>
-- <keyName>POWER</keyName>
-- </eventInfo>
-- <tooltip>Power</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="63" top="3" width="70" height="15"/>
-- <eventInfo>
-- <keyCode>115</keyCode>
-- <keyName>VOLUME_UP</keyName>
-- </eventInfo>
-- <tooltip>Volume-up</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="139" top="3" width="70" height="15"/>
-- <eventInfo>
-- <keyCode>114</keyCode>
-- <keyName>VOLUME_DOWN</keyName>
-- </eventInfo>
-- <tooltip>Volume-down</tooltip>
-- </keyMap>
-- </keyMapList>
-- </rotation>
-- <rotation name="Reverse Portrait">
-- <lcd id="0">
-- <region left="34" top="70" width="320" height="480"/>
-- </lcd>
-- <imageList>
-- <mainImage>default_180.png</mainImage>
-- <keyPressedImage>default_180_p.png</keyPressedImage>
-- </imageList>
-- <keyMapList>
-- <keyMap>
-- <region left="167" top="14" width="54" height="54"/>
-- <eventInfo>
-- <keyCode>101</keyCode>
-- <keyName>HOME</keyName>
-- </eventInfo>
-- <tooltip>Home</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="3" top="64" width="15" height="70"/>
-- <eventInfo>
-- <keyCode>103</keyCode>
-- <keyName>POWER</keyName>
-- </eventInfo>
-- <tooltip>Power</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="3" top="488" width="15" height="70"/>
-- <eventInfo>
-- <keyCode>115</keyCode>
-- <keyName>VOLUME_UP</keyName>
-- </eventInfo>
-- <tooltip>Volume-up</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="3" top="412" width="15" height="70"/>
-- <eventInfo>
-- <keyCode>114</keyCode>
-- <keyName>VOLUME_DOWN</keyName>
-- </eventInfo>
-- <tooltip>Volume-down</tooltip>
-- </keyMap>
-- </keyMapList>
-- </rotation>
-- <rotation name="Reverse Landscape">
-- <lcd id="0">
-- <region left="70" top="26" width="480" height="320"/>
-- </lcd>
-- <imageList>
-- <mainImage>default_R90.png</mainImage>
-- <keyPressedImage>default_R90_p.png</keyPressedImage>
-- </imageList>
-- <keyMapList>
-- <keyMap>
-- <region left="14" top="159" width="54" height="54"/>
-- <eventInfo>
-- <keyCode>101</keyCode>
-- <keyName>HOME</keyName>
-- </eventInfo>
-- <tooltip>Home</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="64" top="362" width="70" height="15"/>
-- <eventInfo>
-- <keyCode>103</keyCode>
-- <keyName>POWER</keyName>
-- </eventInfo>
-- <tooltip>Power</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="488" top="362" width="70" height="15"/>
-- <eventInfo>
-- <keyCode>115</keyCode>
-- <keyName>VOLUME_UP</keyName>
-- </eventInfo>
-- <tooltip>Volume-up</tooltip>
-- </keyMap>
-- <keyMap>
-- <region left="412" top="362" width="70" height="15"/>
-- <eventInfo>
-- <keyCode>114</keyCode>
-- <keyName>VOLUME_DOWN</keyName>
-- </eventInfo>
-- <tooltip>Volume-down</tooltip>
-- </keyMap>
-- </keyMapList>
-- </rotation>
-- </rotations>
-- <colors>
-- <hoverColor B="255" G="255" R="255" />
-- </colors>
--</EmulatorUI>
#include "emul_state.h"
#include "hw/maru_pm.h"
#include "sysemu.h"
++#include "sysbus.h"
-// for ramdump
+#ifdef CONFIG_HAX
+ #include "guest_debug.h"
+
-#ifdef CONFIG_WIN32
#include "target-i386/hax-i386.h"
#endif
#define MAX_VIRTIO_CONSOLES 1
#ifdef CONFIG_MARU
-#define VIRTIOGL_DEV_NAME "virtio-gl-pci"
+ #define MARUCAM_DEV_NAME "maru_camera_pci"
extern int tizen_base_port;
int skin_disabled = 0;
#endif
}
}
#endif
+#endif
+ #if defined(CONFIG_MARU)
+ if (!is_webcam_enabled) {
+ const char *driver = qemu_opt_get(opts, "driver");
+ if (driver && (strcmp (driver, MARUCAM_DEV_NAME) == 0)) {
+ return 0;
+ }
+ }
+ #endif
dev = qdev_device_add(opts);
if (!dev)
}
loc_set_none();
- capability_check_gl = gl_acceleration_capability_check();
- if (enable_gl && (capability_check_gl != 0)) {
- enable_gl = 0;
- fprintf (stderr, "Warn: GL acceleration was disabled due to the fail of GL check!\n");
- }
-
+ /* Init CPU def lists, based on config
+ * - Must be called after all the qemu_read_config_file() calls
+ * - Must be called before list_cpus()
+ * - Must be called before machine->init()
+ */
+ cpudef_init();
+
+ if (cpu_model && *cpu_model == '?') {
+ list_cpus(stdout, &fprintf, cpu_model);
+ exit(0);
+ }
+
+#ifdef CONFIG_VIRTIO_GL
#if defined(CONFIG_MARU) && (!defined(CONFIG_DARWIN))
if (enable_gl) {
- device_opt_finding_t devp = {VIRTIOGL_DEV_NAME, 0};
- qemu_opts_foreach(qemu_find_opts("device"), find_device_opt, &devp, 0);
- if (devp.found == 0) {
- if (!qemu_opts_parse(qemu_find_opts("device"), VIRTIOGL_DEV_NAME, "driver")) {
- exit(1);
- }
+ capability_check_gl = gl_acceleration_capability_check();
+
+ if (capability_check_gl != 0) {
+ enable_gl = 0;
+ fprintf (stderr, "Warn: GL acceleration was disabled due to the fail of GL check!\n");
}
- }
- #endif
- #endif
-
- // To check host gl driver capability and notify to guest.
- gchar *tmp = kernel_cmdline;
- kernel_cmdline = g_strdup_printf("%s gles=%d", tmp, enable_gl);
- fprintf(stdout, "kernel command : %s\n", kernel_cmdline);
- g_free(tmp);
++
+ // To check host gl driver capability and notify to guest.
+ gchar *tmp = tmp_cmdline;
+ tmp_cmdline = g_strdup_printf("%s gles=%d", tmp, enable_gl);
+ qemu_opts_set(qemu_find_opts("machine"), 0, "append", tmp_cmdline);
+ fprintf(stdout, "kernel command : %s\n", tmp_cmdline);
+ g_free(tmp);
+
+ if (enable_gl) {
+ device_opt_finding_t devp = {VIRTIOGL_DEV_NAME, 0};
+ qemu_opts_foreach(qemu_find_opts("device"), find_device_opt, &devp, 0);
+ if (devp.found == 0) {
+ if (!qemu_opts_parse(qemu_find_opts("device"), VIRTIOGL_DEV_NAME, "driver")) {
+ exit(1);
+ }
+ }
+ }
+ }
+ #endif
++#endif
+
+ #if defined(CONFIG_MARU)
+ is_webcam_enabled = marucam_device_check();
+ if (!is_webcam_enabled) {
+ fprintf (stderr, "WARNING: Webcam support was disabled due to "
+ "the fail of webcam capability check!\n");
+ }
+
+ gchar *tmp_cam_kcmd = kernel_cmdline;
+ kernel_cmdline = g_strdup_printf("%s enable_cam=%d", tmp_cam_kcmd, is_webcam_enabled);
+ fprintf(stdout, "kernel command : %s\n", kernel_cmdline);
+ g_free(tmp_cam_kcmd);
+
+ if (is_webcam_enabled) {
+ device_opt_finding_t devp = {MARUCAM_DEV_NAME, 0};
+ qemu_opts_foreach(qemu_find_opts("device"), find_device_opt, &devp, 0);
+ if (devp.found == 0) {
+ if (!qemu_opts_parse(qemu_find_opts("device"), MARUCAM_DEV_NAME, "driver")) {
+ exit(1);
+ }
+ }
+ }
+ #endif
/* Open the logfile at this point, if necessary. We can't open the logfile
* when encountering either of the logging options (-d or -D) because the
projects / sdk / emulator / qemu.git / commitdiff