cef168 — Canon EF
Lens Kontrol Kartı.

imx219   # Raspberry Pi Camera Module 2
imx283
imx296
imx477   # Raspberry Pi HQ Camera (en yaygın kullanım)
imx519
imx708   # Raspberry Pi Camera Module 3
ov5647   # Raspberry Pi Camera Module v1
ov9281

# 1. Repoyu klonla
git clone https://github.com/pinefeat/cef168.git
cd cef168

# 2. Sensor seç ve overlay'leri hazırla (imx477 = HQ Camera)
./configure.sh    # menüden imx477 seç

# 3. Kernel modülü + kalibrasyon aracı + DTBO derle
make

# 4. Kur (/boot/firmware/overlays'e kopyala, modprobe)
sudo make install

# 5. Yeniden başlat
sudo reboot

# Media device'ı bul (unicam = RPi 4, rp1-cfe = RPi 5):
export DEV_MEDIA=$(v4l2-ctl --list-devices \
  | awk '/unicam|rp1-cfe/ {found=1} found && /\/dev\/media/ {print; exit;}')
echo $DEV_MEDIA
# /dev/media0

# Media pipeline'ını göster:
media-ctl -d $DEV_MEDIA -p | grep entity
# ...  cef168 1-000d (1 pad, 0 link)

# Lens sub-device dosyasını bul:
export DEV_LENS=$(media-ctl -d $DEV_MEDIA -p \
  | awk '/entity.*cef168.*-000d/ {found=1} found && /\/dev\/v4l-subdev/ {print $4; exit;}')
echo $DEV_LENS
# /dev/v4l-subdev2

# Tüm kontrolleri listele:
v4l2-ctl -d $DEV_LENS --list-ctrls-menus
# focus_absolute 0x009a0901 (int) : min=0 max=32767 ...
# iris_absolute 0x009a0903 (int) : min=0 max=32767 ...
# calibrate 0x00980aaa (button) ...

static int cef168_i2c_write(struct cef168_device *cef168_dev, u8 cmd, u16 val)
{
    struct i2c_client *client = v4l2_get_subdevdata(&cef168_dev->sd);
    int retry, ret;

    /* little-endian dönüşümü */
    __le16 le_data = cpu_to_le16(val);
    char tx_data[4] = { cmd,
                        ((u8 *)&le_data)[0],   /* LSB */
                        ((u8 *)&le_data)[1] };  /* MSB */

    /* CRC-8 hesapla ve son bayta yaz */
    tx_data[3] = crc8(cef168_crc8_table, tx_data, 3, CRC8_INIT_VALUE);

    /* en fazla 3 deneme (-EIO veya -EREMOTEIO'da) */
    for (retry = 0; retry < 3; retry++) {
        ret = i2c_master_send(client, tx_data, sizeof(tx_data));
        if (ret == sizeof(tx_data))
            return 0;
        else if (ret != -EIO && ret != -EREMOTEIO)
            break;
    }
    dev_err(&client->dev, "I2C write fail after %d retries, ret=%d\n", retry, ret);
    return -EIO;
}

static int cef168_i2c_read(struct cef168_device *cef168_dev,
                           struct cef168_data *rx_data)
{
    struct i2c_client *client = v4l2_get_subdevdata(&cef168_dev->sd);

    int ret = i2c_master_recv(client, (char *)rx_data,
                              sizeof(struct cef168_data));
    if (ret != sizeof(struct cef168_data)) {
        dev_err(&client->dev, "I2C read fail, ret=%d\n", ret);
        return -EIO;
    }

    /* CRC-8 doğrula (son bayt hariç tüm struct) */
    u8 computed_crc = crc8(cef168_crc8_table, (const u8 *)rx_data,
                           sizeof(struct cef168_data) - 1, CRC8_INIT_VALUE);
    if (computed_crc != rx_data->crc8) {
        dev_err(&client->dev,
                "CRC mismatch calculated=0x%02X read=0x%02X\n",
                computed_crc, rx_data->crc8);
        return -EIO;
    }

