You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
Merge branch 'linus' into tracing/core
Merge reason: Pick up kernel/softirq.c update for dependent fix. Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Ingo Molnar
+17
-1
@@ -248,7 +248,6 @@ struct acpi_device_perf {
|
||||
/* Wakeup Management */
|
||||
struct acpi_device_wakeup_flags {
|
||||
u8 valid:1; /* Can successfully enable wakeup? */
|
||||
u8 prepared:1; /* Has the wake-up capability been enabled? */
|
||||
u8 run_wake:1; /* Run-Wake GPE devices */
|
||||
};
|
||||
|
||||
@@ -263,6 +262,7 @@ struct acpi_device_wakeup {
|
||||
struct acpi_handle_list resources;
|
||||
struct acpi_device_wakeup_state state;
|
||||
struct acpi_device_wakeup_flags flags;
|
||||
int prepare_count;
|
||||
};
|
||||
|
||||
/* Device */
|
||||
@@ -369,10 +369,26 @@ int register_acpi_bus_type(struct acpi_bus_type *);
|
||||
int unregister_acpi_bus_type(struct acpi_bus_type *);
|
||||
struct device *acpi_get_physical_device(acpi_handle);
|
||||
|
||||
struct acpi_pci_root {
|
||||
struct list_head node;
|
||||
struct acpi_device * device;
|
||||
struct acpi_pci_id id;
|
||||
struct pci_bus *bus;
|
||||
u16 segment;
|
||||
u8 bus_nr;
|
||||
|
||||
u32 osc_support_set; /* _OSC state of support bits */
|
||||
u32 osc_control_set; /* _OSC state of control bits */
|
||||
u32 osc_control_qry; /* the latest _OSC query result */
|
||||
|
||||
u32 osc_queried:1; /* has _OSC control been queried? */
|
||||
};
|
||||
|
||||
/* helper */
|
||||
acpi_handle acpi_get_child(acpi_handle, acpi_integer);
|
||||
int acpi_is_root_bridge(acpi_handle);
|
||||
acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
|
||||
struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
|
||||
#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle))
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
|
||||
@@ -3,6 +3,11 @@ ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/include/asm/kvm.h \
|
||||
header-y += kvm.h
|
||||
endif
|
||||
|
||||
ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/include/asm/kvm_para.h \
|
||||
$(srctree)/include/asm-$(SRCARCH)/kvm_para.h),)
|
||||
header-y += kvm_para.h
|
||||
endif
|
||||
|
||||
ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/include/asm/a.out.h \
|
||||
$(srctree)/include/asm-$(SRCARCH)/a.out.h),)
|
||||
unifdef-y += a.out.h
|
||||
|
||||
@@ -9,4 +9,7 @@
|
||||
struct dev_archdata {
|
||||
};
|
||||
|
||||
struct pdev_archdata {
|
||||
};
|
||||
|
||||
#endif /* _ASM_GENERIC_DEVICE_H */
|
||||
|
||||
@@ -103,7 +103,6 @@ static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
|
||||
if (ops->sync_single_for_cpu)
|
||||
ops->sync_single_for_cpu(dev, addr, size, dir);
|
||||
debug_dma_sync_single_for_cpu(dev, addr, size, dir);
|
||||
flush_write_buffers();
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_for_device(struct device *dev,
|
||||
@@ -116,7 +115,6 @@ static inline void dma_sync_single_for_device(struct device *dev,
|
||||
if (ops->sync_single_for_device)
|
||||
ops->sync_single_for_device(dev, addr, size, dir);
|
||||
debug_dma_sync_single_for_device(dev, addr, size, dir);
|
||||
flush_write_buffers();
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_range_for_cpu(struct device *dev,
|
||||
@@ -132,7 +130,6 @@ static inline void dma_sync_single_range_for_cpu(struct device *dev,
|
||||
ops->sync_single_range_for_cpu(dev, addr, offset, size, dir);
|
||||
debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
|
||||
|
||||
flush_write_buffers();
|
||||
} else
|
||||
dma_sync_single_for_cpu(dev, addr, size, dir);
|
||||
}
|
||||
@@ -150,7 +147,6 @@ static inline void dma_sync_single_range_for_device(struct device *dev,
|
||||
ops->sync_single_range_for_device(dev, addr, offset, size, dir);
|
||||
debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
|
||||
|
||||
flush_write_buffers();
|
||||
} else
|
||||
dma_sync_single_for_device(dev, addr, size, dir);
|
||||
}
|
||||
@@ -165,7 +161,6 @@ dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
|
||||
if (ops->sync_sg_for_cpu)
|
||||
ops->sync_sg_for_cpu(dev, sg, nelems, dir);
|
||||
debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
|
||||
flush_write_buffers();
|
||||
}
|
||||
|
||||
static inline void
|
||||
@@ -179,7 +174,6 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
|
||||
ops->sync_sg_for_device(dev, sg, nelems, dir);
|
||||
debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
|
||||
|
||||
flush_write_buffers();
|
||||
}
|
||||
|
||||
#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
|
||||
|
||||
@@ -30,7 +30,18 @@ pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
|
||||
res->end = region->end;
|
||||
}
|
||||
|
||||
#define pcibios_scan_all_fns(a, b) 0
|
||||
static inline struct resource *
|
||||
pcibios_select_root(struct pci_dev *pdev, struct resource *res)
|
||||
{
|
||||
struct resource *root = NULL;
|
||||
|
||||
if (res->flags & IORESOURCE_IO)
|
||||
root = &ioport_resource;
|
||||
if (res->flags & IORESOURCE_MEM)
|
||||
root = &iomem_resource;
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
#ifndef HAVE_ARCH_PCI_GET_LEGACY_IDE_IRQ
|
||||
static inline int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel)
|
||||
|
||||
@@ -81,14 +81,17 @@ extern void setup_per_cpu_areas(void);
|
||||
|
||||
#ifdef MODULE
|
||||
#define PER_CPU_SHARED_ALIGNED_SECTION ""
|
||||
#define PER_CPU_ALIGNED_SECTION ""
|
||||
#else
|
||||
#define PER_CPU_SHARED_ALIGNED_SECTION ".shared_aligned"
|
||||
#define PER_CPU_ALIGNED_SECTION ".shared_aligned"
|
||||
#endif
|
||||
#define PER_CPU_FIRST_SECTION ".first"
|
||||
|
||||
#else
|
||||
|
||||
#define PER_CPU_SHARED_ALIGNED_SECTION ""
|
||||
#define PER_CPU_ALIGNED_SECTION ".shared_aligned"
|
||||
#define PER_CPU_FIRST_SECTION ""
|
||||
|
||||
#endif
|
||||
|
||||
@@ -60,4 +60,7 @@
|
||||
#define SO_TIMESTAMPING 37
|
||||
#define SCM_TIMESTAMPING SO_TIMESTAMPING
|
||||
|
||||
#define SO_PROTOCOL 38
|
||||
#define SO_DOMAIN 39
|
||||
|
||||
#endif /* __ASM_GENERIC_SOCKET_H */
|
||||
|
||||
@@ -33,13 +33,10 @@
|
||||
* BSS_SECTION(0, 0, 0)
|
||||
* _end = .;
|
||||
*
|
||||
* /DISCARD/ : {
|
||||
* EXIT_TEXT
|
||||
* EXIT_DATA
|
||||
* EXIT_CALL
|
||||
* }
|
||||
* STABS_DEBUG
|
||||
* DWARF_DEBUG
|
||||
*
|
||||
* DISCARDS // must be the last
|
||||
* }
|
||||
*
|
||||
* [__init_begin, __init_end] is the init section that may be freed after init
|
||||
@@ -627,6 +624,23 @@
|
||||
#define INIT_RAM_FS
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Default discarded sections.
|
||||
*
|
||||
* Some archs want to discard exit text/data at runtime rather than
|
||||
* link time due to cross-section references such as alt instructions,
|
||||
* bug table, eh_frame, etc. DISCARDS must be the last of output
|
||||
* section definitions so that such archs put those in earlier section
|
||||
* definitions.
|
||||
*/
|
||||
#define DISCARDS \
|
||||
/DISCARD/ : { \
|
||||
EXIT_TEXT \
|
||||
EXIT_DATA \
|
||||
EXIT_CALL \
|
||||
*(.discard) \
|
||||
}
|
||||
|
||||
/**
|
||||
* PERCPU_VADDR - define output section for percpu area
|
||||
* @vaddr: explicit base address (optional)
|
||||
|
||||
+26
-11
@@ -22,11 +22,9 @@ struct seq_file;
|
||||
|
||||
struct crypto_type {
|
||||
unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask);
|
||||
unsigned int (*extsize)(struct crypto_alg *alg,
|
||||
const struct crypto_type *frontend);
|
||||
unsigned int (*extsize)(struct crypto_alg *alg);
|
||||
int (*init)(struct crypto_tfm *tfm, u32 type, u32 mask);
|
||||
int (*init_tfm)(struct crypto_tfm *tfm,
|
||||
const struct crypto_type *frontend);
|
||||
int (*init_tfm)(struct crypto_tfm *tfm);
|
||||
void (*show)(struct seq_file *m, struct crypto_alg *alg);
|
||||
struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask);
|
||||
|
||||
@@ -52,6 +50,7 @@ struct crypto_template {
|
||||
|
||||
struct crypto_instance *(*alloc)(struct rtattr **tb);
|
||||
void (*free)(struct crypto_instance *inst);
|
||||
int (*create)(struct crypto_template *tmpl, struct rtattr **tb);
|
||||
|
||||
char name[CRYPTO_MAX_ALG_NAME];
|
||||
};
|
||||
@@ -60,6 +59,7 @@ struct crypto_spawn {
|
||||
struct list_head list;
|
||||
struct crypto_alg *alg;
|
||||
struct crypto_instance *inst;
|
||||
const struct crypto_type *frontend;
|
||||
u32 mask;
|
||||
};
|
||||
|
||||
@@ -114,11 +114,19 @@ int crypto_register_template(struct crypto_template *tmpl);
|
||||
void crypto_unregister_template(struct crypto_template *tmpl);
|
||||
struct crypto_template *crypto_lookup_template(const char *name);
|
||||
|
||||
int crypto_register_instance(struct crypto_template *tmpl,
|
||||
struct crypto_instance *inst);
|
||||
|
||||
int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
|
||||
struct crypto_instance *inst, u32 mask);
|
||||
int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
|
||||
struct crypto_instance *inst,
|
||||
const struct crypto_type *frontend);
|
||||
|
||||
void crypto_drop_spawn(struct crypto_spawn *spawn);
|
||||
struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
|
||||
u32 mask);
|
||||
void *crypto_spawn_tfm2(struct crypto_spawn *spawn);
|
||||
|
||||
static inline void crypto_set_spawn(struct crypto_spawn *spawn,
|
||||
struct crypto_instance *inst)
|
||||
@@ -129,8 +137,19 @@ static inline void crypto_set_spawn(struct crypto_spawn *spawn,
|
||||
struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);
|
||||
int crypto_check_attr_type(struct rtattr **tb, u32 type);
|
||||
const char *crypto_attr_alg_name(struct rtattr *rta);
|
||||
struct crypto_alg *crypto_attr_alg(struct rtattr *rta, u32 type, u32 mask);
|
||||
struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,
|
||||
const struct crypto_type *frontend,
|
||||
u32 type, u32 mask);
|
||||
|
||||
static inline struct crypto_alg *crypto_attr_alg(struct rtattr *rta,
|
||||
u32 type, u32 mask)
|
||||
{
|
||||
return crypto_attr_alg2(rta, NULL, type, mask);
|
||||
}
|
||||
|
||||
int crypto_attr_u32(struct rtattr *rta, u32 *num);
|
||||
void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg,
|
||||
unsigned int head);
|
||||
struct crypto_instance *crypto_alloc_instance(const char *name,
|
||||
struct crypto_alg *alg);
|
||||
|
||||
@@ -157,12 +176,8 @@ int blkcipher_walk_virt_block(struct blkcipher_desc *desc,
|
||||
|
||||
static inline void *crypto_tfm_ctx_aligned(struct crypto_tfm *tfm)
|
||||
{
|
||||
unsigned long addr = (unsigned long)crypto_tfm_ctx(tfm);
|
||||
unsigned long align = crypto_tfm_alg_alignmask(tfm);
|
||||
|
||||
if (align <= crypto_tfm_ctx_alignment())
|
||||
align = 1;
|
||||
return (void *)ALIGN(addr, align);
|
||||
return PTR_ALIGN(crypto_tfm_ctx(tfm),
|
||||
crypto_tfm_alg_alignmask(tfm) + 1);
|
||||
}
|
||||
|
||||
static inline struct crypto_instance *crypto_tfm_alg_instance(
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
|
||||
#include <linux/crypto.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <crypto/hash.h>
|
||||
|
||||
struct cryptd_ablkcipher {
|
||||
struct crypto_ablkcipher base;
|
||||
@@ -24,4 +25,20 @@ struct cryptd_ablkcipher *cryptd_alloc_ablkcipher(const char *alg_name,
|
||||
struct crypto_blkcipher *cryptd_ablkcipher_child(struct cryptd_ablkcipher *tfm);
|
||||
void cryptd_free_ablkcipher(struct cryptd_ablkcipher *tfm);
|
||||
|
||||
struct cryptd_ahash {
|
||||
struct crypto_ahash base;
|
||||
};
|
||||
|
||||
static inline struct cryptd_ahash *__cryptd_ahash_cast(
|
||||
struct crypto_ahash *tfm)
|
||||
{
|
||||
return (struct cryptd_ahash *)tfm;
|
||||
}
|
||||
|
||||
/* alg_name should be algorithm to be cryptd-ed */
|
||||
struct cryptd_ahash *cryptd_alloc_ahash(const char *alg_name,
|
||||
u32 type, u32 mask);
|
||||
struct crypto_shash *cryptd_ahash_child(struct cryptd_ahash *tfm);
|
||||
void cryptd_free_ahash(struct cryptd_ahash *tfm);
|
||||
|
||||
#endif
|
||||
|
||||
+100
-49
@@ -15,6 +15,42 @@
|
||||
|
||||
#include <linux/crypto.h>
|
||||
|
||||
struct crypto_ahash;
|
||||
|
||||
struct hash_alg_common {
|
||||
unsigned int digestsize;
|
||||
unsigned int statesize;
|
||||
|
||||
struct crypto_alg base;
|
||||
};
|
||||
|
||||
struct ahash_request {
|
||||
struct crypto_async_request base;
|
||||
|
||||
unsigned int nbytes;
|
||||
struct scatterlist *src;
|
||||
u8 *result;
|
||||
|
||||
/* This field may only be used by the ahash API code. */
|
||||
void *priv;
|
||||
|
||||
void *__ctx[] CRYPTO_MINALIGN_ATTR;
|
||||
};
|
||||
|
||||
struct ahash_alg {
|
||||
int (*init)(struct ahash_request *req);
|
||||
int (*update)(struct ahash_request *req);
|
||||
int (*final)(struct ahash_request *req);
|
||||
int (*finup)(struct ahash_request *req);
|
||||
int (*digest)(struct ahash_request *req);
|
||||
int (*export)(struct ahash_request *req, void *out);
|
||||
int (*import)(struct ahash_request *req, const void *in);
|
||||
int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
|
||||
unsigned int keylen);
|
||||
|
||||
struct hash_alg_common halg;
|
||||
};
|
||||
|
||||
struct shash_desc {
|
||||
struct crypto_shash *tfm;
|
||||
u32 flags;
|
||||
@@ -24,7 +60,6 @@ struct shash_desc {
|
||||
|
||||
struct shash_alg {
|
||||
int (*init)(struct shash_desc *desc);
|
||||
int (*reinit)(struct shash_desc *desc);
|
||||
int (*update)(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len);
|
||||
int (*final)(struct shash_desc *desc, u8 *out);
|
||||
@@ -32,38 +67,48 @@ struct shash_alg {
|
||||
unsigned int len, u8 *out);
|
||||
int (*digest)(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len, u8 *out);
|
||||
int (*export)(struct shash_desc *desc, void *out);
|
||||
int (*import)(struct shash_desc *desc, const void *in);
|
||||
int (*setkey)(struct crypto_shash *tfm, const u8 *key,
|
||||
unsigned int keylen);
|
||||
|
||||
unsigned int descsize;
|
||||
unsigned int digestsize;
|
||||
|
||||
/* These fields must match hash_alg_common. */
|
||||
unsigned int digestsize
|
||||
__attribute__ ((aligned(__alignof__(struct hash_alg_common))));
|
||||
unsigned int statesize;
|
||||
|
||||
struct crypto_alg base;
|
||||
};
|
||||
|
||||
struct crypto_ahash {
|
||||
int (*init)(struct ahash_request *req);
|
||||
int (*update)(struct ahash_request *req);
|
||||
int (*final)(struct ahash_request *req);
|
||||
int (*finup)(struct ahash_request *req);
|
||||
int (*digest)(struct ahash_request *req);
|
||||
int (*export)(struct ahash_request *req, void *out);
|
||||
int (*import)(struct ahash_request *req, const void *in);
|
||||
int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
|
||||
unsigned int keylen);
|
||||
|
||||
unsigned int reqsize;
|
||||
struct crypto_tfm base;
|
||||
};
|
||||
|
||||
struct crypto_shash {
|
||||
unsigned int descsize;
|
||||
struct crypto_tfm base;
|
||||
};
|
||||
|
||||
static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
|
||||
{
|
||||
return (struct crypto_ahash *)tfm;
|
||||
return container_of(tfm, struct crypto_ahash, base);
|
||||
}
|
||||
|
||||
static inline struct crypto_ahash *crypto_alloc_ahash(const char *alg_name,
|
||||
u32 type, u32 mask)
|
||||
{
|
||||
type &= ~CRYPTO_ALG_TYPE_MASK;
|
||||
mask &= ~CRYPTO_ALG_TYPE_MASK;
|
||||
type |= CRYPTO_ALG_TYPE_AHASH;
|
||||
mask |= CRYPTO_ALG_TYPE_AHASH_MASK;
|
||||
|
||||
return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, mask));
|
||||
}
|
||||
struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
|
||||
u32 mask);
|
||||
|
||||
static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
|
||||
{
|
||||
@@ -72,7 +117,7 @@ static inline struct crypto_tfm *crypto_ahash_tfm(struct crypto_ahash *tfm)
|
||||
|
||||
static inline void crypto_free_ahash(struct crypto_ahash *tfm)
|
||||
{
|
||||
crypto_free_tfm(crypto_ahash_tfm(tfm));
|
||||
crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
|
||||
}
|
||||
|
||||
static inline unsigned int crypto_ahash_alignmask(
|
||||
@@ -81,14 +126,26 @@ static inline unsigned int crypto_ahash_alignmask(
|
||||
return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
|
||||
}
|
||||
|
||||
static inline struct ahash_tfm *crypto_ahash_crt(struct crypto_ahash *tfm)
|
||||
static inline struct hash_alg_common *__crypto_hash_alg_common(
|
||||
struct crypto_alg *alg)
|
||||
{
|
||||
return &crypto_ahash_tfm(tfm)->crt_ahash;
|
||||
return container_of(alg, struct hash_alg_common, base);
|
||||
}
|
||||
|
||||
static inline struct hash_alg_common *crypto_hash_alg_common(
|
||||
struct crypto_ahash *tfm)
|
||||
{
|
||||
return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);
|
||||
}
|
||||
|
||||
static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
|
||||
{
|
||||
return crypto_ahash_crt(tfm)->digestsize;
|
||||
return crypto_hash_alg_common(tfm)->digestsize;
|
||||
}
|
||||
|
||||
static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
|
||||
{
|
||||
return crypto_hash_alg_common(tfm)->statesize;
|
||||
}
|
||||
|
||||
static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
|
||||
@@ -114,7 +171,7 @@ static inline struct crypto_ahash *crypto_ahash_reqtfm(
|
||||
|
||||
static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
|
||||
{
|
||||
return crypto_ahash_crt(tfm)->reqsize;
|
||||
return tfm->reqsize;
|
||||
}
|
||||
|
||||
static inline void *ahash_request_ctx(struct ahash_request *req)
|
||||
@@ -122,44 +179,30 @@ static inline void *ahash_request_ctx(struct ahash_request *req)
|
||||
return req->__ctx;
|
||||
}
|
||||
|
||||
static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
|
||||
const u8 *key, unsigned int keylen)
|
||||
{
|
||||
struct ahash_tfm *crt = crypto_ahash_crt(tfm);
|
||||
int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
|
||||
unsigned int keylen);
|
||||
int crypto_ahash_finup(struct ahash_request *req);
|
||||
int crypto_ahash_final(struct ahash_request *req);
|
||||
int crypto_ahash_digest(struct ahash_request *req);
|
||||
|
||||
return crt->setkey(tfm, key, keylen);
|
||||
static inline int crypto_ahash_export(struct ahash_request *req, void *out)
|
||||
{
|
||||
return crypto_ahash_reqtfm(req)->export(req, out);
|
||||
}
|
||||
|
||||
static inline int crypto_ahash_digest(struct ahash_request *req)
|
||||
static inline int crypto_ahash_import(struct ahash_request *req, const void *in)
|
||||
{
|
||||
struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
|
||||
return crt->digest(req);
|
||||
return crypto_ahash_reqtfm(req)->import(req, in);
|
||||
}
|
||||
|
||||
static inline void crypto_ahash_export(struct ahash_request *req, u8 *out)
|
||||
{
|
||||
memcpy(out, ahash_request_ctx(req),
|
||||
crypto_ahash_reqsize(crypto_ahash_reqtfm(req)));
|
||||
}
|
||||
|
||||
int crypto_ahash_import(struct ahash_request *req, const u8 *in);
|
||||
|
||||
static inline int crypto_ahash_init(struct ahash_request *req)
|
||||
{
|
||||
struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
|
||||
return crt->init(req);
|
||||
return crypto_ahash_reqtfm(req)->init(req);
|
||||
}
|
||||
|
||||
static inline int crypto_ahash_update(struct ahash_request *req)
|
||||
{
|
||||
struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
|
||||
return crt->update(req);
|
||||
}
|
||||
|
||||
static inline int crypto_ahash_final(struct ahash_request *req)
|
||||
{
|
||||
struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
|
||||
return crt->final(req);
|
||||
return crypto_ahash_reqtfm(req)->update(req);
|
||||
}
|
||||
|
||||
static inline void ahash_request_set_tfm(struct ahash_request *req,
|
||||
@@ -184,7 +227,7 @@ static inline struct ahash_request *ahash_request_alloc(
|
||||
|
||||
static inline void ahash_request_free(struct ahash_request *req)
|
||||
{
|
||||
kfree(req);
|
||||
kzfree(req);
|
||||
}
|
||||
|
||||
static inline struct ahash_request *ahash_request_cast(
|
||||
@@ -251,6 +294,11 @@ static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
|
||||
return crypto_shash_alg(tfm)->digestsize;
|
||||
}
|
||||
|
||||
static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
|
||||
{
|
||||
return crypto_shash_alg(tfm)->statesize;
|
||||
}
|
||||
|
||||
static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
|
||||
{
|
||||
return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
|
||||
@@ -268,7 +316,7 @@ static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
|
||||
|
||||
static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
|
||||
{
|
||||
return crypto_shash_alg(tfm)->descsize;
|
||||
return tfm->descsize;
|
||||
}
|
||||
|
||||
static inline void *shash_desc_ctx(struct shash_desc *desc)
|
||||
@@ -281,12 +329,15 @@ int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
|
||||
int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len, u8 *out);
|
||||
|
||||
static inline void crypto_shash_export(struct shash_desc *desc, u8 *out)
|
||||
static inline int crypto_shash_export(struct shash_desc *desc, void *out)
|
||||
{
|
||||
memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
|
||||
return crypto_shash_alg(desc->tfm)->export(desc, out);
|
||||
}
|
||||
|
||||
int crypto_shash_import(struct shash_desc *desc, const u8 *in);
|
||||
static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
|
||||
{
|
||||
return crypto_shash_alg(desc->tfm)->import(desc, in);
|
||||
}
|
||||
|
||||
static inline int crypto_shash_init(struct shash_desc *desc)
|
||||
{
|
||||
|
||||
@@ -34,6 +34,22 @@ struct crypto_hash_walk {
|
||||
unsigned int flags;
|
||||
};
|
||||
|
||||
struct ahash_instance {
|
||||
struct ahash_alg alg;
|
||||
};
|
||||
|
||||
struct shash_instance {
|
||||
struct shash_alg alg;
|
||||
};
|
||||
|
||||
struct crypto_ahash_spawn {
|
||||
struct crypto_spawn base;
|
||||
};
|
||||
|
||||
struct crypto_shash_spawn {
|
||||
struct crypto_spawn base;
|
||||
};
|
||||
|
||||
extern const struct crypto_type crypto_ahash_type;
|
||||
|
||||
int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
|
||||
@@ -43,18 +59,100 @@ int crypto_hash_walk_first_compat(struct hash_desc *hdesc,
|
||||
struct crypto_hash_walk *walk,
|
||||
struct scatterlist *sg, unsigned int len);
|
||||
|
||||
static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
|
||||
{
|
||||
return !(walk->entrylen | walk->total);
|
||||
}
|
||||
|
||||
int crypto_register_ahash(struct ahash_alg *alg);
|
||||
int crypto_unregister_ahash(struct ahash_alg *alg);
|
||||
int ahash_register_instance(struct crypto_template *tmpl,
|
||||
struct ahash_instance *inst);
|
||||
void ahash_free_instance(struct crypto_instance *inst);
|
||||
|
||||
int crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn,
|
||||
struct hash_alg_common *alg,
|
||||
struct crypto_instance *inst);
|
||||
|
||||
static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
|
||||
{
|
||||
crypto_drop_spawn(&spawn->base);
|
||||
}
|
||||
|
||||
struct hash_alg_common *ahash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
|
||||
|
||||
int crypto_register_shash(struct shash_alg *alg);
|
||||
int crypto_unregister_shash(struct shash_alg *alg);
|
||||
int shash_register_instance(struct crypto_template *tmpl,
|
||||
struct shash_instance *inst);
|
||||
void shash_free_instance(struct crypto_instance *inst);
|
||||
|
||||
int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
|
||||
struct shash_alg *alg,
|
||||
struct crypto_instance *inst);
|
||||
|
||||
static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
|
||||
{
|
||||
crypto_drop_spawn(&spawn->base);
|
||||
}
|
||||
|
||||
struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask);
|
||||
|
||||
int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
|
||||
int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
|
||||
int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
|
||||
|
||||
int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
|
||||
|
||||
static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
|
||||
{
|
||||
return crypto_tfm_ctx(&tfm->base);
|
||||
return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
|
||||
}
|
||||
|
||||
static inline struct ahash_alg *crypto_ahash_alg(
|
||||
struct crypto_ahash *tfm)
|
||||
static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
|
||||
{
|
||||
return &crypto_ahash_tfm(tfm)->__crt_alg->cra_ahash;
|
||||
return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
|
||||
halg);
|
||||
}
|
||||
|
||||
static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
|
||||
unsigned int reqsize)
|
||||
{
|
||||
tfm->reqsize = reqsize;
|
||||
}
|
||||
|
||||
static inline struct crypto_instance *ahash_crypto_instance(
|
||||
struct ahash_instance *inst)
|
||||
{
|
||||
return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
|
||||
}
|
||||
|
||||
static inline struct ahash_instance *ahash_instance(
|
||||
struct crypto_instance *inst)
|
||||
{
|
||||
return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
|
||||
}
|
||||
|
||||
static inline void *ahash_instance_ctx(struct ahash_instance *inst)
|
||||
{
|
||||
return crypto_instance_ctx(ahash_crypto_instance(inst));
|
||||
}
|
||||
|
||||
static inline unsigned int ahash_instance_headroom(void)
|
||||
{
|
||||
return sizeof(struct ahash_alg) - sizeof(struct crypto_alg);
|
||||
}
|
||||
|
||||
static inline struct ahash_instance *ahash_alloc_instance(
|
||||
const char *name, struct crypto_alg *alg)
|
||||
{
|
||||
return crypto_alloc_instance2(name, alg, ahash_instance_headroom());
|
||||
}
|
||||
|
||||
static inline struct crypto_ahash *crypto_spawn_ahash(
|
||||
struct crypto_ahash_spawn *spawn)
|
||||
{
|
||||
return crypto_spawn_tfm2(&spawn->base);
|
||||
}
|
||||
|
||||
static inline int ahash_enqueue_request(struct crypto_queue *queue,
|
||||
@@ -80,5 +178,46 @@ static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
|
||||
return crypto_tfm_ctx(&tfm->base);
|
||||
}
|
||||
|
||||
static inline struct crypto_instance *shash_crypto_instance(
|
||||
struct shash_instance *inst)
|
||||
{
|
||||
return container_of(&inst->alg.base, struct crypto_instance, alg);
|
||||
}
|
||||
|
||||
static inline struct shash_instance *shash_instance(
|
||||
struct crypto_instance *inst)
|
||||
{
|
||||
return container_of(__crypto_shash_alg(&inst->alg),
|
||||
struct shash_instance, alg);
|
||||
}
|
||||
|
||||
static inline void *shash_instance_ctx(struct shash_instance *inst)
|
||||
{
|
||||
return crypto_instance_ctx(shash_crypto_instance(inst));
|
||||
}
|
||||
|
||||
static inline struct shash_instance *shash_alloc_instance(
|
||||
const char *name, struct crypto_alg *alg)
|
||||
{
|
||||
return crypto_alloc_instance2(name, alg,
|
||||
sizeof(struct shash_alg) - sizeof(*alg));
|
||||
}
|
||||
|
||||
static inline struct crypto_shash *crypto_spawn_shash(
|
||||
struct crypto_shash_spawn *spawn)
|
||||
{
|
||||
return crypto_spawn_tfm2(&spawn->base);
|
||||
}
|
||||
|
||||
static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
|
||||
{
|
||||
return crypto_tfm_ctx_aligned(&tfm->base);
|
||||
}
|
||||
|
||||
static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
|
||||
{
|
||||
return container_of(tfm, struct crypto_shash, base);
|
||||
}
|
||||
|
||||
#endif /* _CRYPTO_INTERNAL_HASH_H */
|
||||
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
#ifndef _CRYPTO_SHA_H
|
||||
#define _CRYPTO_SHA_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
#define SHA1_DIGEST_SIZE 20
|
||||
#define SHA1_BLOCK_SIZE 64
|
||||
|
||||
@@ -62,4 +64,22 @@
|
||||
#define SHA512_H6 0x1f83d9abfb41bd6bULL
|
||||
#define SHA512_H7 0x5be0cd19137e2179ULL
|
||||
|
||||
struct sha1_state {
|
||||
u64 count;
|
||||
u32 state[SHA1_DIGEST_SIZE / 4];
|
||||
u8 buffer[SHA1_BLOCK_SIZE];
|
||||
};
|
||||
|
||||
struct sha256_state {
|
||||
u64 count;
|
||||
u32 state[SHA256_DIGEST_SIZE / 4];
|
||||
u8 buf[SHA256_BLOCK_SIZE];
|
||||
};
|
||||
|
||||
struct sha512_state {
|
||||
u64 count[2];
|
||||
u64 state[SHA512_DIGEST_SIZE / 8];
|
||||
u8 buf[SHA512_BLOCK_SIZE];
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
/*
|
||||
* Modified to interface to the Linux kernel
|
||||
* Copyright (c) 2009, Intel Corporation.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with
|
||||
* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
||||
* Place - Suite 330, Boston, MA 02111-1307 USA.
|
||||
*/
|
||||
|
||||
#ifndef __CRYPTO_VMAC_H
|
||||
#define __CRYPTO_VMAC_H
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
* VMAC and VHASH Implementation by Ted Krovetz (tdk@acm.org) and Wei Dai.
|
||||
* This implementation is herby placed in the public domain.
|
||||
* The authors offers no warranty. Use at your own risk.
|
||||
* Please send bug reports to the authors.
|
||||
* Last modified: 17 APR 08, 1700 PDT
|
||||
* ----------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* User definable settings.
|
||||
*/
|
||||
#define VMAC_TAG_LEN 64
|
||||
#define VMAC_KEY_SIZE 128/* Must be 128, 192 or 256 */
|
||||
#define VMAC_KEY_LEN (VMAC_KEY_SIZE/8)
|
||||
#define VMAC_NHBYTES 128/* Must 2^i for any 3 < i < 13 Standard = 128*/
|
||||
|
||||
/*
|
||||
* This implementation uses u32 and u64 as names for unsigned 32-
|
||||
* and 64-bit integer types. These are defined in C99 stdint.h. The
|
||||
* following may need adaptation if you are not running a C99 or
|
||||
* Microsoft C environment.
|
||||
*/
|
||||
struct vmac_ctx {
|
||||
u64 nhkey[(VMAC_NHBYTES/8)+2*(VMAC_TAG_LEN/64-1)];
|
||||
u64 polykey[2*VMAC_TAG_LEN/64];
|
||||
u64 l3key[2*VMAC_TAG_LEN/64];
|
||||
u64 polytmp[2*VMAC_TAG_LEN/64];
|
||||
u64 cached_nonce[2];
|
||||
u64 cached_aes[2];
|
||||
int first_block_processed;
|
||||
};
|
||||
|
||||
typedef u64 vmac_t;
|
||||
|
||||
struct vmac_ctx_t {
|
||||
struct crypto_cipher *child;
|
||||
struct vmac_ctx __vmac_ctx;
|
||||
};
|
||||
|
||||
#endif /* __CRYPTO_VMAC_H */
|
||||
@@ -268,6 +268,10 @@ ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/include/asm/kvm.h \
|
||||
$(srctree)/include/asm-$(SRCARCH)/kvm.h),)
|
||||
unifdef-y += kvm.h
|
||||
endif
|
||||
ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/include/asm/kvm_para.h \
|
||||
$(srctree)/include/asm-$(SRCARCH)/kvm_para.h),)
|
||||
unifdef-y += kvm_para.h
|
||||
endif
|
||||
unifdef-y += llc.h
|
||||
unifdef-y += loop.h
|
||||
unifdef-y += lp.h
|
||||
|
||||
@@ -79,9 +79,12 @@ struct agp_memory {
|
||||
u32 physical;
|
||||
bool is_bound;
|
||||
bool is_flushed;
|
||||
bool vmalloc_flag;
|
||||
bool vmalloc_flag;
|
||||
/* list of agp_memory mapped to the aperture */
|
||||
struct list_head mapped_list;
|
||||
/* DMA-mapped addresses */
|
||||
struct scatterlist *sg_list;
|
||||
int num_sg;
|
||||
};
|
||||
|
||||
#define AGP_NORMAL_MEMORY 0
|
||||
|
||||
@@ -36,6 +36,11 @@ struct amba_driver {
|
||||
struct amba_id *id_table;
|
||||
};
|
||||
|
||||
enum amba_vendor {
|
||||
AMBA_VENDOR_ARM = 0x41,
|
||||
AMBA_VENDOR_ST = 0x80,
|
||||
};
|
||||
|
||||
#define amba_get_drvdata(d) dev_get_drvdata(&d->dev)
|
||||
#define amba_set_drvdata(d,p) dev_set_drvdata(&d->dev, p)
|
||||
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
/* linux/amba/pl093.h
|
||||
*
|
||||
* Copyright (c) 2008 Simtec Electronics
|
||||
* http://armlinux.simtec.co.uk/
|
||||
* Ben Dooks <ben@simtec.co.uk>
|
||||
*
|
||||
* AMBA PL093 SSMC (synchronous static memory controller)
|
||||
* See DDI0236.pdf (r0p4) for more details
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#define SMB_BANK(x) ((x) * 0x20) /* each bank control set is 0x20 apart */
|
||||
|
||||
/* Offsets for SMBxxxxRy registers */
|
||||
|
||||
#define SMBIDCYR (0x00)
|
||||
#define SMBWSTRDR (0x04)
|
||||
#define SMBWSTWRR (0x08)
|
||||
#define SMBWSTOENR (0x0C)
|
||||
#define SMBWSTWENR (0x10)
|
||||
#define SMBCR (0x14)
|
||||
#define SMBSR (0x18)
|
||||
#define SMBWSTBRDR (0x1C)
|
||||
|
||||
/* Masks for SMB registers */
|
||||
#define IDCY_MASK (0xf)
|
||||
#define WSTRD_MASK (0xf)
|
||||
#define WSTWR_MASK (0xf)
|
||||
#define WSTOEN_MASK (0xf)
|
||||
#define WSTWEN_MASK (0xf)
|
||||
|
||||
/* Notes from datasheet:
|
||||
* WSTOEN <= WSTRD
|
||||
* WSTWEN <= WSTWR
|
||||
*
|
||||
* WSTOEN is not used with nWAIT
|
||||
*/
|
||||
|
||||
/* SMBCR bit definitions */
|
||||
#define SMBCR_BIWRITEEN (1 << 21)
|
||||
#define SMBCR_ADDRVALIDWRITEEN (1 << 20)
|
||||
#define SMBCR_SYNCWRITE (1 << 17)
|
||||
#define SMBCR_BMWRITE (1 << 16)
|
||||
#define SMBCR_WRAPREAD (1 << 14)
|
||||
#define SMBCR_BIREADEN (1 << 13)
|
||||
#define SMBCR_ADDRVALIDREADEN (1 << 12)
|
||||
#define SMBCR_SYNCREAD (1 << 9)
|
||||
#define SMBCR_BMREAD (1 << 8)
|
||||
#define SMBCR_SMBLSPOL (1 << 6)
|
||||
#define SMBCR_WP (1 << 3)
|
||||
#define SMBCR_WAITEN (1 << 2)
|
||||
#define SMBCR_WAITPOL (1 << 1)
|
||||
#define SMBCR_RBLE (1 << 0)
|
||||
|
||||
#define SMBCR_BURSTLENWRITE_MASK (3 << 18)
|
||||
#define SMBCR_BURSTLENWRITE_4 (0 << 18)
|
||||
#define SMBCR_BURSTLENWRITE_8 (1 << 18)
|
||||
#define SMBCR_BURSTLENWRITE_RESERVED (2 << 18)
|
||||
#define SMBCR_BURSTLENWRITE_CONTINUOUS (3 << 18)
|
||||
|
||||
#define SMBCR_BURSTLENREAD_MASK (3 << 10)
|
||||
#define SMBCR_BURSTLENREAD_4 (0 << 10)
|
||||
#define SMBCR_BURSTLENREAD_8 (1 << 10)
|
||||
#define SMBCR_BURSTLENREAD_16 (2 << 10)
|
||||
#define SMBCR_BURSTLENREAD_CONTINUOUS (3 << 10)
|
||||
|
||||
#define SMBCR_MW_MASK (3 << 4)
|
||||
#define SMBCR_MW_8BIT (0 << 4)
|
||||
#define SMBCR_MW_16BIT (1 << 4)
|
||||
#define SMBCR_MW_M32BIT (2 << 4)
|
||||
|
||||
/* SSMC status registers */
|
||||
#define SSMCCSR (0x200)
|
||||
#define SSMCCR (0x204)
|
||||
#define SSMCITCR (0x208)
|
||||
#define SSMCITIP (0x20C)
|
||||
#define SSMCITIOP (0x210)
|
||||
@@ -337,7 +337,8 @@ struct net_device *alloc_arcdev(const char *name);
|
||||
|
||||
int arcnet_open(struct net_device *dev);
|
||||
int arcnet_close(struct net_device *dev);
|
||||
int arcnet_send_packet(struct sk_buff *skb, struct net_device *dev);
|
||||
netdev_tx_t arcnet_send_packet(struct sk_buff *skb,
|
||||
struct net_device *dev);
|
||||
void arcnet_timeout(struct net_device *dev);
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
|
||||
+35
-1
@@ -210,15 +210,25 @@ enum {
|
||||
ATA_CMD_STANDBY = 0xE2, /* place in standby power mode */
|
||||
ATA_CMD_IDLE = 0xE3, /* place in idle power mode */
|
||||
ATA_CMD_EDD = 0x90, /* execute device diagnostic */
|
||||
ATA_CMD_DOWNLOAD_MICRO = 0x92,
|
||||
ATA_CMD_NOP = 0x00,
|
||||
ATA_CMD_FLUSH = 0xE7,
|
||||
ATA_CMD_FLUSH_EXT = 0xEA,
|
||||
ATA_CMD_ID_ATA = 0xEC,
|
||||
ATA_CMD_ID_ATAPI = 0xA1,
|
||||
ATA_CMD_SERVICE = 0xA2,
|
||||
ATA_CMD_READ = 0xC8,
|
||||
ATA_CMD_READ_EXT = 0x25,
|
||||
ATA_CMD_READ_QUEUED = 0x26,
|
||||
ATA_CMD_READ_STREAM_EXT = 0x2B,
|
||||
ATA_CMD_READ_STREAM_DMA_EXT = 0x2A,
|
||||
ATA_CMD_WRITE = 0xCA,
|
||||
ATA_CMD_WRITE_EXT = 0x35,
|
||||
ATA_CMD_WRITE_QUEUED = 0x36,
|
||||
ATA_CMD_WRITE_STREAM_EXT = 0x3B,
|
||||
ATA_CMD_WRITE_STREAM_DMA_EXT = 0x3A,
|
||||
ATA_CMD_WRITE_FUA_EXT = 0x3D,
|
||||
ATA_CMD_WRITE_QUEUED_FUA_EXT = 0x3E,
|
||||
ATA_CMD_FPDMA_READ = 0x60,
|
||||
ATA_CMD_FPDMA_WRITE = 0x61,
|
||||
ATA_CMD_PIO_READ = 0x20,
|
||||
@@ -235,6 +245,7 @@ enum {
|
||||
ATA_CMD_PACKET = 0xA0,
|
||||
ATA_CMD_VERIFY = 0x40,
|
||||
ATA_CMD_VERIFY_EXT = 0x42,
|
||||
ATA_CMD_WRITE_UNCORR_EXT = 0x45,
|
||||
ATA_CMD_STANDBYNOW1 = 0xE0,
|
||||
ATA_CMD_IDLEIMMEDIATE = 0xE1,
|
||||
ATA_CMD_SLEEP = 0xE6,
|
||||
@@ -243,15 +254,34 @@ enum {
|
||||
ATA_CMD_READ_NATIVE_MAX_EXT = 0x27,
|
||||
ATA_CMD_SET_MAX = 0xF9,
|
||||
ATA_CMD_SET_MAX_EXT = 0x37,
|
||||
ATA_CMD_READ_LOG_EXT = 0x2f,
|
||||
ATA_CMD_READ_LOG_EXT = 0x2F,
|
||||
ATA_CMD_WRITE_LOG_EXT = 0x3F,
|
||||
ATA_CMD_READ_LOG_DMA_EXT = 0x47,
|
||||
ATA_CMD_WRITE_LOG_DMA_EXT = 0x57,
|
||||
ATA_CMD_TRUSTED_RCV = 0x5C,
|
||||
ATA_CMD_TRUSTED_RCV_DMA = 0x5D,
|
||||
ATA_CMD_TRUSTED_SND = 0x5E,
|
||||
ATA_CMD_TRUSTED_SND_DMA = 0x5F,
|
||||
ATA_CMD_PMP_READ = 0xE4,
|
||||
ATA_CMD_PMP_WRITE = 0xE8,
|
||||
ATA_CMD_CONF_OVERLAY = 0xB1,
|
||||
ATA_CMD_SEC_SET_PASS = 0xF1,
|
||||
ATA_CMD_SEC_UNLOCK = 0xF2,
|
||||
ATA_CMD_SEC_ERASE_PREP = 0xF3,
|
||||
ATA_CMD_SEC_ERASE_UNIT = 0xF4,
|
||||
ATA_CMD_SEC_FREEZE_LOCK = 0xF5,
|
||||
ATA_CMD_SEC_DISABLE_PASS = 0xF6,
|
||||
ATA_CMD_CONFIG_STREAM = 0x51,
|
||||
ATA_CMD_SMART = 0xB0,
|
||||
ATA_CMD_MEDIA_LOCK = 0xDE,
|
||||
ATA_CMD_MEDIA_UNLOCK = 0xDF,
|
||||
ATA_CMD_DSM = 0x06,
|
||||
ATA_CMD_CHK_MED_CRD_TYP = 0xD1,
|
||||
ATA_CMD_CFA_REQ_EXT_ERR = 0x03,
|
||||
ATA_CMD_CFA_WRITE_NE = 0x38,
|
||||
ATA_CMD_CFA_TRANS_SECT = 0x87,
|
||||
ATA_CMD_CFA_ERASE = 0xC0,
|
||||
ATA_CMD_CFA_WRITE_MULT_NE = 0xCD,
|
||||
/* marked obsolete in the ATA/ATAPI-7 spec */
|
||||
ATA_CMD_RESTORE = 0x10,
|
||||
|
||||
@@ -306,6 +336,7 @@ enum {
|
||||
/* SETFEATURE Sector counts for SATA features */
|
||||
SATA_AN = 0x05, /* Asynchronous Notification */
|
||||
SATA_DIPM = 0x03, /* Device Initiated Power Management */
|
||||
SATA_FPDMA_AA = 0x02, /* DMA Setup FIS Auto-Activate */
|
||||
|
||||
/* feature values for SET_MAX */
|
||||
ATA_SET_MAX_ADDR = 0x00,
|
||||
@@ -525,6 +556,9 @@ static inline int ata_is_data(u8 prot)
|
||||
#define ata_id_has_atapi_AN(id) \
|
||||
( (((id)[76] != 0x0000) && ((id)[76] != 0xffff)) && \
|
||||
((id)[78] & (1 << 5)) )
|
||||
#define ata_id_has_fpdma_aa(id) \
|
||||
( (((id)[76] != 0x0000) && ((id)[76] != 0xffff)) && \
|
||||
((id)[78] & (1 << 2)) )
|
||||
#define ata_id_iordy_disable(id) ((id)[ATA_ID_CAPABILITY] & (1 << 10))
|
||||
#define ata_id_has_iordy(id) ((id)[ATA_ID_CAPABILITY] & (1 << 11))
|
||||
#define ata_id_u32(id,n) \
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user