BMP085/BMP18x/BMP28x digital pressure sensors

Required properties:
- compatible: must be one of:
  "bosch,bmp085"
  "bosch,bmp180"
  "bosch,bmp280"
  "bosch,bme280"

Optional properties:
- chip-id: configurable chip id for non-default chip revisions
- temp-measurement-period: temperature measurement period (milliseconds)
- default-oversampling: default oversampling value to be used at startup,
  value range is 0-3 with rising sensitivity.
- interrupt-parent: should be the phandle for the interrupt controller
- interrupts: interrupt mapping for IRQ
- reset-gpios: a GPIO line handling reset of the sensor: as the line is
  active low, it should be marked GPIO_ACTIVE_LOW (see gpio/gpio.txt)
- vddd-supply: digital voltage regulator (see regulator/regulator.txt)
- vdda-supply: analog voltage regulator (see regulator/regulator.txt)

Example:

pressure@77 {
	compatible = "bosch,bmp085";
	reg = <0x77>;
	chip-id = <10>;
	temp-measurement-period = <100>;
	default-oversampling = <2>;
	interrupt-parent = <&gpio0>;
	interrupts = <25 IRQ_TYPE_EDGE_RISING>;
	reset-gpios = <&gpio0 26 GPIO_ACTIVE_LOW>;
	vddd-supply = <&foo>;
	vdda-supply = <&bar>;
};
