marek

SPI master driver is prepared so just add some platform data and board info for sca3000 and it must work .

If you would like to connect some SPI device on your mini2440 board you need to:

1. update mach-mini2440.c file in arch/arm/mach-s3c2440/ following:

Add s3c2410_spi_info structure with filled entries
(we use standars SPI pins for spi.0 on CON4):

static struct s3c2410_spi_info mini2440_spi0_pdata = {
         .pin_cs = S3C2410_GPG(2),
         .num_cs = 1,
         .bus_num = 0,
         .gpio_setup = &s3c24xx_spi_gpiocfg_bus0_gpe11_12_13,
};

2. add platform data for device:

static struct spi_board_info mini2440_spi_devs[] __initdata = {
         {       /* sca3000 accel */
                 .modalias       = "sca3000_d01",
                 .chip_select    = 0,
                 .max_speed_hz   = 1 * 1000 * 1000,
                 .bus_num        = 0,
         }
};

3. Add &s3c_device_spi0 line to array of structures mini2440_devices[].

4. In function mini2440_init add lines:

s3c_device_spi0.dev.platform_data = &mini2440_spi0_pdata;

spi_register_board_info(mini2440_spi_devs,
                                 ARRAY_SIZE(mini2440_spi_devs));

You have now prepared kernel code for working with SPI accelerometer.
Just enable all drivers you need (SPI, SCA3000, …) and recompile kernel.

If this is little bit hard to understand you can download a ::patch:: for it.

I try to fix it and provide driver functionality for newest kernels.Hacking takes me maybe 1/2 a day and result was very good.

Device is properly loaded to kernel (tested on openSuse 11.2 on 2.6.31-12).

Also new eth interface is correctly created and fully working.

I observed that loading of DSP firmware sometimes fails (need to fix this)
and also removing device makes a troubles.I try to fix if asap.

You can download code at:

git://github.com/nandra/ft1000.git

Then just follow instructions in README file and if something is wrong please let me know.

Marek

Code:

#include <stdio.h>
#include <stdlib.h>

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

#define container_of(ptr, type, member) ({            \
 const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
 (type *)( (char *)__mptr - offsetof(type,member) );})

#define CONT(prt, type, mem) container_of((prt), type, mem)

struct test {
 int a;
};

struct m {
 int b;
 struct test t;
 int c;
};

int main(int argc, char *argv[])
{
 /* existing structure */
 struct m *ma;
 ma = malloc(sizeof(struct m));
 ma->t.a = 5;
 ma->b = 3;
 /* pointer to existing entry */    
 struct test *te = &ma->t;

 struct m *m = CONT(te, struct m, t);

 printf("m->b = %d\n", m->b);

 return EXIT_SUCCESS;
}

At the beginnig is defined offsetof and container_of macros taken from kernel source.

We will use structure m which encapsulate structure test.

Container of macro is used to get a pointer to beginning of structure which contain element by type.

In our case we have a element t (in struct main) and would like to get pointer to main structure.

Input arguments will be : prt – pointer to element, type – type of element, elemet.

Note: this code is just for understanding how it works, don’t comment it .

You can find very good description at : http://www.kroah.com/log/linux/container_of.html

Marek

For Qt development I’m using Qt Creator which is freely available and combine designer and editor to one complex program.

First simple program which print some data to standard output.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    unsigned i = 0;

    for ( ; ; ) {
        fprintf(stdout,"Value = %X\n", i++);
        fflush(stdout);
        sleep(2);
    }
    return 0;
}

For compiling use :

gcc -o test test.c

For reading stdout we use Qt signal readyStandardOutput() which is triggered when something is written to stdout.

In Qt Creator just create default Qt4 application.

Add to mainwindow.h:

private:
    Ui::MainWindowClass *ui;
    QProcess *process;

Methods and slot in mainwindow.cpp:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QProcess>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), ui(new Ui::MainWindowClass)
{
    ui->setupUi(this);
    process = new QProcess(this);
    process->setReadChannel(QProcess::StandardOutput);
    connect(process, SIGNAL(readyReadStandardOutput()), this, SLOT(updateOutput()));
    process->start("./test");

}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow :: updateOutput(void)
{
    QByteArray bytes = process->readAllStandardOutput();
    ui->textEdit->insertPlainText(bytes);
}

That’s all. When you run Qt application you should see all stdout in textEdit.
Complete project here:  ext_process.tar

Marek

You can check it here ::bug tracker::

First should be create an application for debugging and programming IQRF modules in linux environment (company support only windows). First steps was already done (spying usb interface) to reverse engineer it.  We try to use libusb library to create an application which can communicate with device. More infos about modules at www.iqrf.com.

Next project should be focused on driver development. I participate on linuxdriver project. I choose driver for webcams based on NW8xx chip from out-of-tree drivers to adapt and get it to mainline. I will continue on previous work. Updating was stopped in 2007 and no other updates are available. This driver should support to 8 webcams which use mentioned chip. So thats the plans .

Marek

Source can be browsed here and downloaded from github.com:

git clone git://github.com/nandra/ctimer.git ctimer