firmware/usb.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include "config.h"
  20 #include "cpu.h"
  21 #include "kernel.h"
  22 #include "thread.h"
  23 #include "system.h"
  24 #include "debug.h"
  25 #include "ata.h"
  26 #include "fat.h"
  27 #include "disk.h"
  28 #include "panic.h"
  29 #include "lcd.h"
  30 #include "adc.h"
  31 #include "usb.h"
  32 #include "button.h"
  33 #include "sprintf.h"
  34 #include "hwcompat.h"
  35 #ifdef HAVE_MMC
  36 #include "ata_mmc.h"
  37 #endif
  38
  39 extern void dbg_ports(void); /* NASTY! defined in apps/ */
  40
  41 #ifdef HAVE_LCD_BITMAP
  42 bool do_screendump_instead_of_usb = false;
  43 void screen_dump(void);   /* Nasty again. Defined in apps/ too */
  44 #endif
  45
  46 #define USB_REALLY_BRAVE
  47
  48 #if !defined(SIMULATOR) && !defined(USB_NONE)
  49
  50 /* Messages from usb_tick */
  51 #define USB_INSERTED    1
  52 #define USB_EXTRACTED   2
  53 #ifdef HAVE_MMC
  54 #define USB_REENABLE    3
  55 #endif
  56
  57 /* Thread states */
  58 #define EXTRACTING      1
  59 #define EXTRACTED       2
  60 #define INSERTED        3
  61 #define INSERTING       4
  62
  63 /* The ADC tick reads one channel per tick, and we want to check 3 successive
  64    readings on the USB voltage channel. This doesn't apply to the Player, but
  65    debouncing the USB detection port won't hurt us either. */
  66 #define NUM_POLL_READINGS (NUM_ADC_CHANNELS * 3)
  67 static int countdown;
  68
  69 static int usb_state;
  70
  71 #ifdef HAVE_MMC
  72 static int usb_mmc_countdown = 0;
  73 #endif
  74
  75 /* FIXME: The extra 0x400 is consumed by fat_mount() when the fsinfo
  76    needs updating */
  77 static char usb_stack[DEFAULT_STACK_SIZE + 0x400];
  78 static const char usb_thread_name[] = "usb";
  79 static struct event_queue usb_queue;
  80 static bool last_usb_status;
  81 static bool usb_monitor_enabled;
  82
  83 static void usb_enable(bool on)
  84 {
  85 #ifdef USB_ENABLE_ONDIOSTYLE
  86     PACR2 &= ~0x04C0; /* use PA3, PA5 as GPIO */
  87     if(on)
  88     {
  89 #ifdef HAVE_MMC
  90         mmc_select_clock(mmc_detect() ? 1 : 0);
  91 #endif
  92         if (!(read_hw_mask() & MMC_CLOCK_POLARITY))
  93             and_b(~0x20, &PBDRH); /* old circuit needs SCK1 = low while on USB */
  94         or_b(0x20, &PADRL); /* enable USB */
  95         and_b(~0x08, &PADRL); /* assert card detect */
  96     }
  97     else
  98     {
  99         if (!(read_hw_mask() & MMC_CLOCK_POLARITY))
 100             or_b(0x20, &PBDRH); /* reset SCK1 = high for old circuit */
 101         and_b(~0x20, &PADRL); /* disable USB */
 102         or_b(0x08, &PADRL); /* deassert card detect */
 103     }
 104     or_b(0x28, &PAIORL); /* output for USB enable and card detect */
 105 #else /* standard HD Jukebox */
 106 #ifdef HAVE_LCD_BITMAP
 107     if(read_hw_mask() & USB_ACTIVE_HIGH)
 108         on = !on;
 109 #endif
 110     if(on)
 111     {
 112         and_b(~0x04, &PADRH); /* enable USB */
 113     }
 114     else
 115     {
 116         or_b(0x04, &PADRH);
 117     }
 118     or_b(0x04, &PAIORH);
 119 #endif
 120 }
 121
 122 static void usb_slave_mode(bool on)
 123 {
 124     int rc;
 125
 126     if(on)
 127     {
 128         DEBUGF("Entering USB slave mode\n");
 129         ata_soft_reset();
 130         ata_init();
 131         ata_standby(15);
 132         ata_enable(false);
 133         usb_enable(true);
 134     }
 135     else
 136     {
 137         DEBUGF("Leaving USB slave mode\n");
 138
 139         /* Let the ISDx00 settle */
 140         sleep(HZ*1);
 141
 142         usb_enable(false);
 143
 144         rc = ata_init();
 145         if(rc)
 146         {
 147             /* fixme: can we remove this? (already such in main.c) */
 148             char str[32];
 149             lcd_clear_display();
 150             snprintf(str, 31, "ATA error: %d", rc);
 151             lcd_puts(0, 0, str);
 152             lcd_puts(0, 1, "Press ON to debug");
 153             lcd_update();
 154             while(!(button_get(true) & BUTTON_REL)) {};
 155             dbg_ports();
 156             panicf("ata: %d",rc);
 157         }
 158
 159         rc = disk_mount_all();
 160         if (rc <= 0) /* no partition */
 161             panicf("mount: %d",rc);
 162
 163     }
 164 }
 165
 166 static void usb_thread(void)
 167 {
 168     int num_acks_to_expect = -1;
 169     bool waiting_for_ack;
 170     struct event ev;
 171
 172     waiting_for_ack = false;
 173
 174     while(1)
 175     {
 176         queue_wait(&usb_queue, &ev);
 177         switch(ev.id)
 178         {
 179             case USB_INSERTED:
 180 #ifdef HAVE_LCD_BITMAP
 181                 if(do_screendump_instead_of_usb)
 182                 {
 183                     screen_dump();
 184                 }
 185                 else
 186                 {
 187 #endif
 188                     /* Tell all threads that they have to back off the ATA.
 189                        We subtract one for our own thread. */
 190                     num_acks_to_expect =
 191                         queue_broadcast(SYS_USB_CONNECTED, NULL) - 1;
 192                     waiting_for_ack = true;
 193                     DEBUGF("USB inserted. Waiting for ack from %d threads...\n",
 194                            num_acks_to_expect);
 195 #ifdef HAVE_LCD_BITMAP
 196                 }
 197 #endif
 198                 break;
 199
 200             case SYS_USB_CONNECTED_ACK:
 201                 if(waiting_for_ack)
 202                 {
 203                     num_acks_to_expect--;
 204                     if(num_acks_to_expect == 0)
 205                     {
 206                         DEBUGF("All threads have acknowledged the connect.\n");
 207 #ifdef USB_REALLY_BRAVE
 208                         usb_slave_mode(true);
 209                         usb_state = USB_INSERTED;
 210 #else
 211                         system_reboot();
 212 #endif
 213                     }
 214                     else
 215                     {
 216                         DEBUGF("usb: got ack, %d to go...\n",
 217                                num_acks_to_expect);
 218                     }
 219                 }
 220                 break;
 221
 222             case USB_EXTRACTED:
 223 #ifdef HAVE_LCD_BITMAP
 224                 if(!do_screendump_instead_of_usb)
 225                 {
 226 #endif
 227                     if(usb_state == USB_INSERTED)
 228                     {
 229                         /* Only disable the USB mode if we really have enabled it
 230                            some threads might not have acknowledged the
 231                            insertion */
 232                         usb_slave_mode(false);
 233                     }
 234
 235                     usb_state = USB_EXTRACTED;
 236
 237                     /* Tell all threads that we are back in business */
 238                     num_acks_to_expect =
 239                         queue_broadcast(SYS_USB_DISCONNECTED, NULL) - 1;
 240                     waiting_for_ack = true;
 241                     DEBUGF("USB extracted. Waiting for ack from %d threads...\n",
 242                            num_acks_to_expect);
 243 #ifdef HAVE_LCD_CHARCELLS
 244                     lcd_icon(ICON_USB, false);
 245 #endif
 246 #ifdef HAVE_LCD_BITMAP
 247                 }
 248 #endif
 249                 break;
 250
 251             case SYS_USB_DISCONNECTED_ACK:
 252                 if(waiting_for_ack)
 253                 {
 254                     num_acks_to_expect--;
 255                     if(num_acks_to_expect == 0)
 256                     {
 257                         DEBUGF("All threads have acknowledged. "
 258                                "We're in business.\n");
 259                     }
 260                     else
 261                     {
 262                         DEBUGF("usb: got ack, %d to go...\n",
 263                                num_acks_to_expect);
 264                     }
 265                 }
 266                 break;
 267
 268 #ifdef HAVE_MMC
 269             case SYS_MMC_INSERTED:
 270             case SYS_MMC_EXTRACTED:
 271                 if(usb_state == USB_INSERTED)
 272                 {
 273                     usb_enable(false);
 274                     usb_mmc_countdown = HZ/2; /* re-enable after 0.5 sec */
 275                 }
 276                 break;
 277
 278             case USB_REENABLE:
 279                 if(usb_state == USB_INSERTED)
 280                     usb_enable(true);  /* reenable only if still inserted */
 281                 break;
 282 #endif
 283         }
 284     }
 285 }
 286
 287 bool usb_detect(void)
 288 {
 289     bool current_status;
 290
 291 #ifdef USB_RECORDERSTYLE
 292     current_status = (adc_read(ADC_USB_POWER) > 500)?true:false;
 293 #endif
 294 #ifdef USB_FMRECORDERSTYLE
 295     current_status = (adc_read(ADC_USB_POWER) <= 512)?true:false;
 296 #endif
 297 #ifdef USB_PLAYERSTYLE
 298     current_status = (PADR & 0x8000)?false:true;
 299 #endif
 300 #ifdef IRIVER_H100
 301     current_status = (GPIO1_READ & 0x80)?true:false;
 302 #endif
 303     return current_status;
 304 }
 305
 306
 307 static void usb_tick(void)
 308 {
 309     bool current_status;
 310
 311     if(usb_monitor_enabled)
 312     {
 313         current_status = usb_detect();
 314
 315         /* Only report when the status has changed */
 316         if(current_status != last_usb_status)
 317         {
 318             last_usb_status = current_status;
 319             countdown = NUM_POLL_READINGS;
 320         }
 321         else
 322         {
 323             /* Count down until it gets negative */
 324             if(countdown >= 0)
 325                 countdown--;
 326
 327             /* Report to the thread if we have had 3 identical status
 328                readings in a row */
 329             if(countdown == 0)
 330             {
 331                 if(current_status)
 332                     queue_post(&usb_queue, USB_INSERTED, NULL);
 333                 else
 334                     queue_post(&usb_queue, USB_EXTRACTED, NULL);
 335             }
 336         }
 337     }
 338 #ifdef HAVE_MMC
 339     if(usb_mmc_countdown > 0)
 340     {
 341         usb_mmc_countdown--;
 342         if (usb_mmc_countdown == 0)
 343             queue_post(&usb_queue, USB_REENABLE, NULL);
 344     }
 345 #endif
 346 }
 347
 348 void usb_acknowledge(int id)
 349 {
 350     queue_post(&usb_queue, id, NULL);
 351 }
 352
 353 void usb_init(void)
 354 {
 355     usb_state = USB_EXTRACTED;
 356     usb_monitor_enabled = false;
 357     countdown = -1;
 358
 359 #ifdef IRIVER_H100
 360     GPIO1_FUNCTION |= 0x80; /* GPIO39 is the USB detect input */
 361 #endif
 362
 363     usb_enable(false);
 364
 365     /* We assume that the USB cable is extracted */
 366     last_usb_status = false;
 367
 368     queue_init(&usb_queue);
 369     create_thread(usb_thread, usb_stack, sizeof(usb_stack), usb_thread_name);
 370
 371     tick_add_task(usb_tick);
 372 }
 373
 374 void usb_wait_for_disconnect(struct event_queue *q)
 375 {
 376     struct event ev;
 377
 378     /* Don't return until we get SYS_USB_DISCONNECTED */
 379     while(1)
 380     {
 381         queue_wait(q, &ev);
 382         if(ev.id == SYS_USB_DISCONNECTED)
 383         {
 384             usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 385             return;
 386         }
 387     }
 388 }
 389
 390 int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks)
 391 {
 392     struct event ev;
 393
 394     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
 395     while(1)
 396     {
 397         queue_wait_w_tmo(q, &ev, ticks);
 398         switch(ev.id)
 399         {
 400             case SYS_USB_DISCONNECTED:
 401                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 402                 return 0;
 403                 break;
 404             case SYS_TIMEOUT:
 405                 return 1;
 406                 break;
 407         }
 408     }
 409 }
 410
 411 void usb_start_monitoring(void)
 412 {
 413     usb_monitor_enabled = true;
 414 }
 415
 416 bool usb_inserted(void)
 417 {
 418     return usb_state == USB_INSERTED;
 419 }
 420
 421 #else
 422
 423 #ifdef USB_NONE
 424 bool usb_inserted(void)
 425 {
 426     return false;
 427 }
 428 #endif
 429
 430 /* Dummy simulator functions */
 431 void usb_acknowledge(int id)
 432 {
 433     id = id;
 434 }
 435
 436 void usb_init(void)
 437 {
 438 }
 439
 440 void usb_start_monitoring(void)
 441 {
 442 }
 443
 444 bool usb_detect(void)
 445 {
 446     return false;
 447 }
 448
 449 #endif /* USB_NONE or SIMULATOR */