Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781// SPDX-License-Identifier: GPL-2.0-only/* * linux/drivers/firmware/edd.c * Copyright (C) 2002, 2003, 2004 Dell Inc. * by Matt Domsch <Matt_Domsch@dell.com> * disk signature by Matt Domsch, Andrew Wilks, and Sandeep K. Shandilya * legacy CHS by Patrick J. LoPresti <patl@users.sourceforge.net> * * BIOS Enhanced Disk Drive Services (EDD) * conformant to T13 Committee www.t13.org * projects 1572D, 1484D, 1386D, 1226DT * * This code takes information provided by BIOS EDD calls * fn41 - Check Extensions Present and * fn48 - Get Device Parameters with EDD extensions * made in setup.S, copied to safe structures in setup.c, * and presents it in sysfs. * * Please see http://linux.dell.com/edd/results.html for * the list of BIOSs which have been reported to implement EDD. */
#include <linux/module.h>#include <linux/string.h>#include <linux/types.h>#include <linux/init.h>#include <linux/stat.h>#include <linux/err.h>#include <linux/ctype.h>#include <linux/slab.h>#include <linux/limits.h>#include <linux/device.h>#include <linux/pci.h>#include <linux/blkdev.h>#include <linux/edd.h>
#define EDD_VERSION "0.16"#define EDD_DATE "2004-Jun-25"
MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");MODULE_DESCRIPTION("sysfs interface to BIOS EDD information");MODULE_LICENSE("GPL");MODULE_VERSION(EDD_VERSION);
#define left (PAGE_SIZE - (p - buf) - 1)
struct edd_device { unsigned int index; unsigned int mbr_signature; struct edd_info *info; struct kobject kobj;};
struct edd_attribute { struct attribute attr; ssize_t(*show) (struct edd_device * edev, char *buf); int (*test) (struct edd_device * edev);};
/* forward declarations */static int edd_dev_is_type(struct edd_device *edev, const char *type);static struct pci_dev *edd_get_pci_dev(struct edd_device *edev);
static struct edd_device *edd_devices[EDD_MBR_SIG_MAX];
#define EDD_DEVICE_ATTR(_name,_mode,_show,_test) \struct edd_attribute edd_attr_##_name = { \ .attr = {.name = __stringify(_name), .mode = _mode }, \ .show = _show, \ .test = _test, \};
static intedd_has_mbr_signature(struct edd_device *edev){ return edev->index < min_t(unsigned char, edd.mbr_signature_nr, EDD_MBR_SIG_MAX);}
static intedd_has_edd_info(struct edd_device *edev){ return edev->index < min_t(unsigned char, edd.edd_info_nr, EDDMAXNR);}
static inline struct edd_info *edd_dev_get_info(struct edd_device *edev){ return edev->info;}
static inline voidedd_dev_set_info(struct edd_device *edev, int i){ edev->index = i; if (edd_has_mbr_signature(edev)) edev->mbr_signature = edd.mbr_signature[i]; if (edd_has_edd_info(edev)) edev->info = &edd.edd_info[i];}
#define to_edd_attr(_attr) container_of(_attr,struct edd_attribute,attr)#define to_edd_device(obj) container_of(obj,struct edd_device,kobj)
static ssize_tedd_attr_show(struct kobject * kobj, struct attribute *attr, char *buf){ struct edd_device *dev = to_edd_device(kobj); struct edd_attribute *edd_attr = to_edd_attr(attr); ssize_t ret = -EIO;
if (edd_attr->show) ret = edd_attr->show(dev, buf); return ret;}
static const struct sysfs_ops edd_attr_ops = { .show = edd_attr_show,};
static ssize_tedd_show_host_bus(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; int i;
if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
for (i = 0; i < 4; i++) { if (isprint(info->params.host_bus_type[i])) { p += scnprintf(p, left, "%c", info->params.host_bus_type[i]); } else { p += scnprintf(p, left, " "); } }
if (!strncmp(info->params.host_bus_type, "ISA", 3)) { p += scnprintf(p, left, "\tbase_address: %x\n", info->params.interface_path.isa.base_address); } else if (!strncmp(info->params.host_bus_type, "PCIX", 4) || !strncmp(info->params.host_bus_type, "PCI", 3) || !strncmp(info->params.host_bus_type, "XPRS", 4)) { p += scnprintf(p, left, "\t%02x:%02x.%d channel: %u\n", info->params.interface_path.pci.bus, info->params.interface_path.pci.slot, info->params.interface_path.pci.function, info->params.interface_path.pci.channel); } else if (!strncmp(info->params.host_bus_type, "IBND", 4) || !strncmp(info->params.host_bus_type, "HTPT", 4)) { p += scnprintf(p, left, "\tTBD: %llx\n", info->params.interface_path.ibnd.reserved);
} else { p += scnprintf(p, left, "\tunknown: %llx\n", info->params.interface_path.unknown.reserved); } return (p - buf);}
static ssize_tedd_show_interface(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; int i;
if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
for (i = 0; i < 8; i++) { if (isprint(info->params.interface_type[i])) { p += scnprintf(p, left, "%c", info->params.interface_type[i]); } else { p += scnprintf(p, left, " "); } } if (!strncmp(info->params.interface_type, "ATAPI", 5)) { p += scnprintf(p, left, "\tdevice: %u lun: %u\n", info->params.device_path.atapi.device, info->params.device_path.atapi.lun); } else if (!strncmp(info->params.interface_type, "ATA", 3)) { p += scnprintf(p, left, "\tdevice: %u\n", info->params.device_path.ata.device); } else if (!strncmp(info->params.interface_type, "SCSI", 4)) { p += scnprintf(p, left, "\tid: %u lun: %llu\n", info->params.device_path.scsi.id, info->params.device_path.scsi.lun); } else if (!strncmp(info->params.interface_type, "USB", 3)) { p += scnprintf(p, left, "\tserial_number: %llx\n", info->params.device_path.usb.serial_number); } else if (!strncmp(info->params.interface_type, "1394", 4)) { p += scnprintf(p, left, "\teui: %llx\n", info->params.device_path.i1394.eui); } else if (!strncmp(info->params.interface_type, "FIBRE", 5)) { p += scnprintf(p, left, "\twwid: %llx lun: %llx\n", info->params.device_path.fibre.wwid, info->params.device_path.fibre.lun); } else if (!strncmp(info->params.interface_type, "I2O", 3)) { p += scnprintf(p, left, "\tidentity_tag: %llx\n", info->params.device_path.i2o.identity_tag); } else if (!strncmp(info->params.interface_type, "RAID", 4)) { p += scnprintf(p, left, "\tidentity_tag: %x\n", info->params.device_path.raid.array_number); } else if (!strncmp(info->params.interface_type, "SATA", 4)) { p += scnprintf(p, left, "\tdevice: %u\n", info->params.device_path.sata.device); } else { p += scnprintf(p, left, "\tunknown: %llx %llx\n", info->params.device_path.unknown.reserved1, info->params.device_path.unknown.reserved2); }
return (p - buf);}
/** * edd_show_raw_data() - copies raw data to buffer for userspace to parse * @edev: target edd_device * @buf: output buffer * * Returns: number of bytes written, or -EINVAL on failure */static ssize_tedd_show_raw_data(struct edd_device *edev, char *buf){ struct edd_info *info; ssize_t len = sizeof (info->params); if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
if (!(info->params.key == 0xBEDD || info->params.key == 0xDDBE)) len = info->params.length;
/* In case of buggy BIOSs */ if (len > (sizeof(info->params))) len = sizeof(info->params);
memcpy(buf, &info->params, len); return len;}
static ssize_tedd_show_version(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "0x%02x\n", info->version); return (p - buf);}
static ssize_tedd_show_mbr_signature(struct edd_device *edev, char *buf){ char *p = buf; p += scnprintf(p, left, "0x%08x\n", edev->mbr_signature); return (p - buf);}
static ssize_tedd_show_extensions(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
if (info->interface_support & EDD_EXT_FIXED_DISK_ACCESS) { p += scnprintf(p, left, "Fixed disk access\n"); } if (info->interface_support & EDD_EXT_DEVICE_LOCKING_AND_EJECTING) { p += scnprintf(p, left, "Device locking and ejecting\n"); } if (info->interface_support & EDD_EXT_ENHANCED_DISK_DRIVE_SUPPORT) { p += scnprintf(p, left, "Enhanced Disk Drive support\n"); } if (info->interface_support & EDD_EXT_64BIT_EXTENSIONS) { p += scnprintf(p, left, "64-bit extensions\n"); } return (p - buf);}
static ssize_tedd_show_info_flags(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
if (info->params.info_flags & EDD_INFO_DMA_BOUNDARY_ERROR_TRANSPARENT) p += scnprintf(p, left, "DMA boundary error transparent\n"); if (info->params.info_flags & EDD_INFO_GEOMETRY_VALID) p += scnprintf(p, left, "geometry valid\n"); if (info->params.info_flags & EDD_INFO_REMOVABLE) p += scnprintf(p, left, "removable\n"); if (info->params.info_flags & EDD_INFO_WRITE_VERIFY) p += scnprintf(p, left, "write verify\n"); if (info->params.info_flags & EDD_INFO_MEDIA_CHANGE_NOTIFICATION) p += scnprintf(p, left, "media change notification\n"); if (info->params.info_flags & EDD_INFO_LOCKABLE) p += scnprintf(p, left, "lockable\n"); if (info->params.info_flags & EDD_INFO_NO_MEDIA_PRESENT) p += scnprintf(p, left, "no media present\n"); if (info->params.info_flags & EDD_INFO_USE_INT13_FN50) p += scnprintf(p, left, "use int13 fn50\n"); return (p - buf);}
static ssize_tedd_show_legacy_max_cylinder(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%u\n", info->legacy_max_cylinder); return (p - buf);}
static ssize_tedd_show_legacy_max_head(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%u\n", info->legacy_max_head); return (p - buf);}
static ssize_tedd_show_legacy_sectors_per_track(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%u\n", info->legacy_sectors_per_track); return (p - buf);}
static ssize_tedd_show_default_cylinders(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%u\n", info->params.num_default_cylinders); return (p - buf);}
static ssize_tedd_show_default_heads(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%u\n", info->params.num_default_heads); return (p - buf);}
static ssize_tedd_show_default_sectors_per_track(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%u\n", info->params.sectors_per_track); return (p - buf);}
static ssize_tedd_show_sectors(struct edd_device *edev, char *buf){ struct edd_info *info; char *p = buf; if (!edev) return -EINVAL; info = edd_dev_get_info(edev); if (!info || !buf) return -EINVAL;
p += scnprintf(p, left, "%llu\n", info->params.number_of_sectors); return (p - buf);}
/* * Some device instances may not have all the above attributes, * or the attribute values may be meaningless (i.e. if * the device is < EDD 3.0, it won't have host_bus and interface * information), so don't bother making files for them. Likewise * if the default_{cylinders,heads,sectors_per_track} values * are zero, the BIOS doesn't provide sane values, don't bother * creating files for them either. */
static intedd_has_legacy_max_cylinder(struct edd_device *edev){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0; return info->legacy_max_cylinder > 0;}
static intedd_has_legacy_max_head(struct edd_device *edev){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0; return info->legacy_max_head > 0;}
static intedd_has_legacy_sectors_per_track(struct edd_device *edev){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0; return info->legacy_sectors_per_track > 0;}
static intedd_has_default_cylinders(struct edd_device *edev){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0; return info->params.num_default_cylinders > 0;}
static intedd_has_default_heads(struct edd_device *edev){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0; return info->params.num_default_heads > 0;}
static intedd_has_default_sectors_per_track(struct edd_device *edev){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0; return info->params.sectors_per_track > 0;}
static intedd_has_edd30(struct edd_device *edev){ struct edd_info *info; int i; u8 csum = 0;
if (!edev) return 0; info = edd_dev_get_info(edev); if (!info) return 0;
if (!(info->params.key == 0xBEDD || info->params.key == 0xDDBE)) { return 0; }
/* We support only T13 spec */ if (info->params.device_path_info_length != 44) return 0;
for (i = 30; i < info->params.device_path_info_length + 30; i++) csum += *(((u8 *)&info->params) + i);
if (csum) return 0;
return 1;}
static EDD_DEVICE_ATTR(raw_data, 0444, edd_show_raw_data, edd_has_edd_info);static EDD_DEVICE_ATTR(version, 0444, edd_show_version, edd_has_edd_info);static EDD_DEVICE_ATTR(extensions, 0444, edd_show_extensions, edd_has_edd_info);static EDD_DEVICE_ATTR(info_flags, 0444, edd_show_info_flags, edd_has_edd_info);static EDD_DEVICE_ATTR(sectors, 0444, edd_show_sectors, edd_has_edd_info);static EDD_DEVICE_ATTR(legacy_max_cylinder, 0444, edd_show_legacy_max_cylinder, edd_has_legacy_max_cylinder);static EDD_DEVICE_ATTR(legacy_max_head, 0444, edd_show_legacy_max_head, edd_has_legacy_max_head);static EDD_DEVICE_ATTR(legacy_sectors_per_track, 0444, edd_show_legacy_sectors_per_track, edd_has_legacy_sectors_per_track);static EDD_DEVICE_ATTR(default_cylinders, 0444, edd_show_default_cylinders, edd_has_default_cylinders);static EDD_DEVICE_ATTR(default_heads, 0444, edd_show_default_heads, edd_has_default_heads);static EDD_DEVICE_ATTR(default_sectors_per_track, 0444, edd_show_default_sectors_per_track, edd_has_default_sectors_per_track);static EDD_DEVICE_ATTR(interface, 0444, edd_show_interface, edd_has_edd30);static EDD_DEVICE_ATTR(host_bus, 0444, edd_show_host_bus, edd_has_edd30);static EDD_DEVICE_ATTR(mbr_signature, 0444, edd_show_mbr_signature, edd_has_mbr_signature);
/* These attributes are conditional and only added for some devices. */static struct edd_attribute * edd_attrs[] = { &edd_attr_raw_data, &edd_attr_version, &edd_attr_extensions, &edd_attr_info_flags, &edd_attr_sectors, &edd_attr_legacy_max_cylinder, &edd_attr_legacy_max_head, &edd_attr_legacy_sectors_per_track, &edd_attr_default_cylinders, &edd_attr_default_heads, &edd_attr_default_sectors_per_track, &edd_attr_interface, &edd_attr_host_bus, &edd_attr_mbr_signature, NULL,};
/** * edd_release - free edd structure * @kobj: kobject of edd structure * * This is called when the refcount of the edd structure * reaches 0. This should happen right after we unregister, * but just in case, we use the release callback anyway. */
static void edd_release(struct kobject * kobj){ struct edd_device * dev = to_edd_device(kobj); kfree(dev);}
static const struct kobj_type edd_ktype = { .release = edd_release, .sysfs_ops = &edd_attr_ops,};
static struct kset *edd_kset;
/** * edd_dev_is_type() - is this EDD device a 'type' device? * @edev: target edd_device * @type: a host bus or interface identifier string per the EDD spec * * Returns 1 (TRUE) if it is a 'type' device, 0 otherwise. */static intedd_dev_is_type(struct edd_device *edev, const char *type){ struct edd_info *info; if (!edev) return 0; info = edd_dev_get_info(edev);
if (type && info) { if (!strncmp(info->params.host_bus_type, type, strlen(type)) || !strncmp(info->params.interface_type, type, strlen(type))) return 1; } return 0;}
/** * edd_get_pci_dev() - finds pci_dev that matches edev * @edev: edd_device * * Returns pci_dev if found, or NULL */static struct pci_dev *edd_get_pci_dev(struct edd_device *edev){ struct edd_info *info = edd_dev_get_info(edev);
if (edd_dev_is_type(edev, "PCI") || edd_dev_is_type(edev, "XPRS")) { return pci_get_domain_bus_and_slot(0, info->params.interface_path.pci.bus, PCI_DEVFN(info->params.interface_path.pci.slot, info->params.interface_path.pci.function)); } return NULL;}
static intedd_create_symlink_to_pcidev(struct edd_device *edev){
struct pci_dev *pci_dev = edd_get_pci_dev(edev); int ret; if (!pci_dev) return 1; ret = sysfs_create_link(&edev->kobj,&pci_dev->dev.kobj,"pci_dev"); pci_dev_put(pci_dev); return ret;}
static inline voidedd_device_unregister(struct edd_device *edev){ kobject_put(&edev->kobj);}
static void edd_populate_dir(struct edd_device * edev){ struct edd_attribute * attr; int error = 0; int i;
for (i = 0; (attr = edd_attrs[i]) && !error; i++) { if (!attr->test || attr->test(edev)) error = sysfs_create_file(&edev->kobj,&attr->attr); }
if (!error) { edd_create_symlink_to_pcidev(edev); }}
static intedd_device_register(struct edd_device *edev, int i){ int error;
if (!edev) return 1; edd_dev_set_info(edev, i); edev->kobj.kset = edd_kset; error = kobject_init_and_add(&edev->kobj, &edd_ktype, NULL, "int13_dev%02x", 0x80 + i); if (!error) { edd_populate_dir(edev); kobject_uevent(&edev->kobj, KOBJ_ADD); } return error;}
static inline int edd_num_devices(void){ return max_t(unsigned char, min_t(unsigned char, EDD_MBR_SIG_MAX, edd.mbr_signature_nr), min_t(unsigned char, EDDMAXNR, edd.edd_info_nr));}
/** * edd_init() - creates sysfs tree of EDD data */static int __initedd_init(void){ int i; int rc=0; struct edd_device *edev;
if (!edd_num_devices()) return -ENODEV;
printk(KERN_INFO "BIOS EDD facility v%s %s, %d devices found\n", EDD_VERSION, EDD_DATE, edd_num_devices());
edd_kset = kset_create_and_add("edd", NULL, firmware_kobj); if (!edd_kset) return -ENOMEM;
for (i = 0; i < edd_num_devices(); i++) { edev = kzalloc_obj(*edev); if (!edev) { rc = -ENOMEM; goto out; }
rc = edd_device_register(edev, i); if (rc) { kfree(edev); goto out; } edd_devices[i] = edev; }
return 0;
out: while (--i >= 0) edd_device_unregister(edd_devices[i]); kset_unregister(edd_kset); return rc;}
static void __exitedd_exit(void){ int i; struct edd_device *edev;
for (i = 0; i < edd_num_devices(); i++) { if ((edev = edd_devices[i])) edd_device_unregister(edev); } kset_unregister(edd_kset);}
late_initcall(edd_init);module_exit(edd_exit);