Develop Bugs

HTC Kernel I2C

Hi, right been looking at the Hero CDMA Kernel trying to get direct access to the light sensor.
I know its part of I2C, and have found some documentation, but its completely over my head! Anyone smarter than me know what this means/how to use it?
Thanks
Usually, i2c devices are controlled by a kernel driver. But it is also
possible to access all devices on an adapter from userspace, through
the /dev interface. You need to load module i2c-dev for this.
Each registered i2c adapter gets a number, counting from 0. You can
examine /sys/class/i2c-dev/ to see what number corresponds to which adapter.
I2C device files are character device files with major device number 89
and a minor device number corresponding to the number assigned as
explained above. They should be called "i2c-%d" (i2c-0, i2c-1, ...,
i2c-10, ...). All 256 minor device numbers are reserved for i2c.
C example
=========
So let's say you want to access an i2c adapter from a C program. The
first thing to do is "#include <linux/i2c-dev.h>". Please note that
there are two files named "i2c-dev.h" out there, one is distributed
with the Linux kernel and is meant to be included from kernel
driver code, the other one is distributed with lm_sensors and is
meant to be included from user-space programs. You obviously want
the second one here.
Now, you have to decide which adapter you want to access. You should
inspect /sys/class/i2c-dev/ to decide this. Adapter numbers are assigned
somewhat dynamically, so you can not even assume /dev/i2c-0 is the
first adapter.
Next thing, open the device file, as follows:
int file;
int adapter_nr = 2; /* probably dynamically determined */
char filename[20];
sprintf(filename,"/dev/i2c-%d",adapter_nr);
if ((file = open(filename,O_RDWR)) < 0) {
/* ERROR HANDLING; you can check errno to see what went wrong */
exit(1);
}
When you have opened the device, you must specify with what device
address you want to communicate:
int addr = 0x40; /* The I2C address */
if (ioctl(file,I2C_SLAVE,addr) < 0) {
/* ERROR HANDLING; you can check errno to see what went wrong */
exit(1);
}
Well, you are all set up now. You can now use SMBus commands or plain
I2C to communicate with your device. SMBus commands are preferred if
the device supports them. Both are illustrated below.
__u8 register = 0x10; /* Device register to access */
__s32 res;
char buf[10];
/* Using SMBus commands */
res = i2c_smbus_read_word_data(file,register);
if (res < 0) {
/* ERROR HANDLING: i2c transaction failed */
} else {
/* res contains the read word */
}
/* Using I2C Write, equivalent of
i2c_smbus_write_word_data(file,register,0x6543) */
buf[0] = register;
buf[1] = 0x43;
buf[2] = 0x65;
if ( write(file,buf,3) != 3) {
/* ERROR HANDLING: i2c transaction failed */
}
/* Using I2C Read, equivalent of i2c_smbus_read_byte(file) */
if (read(file,buf,1) != 1) {
/* ERROR HANDLING: i2c transaction failed */
} else {
/* buf[0] contains the read byte */
}
IMPORTANT: because of the use of inline functions, you *have* to use
'-O' or some variation when you compile your program!
Full interface description
==========================
The following IOCTLs are defined and fully supported
(see also i2c-dev.h):
ioctl(file,I2C_SLAVE,long addr)
Change slave address. The address is passed in the 7 lower bits of the
argument (except for 10 bit addresses, passed in the 10 lower bits in this
case).
ioctl(file,I2C_TENBIT,long select)
Selects ten bit addresses if select not equals 0, selects normal 7 bit
addresses if select equals 0. Default 0. This request is only valid
if the adapter has I2C_FUNC_10BIT_ADDR.
ioctl(file,I2C_PEC,long select)
Selects SMBus PEC (packet error checking) generation and verification
if select not equals 0, disables if select equals 0. Default 0.
Used only for SMBus transactions. This request only has an effect if the
the adapter has I2C_FUNC_SMBUS_PEC; it is still safe if not, it just
doesn't have any effect.
ioctl(file,I2C_FUNCS,unsigned long *funcs)
Gets the adapter functionality and puts it in *funcs.
ioctl(file,I2C_RDWR,struct i2c_rdwr_ioctl_data *msgset)
Do combined read/write transaction without stop in between.
Only valid if the adapter has I2C_FUNC_I2C. The argument is
a pointer to a
struct i2c_rdwr_ioctl_data {
struct i2c_msg *msgs; /* ptr to array of simple messages */
int nmsgs; /* number of messages to exchange */
}
The msgs[] themselves contain further pointers into data buffers.
The function will write or read data to or from that buffers depending
on whether the I2C_M_RD flag is set in a particular message or not.
The slave address and whether to use ten bit address mode has to be
set in each message, overriding the values set with the above ioctl's.
Other values are NOT supported at this moment, except for I2C_SMBUS,
which you should never directly call; instead, use the access functions
below.
You can do plain i2c transactions by using read(2) and write(2) calls.
You do not need to pass the address byte; instead, set it through
ioctl I2C_SLAVE before you try to access the device.
You can do SMBus level transactions (see documentation file smbus-protocol
for details) through the following functions:
__s32 i2c_smbus_write_quick(int file, __u8 value);
__s32 i2c_smbus_read_byte(int file);
__s32 i2c_smbus_write_byte(int file, __u8 value);
__s32 i2c_smbus_read_byte_data(int file, __u8 command);
__s32 i2c_smbus_write_byte_data(int file, __u8 command, __u8 value);
__s32 i2c_smbus_read_word_data(int file, __u8 command);
__s32 i2c_smbus_write_word_data(int file, __u8 command, __u16 value);
__s32 i2c_smbus_process_call(int file, __u8 command, __u16 value);
__s32 i2c_smbus_read_block_data(int file, __u8 command, __u8 *values);
__s32 i2c_smbus_write_block_data(int file, __u8 command, __u8 length,
__u8 *values);
All these transactions return -1 on failure; you can read errno to see
what happened. The 'write' transactions return 0 on success; the
'read' transactions return the read value, except for read_block, which
returns the number of values read. The block buffers need not be longer
than 32 bytes.
The above functions are all macros, that resolve to calls to the
i2c_smbus_access function, that on its turn calls a specific ioctl
with the data in a specific format. Read the source code if you
want to know what happens behind the screens.
Click to expand...
Click to collapse

