The Tor Browser: hal/gonk/GonkFMRadio.cpp@97036ab72558 (annotated)

hal/gonk/GonkFMRadio.cpp@97036ab72558 (annotated)

hal/gonk/GonkFMRadio.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* Copyright 2012 Mozilla Foundation and Mozilla contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include "Hal.h"
 #include "tavarua.h"
 #include "nsThreadUtils.h"
 #include "mozilla/FileUtils.h"
 #include <cutils/properties.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 namespace mozilla {
 namespace hal_impl {
 uint32_t GetFMRadioFrequency();
 static int sRadioFD;
 static bool sRadioEnabled;
 static pthread_t sRadioThread;
 static hal::FMRadioSettings sRadioSettings;
 static int sMsmFMVersion;
 static bool sMsmFMMode;
 static int
 setControl(uint32_t id, int32_t value)
 {
   struct v4l2_control control;
   control.id = id;
   control.value = value;
   return ioctl(sRadioFD, VIDIOC_S_CTRL, &control);
 }
 class RadioUpdate : public nsRunnable {
   hal::FMRadioOperation mOp;
   hal::FMRadioOperationStatus mStatus;
 public:
   RadioUpdate(hal::FMRadioOperation op, hal::FMRadioOperationStatus status)
     : mOp(op)
     , mStatus(status)
   {}
   NS_IMETHOD Run() {
     hal::FMRadioOperationInformation info;
     info.operation() = mOp;
     info.status() = mStatus;
     info.frequency() = GetFMRadioFrequency();
     hal::NotifyFMRadioStatus(info);
     return NS_OK;
   }
 };
 /* Runs on the radio thread */
 static void
 initMsmFMRadio(hal::FMRadioSettings &aInfo)
 {
   mozilla::ScopedClose fd(sRadioFD);
   char version[64];
   int rc;
   snprintf(version, sizeof(version), "%d", sMsmFMVersion);
   property_set("hw.fm.version", version);
   /* Set the mode for soc downloader */
   property_set("hw.fm.mode", "normal");
   /* start fm_dl service */
   property_set("ctl.start", "fm_dl");
   /*
    * Fix bug 800263. Wait until the FM radio chips initialization is done
    * then set other properties, or the system will hang and reboot. This
    * work around is from codeaurora
    * (git://codeaurora.org/platform/frameworks/base.git).
    */
   for (int i = 0; i < 4; ++i) {
     sleep(1);
     char value[PROPERTY_VALUE_MAX];
     property_get("hw.fm.init", value, "0");
     if (!strcmp(value, "1")) {
       break;
     }
   }
   rc = setControl(V4L2_CID_PRIVATE_TAVARUA_STATE, FM_RECV);
   if (rc < 0) {
     HAL_LOG(("Unable to turn on radio |%s|", strerror(errno)));
     return;
   }
   int preEmphasis = aInfo.preEmphasis() <= 50;
   rc = setControl(V4L2_CID_PRIVATE_TAVARUA_EMPHASIS, preEmphasis);
   if (rc) {
     HAL_LOG(("Unable to configure preemphasis"));
     return;
   }
   rc = setControl(V4L2_CID_PRIVATE_TAVARUA_RDS_STD, 0);
   if (rc) {
     HAL_LOG(("Unable to configure RDS"));
     return;
   }
   int spacing;
   switch (aInfo.spaceType()) {
   case 50:
     spacing = FM_CH_SPACE_50KHZ;
     break;
   case 100:
     spacing = FM_CH_SPACE_100KHZ;
     break;
   case 200:
     spacing = FM_CH_SPACE_200KHZ;
     break;
   default:
     HAL_LOG(("Unsupported space value - %d", aInfo.spaceType()));
     return;
   }
   rc = setControl(V4L2_CID_PRIVATE_TAVARUA_SPACING, spacing);
   if (rc) {
     HAL_LOG(("Unable to configure spacing"));
     return;
   }
   /*
    * Frequency conversions
    *
    * HAL uses units of 1k for frequencies
    * V4L2 uses units of 62.5kHz
    * Multiplying by (10000 / 625) converts from HAL units to V4L2.
    */
   struct v4l2_tuner tuner = {0};
   tuner.rangelow = (aInfo.lowerLimit() * 10000) / 625;
   tuner.rangehigh = (aInfo.upperLimit() * 10000) / 625;
   tuner.audmode = V4L2_TUNER_MODE_STEREO;
   rc = ioctl(fd, VIDIOC_S_TUNER, &tuner);
   if (rc < 0) {
     HAL_LOG(("Unable to adjust band limits"));
     return;
   }
   rc = setControl(V4L2_CID_PRIVATE_TAVARUA_REGION, TAVARUA_REGION_OTHER);
   if (rc < 0) {
     HAL_LOG(("Unable to configure region"));
     return;
   }
   // Some devices do not support analog audio routing. This should be
   // indicated by the 'ro.moz.fm.noAnalog' property at build time.
   char propval[PROPERTY_VALUE_MAX];
   property_get("ro.moz.fm.noAnalog", propval, "");
   bool noAnalog = !strcmp(propval, "true");
   rc = setControl(V4L2_CID_PRIVATE_TAVARUA_SET_AUDIO_PATH,
                   noAnalog ? FM_DIGITAL_PATH : FM_ANALOG_PATH);
   if (rc < 0) {
     HAL_LOG(("Unable to set audio path"));
     return;
   }
   if (!noAnalog) {
     /* Set the mode for soc downloader */
     property_set("hw.fm.mode", "config_dac");
     /* Use analog mode FM */
     property_set("hw.fm.isAnalog", "true");
     /* start fm_dl service */
     property_set("ctl.start", "fm_dl");
     for (int i = 0; i < 4; ++i) {
       sleep(1);
       char value[PROPERTY_VALUE_MAX];
       property_get("hw.fm.init", value, "0");
       if (!strcmp(value, "1")) {
         break;
       }
     }
   }
   fd.forget();
   sRadioEnabled = true;
 }
 /* Runs on the radio thread */
 static void *
 runMsmFMRadio(void *)
 {
   initMsmFMRadio(sRadioSettings);
   if (!sRadioEnabled) {
     NS_DispatchToMainThread(new RadioUpdate(hal::FM_RADIO_OPERATION_ENABLE,
                                             hal::FM_RADIO_OPERATION_STATUS_FAIL));
     return nullptr;
   }
   uint8_t buf[128];
   struct v4l2_buffer buffer = {0};
   buffer.index = 1;
   buffer.type = V4L2_BUF_TYPE_PRIVATE;
   buffer.length = sizeof(buf);
   buffer.m.userptr = (long unsigned int)buf;
   while (sRadioEnabled) {
     if (ioctl(sRadioFD, VIDIOC_DQBUF, &buffer) < 0) {
       if (errno == EINTR)
         continue;
       break;
     }
     /* The tavarua driver reports a number of things asynchronously.
      * In those cases, the status update comes from this thread. */
     for (unsigned int i = 0; i < buffer.bytesused; i++) {
       switch (buf[i]) {
       case TAVARUA_EVT_RADIO_READY:
         // The driver sends RADIO_READY both when we turn the radio on and when we turn
         // the radio off.
         if (sRadioEnabled) {
           NS_DispatchToMainThread(new RadioUpdate(hal::FM_RADIO_OPERATION_ENABLE,
                                                   hal::FM_RADIO_OPERATION_STATUS_SUCCESS));
         }
         break;
       case TAVARUA_EVT_SEEK_COMPLETE:
         NS_DispatchToMainThread(new RadioUpdate(hal::FM_RADIO_OPERATION_SEEK,
                                                 hal::FM_RADIO_OPERATION_STATUS_SUCCESS));
         break;
       case TAVARUA_EVT_TUNE_SUCC:
         NS_DispatchToMainThread(new RadioUpdate(hal::FM_RADIO_OPERATION_TUNE,
                                                 hal::FM_RADIO_OPERATION_STATUS_SUCCESS));
         break;
       default:
         break;
       }
     }
   }
   return nullptr;
 }
 /* This runs on the main thread but most of the
  * initialization is pushed to the radio thread. */
 void
 EnableFMRadio(const hal::FMRadioSettings& aInfo)
 {
   if (sRadioEnabled) {
     HAL_LOG(("Radio already enabled!"));
     return;
   }
   mozilla::ScopedClose fd(open("/dev/radio0", O_RDWR));
   if (fd < 0) {
     HAL_LOG(("Unable to open radio device"));
     return;
   }
   struct v4l2_capability cap;
   int rc = ioctl(fd, VIDIOC_QUERYCAP, &cap);
   if (rc < 0) {
     HAL_LOG(("Unable to query radio device"));
     return;
   }
   sMsmFMMode = !strcmp((char *)cap.driver, "radio-tavarua") ||
       !strcmp((char *)cap.driver, "radio-iris");
   HAL_LOG(("Radio: %s (%s)\n", cap.driver, cap.card));
   if (!(cap.capabilities & V4L2_CAP_RADIO)) {
     HAL_LOG(("/dev/radio0 isn't a radio"));
     return;
   }
   if (!(cap.capabilities & V4L2_CAP_TUNER)) {
     HAL_LOG(("/dev/radio0 doesn't support the tuner interface"));
     return;
   }
   sRadioSettings = aInfo;
   if (sMsmFMMode) {
     sRadioFD = fd.forget();
     sMsmFMVersion = cap.version;
     pthread_create(&sRadioThread, nullptr, runMsmFMRadio, nullptr);
     return;
   }
   struct v4l2_tuner tuner = {0};
   tuner.type = V4L2_TUNER_RADIO;
   tuner.rangelow = (aInfo.lowerLimit() * 10000) / 625;
   tuner.rangehigh = (aInfo.upperLimit() * 10000) / 625;
   tuner.audmode = V4L2_TUNER_MODE_STEREO;
   rc = ioctl(fd, VIDIOC_S_TUNER, &tuner);
   if (rc < 0) {
     HAL_LOG(("Unable to adjust band limits"));
   }
   sRadioFD = fd.forget();
   sRadioEnabled = true;
   hal::FMRadioOperationInformation info;
   info.operation() = hal::FM_RADIO_OPERATION_ENABLE;
   info.status() = hal::FM_RADIO_OPERATION_STATUS_SUCCESS;
   hal::NotifyFMRadioStatus(info);
 }
 void
 DisableFMRadio()
 {
   if (!sRadioEnabled)
     return;
   sRadioEnabled = false;
   if (sMsmFMMode) {
     int rc = setControl(V4L2_CID_PRIVATE_TAVARUA_STATE, FM_OFF);
     if (rc < 0) {
       HAL_LOG(("Unable to turn off radio"));
     }
     pthread_join(sRadioThread, nullptr);
   }
   close(sRadioFD);
   hal::FMRadioOperationInformation info;
   info.operation() = hal::FM_RADIO_OPERATION_DISABLE;
   info.status() = hal::FM_RADIO_OPERATION_STATUS_SUCCESS;
   hal::NotifyFMRadioStatus(info);
 }
 void
 FMRadioSeek(const hal::FMRadioSeekDirection& aDirection)
 {
   struct v4l2_hw_freq_seek seek = {0};
   seek.type = V4L2_TUNER_RADIO;
   seek.seek_upward = aDirection == hal::FMRadioSeekDirection::FM_RADIO_SEEK_DIRECTION_UP;
   /* ICS and older don't have the spacing field */
 #if ANDROID_VERSION == 15
   seek.reserved[0] = sRadioSettings.spaceType() * 1000;
 #else
   seek.spacing = sRadioSettings.spaceType() * 1000;
 #endif
   int rc = ioctl(sRadioFD, VIDIOC_S_HW_FREQ_SEEK, &seek);
   if (sMsmFMMode && rc >= 0)
     return;
   hal::FMRadioOperationInformation info;
   info.operation() = hal::FM_RADIO_OPERATION_SEEK;
   info.status() = rc < 0 ? hal::FM_RADIO_OPERATION_STATUS_FAIL :
                            hal::FM_RADIO_OPERATION_STATUS_SUCCESS;
   hal::NotifyFMRadioStatus(info);
   if (rc < 0) {
     HAL_LOG(("Could not initiate hardware seek"));
     return;
   }
   info.operation() = hal::FM_RADIO_OPERATION_TUNE;
   info.status() = hal::FM_RADIO_OPERATION_STATUS_SUCCESS;
   hal::NotifyFMRadioStatus(info);
 }
 void
 GetFMRadioSettings(hal::FMRadioSettings* aInfo)
 {
   if (!sRadioEnabled) {
     return;
   }
   struct v4l2_tuner tuner = {0};
   int rc = ioctl(sRadioFD, VIDIOC_G_TUNER, &tuner);
   if (rc < 0) {
     HAL_LOG(("Could not query fm radio for settings"));
     return;
   }
   aInfo->upperLimit() = (tuner.rangehigh * 625) / 10000;
   aInfo->lowerLimit() = (tuner.rangelow * 625) / 10000;
 }
 void
 SetFMRadioFrequency(const uint32_t frequency)
 {
   struct v4l2_frequency freq = {0};
   freq.type = V4L2_TUNER_RADIO;
   freq.frequency = (frequency * 10000) / 625;
   int rc = ioctl(sRadioFD, VIDIOC_S_FREQUENCY, &freq);
   if (rc < 0)
     HAL_LOG(("Could not set radio frequency"));
   if (sMsmFMMode && rc >= 0)
     return;
   hal::FMRadioOperationInformation info;
   info.operation() = hal::FM_RADIO_OPERATION_TUNE;
   info.status() = rc < 0 ? hal::FM_RADIO_OPERATION_STATUS_FAIL :
                            hal::FM_RADIO_OPERATION_STATUS_SUCCESS;
   hal::NotifyFMRadioStatus(info);
 }
 uint32_t
 GetFMRadioFrequency()
 {
   if (!sRadioEnabled)
     return 0;
   struct v4l2_frequency freq;
   int rc = ioctl(sRadioFD, VIDIOC_G_FREQUENCY, &freq);
   if (rc < 0) {
     HAL_LOG(("Could not get radio frequency"));
     return 0;
   }
   return (freq.frequency * 625) / 10000;
 }
 bool
 IsFMRadioOn()
 {
   return sRadioEnabled;
 }
 uint32_t
 GetFMRadioSignalStrength()
 {
   struct v4l2_tuner tuner = {0};
   int rc = ioctl(sRadioFD, VIDIOC_G_TUNER, &tuner);
   if (rc < 0) {
     HAL_LOG(("Could not query fm radio for signal strength"));
     return 0;
   }
   return tuner.signal;
 }
 void
 CancelFMRadioSeek()
 {}
 } // hal_impl
 } // namespace mozilla

The Tor Browser / annotate

hal/gonk/GonkFMRadio.cpp@97036ab72558 (annotated)

hal/gonk/GonkFMRadio.cpp