Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[linux-2.6] / drivers / hwmon / sht15.c
1 /*
2  * sht15.c - support for the SHT15 Temperature and Humidity Sensor
3  *
4  * Copyright (c) 2009 Jonathan Cameron
5  *
6  * Copyright (c) 2007 Wouter Horre
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * Currently ignoring checksum on readings.
13  * Default resolution only (14bit temp, 12bit humidity)
14  * Ignoring battery status.
15  * Heater not enabled.
16  * Timings are all conservative.
17  *
18  * Data sheet available (1/2009) at
19  * http://www.sensirion.ch/en/pdf/product_information/Datasheet-humidity-sensor-SHT1x.pdf
20  *
21  * Regulator supply name = vcc
22  */
23
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/gpio.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/mutex.h>
32 #include <linux/platform_device.h>
33 #include <linux/delay.h>
34 #include <linux/jiffies.h>
35 #include <linux/err.h>
36 #include <linux/sht15.h>
37 #include <linux/regulator/consumer.h>
38 #include <asm/atomic.h>
39
40 #define SHT15_MEASURE_TEMP      3
41 #define SHT15_MEASURE_RH        5
42
43 #define SHT15_READING_NOTHING   0
44 #define SHT15_READING_TEMP      1
45 #define SHT15_READING_HUMID     2
46
47 /* Min timings in nsecs */
48 #define SHT15_TSCKL             100     /* clock low */
49 #define SHT15_TSCKH             100     /* clock high */
50 #define SHT15_TSU               150     /* data setup time */
51
52 /**
53  * struct sht15_temppair - elements of voltage dependant temp calc
54  * @vdd:        supply voltage in microvolts
55  * @d1:         see data sheet
56  */
57 struct sht15_temppair {
58         int vdd; /* microvolts */
59         int d1;
60 };
61
62 /* Table 9 from data sheet - relates temperature calculation
63  * to supply voltage.
64  */
65 static const struct sht15_temppair temppoints[] = {
66         { 2500000, -39400 },
67         { 3000000, -39600 },
68         { 3500000, -39700 },
69         { 4000000, -39800 },
70         { 5000000, -40100 },
71 };
72
73 /**
74  * struct sht15_data - device instance specific data
75  * @pdata:      platform data (gpio's etc)
76  * @read_work:  bh of interrupt handler
77  * @wait_queue: wait queue for getting values from device
78  * @val_temp:   last temperature value read from device
79  * @val_humid:  last humidity value read from device
80  * @flag:       status flag used to identify what the last request was
81  * @valid:      are the current stored values valid (start condition)
82  * @last_updat: time of last update
83  * @read_lock:  mutex to ensure only one read in progress
84  *              at a time.
85  * @dev:        associate device structure
86  * @hwmon_dev:  device associated with hwmon subsystem
87  * @reg:        associated regulator (if specified)
88  * @nb:         notifier block to handle notifications of voltage changes
89  * @supply_uV:  local copy of supply voltage used to allow
90  *              use of regulator consumer if available
91  * @supply_uV_valid:   indicates that an updated value has not yet
92  *              been obtained from the regulator and so any calculations
93  *              based upon it will be invalid.
94  * @update_supply_work: work struct that is used to update the supply_uV
95  * @interrupt_handled:  flag used to indicate a hander has been scheduled
96  */
97 struct sht15_data {
98         struct sht15_platform_data      *pdata;
99         struct work_struct              read_work;
100         wait_queue_head_t               wait_queue;
101         uint16_t                        val_temp;
102         uint16_t                        val_humid;
103         u8                              flag;
104         u8                              valid;
105         unsigned long                   last_updat;
106         struct mutex                    read_lock;
107         struct device                   *dev;
108         struct device                   *hwmon_dev;
109         struct regulator                *reg;
110         struct notifier_block           nb;
111         int                             supply_uV;
112         int                             supply_uV_valid;
113         struct work_struct              update_supply_work;
114         atomic_t                        interrupt_handled;
115 };
116
117 /**
118  * sht15_connection_reset() - reset the comms interface
119  * @data:       sht15 specific data
120  *
121  * This implements section 3.4 of the data sheet
122  */
123 static void sht15_connection_reset(struct sht15_data *data)
124 {
125         int i;
126         gpio_direction_output(data->pdata->gpio_data, 1);
127         ndelay(SHT15_TSCKL);
128         gpio_set_value(data->pdata->gpio_sck, 0);
129         ndelay(SHT15_TSCKL);
130         for (i = 0; i < 9; ++i) {
131                 gpio_set_value(data->pdata->gpio_sck, 1);
132                 ndelay(SHT15_TSCKH);
133                 gpio_set_value(data->pdata->gpio_sck, 0);
134                 ndelay(SHT15_TSCKL);
135         }
136 }
137 /**
138  * sht15_send_bit() - send an individual bit to the device
139  * @data:       device state data
140  * @val:        value of bit to be sent
141  **/
142 static inline void sht15_send_bit(struct sht15_data *data, int val)
143 {
144
145         gpio_set_value(data->pdata->gpio_data, val);
146         ndelay(SHT15_TSU);
147         gpio_set_value(data->pdata->gpio_sck, 1);
148         ndelay(SHT15_TSCKH);
149         gpio_set_value(data->pdata->gpio_sck, 0);
150         ndelay(SHT15_TSCKL); /* clock low time */
151 }
152
153 /**
154  * sht15_transmission_start() - specific sequence for new transmission
155  *
156  * @data:       device state data
157  * Timings for this are not documented on the data sheet, so very
158  * conservative ones used in implementation. This implements
159  * figure 12 on the data sheet.
160  **/
161 static void sht15_transmission_start(struct sht15_data *data)
162 {
163         /* ensure data is high and output */
164         gpio_direction_output(data->pdata->gpio_data, 1);
165         ndelay(SHT15_TSU);
166         gpio_set_value(data->pdata->gpio_sck, 0);
167         ndelay(SHT15_TSCKL);
168         gpio_set_value(data->pdata->gpio_sck, 1);
169         ndelay(SHT15_TSCKH);
170         gpio_set_value(data->pdata->gpio_data, 0);
171         ndelay(SHT15_TSU);
172         gpio_set_value(data->pdata->gpio_sck, 0);
173         ndelay(SHT15_TSCKL);
174         gpio_set_value(data->pdata->gpio_sck, 1);
175         ndelay(SHT15_TSCKH);
176         gpio_set_value(data->pdata->gpio_data, 1);
177         ndelay(SHT15_TSU);
178         gpio_set_value(data->pdata->gpio_sck, 0);
179         ndelay(SHT15_TSCKL);
180 }
181 /**
182  * sht15_send_byte() - send a single byte to the device
183  * @data:       device state
184  * @byte:       value to be sent
185  **/
186 static void sht15_send_byte(struct sht15_data *data, u8 byte)
187 {
188         int i;
189         for (i = 0; i < 8; i++) {
190                 sht15_send_bit(data, !!(byte & 0x80));
191                 byte <<= 1;
192         }
193 }
194 /**
195  * sht15_wait_for_response() - checks for ack from device
196  * @data:       device state
197  **/
198 static int sht15_wait_for_response(struct sht15_data *data)
199 {
200         gpio_direction_input(data->pdata->gpio_data);
201         gpio_set_value(data->pdata->gpio_sck, 1);
202         ndelay(SHT15_TSCKH);
203         if (gpio_get_value(data->pdata->gpio_data)) {
204                 gpio_set_value(data->pdata->gpio_sck, 0);
205                 dev_err(data->dev, "Command not acknowledged\n");
206                 sht15_connection_reset(data);
207                 return -EIO;
208         }
209         gpio_set_value(data->pdata->gpio_sck, 0);
210         ndelay(SHT15_TSCKL);
211         return 0;
212 }
213
214 /**
215  * sht15_send_cmd() - Sends a command to the device.
216  * @data:       device state
217  * @cmd:        command byte to be sent
218  *
219  * On entry, sck is output low, data is output pull high
220  * and the interrupt disabled.
221  **/
222 static int sht15_send_cmd(struct sht15_data *data, u8 cmd)
223 {
224         int ret = 0;
225         sht15_transmission_start(data);
226         sht15_send_byte(data, cmd);
227         ret = sht15_wait_for_response(data);
228         return ret;
229 }
230 /**
231  * sht15_update_single_val() - get a new value from device
232  * @data:               device instance specific data
233  * @command:            command sent to request value
234  * @timeout_msecs:      timeout after which comms are assumed
235  *                      to have failed are reset.
236  **/
237 static inline int sht15_update_single_val(struct sht15_data *data,
238                                           int command,
239                                           int timeout_msecs)
240 {
241         int ret;
242         ret = sht15_send_cmd(data, command);
243         if (ret)
244                 return ret;
245
246         gpio_direction_input(data->pdata->gpio_data);
247         atomic_set(&data->interrupt_handled, 0);
248
249         enable_irq(gpio_to_irq(data->pdata->gpio_data));
250         if (gpio_get_value(data->pdata->gpio_data) == 0) {
251                 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));
252                 /* Only relevant if the interrupt hasn't occured. */
253                 if (!atomic_read(&data->interrupt_handled))
254                         schedule_work(&data->read_work);
255         }
256         ret = wait_event_timeout(data->wait_queue,
257                                  (data->flag == SHT15_READING_NOTHING),
258                                  msecs_to_jiffies(timeout_msecs));
259         if (ret == 0) {/* timeout occurred */
260                 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));;
261                 sht15_connection_reset(data);
262                 return -ETIME;
263         }
264         return 0;
265 }
266
267 /**
268  * sht15_update_vals() - get updated readings from device if too old
269  * @data:       device state
270  **/
271 static int sht15_update_vals(struct sht15_data *data)
272 {
273         int ret = 0;
274         int timeout = HZ;
275
276         mutex_lock(&data->read_lock);
277         if (time_after(jiffies, data->last_updat + timeout)
278             || !data->valid) {
279                 data->flag = SHT15_READING_HUMID;
280                 ret = sht15_update_single_val(data, SHT15_MEASURE_RH, 160);
281                 if (ret)
282                         goto error_ret;
283                 data->flag = SHT15_READING_TEMP;
284                 ret = sht15_update_single_val(data, SHT15_MEASURE_TEMP, 400);
285                 if (ret)
286                         goto error_ret;
287                 data->valid = 1;
288                 data->last_updat = jiffies;
289         }
290 error_ret:
291         mutex_unlock(&data->read_lock);
292
293         return ret;
294 }
295
296 /**
297  * sht15_calc_temp() - convert the raw reading to a temperature
298  * @data:       device state
299  *
300  * As per section 4.3 of the data sheet.
301  **/
302 static inline int sht15_calc_temp(struct sht15_data *data)
303 {
304         int d1 = 0;
305         int i;
306
307         for (i = 1; i < ARRAY_SIZE(temppoints) - 1; i++)
308                 /* Find pointer to interpolate */
309                 if (data->supply_uV > temppoints[i - 1].vdd) {
310                         d1 = (data->supply_uV/1000 - temppoints[i - 1].vdd)
311                                 * (temppoints[i].d1 - temppoints[i - 1].d1)
312                                 / (temppoints[i].vdd - temppoints[i - 1].vdd)
313                                 + temppoints[i - 1].d1;
314                         break;
315                 }
316
317         return data->val_temp*10 + d1;
318 }
319
320 /**
321  * sht15_calc_humid() - using last temperature convert raw to humid
322  * @data:       device state
323  *
324  * This is the temperature compensated version as per section 4.2 of
325  * the data sheet.
326  **/
327 static inline int sht15_calc_humid(struct sht15_data *data)
328 {
329         int RHlinear; /* milli percent */
330         int temp = sht15_calc_temp(data);
331
332         const int c1 = -4;
333         const int c2 = 40500; /* x 10 ^ -6 */
334         const int c3 = 2800; /* x10 ^ -9 */
335
336         RHlinear = c1*1000
337                 + c2 * data->val_humid/1000
338                 + (data->val_humid * data->val_humid * c3)/1000000;
339         return (temp - 25000) * (10000 + 800 * data->val_humid)
340                 / 1000000 + RHlinear;
341 }
342
343 static ssize_t sht15_show_temp(struct device *dev,
344                                struct device_attribute *attr,
345                                char *buf)
346 {
347         int ret;
348         struct sht15_data *data = dev_get_drvdata(dev);
349
350         /* Technically no need to read humidity as well */
351         ret = sht15_update_vals(data);
352
353         return ret ? ret : sprintf(buf, "%d\n",
354                                    sht15_calc_temp(data));
355 }
356
357 static ssize_t sht15_show_humidity(struct device *dev,
358                                    struct device_attribute *attr,
359                                    char *buf)
360 {
361         int ret;
362         struct sht15_data *data = dev_get_drvdata(dev);
363
364         ret = sht15_update_vals(data);
365
366         return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data));
367
368 };
369 static ssize_t show_name(struct device *dev,
370                          struct device_attribute *attr,
371                          char *buf)
372 {
373         struct platform_device *pdev = to_platform_device(dev);
374         return sprintf(buf, "%s\n", pdev->name);
375 }
376
377 static SENSOR_DEVICE_ATTR(temp1_input,
378                           S_IRUGO, sht15_show_temp,
379                           NULL, 0);
380 static SENSOR_DEVICE_ATTR(humidity1_input,
381                           S_IRUGO, sht15_show_humidity,
382                           NULL, 0);
383 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
384 static struct attribute *sht15_attrs[] = {
385         &sensor_dev_attr_temp1_input.dev_attr.attr,
386         &sensor_dev_attr_humidity1_input.dev_attr.attr,
387         &dev_attr_name.attr,
388         NULL,
389 };
390
391 static const struct attribute_group sht15_attr_group = {
392         .attrs = sht15_attrs,
393 };
394
395 static irqreturn_t sht15_interrupt_fired(int irq, void *d)
396 {
397         struct sht15_data *data = d;
398         /* First disable the interrupt */
399         disable_irq_nosync(irq);
400         atomic_inc(&data->interrupt_handled);
401         /* Then schedule a reading work struct */
402         if (data->flag != SHT15_READING_NOTHING)
403                 schedule_work(&data->read_work);
404         return IRQ_HANDLED;
405 }
406
407 /* Each byte of data is acknowledged by pulling the data line
408  * low for one clock pulse.
409  */
410 static void sht15_ack(struct sht15_data *data)
411 {
412         gpio_direction_output(data->pdata->gpio_data, 0);
413         ndelay(SHT15_TSU);
414         gpio_set_value(data->pdata->gpio_sck, 1);
415         ndelay(SHT15_TSU);
416         gpio_set_value(data->pdata->gpio_sck, 0);
417         ndelay(SHT15_TSU);
418         gpio_set_value(data->pdata->gpio_data, 1);
419
420         gpio_direction_input(data->pdata->gpio_data);
421 }
422 /**
423  * sht15_end_transmission() - notify device of end of transmission
424  * @data:       device state
425  *
426  * This is basically a NAK. (single clock pulse, data high)
427  **/
428 static void sht15_end_transmission(struct sht15_data *data)
429 {
430         gpio_direction_output(data->pdata->gpio_data, 1);
431         ndelay(SHT15_TSU);
432         gpio_set_value(data->pdata->gpio_sck, 1);
433         ndelay(SHT15_TSCKH);
434         gpio_set_value(data->pdata->gpio_sck, 0);
435         ndelay(SHT15_TSCKL);
436 }
437
438 static void sht15_bh_read_data(struct work_struct *work_s)
439 {
440         int i;
441         uint16_t val = 0;
442         struct sht15_data *data
443                 = container_of(work_s, struct sht15_data,
444                                read_work);
445         /* Firstly, verify the line is low */
446         if (gpio_get_value(data->pdata->gpio_data)) {
447                 /* If not, then start the interrupt again - care
448                    here as could have gone low in meantime so verify
449                    it hasn't!
450                 */
451                 atomic_set(&data->interrupt_handled, 0);
452                 enable_irq(gpio_to_irq(data->pdata->gpio_data));
453                 /* If still not occured or another handler has been scheduled */
454                 if (gpio_get_value(data->pdata->gpio_data)
455                     || atomic_read(&data->interrupt_handled))
456                         return;
457         }
458         /* Read the data back from the device */
459         for (i = 0; i < 16; ++i) {
460                 val <<= 1;
461                 gpio_set_value(data->pdata->gpio_sck, 1);
462                 ndelay(SHT15_TSCKH);
463                 val |= !!gpio_get_value(data->pdata->gpio_data);
464                 gpio_set_value(data->pdata->gpio_sck, 0);
465                 ndelay(SHT15_TSCKL);
466                 if (i == 7)
467                         sht15_ack(data);
468         }
469         /* Tell the device we are done */
470         sht15_end_transmission(data);
471
472         switch (data->flag) {
473         case SHT15_READING_TEMP:
474                 data->val_temp = val;
475                 break;
476         case SHT15_READING_HUMID:
477                 data->val_humid = val;
478                 break;
479         }
480
481         data->flag = SHT15_READING_NOTHING;
482         wake_up(&data->wait_queue);
483 }
484
485 static void sht15_update_voltage(struct work_struct *work_s)
486 {
487         struct sht15_data *data
488                 = container_of(work_s, struct sht15_data,
489                                update_supply_work);
490         data->supply_uV = regulator_get_voltage(data->reg);
491 }
492
493 /**
494  * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg
495  * @nb:         associated notification structure
496  * @event:      voltage regulator state change event code
497  * @ignored:    function parameter - ignored here
498  *
499  * Note that as the notification code holds the regulator lock, we have
500  * to schedule an update of the supply voltage rather than getting it directly.
501  **/
502 static int sht15_invalidate_voltage(struct notifier_block *nb,
503                                 unsigned long event,
504                                 void *ignored)
505 {
506         struct sht15_data *data = container_of(nb, struct sht15_data, nb);
507
508         if (event == REGULATOR_EVENT_VOLTAGE_CHANGE)
509                 data->supply_uV_valid = false;
510         schedule_work(&data->update_supply_work);
511
512         return NOTIFY_OK;
513 }
514
515 static int __devinit sht15_probe(struct platform_device *pdev)
516 {
517         int ret = 0;
518         struct sht15_data *data = kzalloc(sizeof(*data), GFP_KERNEL);
519
520         if (!data) {
521                 ret = -ENOMEM;
522                 dev_err(&pdev->dev, "kzalloc failed");
523                 goto error_ret;
524         }
525
526         INIT_WORK(&data->read_work, sht15_bh_read_data);
527         INIT_WORK(&data->update_supply_work, sht15_update_voltage);
528         platform_set_drvdata(pdev, data);
529         mutex_init(&data->read_lock);
530         data->dev = &pdev->dev;
531         init_waitqueue_head(&data->wait_queue);
532
533         if (pdev->dev.platform_data == NULL) {
534                 dev_err(&pdev->dev, "no platform data supplied");
535                 goto err_free_data;
536         }
537         data->pdata = pdev->dev.platform_data;
538         data->supply_uV = data->pdata->supply_mv*1000;
539
540 /* If a regulator is available, query what the supply voltage actually is!*/
541         data->reg = regulator_get(data->dev, "vcc");
542         if (!IS_ERR(data->reg)) {
543                 data->supply_uV = regulator_get_voltage(data->reg);
544                 regulator_enable(data->reg);
545                 /* setup a notifier block to update this if another device
546                  *  causes the voltage to change */
547                 data->nb.notifier_call = &sht15_invalidate_voltage;
548                 ret = regulator_register_notifier(data->reg, &data->nb);
549         }
550 /* Try requesting the GPIOs */
551         ret = gpio_request(data->pdata->gpio_sck, "SHT15 sck");
552         if (ret) {
553                 dev_err(&pdev->dev, "gpio request failed");
554                 goto err_free_data;
555         }
556         gpio_direction_output(data->pdata->gpio_sck, 0);
557         ret = gpio_request(data->pdata->gpio_data, "SHT15 data");
558         if (ret) {
559                 dev_err(&pdev->dev, "gpio request failed");
560                 goto err_release_gpio_sck;
561         }
562         ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group);
563         if (ret) {
564                 dev_err(&pdev->dev, "sysfs create failed");
565                 goto err_free_data;
566         }
567
568         ret = request_irq(gpio_to_irq(data->pdata->gpio_data),
569                           sht15_interrupt_fired,
570                           IRQF_TRIGGER_FALLING,
571                           "sht15 data",
572                           data);
573         if (ret) {
574                 dev_err(&pdev->dev, "failed to get irq for data line");
575                 goto err_release_gpio_data;
576         }
577         disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));
578         sht15_connection_reset(data);
579         sht15_send_cmd(data, 0x1E);
580
581         data->hwmon_dev = hwmon_device_register(data->dev);
582         if (IS_ERR(data->hwmon_dev)) {
583                 ret = PTR_ERR(data->hwmon_dev);
584                 goto err_release_gpio_data;
585         }
586         return 0;
587
588 err_release_gpio_data:
589         gpio_free(data->pdata->gpio_data);
590 err_release_gpio_sck:
591         gpio_free(data->pdata->gpio_sck);
592 err_free_data:
593         kfree(data);
594 error_ret:
595
596         return ret;
597 }
598
599 static int __devexit sht15_remove(struct platform_device *pdev)
600 {
601         struct sht15_data *data = platform_get_drvdata(pdev);
602
603         /* Make sure any reads from the device are done and
604          * prevent new ones beginnning */
605         mutex_lock(&data->read_lock);
606         hwmon_device_unregister(data->hwmon_dev);
607         sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group);
608         if (!IS_ERR(data->reg)) {
609                 regulator_unregister_notifier(data->reg, &data->nb);
610                 regulator_disable(data->reg);
611                 regulator_put(data->reg);
612         }
613
614         free_irq(gpio_to_irq(data->pdata->gpio_data), data);
615         gpio_free(data->pdata->gpio_data);
616         gpio_free(data->pdata->gpio_sck);
617         mutex_unlock(&data->read_lock);
618         kfree(data);
619         return 0;
620 }
621
622
623 static struct platform_driver sht_drivers[] = {
624         {
625                 .driver = {
626                         .name = "sht10",
627                         .owner = THIS_MODULE,
628                 },
629                 .probe = sht15_probe,
630                 .remove = __devexit_p(sht15_remove),
631         }, {
632                 .driver = {
633                         .name = "sht11",
634                         .owner = THIS_MODULE,
635                 },
636                 .probe = sht15_probe,
637                 .remove = __devexit_p(sht15_remove),
638         }, {
639                 .driver = {
640                         .name = "sht15",
641                         .owner = THIS_MODULE,
642                 },
643                 .probe = sht15_probe,
644                 .remove = __devexit_p(sht15_remove),
645         }, {
646                 .driver = {
647                         .name = "sht71",
648                         .owner = THIS_MODULE,
649                 },
650                 .probe = sht15_probe,
651                 .remove = __devexit_p(sht15_remove),
652         }, {
653                 .driver = {
654                         .name = "sht75",
655                         .owner = THIS_MODULE,
656                 },
657                 .probe = sht15_probe,
658                 .remove = __devexit_p(sht15_remove),
659         },
660 };
661
662
663 static int __init sht15_init(void)
664 {
665         int ret;
666         int i;
667
668         for (i = 0; i < ARRAY_SIZE(sht_drivers); i++) {
669                 ret = platform_driver_register(&sht_drivers[i]);
670                 if (ret)
671                         goto error_unreg;
672         }
673
674         return 0;
675
676 error_unreg:
677         while (--i >= 0)
678                 platform_driver_unregister(&sht_drivers[i]);
679
680         return ret;
681 }
682 module_init(sht15_init);
683
684 static void __exit sht15_exit(void)
685 {
686         int i;
687         for (i = ARRAY_SIZE(sht_drivers) - 1; i >= 0; i--)
688                 platform_driver_unregister(&sht_drivers[i]);
689 }
690 module_exit(sht15_exit);
691
692 MODULE_LICENSE("GPL");