    /* little-endian → host byte order */
    rx_data->moving_time         = le16_to_cpup((__le16 *)&rx_data->moving_time);
    rx_data->focus_position_min  = le16_to_cpup((__le16 *)&rx_data->focus_position_min);
    rx_data->focus_position_max  = le16_to_cpup((__le16 *)&rx_data->focus_position_max);
    rx_data->focus_position_cur  = le16_to_cpup((__le16 *)&rx_data->focus_position_cur);
    rx_data->focus_distance_min  = le16_to_cpup((__le16 *)&rx_data->focus_distance_min);
    rx_data->focus_distance_max  = le16_to_cpup((__le16 *)&rx_data->focus_distance_max);
    return 0;
}

#define INP_CALIBRATE     0x22
#define INP_SET_FOCUS      0x80
#define INP_SET_FOCUS_P    0x81
#define INP_SET_FOCUS_N    0x82
#define INP_SET_APERTURE   0x7A
#define INP_SET_APERTURE_P 0x7B
#define INP_SET_APERTURE_N 0x7C

static int cef168_set_ctrl(struct v4l2_ctrl *ctrl)
{
    struct cef168_device *dev = to_cef168(ctrl);
    u8 cmd;

    switch (ctrl->id) {
    case V4L2_CID_FOCUS_ABSOLUTE:
        return cef168_i2c_write(dev, INP_SET_FOCUS, ctrl->val);

    case V4L2_CID_FOCUS_RELATIVE:
        cmd = ctrl->val < 0 ? INP_SET_FOCUS_N : INP_SET_FOCUS_P;
        return cef168_i2c_write(dev, cmd, abs(ctrl->val));

    case V4L2_CID_IRIS_ABSOLUTE:
        return cef168_i2c_write(dev, INP_SET_APERTURE, ctrl->val);

    case V4L2_CID_IRIS_RELATIVE:
        cmd = ctrl->val < 0 ? INP_SET_APERTURE_N : INP_SET_APERTURE_P;
        return cef168_i2c_write(dev, cmd, abs(ctrl->val));

    case CEF168_V4L2_CID_CUSTOM(calibrate):
        return cef168_i2c_write(dev, INP_CALIBRATE, 0);
    }
    return -EINVAL;
}

struct cef168_data {
    __u8  lens_id;              // [0]    Canon lens tip baytı (ör. 0xEB)
    __u8  moving      : 1;      // [1] b0 motor aktif mi
    __u8  calibrating : 2;      // [1] b1-b2  0=boş, 2=kalibrasyon aktif
    __u16 moving_time;          // [2-3]  son işlem süresi (ms), LE
    __u16 focus_position_min;   // [4-5]  kalibrasyon sonrası min adım, LE
    __u16 focus_position_max;   // [6-7]  kalibrasyon sonrası max adım, LE
    __u16 focus_position_cur;   // [8-9]  mevcut odak adımı, LE
    __u16 focus_distance_min;   // [10-11] cm cinsinden yakın mesafe, LE
    __u16 focus_distance_max;   // [12-13] cm cinsinden uzak mesafe, LE (0xFFFF ≈ sonsuz)
    __u8  crc8;                 // [14]  önceki 14 bayt üzerinden CRC-8
} __packed;                     // toplam: 15 bayt

# 15 baytlık veri kontrolünü oku (hexdump olarak göster):
v4l2-ctl -d $DEV_LENS --get-ctrl=0x00980aa9 | xxd
# Çıktı (örnek): EB 00 5F 00 00 00 B4 04 95 02 17 00 A8 19 CRC
#                ↑lens_id  ↑mt    ↑min   ↑max   ↑cur   ↑dmin  ↑dmax

/* Device Tree eşleme tablosu */
static const struct of_device_id cef168_of_table[] = {
    { .compatible = "pinefeat,cef168" },
    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, cef168_of_table);

static struct i2c_driver cef168_i2c_driver = {
    .driver = {
        .name = CEF168_NAME,
        .of_match_table = cef168_of_table,
    },
    .probe  = cef168_probe,
    .remove = cef168_remove,
};
module_i2c_driver(cef168_i2c_driver);

