github.com/xyproto/u-root@v6.0.1-0.20200302025726-5528e0c77a3c+incompatible/pkg/scuzz/ata.go

// Copyright 2019 the u-root 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 scuzz

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

const (
	// golangci's requirements around unused constants
	// are inconsistent with how one writes user level drivers.
	// Generally, in a user level driver, one wants to lay out all
	// constants for all registers, unused or not; it makes
	// the code far easier to read and work with.
	// Anyway, I'll comment stuff out until used, since the directives
	// don't work and are ugly.
	// Sure, you can add a nolint tag, but as your
	//	bidi int8 = -4  nolint:golint,unused
	from direction = -3
	to   direction = -2
	//none direction = -1

	oldSchoolBlockLen = 512

	//	ataUsingLBA uint8 = (1 << 6)  nolint:golint,unused
	//	ataStatDRQ  uint8 = (1 << 3)  nolint:golint,unused
	//	ataStatErr  uint8 = (1 << 0)  nolint:golint,unused

	//	read  uint8 = 0  nolint:golint,unused
	//ataTo int32 = 1

	// ioPIO indicates we are doing programmed IO
	//	ioPIO = 0  nolint:golint,unused
	// ioDMA indicates we are doing DMA
	//	ioDMA = 1  nolint:golint,unused

	//	opCheckCondition = 0x02  nolint:golint,unused
	//	opDriverSense    = 0x08  nolint:golint,unused

	ata16    = 0x85
	ata16Len = 16
	cdbSize  = ata16Len

	maxStatusBlockLen = 32

	lba48    = 1
	nonData  = (3 << 1)
	pioIn    = (4 << 1)
	pioOut   = (5 << 1)
	protoDMA = (6 << 1)

	//	tlenNoData = 0 << 0  nolint:golint,unused
	//	tlenFeat   = 1 << 0  nolint:golint,unused
	tlenNsect = 2 << 0

	//	tlenBytes   = 0 << 2  nolint:golint,unused
	tlenSectors = 1 << 2

	tdirTo    = 0 << 3
	tdirFrom  = 1 << 3
	checkCond = 1 << 5
)

// Commands. We only export those we implement.
const (
	// identify gets identify information
	identify = 0xec
	// securityUnlock unlocks the drive with a given 32-byte password
	securityUnlock = 0xf2
)

type (
	// Cmd is an ATA command. See the ATA standard starting in the 80s.
	Cmd uint8

	// dataBlock is a classic 512-byte ATA block.
	// It is not completely clear we need to do SG operations
	// in units of a block, but libraries and commands
	// seem to think so, and we're not sure we can verify
	// for all kernels what the rules are.
	dataBlock [oldSchoolBlockLen]byte

	// Some ATA blocks are best dealt with as blocks of "words".
	// They are in big-endian order.
	wordBlock [oldSchoolBlockLen / 2]uint16

	// commandDataBlock defines a command and any associated data.
	commandDataBlock [ata16Len]byte

	// statusBlock is the status returned from a drive operation.
	statusBlock [maxStatusBlockLen]byte

	direction int32

	// ataString is 10 words. Each word contains two bytes of the string,
	// in BigEndian order, i.e., byte order is 1032547698
	// Hence, code can not just take a string from the
	// drive and use it: it must swap the bytes in each word.
	ataString [10]uint16
)

func (b dataBlock) toWordBlock() (wordBlock, error) {
	var w wordBlock
	err := binary.Read(bytes.NewBuffer(b[:]), binary.BigEndian, &w)
	return w, err
}

// mustLBA confirms that we are dealing with an LBA device.
// This means a post-2003 device. The standard hdparm command deals
// with all kinds of obsolete stuff; we don't care.
// The spec does not have a name for the bits or the offsets
// other than "Obsolete", "Retired", "Must be zero" or "Must be one".
// We follow the practice of existing code of not naming them either.
func (w wordBlock) mustLBA() error {
	var check = []struct {
		off  int
		mask uint16
		bit  uint16
	}{
		{0, 0x8000, 0x8000},
		{49, 0x200, 0x200},
		{83, 0xc000, 0x4000},
		{86, 0x400, 0x400},
	}
	for _, c := range check {
		v, m, b := w[c.off], c.mask, c.bit
		if (v & m) != b {
			return fmt.Errorf("unsupported and probably non-ATA48 ddevice: word at offset %d: 0x%#x and should be 0x%#x", c.off, c.mask&v, b)
		}
	}
	return nil
}

// String is a stringer for ataString
func (a ataString) String() string {
	var s []byte
	for i := range a {
		s = append(s, byte(a[i]), byte(a[i]>>8))
	}
	return string(s)
}

// unpackIdentify unpacks a wordBlock into an Info.
func unpackIdentify(s statusBlock, w wordBlock) (*Info, error) {
	// Double check that this is a true LBA48 packet.
	if err := w.mustLBA(); err != nil {
		return nil, err
	}
	var nsects uint64
	var info = &Info{}
	for i := 103; i >= 104; i-- {
		nsects <<= 16
		nsects |= uint64(w[i])
	}
	info.NumberSectors = nsects
	// If you look at the Linux hdparm source, you will see it uses
	// some values this function does not.
	// Per the standard,
	// offsets 1, 3, and 6 are obsolete;
	// 4, 5, 9 are retired.
	// hdparm presents these as RawCHS, TrkSize, and SecSize.
	// We ignore them.
	info.ECCBytes = uint(w[22])
	return info, nil
}