ruby.git - Ruby GIT repository

diff options

author	akr <akr@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>	2008-09-18 09:29:01 +0000
committer	akr <akr@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>	2008-09-18 09:29:01 +0000
commit	a28628c85f6d28647b8cbe700bebb045352f11c0 (patch)
tree	48ff0d3f98868bd89bb8d116c2073b165b80c031 /test/ruby/test_optimization.rb
parent	8b9a8a6c2078636376eae8d7eb892824cfff8a0b (diff)
download	ruby-a28628c85f6d28647b8cbe700bebb045352f11c0.tar.gz ruby-a28628c85f6d28647b8cbe700bebb045352f11c0.tar.xz ruby-a28628c85f6d28647b8cbe700bebb045352f11c0.zip

* transcode.c (enc_arg): must take pointer argument to avoid GC

problem. StringValueCStr modifies the argument and it should be preserved while the string StringValueCStr returns is used. Since the string is used by caller, the modified argument should be hold by caller. Actually GC.stress = true def (o=Object.new).to_str() "universal"+"_newline" end "\u3042".encode(o, "")' causes curious warning: rb_define_const: invalid name `' for constant git-svn-id: http://svn.ruby-lang.org/repos/ruby/trunk@19408 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

Diffstat (limited to 'test/ruby/test_optimization.rb')

0 files changed, 0 insertions, 0 deletions