static int cef168_probe(struct i2c_client *client)
{
    struct cef168_device *cef168_dev;
    int rval;

    /* sürücü özel yapısını tahsis et */
    cef168_dev = devm_kzalloc(&client->dev, sizeof(*cef168_dev), GFP_KERNEL);
    if (!cef168_dev)
        return -ENOMEM;

    /* I²C client → sub-device bağlantısını kur */
    v4l2_i2c_subdev_init(&cef168_dev->sd, client, &cef168_ops);
    cef168_dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |
                            V4L2_SUBDEV_FL_HAS_EVENTS;

    /* V4L2 control handler'ı başlat */
    rval = cef168_init_controls(cef168_dev);
    if (rval) goto err_cleanup;

    /* media entity: sıfır pad, fonksiyon = LENS */
    rval = media_entity_pads_init(&cef168_dev->sd.entity, 0, NULL);
    if (rval < 0) goto err_cleanup;
    cef168_dev->sd.entity.function = MEDIA_ENT_F_LENS;

    /* asenkron kayıt: kamera sensörü hazır olduğunda otomatik bağlanır */
    rval = v4l2_async_register_subdev(&cef168_dev->sd);
    if (rval < 0) goto err_cleanup;

    /* CRC-8 tablosunu başlat (polinom 168, MSB-first) */
    crc8_populate_msb(cef168_crc8_table, CEF_CRC8_POLYNOMIAL);
    return 0;

err_cleanup:
    v4l2_ctrl_handler_free(&cef168_dev->ctrls);
    media_entity_cleanup(&cef168_dev->sd.entity);
    return rval;
}

static int cef168_get_ctrl(struct v4l2_ctrl *ctrl)
{
    struct cef168_data data;
    struct cef168_device *dev = to_cef168(ctrl);
    int rval = cef168_i2c_read(dev, &data);
    if (rval < 0) return rval;

    switch (ctrl->id) {
    case V4L2_CID_FOCUS_ABSOLUTE:
        /* min/max aralığını kartın gerçek değerleriyle güncelle */
        __v4l2_ctrl_modify_range(ctrl,
                                 data.focus_position_min,
                                 data.focus_position_max, 1, 0);
        ctrl->val = data.focus_position_cur;
        return 0;

    case CEF168_V4L2_CID_CUSTOM(lens_id):
        ctrl->p_new.p_u8[0] = data.lens_id;
        return 0;

    case CEF168_V4L2_CID_CUSTOM(data):
        memcpy(ctrl->p_new.p_u8, &data, sizeof(data));
        return 0;
    }
    return -EINVAL;
}

class IDevice {
  protected:
    int fd;
    const char *dev;
  public:
    IDevice(const char *dev);        // open(dev, O_RDWR)
    virtual ~IDevice();             // close(fd)
    virtual void calibrate() = 0;  // saf sanal — arka uca göre davranır
    virtual void getData(struct cef168_data &data) = 0;
};

class V4L2SubDev : public IDevice { ... }; // ioctl (VIDIOC_S_CTRL, VIDIOC_G_EXT_CTRLS)
class I2CDev    : public IDevice { ... }; // ham write(4) / read(sizeof struct)

void V4L2SubDev::calibrate()
{
    struct v4l2_control cal = {
        .id = CEF168_V4L2_CID_CUSTOM(calibrate),
        .value = 0,
    };
    if (ioctl(fd, VIDIOC_S_CTRL, &cal) < 0) { ... }
}

void V4L2SubDev::getData(struct cef168_data &data)
{
    struct v4l2_ext_control ext_ctrl = {
        .id   = CEF168_V4L2_CID_CUSTOM(data),
        .size = sizeof(struct cef168_data),
        .ptr  = &data,
    };
    struct v4l2_ext_controls ctrls = {
        .ctrl_class = V4L2_CTRL_CLASS_USER,
        .count      = 1,
        .controls   = &ext_ctrl,
    };
    if (ioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls) < 0) { ... }
}

