camd3 auf Raspberry PI per qemu möglich?

[stonev]

Hallo,

ich überlege gerade den Raspberry (nur 3,5 Watt) als CS Server einzusetzen und meine Fritte zu entlasten.
Oscam ist ja kein Problem.

Allerdings wäre es schön, wenn man über den Raspberry auch camd3 keys teilen könnte. Mir ist klar, dass die camd3 auf ARM nicht läuft. Ich habe aber gelesen, dass z. B. qemu einen MIPS-Prozessoer emulieren kann.

Wäre es möglich (und auch sinnvoll) per Emulation einen camd3 Server neben Oscam auf dem Raspberry laufen zu lassen?

 

[aragorn]

AW: camd3 auf Raspberry PI per qemu möglich?

ich hab mir daran schon mal die zähne ausgebissen den user-space-mode dafür zu nutzen..
ein komplettes system zu emulieren ist denk ich übertrieben hab ich aber auch schon versucht bin aber an der netzwerk verbindung zwischen host und gast gescheitert..

wenn du das hin kriegen solltest dann gib bitte bescheid :emoticon-0116-evilg


edit: hatte auch schon probiert i386 anstatt mips zu nutzen..
ich poste dir mal meine bisher mühsam zusammen geschusterte vorgehensweise/howto die aber leider bisher auch kein erfolg gebracht hat..
vielleicht hilft es dir ja oder du findest einen fehler.. wär auf jeden fall super wenn du das hier dann posten/mitteilen würdest

Spoiler

Vorbereitungen auf dem PC:

1) QEMU für Windows laden und installieren: http://qemu.weilnetz.de/w32/qemu-w32.exe
2) Debian i386 netinstall laden: http://cdimage.debian.org/debian-cd/6.0.5/i386/iso-cd/debian-6.0.5-i386-netinst.iso
3) Per Eingabeaufforderung in C:\Program Files\qemu\ wechseln
4) 900MB Image erstellen: qemu-img.exe create -f qcow2 G:\debian.img 900M (nach installation sind ca. 480MB belegt. das image ist aber ca. 720MB gross)
5) Debian installation starten (512mb ram und nur ein cpu-core, auf keinen fall mehr cores da der raspberry auch nur einen hat!):
qemu -cpu 486 -hda G:\debian.img -cdrom G:\debian-6.0.4-i386-netinst.iso -boot d -m 512 -smp 1
6) Absolut minimale Installation durchführen (KEINE Pakete auswählen!)

7) apt-get remove grub-common grub-pc
8) apt-get install lilo
9) nano /etc/lilo.conf :

boot=/dev/sda
lba32
large-memory

install=text
timeout=50
default=linux

image=/boot/vmlinuz-2.6.32-5-486
initrd=/boot/initrd.img-2.6.32-5-486
root=/dev/sda1
label=linux

10) liloconfig



Vorbereitungen auf dem Raspberry:

1) apt-get install git zlib1g-dev libsdl1.2-dev libncurses5-dev ncurses-dev
2) mkdir raspidev && cd raspidev
3) wget http://thoronir.net/raspi-dev/qemu-git.tar.bz2
4) tar xfj qemu-git.tar.bz2
5) cd qemu
6) ./configure --target-list="i386-softmmu" --prefix=/usr --extra-cflags="-O3 -mfloat-abi=hard -mfpu=vfp -mcpu=arm1176jzf-s -mtune=arm1176jzf-s -march=armv6zk"
7) nano tcg/arm/tcg-target.c
static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)
in folgendes ändern:
static inline void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)

8) nano tcg/i386/tcg-target.c .. das selbe wie in 7)
9) rm qapi/qmp-input-visitor.c
10) nano qapi/qmp-input-visitor.c .. und copy&past:

Spoiler

/*
 * Input Visitor
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */

#include "qmp-input-visitor.h"
#include "qemu-queue.h"
#include "qemu-common.h"
#include "qemu-objects.h"
#include "qerror.h"

#define QIV_STACK_SIZE 1024

typedef struct StackObject
{
    const QObject *obj;
    const  QListEntry *entry;
} StackObject;

