// Code generated by protoc-gen-go. DO NOT EDIT.
// source: lab/dut_state.proto

package lab

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// Next Tag: 16
type PeripheralState int32

const (
	// Please keep for all unknown states.
	PeripheralState_UNKNOWN PeripheralState = 0
	// Device and software on it is working as expected.
	PeripheralState_WORKING PeripheralState = 1
	// Configuration for device is not provided.
	PeripheralState_MISSING_CONFIG PeripheralState = 5
	// Configuration contains incorrect information.
	PeripheralState_WRONG_CONFIG PeripheralState = 4
	// Device is not connected/plugged.
	PeripheralState_NOT_CONNECTED PeripheralState = 2
	// Device is not reachable over ssh.
	PeripheralState_NO_SSH PeripheralState = 6
	// Device is broken or not working as expected. the state used if no specified state for the issue.
	PeripheralState_BROKEN PeripheralState = 3
	// Device cannot be repaired or required manual attention to fix/replace it.
	PeripheralState_NEED_REPLACEMENT PeripheralState = 7
	// Servo specific states.
	// cr50 console missing or unresponsive.
	PeripheralState_CR50_CONSOLE_MISSING PeripheralState = 13
	// Servod daemon cannot start on servo-host because cr50 testlab not enabled.
	PeripheralState_CCD_TESTLAB_ISSUE PeripheralState = 8
	// Servod daemon cannot start on servo-host.
	PeripheralState_SERVOD_ISSUE PeripheralState = 9
	// device lid is not open.
	PeripheralState_LID_OPEN_FAILED PeripheralState = 10
	// the ribbon cable between servo and DUT is broken or not connected.
	PeripheralState_BAD_RIBBON_CABLE PeripheralState = 11
	// the EC on the DUT has issue.
	PeripheralState_EC_BROKEN PeripheralState = 12
	// Servo is not connected to the DUT.
	PeripheralState_DUT_NOT_CONNECTED PeripheralState = 14
	// Some component in servo-topology missed or not detected.
	PeripheralState_TOPOLOGY_ISSUE PeripheralState = 15
)

var PeripheralState_name = map[int32]string{
	0:  "UNKNOWN",
	1:  "WORKING",
	5:  "MISSING_CONFIG",
	4:  "WRONG_CONFIG",
	2:  "NOT_CONNECTED",
	6:  "NO_SSH",
	3:  "BROKEN",
	7:  "NEED_REPLACEMENT",
	13: "CR50_CONSOLE_MISSING",
	8:  "CCD_TESTLAB_ISSUE",
	9:  "SERVOD_ISSUE",
	10: "LID_OPEN_FAILED",
	11: "BAD_RIBBON_CABLE",
	12: "EC_BROKEN",
	14: "DUT_NOT_CONNECTED",
	15: "TOPOLOGY_ISSUE",
}

var PeripheralState_value = map[string]int32{
	"UNKNOWN":              0,
	"WORKING":              1,
	"MISSING_CONFIG":       5,
	"WRONG_CONFIG":         4,
	"NOT_CONNECTED":        2,
	"NO_SSH":               6,
	"BROKEN":               3,
	"NEED_REPLACEMENT":     7,
	"CR50_CONSOLE_MISSING": 13,
	"CCD_TESTLAB_ISSUE":    8,
	"SERVOD_ISSUE":         9,
	"LID_OPEN_FAILED":      10,
	"BAD_RIBBON_CABLE":     11,
	"EC_BROKEN":            12,
	"DUT_NOT_CONNECTED":    14,
	"TOPOLOGY_ISSUE":       15,
}

func (x PeripheralState) String() string {
	return proto.EnumName(PeripheralState_name, int32(x))
}

func (PeripheralState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0}
}

// The states are using for DUT storage and USB-drive on servo.
// Next Tag: 5
type HardwareState int32

const (
	// keep for all unknown state by default.
	HardwareState_HARDWARE_UNKNOWN HardwareState = 0
	// Hardware is in good shape and pass all verifiers.
	HardwareState_HARDWARE_NORMAL HardwareState = 1
	// Hardware is still good but some not critical verifiers did not pass or provided border values.
	// (used for DUT storage when usage reached 98%)
	HardwareState_HARDWARE_ACCEPTABLE HardwareState = 2
	// Hardware is broken or bad (did not pass verifiers).
	HardwareState_HARDWARE_NEED_REPLACEMENT HardwareState = 3
	// Hardware is not detected to run verifiers.
	// (used for USB-drive when it expected but not detected on the device)
	HardwareState_HARDWARE_NOT_DETECTED HardwareState = 4
)

