1 /* ------------------------------------------------------------------------- */ 2 /* */ 3 /* i2c.h - definitions for the i2c-bus interface */ 4 /* */ 5 /* ------------------------------------------------------------------------- */ 6 /* Copyright (C) 1995-2000 Simon G. Vogl 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 21 /* ------------------------------------------------------------------------- */ 22 23 /* With some changes from Ky�sti M�lkki <kmalkki@cc.hut.fi> and 24 Frodo Looijaard <frodol@dds.nl> */ 25 26 /* $Id: i2c.h,v 1.46 2001/08/31 00:04:07 phil Exp $ */ 27 28 #ifndef I2C_H 29 #define I2C_H 30 31 #define I2C_DATE "20010830" 32 #define I2C_VERSION "2.6.1" 33 34 #include <linux/i2c-id.h> /* id values of adapters et. al. */ 35 #include <linux/types.h> 36 37 38 struct i2c_msg; 39 40 41 #ifdef __KERNEL__ 42 43 /* --- Includes and compatibility declarations ------------------------ */ 44 45 #include <asm/semaphore.h> 46 #include <linux/config.h> 47 48 /* --- General options ------------------------------------------------ */ 49 50 #define I2C_ADAP_MAX 16 /* control memory consumption */ 51 #define I2C_DRIVER_MAX 16 52 #define I2C_CLIENT_MAX 32 53 54 struct i2c_algorithm; 55 struct i2c_adapter; 56 struct i2c_client; 57 struct i2c_driver; 58 struct i2c_client_address_data; 59 union i2c_smbus_data; 60 61 62 /* 63 * The master routines are the ones normally used to transmit data to devices 64 * on a bus (or read from them). Apart from two basic transfer functions to 65 * transmit one message at a time, a more complex version can be used to 66 * transmit an arbitrary number of messages without interruption. 67 */ 68 extern int i2c_master_send(struct i2c_client *,const char* ,int); 69 extern int i2c_master_recv(struct i2c_client *,char* ,int); 70 71 /* Transfer num messages. 72 */ 73 extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,int num); 74 75 76 /* This is the very generalized SMBus access routine. You probably do not 77 want to use this, though; one of the functions below may be much easier, 78 and probably just as fast. 79 Note that we use i2c_adapter here, because you do not need a specific 80 smbus adapter to call this function. */ 81 extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr, 82 unsigned short flags, 83 char read_write, u8 command, int size, 84 union i2c_smbus_data * data); 85 86 /* Now follow the 'nice' access routines. These also document the calling 87 conventions of smbus_access. */ 88 89 extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value); 90 extern s32 i2c_smbus_read_byte(struct i2c_client * client); 91 extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value); 92 extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command); 93 extern s32 i2c_smbus_write_byte_data(struct i2c_client * client, 94 u8 command, u8 value); 95 extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command); 96 extern s32 i2c_smbus_write_word_data(struct i2c_client * client, 97 u8 command, u16 value); 98 extern s32 i2c_smbus_process_call(struct i2c_client * client, 99 u8 command, u16 value); 100 /* Returns the number of read bytes */ 101 extern s32 i2c_smbus_read_block_data(struct i2c_client * client, 102 u8 command, u8 *values); 103 extern s32 i2c_smbus_write_block_data(struct i2c_client * client, 104 u8 command, u8 length, 105 u8 *values); 106 extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client, 107 u8 command, u8 length, 108 u8 *values); 109 110 111 /* 112 * A driver is capable of handling one or more physical devices present on 113 * I2C adapters. This information is used to inform the driver of adapter 114 * events. 115 */ 116 117 struct i2c_driver { 118 char name[32]; 119 int id; 120 unsigned int flags; /* div., see below */ 121 122 /* Notifies the driver that a new bus has appeared. This routine 123 * can be used by the driver to test if the bus meets its conditions 124 * & seek for the presence of the chip(s) it supports. If found, it 125 * registers the client(s) that are on the bus to the i2c admin. via 126 * i2c_attach_client. 127 */ 128 int (*attach_adapter)(struct i2c_adapter *); 129 130 /* tells the driver that a client is about to be deleted & gives it 131 * the chance to remove its private data. Also, if the client struct 132 * has been dynamically allocated by the driver in the function above, 133 * it must be freed here. 134 */ 135 int (*detach_client)(struct i2c_client *); 136 137 /* a ioctl like command that can be used to perform specific functions 138 * with the device. 139 */ 140 int (*command)(struct i2c_client *client,unsigned int cmd, void *arg); 141 142 /* These two are used for bookkeeping & dynamic unloading of 143 * kernel modules. inc_use tells the driver that a client is being 144 * used by another module & that it should increase its ref. counter. 145 * dec_use is the inverse operation. 146 * NB: Make sure you have no circular dependencies, or else you get a 147 * deadlock when trying to unload the modules. 148 * You should use the i2c_{inc,dec}_use_client functions instead of 149 * calling this function directly. 150 */ 151 void (*inc_use)(struct i2c_client *client); 152 void (*dec_use)(struct i2c_client *client); 153 }; 154 155 /* 156 * i2c_client identifies a single device (i.e. chip) that is connected to an 157 * i2c bus. The behaviour is defined by the routines of the driver. This 158 * function is mainly used for lookup & other admin. functions. 159 */ 160 struct i2c_client { 161 char name[32]; 162 int id; 163 unsigned int flags; /* div., see below */ 164 unsigned int addr; /* chip address - NOTE: 7bit */ 165 /* addresses are stored in the */ 166 /* _LOWER_ 7 bits of this char */ 167 /* addr: unsigned int to make lm_sensors i2c-isa adapter work 168 more cleanly. It does not take any more memory space, due to 169 alignment considerations */ 170 struct i2c_adapter *adapter; /* the adapter we sit on */ 171 struct i2c_driver *driver; /* and our access routines */ 172 void *data; /* for the clients */ 173 int usage_count; /* How many accesses currently */ 174 /* to the client */ 175 }; 176 177 178 /* 179 * The following structs are for those who like to implement new bus drivers: 180 * i2c_algorithm is the interface to a class of hardware solutions which can 181 * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584 182 * to name two of the most common. 183 */ 184 struct i2c_algorithm { 185 char name[32]; /* textual description */ 186 unsigned int id; 187 188 /* If an adapter algorithm can't do I2C-level access, set master_xfer 189 to NULL. If an adapter algorithm can do SMBus access, set 190 smbus_xfer. If set to NULL, the SMBus protocol is simulated 191 using common I2C messages */ 192 int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs, 193 int num); 194 int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, 195 unsigned short flags, char read_write, 196 u8 command, int size, union i2c_smbus_data * data); 197 198 /* --- these optional/future use for some adapter types.*/ 199 int (*slave_send)(struct i2c_adapter *,char*,int); 200 int (*slave_recv)(struct i2c_adapter *,char*,int); 201 202 /* --- ioctl like call to set div. parameters. */ 203 int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long); 204 205 /* To determine what the adapter supports */ 206 u32 (*functionality) (struct i2c_adapter *); 207 }; 208 209 /* 210 * i2c_adapter is the structure used to identify a physical i2c bus along 211 * with the access algorithms necessary to access it. 212 */ 213 struct i2c_adapter { 214 char name[32]; /* some useful name to identify the adapter */ 215 unsigned int id;/* == is algo->id | hwdep.struct->id, */ 216 /* for registered values see below */ 217 struct i2c_algorithm *algo;/* the algorithm to access the bus */ 218 void *algo_data; 219 220 /* --- These may be NULL, but should increase the module use count */ 221 void (*inc_use)(struct i2c_adapter *); 222 void (*dec_use)(struct i2c_adapter *); 223 224 /* --- administration stuff. */ 225 int (*client_register)(struct i2c_client *); 226 int (*client_unregister)(struct i2c_client *); 227 228 void *data; /* private data for the adapter */ 229 /* some data fields that are used by all types */ 230 /* these data fields are readonly to the public */ 231 /* and can be set via the i2c_ioctl call */ 232 233 /* data fields that are valid for all devices */ 234 struct semaphore lock; 235 unsigned int flags;/* flags specifying div. data */ 236 237 struct i2c_client *clients[I2C_CLIENT_MAX]; 238 int client_count; 239 240 int timeout; 241 int retries; 242 243 #ifdef CONFIG_PROC_FS 244 /* No need to set this when you initialize the adapter */ 245 int inode; 246 #endif /* def CONFIG_PROC_FS */ 247 }; 248 249 /*flags for the driver struct: */ 250 #define I2C_DF_NOTIFY 0x01 /* notify on bus (de/a)ttaches */ 251 #define I2C_DF_DUMMY 0x02 /* do not connect any clients */ 252 253 /*flags for the client struct: */ 254 #define I2C_CLIENT_ALLOW_USE 0x01 /* Client allows access */ 255 #define I2C_CLIENT_ALLOW_MULTIPLE_USE 0x02 /* Allow multiple access-locks */ 256 /* on an i2c_client */ 257 258 /* i2c_client_address_data is the struct for holding default client 259 * addresses for a driver and for the parameters supplied on the 260 * command line 261 */ 262 struct i2c_client_address_data { 263 unsigned short *normal_i2c; 264 unsigned short *normal_i2c_range; 265 unsigned short *probe; 266 unsigned short *probe_range; 267 unsigned short *ignore; 268 unsigned short *ignore_range; 269 unsigned short *force; 270 }; 271 272 /* Internal numbers to terminate lists */ 273 #define I2C_CLIENT_END 0xfffe 274 275 /* The numbers to use to set I2C bus address */ 276 #define ANY_I2C_BUS 0xffff 277 278 /* The length of the option lists */ 279 #define I2C_CLIENT_MAX_OPTS 48 280 281 282 /* ----- functions exported by i2c.o */ 283 284 /* administration... 285 */ 286 extern int i2c_add_adapter(struct i2c_adapter *); 287 extern int i2c_del_adapter(struct i2c_adapter *); 288 289 extern int i2c_add_driver(struct i2c_driver *); 290 extern int i2c_del_driver(struct i2c_driver *); 291 292 extern int i2c_attach_client(struct i2c_client *); 293 extern int i2c_detach_client(struct i2c_client *); 294 295 /* Only call these if you grab a resource that makes unloading the 296 client and the adapter it is on completely impossible. Like when a 297 /proc directory is entered. */ 298 extern void i2c_inc_use_client(struct i2c_client *); 299 extern void i2c_dec_use_client(struct i2c_client *); 300 301 /* New function: This is to get an i2c_client-struct for controlling the 302 client either by using i2c_control-function or having the 303 client-module export functions that can be used with the i2c_client 304 -struct. */ 305 extern struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 306 struct i2c_client *prev); 307 308 /* Should be used with new function 309 extern struct i2c_client *i2c_get_client(int,int,struct i2c_client *); 310 to make sure that client-struct is valid and that it is okay to access 311 the i2c-client. 312 returns -EACCES if client doesn't allow use (default) 313 returns -EBUSY if client doesn't allow multiple use (default) and 314 usage_count >0 */ 315 extern int i2c_use_client(struct i2c_client *); 316 extern int i2c_release_client(struct i2c_client *); 317 318 /* returns -EBUSY if address has been taken, 0 if not. Note that the only 319 other place at which this is called is within i2c_attach_client; so 320 you can cheat by simply not registering. Not recommended, of course! */ 321 extern int i2c_check_addr (struct i2c_adapter *adapter, int addr); 322 323 /* Detect function. It iterates over all possible addresses itself. 324 * It will only call found_proc if some client is connected at the 325 * specific address (unless a 'force' matched); 326 */ 327 typedef int i2c_client_found_addr_proc (struct i2c_adapter *adapter, 328 int addr, unsigned short flags,int kind); 329 330 extern int i2c_probe(struct i2c_adapter *adapter, 331 struct i2c_client_address_data *address_data, 332 i2c_client_found_addr_proc *found_proc); 333 334 /* An ioctl like call to set div. parameters of the adapter. 335 */ 336 extern int i2c_control(struct i2c_client *,unsigned int, unsigned long); 337 338 /* This call returns a unique low identifier for each registered adapter, 339 * or -1 if the adapter was not registered. 340 */ 341 extern int i2c_adapter_id(struct i2c_adapter *adap); 342 343 344 345 /* Return the functionality mask */ 346 extern u32 i2c_get_functionality (struct i2c_adapter *adap); 347 348 /* Return 1 if adapter supports everything we need, 0 if not. */ 349 extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func); 350 351 #endif /* __KERNEL__ */ 352 353 /* 354 * I2C Message - used for pure i2c transaction, also from /dev interface 355 */ 356 struct i2c_msg { 357 __u16 addr; /* slave address */ 358 __u16 flags; 359 #define I2C_M_TEN 0x10 /* we have a ten bit chip address */ 360 #define I2C_M_RD 0x01 361 #define I2C_M_NOSTART 0x4000 362 #define I2C_M_REV_DIR_ADDR 0x2000 363 __u16 len; /* msg length */ 364 __u8 *buf; /* pointer to msg data */ 365 }; 366 367 /* To determine what functionality is present */ 368 369 #define I2C_FUNC_I2C 0x00000001 370 #define I2C_FUNC_10BIT_ADDR 0x00000002 371 #define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART} */ 372 #define I2C_FUNC_SMBUS_QUICK 0x00010000 373 #define I2C_FUNC_SMBUS_READ_BYTE 0x00020000 374 #define I2C_FUNC_SMBUS_WRITE_BYTE 0x00040000 375 #define I2C_FUNC_SMBUS_READ_BYTE_DATA 0x00080000 376 #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA 0x00100000 377 #define I2C_FUNC_SMBUS_READ_WORD_DATA 0x00200000 378 #define I2C_FUNC_SMBUS_WRITE_WORD_DATA 0x00400000 379 #define I2C_FUNC_SMBUS_PROC_CALL 0x00800000 380 #define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0x01000000 381 #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000 382 #define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */ 383 #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */ 384 385 #define I2C_FUNC_SMBUS_BYTE (I2C_FUNC_SMBUS_READ_BYTE | \ 386 I2C_FUNC_SMBUS_WRITE_BYTE) 387 #define I2C_FUNC_SMBUS_BYTE_DATA (I2C_FUNC_SMBUS_READ_BYTE_DATA | \ 388 I2C_FUNC_SMBUS_WRITE_BYTE_DATA) 389 #define I2C_FUNC_SMBUS_WORD_DATA (I2C_FUNC_SMBUS_READ_WORD_DATA | \ 390 I2C_FUNC_SMBUS_WRITE_WORD_DATA) 391 #define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \ 392 I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) 393 #define I2C_FUNC_SMBUS_I2C_BLOCK (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \ 394 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK) 395 396 #define I2C_FUNC_SMBUS_EMUL (I2C_FUNC_SMBUS_QUICK | \ 397 I2C_FUNC_SMBUS_BYTE | \ 398 I2C_FUNC_SMBUS_BYTE_DATA | \ 399 I2C_FUNC_SMBUS_WORD_DATA | \ 400 I2C_FUNC_SMBUS_PROC_CALL | \ 401 I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) 402 403 /* 404 * Data for SMBus Messages 405 */ 406 #define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */ 407 #define I2C_SMBUS_I2C_BLOCK_MAX 32 /* Not specified but we use same structure */ 408 union i2c_smbus_data { 409 __u8 byte; 410 __u16 word; 411 __u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */ 412 /* one more for read length in block process call */ 413 }; 414 415 /* smbus_access read or write markers */ 416 #define I2C_SMBUS_READ 1 417 #define I2C_SMBUS_WRITE 0 418 419 /* SMBus transaction types (size parameter in the above functions) 420 Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */ 421 #define I2C_SMBUS_QUICK 0 422 #define I2C_SMBUS_BYTE 1 423 #define I2C_SMBUS_BYTE_DATA 2 424 #define I2C_SMBUS_WORD_DATA 3 425 #define I2C_SMBUS_PROC_CALL 4 426 #define I2C_SMBUS_BLOCK_DATA 5 427 #define I2C_SMBUS_I2C_BLOCK_DATA 6 428 429 430 /* ----- commands for the ioctl like i2c_command call: 431 * note that additional calls are defined in the algorithm and hw 432 * dependent layers - these can be listed here, or see the 433 * corresponding header files. 434 */ 435 /* -> bit-adapter specific ioctls */ 436 #define I2C_RETRIES 0x0701 /* number of times a device address */ 437 /* should be polled when not */ 438 /* acknowledging */ 439 #define I2C_TIMEOUT 0x0702 /* set timeout - call with int */ 440 441 442 /* this is for i2c-dev.c */ 443 #define I2C_SLAVE 0x0703 /* Change slave address */ 444 /* Attn.: Slave address is 7 or 10 bits */ 445 #define I2C_SLAVE_FORCE 0x0706 /* Change slave address */ 446 /* Attn.: Slave address is 7 or 10 bits */ 447 /* This changes the address, even if it */ 448 /* is already taken! */ 449 #define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */ 450 451 #define I2C_FUNCS 0x0705 /* Get the adapter functionality */ 452 #define I2C_RDWR 0x0707 /* Combined R/W transfer (one stop only)*/ 453 454 #define I2C_SMBUS 0x0720 /* SMBus-level access */ 455 456 /* ----- I2C-DEV: char device interface stuff ------------------------- */ 457 458 #define I2C_MAJOR 89 /* Device major number */ 459 460 #ifdef __KERNEL__ 461 462 # ifndef NULL 463 # define NULL ( (void *) 0 ) 464 # endif 465 466 # ifndef ENODEV 467 # include <asm/errno.h> 468 # endif 469 470 /* These defines are used for probing i2c client addresses */ 471 /* Default fill of many variables */ 472 #define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 473 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 474 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 475 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 476 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 477 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 478 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 479 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 480 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 481 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 482 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 483 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 484 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 485 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 486 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \ 487 I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END} 488 489 /* This is ugly. We need to evaluate I2C_CLIENT_MAX_OPTS before it is 490 stringified */ 491 #define I2C_CLIENT_MODPARM_AUX1(x) "1-" #x "h" 492 #define I2C_CLIENT_MODPARM_AUX(x) I2C_CLIENT_MODPARM_AUX1(x) 493 #define I2C_CLIENT_MODPARM I2C_CLIENT_MODPARM_AUX(I2C_CLIENT_MAX_OPTS) 494 495 /* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the 496 module header */ 497 498 #define I2C_CLIENT_MODULE_PARM(var,desc) \ 499 static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \ 500 MODULE_PARM(var,I2C_CLIENT_MODPARM); \ 501 MODULE_PARM_DESC(var,desc) 502 503 /* This is the one you want to use in your own modules */ 504 #define I2C_CLIENT_INSMOD \ 505 I2C_CLIENT_MODULE_PARM(probe, \ 506 "List of adapter,address pairs to scan additionally"); \ 507 I2C_CLIENT_MODULE_PARM(probe_range, \ 508 "List of adapter,start-addr,end-addr triples to scan " \ 509 "additionally"); \ 510 I2C_CLIENT_MODULE_PARM(ignore, \ 511 "List of adapter,address pairs not to scan"); \ 512 I2C_CLIENT_MODULE_PARM(ignore_range, \ 513 "List of adapter,start-addr,end-addr triples not to " \ 514 "scan"); \ 515 I2C_CLIENT_MODULE_PARM(force, \ 516 "List of adapter,address pairs to boldly assume " \ 517 "to be present"); \ 518 static struct i2c_client_address_data addr_data = \ 519 {normal_i2c, normal_i2c_range, \ 520 probe, probe_range, \ 521 ignore, ignore_range, \ 522 force} 523 524 /* Detect whether we are on the isa bus. If this returns true, all i2c 525 access will fail! */ 526 #define i2c_is_isa_client(clientptr) \ 527 ((clientptr)->adapter->algo->id == I2C_ALGO_ISA) 528 #define i2c_is_isa_adapter(adapptr) \ 529 ((adapptr)->algo->id == I2C_ALGO_ISA) 530 531 #endif /* def __KERNEL__ */ 532 #endif /* I2C_H */ 533