struct QmpInputVisitor
{
    Visitor visitor;
    QObject *obj;
    StackObject stack[QIV_STACK_SIZE];
    int nb_stack;
};

static QmpInputVisitor *to_qiv(Visitor *v)
{
    return container_of(v, QmpInputVisitor, visitor);
}

static const QObject *qmp_input_get_object(QmpInputVisitor *qiv,
                                           const char *name)
{
    const QObject *qobj;

    if (qiv->nb_stack == 0) {
        qobj = qiv->obj;
    } else {
        qobj = qiv->stack[qiv->nb_stack - 1].obj;
    }

    if (name && qobject_type(qobj) == QTYPE_QDICT) {
        return qdict_get(qobject_to_qdict(qobj), name);
    } else if (qiv->nb_stack > 0 && qobject_type(qobj) == QTYPE_QLIST) {
        return qlist_entry_obj(qiv->stack[qiv->nb_stack - 1].entry);
    }

    return qobj;
}

static void qmp_input_push(QmpInputVisitor *qiv, const QObject *obj, Error **errp)
{
    qiv->stack[qiv->nb_stack].obj = obj;
    if (qobject_type(obj) == QTYPE_QLIST) {
        qiv->stack[qiv->nb_stack].entry = qlist_first(qobject_to_qlist(obj));
    }
    qiv->nb_stack++;

    if (qiv->nb_stack >= QIV_STACK_SIZE) {
        error_set(errp, QERR_BUFFER_OVERRUN);
        return;
    }
}

static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp)
{
    qiv->nb_stack--;
    if (qiv->nb_stack < 0) {
        error_set(errp, QERR_BUFFER_OVERRUN);
        return;
    }
}

static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind,
                                   const char *name, size_t size, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
        error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                  "QDict");
        return;
    }

    qmp_input_push(qiv, qobj, errp);
    if (error_is_set(errp)) {
        return;
    }

    if (obj) {
        *obj = g_malloc0(size);
    }
}

static void qmp_input_end_struct(Visitor *v, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);

    qmp_input_pop(qiv, errp);
}

static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
        error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                  "list");
        return;
    }

    qmp_input_push(qiv, qobj, errp);
}

static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
                                        Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    GenericList *entry;
    StackObject *so = &qiv->stack[qiv->nb_stack - 1];

    if (so->entry == NULL) {
        return NULL;
    }

    entry = g_malloc0(sizeof(*entry));
    if (*list) {
        so->entry = qlist_next(so->entry);
        if (so->entry == NULL) {
            g_free(entry);
            return NULL;
        }
        (*list)->next = entry;
    }
    *list = entry;


    return entry;
}

static void qmp_input_end_list(Visitor *v, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);

    qmp_input_pop(qiv, errp);
}

static void qmp_input_type_int(Visitor *v, int64_t *obj, const char *name,
                               Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj || qobject_type(qobj) != QTYPE_QINT) {
        error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                  "integer");
        return;
    }

    *obj = qint_get_int(qobject_to_qint(qobj));
}

static void qmp_input_type_bool(Visitor *v, bool *obj, const char *name,
                                Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj || qobject_type(qobj) != QTYPE_QBOOL) {
        error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                  "boolean");
        return;
    }

    *obj = qbool_get_int(qobject_to_qbool(qobj));
}

static void qmp_input_type_str(Visitor *v, char **obj, const char *name,
                               Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj || qobject_type(qobj) != QTYPE_QSTRING) {
        error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                  "string");
        return;
    }

    *obj = g_strdup(qstring_get_str(qobject_to_qstring(qobj)));
}

static void qmp_input_type_number(Visitor *v, double *obj, const char *name,
                                  Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj || qobject_type(qobj) != QTYPE_QFLOAT) {
        error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                  "double");
        return;
    }

    *obj = qfloat_get_double(qobject_to_qfloat(qobj));
}