I2CDev::I2CDev(const char *dev, const int addr) : IDevice(dev), addr(addr)
{
    if (ioctl(fd, I2C_SLAVE, addr) < 0) { ... }  // adres 0x0d
}

void I2CDev::calibrate()
{
    /* hardcoded paket: {0x22, 0x00, 0x00, CRC} — CRC = 0x30 */
    const __u8 tx[4] = { INP_CALIBRATE, 0, 0, 0x30 };
    if (write(fd, &tx, sizeof(tx)) != sizeof(tx)) { ... }
}

void I2CDev::getData(struct cef168_data &rx)
{
    if (read(fd, &rx, sizeof(rx)) != sizeof(rx)) { ... }
    /* CRC doğrula */
    u8 crc = crc8_msb((u8*)&rx, sizeof(rx) - 1);
    if (crc != rx.crc8) throw std::runtime_error("CRC mismatch");
    /* endian dönüşümü */
    rx.moving_time        = __le16_to_cpu(rx.moving_time);
    rx.focus_position_min = __le16_to_cpu(rx.focus_position_min);
    /* ... */
}

device->calibrate();

cef168_data data;
do {
    usleep(500);                  // ~2 kHz polling
    device->getData(data);

    if (data.calibrating == 2 && data.focus_distance_min != 0) {
        /* mesafe cm → diyoptri dönüşümü: 1/m = 100/cm */
        update(points, {
            100 / (double)data.focus_distance_min,  // x ekseni: ters mesafe (m⁻¹)
            data.focus_position_cur,               // y ekseni: donanım adımı
        });
    }
} while (data.calibrating != 0 ||
          elapsed_ms() < 100);    // en az 100 ms bekle

/* step_frames: son hareket süresinden hesapla */
int stepFrames = data.moving_time < 300 ? 4 :
                 data.moving_time < 350 ? 5 : 6;

Focus:     0, time:   0 ms, distance: 655.35 -655.35 m, status: 0/2
Focus:   108, time:  95 ms, distance:   6.50 -  6.50 m, status: 1/2
Focus:   280, time:  87 ms, distance:   2.25 -  2.25 m, status: 1/2
Focus:   512, time:  92 ms, distance:   0.88 -  0.88 m, status: 1/2
Focus:   780, time:  88 ms, distance:   0.46 -  0.46 m, status: 1/2
Focus:  1069, time:  95 ms, distance:   0.23 -  0.23 m, status: 0/0
------------------------------------------------------------
Parameters for "rpi.af" section of camera tuning JSON file
------------------------------------------------------------
Inverse of focus distance, m⁻¹:
    "min": 0.00153,
    "max": 4.35,
    "default": 4.35,
Speed:
    step_frames: 4
PWL function:
    "map": [ 0.00153, 1069, 0.154, 1042, 0.446, 996, 0.719, 969,
             0.971, 941, 1.2, 901, 1.45, 860, 1.72, 805, 2.04, 764,
             2.44, 682, 2.86, 559, 3.45, 388, 3.85, 252, 4.35, 0 ]

# minicom ile bağlan (local echo açık, satırsonu çevirisi kapalı):
sudo minicom -D /dev/ttyUSB0 -b 115200 --noinit

# picocom ile (daha minimal):
picocom -b 115200 --echo /dev/ttyUSB0

# pyserial ile (script'ten test):
python3 -c "
import serial, time
s = serial.Serial('/dev/ttyUSB0', 115200, timeout=1)
s.write(b'h\r'); time.sleep(0.1); print(s.read(200).decode())
"

> v
1.3
> n
PINEFEAT CEF1680000011
> h
Lens ID: 0xEB
Focal length: 10-22 mm
Zoom: 1x
Aperture: f/3.5-22.6
Focus distance: 0.23-0.23 m
> c
ok
> e
y
> e
n
> r
0-1069
> f
1069
> f500
ok
> a5.6
ok
> a
3.5-22.6

