mirror of
https://github.com/adulau/aha.git
synced 2024-12-27 19:26:25 +00:00
firmware: remove broken example files
The firmware example files are beyond broken, and will not work, and should not be used as an example at all. So lets remove them and hope someone writes new files sometime in the future. Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Greg Kroah-Hartman
parent
5e8e9245f9
commit
d12b77afb4
2 changed files with 0 additions and 325 deletions
|
|
@ -1,121 +0,0 @@
|
|||
/*
|
||||
* firmware_sample_driver.c -
|
||||
*
|
||||
* Copyright (c) 2003 Manuel Estrada Sainz
|
||||
*
|
||||
* Sample code on how to use request_firmware() from drivers.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/firmware.h>
|
||||
|
||||
static struct device ghost_device = {
|
||||
.bus_id = "ghost0",
|
||||
};
|
||||
|
||||
|
||||
static void sample_firmware_load(char *firmware, int size)
|
||||
{
|
||||
u8 buf[size+1];
|
||||
memcpy(buf, firmware, size);
|
||||
buf[size] = '\0';
|
||||
printk(KERN_INFO "firmware_sample_driver: firmware: %s\n", buf);
|
||||
}
|
||||
|
||||
static void sample_probe_default(void)
|
||||
{
|
||||
/* uses the default method to get the firmware */
|
||||
const struct firmware *fw_entry;
|
||||
int retval;
|
||||
|
||||
printk(KERN_INFO "firmware_sample_driver: "
|
||||
"a ghost device got inserted :)\n");
|
||||
|
||||
retval = request_firmware(&fw_entry, "sample_driver_fw", &ghost_device);
|
||||
if (retval) {
|
||||
printk(KERN_ERR
|
||||
"firmware_sample_driver: Firmware not available\n");
|
||||
return;
|
||||
}
|
||||
|
||||
sample_firmware_load(fw_entry->data, fw_entry->size);
|
||||
|
||||
release_firmware(fw_entry);
|
||||
|
||||
/* finish setting up the device */
|
||||
}
|
||||
|
||||
static void sample_probe_specific(void)
|
||||
{
|
||||
int retval;
|
||||
/* Uses some specific hotplug support to get the firmware from
|
||||
* userspace directly into the hardware, or via some sysfs file */
|
||||
|
||||
/* NOTE: This currently doesn't work */
|
||||
|
||||
printk(KERN_INFO "firmware_sample_driver: "
|
||||
"a ghost device got inserted :)\n");
|
||||
|
||||
retval = request_firmware(NULL, "sample_driver_fw", &ghost_device);
|
||||
if (retval) {
|
||||
printk(KERN_ERR
|
||||
"firmware_sample_driver: Firmware load failed\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* request_firmware blocks until userspace finished, so at
|
||||
* this point the firmware should be already in the device */
|
||||
|
||||
/* finish setting up the device */
|
||||
}
|
||||
|
||||
static void sample_probe_async_cont(const struct firmware *fw, void *context)
|
||||
{
|
||||
if (!fw) {
|
||||
printk(KERN_ERR
|
||||
"firmware_sample_driver: firmware load failed\n");
|
||||
return;
|
||||
}
|
||||
|
||||
printk(KERN_INFO "firmware_sample_driver: device pointer \"%s\"\n",
|
||||
(char *)context);
|
||||
sample_firmware_load(fw->data, fw->size);
|
||||
}
|
||||
|
||||
static void sample_probe_async(void)
|
||||
{
|
||||
/* Let's say that I can't sleep */
|
||||
int error;
|
||||
error = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOHOTPLUG,
|
||||
"sample_driver_fw", &ghost_device,
|
||||
"my device pointer",
|
||||
sample_probe_async_cont);
|
||||
if (error)
|
||||
printk(KERN_ERR "firmware_sample_driver:"
|
||||
" request_firmware_nowait failed\n");
|
||||
}
|
||||
|
||||
static int __init sample_init(void)
|
||||
{
|
||||
device_initialize(&ghost_device);
|
||||
/* since there is no real hardware insertion I just call the
|
||||
* sample probe functions here */
|
||||
sample_probe_specific();
|
||||
sample_probe_default();
|
||||
sample_probe_async();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit sample_exit(void)
|
||||
{
|
||||
}
|
||||
|
||||
module_init(sample_init);
|
||||
module_exit(sample_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
@ -1,204 +0,0 @@
|
|||
/*
|
||||
* firmware_sample_firmware_class.c -
|
||||
*
|
||||
* Copyright (c) 2003 Manuel Estrada Sainz
|
||||
*
|
||||
* NOTE: This is just a probe of concept, if you think that your driver would
|
||||
* be well served by this mechanism please contact me first.
|
||||
*
|
||||
* DON'T USE THIS CODE AS IS
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/timer.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/firmware.h>
|
||||
|
||||
|
||||
MODULE_AUTHOR("Manuel Estrada Sainz");
|
||||
MODULE_DESCRIPTION("Hackish sample for using firmware class directly");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
static inline struct class_device *to_class_dev(struct kobject *obj)
|
||||
{
|
||||
return container_of(obj, struct class_device, kobj);
|
||||
}
|
||||
|
||||
static inline
|
||||
struct class_device_attribute *to_class_dev_attr(struct attribute *_attr)
|
||||
{
|
||||
return container_of(_attr, struct class_device_attribute, attr);
|
||||
}
|
||||
|
||||
struct firmware_priv {
|
||||
char fw_id[FIRMWARE_NAME_MAX];
|
||||
s32 loading:2;
|
||||
u32 abort:1;
|
||||
};
|
||||
|
||||
static ssize_t firmware_loading_show(struct class_device *class_dev, char *buf)
|
||||
{
|
||||
struct firmware_priv *fw_priv = class_get_devdata(class_dev);
|
||||
return sprintf(buf, "%d\n", fw_priv->loading);
|
||||
}
|
||||
|
||||
static ssize_t firmware_loading_store(struct class_device *class_dev,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
struct firmware_priv *fw_priv = class_get_devdata(class_dev);
|
||||
int prev_loading = fw_priv->loading;
|
||||
|
||||
fw_priv->loading = simple_strtol(buf, NULL, 10);
|
||||
|
||||
switch (fw_priv->loading) {
|
||||
case -1:
|
||||
/* abort load an panic */
|
||||
break;
|
||||
case 1:
|
||||
/* setup load */
|
||||
break;
|
||||
case 0:
|
||||
if (prev_loading == 1) {
|
||||
/* finish load and get the device back to working
|
||||
* state */
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
static CLASS_DEVICE_ATTR(loading, 0644,
|
||||
firmware_loading_show, firmware_loading_store);
|
||||
|
||||
static ssize_t firmware_data_read(struct kobject *kobj,
|
||||
struct bin_attribute *bin_attr,
|
||||
char *buffer, loff_t offset, size_t count)
|
||||
{
|
||||
struct class_device *class_dev = to_class_dev(kobj);
|
||||
struct firmware_priv *fw_priv = class_get_devdata(class_dev);
|
||||
|
||||
/* read from the devices firmware memory */
|
||||
|
||||
return count;
|
||||
}
|
||||
static ssize_t firmware_data_write(struct kobject *kobj,
|
||||
struct bin_attribute *bin_attr,
|
||||
char *buffer, loff_t offset, size_t count)
|
||||
{
|
||||
struct class_device *class_dev = to_class_dev(kobj);
|
||||
struct firmware_priv *fw_priv = class_get_devdata(class_dev);
|
||||
|
||||
/* write to the devices firmware memory */
|
||||
|
||||
return count;
|
||||
}
|
||||
static struct bin_attribute firmware_attr_data = {
|
||||
.attr = {.name = "data", .mode = 0644},
|
||||
.size = 0,
|
||||
.read = firmware_data_read,
|
||||
.write = firmware_data_write,
|
||||
};
|
||||
static int fw_setup_class_device(struct class_device *class_dev,
|
||||
const char *fw_name,
|
||||
struct device *device)
|
||||
{
|
||||
int retval;
|
||||
struct firmware_priv *fw_priv;
|
||||
|
||||
fw_priv = kzalloc(sizeof(struct firmware_priv), GFP_KERNEL);
|
||||
if (!fw_priv) {
|
||||
retval = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
memset(class_dev, 0, sizeof(*class_dev));
|
||||
|
||||
strncpy(fw_priv->fw_id, fw_name, FIRMWARE_NAME_MAX);
|
||||
fw_priv->fw_id[FIRMWARE_NAME_MAX-1] = '\0';
|
||||
|
||||
strncpy(class_dev->class_id, device->bus_id, BUS_ID_SIZE);
|
||||
class_dev->class_id[BUS_ID_SIZE-1] = '\0';
|
||||
class_dev->dev = device;
|
||||
|
||||
class_dev->class = &firmware_class;
|
||||
class_set_devdata(class_dev, fw_priv);
|
||||
retval = class_device_register(class_dev);
|
||||
if (retval) {
|
||||
printk(KERN_ERR "%s: class_device_register failed\n",
|
||||
__func__);
|
||||
goto error_free_fw_priv;
|
||||
}
|
||||
|
||||
retval = sysfs_create_bin_file(&class_dev->kobj, &firmware_attr_data);
|
||||
if (retval) {
|
||||
printk(KERN_ERR "%s: sysfs_create_bin_file failed\n",
|
||||
__func__);
|
||||
goto error_unreg_class_dev;
|
||||
}
|
||||
|
||||
retval = class_device_create_file(class_dev,
|
||||
&class_device_attr_loading);
|
||||
if (retval) {
|
||||
printk(KERN_ERR "%s: class_device_create_file failed\n",
|
||||
__func__);
|
||||
goto error_remove_data;
|
||||
}
|
||||
|
||||
goto out;
|
||||
|
||||
error_remove_data:
|
||||
sysfs_remove_bin_file(&class_dev->kobj, &firmware_attr_data);
|
||||
error_unreg_class_dev:
|
||||
class_device_unregister(class_dev);
|
||||
error_free_fw_priv:
|
||||
kfree(fw_priv);
|
||||
out:
|
||||
return retval;
|
||||
}
|
||||
static void fw_remove_class_device(struct class_device *class_dev)
|
||||
{
|
||||
struct firmware_priv *fw_priv = class_get_devdata(class_dev);
|
||||
|
||||
class_device_remove_file(class_dev, &class_device_attr_loading);
|
||||
sysfs_remove_bin_file(&class_dev->kobj, &firmware_attr_data);
|
||||
class_device_unregister(class_dev);
|
||||
}
|
||||
|
||||
static struct class_device *class_dev;
|
||||
|
||||
static struct device my_device = {
|
||||
.bus_id = "my_dev0",
|
||||
};
|
||||
|
||||
static int __init firmware_sample_init(void)
|
||||
{
|
||||
int error;
|
||||
|
||||
device_initialize(&my_device);
|
||||
class_dev = kmalloc(sizeof(struct class_device), GFP_KERNEL);
|
||||
if (!class_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
error = fw_setup_class_device(class_dev, "my_firmware_image",
|
||||
&my_device);
|
||||
if (error) {
|
||||
kfree(class_dev);
|
||||
return error;
|
||||
}
|
||||
return 0;
|
||||
|
||||
}
|
||||
static void __exit firmware_sample_exit(void)
|
||||
{
|
||||
struct firmware_priv *fw_priv = class_get_devdata(class_dev);
|
||||
fw_remove_class_device(class_dev);
|
||||
kfree(fw_priv);
|
||||
kfree(class_dev);
|
||||
}
|
||||
|
||||
module_init(firmware_sample_init);
|
||||
module_exit(firmware_sample_exit);
|
||||
Loading…
Reference in a new issue