static void qmp_input_type_enum(Visitor *v, int *obj, const char *strings[],
                                const char *kind, const char *name,
                                Error **errp)
{
    int64_t value = 0;
    char *enum_str;
    assert(strings);
   enum_str = (char *)strings[value];
    qmp_input_type_str(v, &enum_str, name, errp);
    if (error_is_set(errp)) {
        return;
    }

    while (strings[value] != NULL) {
        if (strcmp(strings[value], enum_str) == 0) {
            break;
        }
        value++;
    }

    if (strings[value] == NULL) {
        error_set(errp, QERR_INVALID_PARAMETER, name ? name : "null");
        return;
    }

    *obj = value;
}

static void qmp_input_start_optional(Visitor *v, bool *present,
                                     const char *name, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    const QObject *qobj = qmp_input_get_object(qiv, name);

    if (!qobj) {
        *present = false;
        return;
    }

    *present = true;
}

static void qmp_input_end_optional(Visitor *v, Error **errp)
{
}

Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
{
    return &v->visitor;
}

void qmp_input_visitor_cleanup(QmpInputVisitor *v)
{
    qobject_decref(v->obj);
    g_free(v);
}

QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
{
    QmpInputVisitor *v;

    v = g_malloc0(sizeof(*v));

    v->visitor.start_struct = qmp_input_start_struct;
    v->visitor.end_struct = qmp_input_end_struct;
    v->visitor.start_list = qmp_input_start_list;
    v->visitor.next_list = qmp_input_next_list;
    v->visitor.end_list = qmp_input_end_list;
    v->visitor.type_enum = qmp_input_type_enum;
    v->visitor.type_int = qmp_input_type_int;
    v->visitor.type_bool = qmp_input_type_bool;
    v->visitor.type_str = qmp_input_type_str;
    v->visitor.type_number = qmp_input_type_number;
    v->visitor.start_optional = qmp_input_start_optional;
    v->visitor.end_optional = qmp_input_end_optional;

    v->obj = obj;
    qobject_incref(v->obj);

    return v;
}

11) make && make install
12) Fehlende sgabios.bin in /usr/share/qemu/ laden
wget -O/usr/share/qemu/sgabios.bin http://qemu.weilnetz.de/w32/2012-06-28/sgabios.bin




Das zuvor unter Windows erstellte debian.img Image auf den Raspberry in den Ordner /qemu/ kopieren (ordner anlegen)
Starten:
/usr/bin/qemu -cpu 486 -hda /qemu/debian.img -m 64 -nographic -pidfile /var/run/qemu.i386.pid


Netzwerk:
http://www.helbing.nu/projekte/linux/qemu.html


Netzwerk des Raspberry:
1) apt-get install bridge-utils
2) nano /etc/network/interfaces
alle zeilen eth0 betreffend auskommentieren und stattdessen folgendes einfügen:

auto br0
iface br0 inet static
   address 192.168.1.10
   network 192.168.1.0
   netmask 255.255.255.0
   broadcast 192.168.1.255
   gateway 192.168.1.1
   bridge_ports eth0
   bridge_fd 9
   bridge_hello 2
   bridge_maxage 12
   bridge_stp off

3) nano /etc/qemu-ifup
#!/bin/sh
sudo -p "Password for $0:" /sbin/ifconfig $1 0.0.0.0 promisc up
sudo -p "Password for $0:" /sbin/brctl addif br0 $1


Netzwerk der qemu:
1) qemu -cpu 486 -hda /qemu/debian.img -m 64 -nographic -pidfile /var/run/qemu.i386.pid -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 -no-acpi
2) nano /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE=eth0
IPADDR=192.168.1.10
NETMASK=255.255.255.0
NETWORK=192.168.1.0
BROADCAST=255.255.255.255
GATEWAY=192.168.1.1
ONBOOT=yes
TYPE=Ethernet
HWADDR=52:54:00:12:34:56

 

[stonev]

AW: camd3 auf Raspberry PI per qemu möglich?

Hi aragorn,

so tiefgreifend sind meine Linuxkenntnisse leider nicht, dass ich etwas derartiges selber erarbeiten könnte. Es reicht gerade aus, um zu reproduzieren. Ich suche aber gern weiter und melde zurück, wenn ich etwas sinnvolles finde.