vcm_node: cef168@d {
    compatible = "pinefeat,cef168";
    reg = <0x0d>;
    status = "disabled";          /* dtoverlay=...,vcm parametresiyle etkinleştirilir */
    vcc-supply = <&vdd_3v3_reg>;
};

fragment@N {
    target = <&cam_node>;
    __overlay__ {
        lens-focus = <&vcm_node>;
    };
};

/* __overrides__ bölümüne vcm parametresi: */
vcm = <&vcm_node>, "status",
      <0>, "=0";   /* fragment index */

/* dosya sonunda: */
&vcm_node {
    status = "okay";
};

# 1. Kurulu RPi firmware versiyonunu bul:
upstream_version=$(zgrep 'raspi-firmware' \
    '/usr/share/doc/raspi-firmware/changelog.Debian.gz' \
    | head -1 | awk '-F[ ():-]' '{print $5}')
# ör: 1:1.20240902+ds-1

# 2. Bu versiyona karşılık gelen kernel Git hash'ini bul:
commit=$(wget -qO- \
    "https://raw.githubusercontent.com/raspberrypi/firmware/refs/tags/${upstream_version}/extra/git_hash")
# ör: abc123def456...

# 3. Sensor overlay DTS dosyasını indir (#include zinciri takip edilir):
wget "${download_path}${file}"  # ör: imx477-overlay.dts + içerdiği .dtsi'lar

# Kernel modülü + sensor DTBO'ları (configure.sh sensor isimlerini ekler)
obj-m := cef168.o

KERNEL_SRC ?= /lib/modules/`uname -r`/build

default:
    $(MAKE) -C "$(KERNEL_SRC)" M="$(CURDIR)"    # cef168.ko
    $(CXX) -Wall -Wextra -o calibrate calibrate.cpp  # kalibrasyon aracı

install:
    $(MAKE) ... modules_install  # /lib/modules/.../kernel/drivers/media/i2c/
    depmod -A
    cp *.dtbo /boot/firmware/overlays --backup=numbered  # eski dosya korunur

# Modül yüklenmiş mi?
lsmod | grep cef168
# cef168   16384  0

# Kernel log'unda hata var mı?
dmesg | grep cef168
# [  2.341] cef168 1-000d: cef168_init_controls ok

# Media grafiğinde görünüyor mu?
media-ctl -d $DEV_MEDIA -p | grep -A3 cef168
# entity 3: cef168 1-000d (1 pad, 0 link)
#   type V4L2 subdev subtype Lens

# Raspberry Pi 5 (pisp ISP):
ls /usr/share/libcamera/ipa/rpi/pisp/
# imx477.json  imx708.json  ov5647.json  ...

# Raspberry Pi 4 (vc4):
ls /usr/share/libcamera/ipa/rpi/vc4/
# Çalışma kopyasını oluştur:
cp /usr/share/libcamera/ipa/rpi/vc4/imx477.json ~/imx477-EF-S10-18mm.json

{
    "rpi.af":
    {
        "ranges":
        {
            "normal":
            {
                "min": 0.00153,      // calibrate çıktısından
                "max": 4.35,
                "default": 4.35
            }
        },
        "speeds":
        {
            "normal":
            {
                "step_coarse": 0.2,
                "step_fine": 0.05,
                "contrast_ratio": 0.75,
                "retrigger_ratio": 0.8,
                "retrigger_delay": 10,
                "pdaf_gain": 0.0,       // Canon lensle PDAF kapalı
                "pdaf_squelch": 0.0,
                "max_slew": 2.0,
                "pdaf_frames": 0,
                "dropout_frames": 0,
                "step_frames": 4        // calibrate çıktısından
            }
        },
        "conf_epsilon": 0,
        "conf_thresh": 0,
        "conf_clip": 0,
        "skip_frames": 5,
        "check_for_ir": false,
        "map": [ 0.00153, 1069, 0.154, 1042, 0.446, 996, 4.35, 0 ]
    }
}

# Sürekli AF ile önizleme:
rpicam-hello --tuning-file ~/imx477-EF-S10-18mm.json --timeout 0