Surely if you want to use the light sensor in an application, the correct path is via API calls, or do you have other intentions?
Regards,
Dave

Ideally yes, but when you use the API to get the light sensor values, you get the accelerometer values instead! Interesting its similar on the Samsung Moment, asking for the light sensor values returns the compass values!
Seems neither HTC or Samsung know what they are doing!

[Q] root_plug

Not sure if this means anything, just throwing it out there, but i was going through file for froyo on the evo, original file name "supersonic-2.6.32.15-g746f4f0.tar" and found a file named root_plug-notepad, now i'm only guessing, but is this how they are blocking us from being able to root our device, or am i just guessing outta my arse.
on the notepad the full content is:
/*
* Root Plug sample LSM module
*
* Originally written for a Linux Journal.
*
* Copyright (C) 2002 Greg Kroah-Hartman
*
* Prevents any programs running with egid == 0 if a specific USB device
* is not present in the system. Yes, it can be gotten around, but is a
* nice starting point for people to play with, and learn the LSM
* interface.
*
* If you want to turn this into something with a semblance of security,
* you need to hook the task_* functions also.
*
* See for more information
* about this code.
*
* 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, version 2 of the
* License.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/security.h>
#include <linux/usb.h>
#include <linux/moduleparam.h>
/* default is a generic type of usb to serial converter */
static int vendor_id = 0x0557;
static int product_id = 0x2008;
module_param(vendor_id, uint, 0400);
module_param(product_id, uint, 0400);
/* should we print out debug messages */
static int debug = 0;
module_param(debug, bool, 0600);
#define MY_NAME "root_plug"
#define root_dbg(fmt, arg...) \
do { \
if (debug) \
printk(KERN_DEBUG "%s: %s: " fmt , \
MY_NAME , __func__ , \
## arg); \
} while (0)
static int rootplug_bprm_check_security (struct linux_binprm *bprm)
{
struct usb_device *dev;
root_dbg("file %s, e_uid = %d, e_gid = %d\n",
bprm->filename, bprm->cred->euid, bprm->cred->egid);
if (bprm->cred->egid == 0) {
dev = usb_find_device(vendor_id, product_id);
if (!dev) {
root_dbg("e_gid = 0, and device not found, "
"task not allowed to run...\n");
return -EPERM;
}
usb_put_dev(dev);
}
return 0;
}
static struct security_operations rootplug_security_ops = {
.bprm_check_security = rootplug_bprm_check_security,
};
static int __init rootplug_init (void)
{
/* register ourselves with the security framework */
if (register_security (&rootplug_security_ops)) {
printk (KERN_INFO
"Failure registering Root Plug module with the kernel\n");
return -EINVAL;
}
printk (KERN_INFO "Root Plug module initialized, "
"vendor_id = %4.4x, product id = %4.4x\n", vendor_id, product_id);
return 0;
}
security_initcall (rootplug_init);

nobody, nothing, someone has to have some sort of input, lol.

pubbs.net/200910/kernel/36760-patchrfc-security-remove-rootplug.html

Uncle jimmy says hello

Solved .[eVC++] How to use "srand" function?

Hello.
I want to ask some skilled developers,how to use "srand" function?
I found in help this:
Code:
/* RAND.C: This program seeds the random-number generator
* with the time, then displays 10 random integers.
*/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
void main( void )
{
int i;
/* Seed the random-number generator with current time so that
the numbers will be different every time we run.
*/
srand( (unsigned)time( NULL ) );
/* Display 10 numbers. */
for( i = 0; i < 10;i++ )
printf( “ %6d\n”, rand() );
}
Problem is,when I use this example,I get errormessages:
CNS.obj : error LNK2019: unresolved external symbol time referenced in function "void __cdecl PrepareWheel(struct HDC__ *)" ([email protected]@[email protected]@@Z)
ARMV4Dbg/CNS.exe : fatal error LNK1120: 1 unresolved externals
Without this function,function "rand" returns all the time same sequence(as we know).
I am using Embedded Visual C++ 4.0 for PocketPC app development.
That's for now,thanks,Tomas.

[UTIL][PB]★(¯ `•.MS ® Windows Phone - for Flash.Store.Bin[Ext/Build/Info/More].•´¯)★

[UTIL][PB]★(¯ `•.MS ® Windows Phone - for Flash.Store.Bin[Ext/Build/Info/More].•´¯)★
Now We have tool for Ext/Build/Mod./and More Flash.Store.bin
imgtool - Modyfication Image Store, extract/build/repartition/and more... for system
structure store partition, and general part sections image Windows Phone.
Support All Image Flash.Store.Bin Devices:
-- Toshiba/Dell/HTC/Samsung/Nokia/Etc...
Support Other Image System Devices:
-- bin|dio|xml|raw
Info - Usage:
Code:
ImgTool [...options...] inFile [outFile]
Info - Options:
Code:
Options:
-inFormat bin|dio|xml|raw Input file format
-inCert certificateFile Certificate for input file
-inBase address Raw image base address
-outFormat bin|xml|raw|secbin Output file format
-outHash sum|sha1 Output file hash
-outPvk privateKeyFile Private key for output hash
-outPvkPwd password Password for private key
-outCert certificateFile Certificate for output file
-ui Enable crypto user interface
-sectorSize bytes Output file sector size
-sectorsPerRecord sectors Output file sectors in record
-recordSize Output file maximal record size
-ram2store [...type...] Converts ram to storage image
-extendLast Set last partition size as unlimited
-extractPublicKey Extract public key from input certificate
Platform Info © 2012 By UPE-Product
All Rights Reserved

Support Example Format Store File - BOOT_DOWNLOAD_BIN_FORMAT_STORE:
Code:
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//
#ifndef __BOOT_DOWNLOAD_BIN_FORMAT_H
#define __BOOT_DOWNLOAD_BIN_FORMAT_H
#include "bootTypes.h"
#ifdef __cplusplus
extern "C" {
#endif
#pragma pack(push, 1)
//------------------------------------------------------------------------------
#define BOOT_BIN_SIGNATURE_RAM "B000FF\x0A"
#define BOOT_BIN_SIGNATURE_SIGNED_RAM "S000FF\x0A"
#define BOOT_BIN_SIGNATURE_RAW "N000FF\x0A"
#define BOOT_BIN_SIGNATURE_SIGNED_RAW "R000FF\x0A"
#define BOOT_BIN_SIGNATURE_STORE "D000FF\x0A"
#define BOOT_BIN_SIGNATURE_JUMP "J00000\x0A"
//------------------------------------------------------------------------------
typedef struct BootBinFormatRamHeader_t {
uint32_t start;
uint32_t size;
} BootBinFormatRamHeader_t;
typedef struct BootBinFormatRamRecordHeader_t {
uint32_t address;
uint32_t length;
uint32_t checksum;
} BootBinFormatRamRecordHeader_t;
//------------------------------------------------------------------------------
typedef struct BootBinFormatSignature_t {
uint8_t signature[7];
} BootBinFormatSignature_t;
enum BootBinFormatFlags_e {
BOOT_BIN_FORMAT_FLAG_CLEAN = (1 << 0)
};
//------------------------------------------------------------------------------
enum BootBinFormatHashType_e {
BOOT_BIN_FORMAT_HASH_SUM = 0,
BOOT_BIN_FORMAT_HASH_SHA1 = 1,
BOOT_BIN_FORMAT_HASH_SHA256 = 2,
BOOT_BIN_FORMAT_HASH_OEM = 0x8000
// OEM can define new hashing algorithms in their own platform-specific
// BSPs. The definitions must start at BOOT_BIN_FORMAT_HASH_OEM, e.g.
// BOOT_BIN_FORMAT_HASH_ALG1 = BOOT_BIN_FORMAT_HASH_OEM + 0,
// BOOT_BIN_FORMAT_HASH_ALG2 = BOOT_BIN_FORMAT_HASH_OEM + 1
};
//------------------------------------------------------------------------------
typedef struct BootBinFormatStoreHeader_t {
uint32_t flags;
uint32_t sectorSize;
uint32_t sectors;
uint32_t segments;
uint32_t hashType;
uint32_t hashSize;
uint32_t hashInfoSize;
} BootBinFormatStoreHeader_t, *BootBinFormatStoreHeader;
typedef struct BootBinFormatStoreSha1Info_t {
uint32_t publicKeySize;
uint32_t seedSize;
/*
uint8_t publicKey[publicKeySize];
uint8_t seed[seedSize];
*/
} BootBinFormatStoreSha1Info_t;
enum BootBinFormatStoreSegmentType_e {
BOOT_BIN_FORMAT_STORE_SEGMENT_BINARY = 1,
BOOT_BIN_FORMAT_STORE_SEGMENT_RESERVED = 2,
BOOT_BIN_FORMAT_STORE_SEGMENT_PARTITION = 3
};
typedef struct BootBinFormatStoreSegmentHeader_t {
uint32_t type;
uint32_t sectors;
uint32_t infoSize;
} BootBinFormatStoreSegmentHeader_t, *BootBinFormatStoreSegmentHeader;
typedef struct BootBinFormatStoreSegmentBinaryInfo_t {
uint8_t index;
} BootBinFormatStoreSegmentBinaryInfo_t;
typedef struct BootBinFormatStoreSegmentReservedInfo_t {
char name[8];
} BootBinFormatStoreSegmentReservedInfo_t;
typedef struct BootBinFormatStoreSegmentPartitionInfo_t {
uint8_t fileSystem;
uint8_t index;
} BootBinFormatStoreSegmentPartitionInfo_t;
typedef struct BootBinFormatStoreRecordHeader_t {
uint32_t segment;
uint32_t sector;
uint32_t sectors;
} BootBinFormatStoreRecordHeader_t;
/*
This is pseudo-C definition of store format
typedef struct BootBinFormatStore_t {
uint8_t signature[7];
BootBinFormatStoreHeader_t header;
uint8_t hashInfo[header.hashInfoSize];
struct {
BootBinFormatStoreSegmentHeader_t segmentHeader;
union {
BootBinFormatStoreSegmentBinaryInfo_t binaryInfo;
BootBinFormatStoreSegmentReservedInfo_t reservedInfo;
BootBinFormatStoreSegmentPartitionInfo_t partitionInfo;
};
} segment[header.segments];
uint8_t hash[header.hashSize]; // Header hash/checksum
struct {
BootBinFormatStoreRecordHeader_t recordHeader;
uint8_t recordData[recordHeader.sectors * header.sectorSize];
uint8_t recordHash[header.hashSize];
} record[];
} BootBinFormatStore_t;
*/
//------------------------------------------------------------------------------
#pragma pack(pop)
#ifdef __cplusplus
}
#endif
#endif // __BOOT_DOWNLOAD_BIN_FORMAT_H

[Q] Regarding USB audio (source code help)

By using the GlaDOS kernel and Usb audio recorder ROOT, I was able to listen to music with my USB headset, however I really would like a way to implement it into the kernel or the OS so I can reroute media sound to my headset with other apps.
Here's the source code of the driver... Maybe someone with more knowledge than me will be able to implement it or maybe point me in the right direction.
Code:
#ifndef __USBAUDIO_H
#define __USBAUDIO_H
/*
* (Tentative) USB Audio Driver for ALSA
*
* Copyright (c) 2002 by Takashi Iwai <[email protected]>
*
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* handling of USB vendor/product ID pairs as 32-bit numbers */
#define USB_ID(vendor, product) (((vendor) << 16) | (product))
#define USB_ID_VENDOR(id) ((id) >> 16)
#define USB_ID_PRODUCT(id) ((u16)(id))
/*
*
*/
struct snd_usb_audio {
int index;
struct usb_device *dev;
struct snd_card *card;
struct usb_interface *pm_intf;
u32 usb_id;
struct mutex shutdown_mutex;
unsigned int shutdown:1;
unsigned int probing:1;
unsigned int autosuspended:1;
unsigned int txfr_quirk:1; /* Subframe boundaries on transfers */
int num_interfaces;
int num_suspended_intf;
struct list_head pcm_list; /* list of pcm streams */
int pcm_devs;
struct list_head midi_list; /* list of midi interfaces */
struct list_head mixer_list; /* list of mixer interfaces */
int setup; /* from the 'device_setup' module param */
int nrpacks; /* from the 'nrpacks' module param */
int async_unlink; /* from the 'async_unlink' module param */
struct usb_host_interface *ctrl_intf; /* the audio control interface */
};
/*
* Information about devices with broken descriptors
*/
/* special values for .ifnum */
#define QUIRK_NO_INTERFACE -2
#define QUIRK_ANY_INTERFACE -1
enum quirk_type {
QUIRK_IGNORE_INTERFACE,
QUIRK_COMPOSITE,
QUIRK_MIDI_STANDARD_INTERFACE,
QUIRK_MIDI_FIXED_ENDPOINT,
QUIRK_MIDI_YAMAHA,
QUIRK_MIDI_MIDIMAN,
QUIRK_MIDI_NOVATION,
QUIRK_MIDI_RAW_BYTES,
QUIRK_MIDI_EMAGIC,
QUIRK_MIDI_CME,
QUIRK_MIDI_AKAI,
QUIRK_MIDI_US122L,
QUIRK_AUDIO_STANDARD_INTERFACE,
QUIRK_AUDIO_FIXED_ENDPOINT,
QUIRK_AUDIO_EDIROL_UAXX,
QUIRK_AUDIO_ALIGN_TRANSFER,
QUIRK_AUDIO_STANDARD_MIXER,
QUIRK_TYPE_COUNT
};
struct snd_usb_audio_quirk {
const char *vendor_name;
const char *product_name;
int16_t ifnum;
uint16_t type;
const void *data;
};
#define combine_word(s) ((*(s)) | ((unsigned int)(s)[1] << 8))
#define combine_triple(s) (combine_word(s) | ((unsigned int)(s)[2] << 16))
#define combine_quad(s) (combine_triple(s) | ((unsigned int)(s)[3] << 24))
#endif /* __USBAUDIO_H */