May 20, 2014 The compiler is seeing struct radios614L8 as an incomplete type. This means it doesn't know what's inside the struct. Whatever you did to provide it is not working. Dereferencing pointer to incomplete type so i need to create a function that creates a 2 dimensional field of pointers to a structure called a 'cell'. This is the code for the structure, nothing too hard here.
*/
#include <linux/module.h> #include <linux/slab.h> #include <linux/delay.h> #include <linux/io.h> #include <linux/init.h> #include <linux/err.h> #include <linux/clk.h> #include <linux/interrupt.h> #include <linux/platform_device.h> #include <linux/hwmon.h> #include <linux/hwmon-sysfs.h> #include <plat/adc.h> // #include <linux/platform_data/hwmon-s3c.h> #include <plat/hwmon.h> /* added by naresh */ #include <linux/device.h> #include <linux/fs.h> #include <linux/sched.h> #include <linux/fs_struct.h> struct s3c24xx_adc_hwmon_incfg *cfg; struct s3c_hwmon_attr { struct sensor_device_attribute in; struct sensor_device_attribute label; char in_name[12]; char label_name[12]; }; /** * struct s3c_hwmon - ADC hwmon client information * @lock: Access lock to serialise the conversions. * @client: The client we registered with the S3C ADC core. * @hwmon_dev: The hwmon device we created. * @attr: The holders for the channel attributes. */ struct s3c_hwmon { struct semaphore lock; struct s3c_adc_client *client; struct device *hwmon_dev; struct s3c_hwmon_attr attrs[8]; }; /** * s3c_hwmon_read_ch - read a value from a given adc channel. * @dev: The device. * @hwmon: Our state. * @channel: The channel we're reading from. * * Read a value from the @channel with the proper locking and sleep until * either the read completes or we timeout awaiting the ADC core to get * back to us. */ static int s3c_hwmon_read_ch(struct device *dev, struct s3c_hwmon *hwmon, int channel) { int ret; ret = down_interruptible(&hwmon->lock); if (ret < 0) return ret; dev_dbg(dev, 'reading channel %dn', channel); ret = s3c_adc_read(hwmon->client, channel); up(&hwmon->lock); return ret; } #ifdef CONFIG_SENSORS_S3C_RAW /** * s3c_hwmon_show_raw - show a conversion from the raw channel number. * @dev: The device that the attribute belongs to. * @attr: The attribute being read. * @buf: The result buffer. * * This show deals with the raw attribute, registered for each possible * ADC channel. This does a conversion and returns the raw (un-scaled) * value returned from the hardware. */ static ssize_t s3c_hwmon_show_raw(struct device *dev, struct device_attribute *attr, char *buf) { struct s3c_hwmon *adc = platform_get_drvdata(to_platform_device(dev)); struct sensor_device_attribute *sa = to_sensor_dev_attr(attr); int ret; ret = s3c_hwmon_read_ch(dev, adc, sa->index); return (ret < 0) ? ret : snprintf(buf, PAGE_SIZE, '%dn', ret); } #define DEF_ADC_ATTR(x) static SENSOR_DEVICE_ATTR(adc##x##_raw, S_IRUGO, s3c_hwmon_show_raw, NULL, x) DEF_ADC_ATTR(0); DEF_ADC_ATTR(1); DEF_ADC_ATTR(2); DEF_ADC_ATTR(3); DEF_ADC_ATTR(4); DEF_ADC_ATTR(5); DEF_ADC_ATTR(6); DEF_ADC_ATTR(7); static struct attribute *s3c_hwmon_attrs[9] = { &sensor_dev_attr_adc0_raw.dev_attr.attr, &sensor_dev_attr_adc1_raw.dev_attr.attr, &sensor_dev_attr_adc2_raw.dev_attr.attr, &sensor_dev_attr_adc3_raw.dev_attr.attr, &sensor_dev_attr_adc4_raw.dev_attr.attr, &sensor_dev_attr_adc5_raw.dev_attr.attr, &sensor_dev_attr_adc6_raw.dev_attr.attr, &sensor_dev_attr_adc7_raw.dev_attr.attr, NULL, }; static struct attribute_group s3c_hwmon_attrgroup = { .attrs = s3c_hwmon_attrs, }; static inline int s3c_hwmon_add_raw(struct device *dev) { return sysfs_create_group(&dev->kobj, &s3c_hwmon_attrgroup); } static inline void s3c_hwmon_remove_raw(struct device *dev) { sysfs_remove_group(&dev->kobj, &s3c_hwmon_attrgroup); } #else static inline int s3c_hwmon_add_raw(struct device *dev) { return 0; } static inline void s3c_hwmon_remove_raw(struct device *dev) { } #endif /* CONFIG_SENSORS_S3C_RAW */ /** * s3c_hwmon_ch_show - show value of a given channel * @dev: The device that the attribute belongs to. * @attr: The attribute being read. * @buf: The result buffer. * * Read a value from the ADC and scale it before returning it to the * caller. The scale factor is gained from the channel configuration * passed via the platform data when the device was registered. */ static ssize_t s3c_hwmon_ch_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr); struct s3c_hwmon *hwmon = platform_get_drvdata(to_platform_device(dev)); struct s3c_hwmon_pdata *pdata = dev->platform_data; struct s3c_hwmon_chcfg *cfg; int ret; cfg = pdata->in[sen_attr->index]; ret = s3c_hwmon_read_ch(dev, hwmon, sen_attr->index); if (ret < 0) return ret; ret *= cfg->mult; ret = DIV_ROUND_CLOSEST(ret, cfg->div); return snprintf(buf, PAGE_SIZE, '%dn', ret); } /** * s3c_hwmon_label_show - show label name of the given channel. * @dev: The device that the attribute belongs to. * @attr: The attribute being read. * @buf: The result buffer. * * Return the label name of a given channel */ static ssize_t s3c_hwmon_label_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute *sen_attr = to_sensor_dev_attr(attr); struct s3c_hwmon_pdata *pdata = dev->platform_data; struct s3c_hwmon_chcfg *cfg; cfg = pdata->in[sen_attr->index]; return snprintf(buf, PAGE_SIZE, '%sn', cfg->name); } /** * s3c_hwmon_create_attr - create hwmon attribute for given channel. * @dev: The device to create the attribute on. * @cfg: The channel configuration passed from the platform data. * @channel: The ADC channel number to process. * * Create the scaled attribute for use with hwmon from the specified * platform data in @pdata. The sysfs entry is handled by the routine * s3c_hwmon_ch_show(). * * The attribute name is taken from the configuration data if present * otherwise the name is taken by concatenating in_ with the channel * number. */ static int s3c_hwmon_create_attr(struct device *dev, struct s3c_hwmon_chcfg *cfg, struct s3c_hwmon_attr *attrs, int channel) { struct sensor_device_attribute *attr; int ret; snprintf(attrs->in_name, sizeof(attrs->in_name), 'in%d_input', channel); attr = &attrs->in; attr->index = channel; attr->dev_attr.attr.name = attrs->in_name; attr->dev_attr.attr.mode = S_IRUGO; attr->dev_attr.attr.owner = THIS_MODULE; attr->dev_attr.show = s3c_hwmon_ch_show; ret = device_create_file(dev, &attr->dev_attr); if (ret < 0) { dev_err(dev, 'failed to create input attributen'); return ret; } /* if this has a name, add a label */ if (cfg->name) { snprintf(attrs->label_name, sizeof(attrs->label_name), 'in%d_label', channel); attr = &attrs->label; attr->index = channel; attr->dev_attr.attr.name = attrs->label_name; attr->dev_attr.attr.mode = S_IRUGO; attr->dev_attr.attr.owner = THIS_MODULE; attr->dev_attr.show = s3c_hwmon_label_show; ret = device_create_file(dev, &attr->dev_attr); if (ret < 0) { device_remove_file(dev, &attrs->in.dev_attr); dev_err(dev, 'failed to create label attributen'); } } return ret; } static void s3c_hwmon_remove_attr(struct device *dev, struct s3c_hwmon_attr *attrs) { device_remove_file(dev, &attrs->in.dev_attr); device_remove_file(dev, &attrs->label.dev_attr); } /** * s3c_hwmon_probe - device probe entry. * @dev: The device being probed. */ static int __devinit s3c_hwmon_probe(struct platform_device *dev) { struct s3c_hwmon_pdata *pdata = dev->dev.platform_data; struct s3c_hwmon *hwmon; int ret = 0; int i; if (!pdata) { dev_err(&dev->dev, 'no platform data suppliedn'); return -EINVAL; } hwmon = kzalloc(sizeof(struct s3c_hwmon), GFP_KERNEL); if (hwmon NULL) { dev_err(&dev->dev, 'no memoryn'); return -ENOMEM; } platform_set_drvdata(dev, hwmon); init_MUTEX(&hwmon->lock); /* Register with the core ADC driver. */ hwmon->client = s3c_adc_register(dev, NULL, NULL, 0); if (IS_ERR(hwmon->client)) { dev_err(&dev->dev, 'cannot register adcn'); ret = PTR_ERR(hwmon->client); goto err_mem; } /* add attributes for our adc devices. */ ret = s3c_hwmon_add_raw(&dev->dev); if (ret) goto err_registered; /* register with the hwmon core */ hwmon->hwmon_dev = hwmon_device_register(&dev->dev); if (IS_ERR(hwmon->hwmon_dev)) { dev_err(&dev->dev, 'error registering with hwmonn'); ret = PTR_ERR(hwmon->hwmon_dev); goto err_raw_attribute; } for (i = 0; i < ARRAY_SIZE(pdata->in); i++) { struct s3c24xx_adc_hwmon_incfg *cfg = pdata->in[i]; if (!cfg) continue; if (cfg->mult >= 0x10000) dev_warn(&dev->dev, 'channel %d multiplier too largen', i); if (cfg->divider 0) { dev_err(&dev->dev, 'channel %d divider zeron', i); continue; } ret = s3c_hwmon_create_attr(&dev->dev, pdata->in[i], &hwmon->attrs[i], i); if (ret) { dev_err(&dev->dev, 'error creating channel %dn', i); for (i--; i >= 0; i--) s3c_hwmon_remove_attr(&dev->dev,&hwmon->attrs[i]); goto err_hwmon_register; } } return 0; err_hwmon_register: hwmon_device_unregister(hwmon->hwmon_dev); err_raw_attribute: s3c_hwmon_remove_raw(&dev->dev); err_registered: s3c_adc_release(hwmon->client); err_mem: kfree(hwmon); return ret; } static int __devexit s3c_hwmon_remove(struct platform_device *dev) { struct s3c_hwmon *hwmon = platform_get_drvdata(dev); int i; s3c_hwmon_remove_raw(&dev->dev); for (i = 0; i < ARRAY_SIZE(hwmon->attrs); i++) s3c_hwmon_remove_attr(&dev->dev, &hwmon->attrs[i]); hwmon_device_unregister(hwmon->hwmon_dev); s3c_adc_release(hwmon->client); return 0; } static struct platform_driver s3c_hwmon_driver = { .driver = { .name = 's3c-hwmon', .owner = THIS_MODULE, }, .probe = s3c_hwmon_probe, .remove = __devexit_p(s3c_hwmon_remove), }; static int __init s3c_hwmon_init(void) { return platform_driver_register(&s3c_hwmon_driver); } static void __exit s3c_hwmon_exit(void) { platform_driver_unregister(&s3c_hwmon_driver); } module_init(s3c_hwmon_init); module_exit(s3c_hwmon_exit); MODULE_AUTHOR('Ben Dooks <[email protected]>'); MODULE_DESCRIPTION('S3C ADC HWMon driver'); MODULE_LICENSE('GPL v2'); MODULE_ALIAS('platform:s3c-hwmon'); i am getting error drivers/hwmon/s3c-hwmon.c: In function 's3c_hwmon_probe': drivers/hwmon/s3c-hwmon.c:326: warning: initialization from incompatible pointer type drivers/hwmon/s3c-hwmon.c:331: error: dereferencing pointer to incomplete type drivers/hwmon/s3c-hwmon.c:336: error: dereferencing pointer to incomplete type I am trying to get information from Tree field I made, and I am getting the error in the title: dereferencing pointer to incomplete type 'struct List_t' Tree Source File: Tree Header File: App Source file: what should I do? what am I doing wrong? thanks!
MaorE
MaorEMaorE
2 AnswersThe declaration of
William PursellWilliam Pursell
You have provided three pieces of code, and identified them as:
Let's call these files When you are compiling inside it. That is how the compiler knows to go and look inside another file for a definition. If your In particular, if you have provided information inside The solution is (as others have said) to move your Alternatively, if you wish for the members of the structure to be private, you can provide a function that returns the data. Of course, the declaration of that function will be part of the public interface so it will have to be in the
aghastaghast
Not the answer you're looking for? Browse other questions tagged cpointersdereference or ask your own question.
0 Comments
Leave a Reply. |