# AF debug logu:
LIBCAMERA_LOG_LEVELS=RPiAf:DEBUG rpicam-hello \
    --tuning-file ~/imx477-EF-S10-18mm.json --timeout 0

# Fotoğraf çek (AF tamamlanana kadar bekle):
rpicam-still --tuning-file ~/imx477-EF-S10-18mm.json -o photo.jpg

# Video (AF aktif):
rpicam-vid --tuning-file ~/imx477-EF-S10-18mm.json -o video.h264 -t 10000

# 1. Raspberry Pi'nin açık ve kartı besliyor olması gerekiyor
# 2. Lens üzerindeki AF/MF switch'ini 15 saniye içinde 3 kez değiştir
# 3. Kart otomatik olarak şu diziyi çalıştırır:
#    - Odağı minimumdan sonsuza 4 adımda götür
#    - Tekrar minimuma döndür
#    - Diyaframı tam kapat
#    - 4 adımda tam açıklığa aç
# Yazılım komutu gerekmez — firmware tarafından tetiklenir

export DEV_MEDIA=$(v4l2-ctl --list-devices \
    | awk '/unicam|rp1-cfe/ {found=1} found && /\/dev\/media/ {print; exit;}')

export DEV_LENS=$(media-ctl -d $DEV_MEDIA -p \
    | awk '/entity.*cef168.*-000d/ {found=1} found && /\/dev\/v4l-subdev/ {print $4; exit;}')

# Zorunlu — her lens için bir kez. Sonucu tuning dosyasına ekle.
./calibrate -d $DEV_LENS

# Adım adım görmek için verbose:
./calibrate -d $DEV_LENS -v

# Kernel sürücüsü kurulu değilse — ham I²C ile:
./calibrate -d /dev/i2c-1 -a 0x0d

# Mutlak diyafram (f-stop × 100):
v4l2-ctl -d $DEV_LENS -c iris_absolute=350   # f/3.5 — tam açık
v4l2-ctl -d $DEV_LENS -c iris_absolute=560   # f/5.6
v4l2-ctl -d $DEV_LENS -c iris_absolute=800   # f/8.0
v4l2-ctl -d $DEV_LENS -c iris_absolute=2260  # f/22.6 — tam kapalı

# Göreceli (minimum adım = 100 = 1 f-stop):
v4l2-ctl -d $DEV_LENS -c iris_relative=+100  # 1 f-stop kapat
v4l2-ctl -d $DEV_LENS -c iris_relative=-100  # 1 f-stop aç

# Mevcut konumu oku:
v4l2-ctl -d $DEV_LENS --get-ctrl=focus_absolute
# focus_absolute: 500

# Mutlak konum:
v4l2-ctl -d $DEV_LENS -c focus_absolute=0     # minimum (sonsuz)
v4l2-ctl -d $DEV_LENS -c focus_absolute=1069  # maximum (yakın)

# Göreceli hareket:
v4l2-ctl -d $DEV_LENS -c focus_relative=+100  # sonsuza doğru
v4l2-ctl -d $DEV_LENS -c focus_relative=-100  # yakına doğru

# Sürekli AF — önizleme:
rpicam-hello --tuning-file ~/imx477-EF-S10-18mm.json --timeout 0

# Tek fotoğraf:
rpicam-still --tuning-file ~/imx477-EF-S10-18mm.json -o photo.jpg

# Video:
rpicam-vid --tuning-file ~/imx477-EF-S10-18mm.json -o video.h264 -t 10000

# AF debug çıktısı ile:
LIBCAMERA_LOG_LEVELS=RPiAf:DEBUG rpicam-hello \
    --tuning-file ~/imx477-EF-S10-18mm.json --timeout 0 2>&1 | grep AF

# Tüm kontrolleri listele:
v4l2-ctl -d $DEV_LENS --list-ctrls

# Lens ID oku:
v4l2-ctl -d $DEV_LENS --get-ctrl=0x00980aa8
# User class 0x00980aa8 (u8) : 0xEB

# Ham data struct oku (15 bayt hex):
v4l2-ctl -d $DEV_LENS --get-ctrl=0x00980aa9