treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / iio / common / ssp_sensors / ssp_dev.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Copyright (C) 2014, Samsung Electronics Co. Ltd. All Rights Reserved.
4  */
5
6 #include <linux/iio/iio.h>
7 #include <linux/interrupt.h>
8 #include <linux/io.h>
9 #include <linux/mfd/core.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/of_gpio.h>
13 #include <linux/of_platform.h>
14 #include "ssp.h"
15
16 #define SSP_WDT_TIME                    10000
17 #define SSP_LIMIT_RESET_CNT             20
18 #define SSP_LIMIT_TIMEOUT_CNT           3
19
20 /* It is possible that it is max clk rate for version 1.0 of bootcode */
21 #define SSP_BOOT_SPI_HZ 400000
22
23 /*
24  * These fields can look enigmatic but this structure is used mainly to flat
25  * some values and depends on command type.
26  */
27 struct ssp_instruction {
28         __le32 a;
29         __le32 b;
30         u8 c;
31 } __attribute__((__packed__));
32
33 static const u8 ssp_magnitude_table[] = {110, 85, 171, 71, 203, 195, 0, 67,
34         208, 56, 175, 244, 206, 213, 0, 92, 250, 0, 55, 48, 189, 252, 171,
35         243, 13, 45, 250};
36
37 static const struct ssp_sensorhub_info ssp_rinato_info = {
38         .fw_name = "ssp_B2.fw",
39         .fw_crashed_name = "ssp_crashed.fw",
40         .fw_rev = 14052300,
41         .mag_table = ssp_magnitude_table,
42         .mag_length = ARRAY_SIZE(ssp_magnitude_table),
43 };
44
45 static const struct ssp_sensorhub_info ssp_thermostat_info = {
46         .fw_name = "thermostat_B2.fw",
47         .fw_crashed_name = "ssp_crashed.fw",
48         .fw_rev = 14080600,
49         .mag_table = ssp_magnitude_table,
50         .mag_length = ARRAY_SIZE(ssp_magnitude_table),
51 };
52
53 static const struct mfd_cell sensorhub_sensor_devs[] = {
54         {
55                 .name = "ssp-accelerometer",
56         },
57         {
58                 .name = "ssp-gyroscope",
59         },
60 };
61
62 static void ssp_toggle_mcu_reset_gpio(struct ssp_data *data)
63 {
64         gpio_set_value(data->mcu_reset_gpio, 0);
65         usleep_range(1000, 1200);
66         gpio_set_value(data->mcu_reset_gpio, 1);
67         msleep(50);
68 }
69
70 static void ssp_sync_available_sensors(struct ssp_data *data)
71 {
72         int i, ret;
73
74         for (i = 0; i < SSP_SENSOR_MAX; ++i) {
75                 if (data->available_sensors & BIT(i)) {
76                         ret = ssp_enable_sensor(data, i, data->delay_buf[i]);
77                         if (ret < 0) {
78                                 dev_err(&data->spi->dev,
79                                         "Sync sensor nr: %d fail\n", i);
80                                 continue;
81                         }
82                 }
83         }
84
85         ret = ssp_command(data, SSP_MSG2SSP_AP_MCU_SET_DUMPMODE,
86                           data->mcu_dump_mode);
87         if (ret < 0)
88                 dev_err(&data->spi->dev,
89                         "SSP_MSG2SSP_AP_MCU_SET_DUMPMODE failed\n");
90 }
91
92 static void ssp_enable_mcu(struct ssp_data *data, bool enable)
93 {
94         dev_info(&data->spi->dev, "current shutdown = %d, old = %d\n", enable,
95                  data->shut_down);
96
97         if (enable && data->shut_down) {
98                 data->shut_down = false;
99                 enable_irq(data->spi->irq);
100                 enable_irq_wake(data->spi->irq);
101         } else if (!enable && !data->shut_down) {
102                 data->shut_down = true;
103                 disable_irq(data->spi->irq);
104                 disable_irq_wake(data->spi->irq);
105         } else {
106                 dev_warn(&data->spi->dev, "current shutdown = %d, old = %d\n",
107                          enable, data->shut_down);
108         }
109 }
110
111 /*
112  * This function is the first one which communicates with the mcu so it is
113  * possible that the first attempt will fail
114  */
115 static int ssp_check_fwbl(struct ssp_data *data)
116 {
117         int retries = 0;
118
119         while (retries++ < 5) {
120                 data->cur_firm_rev = ssp_get_firmware_rev(data);
121                 if (data->cur_firm_rev == SSP_INVALID_REVISION ||
122                     data->cur_firm_rev == SSP_INVALID_REVISION2) {
123                         dev_warn(&data->spi->dev,
124                                  "Invalid revision, trying %d time\n", retries);
125                 } else {
126                         break;
127                 }
128         }
129
130         if (data->cur_firm_rev == SSP_INVALID_REVISION ||
131             data->cur_firm_rev == SSP_INVALID_REVISION2) {
132                 dev_err(&data->spi->dev, "SSP_INVALID_REVISION\n");
133                 return SSP_FW_DL_STATE_NEED_TO_SCHEDULE;
134         }
135
136         dev_info(&data->spi->dev,
137                  "MCU Firm Rev : Old = %8u, New = %8u\n",
138                  data->cur_firm_rev,
139                  data->sensorhub_info->fw_rev);
140
141         if (data->cur_firm_rev != data->sensorhub_info->fw_rev)
142                 return SSP_FW_DL_STATE_NEED_TO_SCHEDULE;
143
144         return SSP_FW_DL_STATE_NONE;
145 }
146
147 static void ssp_reset_mcu(struct ssp_data *data)
148 {
149         ssp_enable_mcu(data, false);
150         ssp_clean_pending_list(data);
151         ssp_toggle_mcu_reset_gpio(data);
152         ssp_enable_mcu(data, true);
153 }
154
155 static void ssp_wdt_work_func(struct work_struct *work)
156 {
157         struct ssp_data *data = container_of(work, struct ssp_data, work_wdt);
158
159         dev_err(&data->spi->dev, "%s - Sensor state: 0x%x, RC: %u, CC: %u\n",
160                 __func__, data->available_sensors, data->reset_cnt,
161                 data->com_fail_cnt);
162
163         ssp_reset_mcu(data);
164         data->com_fail_cnt = 0;
165         data->timeout_cnt = 0;
166 }
167
168 static void ssp_wdt_timer_func(struct timer_list *t)
169 {
170         struct ssp_data *data = from_timer(data, t, wdt_timer);
171
172         switch (data->fw_dl_state) {
173         case SSP_FW_DL_STATE_FAIL:
174         case SSP_FW_DL_STATE_DOWNLOADING:
175         case SSP_FW_DL_STATE_SYNC:
176                 goto _mod;
177         }
178
179         if (data->timeout_cnt > SSP_LIMIT_TIMEOUT_CNT ||
180             data->com_fail_cnt > SSP_LIMIT_RESET_CNT)
181                 queue_work(system_power_efficient_wq, &data->work_wdt);
182 _mod:
183         mod_timer(&data->wdt_timer, jiffies + msecs_to_jiffies(SSP_WDT_TIME));
184 }
185
186 static void ssp_enable_wdt_timer(struct ssp_data *data)
187 {
188         mod_timer(&data->wdt_timer, jiffies + msecs_to_jiffies(SSP_WDT_TIME));
189 }
190
191 static void ssp_disable_wdt_timer(struct ssp_data *data)
192 {
193         del_timer_sync(&data->wdt_timer);
194         cancel_work_sync(&data->work_wdt);
195 }
196
197 /**
198  * ssp_get_sensor_delay() - gets sensor data acquisition period
199  * @data:       sensorhub structure
200  * @type:       SSP sensor type
201  *
202  * Returns acquisition period in ms
203  */
204 u32 ssp_get_sensor_delay(struct ssp_data *data, enum ssp_sensor_type type)
205 {
206         return data->delay_buf[type];
207 }
208 EXPORT_SYMBOL(ssp_get_sensor_delay);
209
210 /**
211  * ssp_enable_sensor() - enables data acquisition for sensor
212  * @data:       sensorhub structure
213  * @type:       SSP sensor type
214  * @delay:      delay in ms
215  *
216  * Returns 0 or negative value in case of error
217  */
218 int ssp_enable_sensor(struct ssp_data *data, enum ssp_sensor_type type,
219                       u32 delay)
220 {
221         int ret;
222         struct ssp_instruction to_send;
223
224         to_send.a = cpu_to_le32(delay);
225         to_send.b = cpu_to_le32(data->batch_latency_buf[type]);
226         to_send.c = data->batch_opt_buf[type];
227
228         switch (data->check_status[type]) {
229         case SSP_INITIALIZATION_STATE:
230                 /* do calibration step, now just enable */
231         case SSP_ADD_SENSOR_STATE:
232                 ret = ssp_send_instruction(data,
233                                            SSP_MSG2SSP_INST_BYPASS_SENSOR_ADD,
234                                            type,
235                                            (u8 *)&to_send, sizeof(to_send));
236                 if (ret < 0) {
237                         dev_err(&data->spi->dev, "Enabling sensor failed\n");
238                         data->check_status[type] = SSP_NO_SENSOR_STATE;
239                         goto derror;
240                 }
241
242                 data->sensor_enable |= BIT(type);
243                 data->check_status[type] = SSP_RUNNING_SENSOR_STATE;
244                 break;
245         case SSP_RUNNING_SENSOR_STATE:
246                 ret = ssp_send_instruction(data,
247                                            SSP_MSG2SSP_INST_CHANGE_DELAY, type,
248                                            (u8 *)&to_send, sizeof(to_send));
249                 if (ret < 0) {
250                         dev_err(&data->spi->dev,
251                                 "Changing sensor delay failed\n");
252                         goto derror;
253                 }
254                 break;
255         default:
256                 data->check_status[type] = SSP_ADD_SENSOR_STATE;
257                 break;
258         }
259
260         data->delay_buf[type] = delay;
261
262         if (atomic_inc_return(&data->enable_refcount) == 1)
263                 ssp_enable_wdt_timer(data);
264
265         return 0;
266
267 derror:
268         return ret;
269 }
270 EXPORT_SYMBOL(ssp_enable_sensor);
271
272 /**
273  * ssp_change_delay() - changes data acquisition for sensor
274  * @data:       sensorhub structure
275  * @type:       SSP sensor type
276  * @delay:      delay in ms
277  *
278  * Returns 0 or negative value in case of error
279  */
280 int ssp_change_delay(struct ssp_data *data, enum ssp_sensor_type type,
281                      u32 delay)
282 {
283         int ret;
284         struct ssp_instruction to_send;
285
286         to_send.a = cpu_to_le32(delay);
287         to_send.b = cpu_to_le32(data->batch_latency_buf[type]);
288         to_send.c = data->batch_opt_buf[type];
289
290         ret = ssp_send_instruction(data, SSP_MSG2SSP_INST_CHANGE_DELAY, type,
291                                    (u8 *)&to_send, sizeof(to_send));
292         if (ret < 0) {
293                 dev_err(&data->spi->dev, "Changing sensor delay failed\n");
294                 return ret;
295         }
296
297         data->delay_buf[type] = delay;
298
299         return 0;
300 }
301 EXPORT_SYMBOL(ssp_change_delay);
302
303 /**
304  * ssp_disable_sensor() - disables sensor
305  *
306  * @data:       sensorhub structure
307  * @type:       SSP sensor type
308  *
309  * Returns 0 or negative value in case of error
310  */
311 int ssp_disable_sensor(struct ssp_data *data, enum ssp_sensor_type type)
312 {
313         int ret;
314         __le32 command;
315
316         if (data->sensor_enable & BIT(type)) {
317                 command = cpu_to_le32(data->delay_buf[type]);
318
319                 ret = ssp_send_instruction(data,
320                                            SSP_MSG2SSP_INST_BYPASS_SENSOR_RM,
321                                            type, (u8 *)&command,
322                                            sizeof(command));
323                 if (ret < 0) {
324                         dev_err(&data->spi->dev, "Remove sensor fail\n");
325                         return ret;
326                 }
327
328                 data->sensor_enable &= ~BIT(type);
329         }
330
331         data->check_status[type] = SSP_ADD_SENSOR_STATE;
332
333         if (atomic_dec_and_test(&data->enable_refcount))
334                 ssp_disable_wdt_timer(data);
335
336         return 0;
337 }
338 EXPORT_SYMBOL(ssp_disable_sensor);
339
340 static irqreturn_t ssp_irq_thread_fn(int irq, void *dev_id)
341 {
342         struct ssp_data *data = dev_id;
343
344         /*
345          * This wrapper is done to preserve error path for ssp_irq_msg, also
346          * it is defined in different file.
347          */
348         ssp_irq_msg(data);
349
350         return IRQ_HANDLED;
351 }
352
353 static int ssp_initialize_mcu(struct ssp_data *data)
354 {
355         int ret;
356
357         ssp_clean_pending_list(data);
358
359         ret = ssp_get_chipid(data);
360         if (ret != SSP_DEVICE_ID) {
361                 dev_err(&data->spi->dev, "%s - MCU %s ret = %d\n", __func__,
362                         ret < 0 ? "is not working" : "identification failed",
363                         ret);
364                 return ret < 0 ? ret : -ENODEV;
365         }
366
367         dev_info(&data->spi->dev, "MCU device ID = %d\n", ret);
368
369         /*
370          * needs clarification, for now do not want to export all transfer
371          * methods to sensors' drivers
372          */
373         ret = ssp_set_magnetic_matrix(data);
374         if (ret < 0) {
375                 dev_err(&data->spi->dev,
376                         "%s - ssp_set_magnetic_matrix failed\n", __func__);
377                 return ret;
378         }
379
380         data->available_sensors = ssp_get_sensor_scanning_info(data);
381         if (data->available_sensors == 0) {
382                 dev_err(&data->spi->dev,
383                         "%s - ssp_get_sensor_scanning_info failed\n", __func__);
384                 return -EIO;
385         }
386
387         data->cur_firm_rev = ssp_get_firmware_rev(data);
388         dev_info(&data->spi->dev, "MCU Firm Rev : New = %8u\n",
389                  data->cur_firm_rev);
390
391         return ssp_command(data, SSP_MSG2SSP_AP_MCU_DUMP_CHECK, 0);
392 }
393
394 /*
395  * sensorhub can request its reinitialization as some brutal and rare error
396  * handling. It can be requested from the MCU.
397  */
398 static void ssp_refresh_task(struct work_struct *work)
399 {
400         struct ssp_data *data = container_of((struct delayed_work *)work,
401                                              struct ssp_data, work_refresh);
402
403         dev_info(&data->spi->dev, "refreshing\n");
404
405         data->reset_cnt++;
406
407         if (ssp_initialize_mcu(data) >= 0) {
408                 ssp_sync_available_sensors(data);
409                 if (data->last_ap_state != 0)
410                         ssp_command(data, data->last_ap_state, 0);
411
412                 if (data->last_resume_state != 0)
413                         ssp_command(data, data->last_resume_state, 0);
414
415                 data->timeout_cnt = 0;
416                 data->com_fail_cnt = 0;
417         }
418 }
419
420 int ssp_queue_ssp_refresh_task(struct ssp_data *data, unsigned int delay)
421 {
422         cancel_delayed_work_sync(&data->work_refresh);
423
424         return queue_delayed_work(system_power_efficient_wq,
425                                   &data->work_refresh,
426                                   msecs_to_jiffies(delay));
427 }
428
429 #ifdef CONFIG_OF
430 static const struct of_device_id ssp_of_match[] = {
431         {
432                 .compatible     = "samsung,sensorhub-rinato",
433                 .data           = &ssp_rinato_info,
434         }, {
435                 .compatible     = "samsung,sensorhub-thermostat",
436                 .data           = &ssp_thermostat_info,
437         },
438         {},
439 };
440 MODULE_DEVICE_TABLE(of, ssp_of_match);
441
442 static struct ssp_data *ssp_parse_dt(struct device *dev)
443 {
444         int ret;
445         struct ssp_data *data;
446         struct device_node *node = dev->of_node;
447         const struct of_device_id *match;
448
449         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
450         if (!data)
451                 return NULL;
452
453         data->mcu_ap_gpio = of_get_named_gpio(node, "mcu-ap-gpios", 0);
454         if (data->mcu_ap_gpio < 0)
455                 return NULL;
456
457         data->ap_mcu_gpio = of_get_named_gpio(node, "ap-mcu-gpios", 0);
458         if (data->ap_mcu_gpio < 0)
459                 return NULL;
460
461         data->mcu_reset_gpio = of_get_named_gpio(node, "mcu-reset-gpios", 0);
462         if (data->mcu_reset_gpio < 0)
463                 return NULL;
464
465         ret = devm_gpio_request_one(dev, data->ap_mcu_gpio, GPIOF_OUT_INIT_HIGH,
466                                     "ap-mcu-gpios");
467         if (ret)
468                 return NULL;
469
470         ret = devm_gpio_request_one(dev, data->mcu_reset_gpio,
471                                     GPIOF_OUT_INIT_HIGH, "mcu-reset-gpios");
472         if (ret)
473                 return NULL;
474
475         match = of_match_node(ssp_of_match, node);
476         if (!match)
477                 return NULL;
478
479         data->sensorhub_info = match->data;
480
481         dev_set_drvdata(dev, data);
482
483         return data;
484 }
485 #else
486 static struct ssp_data *ssp_parse_dt(struct device *pdev)
487 {
488         return NULL;
489 }
490 #endif
491
492 /**
493  * ssp_register_consumer() - registers iio consumer in ssp framework
494  *
495  * @indio_dev:  consumer iio device
496  * @type:       ssp sensor type
497  */
498 void ssp_register_consumer(struct iio_dev *indio_dev, enum ssp_sensor_type type)
499 {
500         struct ssp_data *data = dev_get_drvdata(indio_dev->dev.parent->parent);
501
502         data->sensor_devs[type] = indio_dev;
503 }
504 EXPORT_SYMBOL(ssp_register_consumer);
505
506 static int ssp_probe(struct spi_device *spi)
507 {
508         int ret, i;
509         struct ssp_data *data;
510
511         data = ssp_parse_dt(&spi->dev);
512         if (!data) {
513                 dev_err(&spi->dev, "Failed to find platform data\n");
514                 return -ENODEV;
515         }
516
517         ret = mfd_add_devices(&spi->dev, -1, sensorhub_sensor_devs,
518                               ARRAY_SIZE(sensorhub_sensor_devs), NULL, 0, NULL);
519         if (ret < 0) {
520                 dev_err(&spi->dev, "mfd add devices fail\n");
521                 return ret;
522         }
523
524         spi->mode = SPI_MODE_1;
525         ret = spi_setup(spi);
526         if (ret < 0) {
527                 dev_err(&spi->dev, "Failed to setup spi\n");
528                 return ret;
529         }
530
531         data->fw_dl_state = SSP_FW_DL_STATE_NONE;
532         data->spi = spi;
533         spi_set_drvdata(spi, data);
534
535         mutex_init(&data->comm_lock);
536
537         for (i = 0; i < SSP_SENSOR_MAX; ++i) {
538                 data->delay_buf[i] = SSP_DEFAULT_POLLING_DELAY;
539                 data->batch_latency_buf[i] = 0;
540                 data->batch_opt_buf[i] = 0;
541                 data->check_status[i] = SSP_INITIALIZATION_STATE;
542         }
543
544         data->delay_buf[SSP_BIO_HRM_LIB] = 100;
545
546         data->time_syncing = true;
547
548         mutex_init(&data->pending_lock);
549         INIT_LIST_HEAD(&data->pending_list);
550
551         atomic_set(&data->enable_refcount, 0);
552
553         INIT_WORK(&data->work_wdt, ssp_wdt_work_func);
554         INIT_DELAYED_WORK(&data->work_refresh, ssp_refresh_task);
555
556         timer_setup(&data->wdt_timer, ssp_wdt_timer_func, 0);
557
558         ret = request_threaded_irq(data->spi->irq, NULL,
559                                    ssp_irq_thread_fn,
560                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
561                                    "SSP_Int", data);
562         if (ret < 0) {
563                 dev_err(&spi->dev, "Irq request fail\n");
564                 goto err_setup_irq;
565         }
566
567         /* Let's start with enabled one so irq balance could be ok */
568         data->shut_down = false;
569
570         /* just to avoid unbalanced irq set wake up */
571         enable_irq_wake(data->spi->irq);
572
573         data->fw_dl_state = ssp_check_fwbl(data);
574         if (data->fw_dl_state == SSP_FW_DL_STATE_NONE) {
575                 ret = ssp_initialize_mcu(data);
576                 if (ret < 0) {
577                         dev_err(&spi->dev, "Initialize_mcu failed\n");
578                         goto err_read_reg;
579                 }
580         } else {
581                 dev_err(&spi->dev, "Firmware version not supported\n");
582                 ret = -EPERM;
583                 goto err_read_reg;
584         }
585
586         return 0;
587
588 err_read_reg:
589         free_irq(data->spi->irq, data);
590 err_setup_irq:
591         mutex_destroy(&data->pending_lock);
592         mutex_destroy(&data->comm_lock);
593
594         dev_err(&spi->dev, "Probe failed!\n");
595
596         return ret;
597 }
598
599 static int ssp_remove(struct spi_device *spi)
600 {
601         struct ssp_data *data = spi_get_drvdata(spi);
602
603         if (ssp_command(data, SSP_MSG2SSP_AP_STATUS_SHUTDOWN, 0) < 0)
604                 dev_err(&data->spi->dev,
605                         "SSP_MSG2SSP_AP_STATUS_SHUTDOWN failed\n");
606
607         ssp_enable_mcu(data, false);
608         ssp_disable_wdt_timer(data);
609
610         ssp_clean_pending_list(data);
611
612         free_irq(data->spi->irq, data);
613
614         del_timer_sync(&data->wdt_timer);
615         cancel_work_sync(&data->work_wdt);
616
617         mutex_destroy(&data->comm_lock);
618         mutex_destroy(&data->pending_lock);
619
620         mfd_remove_devices(&spi->dev);
621
622         return 0;
623 }
624
625 #ifdef CONFIG_PM_SLEEP
626 static int ssp_suspend(struct device *dev)
627 {
628         int ret;
629         struct ssp_data *data = spi_get_drvdata(to_spi_device(dev));
630
631         data->last_resume_state = SSP_MSG2SSP_AP_STATUS_SUSPEND;
632
633         if (atomic_read(&data->enable_refcount) > 0)
634                 ssp_disable_wdt_timer(data);
635
636         ret = ssp_command(data, SSP_MSG2SSP_AP_STATUS_SUSPEND, 0);
637         if (ret < 0) {
638                 dev_err(&data->spi->dev,
639                         "%s SSP_MSG2SSP_AP_STATUS_SUSPEND failed\n", __func__);
640
641                 ssp_enable_wdt_timer(data);
642                 return ret;
643         }
644
645         data->time_syncing = false;
646         disable_irq(data->spi->irq);
647
648         return 0;
649 }
650
651 static int ssp_resume(struct device *dev)
652 {
653         int ret;
654         struct ssp_data *data = spi_get_drvdata(to_spi_device(dev));
655
656         enable_irq(data->spi->irq);
657
658         if (atomic_read(&data->enable_refcount) > 0)
659                 ssp_enable_wdt_timer(data);
660
661         ret = ssp_command(data, SSP_MSG2SSP_AP_STATUS_RESUME, 0);
662         if (ret < 0) {
663                 dev_err(&data->spi->dev,
664                         "%s SSP_MSG2SSP_AP_STATUS_RESUME failed\n", __func__);
665                 ssp_disable_wdt_timer(data);
666                 return ret;
667         }
668
669         /* timesyncing is set by MCU */
670         data->last_resume_state = SSP_MSG2SSP_AP_STATUS_RESUME;
671
672         return 0;
673 }
674 #endif /* CONFIG_PM_SLEEP */
675
676 static const struct dev_pm_ops ssp_pm_ops = {
677         SET_SYSTEM_SLEEP_PM_OPS(ssp_suspend, ssp_resume)
678 };
679
680 static struct spi_driver ssp_driver = {
681         .probe = ssp_probe,
682         .remove = ssp_remove,
683         .driver = {
684                 .pm = &ssp_pm_ops,
685                 .of_match_table = of_match_ptr(ssp_of_match),
686                 .name = "sensorhub"
687         },
688 };
689
690 module_spi_driver(ssp_driver);
691
692 MODULE_DESCRIPTION("ssp sensorhub driver");
693 MODULE_AUTHOR("Samsung Electronics");
694 MODULE_LICENSE("GPL");