var HardwareState_name = map[int32]string{
	0: "HARDWARE_UNKNOWN",
	1: "HARDWARE_NORMAL",
	2: "HARDWARE_ACCEPTABLE",
	3: "HARDWARE_NEED_REPLACEMENT",
	4: "HARDWARE_NOT_DETECTED",
}

var HardwareState_value = map[string]int32{
	"HARDWARE_UNKNOWN":          0,
	"HARDWARE_NORMAL":           1,
	"HARDWARE_ACCEPTABLE":       2,
	"HARDWARE_NEED_REPLACEMENT": 3,
	"HARDWARE_NOT_DETECTED":     4,
}

func (x HardwareState) String() string {
	return proto.EnumName(HardwareState_name, int32(x))
}

func (HardwareState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{1}
}

// CR50-related configs by definition shouldn't be a state config, but a build config.
// However, we don't have a way to source it from any external configuration system,
// and it's changed frequently enough to handle cr50 tests, which makes
// it basically impossible for manual updatings: See crbug.com/1057145 for the
// troubles it causes.
//
// So we temporarily set it in state config so that repair job can update it.
// For further changes of it, please see tracking bug crbug.com/1057719.
//
// phases for cr50 module. Next Tag: 3
type DutState_CR50Phase int32

const (
	DutState_CR50_PHASE_INVALID DutState_CR50Phase = 0
	DutState_CR50_PHASE_PREPVT  DutState_CR50Phase = 1
	DutState_CR50_PHASE_PVT     DutState_CR50Phase = 2
)

var DutState_CR50Phase_name = map[int32]string{
	0: "CR50_PHASE_INVALID",
	1: "CR50_PHASE_PREPVT",
	2: "CR50_PHASE_PVT",
}

var DutState_CR50Phase_value = map[string]int32{
	"CR50_PHASE_INVALID": 0,
	"CR50_PHASE_PREPVT":  1,
	"CR50_PHASE_PVT":     2,
}

func (x DutState_CR50Phase) String() string {
	return proto.EnumName(DutState_CR50Phase_name, int32(x))
}

func (DutState_CR50Phase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0, 0}
}

// key env for cr50 RW version. Next Tag: 3
type DutState_CR50KeyEnv int32

const (
	DutState_CR50_KEYENV_INVALID DutState_CR50KeyEnv = 0
	DutState_CR50_KEYENV_PROD    DutState_CR50KeyEnv = 1
	DutState_CR50_KEYENV_DEV     DutState_CR50KeyEnv = 2
)

var DutState_CR50KeyEnv_name = map[int32]string{
	0: "CR50_KEYENV_INVALID",
	1: "CR50_KEYENV_PROD",
	2: "CR50_KEYENV_DEV",
}

var DutState_CR50KeyEnv_value = map[string]int32{
	"CR50_KEYENV_INVALID": 0,
	"CR50_KEYENV_PROD":    1,
	"CR50_KEYENV_DEV":     2,
}

func (x DutState_CR50KeyEnv) String() string {
	return proto.EnumName(DutState_CR50KeyEnv_name, int32(x))
}

func (DutState_CR50KeyEnv) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0, 1}
}