Im Raspberry Forum hat jemand das gleiche versucht und ist auch nicht weiter gekommen *Link entfernt* (hoffe man darf hier in einem solchen Fall auf ein anderes Forum verlinken, sonst bitte löschen) Der Thread ist aber recht aktuell und vielleicht wird dort noch eine Lösung gefunden.

Aus einem anderen Thread aus diesem Forum noch folgender Hinweis von asb:

QEMU on ARM is interesting. QEMU on an ARM host was broken for a good while, I think the squeeze armel version is old enough to have missed that. The QEMU 1.1 in wheezy offers support for ARM host again, but of course bugs are very possible.

Die haben es immerhin geschafft Win95 und XP per qemu auf dem PI laufen zu lassen und x86 zu emulieren.

 

[stonev]

AW: camd3 auf Raspberry PI per qemu möglich?

Ich habe in der aktuellen CT den hgier entdeckt:

[h=1]Controllerboard Carambola
Günstiges MIPS-Board mit WLAN, USB und GPIO[/h]MIPS-SoC

Sie müssen registriert sein, um Links zu sehen.

(320 MHz) von Ralink
8 MByte Flash sowie 32 MByte RAM
WLAN (802.11 b/g/n)
maximal nur 1,5 Watt
Betriebssystem läuft das Linux-Derivat

Sie müssen registriert sein, um Links zu sehen.

für MIPS vorinstalliert mit Kernel 3.2.8

Preis: 22 Eur

Kann mann das nicht zusätzlich zum Raspberry hernehmen, um camd3 drauf laufen zu lassen. Für camd3 müsste die Leistung doch reichen, oder?

 

[aragorn]

AW: camd3 auf Raspberry PI per qemu möglich?

naja noch einen extra strom verbraucher nur für camd3 an zu schaffen fände übertrieben
auf wlan würde ich dabei auch verzichten weil wlan hat zum einen höhere latenzen und ist zudem anfälliger als lan

allerdings macht mich folgendes stutzig:

Wer lieber drahtgebunden netzwerkt, für denen stehen zwei Ethernet-Ports mit 100 MBit/s zur Verfügung.
Allerdings fehlen dem kleinen Board die Transceiver und die RJ45-Anschlüsse, die man nachrüsten muss.
Gleiches gilt für den USB-2.0-Port (On-the-Go), die serielle Schnittstelle und die Stromversorgung (maximal nur 1,5 Watt).

Da die Anschlüsse auf Stiftleisten im seltenen 2-mm-Rastermaß geführt sind, ist ein Eigenbau solcher Anschlüsse aus handelsüblichen 2,5-mm-Lochrasterplatinen schwierig.
8Devices bietet dafür ein Link ist nicht mehr aktiv. (75 x 82 mm) für ebenfalls 22 Euro an (Link ist nicht mehr aktiv. mit dem Carambola nur 39 Euro), das sämtliche Anschlüsse mitbringt.

also nicht 22eu sondern mindestens 39eu!

der bericht ist hier zu finden:

Sie müssen registriert sein, um Links zu sehen.

ausserdem ist fraglich wieviel von den 8mb flash noch frei wären um die camd3 plus key files aufpsielen zu können



ps: hab gerade noch mal nach geguckt aber sehe nur eine mipsel aber keine mips camd3 binary. die einzigen camd3 binaries die ich hier habe sind für : armeb, cygwin, i386, mipsel, ppc, ppc405 und sh4

 

[huberhans]

Re: AW: camd3 auf Raspberry PI per qemu möglich?

Hi,

Ich würde debian + IPC installieren. So habe ich es auf meinem RasPI laufen.

 

[aragorn]

AW: camd3 auf Raspberry PI per qemu möglich?

huberhans: dieses Thema hier dreht sich aber um die frage, ob man camd3 auf dem rpi betreiben kann - das geht auch nicht wenn man IPC installiert also ist dein post hier offtopic



zwinschenzeitlich (der letzte post hier ist 6 monate alt) ist aber zwischenzeitlich Link ist nicht mehr aktiv. raus gekommen mit dem man die emu-key-files, wofür camd3 genutzt wurde, ebenfals nutzen kann..