// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package spi allows users to read from and write to an SPI device.
package spi // import "golang.org/x/exp/io/spi"

import (
	"time"

	"golang.org/x/exp/io/spi/driver"
)

// Mode represents the SPI mode number where clock parity (CPOL)
// is the high order and clock edge (CPHA) is the low order bit.
type Mode int

const (
	Mode0 = Mode(0)
	Mode1 = Mode(1)
	Mode2 = Mode(2)
	Mode3 = Mode(3)
)

// Order is the bit justification to be used while transfering
// words to the SPI device. MSB-first encoding is more popular
// than LSB-first.
type Order int

const (
	MSBFirst = Order(0)
	LSBFirst = Order(1)
)

type Device struct {
	conn driver.Conn
}

// SetMode sets the SPI mode. SPI mode is a combination of polarity and phases.
// CPOL is the high order bit, CPHA is the low order. Pre-computed mode
// values are Mode0, Mode1, Mode2 and Mode3.
// The value can be changed by SPI device's driver.
func (d *Device) SetMode(mode Mode) error {
	return d.conn.Configure(driver.Mode, int(mode))
}

// SetMaxSpeed sets the maximum clock speed in Hz.
// The value can be overriden by SPI device's driver.
func (d *Device) SetMaxSpeed(speed int) error {
	return d.conn.Configure(driver.Speed, speed)
}

// SetBitsPerWord sets how many bits it takes to represent a word, e.g. 8 represents 8-bit words.
// The default is 8 bits per word.
func (d *Device) SetBitsPerWord(bits int) error {
	return d.conn.Configure(driver.Bits, bits)
}

// SetBitOrder sets the bit justification used to transfer SPI words.
// Valid values are MSBFirst and LSBFirst.
func (d *Device) SetBitOrder(o Order) error {
	return d.conn.Configure(driver.Order, int(o))
}

// SetDelay sets the amount of pause will be added after each frame write.
func (d *Device) SetDelay(t time.Duration) error {
	return d.conn.Configure(driver.Delay, int(t.Nanoseconds()/1000))
}

// Transfer performs a duplex transmission to write to the SPI device
// and read len(rx) bytes to rx.
// User should not mutate the tx and rx until this call returns.
func (d *Device) Transfer(tx, rx []byte) error {
	return d.conn.Transfer(tx, rx)
}

// Open opens a device with the specified bus and chip select
// by using the given driver. If a nil driver is provided,
// the default driver (devfs) is used.
// Mode is the SPI mode. SPI mode is a combination of polarity and phases.
// CPOL is the high order bit, CPHA is the low order. Pre-computed mode
// values are Mode0, Mode1, Mode2 and Mode3. The value of the mode argument
// can be overriden by the device's driver.
// Speed is the max clock speed (Hz) and can be overriden by the device's driver.
func Open(o driver.Opener, bus, cs int, mode Mode, speed int) (*Device, error) {
	if o == nil {
		o = &Devfs{}
	}

	conn, err := o.Open(bus, cs)
	if err != nil {
		return nil, err
	}

	dev := &Device{conn: conn}
	if err := dev.SetMode(mode); err != nil {
		dev.Close()
		return nil, err
	}
	if err := dev.SetMaxSpeed(speed); err != nil {
		dev.Close()
		return nil, err
	}
	return dev, nil
}

// Close closes the SPI device and releases the related resources.
func (d *Device) Close() error {
	return d.conn.Close()
}