// Next Tag: 10
type DutState struct {
	Id                  *ChromeOSDeviceID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Servo               PeripheralState   `protobuf:"varint,2,opt,name=servo,proto3,enum=lab.PeripheralState" json:"servo,omitempty"`
	Chameleon           PeripheralState   `protobuf:"varint,3,opt,name=chameleon,proto3,enum=lab.PeripheralState" json:"chameleon,omitempty"`
	AudioLoopbackDongle PeripheralState   `protobuf:"varint,4,opt,name=audio_loopback_dongle,json=audioLoopbackDongle,proto3,enum=lab.PeripheralState" json:"audio_loopback_dongle,omitempty"`
	// Indicate how many working bluetooth btpeer for a device.
	WorkingBluetoothBtpeer int32              `protobuf:"varint,5,opt,name=working_bluetooth_btpeer,json=workingBluetoothBtpeer,proto3" json:"working_bluetooth_btpeer,omitempty"`
	Cr50Phase              DutState_CR50Phase `protobuf:"varint,6,opt,name=cr50_phase,json=cr50Phase,proto3,enum=lab.DutState_CR50Phase" json:"cr50_phase,omitempty"`
	// Detected based on the cr50 RW version that the DUT is running on.
	Cr50KeyEnv DutState_CR50KeyEnv `protobuf:"varint,7,opt,name=cr50_key_env,json=cr50KeyEnv,proto3,enum=lab.DutState_CR50KeyEnv" json:"cr50_key_env,omitempty"`
	// Detected during running admin_audit task.
	StorageState         HardwareState `protobuf:"varint,8,opt,name=storage_state,json=storageState,proto3,enum=lab.HardwareState" json:"storage_state,omitempty"`
	ServoUsbState        HardwareState `protobuf:"varint,9,opt,name=servo_usb_state,json=servoUsbState,proto3,enum=lab.HardwareState" json:"servo_usb_state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *DutState) Reset()         { *m = DutState{} }
func (m *DutState) String() string { return proto.CompactTextString(m) }
func (*DutState) ProtoMessage()    {}
func (*DutState) Descriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0}
}

func (m *DutState) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DutState.Unmarshal(m, b)
}
func (m *DutState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DutState.Marshal(b, m, deterministic)
}
func (m *DutState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DutState.Merge(m, src)
}
func (m *DutState) XXX_Size() int {
	return xxx_messageInfo_DutState.Size(m)
}
func (m *DutState) XXX_DiscardUnknown() {
	xxx_messageInfo_DutState.DiscardUnknown(m)
}

var xxx_messageInfo_DutState proto.InternalMessageInfo

func (m *DutState) GetId() *ChromeOSDeviceID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *DutState) GetServo() PeripheralState {
	if m != nil {
		return m.Servo
	}
	return PeripheralState_UNKNOWN
}

func (m *DutState) GetChameleon() PeripheralState {
	if m != nil {
		return m.Chameleon
	}
	return PeripheralState_UNKNOWN
}

func (m *DutState) GetAudioLoopbackDongle() PeripheralState {
	if m != nil {
		return m.AudioLoopbackDongle
	}
	return PeripheralState_UNKNOWN
}

func (m *DutState) GetWorkingBluetoothBtpeer() int32 {
	if m != nil {
		return m.WorkingBluetoothBtpeer
	}
	return 0
}

func (m *DutState) GetCr50Phase() DutState_CR50Phase {
	if m != nil {
		return m.Cr50Phase
	}
	return DutState_CR50_PHASE_INVALID
}

func (m *DutState) GetCr50KeyEnv() DutState_CR50KeyEnv {
	if m != nil {
		return m.Cr50KeyEnv
	}
	return DutState_CR50_KEYENV_INVALID
}

func (m *DutState) GetStorageState() HardwareState {
	if m != nil {
		return m.StorageState
	}
	return HardwareState_HARDWARE_UNKNOWN
}

func (m *DutState) GetServoUsbState() HardwareState {
	if m != nil {
		return m.ServoUsbState
	}
	return HardwareState_HARDWARE_UNKNOWN
}

func init() {
	proto.RegisterEnum("lab.PeripheralState", PeripheralState_name, PeripheralState_value)
	proto.RegisterEnum("lab.HardwareState", HardwareState_name, HardwareState_value)
	proto.RegisterEnum("lab.DutState_CR50Phase", DutState_CR50Phase_name, DutState_CR50Phase_value)
	proto.RegisterEnum("lab.DutState_CR50KeyEnv", DutState_CR50KeyEnv_name, DutState_CR50KeyEnv_value)
	proto.RegisterType((*DutState)(nil), "lab.DutState")
}

func init() { proto.RegisterFile("lab/dut_state.proto", fileDescriptor_bfe5ddd3f74c848d) }

var fileDescriptor_bfe5ddd3f74c848d = []byte{
	// 737 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xe1, 0x6e, 0xdb, 0x36,
	0x10, 0xae, 0x9d, 0x38, 0x89, 0x2f, 0x71, 0xcc, 0xd2, 0x49, 0xab, 0x0e, 0x1b, 0x10, 0x04, 0x18,
	0x10, 0x04, 0x98, 0x5d, 0x64, 0xe8, 0x36, 0xf4, 0x9f, 0x24, 0xb2, 0xb1, 0x60, 0x85, 0x14, 0x28,
	0xc5, 0x41, 0xf7, 0x87, 0x90, 0x6c, 0xce, 0x16, 0xa2, 0x98, 0x86, 0x2c, 0xa7, 0xe8, 0x43, 0xec,
	0x1d, 0xf6, 0x1c, 0x7b, 0xba, 0x81, 0xb4, 0x13, 0xbb, 0x1d, 0xda, 0x7f, 0xbc, 0xbb, 0xef, 0xbb,
	0xef, 0xbb, 0x3b, 0x80, 0xd0, 0x29, 0xd2, 0xac, 0x37, 0x5e, 0x56, 0x72, 0x51, 0xa5, 0x95, 0xea,
	0xce, 0x4b, 0x5d, 0x69, 0xbc, 0x53, 0xa4, 0xd9, 0x0f, 0x3f, 0x9a, 0xca, 0x68, 0x5a, 0xea, 0x07,
	0xa5, 0x17, 0x72, 0xac, 0x1e, 0xf3, 0x91, 0x92, 0xf9, 0x78, 0x05, 0x39, 0xff, 0xa7, 0x01, 0x07,
	0x64, 0x59, 0xc5, 0x86, 0x85, 0x7f, 0x86, 0x7a, 0x3e, 0x76, 0x6a, 0x67, 0xb5, 0x8b, 0xc3, 0xab,
	0xd3, 0x6e, 0x91, 0x66, 0x5d, 0xdf, 0xf2, 0x78, 0x4c, 0x2c, 0x2d, 0x20, 0xa2, 0x9e, 0x8f, 0xf1,
	0x25, 0x34, 0x16, 0xaa, 0x7c, 0xd4, 0x4e, 0xfd, 0xac, 0x76, 0x71, 0x7c, 0x75, 0x62, 0x91, 0x91,
	0x2a, 0xf3, 0xf9, 0x54, 0x95, 0x69, 0x61, 0x7b, 0x89, 0x15, 0x04, 0x5f, 0x41, 0x73, 0x34, 0x4d,
	0x1f, 0x54, 0xa1, 0xf4, 0xcc, 0xd9, 0xf9, 0x0e, 0x7e, 0x03, 0xc3, 0x7d, 0x38, 0x4d, 0x97, 0xe3,
	0x5c, 0xcb, 0x42, 0xeb, 0x79, 0x96, 0x8e, 0xee, 0xe5, 0x58, 0xcf, 0x26, 0x85, 0x72, 0x76, 0xbf,
	0xc3, 0xef, 0x58, 0x4a, 0xb8, 0x66, 0x10, 0x4b, 0xc0, 0x7f, 0x80, 0xf3, 0x49, 0x97, 0xf7, 0xf9,
	0x6c, 0x22, 0xb3, 0x62, 0xa9, 0x2a, 0xad, 0xab, 0xa9, 0xcc, 0xaa, 0xb9, 0x52, 0xa5, 0xd3, 0x38,
	0xab, 0x5d, 0x34, 0xc4, 0xab, 0x75, 0xdd, 0x7b, 0x2a, 0x7b, 0xb6, 0x8a, 0x7f, 0x03, 0x18, 0x95,
	0xef, 0xde, 0xca, 0xf9, 0x34, 0x5d, 0x28, 0x67, 0xcf, 0x0a, 0xbf, 0xb6, 0xc2, 0x4f, 0xdb, 0xea,
	0xfa, 0xe2, 0xdd, 0xdb, 0xc8, 0x94, 0x45, 0xd3, 0x40, 0xed, 0x13, 0xbf, 0x87, 0x23, 0xcb, 0xbb,
	0x57, 0x9f, 0xa5, 0x9a, 0x3d, 0x3a, 0xfb, 0x96, 0xe9, 0xfc, 0x9f, 0x39, 0x50, 0x9f, 0xe9, 0xec,
	0x51, 0x58, 0x95, 0xd5, 0x1b, 0xff, 0x0e, 0xad, 0x45, 0xa5, 0xcb, 0x74, 0xa2, 0x56, 0x57, 0x74,
	0x0e, 0x2c, 0x19, 0x5b, 0x72, 0x3f, 0x2d, 0xc7, 0x9f, 0xd2, 0x52, 0xad, 0xa6, 0x3d, 0x5a, 0x03,
	0x57, 0x77, 0x7b, 0x0f, 0x6d, 0xbb, 0x6d, 0xb9, 0x5c, 0x64, 0x6b, 0x6a, 0xf3, 0x9b, 0xd4, 0x96,
	0x85, 0xde, 0x2e, 0x32, 0x1b, 0x9e, 0x33, 0x68, 0x3e, 0x0f, 0x82, 0x5f, 0x01, 0x36, 0x81, 0x8c,
	0xfa, 0x6e, 0x4c, 0x65, 0xc0, 0x86, 0x6e, 0x18, 0x10, 0xf4, 0x02, 0x9f, 0xc2, 0xcb, 0xad, 0x7c,
	0x24, 0x68, 0x34, 0x4c, 0x50, 0x0d, 0x63, 0x38, 0xde, 0x4e, 0x0f, 0x13, 0x54, 0x3f, 0x8f, 0x00,
	0x36, 0xe3, 0xe1, 0xd7, 0xd0, 0xb1, 0x88, 0x01, 0xfd, 0x48, 0xd9, 0x70, 0xab, 0xe3, 0x09, 0xa0,
	0xed, 0x42, 0x24, 0x38, 0x41, 0x35, 0xdc, 0x81, 0xf6, 0x76, 0x96, 0xd0, 0x21, 0xaa, 0x5f, 0xfe,
	0x5b, 0x87, 0xf6, 0x57, 0xd7, 0xc6, 0x87, 0xb0, 0x7f, 0xcb, 0x06, 0x8c, 0xdf, 0x31, 0xf4, 0xc2,
	0x04, 0x77, 0x5c, 0x0c, 0x02, 0x76, 0xbd, 0xf2, 0x74, 0x13, 0xc4, 0x71, 0xc0, 0xae, 0xa5, 0xcf,
	0xd9, 0x87, 0xe0, 0x1a, 0x35, 0x30, 0x82, 0xa3, 0x3b, 0xc1, 0x37, 0x99, 0x5d, 0xfc, 0x12, 0x5a,
	0x8c, 0x27, 0x26, 0x66, 0xd4, 0x4f, 0x28, 0x41, 0x75, 0x0c, 0xb0, 0xc7, 0xb8, 0x8c, 0xe3, 0x3e,
	0xda, 0x33, 0x6f, 0x4f, 0xf0, 0x01, 0x65, 0x68, 0xc7, 0x38, 0x65, 0x94, 0x12, 0x29, 0x68, 0x14,
	0xba, 0x3e, 0xbd, 0xa1, 0x2c, 0x41, 0xfb, 0xd8, 0x81, 0x13, 0xeb, 0xd4, 0xe7, 0x2c, 0xe6, 0x21,
	0x95, 0x6b, 0x4d, 0xd4, 0xb2, 0xbb, 0xf2, 0x89, 0x4c, 0x68, 0x9c, 0x84, 0xae, 0x27, 0x83, 0x38,
	0xbe, 0xa5, 0xe8, 0xc0, 0x78, 0x88, 0xa9, 0x18, 0x72, 0xb2, 0xce, 0x34, 0xcd, 0xb0, 0x61, 0x40,
	0x24, 0x8f, 0x28, 0x93, 0x1f, 0xdc, 0x20, 0xa4, 0x04, 0x81, 0x51, 0xf3, 0x5c, 0x22, 0x45, 0xe0,
	0x79, 0x9c, 0x49, 0xdf, 0xf5, 0x42, 0x8a, 0x0e, 0x71, 0x0b, 0x9a, 0xd4, 0x97, 0x6b, 0x4b, 0x47,
	0x46, 0x82, 0xdc, 0x26, 0xf2, 0xcb, 0x09, 0x8e, 0xcd, 0xe8, 0x09, 0x8f, 0x78, 0xc8, 0xaf, 0x3f,
	0xae, 0x45, 0xda, 0x97, 0x7f, 0xd7, 0xa0, 0xf5, 0xc5, 0xfd, 0x8d, 0x42, 0xdf, 0x15, 0xe4, 0xce,
	0x15, 0x54, 0x6e, 0x76, 0xd8, 0x81, 0xf6, 0x73, 0x96, 0x71, 0x71, 0xe3, 0x86, 0xa8, 0x66, 0xae,
	0xf7, 0x9c, 0x74, 0x7d, 0x9f, 0x46, 0x89, 0xf5, 0x53, 0xc7, 0x3f, 0xc1, 0x9b, 0x0d, 0xfa, 0xeb,
	0xe5, 0xec, 0xe0, 0x37, 0x70, 0xba, 0xd5, 0x2c, 0x91, 0x84, 0x26, 0x2b, 0x8f, 0xbb, 0x5e, 0xef,
	0xcf, 0x5f, 0x26, 0xba, 0x6b, 0xbf, 0xa3, 0x7c, 0xf9, 0xd0, 0xd5, 0xe5, 0xa4, 0xf7, 0x14, 0xe8,
	0x45, 0x2f, 0x9f, 0xfd, 0x55, 0xa6, 0x3d, 0xfb, 0x33, 0xf5, 0x26, 0xba, 0x57, 0xa4, 0x59, 0xb6,
	0x67, 0xa3, 0x5f, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x42, 0xfc, 0x36, 0x48, 0xe1, 0x04, 0x00,
	0x00,
}