/* * Copyright (C) 2009 Sergey Kubushyn <ksi@koi8.net> * Copyright (C) 2009 - 2013 Heiko Schocher <hs@denx.de> * Changes for multibus/multiadapter I2C support. * * (C) Copyright 2001 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com. * * SPDX-License-Identifier: GPL-2.0+ * * The original I2C interface was * (C) 2000 by Paolo Scaffardi (arsenio@tin.it) * AIRVENT SAM s.p.a - RIMINI(ITALY) * but has been changed substantially. */ #ifndef _I2C_H_ #define _I2C_H_ /* * For now there are essentially two parts to this file - driver model * here at the top, and the older code below (with CONFIG_SYS_I2C being * most recent). The plan is to migrate everything to driver model. * The driver model structures and API are separate as they are different * enough as to be incompatible for compilation purposes. */ enum dm_i2c_chip_flags { DM_I2C_CHIP_10BIT = 1 << 0, /* Use 10-bit addressing */ DM_I2C_CHIP_RD_ADDRESS = 1 << 1, /* Send address for each read byte */ DM_I2C_CHIP_WR_ADDRESS = 1 << 2, /* Send address for each write byte */ }; struct udevice; /** * struct dm_i2c_chip - information about an i2c chip * * An I2C chip is a device on the I2C bus. It sits at a particular address * and normally supports 7-bit or 10-bit addressing. * * To obtain this structure, use dev_get_parent_platdata(dev) where dev is * the chip to examine. * * @chip_addr: Chip address on bus * @offset_len: Length of offset in bytes. A single byte offset can * represent up to 256 bytes. A value larger than 1 may be * needed for larger devices. * @flags: Flags for this chip (dm_i2c_chip_flags) * @emul: Emulator for this chip address (only used for emulation) */ struct dm_i2c_chip { uint chip_addr; uint offset_len; uint flags; #ifdef CONFIG_SANDBOX struct udevice *emul; bool test_mode; #endif }; /** * struct dm_i2c_bus- information about an i2c bus * * An I2C bus contains 0 or more chips on it, each at its own address. The * bus can operate at different speeds (measured in Hz, typically 100KHz * or 400KHz). * * To obtain this structure, use dev_get_uclass_priv(bus) where bus is the * I2C bus udevice. * * @speed_hz: Bus speed in hertz (typically 100000) */ struct dm_i2c_bus { int speed_hz; }; /** * dm_i2c_read() - read bytes from an I2C chip * * To obtain an I2C device (called a 'chip') given the I2C bus address you * can use i2c_get_chip(). To obtain a bus by bus number use * uclass_get_device_by_seq(UCLASS_I2C, <bus number>). * * To set the address length of a devce use i2c_set_addr_len(). It * defaults to 1. * * @dev: Chip to read from * @offset: Offset within chip to start reading * @buffer: Place to put data * @len: Number of bytes to read * * @return 0 on success, -ve on failure */ int dm_i2c_read(struct udevice *dev, uint offset, uint8_t *buffer, int len); /** * dm_i2c_write() - write bytes to an I2C chip * * See notes for dm_i2c_read() above. * * @dev: Chip to write to * @offset: Offset within chip to start writing * @buffer: Buffer containing data to write * @len: Number of bytes to write * * @return 0 on success, -ve on failure */ int dm_i2c_write(struct udevice *dev, uint offset, const uint8_t *buffer, int len); /** * dm_i2c_probe() - probe a particular chip address * * This can be useful to check for the existence of a chip on the bus. * It is typically implemented by writing the chip address to the bus * and checking that the chip replies with an ACK. * * @bus: Bus to probe * @chip_addr: 7-bit address to probe (10-bit and others are not supported) * @chip_flags: Flags for the probe (see enum dm_i2c_chip_flags) * @devp: Returns the device found, or NULL if none * @return 0 if a chip was found at that address, -ve if not */ int dm_i2c_probe(struct udevice *bus, uint chip_addr, uint chip_flags, struct udevice **devp); /** * dm_i2c_reg_read() - Read a value from an I2C register * * This reads a single value from the given address in an I2C chip * * @addr: Address to read from * @return value read, or -ve on error */ int dm_i2c_reg_read(struct udevice *dev, uint offset); /** * dm_i2c_reg_write() - Write a value to an I2C register * * This writes a single value to the given address in an I2C chip * * @addr: Address to write to * @val: Value to write (normally a byte) * @return 0 on success, -ve on error */ int dm_i2c_reg_write(struct udevice *dev, uint offset, unsigned int val); /** * dm_i2c_set_bus_speed() - set the speed of a bus * * @bus: Bus to adjust * @speed: Requested speed in Hz * @return 0 if OK, -EINVAL for invalid values */ int dm_i2c_set_bus_speed(struct udevice *bus, unsigned int speed); /** * dm_i2c_get_bus_speed() - get the speed of a bus * * @bus: Bus to check * @return speed of selected I2C bus in Hz, -ve on error */ int dm_i2c_get_bus_speed(struct udevice *bus); /** * i2c_set_chip_flags() - set flags for a chip * * Typically addresses are 7 bits, but for 10-bit addresses you should set * flags to DM_I2C_CHIP_10BIT. All accesses will then use 10-bit addressing. * * @dev: Chip to adjust * @flags: New flags * @return 0 if OK, -EINVAL if value is unsupported, other -ve value on error */ int i2c_set_chip_flags(struct udevice *dev, uint flags); /** * i2c_get_chip_flags() - get flags for a chip * * @dev: Chip to check * @flagsp: Place to put flags * @return 0 if OK, other -ve value on error */ int i2c_get_chip_flags(struct udevice *dev, uint *flagsp); /** * i2c_set_offset_len() - set the offset length for a chip * * The offset used to access a chip may be up to 4 bytes long. Typically it * is only 1 byte, which is enough for chips with 256 bytes of memory or * registers. The default value is 1, but you can call this function to * change it. * * @offset_len: New offset length value (typically 1 or 2) */ int i2c_set_chip_offset_len(struct udevice *dev, uint offset_len); /** * i2c_deblock() - recover a bus that is in an unknown state * * See the deblock() method in 'struct dm_i2c_ops' for full information * * @bus: Bus to recover * @return 0 if OK, -ve on error */ int i2c_deblock(struct udevice *bus); #ifdef CONFIG_DM_I2C_COMPAT /** * i2c_probe() - Compatibility function for driver model * * Calls dm_i2c_probe() on the current bus */ int i2c_probe(uint8_t chip_addr); /** * i2c_read() - Compatibility function for driver model * * Calls dm_i2c_read() with the device corresponding to @chip_addr, and offset * set to @addr. @alen must match the current setting for the device. */ int i2c_read(uint8_t chip_addr, unsigned int addr, int alen, uint8_t *buffer, int len); /** * i2c_write() - Compatibility function for driver model * * Calls dm_i2c_write() with the device corresponding to @chip_addr, and offset * set to @addr. @alen must match the current setting for the device. */ int i2c_write(uint8_t chip_addr, unsigned int addr, int alen, uint8_t *buffer, int len); /** * i2c_get_bus_num_fdt() - Compatibility function for driver model * * @return the bus number associated with the given device tree node */ int i2c_get_bus_num_fdt(int node); /** * i2c_get_bus_num() - Compatibility function for driver model * * @return the 'current' bus number */ unsigned int i2c_get_bus_num(void); /** * i2c_set_bus_num() - Compatibility function for driver model * * Sets the 'current' bus */ int i2c_set_bus_num(unsigned int bus); static inline void I2C_SET_BUS(unsigned int bus) { i2c_set_bus_num(bus); } static inline unsigned int I2C_GET_BUS(void) { return i2c_get_bus_num(); } /** * i2c_init() - Compatibility function for driver model * * This function does nothing. */ void i2c_init(int speed, int slaveaddr); /** * board_i2c_init() - Compatibility function for driver model * * @param blob Device tree blbo * @return the number of I2C bus */ void board_i2c_init(const void *blob); #endif /* * Not all of these flags are implemented in the U-Boot API */ enum dm_i2c_msg_flags { I2C_M_TEN = 0x0010, /* ten-bit chip address */ I2C_M_RD = 0x0001, /* read data, from slave to master */ I2C_M_STOP = 0x8000, /* send stop after this message */ I2C_M_NOSTART = 0x4000, /* no start before this message */ I2C_M_REV_DIR_ADDR = 0x2000, /* invert polarity of R/W bit */ I2C_M_IGNORE_NAK = 0x1000, /* continue after NAK */ I2C_M_NO_RD_ACK = 0x0800, /* skip the Ack bit on reads */ I2C_M_RECV_LEN = 0x0400, /* length is first received byte */ }; /** * struct i2c_msg - an I2C message * * @addr: Slave address * @flags: Flags (see enum dm_i2c_msg_flags) * @len: Length of buffer in bytes, may be 0 for a probe * @buf: Buffer to send/receive, or NULL if no data */ struct i2c_msg { uint addr; uint flags; uint len; u8 *buf; }; /** * struct i2c_msg_list - a list of I2C messages * * This is called i2c_rdwr_ioctl_data in Linux but the name does not seem * appropriate in U-Boot. * * @msg: Pointer to i2c_msg array * @nmsgs: Number of elements in the array */ struct i2c_msg_list { struct i2c_msg *msgs; uint nmsgs; }; /** * struct dm_i2c_ops - driver operations for I2C uclass * * Drivers should support these operations unless otherwise noted. These * operations are intended to be used by uclass code, not directly from * other code. */ struct dm_i2c_ops { /** * xfer() - transfer a list of I2C messages * * @bus: Bus to read from * @msg: List of messages to transfer * @nmsgs: Number of messages in the list * @return 0 if OK, -EREMOTEIO if the slave did not ACK a byte, * -ECOMM if the speed cannot be supported, -EPROTO if the chip * flags cannot be supported, other -ve value on some other error */ int (*xfer)(struct udevice *bus, struct i2c_msg *msg, int nmsgs); /** * probe_chip() - probe for the presense of a chip address * * This function is optional. If omitted, the uclass will send a zero * length message instead. * * @bus: Bus to probe * @chip_addr: Chip address to probe * @chip_flags: Probe flags (enum dm_i2c_chip_flags) * @return 0 if chip was found, -EREMOTEIO if not, -ENOSYS to fall back * to default probem other -ve value on error */ int (*probe_chip)(struct udevice *bus, uint chip_addr, uint chip_flags); /** * set_bus_speed() - set the speed of a bus (optional) * * The bus speed value will be updated by the uclass if this function * does not return an error. This method is optional - if it is not * provided then the driver can read the speed from * dev_get_uclass_priv(bus)->speed_hz * * @bus: Bus to adjust * @speed: Requested speed in Hz * @return 0 if OK, -EINVAL for invalid values */ int (*set_bus_speed)(struct udevice *bus, unsigned int speed); /** * get_bus_speed() - get the speed of a bus (optional) * * Normally this can be provided by the uclass, but if you want your * driver to check the bus speed by looking at the hardware, you can * implement that here. This method is optional. This method would * normally be expected to return dev_get_uclass_priv(bus)->speed_hz. * * @bus: Bus to check * @return speed of selected I2C bus in Hz, -ve on error */ int (*get_bus_speed)(struct udevice *bus); /** * set_flags() - set the flags for a chip (optional) * * This is generally implemented by the uclass, but drivers can * check the value to ensure that unsupported options are not used. * This method is optional. If provided, this method will always be * called when the flags change. * * @dev: Chip to adjust * @flags: New flags value * @return 0 if OK, -EINVAL if value is unsupported */ int (*set_flags)(struct udevice *dev, uint flags); /** * deblock() - recover a bus that is in an unknown state * * I2C is a synchronous protocol and resets of the processor in the * middle of an access can block the I2C Bus until a powerdown of * the full unit is done. This is because slaves can be stuck * waiting for addition bus transitions for a transaction that will * never complete. Resetting the I2C master does not help. The only * way is to force the bus through a series of transitions to make * sure that all slaves are done with the transaction. This method * performs this 'deblocking' if support by the driver.


context:
space:
mode: