V4L/DVB (11957): dsbr100: change radio->muted to radio->status, update suspend/resume
[linux-2.6.git] / drivers / media / radio / dsbr100.c
1 /* A driver for the D-Link DSB-R100 USB radio and Gemtek USB Radio 21.
2  The device plugs into both the USB and an analog audio input, so this thing
3  only deals with initialisation and frequency setting, the
4  audio data has to be handled by a sound driver.
5
6  Major issue: I can't find out where the device reports the signal
7  strength, and indeed the windows software appearantly just looks
8  at the stereo indicator as well.  So, scanning will only find
9  stereo stations.  Sad, but I can't help it.
10
11  Also, the windows program sends oodles of messages over to the
12  device, and I couldn't figure out their meaning.  My suspicion
13  is that they don't have any:-)
14
15  You might find some interesting stuff about this module at
16  http://unimut.fsk.uni-heidelberg.de/unimut/demi/dsbr
17
18  Copyright (c) 2000 Markus Demleitner <msdemlei@cl.uni-heidelberg.de>
19
20  This program is free software; you can redistribute it and/or modify
21  it under the terms of the GNU General Public License as published by
22  the Free Software Foundation; either version 2 of the License, or
23  (at your option) any later version.
24
25  This program is distributed in the hope that it will be useful,
26  but WITHOUT ANY WARRANTY; without even the implied warranty of
27  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28  GNU General Public License for more details.
29
30  You should have received a copy of the GNU General Public License
31  along with this program; if not, write to the Free Software
32  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33
34  History:
35
36  Version 0.46:
37         Removed usb_dsbr100_open/close calls and radio->users counter. Also,
38         radio->muted changed to radio->status and suspend/resume calls updated.
39
40  Version 0.45:
41         Converted to v4l2_device.
42
43  Version 0.44:
44         Add suspend/resume functions, fix unplug of device,
45         a lot of cleanups and fixes by Alexey Klimov <klimov.linux@gmail.com>
46
47  Version 0.43:
48         Oliver Neukum: avoided DMA coherency issue
49
50  Version 0.42:
51         Converted dsbr100 to use video_ioctl2
52         by Douglas Landgraf <dougsland@gmail.com>
53
54  Version 0.41-ac1:
55         Alan Cox: Some cleanups and fixes
56
57  Version 0.41:
58         Converted to V4L2 API by Mauro Carvalho Chehab <mchehab@infradead.org>
59
60  Version 0.40:
61         Markus: Updates for 2.6.x kernels, code layout changes, name sanitizing
62
63  Version 0.30:
64         Markus: Updates for 2.5.x kernel and more ISO compliant source
65
66  Version 0.25:
67         PSL and Markus: Cleanup, radio now doesn't stop on device close
68
69  Version 0.24:
70         Markus: Hope I got these silly VIDEO_TUNER_LOW issues finally
71         right.  Some minor cleanup, improved standalone compilation
72
73  Version 0.23:
74         Markus: Sign extension bug fixed by declaring transfer_buffer unsigned
75
76  Version 0.22:
77         Markus: Some (brown bag) cleanup in what VIDIOCSTUNER returns,
78         thanks to Mike Cox for pointing the problem out.
79
80  Version 0.21:
81         Markus: Minor cleanup, warnings if something goes wrong, lame attempt
82         to adhere to Documentation/CodingStyle
83
84  Version 0.2:
85         Brad Hards <bradh@dynamite.com.au>: Fixes to make it work as non-module
86         Markus: Copyright clarification
87
88  Version 0.01: Markus: initial release
89
90 */
91
92 #include <linux/kernel.h>
93 #include <linux/module.h>
94 #include <linux/init.h>
95 #include <linux/slab.h>
96 #include <linux/input.h>
97 #include <linux/videodev2.h>
98 #include <media/v4l2-device.h>
99 #include <media/v4l2-ioctl.h>
100 #include <linux/usb.h>
101
102 /*
103  * Version Information
104  */
105 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
106
107 #define DRIVER_VERSION "v0.46"
108 #define RADIO_VERSION KERNEL_VERSION(0, 4, 6)
109
110 #define DRIVER_AUTHOR "Markus Demleitner <msdemlei@tucana.harvard.edu>"
111 #define DRIVER_DESC "D-Link DSB-R100 USB FM radio driver"
112
113 #define DSB100_VENDOR 0x04b4
114 #define DSB100_PRODUCT 0x1002
115
116 /* Commands the device appears to understand */
117 #define DSB100_TUNE 1
118 #define DSB100_ONOFF 2
119
120 #define TB_LEN 16
121
122 /* Frequency limits in MHz -- these are European values.  For Japanese
123 devices, that would be 76 and 91.  */
124 #define FREQ_MIN  87.5
125 #define FREQ_MAX 108.0
126 #define FREQ_MUL 16000
127
128 /* defines for radio->status */
129 #define STARTED 0
130 #define STOPPED 1
131
132 #define videodev_to_radio(d) container_of(d, struct dsbr100_device, videodev)
133
134 static int usb_dsbr100_probe(struct usb_interface *intf,
135                              const struct usb_device_id *id);
136 static void usb_dsbr100_disconnect(struct usb_interface *intf);
137 static int usb_dsbr100_suspend(struct usb_interface *intf,
138                                                 pm_message_t message);
139 static int usb_dsbr100_resume(struct usb_interface *intf);
140
141 static int radio_nr = -1;
142 module_param(radio_nr, int, 0);
143
144 /* Data for one (physical) device */
145 struct dsbr100_device {
146         struct usb_device *usbdev;
147         struct video_device videodev;
148         struct v4l2_device v4l2_dev;
149
150         u8 *transfer_buffer;
151         struct mutex lock;      /* buffer locking */
152         int curfreq;
153         int stereo;
154         int removed;
155         int status;
156 };
157
158 static struct usb_device_id usb_dsbr100_device_table [] = {
159         { USB_DEVICE(DSB100_VENDOR, DSB100_PRODUCT) },
160         { }                                             /* Terminating entry */
161 };
162
163 MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table);
164
165 /* USB subsystem interface */
166 static struct usb_driver usb_dsbr100_driver = {
167         .name                   = "dsbr100",
168         .probe                  = usb_dsbr100_probe,
169         .disconnect             = usb_dsbr100_disconnect,
170         .id_table               = usb_dsbr100_device_table,
171         .suspend                = usb_dsbr100_suspend,
172         .resume                 = usb_dsbr100_resume,
173         .reset_resume           = usb_dsbr100_resume,
174         .supports_autosuspend   = 0,
175 };
176
177 /* Low-level device interface begins here */
178
179 /* switch on radio */
180 static int dsbr100_start(struct dsbr100_device *radio)
181 {
182         int retval;
183         int request;
184
185         mutex_lock(&radio->lock);
186
187         retval = usb_control_msg(radio->usbdev,
188                 usb_rcvctrlpipe(radio->usbdev, 0),
189                 USB_REQ_GET_STATUS,
190                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
191                 0x00, 0xC7, radio->transfer_buffer, 8, 300);
192
193         if (retval < 0) {
194                 request = USB_REQ_GET_STATUS;
195                 goto usb_control_msg_failed;
196         }
197
198         retval = usb_control_msg(radio->usbdev,
199                 usb_rcvctrlpipe(radio->usbdev, 0),
200                 DSB100_ONOFF,
201                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
202                 0x01, 0x00, radio->transfer_buffer, 8, 300);
203
204         if (retval < 0) {
205                 request = DSB100_ONOFF;
206                 goto usb_control_msg_failed;
207         }
208
209         radio->status = STARTED;
210         mutex_unlock(&radio->lock);
211         return (radio->transfer_buffer)[0];
212
213 usb_control_msg_failed:
214         mutex_unlock(&radio->lock);
215         dev_err(&radio->usbdev->dev,
216                 "%s - usb_control_msg returned %i, request %i\n",
217                         __func__, retval, request);
218         return retval;
219
220 }
221
222 /* switch off radio */
223 static int dsbr100_stop(struct dsbr100_device *radio)
224 {
225         int retval;
226         int request;
227
228         mutex_lock(&radio->lock);
229
230         retval = usb_control_msg(radio->usbdev,
231                 usb_rcvctrlpipe(radio->usbdev, 0),
232                 USB_REQ_GET_STATUS,
233                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
234                 0x16, 0x1C, radio->transfer_buffer, 8, 300);
235
236         if (retval < 0) {
237                 request = USB_REQ_GET_STATUS;
238                 goto usb_control_msg_failed;
239         }
240
241         retval = usb_control_msg(radio->usbdev,
242                 usb_rcvctrlpipe(radio->usbdev, 0),
243                 DSB100_ONOFF,
244                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
245                 0x00, 0x00, radio->transfer_buffer, 8, 300);
246
247         if (retval < 0) {
248                 request = DSB100_ONOFF;
249                 goto usb_control_msg_failed;
250         }
251
252         radio->status = STOPPED;
253         mutex_unlock(&radio->lock);
254         return (radio->transfer_buffer)[0];
255
256 usb_control_msg_failed:
257         mutex_unlock(&radio->lock);
258         dev_err(&radio->usbdev->dev,
259                 "%s - usb_control_msg returned %i, request %i\n",
260                         __func__, retval, request);
261         return retval;
262
263 }
264
265 /* set a frequency, freq is defined by v4l's TUNER_LOW, i.e. 1/16th kHz */
266 static int dsbr100_setfreq(struct dsbr100_device *radio)
267 {
268         int retval;
269         int request;
270         int freq = (radio->curfreq / 16 * 80) / 1000 + 856;
271
272         mutex_lock(&radio->lock);
273
274         retval = usb_control_msg(radio->usbdev,
275                 usb_rcvctrlpipe(radio->usbdev, 0),
276                 DSB100_TUNE,
277                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
278                 (freq >> 8) & 0x00ff, freq & 0xff,
279                 radio->transfer_buffer, 8, 300);
280
281         if (retval < 0) {
282                 request = DSB100_TUNE;
283                 goto usb_control_msg_failed;
284         }
285
286         retval = usb_control_msg(radio->usbdev,
287                 usb_rcvctrlpipe(radio->usbdev, 0),
288                 USB_REQ_GET_STATUS,
289                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
290                 0x96, 0xB7, radio->transfer_buffer, 8, 300);
291
292         if (retval < 0) {
293                 request = USB_REQ_GET_STATUS;
294                 goto usb_control_msg_failed;
295         }
296
297         retval = usb_control_msg(radio->usbdev,
298                 usb_rcvctrlpipe(radio->usbdev, 0),
299                 USB_REQ_GET_STATUS,
300                 USB_TYPE_VENDOR | USB_RECIP_DEVICE |  USB_DIR_IN,
301                 0x00, 0x24, radio->transfer_buffer, 8, 300);
302
303         if (retval < 0) {
304                 request = USB_REQ_GET_STATUS;
305                 goto usb_control_msg_failed;
306         }
307
308         radio->stereo = !((radio->transfer_buffer)[0] & 0x01);
309         mutex_unlock(&radio->lock);
310         return (radio->transfer_buffer)[0];
311
312 usb_control_msg_failed:
313         radio->stereo = -1;
314         mutex_unlock(&radio->lock);
315         dev_err(&radio->usbdev->dev,
316                 "%s - usb_control_msg returned %i, request %i\n",
317                         __func__, retval, request);
318         return retval;
319 }
320
321 /* return the device status.  This is, in effect, just whether it
322 sees a stereo signal or not.  Pity. */
323 static void dsbr100_getstat(struct dsbr100_device *radio)
324 {
325         int retval;
326
327         mutex_lock(&radio->lock);
328
329         retval = usb_control_msg(radio->usbdev,
330                 usb_rcvctrlpipe(radio->usbdev, 0),
331                 USB_REQ_GET_STATUS,
332                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
333                 0x00 , 0x24, radio->transfer_buffer, 8, 300);
334
335         if (retval < 0) {
336                 radio->stereo = -1;
337                 dev_err(&radio->usbdev->dev,
338                         "%s - usb_control_msg returned %i, request %i\n",
339                                 __func__, retval, USB_REQ_GET_STATUS);
340         } else {
341                 radio->stereo = !(radio->transfer_buffer[0] & 0x01);
342         }
343
344         mutex_unlock(&radio->lock);
345 }
346
347 /* USB subsystem interface begins here */
348
349 /*
350  * Handle unplugging of the device.
351  * We call video_unregister_device in any case.
352  * The last function called in this procedure is
353  * usb_dsbr100_video_device_release
354  */
355 static void usb_dsbr100_disconnect(struct usb_interface *intf)
356 {
357         struct dsbr100_device *radio = usb_get_intfdata(intf);
358
359         usb_set_intfdata (intf, NULL);
360
361         mutex_lock(&radio->lock);
362         radio->removed = 1;
363         mutex_unlock(&radio->lock);
364
365         video_unregister_device(&radio->videodev);
366         v4l2_device_disconnect(&radio->v4l2_dev);
367 }
368
369
370 static int vidioc_querycap(struct file *file, void *priv,
371                                         struct v4l2_capability *v)
372 {
373         struct dsbr100_device *radio = video_drvdata(file);
374
375         strlcpy(v->driver, "dsbr100", sizeof(v->driver));
376         strlcpy(v->card, "D-Link R-100 USB FM Radio", sizeof(v->card));
377         usb_make_path(radio->usbdev, v->bus_info, sizeof(v->bus_info));
378         v->version = RADIO_VERSION;
379         v->capabilities = V4L2_CAP_TUNER;
380         return 0;
381 }
382
383 static int vidioc_g_tuner(struct file *file, void *priv,
384                                 struct v4l2_tuner *v)
385 {
386         struct dsbr100_device *radio = video_drvdata(file);
387
388         /* safety check */
389         if (radio->removed)
390                 return -EIO;
391
392         if (v->index > 0)
393                 return -EINVAL;
394
395         dsbr100_getstat(radio);
396         strcpy(v->name, "FM");
397         v->type = V4L2_TUNER_RADIO;
398         v->rangelow = FREQ_MIN * FREQ_MUL;
399         v->rangehigh = FREQ_MAX * FREQ_MUL;
400         v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
401         v->capability = V4L2_TUNER_CAP_LOW;
402         if(radio->stereo)
403                 v->audmode = V4L2_TUNER_MODE_STEREO;
404         else
405                 v->audmode = V4L2_TUNER_MODE_MONO;
406         v->signal = 0xffff;     /* We can't get the signal strength */
407         return 0;
408 }
409
410 static int vidioc_s_tuner(struct file *file, void *priv,
411                                 struct v4l2_tuner *v)
412 {
413         struct dsbr100_device *radio = video_drvdata(file);
414
415         /* safety check */
416         if (radio->removed)
417                 return -EIO;
418
419         if (v->index > 0)
420                 return -EINVAL;
421
422         return 0;
423 }
424
425 static int vidioc_s_frequency(struct file *file, void *priv,
426                                 struct v4l2_frequency *f)
427 {
428         struct dsbr100_device *radio = video_drvdata(file);
429         int retval;
430
431         /* safety check */
432         if (radio->removed)
433                 return -EIO;
434
435         mutex_lock(&radio->lock);
436         radio->curfreq = f->frequency;
437         mutex_unlock(&radio->lock);
438
439         retval = dsbr100_setfreq(radio);
440         if (retval < 0)
441                 dev_warn(&radio->usbdev->dev, "Set frequency failed\n");
442         return 0;
443 }
444
445 static int vidioc_g_frequency(struct file *file, void *priv,
446                                 struct v4l2_frequency *f)
447 {
448         struct dsbr100_device *radio = video_drvdata(file);
449
450         /* safety check */
451         if (radio->removed)
452                 return -EIO;
453
454         f->type = V4L2_TUNER_RADIO;
455         f->frequency = radio->curfreq;
456         return 0;
457 }
458
459 static int vidioc_queryctrl(struct file *file, void *priv,
460                                 struct v4l2_queryctrl *qc)
461 {
462         switch (qc->id) {
463         case V4L2_CID_AUDIO_MUTE:
464                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
465         }
466
467         return -EINVAL;
468 }
469
470 static int vidioc_g_ctrl(struct file *file, void *priv,
471                                 struct v4l2_control *ctrl)
472 {
473         struct dsbr100_device *radio = video_drvdata(file);
474
475         /* safety check */
476         if (radio->removed)
477                 return -EIO;
478
479         switch (ctrl->id) {
480         case V4L2_CID_AUDIO_MUTE:
481                 ctrl->value = radio->status;
482                 return 0;
483         }
484         return -EINVAL;
485 }
486
487 static int vidioc_s_ctrl(struct file *file, void *priv,
488                                 struct v4l2_control *ctrl)
489 {
490         struct dsbr100_device *radio = video_drvdata(file);
491         int retval;
492
493         /* safety check */
494         if (radio->removed)
495                 return -EIO;
496
497         switch (ctrl->id) {
498         case V4L2_CID_AUDIO_MUTE:
499                 if (ctrl->value) {
500                         retval = dsbr100_stop(radio);
501                         if (retval < 0) {
502                                 dev_warn(&radio->usbdev->dev,
503                                          "Radio did not respond properly\n");
504                                 return -EBUSY;
505                         }
506                 } else {
507                         retval = dsbr100_start(radio);
508                         if (retval < 0) {
509                                 dev_warn(&radio->usbdev->dev,
510                                          "Radio did not respond properly\n");
511                                 return -EBUSY;
512                         }
513                 }
514                 return 0;
515         }
516         return -EINVAL;
517 }
518
519 static int vidioc_g_audio(struct file *file, void *priv,
520                                 struct v4l2_audio *a)
521 {
522         if (a->index > 1)
523                 return -EINVAL;
524
525         strcpy(a->name, "Radio");
526         a->capability = V4L2_AUDCAP_STEREO;
527         return 0;
528 }
529
530 static int vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
531 {
532         *i = 0;
533         return 0;
534 }
535
536 static int vidioc_s_input(struct file *filp, void *priv, unsigned int i)
537 {
538         if (i != 0)
539                 return -EINVAL;
540         return 0;
541 }
542
543 static int vidioc_s_audio(struct file *file, void *priv,
544                                         struct v4l2_audio *a)
545 {
546         if (a->index != 0)
547                 return -EINVAL;
548         return 0;
549 }
550
551 /* Suspend device - stop device. */
552 static int usb_dsbr100_suspend(struct usb_interface *intf, pm_message_t message)
553 {
554         struct dsbr100_device *radio = usb_get_intfdata(intf);
555         int retval;
556
557         if (radio->status == STARTED) {
558                 retval = dsbr100_stop(radio);
559                 if (retval < 0)
560                         dev_warn(&intf->dev, "dsbr100_stop failed\n");
561
562                 /* After dsbr100_stop() status set to STOPPED.
563                  * If we want driver to start radio on resume
564                  * we set status equal to STARTED.
565                  * On resume we will check status and run radio if needed.
566                  */
567
568                 mutex_lock(&radio->lock);
569                 radio->status = STARTED;
570                 mutex_unlock(&radio->lock);
571         }
572
573         dev_info(&intf->dev, "going into suspend..\n");
574
575         return 0;
576 }
577
578 /* Resume device - start device. */
579 static int usb_dsbr100_resume(struct usb_interface *intf)
580 {
581         struct dsbr100_device *radio = usb_get_intfdata(intf);
582         int retval;
583
584         if (radio->status == STARTED) {
585                 retval = dsbr100_start(radio);
586                 if (retval < 0)
587                         dev_warn(&intf->dev, "dsbr100_start failed\n");
588         }
589
590         dev_info(&intf->dev, "coming out of suspend..\n");
591
592         return 0;
593 }
594
595 /* free data structures */
596 static void usb_dsbr100_video_device_release(struct video_device *videodev)
597 {
598         struct dsbr100_device *radio = videodev_to_radio(videodev);
599
600         v4l2_device_unregister(&radio->v4l2_dev);
601         kfree(radio->transfer_buffer);
602         kfree(radio);
603 }
604
605 /* File system interface */
606 static const struct v4l2_file_operations usb_dsbr100_fops = {
607         .owner          = THIS_MODULE,
608         .ioctl          = video_ioctl2,
609 };
610
611 static const struct v4l2_ioctl_ops usb_dsbr100_ioctl_ops = {
612         .vidioc_querycap    = vidioc_querycap,
613         .vidioc_g_tuner     = vidioc_g_tuner,
614         .vidioc_s_tuner     = vidioc_s_tuner,
615         .vidioc_g_frequency = vidioc_g_frequency,
616         .vidioc_s_frequency = vidioc_s_frequency,
617         .vidioc_queryctrl   = vidioc_queryctrl,
618         .vidioc_g_ctrl      = vidioc_g_ctrl,
619         .vidioc_s_ctrl      = vidioc_s_ctrl,
620         .vidioc_g_audio     = vidioc_g_audio,
621         .vidioc_s_audio     = vidioc_s_audio,
622         .vidioc_g_input     = vidioc_g_input,
623         .vidioc_s_input     = vidioc_s_input,
624 };
625
626 /* check if the device is present and register with v4l and usb if it is */
627 static int usb_dsbr100_probe(struct usb_interface *intf,
628                                 const struct usb_device_id *id)
629 {
630         struct dsbr100_device *radio;
631         struct v4l2_device *v4l2_dev;
632         int retval;
633
634         radio = kzalloc(sizeof(struct dsbr100_device), GFP_KERNEL);
635
636         if (!radio)
637                 return -ENOMEM;
638
639         radio->transfer_buffer = kmalloc(TB_LEN, GFP_KERNEL);
640
641         if (!(radio->transfer_buffer)) {
642                 kfree(radio);
643                 return -ENOMEM;
644         }
645
646         v4l2_dev = &radio->v4l2_dev;
647
648         retval = v4l2_device_register(&intf->dev, v4l2_dev);
649         if (retval < 0) {
650                 v4l2_err(v4l2_dev, "couldn't register v4l2_device\n");
651                 kfree(radio->transfer_buffer);
652                 kfree(radio);
653                 return retval;
654         }
655
656         strlcpy(radio->videodev.name, v4l2_dev->name, sizeof(radio->videodev.name));
657         radio->videodev.v4l2_dev = v4l2_dev;
658         radio->videodev.fops = &usb_dsbr100_fops;
659         radio->videodev.ioctl_ops = &usb_dsbr100_ioctl_ops;
660         radio->videodev.release = usb_dsbr100_video_device_release;
661
662         mutex_init(&radio->lock);
663
664         radio->removed = 0;
665         radio->usbdev = interface_to_usbdev(intf);
666         radio->curfreq = FREQ_MIN * FREQ_MUL;
667         radio->status = STOPPED;
668
669         video_set_drvdata(&radio->videodev, radio);
670
671         retval = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
672         if (retval < 0) {
673                 v4l2_err(v4l2_dev, "couldn't register video device\n");
674                 v4l2_device_unregister(v4l2_dev);
675                 kfree(radio->transfer_buffer);
676                 kfree(radio);
677                 return -EIO;
678         }
679         usb_set_intfdata(intf, radio);
680         return 0;
681 }
682
683 static int __init dsbr100_init(void)
684 {
685         int retval = usb_register(&usb_dsbr100_driver);
686         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
687                DRIVER_DESC "\n");
688         return retval;
689 }
690
691 static void __exit dsbr100_exit(void)
692 {
693         usb_deregister(&usb_dsbr100_driver);
694 }
695
696 module_init (dsbr100_init);
697 module_exit (dsbr100_exit);
698
699 MODULE_AUTHOR( DRIVER_AUTHOR );
700 MODULE_DESCRIPTION( DRIVER_DESC );
701 MODULE_LICENSE("GPL");