Frost's Blog

(ios)Scroll View Auto Layout

2015-12-21T14:43:00.004+08:00

解決Scroll View Auto Layout的warring issue,
原則上Scroll View裡面只能放一個View,
故拉一個UIView等同scroll view的寬＆高

(ios)move TableView cell

2015-11-21T03:42:00.002+08:00

http://www.raywenderlich.com/63089/cookbook-moving-table-view-cells-with-a-long-press-gesture

http://www.cnblogs.com/iCocos/p/4674721.html

http://stackoverflow.com/questions/6097464/reordering-controls-on-uitableview-while-not-in-editing-mode

[iOS] NSOperation & NSOperation Queue

2015-11-03T11:25:00.002+08:00

NSOperation:

1. NSInvocationOperation

ex:

NSInvocationOperation *invacationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomethingWithObj:) object:obj];

get result:

id result = [invacationOperation result];

2. NSBlockOperation

ex:

NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:

//do something

}];

3. 自定義（繼承）NSOperation

- NSInvocationOperation & NSBlockOperation 兩者實際上無太大差別

- Start & Cancel 一個 Operation

[operation start];

[operation cancel];

- 設置Operation的completionBlock:

completionBlock實現原理是對Operation的isFinnshed字段進行KVO（Key-Value Observing），當監聽到isFinnished變成YES时，就执行completionBlock。

operation.completionBlock =

NSLog(@"finished");

};

NSOperationQueue:

NSOperationQueue是一个Operation执行队列，你可以将任何你想要执行的Operation添加到Operation Queue中，以在队列中执行。'

- Operation的依賴關係:

[operation addDependency:anotherOperation];

[operation removeDependency:anotherOperation];

如果将这些Operation和它所依赖的Operation加如队列中，那么Operation只有在它依赖的Operation都执行完毕后才可以被执行。

- Operation在队列中执行的优先级:

Operation在队列中默认是按FIFO（First In First Out）顺序执行的。同时我们可以为单个的Operation设置一个执行的优先级，打乱这个顺序。

- 最大並行Operation數目：

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

queue.maxConcurrentOperationCount = 1;

* 實驗結果：區域變數中的NSBlockOperation 須先經過init, 才能在其他function中被cancel.

ex:

NSBlockOperation *op2 = [[NSBlockOperation alloc] init];

__weak NSBlockOperation *weakOperation = op2;

[op2 addExecutionBlock:

//while (true)

for(int i = 0; i<30; i++)

{

NSLog(@"op2 %@", op2);

if ([op2 isCancelled])

{

return;

}

[NSThread sleepForTimeInterval:1];

}

}];

[iOS] GCD - dispatch

2015-10-29T16:20:00.000+08:00

Queues Types:

- Serial Queues

Tasks in serial queues execute one at a time, each task starting only after the preceding task has finished.

- Concurrent Queues

Tasks in concurrent queues are guaranteed to start in the order they were added,
Items can finish in any order and you have no knowledge of the time it will take for the next block to start, nor the number of blocks that are running at any given time.
- Main Queues

Like any serial queue, tasks in this queue execute one at a time. However, it’s guaranteed that all tasks will execute on the main thread, which is the only thread allowed to update your UI. This queue is the one to use for sending messages to UIViews or posting notifications.

- Examples:

 //  background執行：
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // something
 });

 // main thread執行：
 dispatch_async(dispatch_get_main_queue(), ^{
      // something
 });

 // 一次性執行：
 static dispatch_once_t onceToken;
 dispatch_once(&onceToken, ^{
     // code to be executed once
 });

 // delay 2 秒執行：
 double delayInSeconds = 2.0;
 dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
 dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
     // code to be executed on the main queue after delay
 });

// 自定義Queue (Serial Queue)

dispatch_queue_t urls_queue = dispatch_queue_create("blog.devtang.com", NULL); dispatch_async(urls_queue, ^{ // your code }); dispatch_release(urls_queue);

- dispatch_group：

GCD 还有一些高级用法，例如让后台 2 个线程并行执行，然后等 2 个线程都结束后，再汇总执行结果。这个可以用 dispatch_group, dispatch_group_async 和 dispatch_group_notify 来实现，示例如下：

dispatch_group_t group = dispatch_group_create(); dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{ // 並行執行的 Thread 1 }); dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{ // 並行執行的 Thread 2 }); dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{ // thread 1 & 2 完成後執行 });

[iOS] Auto Layout - NSLayoutConstraint

2015-10-29T10:14:00.000+08:00

Object - C:

NSMutableArray *myConstraints = [NSMutableArray array];

NSDictionary *variableBindings = @{@"_btn_cancel" : _btn_cancel};

NSDictionary *metrics = @{@"height": 100,

@"margin": 10};

// ex1: 從水平方向佈局

[myConstraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat:

@"H:|-margin-[_btn_cancel(height)]-|"

options:NSLayoutFormatDirectionLeadingToTrailing

metrics:metrics

views:variableBindings]];

//ex2: 從垂直方向佈局

[myConstraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat:

@"V:[ViewB(ViewA)]-|"

options:NSLayoutFormatDirectionLeadingToTrailing

metrics:nil

views:NSDictionaryOfVariableBindings(ViewB,ViewA)]];

[self.view addConstraints:myConstraints];

參數說明：

options: 佈局時的順序，預設是由上而下（垂直）與由左而右（水平)

metrics : 一般为nil ，参数类型为NSDictionary, 為要傳入的變數

views ：参数类型为NSDictionary, 為要傳入的Views

語法：

＊ " V: " 和 " H: "

分別代表由垂直或是水平方向來佈局。

＊" | "

代表 Superview 的邊界。

＊" - "

代表預設距離，例如在中間加上數字 " -20- "，則代表限制 20 個單位距離。

＊" [ ] "

代表物件本身，括號內包含物件的變數名稱與大小限制，可以使用關係運算子（<＝、>＝或＝＝等）。

＊ " @ "

優先權，1 至 1000 的整數，優先權較大的條件會優先被滿足，例如，[ViewB(>=100@1000)]，物件 ViewB 不可以小於 100 個單位長度或寬度會最優先被考慮。

Intent呼叫第三方程式 (setComponent)

2012-04-16T14:23:00.000+08:00

Intent呼叫第三方程式 (setComponent)

資料來源:http://slashgill.blogspot.com/2010/10/intent.html

只要利用adb logcat ，再搭配使用setComponet()，就可以輕易的呼叫第三方程式(不在自己的application內)。
詳細用法參考原文:
http://developer.android.com/reference/android/content/Intent.html#setComponent%28android.content.ComponentName%29

比如我自己的程式想執行Android裡面的Settings，先用adb logcat看系統是如何呼叫Settings的

I/ActivityManager(   60): Starting activity: Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.android.settings/.Settings }
I/ActivityManager(   60): Displayed activity com.android.settings/.Settings: 1205 ms (total 1205 ms)

只要有這個cmp就可以呼叫Settings了

public class Main extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent i = new Intent();
        ComponentName comp = new ComponentName("com.android.settings", "com.android.settings.Settings");
        i.setComponent(comp);
        startActivity(i);
    }
}

另外有些程式要被執行，Intent還要多加搭配Intent.setData()或者是Intent.setAction()等方式。比如:想要開啟Browser，而且是開啟tw.yahoo.com的網頁，程式碼如下:
        Intent i = new Intent();
       ComponentName comp = new ComponentName("com.android.browser", "com.android.browser.BrowserActivity");
       i.setComponent(comp);
       Uri uri = Uri.parse("http://tw.yahoo.com");
       i.setData(uri);
       startActivity(i);

出處
http://blog.xuite.net/ffc99a3b/ooxx/45834263-%5B%E8%BD%89%E8%BC%89%5D+Intent%E5%91%BC%E5%8F%AB%E7%AC%AC%E4%B8%89%E6%96%B9%E7%A8%8B%E5%BC%8F+(setComponent)+

2012-04-10T13:56:00.001+08:00

http://www.androidla.net/index.php/2011/05/19/android-socket-tcpudp/

http://www.cnblogs.com/harrisonpc/archive/2011/03/31/2001565.html

http://hi.baidu.com/gk14/blog/item/a25c0e463fbc1a056a63e52c.html

http://blog.xuite.net/ffc99a3b/ooxx/42960121-%5B%E8%BD%89%E8%BC%89%5DAndroid+UDP+Broadcast+Socket

http://blog.sina.com.cn/s/blog_6c0a8fbb0100s3k5.html#

receiver

2012-04-02T15:22:00.002+08:00

可以在代码文件中声明一个receiver，也可以在manifest中声明一个，前者中的receiver只有在该activity launch起来以后才会监听其所感兴趣的文件，而如果在androidManifext.xml中声明的话，就不受限制，随时可以监听感兴趣的事件。

首先谈谈在androidManifext.xml中注册一个receiver, 例如我们想监听相机按钮按下事件的发生，并且发生后调用我们的camera程序

<receiver android:name="CameraButtonIntentReceiver">
<intent-filter>
<action android:name="android.intent.action.CAMERA_BUTTON"/>
</intent-filter>
</receiver>

复制代码

在这个配置文件中声明了一个receiver用来监听相机的按键事件，所以还需要在代码文件定义与配置文件中同名的receiver：

public class CameraButtonIntentReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
Intent i = new Intent(Intent.ACTION_MAIN);
i.setClass(context, Camera.class);
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(i);
}
}

复制代码

关于另外一种，在代码中注册一个receiver,例如我们想在代码文件中监听电池电量的变化，就可以按照如下方法

private final BroadcastReceiver mBatteryReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
…
}
}
}

复制代码

这种方法需要在onCreate 或者onStart中注册该receiver所感兴趣的intent,如：

registerReceiver(mBatteryReceiver, Intent.ACTION_BATTERY_CHANGED);

复制代码

在onStop及onDestroy中注销监听

registerReceiver(mBatteryReceiver, Intent.ACTION_BATTERY_CHANGED);

复制代码

[Android] Incorporating Google AdMob Ads into your app

2012-04-02T10:41:00.002+08:00

Incorporating Google AdMob Ads into your app is a three step process:

Add the SDK JAR to your Eclipse project.
Declare com.google.ads.AdActivity in AndroidManifest.xml.
Set up required network permissions in the manifest.

Adding the SDK JAR

The decompressed SDK consists of a JAR, a javadoc folder and a README.

1. Right click on your app project in Eclipse and choose Properties.

2. Select Java Build Path and the Libraries tab. Then click Add External JARs... to add the Google AdMob Ads JAR.

com.google.ads.AdActivity

The AdMob Ads SDK requires that com.google.ads.AdActivity be declared in your app's AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" 
          package="com.company" 
          android:versionCode="1" android:versionName="1.0"> 
  <application android:icon="@drawable/icon" android:label="@string/app_name" 
               android:debuggable="true"> 
    <activity android:label="@string/app_name" android:name="BannerExample"> 
      <intent-filter> 
        <action android:name="android.intent.action.MAIN"/> 
        <category android:name="android.intent.category.LAUNCHER"/> 
      </intent-filter> 
    </activity> 
    <activity android:name="com.google.ads.AdActivity" 
              android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize"/> 
  </application> </manifest>

Permissions

Making ad requests requires the networking permissions INTERNET and ACCESS_NETWORK_STATE, so these must also be declared in the manifest:

<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" 
          package="com.company" 
          android:versionCode="1" android:versionName="1.0"> 
  <application android:icon="@drawable/icon" android:label="@string/app_name" 
               android:debuggable="true"> 
    <activity android:label="@string/app_name" android:name="BannerExample"> 
      <intent-filter> 
        <action android:name="android.intent.action.MAIN"/> 
        <category android:name="android.intent.category.LAUNCHER"/> 
      </intent-filter> 
    </activity> 
    <activity android:name="com.google.ads.AdActivity" 
              android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize"/> 
  </application> 
  <uses-permission android:name="android.permission.INTERNET"/> 
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> </manifest>

You should now be able to rebuild your project without any errors.

Adding a com.google.ads.AdView

Android apps are composed of View objects, Java instances the user sees as text areas, buttons and other controls. AdView is simply another View subclass displaying small HTML5 ads that respond to user touch.
Like any View, an AdView may be created either purely in code or largely in XML.
The five lines of code it takes to add a banner:

Import com.google.ads.*
Declare an AdView instance
Create it, specifying a unit ID—your AdMob publisher ID
Add the view to the UI
Load it with an ad

The easiest place to do all this is in your app’s Activity.

import com.google.ads.*; 
 public class BannerExample extends Activity { 
  private AdView adView; 
 
  @Override 
  public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main); 
 
    // Create the adView 
    adView = new AdView(this, AdSize.BANNER, MY_AD_UNIT_ID); 
 
    // Lookup your LinearLayout assuming it’s been given 
    // the attribute android:id="@+id/mainLayout" 
    LinearLayout layout = (LinearLayout)findViewById(R.id.mainLayout); 
 
    // Add the adView to it 
    layout.addView(adView); 
 
    // Initiate a generic request to load it with an ad 
    adView.loadAd(new AdRequest()); 
  } 
 
  @Override 
  public void onDestroy() { 
    if (adView != null) { 
      adView.destroy(); 
    } 
    super.onDestroy(); 
  } }

Warning: Make sure you're in test mode during development to avoid being disabled for clicking your own ads. See the Best Practices guide for more details on enabling test ads.

You can download an example project containing this code here and may alternately create your banner in XML.

The Result

When you now run your app you should see a banner at the top of the screen:

Note: The very first time AdMob sees your publisher ID it may take up to two minutes to receive an ad. This initial two minute lag will recur every time the ID goes unused for 24 hours.

Warning: All new Android apps created after October 14, 2011 will require an AdMob SDK that was released on or after March 15, 2011. This corresponds to version 4.0.2+ for Android. If you downloaded the library from our official download site, then you're already set. Otherwise you may have an old version of the AdMob SDK that was released prior to March 15, 2011, and your new app will not receive any ad impressions until you update your SDK.

source:

https://developers.google.com/mobile-ads-sdk/docs/android/fundamentals

ComponentName

2012-03-29T17:37:00.004+08:00

Android软件时，常常需要打开系统设置或信息界面，来设置相关系统项或查看系统的相关信息，这时我们就可以使用以下语句来实现：（如打开“无线和网络设置”界面）

　　Intent intent = new Intent("/");
　　ComponentName cm = new ComponentName("com.android.settings","com.android.settings.WirelessSettings");
　　intent.setComponent(cm);
　　intent.setAction("android.intent.action.VIEW");
　　activity.startActivityForResult( intent , 0);
　　经过测试，使用下面字段可以在软件中直接打开相应的系统界面
　　com.android.settings.AccessibilitySettings 辅助功能设置
　　com.android.settings.ActivityPicker 选择活动
　　com.android.settings.ApnSettings APN设置
　　com.android.settings.ApplicationSettings 应用程序设置
　　com.android.settings.BandMode 设置GSM/UMTS波段
　　com.android.settings.BatteryInfo 电池信息
　　com.android.settings.DateTimeSettings 日期和坝上旅游网时间设置
　　com.android.settings.DateTimeSettingsSetupWizard 日期和时间设置
　　com.android.settings.DevelopmentSettings 应用程序设置=》开发设置
　　com.android.settings.DeviceAdminSettings 设备管理器
　　com.android.settings.DeviceInfoSettings 关于手机
　　com.android.settings.Display 显示——设置显示字体大小及预览
　　com.android.settings.DisplaySettings 显示设置
　　com.android.settings.DockSettings 底座设置
　　com.android.settings.IccLockSettings SIM卡锁定设置
　　com.android.settings.InstalledAppDetails 语言和键盘设置
　　com.android.settings.LanguageSettings 语言和键盘设置
　　com.android.settings.LocalePicker 选择手机语言
　　com.android.settings.LocalePickerInSetupWizard 选择手机语言
　　com.android.settings.ManageApplications 已下载（安装）软件列表
　　com.android.settings.MasterClear 恢复出厂设置
　　com.android.settings.MediaFormat 格式化手机闪存
　　com.android.settings.PhysicalKeyboardSettings 设置键盘
　　com.android.settings.PrivacySettings 隐私设置
　　com.android.settings.ProxySelector 代理设置
　　com.android.settings.RadioInfo 手机信息
　　com.android.settings.RunningServices 正在运行的程序（服务）
　　com.android.settings.SecuritySettings 位置和安全设置
　　com.android.settings.Settings 系统设置
　　com.android.settings.SettingsSafetyLegalActivity 安全信息
　　com.android.settings.SoundSettings 声音设置
　　com.android.settings.TestingSettings 测试——显示手机信息、电池信息、使用情况统计、Wifi information、服务信息
　　com.android.settings.TetherSettings 绑定与便携式热点
　　com.android.settings.TextToSpeechSettings 文字转语音设置
　　com.android.settings.UsageStats 使用情况统计
　　com.android.settings.UserDictionarySettings 用户词典
　　com.android.settings.VoiceInputOutputSettings 语音输入与输出设置
　　com.android.settings.WirelessSettings 无线和网络设置

[android] java.lang.reflect.Method.invoke()

2012-03-28T16:17:00.000+08:00

Ex: Class A

public Class A
{
        public void setName(String name)
       {

        }
}

A a = new A();
Class c = Class.forName( "A ");
Method method = c.getMethod( "setName ", new Class[]{String.class});
//從Class c中找到名為setName, 帶一個String參數的methid
method.invoke(a, new Object[]{ "name "});
//調用a的該方法, 參數為"name"的String

以上相當於a.setName( "name ");

[Android] Wifi hotspot API -- JAVA Reflection

2012-03-28T14:17:00.001+08:00

There is no official API, but you can use reflection to handle it. I know some say, it's not recommended, however imho I say, screw it if Google doesn't want to provide an API for whatever reason.
Below is the code of an activity I used in my application, where the user can enable/disable the Wifi AP. When you enable Wifi AP, usually the regular Wifi will be turned off, so after the user disables the Wifi AP again, we'll be activating regular wifi again.
The code sample below is taken from one of my projects, hope you can get the logic there easily. Let me know if you have further questions.
Code is tested on Nexus One 2.2 (and I think also 2.3) as well as on Samsung Galaxy S (2.2).

package com.myapp.android.activity.wifi;
import android.app.ProgressDialog; import android.content.Context; import android.net.wifi.WifiConfiguration; import android.net.wifi.WifiManager; import android.os.AsyncTask; import android.os.Bundle; import android.view.View; import android.view.WindowManager; import android.widget.Button;
import java.lang.reflect.Method;
public class WifiAP extends BaseActivity {

// boolean mIsWifiEnabled = false;
private static final int WIFI_AP_STATE_UNKNOWN = -1;
private static final int WIFI_AP_STATE_DISABLING = 0;
private static final int WIFI_AP_STATE_DISABLED = 1;
private static final int WIFI_AP_STATE_ENABLING = 2;
private static final int WIFI_AP_STATE_ENABLED = 3;
private static final int WIFI_AP_STATE_FAILED = 4;

private final String[] WIFI_STATE_TEXTSTATE = new String[] {
"DISABLING","DISABLED","ENABLING","ENABLED","FAILED"
};

private WifiManager wifi;

@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.wifi);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
|WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
|WindowManager.LayoutParams.FLAG_DIM_BEHIND
);

wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);
}

@Override
public void onResume() {
super.onResume();
updateStatusDisplay();
}

public void toggleWifi(View v) {
boolean wifiApIsOn = getWifiAPState()==WIFI_AP_STATE_ENABLED || getWifiAPState()==WIFI_AP_STATE_ENABLING;
new SetWifiAPTask(!wifiApIsOn,false).execute();
}

public void close(View v) {
boolean wifiApIsOn = getWifiAPState()==WIFI_AP_STATE_ENABLED || getWifiAPState()==WIFI_AP_STATE_ENABLING;
if (wifiApIsOn) {
new SetWifiAPTask(false,true).execute();
} else {
finish();
}
}

/**
* Endable/disable wifi
* @param enabled
* @return WifiAP state
*/
private int setWifiApEnabled(boolean enabled) {
Log.d("WifiAP", "*** setWifiApEnabled CALLED **** " + enabled);
if (enabled && wifi.getConnectionInfo() !=null) {
wifi.setWifiEnabled(false);
try {Thread.sleep(1500);} catch (Exception e) {}
}

//int duration = Toast.LENGTH_LONG;
//String toastText = "MobileAP status: ";
int state = WIFI_AP_STATE_UNKNOWN;
try {
wifi.setWifiEnabled(false);
Method method1 = wifi.getClass().getMethod("setWifiApEnabled",
WifiConfiguration.class, boolean.class);
method1.invoke(wifi, null, enabled); // true
Method method2 = wifi.getClass().getMethod("getWifiApState");
state = (Integer) method2.invoke(wifi);
} catch (Exception e) {
Log.e(WIFI_SERVICE, e.getMessage());
// toastText += "ERROR " + e.getMessage();
}

if (!enabled) {
int loopMax = 10;
while (loopMax>0 && (getWifiAPState()==WIFI_AP_STATE_DISABLING
|| getWifiAPState()==WIFI_AP_STATE_ENABLED
|| getWifiAPState()==WIFI_AP_STATE_FAILED)) {
try {Thread.sleep(500);loopMax--;} catch (Exception e) {}
}
wifi.setWifiEnabled(true);
} else if (enabled) {
int loopMax = 10;
while (loopMax>0 && (getWifiAPState()==WIFI_AP_STATE_ENABLING
|| getWifiAPState()==WIFI_AP_STATE_DISABLED
|| getWifiAPState()==WIFI_AP_STATE_FAILED)) {
try {Thread.sleep(500);loopMax--;} catch (Exception e) {}
}
}

return state;
}

private int getWifiAPState() {
int state = WIFI_AP_STATE_UNKNOWN;
try {
Method method2 = wifi.getClass().getMethod("getWifiApState");
state = (Integer) method2.invoke(wifi);
} catch (Exception e) {}
Log.d("WifiAP", "getWifiAPState.state " + (state==-1?"UNKNOWN":WIFI_STATE_TEXTSTATE[state]));
return state;
}

private void updateStatusDisplay() {

if (getWifiAPState()==WIFI_AP_STATE_ENABLED || getWifiAPState()==WIFI_AP_STATE_ENABLING) {
((Button)findViewById(R.id.btnWifiToggle)).setText("Turn off");
findViewById(R.id.bg).setBackgroundResource(R.drawable.bg_wifi_on);
} else {
((Button)findViewById(R.id.btnWifiToggle)).setText("Turn on");
findViewById(R.id.bg).setBackgroundResource(R.drawable.bg_wifi_off);
}

}

class SetWifiAPTask extends AsyncTask<Void, Void, Void> {

boolean mMode;
boolean mFinish;

public SetWifiAPTask(boolean mode, boolean finish) {
mMode = mode;
mFinish = finish;
}

ProgressDialog d = new ProgressDialog(WifiAP.this);

@Override
protected void onPreExecute() {
super.onPreExecute();
d.setTitle("Turning WiFi AP " + (mMode?"on":"off") + "...");
d.setMessage("...please wait a moment.");
d.show();
}

@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
try {d.dismiss();} catch (IllegalArgumentException e) {};
updateStatusDisplay();
if (mFinish) finish();
}

@Override
protected Void doInBackground(Void... params) {
setWifiApEnabled(mMode);
return null;
}
}

}

出處:
http://stackoverflow.com/questions/7048922/android-2-3-wifi-hotspot-api

[Android] Android Tethering API (froyo or above) --JAVA Reflection

2012-03-28T14:08:00.000+08:00

Android Tethering API (froyo or above)

ConnectivityManager class has tethering API methods but those methods are not visible in SDK.
But tethering methods exists in ConnectivityManager class and they works properly.
I used java reflection the standard java feature.
For using those methods, do as following.

1. Get ConnectivityManager class
Object obj = getSystemService(Context.CONNECTIVITY_SERVICE);

2. Find "tether" method on the object
Method m = obj.getClass().getDeclaredMethod("tether", String.class);

3. Invoke that method: When invoke the method send tethering interface usually 'usb0'
m.invoke(obj, "usb0")

If you want to turn off the tethering connection, you simply invoke the "untether" method in this way.

I hope this information helps you.

出處:

http://tjandroid.blogspot.com/2010/12/enabledisable-usb-tethering.html

[android] disable/enable data connection -- JAVA Reflection

2012-03-28T11:47:00.000+08:00

Starting from 'FROYO' you can use the IConnectivityManager.setMobileDataEnabled() method. It's hidden in API, but can be accessed with reflection. http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/net/ConnectivityManager.java#376
With this method you can change the system setting: 'Settings -> Wireless & network -> Mobile network settings -> Data Enabled'

Code example:

private void setMobileDataEnabled(Context context, boolean enabled) { 
    final ConnectivityManager conman = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); 
    final Class conmanClass = Class.forName(conman.getClass().getName()); 
    final Field iConnectivityManagerField = conmanClass.getDeclaredField("mService"); 
    iConnectivityManagerField.setAccessible(true); 
    final Object iConnectivityManager = iConnectivityManagerField.get(conman); 
    final Class iConnectivityManagerClass = Class.forName(iConnectivityManager.getClass().getName()); 
    final Method setMobileDataEnabledMethod = iConnectivityManagerClass.getDeclaredMethod("setMobileDataEnabled", Boolean.TYPE); 
    setMobileDataEnabledMethod.setAccessible(true); 
 
    setMobileDataEnabledMethod.invoke(iConnectivityManager, enabled); }

Also you need the CHANGE_NETWORK_STATE permission.

<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>

Needless to say that this approach might not work in future android versions. But I guess that applications such as '3G watchdog', 'APNdroid' or 'DataLock' work this way.

出處http://stackoverflow.com/questions/3644144/how-to-disable-mobile-data-on-android

JAVA Reflection

2012-03-28T11:34:00.002+08:00

Reflection 是 Java 程式開發語言的特徵之一，它允許營運中的 Java 程式對自身進行檢查，或者說搜尋 Java 類中各成員的名稱並顯示出來。

考慮下面這個簡單的例子，讓我們看看 reflection 是如何工作的。

DumpMethods.java

import java.lang.reflect.*;

public class DumpMethods {

    public static void main(String args[]) {
        try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
                System.out.println(m[i].toString());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

按如下語句執行︰
java DumpMethods java.util.Stack
它的結果輸出為︰
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)
這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和返回類型。
這個程式使用 Class.forName 載入指定的類，然後調用 getDeclaredMethods 來獲取這個類中定義了的方法列表。
java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。

出處:

http://www.javaworld.com.tw/confluence/display/J2SE/Reflection

Activity的生命週期

2012-02-25T15:15:00.000+08:00

Activity的生命週期

內容說明：Activity的相關應用整理與生命週期說明
資料來源：Android Developers

Activity是讓我們進行某個功能時的畫面，它的產生是採取堆疊制的，越晚出現的畫面放在最上面，一旦最後出現的畫面被關閉，就會開啟倒數第二個畫面，即是我們在操作Android手機時，若按下"返回"鍵，就會回到上一個畫面的意思。

Activity的生命週期如圖所示：

onCreate()
當activity第一次被啟動時呼叫。此時系統會建立activity的畫面，並且可以透過Bundle等物件進行初始化設定（參考「Activity間互相傳值」）。

onStart()
讓activity能被使用者看見。

onResume()
將activity移到堆疊的最上層，讓使用者可以和activity互動。

onPause()
當有簡訊、電話、Toast、AlertDialog等另外一個activity進行時，進入onPause()的狀態，停止對螢幕的存取能力。如果畫面沒有轉移，則回到onResume()；若畫面轉移到新的activity時，則進入onStop()。

onStop()
當使用者看不見此activity的畫面時產生。如果這個activity無法透過返回鍵回復，則進入onDestroy()；反之則繼續停留在Stop狀態，當使用者返回此頁面時，則進入onRestart()。

onRestart()
重新啟動Stop狀態的activity。

onDestroy()
當activity被銷毀時執行。銷毀的原因有幾種：activity不會再被使用、程式呼叫finish()、系統因記憶體不足而銷毀Stop程序。要確認activity是否被銷毀可使用 isFinishing() 方法。
這些控制生命週期的方法可以在Eclipse選單 Source > Override/Implement Methods 中找到。
在正常情況下，記憶會保存使用者輸入的資料，但是在記憶體不足時，系統會銷毀Stop狀態的activity，此時使用者輸入的資料會消失。此外，若是系統設定在程式運行中改變（例如螢幕方向、鍵盤狀態和語言），則activity會立即銷毀並重建（執行onDestroy()後接著執行 onCreate()）。

因此如果我們寫的程式不希望使用者輸入的資料因為種種原因而消失，則必需要在onPause()的時候將資料儲存起來，並且在onCreate()將資料讀出，重新顯示在畫面上。

File System和MTD技术

2012-02-03T16:20:00.003+08:00

本節介紹File System和MTD技術

一 FS

熟知的FS有ext2,3,4.但是這些都是針對磁盤設備的。而ES中一般的存儲設備為Flash，由於Flash的特殊性：

Flash存儲按照Block size進行劃分，而一個BLS一般有幾十K。（對比磁盤的一個簇才512個字節）。這麼大的BLS有什麼壞處呢？很明顯，擦除一個BL就需要花費很長的時間了。
另外，FLASH操作，一次必須針對一個BL，也就是如果我想修改一個字節的話，也必須先擦掉128K。這不是想死嗎？
FLASH每個BL擦寫次數是有限的，例如2百萬次？如果每次都操作同一個BL的話，很快這個BL就會死掉。

所以，針對FLASH的特性，整出了一個Journaling Flash File System(JFFS2，第二版)。它的特點就是：

損耗均衡，也就是每次擦寫都不會停留在一個BL上。例如BL1上寫一個文件，那麼再來一個新文件的時候，FS就不會選擇BL1了，而是選擇BL2。這個技術叫weal leveling:損耗均衡

（apt-get install mtd-tools，下載不少好工具，另外，可見往flash設備寫log，可能會導致flash短命喔）

一些偽文件系統：proc/sysfs，systool工具用來分析sysfs。

ES中常用的FS還有ramfs/rootfs/tmpfs，都是基於內存的FS。這個和前面講的initramfs有什麼關係？實際上這些是基於Initramfs的。

這裡要解釋一下幾個比如容易混淆的東西：

ram disk:這個是一個基於ram的disk，用來模擬block設備的，所以它是建立在一個虛擬的BLOCK設備上的，至於上面的FS用什麼，無所謂.這樣就引起效率等的問題。畢竟你的read等操作還是要傳遞到驅動的，並且如果該設備上構造了一個EXT2 FS的話，還得有相應的ext2-FS模塊。麻煩..
ramfs：這是一個基於內存的FS，而不是一個基於真實設備的FS。ramfs的特點就是用戶可以死勁寫內存，直到把系統內存搞空。
為了控制一下上面這個缺點，引出了tmpfs，可以指定tmpfs的size。（這個又好像和真實設備有點類似，因為真實設備的存儲空間也是有限的）
rootfs是一種特殊的ramfs或者tmpfs（看LK中是否啟用了tmpfs），另外，rootfs是不能被umount的

下面介紹一下如何利用mount loop創建一個虛擬的基於文件的BLOCK設備。

先創建一個全是0的文件，利用dd命令：dd if=/dev/zero of=../fstest bs=1024 count=512 這個解釋如下：從if中拷貝數據到of,每次拷貝字節為1024，拷貝總次數為512. 各位可用十六制工具看看，生成的文件裡邊全是0X00
在這個文件中創建FS，mkfs.ext2fs ../fstest。現在，FS就存在於這個文件了。其實FS也就是一些組織結構，例如superblock,inode等信息
如何把這個帶有FS信息的文件掛載呢？其實也就是如何把這個文件當做一個Block device呢？利用mount的loop選項，mount -t ext2 -o loop fstest /tmp/。這樣這個文件就被當做一個虛擬Block設備掛載到tmp了。

二 MTD技術

MTD全稱是Memory Technology Device，內存技術設備？實際上是一個虛擬設備驅動層，類似Virtual File System。它提供標準API給那些操作Raw Flash的device driver。那麼Flash device和普通的Block device的區別是什麼呢？

普通的BLD只有兩種操作：read和write
而Flash Device有三種操作：read，write和erase，另外，還需要一種wear leveling算法來做損耗均衡

這裡要重點指出的是：

SD/MMC卡、CF（Compact Flash）卡、USB Flash等並不是MTD設備，因為這些設備中已經有一個內置的Flash Translation Layer，這個layer處理erase、wear leveling事情了（這個TL應該是固件中支持的）。所以這些設備直接當做普通的Block Device使用

（上面的描述還是沒能說清楚MTD到底是怎麼用的，以後會結合源碼分析一下）

2.1 內核中啟用MTD支持

這個很簡單，make menuconfig的時候打開就行了，有好幾個選項。

圖1 LK中MTD支持的配置選項

其中：

MTC_CHAR和MTD_BLOCK用來支持CHAR模式和BLOCK模式讀寫MTD設備。這個和普通的char以及block設備意思一樣
最後兩個是在內核中設置一個MTD test驅動。8192K用來設置總大小，第二個128用來設置block size。就是在內核中搞了一個虛擬的Flash設備，用作測試

ES中又如何配置MTD及其相關的東西呢？

為Flash Disk設置分區（也可以整個Device就一個分區。BTW，我一直沒徹底搞清楚分區到底是想幹什麼，這個可能是歷史原因啦....）
設置Flash的類型以及location。Flash設備分為NOR和NAND，本節最後會簡單介紹下二者的區別。
為Flash芯片選擇合適的driver
為LK配置driver

下面先看看分區的設置

可對Flash分區，這裡有一些稍微重要的內容：如何把Flash分區的信息傳遞給LK呢？有兩種方法：

將整個device的分區情況存在一個BLock中，這樣BootLoader啟動的時候，根據這個BLock中的內容建立相應信息等。好像只有Red Boot支持。所以叫RedBoot Partition Table。另外，LK可以識別這種分區，通過CFI（Command Flash Interface）讀取這個分區的信息。
Kernel Command Line Partitioning:通過Kernel啟動的時候傳入參數，不過KL必須配置一下。Command格式如下：

圖2

再看看Driver的Mapping，也就是將MTD和對應的Flash Driver配對...

kernel/drivers/mtd/maps......，以後要分析

Flash芯片本身的Driver呢？

kernel/drivers/mtd/chips，目前比較流行的是CFI接口

三一些參考資料和補充知識

http://www.linux-mtd.infradead.org/

MTD的本意是：

We're working on a generic Linux subsystem for memory devices, especially Flash devices.
The aim of the system is to make it simple to provide a driver for new hardware, by providing a generic interface between the hardware drivers and the upper layers of the system.
Hardware drivers need to know nothing about the storage formats used, such as FTL, FFS2, etc., but will only need to provide simple routines for read, write and erase. Presentation of the device's contents to the user in an appropriate form will be handled by the upper layers of the system.

MTD overview
MTD subsystem (stands for Memory Technology Devices) provides an abstraction layer for raw flash devices. It makes it possible to use the same API when working with different flash types and technologies, e.g. NAND, OneNAND, NOR, AG-AND, ECC'd NOR, etc.
MTD subsystem does not deal with block devices like MMC, eMMC, SD, CompactFlash, etc. These devices are not raw flashes but they have a Flash Translation layer inside, which makes them look like block devices. These devices are the subject of the Linux block subsystem, not MTD. Please, refer to this FAQ section for a short list of the main differences between block and MTD devices. And the raw flash vs. FTL devices UBIFS section discusses this in more details.
MTD subsystem has the following interfaces.

MTD character devices - usually referred to as /dev/mtd0, /dev/mtd1, and so on. These character devices provide I/O access to the raw flash. They support a number of ioctl calls for erasing eraseblocks, marking them as bad or checking if an eraseblock is bad, getting information about MTD devices, etc. /dev/mtdx竟然是char device！！
The sysfs interface is relatively newer and it provides full information about each MTD device in the system. This interface is easily extensible and developers are encouraged to use the sysfs interface instead of older ioctl or /proc/mtd interfaces, when possible.
The /proc/mtd proc file system file provides general MTD information. This is a legacy interface and the sysfs interface provides more information.
MTD subsystem supports bare NAND flashes with software and hardware ECC, OneNAND flashes, CFI (Common Flash Interface) NOR flashes, and other flash types.

Additionally, MTD supports legacy FTL/NFTL "translation layers", M-Systems' DiskOnChip 2000 and Millennium chips, and PCMCIA flashes (pcmciamtd driver). But the corresponding drivers are very old and not maintained very much.

MTD Block Driver:

The mtdblock driver available in the MTD is an archaic tool which emulates block devices on top of MTD devices. It does not even have bad eraseblock handling, so it is not really usable with NAND flashes. And it works by caching a whole flash erase block in RAM, modifying it as requested, then erasing the whole block and writing back the modified. This means that mtdblock does not try to do any optimizations, and that you will lose lots of data in case of power cuts. And last, but not least, mtdblock does not do any wear-leveling.
Often people consider mtdblock as general FTL layer and try to use block-based file systems on top of bare flashes using mtdblock. This is wrong in most cases. In other words, please, do not use mtdblock unless you know exactly what you are doing.There is also a read-only version of this driver which doesn't have the capacity to do the caching and erase/writeback, mainly for use with uCLinux where the extra RAM requirement was considered too large

These are the modules which provide interfaces that can be used directly from userspace. The user modules currently planned include:

Raw character access: A character device which allows direct access to the underlying memory. Useful for creating filesystems on the devices, before using some of the translation drivers below, or for raw storage on infrequently-changed flash, or RAM devices.
Raw block access ：A block device driver which allows you to pretend that the flash is a normal device with sensible sector size. It actually works by caching a whole flash erase block in RAM, modifying it as requested, then erasing the whole block and writing back the modified data.This allows you to use normal filesystems on flash parts. Obviously it's not particularly robust when you are writing to it - you lose a whole erase block's worth of data if your read/modify/erase/rewrite cycle actually goes read/modify/erase/poweroff. But for development, and for setting up filesystems which are actually going to be mounted read-only in production units, it should be fine. There is also a read-only version of this driver which doesn't have the capacity to do the caching and erase/writeback, mainly for use with uCLinux where the extra RAM requirement was considered too large.
Flash Translation Layer (FTL)：NFTL，Block device drivers which implement an FTL/NFTL filesystem on the underlying memory device. FTL is fully functional. NFTL is currently working for both reading and writing, but could probably do with some more field testing before being used on production systems.
Journalling Flash File System, v2：This provides a filesystem directly on the flash, rather than emulating a block device. For more information, see sources.redhat.com.
MTD hardware device drivers

These provide physical access to memory devices, and are not used directly - they are accessed through the user modules above.
On-board memory：Many PC chipsets are incapable of correctly caching system memory above 64M or 512M. A driver exists which allows you to use this memory with the linux-mtd system.
PCMCIA devices：PCMCIA flash (not CompactFlash but real flash) cards are now supported by the pcmciamtd driver in CVS.
Common Flash Interface (CFI) onboard NOR flash：This is a common solution and is well-tested and supported, most often using JFFS2 or cramfs file systems.
Onboard NAND flash：NAND flash is rapidly overtaking NOR flash due to its larger size and lower cost; JFFS2 support for NAND flash is approaching production quality.
M-Systems' DiskOnChip 2000 and Millennium：The DiskOnChip 2000, Millennium and Millennium Plus devices should be fully supported, using their native NFTL and INFTL 'translation layers'. Support for JFFS2 on DiskOnChip 2000 and Millennium is also operational although lacking proper support for bad block handling.

這裡牽扯到NOR和NAND，那麼二者有啥區別呢？

Beside the different silicon cell design, the most important difference between NAND and NOR Flash is the bus interface. NOR Flash is connected to a address / data bus direct like other memory devices as SRAM etc. NAND Flash uses a multiplexed I/O Interface with some additional control pins. NAND flash is a sequential access device appropriate for mass storage applications, while NOR flash is a random access device appropriate for code storage application. NOR Flash can be used for code storage and code execution. Code stored on NAND Flash can't be executed from there. It must be loaded into RAM memory and executed from there.

NOR可以直接和CPU相連，就好像內存一樣。NAND不可以，因為NAND還需要別的一些I/O控制接口。所以NAND更像磁盤，而NOR更像內存
NOR比NAND貴，並且，NAND支持順序讀取，而NOR支持隨機讀取。
所以，NOR中可存儲代碼，這樣CPU直接讀取就在其中運行。NAND不可以（主要還是因為CPU取地址的時候不能直接找到NAND）

Polling, Interrupt-driven I/O, DMA(Direct Memory Access)

2012-02-03T10:16:00.003+08:00

三種將資料在I/O間傳送的方法有
1. Polling
2. Interrupt-driven I/O
3. DMA(Direct Memory Access)

Polling：最簡單的方式讓I/O device與CPU溝通。I/O device只要將information放進status register，CPU會週期性的檢查並取得information來得知需要服務的device。

Interrupt-driven I/O：利用interrupt的機制，當一個I/O device需要服務時，會發出interrupt來通知CPU。一個I/O interrupt對於指令的執行是asynchronous，Control unit需要在執行一個新指令時檢查是否有pending I/O interrupt。I/O interrupt也會傳達更多訊息，如哪個device發出的interrupt和它的priority。

DMA(Direct Memory Access)：提供一個device controller，讓I/O device能夠直接在記憶體做資料的傳輸，不需要CPU的參與。

DMA transfer的三個步驟
1. CPU要初始化DMA controller，包括提供I/O device的名稱、執行何種運算、記憶體位置以及所要傳送的bytes數。

2. DMA開始運作。如果request需要多於一次的transfer在bus上，DMA unit會產生下一個memory address和初始下一次的transfer。

3. 一旦DMA transfer完成，DMA controller發出一個interrupt給CPU。

優缺點比較
	Polling	Interrupt-driven I/O	DMA
優點	簡單容易執行，可利用軟體來更改CPU polling的順序	不用浪費許多時間在polling上面	適用於高速裝置不用浪費許多時間在polling上面
缺點	因為CPU速度遠快於I/O device，會浪費許多時間在polling上不適合high-bandwidth devices	需要有interrupt signals和interrupt service routine存在不適合high-bandwidth devices	需要有DMA controller

u-boot common/main.c

2012-02-02T16:57:00.000+08:00

接下来我们主要分析main_loop()

common/main.c:

void main_loop (void)

{

#ifndef CFG_HUSH_PARSER

static char lastcommand[CFG_CBSIZE] = { 0, };

int len;

int rc = 1;

int flag;

#endif

#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)

char *s;

int bootdelay;

#endif

#ifdef CONFIG_PREBOOT

char *p;

#endif

#ifdef CONFIG_BOOTCOUNT_LIMIT

unsigned long bootcount = 0;

unsigned long bootlimit = 0;

char *bcs;

char bcs_set[16];

#endif /* CONFIG_BOOTCOUNT_LIMIT */

#if defined(CONFIG_VFD) && defined(VFD_TEST_LOGO) /*smdk2410没定义*/

ulong bmp = 0; /* default bitmap */

extern int trab_vfd (ulong bitmap);

#ifdef CONFIG_MODEM_SUPPORT

if (do_mdm_init)

bmp = 1; /* alternate bitmap */

#endif

trab_vfd (bmp);

#endif /* CONFIG_VFD && VFD_TEST_LOGO */

#ifdef CONFIG_BOOTCOUNT_LIMIT /*smdk2410没定义*/

bootcount = bootcount_load();

bootcount++;

bootcount_store (bootcount);

sprintf (bcs_set, "%lu", bootcount);

setenv ("bootcount", bcs_set);

bcs = getenv ("bootlimit");

bootlimit = bcs ? simple_strtoul (bcs, NULL, 10) : 0;

#endif /* CONFIG_BOOTCOUNT_LIMIT */

#ifdef CONFIG_MODEM_SUPPORT /*smdk2410没定义*/

debug ("DEBUG: main_loop: do_mdm_init=%d/n", do_mdm_init);

if (do_mdm_init) {

uchar *str = strdup(getenv("mdm_cmd"));

setenv ("preboot", str); /* set or delete definition */

if (str != NULL)

free (str);

mdm_init(); /* wait for modem connection */

}

#endif /* CONFIG_MODEM_SUPPORT */

#ifdef CONFIG_VERSION_VARIABLE /*smdk2410没定义*/

{

extern char version_string[];

setenv ("ver", version_string); /* set version variable */

}

#endif /* CONFIG_VERSION_VARIABLE */

#ifdef CFG_HUSH_PARSER /*smdk2410没定义*/

u_boot_hush_start ();

#endif

#ifdef CONFIG_AUTO_COMPLETE /*smdk2410没定义*/

install_auto_complete();

#endif

#ifdef CONFIG_PREBOOT /*smdk2410没定义*/

if ((p = getenv ("preboot")) != NULL) {

# ifdef CONFIG_AUTOBOOT_KEYED /*smdk2410没定义*/

int prev = disable_ctrlc(1); /* disable Control C checking */

# endif

# ifndef CFG_HUSH_PARSER /*smdk2410没定义*/

run_command (p, 0);

# else

parse_string_outer(p, FLAG_PARSE_SEMICOLON |

FLAG_EXIT_FROM_LOOP);

# endif

# ifdef CONFIG_AUTOBOOT_KEYED /*smdk2410没定义*/

disable_ctrlc(prev); /* restore Control C checking */

# endif

}

#endif /* CONFIG_PREBOOT */

/**/

#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)

s = getenv ("bootdelay");

bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;

debug ("### main_loop entered: bootdelay=%d/n/n", bootdelay);

# ifdef CONFIG_BOOT_RETRY_TIME

init_cmd_timeout ();

# endif /* CONFIG_BOOT_RETRY_TIME */

#ifdef CONFIG_BOOTCOUNT_LIMIT

if (bootlimit && (bootcount > bootlimit)) {

printf ("Warning: Bootlimit (%u) exceeded. Using altbootcmd./n",

(unsigned)bootlimit);

s = getenv ("altbootcmd");

}

else

#endif /* CONFIG_BOOTCOUNT_LIMIT */

s = getenv ("bootcmd"); /*smdk2410下这个环境变量是空的*/

debug ("### main_loop: bootcmd=/"%s/"/n", s ? s : "<UNDEFINED>");

if (bootdelay >= 0 && s && !abortboot (bootdelay)) {

# ifdef CONFIG_AUTOBOOT_KEYED

int prev = disable_ctrlc(1); /* disable Control C checking */

# endif

# ifndef CFG_HUSH_PARSER

run_command (s, 0);

# else

parse_string_outer(s, FLAG_PARSE_SEMICOLON |

FLAG_EXIT_FROM_LOOP);

# endif

# ifdef CONFIG_AUTOBOOT_KEYED

disable_ctrlc(prev); /* restore Control C checking */

# endif

}

# ifdef CONFIG_MENUKEY

if (menukey == CONFIG_MENUKEY) {

s = getenv("menucmd");

if (s) {

# ifndef CFG_HUSH_PARSER

run_command (s, 0);

# else

parse_string_outer(s, FLAG_PARSE_SEMICOLON |

FLAG_EXIT_FROM_LOOP);

# endif

}

#endif /* CONFIG_MENUKEY */

#endif /* CONFIG_BOOTDELAY */

#ifdef CONFIG_AMIGAONEG3SE

{

extern void video_banner(void);

video_banner();

}

#endif

* Main Loop for Monitor Command Processing

* 最核心的就是下面这个死循环了

#ifdef CFG_HUSH_PARSER

parse_file_outer();

/* This point is never reached */

for (;;);

#else

for (;;) {

#ifdef CONFIG_BOOT_RETRY_TIME

if (rc >= 0) {

/* Saw enough of a valid command to

* restart the timeout.

reset_cmd_timeout();

}

#endif

len = readline (CFG_PROMPT);

flag = 0; /* assume no special flags for now */

if (len > 0)

strcpy (lastcommand, console_buffer);

else if (len == 0)

flag |= CMD_FLAG_REPEAT;

#ifdef CONFIG_BOOT_RETRY_TIME

else if (len == -2) {

/* -2 means timed out, retry autoboot

puts ("/nTimed out waiting for command/n");

# ifdef CONFIG_RESET_TO_RETRY

/* Reinit board to run initialization code again */

do_reset (NULL, 0, 0, NULL);

# else

return; /* retry autoboot */

# endif

}

#endif

if (len == -1)

puts ("<INTERRUPT>/n");

else

rc = run_command (lastcommand, flag);

if (rc <= 0) {

/* invalid command or not repeatable, forget it */

lastcommand[0] = 0;

}

#endif /*CFG_HUSH_PARSER*/

}

该函数比较长，但核心就是不停的从串口获取命令并解析执行此命令，这个功能就在函数尾部的那个死循环里，我们重点就是分析这个循环。

先看readline()

common/main.c:

/****************************************************************************/

* Prompt for input and read a line.

* If CONFIG_BOOT_RETRY_TIME is defined and retry_time >= 0,

* time out when time goes past endtime (timebase time in ticks).

* Return: number of read characters

* -1 if break

* -2 if timed out

* 上面的注释说的很清楚了，就是提示用户输入命令，并读取这个命令

int readline (const char *const prompt)

{

char *p = console_buffer; /* console_buffer 是个全局变量*/

int n = 0; /* buffer index */

int plen = 0; /* prompt length */

int col; /* output column cnt */

char c;

/* print prompt */

if (prompt) { /*如果要输出提示符，则输出*/

plen = strlen (prompt);

puts (prompt); //前面分析过了

}

col = plen;

for (;;) {

#ifdef CONFIG_BOOT_RETRY_TIME /*sdmk2410没定义*/

while (!tstc()) { /* while no incoming data */

if (retry_time >= 0 && get_ticks() > endtime)

return (-2); /* timed out */

}

#endif

WATCHDOG_RESET(); /* Trigger watchdog, if needed */

#ifdef CONFIG_SHOW_ACTIVITY /*sdmk2410没定义*/

while (!tstc()) {

extern void show_activity(int arg);

show_activity(0);

}

#endif

c = getc(); /*从串口获取用户输入的命令*/

* Special character handling

/*下面这个switch就是处理不同的字符了*/

switch (c) {

case '/r': /* Enter */

case '/n':

*p = '/0';

puts ("/r/n");

return (p - console_buffer); /*输入结束*/

case '/0': /* nul */ /*忽略，继续*/

continue;

case 0x03: /* ^C - break*//*呵呵，linux下的ctrl+c功能*/

console_buffer[0] = '/0'; /* discard input */

return (-1);

case 0x15: /* ^U - erase line */ /*删除*/

while (col > plen) {

puts (erase_seq);

--col;

}

p = console_buffer;

n = 0;

continue;

case 0x17: /* ^W - erase word *//*删除*/

p=delete_char(console_buffer, p, &col, &n, plen);

while ((n > 0) && (*p != ' ')) {

p=delete_char(console_buffer, p, &col, &n, plen);

}

continue;

case 0x08: /* ^H - backspace */

case 0x7F: /* DEL - backspace */

p=delete_char(console_buffer, p, &col, &n, plen);/*删除*/

continue;

default: /*获取常规字符*/

* Must be a normal character then

if (n < CFG_CBSIZE-2) {

if (c == '/t') { /* expand TABs */

#ifdef CONFIG_AUTO_COMPLETE

/* if auto completion triggered just continue */

/*自动补全功能，熟悉linux的肯定知道*/

*p = '/0';

if (cmd_auto_complete(prompt, console_buffer, &n, &col)) {

p = console_buffer + n; /* reset */

continue;

}

#endif

puts (tab_seq+(col&07));

col += 8 - (col&07);

} else {

++col; /* echo input */

putc (c);

}

*p++ = c;/*把字符保存在buffer中*/

++n;

} else { /* Buffer full */

putc ('/a');

}

上面这个函数就是提示用户输入，然后一直等待用户输入，指到用户输入完成, 然后获取用户数据，并存入全局变量console_buffer中。

再来回顾下那个for循环

common/main.c:

void main_loop (void)

{

……

#ifdef CFG_HUSH_PARSER

parse_file_outer();

/* This point is never reached */

for (;;);

#else

for (;;) {

#ifdef CONFIG_BOOT_RETRY_TIME

if (rc >= 0) {

/* Saw enough of a valid command to

* restart the timeout.

reset_cmd_timeout();

}

#endif

len = readline (CFG_PROMPT); /*获取用户下的command*/

flag = 0; /* assume no special flags for now */

if (len > 0)

strcpy (lastcommand, console_buffer); /*把command存入lastcommand中*/

else if (len == 0)

flag |= CMD_FLAG_REPEAT;

#ifdef CONFIG_BOOT_RETRY_TIME

else if (len == -2) {

/* -2 means timed out, retry autoboot

puts ("/nTimed out waiting for command/n");

# ifdef CONFIG_RESET_TO_RETRY

/* Reinit board to run initialization code again */

do_reset (NULL, 0, 0, NULL);

# else

return; /* retry autoboot */

# endif

}

#endif

if (len == -1)

puts ("<INTERRUPT>/n");

else

rc = run_command (lastcommand, flag); /*执行command*/

if (rc <= 0) {

/* invalid command or not repeatable, forget it */

lastcommand[0] = 0;

}

#endif /*CFG_HUSH_PARSER*/

}

OK！核心中的核心就是run_command函数了，一猜就知道是用户执行所有用户下达命令的函数。Let’s go

bootloader概述（转）

2012-02-02T16:42:00.006+08:00

引导加载程序是系统加电后运行的第一段软件代码。回忆一下 PC 的体系结构我们可以知道，PC 机中的引导加载程序由 BIOS(其本质就是一段固件程序)和位于硬盘 MBR 中的 OS Boot Loader（比如，LILO 和 GRUB 等）一起组成。BIOS 在完成硬件检测和资源分配后，将硬盘 MBR 中的 Boot Loader 读到系统的 RAM 中，然后将控制权交给 OS Boot Loader。Boot Loader 的主要运行任务就是将内核映象从硬盘上读到 RAM 中，然后跳转到内核的入口点去运行，也即开始启动操作系统。

而在嵌入式系统中，通常并没有像 BIOS 那样的固件程序（注，有的嵌入式 CPU 也会内嵌一段短小的启动程序），因此整个系统的加载启动任务就完全由 Boot Loader 来完成。比如在一个基于 ARM9 core 的嵌入式系统中，系统在上电或复位时通常都从地址 0x00000000 处开始执行，而在这个地址处安排的通常就是系统的 Boot Loader 程序。

本文将从 Boot Loader 的概念、Boot Loader 的主要任务、Boot Loader 的框架结构以及 Boot Loader 的安装等四个方面来讨论嵌入式系统的 Boot Loader。

Boot Loader 的概念

简单地说，Boot Loader 就是在操作系统内核运行之前运行的一段小程序。通过这段小程序，我们可以初始化硬件设备、建立内存空间的映射图，从而将系统的软硬件环境带到一个合适的状态，以便为最终调用操作系统内核准备好正确的环境。

通常，Boot Loader 是严重地依赖于硬件而实现的，特别是在嵌入式世界。因此，在嵌入式世界里建立一个通用的 Boot Loader 几乎是不可能的。尽管如此，我们仍然可以对 Boot Loader 归纳出一些通用的概念来，以指导用户特定的 Boot Loader 设计与实现。

1. Boot Loader 所支持的 CPU 和嵌入式板

每种不同的 CPU 体系结构都有不同的 Boot Loader。有些 Boot Loader 也支持多种体系结构的 CPU，比如 U-Boot 就同时支持 ARM 体系结构和MIPS 体系结构。除了依赖于 CPU 的体系结构外，Boot Loader 实际上也依赖于具体的嵌入式板级设备的配置。这也就是说，对于两块不同的嵌入式板而言，即使它们是基于同一种 CPU 而构建的，要想让运行在一块板子上的 Boot Loader 程序也能运行在另一块板子上，通常也都需要修改 Boot Loader 的源程序。

2. Boot Loader 的安装媒介（Installation Medium）

系统加电或复位后，所有的 CPU 通常都从某个由 CPU 制造商预先安排的地址上取指令。比如，基于 ARM7TDMI core 的 CPU 在复位时通常都从地址 0x00000000 取它的第一条指令。而基于 CPU 构建的嵌入式系统通常都有某种类型的固态存储设备(比如：ROM、EEPROM 或 FLASH 等)被映射到这个预先安排的地址上。因此在系统加电后，CPU 将首先执行 Boot Loader 程序。

3. 用来控制 Boot Loader 的设备或机制

主机和目标机之间一般通过串口建立连接，Boot Loader 软件在执行时通常会通过串口来进行 I/O，比如：输出打印信息到串口，从串口读取用户控制字符等。

4. Boot Loader 的启动过程是单阶段（Single Stage）还是多阶段（Multi-Stage）

通常多阶段的 Boot Loader 能提供更为复杂的功能，以及更好的可移植性。从固态存储设备上启动的 Boot Loader 大多都是 2 阶段的启动过程，也即启动过程可以分为 stage 1 和 stage 2 两部分。而至于在 stage 1 和 stage 2 具体完成哪些任务将在下面讨论。

5. Boot Loader 的操作模式 (Operation Mode)

大多数 Boot Loader 都包含两种不同的操作模式："启动加载"模式和"下载"模式，这种区别仅对于开发人员才有意义。但从最终用户的角度看，Boot Loader 的作用就是用来加载操作系统，而并不存在所谓的启动加载模式与下载工作模式的区别。

启动加载（Boot loading）模式：这种模式也称为"自主"（Autonomous）模式。也即 Boot Loader 从目标机上的某个固态存储设备上将操作系统加载到 RAM 中运行，整个过程并没有用户的介入。这种模式是 Boot Loader 的正常工作模式，因此在嵌入式产品发布的时侯，Boot Loader 显然必须工作在这种模式下。

下载（Downloading）模式：在这种模式下，目标机上的 Boot Loader 将通过串口连接或网络连接等通信手段从主机（Host）下载文件，比如：下载内核映像和根文件系统映像等。从主机下载的文件通常首先被 Boot Loader 保存到目标机的 RAM 中，然后再被 Boot Loader 写到目标机上的FLASH 类固态存储设备中。Boot Loader 的这种模式通常在第一次安装内核与根文件系统时被使用；此外，以后的系统更新也会使用 Boot Loader 的这种工作模式。工作于这种模式下的 Boot Loader 通常都会向它的终端用户提供一个简单的命令行接口。

像 Blob 或 U-Boot 等这样功能强大的 Boot Loader 通常同时支持这两种工作模式，而且允许用户在这两种工作模式之间进行切换。比如，U-boot 在启动时处于正常的启动加载模式，但是它会延时 10 秒等待终端用户按下任意键而将 U-boot切换到下载模式。如果在 10 秒内没有用户按键，则 U-boot 继续启动 Linux 内核。

6. BootLoader 与主机之间进行文件传输所用的通信设备及协议

最常见的情况就是，目标机上的 Boot Loader 通过串口与主机之间进行文件传输，传输协议通常是 xmodem／ymodem／zmodem 协议中的一种。但是，串口传输的速度是有限的，因此通过以太网连接并借助 TFTP 协议（或者NFS协议）来下载文件是个更好的选择。

此外，在论及这个话题时，主机方所用的软件也要考虑。比如，在通过以太网连接和 TFTP 协议（或者NFS协议）来下载文件时，主机方必须有一个软件用来的提供 TFTP（或者NFS）服务。

Boot Loader 的主要任务与典型结构框架

从操作系统的角度看，Boot Loader 的总目标就是正确地调用内核来执行。

另外，由于 Boot Loader 的实现依赖于 CPU 的体系结构，因此大多数 Boot Loader 都分为 stage1 和 stage2 两大部分。依赖于 CPU 体系结构的代码，比如设备初始化代码等，通常都放在 stage1 中，而且通常都用汇编语言来实现，以达到短小精悍的目的。而 stage2 则通常用C语言来实现，这样可以实现给复杂的功能，而且代码会具有更好的可读性和可移植性。

Boot Loader 的 stage1 通常包括以下步骤(以执行的先后顺序)：

硬件设备初始化。
为加载 Boot Loader 的 stage2 准备 RAM 空间。
拷贝 Boot Loader 的 stage2 到 RAM 空间中。
设置好堆栈。
跳转到 stage2 的 C 入口点。

Boot Loader 的 stage2 通常包括以下步骤(以执行的先后顺序)：

初始化本阶段要使用到的硬件设备。
检测系统内存映射(memory map)。
将 kernel 映像和根文件系统映像从 flash 上读到 RAM 空间中。
为内核设置启动参数。
调用内核。

Boot Loader 的 stage1

基本的硬件初始化

这是 Boot Loader 一开始就执行的操作，其目的是为 stage2 的执行以及随后的 kernel 的执行准备好一些基本的硬件环境。它通常包括以下步骤（以执行的先后顺序）：

1． 屏蔽所有的中断。为中断提供服务通常是 OS 设备驱动程序的责任，因此在 Boot Loader 的执行全过程中可以不必响应任何中断。中断屏蔽可以通过写 CPU 的中断屏蔽寄存器或状态寄存器（比如 ARM 的 CPSR 寄存器）来完成。

2．设置 CPU 的速度和时钟频率。

3． RAM 初始化。包括正确地设置系统的内存控制器的功能寄存器以及各内存库控制寄存器等。

4. 关闭 CPU 内部指令／数据 cache

拷贝 stage2 到 RAM 中

拷贝时要确定两点：(1) stage2 的可执行映象在固态存储设备的存放起始地址和终止地址；(2) RAM 空间的起始地址。

设置堆栈指针 sp

堆栈指针的设置是为了执行 C 语言代码作好准备。

跳转到 stage2 的 C 入口点

在上述一切都就绪后，就可以跳转到 Boot Loader 的 stage2 去执行了。比如，在 ARM 系统中，这可以通过修改 PC 寄存器为合适的地址来实现。

Boot Loader 的 stage2

stage2 的代码通常用 C 语言来实现，以便于实现更复杂的功能和取得更好的代码可读性和可移植性。但是与普通 C 语言应用程序不同的是，在编译和链接 boot loader 这样的程序时，我们不能使用 glibc 库中的任何支持函数。其原因是显而易见的。

初始化本阶段要使用到的硬件设备

这通常包括：初始化至少一个串口，以便和终端用户进行 I/O 输出信息。设备初始化完成后，可以输出一些打印信息，程序名字字符串、版本号等。

加载内核映像

从nor flash或nand flash（需要编写nand flash裸驱动）上将内核映像拷贝到RAM中

设置内核的启动参数

应该说，在将内核映像拷贝到 RAM 空间中后，就可以准备启动 Linux 内核了。但是在调用内核之前，应该作一步准备工作，即：设置 Linux 内核的启动参数。

Linux 2.4.x 以后的内核都期望以标记列表(tagged list)的形式来传递启动参数。启动参数标记列表以标记 ATAG_CORE 开始，以标记 ATAG_NONE 结束。每个标记由标识被传递参数的 tag_header 结构以及随后的参数值数据结构来组成。数据结构 tag 和 tag_header 定义在 Linux 内核源码的include/asm/setup.h 头文件中。在嵌入式 Linux 系统中，通常需要由 Boot Loader 设置的常见启动参数有：ATAG_CORE、ATAG_MEM、ATAG_CMDLINE

调用内核

Boot Loader 调用 Linux 内核的方法是直接跳转到内核的第一条指令处，也即直接跳转到 MEM_START＋0x8000 地址处。在跳转时，下列条件要满足：

1． CPU 寄存器的设置：

R0＝0；
R1＝机器类型 ID；关于 Machine Type Number，可以参见 linux/arch/arm/tools/mach-types。
R2＝启动参数标记列表在 RAM 中起始基地址；

2． CPU 模式：

必须禁止中断（IRQs和FIQs）；
CPU 必须 SVC 模式；

3． Cache 和 MMU 的设置：

MMU 必须关闭；
指令 Cache 可以打开也可以关闭；
数据 Cache 必须关闭；

如果用 C 语言，可以像下列示例代码这样来调用内核：

void (*theKernel)(int zero, int arch, u32 params_addr) = (void (*)(int, int, u32))KERNEL_RAM_BASE;

……

theKernel(0, ARCH_NUMBER, (u32) kernel_params_start);

注：到此为止，绝大多数内容均来源于詹荣开所著“嵌入式系统 Boot Loader 技术内幕”，只作了少量修改，可视为对该文的转载

下表显示的是几种不同的bootloader

Bootloader	Monitor	描述	x86	ARM	PowerPC
LILO	否	Linux磁盘引导程序	是	否	否
GRUB	否	GNU的 LILO替代程序	是	否	否
Loadlin	否	从 DOS引导 Linux	是	否	否
ROLO	否	从 ROM引导 Linux而不需要 BIOS	是	否	否
Etherboot	否	通过以太网卡启动 Linux系统的固件	是	否	否
LinuxBIOS	否	完全替代 BUIS的 Linux引导程序	是	否	否
BLOB	否	LART等硬件平台的引导程序	否	是	否
U-boot	是	通用引导程序	是	是	是
RedBoot	是	基于 eCos的引导程序	是	是	是

X86的工作站和服务器上一般使用 LILO和GRUB

ARM处理器的芯片商很多，所以每种芯片的开发板都有自己的Bootloader。结果ARM bootloader也变得多种多样。早有为ARM720处理器的开发板编写的固件，后来又有了armboot，以及StrongARM平台的blob，还有S3C2410处理器开发板上的vivi等。现在armboot已经并入了U-Boot，所以U-Boot也支持ARM/XSCALE平台。U- Boot已经成为ARM平台事实上的标准Bootloader。

PowerPC平台的处理器有标准的Bootloader，就是ppcboot。PPCBOOT在合并armboot等之后，创建了U-Boot，成为各种体系结构开发板的通用引导程序。U-Boot仍然是 PowerPC平台的主要Bootloader。

MIPS公司开发的 YAMON是标准的Bootloader，也有许多 MIPS芯片商为自己的开发板写了Bootloader。现在，U-Boot也已经支持 MIPS平台。

SH平台的标准 Bootloader是sh-boot。Redboot在这种平台上也很好用。

M68K平台没有标准的Bootloader。Redboot和U-boot能够支持 m68k系列的系统。

u-boot & kernel bring up工作紀錄

2012-02-02T10:22:00.018+08:00

一、U-Boot

u-boot主要帶起cpu, flash, ram, lan(tftp), 每個案子需求不同

1. 新增
(1) 在include中新增
product_info.h => 定義用來記錄product_info的structure

(2) 在include/configs中新增
dsr250n_common.h => 定義dsr250n的資訊, 如ram, memory等...(利用公板的版本修改)

2. lib_arm/board.c
(1) include product_info.h, 並把product_info儲存在ram中.

(2) 利用eth_init() 去 init ethernet (board\cavium\cns3000\cns3xxx_gsw.c)

3. common/main.c
(1) 於void main_loop (void) 中增加 len = readline (CFG_PROMPT_DSR250N);
(CFG_PROMPT_DSR250N = "DSR-250N # ", 用於顯示u-boot console的提示文字)

4. add u-boot commands
(1) common\cmd_nvedit.c
include product_info.h,

add :
do_printpd, do_getpd, do_setpd, do_savepd

(2) common\cmd_misc.c
include "../board/cavium/cns3000/cns3xxx_phy.h"
include "../board/cavium/cns3000/cns3xxx_symbol.h"

add:
do_phyread, do_phywrite, do_phyreadbypage,
  do_phywritebypage, do_GPIOCtrl, test_wps_button_cmd,
  test_reset_button_cmd, do_testled

(3) common\cmd_mem.c
加入新的do_mem_mtest

5. board\cavium\cns3000\
(1) vega.c
宣告 gpioA_dir, gpioA_set, gpioA_get,
gpioB_dir, gpioB_set, gpioB_get
並設定gpioA與gpioB的初始值

(2) cns3xxx_switch_type.h
參考公板去更改define的value

(3) cns3xxx_phy.h
參考公板去更改define的value

(4) cns3xxx_phy.c
add bcm53128_init_internal_phy等init function,

(5) cns3xxx_gsw.c
   avoid hw auto polling issue (hardward的bug)
- disable hw auto polling before enable MDC/MDIO
- this is workaround solution

6. 修改Makefile

二、Kernel

1. drivers\mtd\maps\cns3xxx-flash.c
定義U-boot, U-boot env, kernel, Cavium env, MD的size與offset

2. drivers\gpio\cns3xxx-gpio.c
(1) #include <mach/gpio.h>
(2) EXPORT_SYMBOL(cns3xxx_gpio_set_value); =>讓其他module使用
(3) 把kernel對gpio的改動mark掉 => 保留boot code的設定

3. \arch\arm\configs
增加dsr250n_defconfig與dsr150n_defconfig (參考公板)

4. mkbootpImage.sh
makefile

5. baudrate
    rootfs/etc/inittab

6. kernel\linux-2.6.31.1\arch\arm\mach-cns3xxx\pcie.c
    pcie1 init

u-boot 2008.10 board.c分析

2012-02-01T16:22:00.001+08:00

* Wolfgang Denk, DENX Software Engineering, wd@denx.de.

* Sysgo Real-Time Solutions, GmbH <www.elinos.com>

* Marius Groeger <mgroeger@sysgo.de>

* See file CREDITS for list of people who contributed to this

* project.

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License as

* published by the Free Software Foundation; either version 2 of

* the License, or (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston,

* MA 02111-1307 USA

* To match the U-Boot user interface on ARM platforms to the U-Boot

* standard (as on PPC platforms), some messages with debug character

* are removed from the default U-Boot build.

* Define DEBUG here if you want additional info as shown below

* printed upon startup:

* U-Boot code: 00F00000 -> 00F3C774 BSS: -> 00FC3274

* IRQ Stack: 00ebff7c

* FIQ Stack: 00ebef7c

#include <common.h>

#include <command.h>

#include <malloc.h>

#include <devices.h>

#include <version.h>

#include <net.h>

#include <serial.h>

#include <nand.h>

#include <onenand_uboot.h>

#ifdef CONFIG_DRIVER_SMC91111

#include "../drivers/net/smc91111.h"

#endif

#ifdef CONFIG_DRIVER_LAN91C96

#include "../drivers/net/lan91c96.h"

#endif

DECLARE_GLOBAL_DATA_PTR;

ulong monitor_flash_len;

#ifdef CONFIG_HAS_DATAFLASH

extern int AT91F_DataflashInit(void);

extern void dataflash_print_info(void);

#endif

#ifndef CONFIG_IDENT_STRING

#define CONFIG_IDENT_STRING ""

#endif

const char version_string[] =

U_BOOT_VERSION" (" __DATE__ " - " __TIME__ ")"CONFIG_IDENT_STRING;

#ifdef CONFIG_DRIVER_CS8900

extern void cs8900_get_enetaddr (uchar * addr);

#endif

#ifdef CONFIG_DRIVER_RTL8019

extern void rtl8019_get_enetaddr (uchar * addr);

#endif

#if defined(CONFIG_HARD_I2C) || \

defined(CONFIG_SOFT_I2C)

#include <i2c.h>

#endif

* Begin and End of memory area for malloc(), and current "brk"

static ulong mem_malloc_start = 0;

static ulong mem_malloc_end = 0;

static ulong mem_malloc_brk = 0;

static

void mem_malloc_init (ulong dest_addr)

{

mem_malloc_start = dest_addr;

mem_malloc_end = dest_addr + CFG_MALLOC_LEN;

mem_malloc_brk = mem_malloc_start;

memset ((void *) mem_malloc_start, 0,

mem_malloc_end - mem_malloc_start);

}

void *sbrk (ptrdiff_t increment)

{

ulong old = mem_malloc_brk;

ulong new = old + increment;

if ((new < mem_malloc_start) || (new > mem_malloc_end)) {

return (NULL);

}

mem_malloc_brk = new;

return ((void *) old);

}

/************************************************************************

* Coloured LED functionality

************************************************************************

* May be supplied by boards if desired

void inline __coloured_LED_init (void) {}

void inline coloured_LED_init (void) __attribute__((weak, alias("__coloured_LED_init")));

void inline __red_LED_on (void) {}

void inline red_LED_on (void) __attribute__((weak, alias("__red_LED_on")));

void inline __red_LED_off(void) {}

void inline red_LED_off(void) __attribute__((weak, alias("__red_LED_off")));

void inline __green_LED_on(void) {}

void inline green_LED_on(void) __attribute__((weak, alias("__green_LED_on")));

void inline __green_LED_off(void) {}

void inline green_LED_off(void)__attribute__((weak, alias("__green_LED_off")));

void inline __yellow_LED_on(void) {}

void inline yellow_LED_on(void)__attribute__((weak, alias("__yellow_LED_on")));

void inline __yellow_LED_off(void) {}

void inline yellow_LED_off(void)__attribute__((weak, alias("__yellow_LED_off")));

/************************************************************************

* Init Utilities *

************************************************************************

* Some of this code should be moved into the core functions,

* or dropped completely,

* but let's get it working (again) first...

static int init_baudrate (void) //初始化全局?据?中波特率的值

{

char tmp[64]; /* long enough for environment variables */

int i = getenv_r ("baudrate", tmp, sizeof (tmp));

gd->bd->bi_baudrate = gd->baudrate = (i > 0)

? (int) simple_strtoul (tmp, NULL, 10)

: CONFIG_BAUDRATE;

return (0);

}

static int display_banner (void)

{

/*by hugerat,phase 1 -----------------------*/

# if defined(CONFIG_rat2440_LED)

S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();

gpio->GPBDAT = 0x100; //hugerat

//在串口初始化和console初始化完成，串口?出信息之前，LED1、LED2、LED3?亮起！

#endif

/*-------------------------------------------*/

/*by hugerat,phase 2-------------------------*/

#if !defined(CONFIG_rat2440_LED)

S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();

#endif

/*--------------------------------------------*/

printf ("\n\n%s\n\n", version_string);

debug ("U-Boot code: %08lX -> %08lX BSS: -> %08lX\n",

_armboot_start, _bss_start, _bss_end);

#ifdef CONFIG_MODEM_SUPPORT

debug ("Modem Support enabled\n");

#endif

#ifdef CONFIG_USE_IRQ

debug ("IRQ Stack: %08lx\n", IRQ_STACK_START);

debug ("FIQ Stack: %08lx\n", FIQ_STACK_START);

#endif

return (0);

}

* WARNING: this code looks "cleaner" than the PowerPC version, but

* has the disadvantage that you either get nothing, or everything.

* On PowerPC, you might see "DRAM: " before the system hangs - which

* gives a simple yet clear indication which part of the

* initialization if failing.

static int display_dram_config (void)

{

int i;

#ifdef DEBUG //

puts ("RAM Configuration:\n");

for(i=0; i<CONFIG_NR_DRAM_BANKS; i++) {

printf ("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);

print_size (gd->bd->bi_dram[i].size, "\n");

}

#else

ulong size = 0;

for (i=0; i<CONFIG_NR_DRAM_BANKS; i++) {

size += gd->bd->bi_dram[i].size;

}

puts("DRAM: ");

print_size(size, "\n");

#endif

return (0);

}

#ifndef CFG_NO_FLASH

static void display_flash_config (ulong size)

{

puts ("Flash: ");

print_size (size, "\n");

}

#endif /* CFG_NO_FLASH */

#if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)

static int init_func_i2c (void)

{

puts ("I2C: ");

i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);

puts ("ready\n");

return (0);

}

#endif

* Breathe some life into the board...

* Initialize a serial port as console, and carry out some hardware

* tests.

* The first part of initialization is running from Flash memory;

* its main purpose is to initialize the RAM so that we

* can relocate the monitor code to RAM.

* All attempts to come up with a "common" initialization sequence

* that works for all boards and architectures failed: some of the

* requirements are just _too_ different. To get rid of the resulting

* mess of board dependent #ifdef'ed code we now make the whole

* initialization sequence configurable to the user.

* The requirements for any new initalization function is simple: it

* receives a pointer to the "global data" structure as it's only

* argument, and returns an integer return code, where 0 means

* "continue" and != 0 means "fatal error, hang the system".

typedef int (init_fnc_t) (void);

int print_cpuinfo (void); /* test-only */

init_fnc_t *init_sequence[] = {

cpu_init, /* basic cpu dependent setup CPU的基本?置 cpu/arm920t/cpu.c */

/*分配IRQ，FIQ?底地址，由于?有定?CONFIG_USE_IRQ,所以相?于空??。*/

board_init, /* 基本的板?相?配置 -- board/smdk2410/smdk2410.c */

interrupt_init, /* 初始化例外?理 -- cpu/arm920t/s3c24x0/interrupt.c */

/*初始化2410的PWM timer 4,使其能自?????值，恒定的?生??中?信?，但是中?被屏蔽了用不上。*/

env_init, /* 初始化?境?量 -- common/env_flash.c */

/*指定?境?的地址。default_environment是默?的?境???置 */

init_baudrate, /* 初始化波特率?置 -- lib_arm/board.c */

serial_init, /* 串口通??置 -- cpu/arm920t/s3c24x0/serial.c */

/*根据bd中波特率值和pclk,?置串口寄存器 */

console_init_f, /* 控制台初始化?段1 -- common/console.c */

/*由于?准????有初始化（gd->flags & GD_FLG_DEVINIT=0），??控制台使用串口作?控制台*/

display_banner, /* 打印u-boot信息 -- lib_arm/board.c */

#if defined(CONFIG_DISPLAY_CPUINFO)

print_cpuinfo, /* display cpu info (and speed) */

#endif

#if defined(CONFIG_DISPLAY_BOARDINFO)

checkboard, /* display board info */

#endif

#if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)

init_func_i2c,

#endif

dram_init, /* 配置可用的RAM -- board/smdk2410/smdk2410.c */

display_dram_config, /* ?示RAM的配置大小 -- lib_arm/board.c */

NULL,

};

void start_armboot (void)

{

init_fnc_t **init_fnc_ptr; //??初始化指?

char *s;

#if !defined(CFG_NO_FLASH) || defined (CONFIG_VFD) || defined(CONFIG_LCD)

ulong size;

#endif

#if defined(CONFIG_VFD) || defined(CONFIG_LCD)

unsigned long addr;

#endif

/* Pointer is writable since we allocated a register for it */

gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t));

// ?全局?据??行地址分配，_armboot_start?0x3f000000,CFG_MALLOC_LEN是堆大小＋?境?据?大小，config/smdk2410.h中CFG_MALLOC_LEN大小定??192KB.

/* compiler optimization barrier needed for GCC >= 3.4 */

__asm__ __volatile__("": : :"memory");//分配??空?

memset ((void*)gd, 0, sizeof (gd_t));

gd->bd = (bd_t*)((char*)gd - sizeof(bd_t));//分配板子?据?bd首地址。???合start.s中?的分配

memset (gd->bd, 0, sizeof (bd_t)); //分配板子?据?bd首地址。

gd->flags |= GD_FLG_RELOC;

monitor_flash_len = _bss_start - _armboot_start;

for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {

if ((*init_fnc_ptr)() != 0) {

hang (); //??信息?出函?

}

}//初始化函?

#ifndef CFG_NO_FLASH //配置可用的Flash?

/* configure available FLASH banks */

size = flash_init (); //配置可用的Flash?，?用board/smdk2410/flash.c

display_flash_config (size);

#endif /* CFG_NO_FLASH */

#ifdef CONFIG_VFD //把???????置在bss_end后面

# ifndef PAGE_SIZE

# define PAGE_SIZE 4096

# endif

* reserve memory for VFD display (always full pages)

/* bss_end is defined in the board-specific linker script */

addr = (_bss_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);

size = vfd_setmem (addr);

gd->fb_base = addr;

#endif /* CONFIG_VFD */

#ifdef CONFIG_LCD

/* board init may have inited fb_base */

if (!gd->fb_base) {

# ifndef PAGE_SIZE

# define PAGE_SIZE 4096

# endif

* reserve memory for LCD display (always full pages)

/* bss_end is defined in the board-specific linker script *//* ?示RAM的配置大小 -- lib_arm/board.c */

addr = (_bss_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);

size = lcd_setmem (addr);

gd->fb_base = addr;

}

#endif /* CONFIG_LCD */

/* armboot_start is defined in the board-specific linker script */

mem_malloc_init (_armboot_start - CFG_MALLOC_LEN);

/*?置heap?，供malloc使用。下面的?量和函?定?在lib_arm/board.c */

#if defined(CONFIG_CMD_NAND) //nand flash初始化

puts ("NAND: ");

nand_init(); /* go init the NAND */

#endif

#if defined(CONFIG_CMD_ONENAND)

onenand_init();

#endif

#ifdef CONFIG_HAS_DATAFLASH

AT91F_DataflashInit();

dataflash_print_info();

#endif

/* initialize environment */

env_relocate (); //初始化?境?量

#ifdef CONFIG_VFD

/* must do this after the framebuffer is allocated */

drv_vfd_init();

#endif /* CONFIG_VFD */

#ifdef CONFIG_SERIAL_MULTI

serial_initialize();

#endif

/* IP Address */

gd->bd->bi_ip_addr = getenv_IPaddr ("ipaddr");

/* MAC Address */

{

int i;

ulong reg;

char *s, *e;

char tmp[64];

i = getenv_r ("ethaddr", tmp, sizeof (tmp));

s = (i > 0) ? tmp : NULL;

for (reg = 0; reg < 6; ++reg) {

gd->bd->bi_enetaddr[reg] = s ? simple_strtoul (s, &e, 16) : 0;

if (s)

s = (*e) ? e + 1 : e;

}//初始化相?网???，填?IP、MAC地址

#ifdef CONFIG_HAS_ETH1

i = getenv_r ("eth1addr", tmp, sizeof (tmp));

s = (i > 0) ? tmp : NULL;

for (reg = 0; reg < 6; ++reg) {

gd->bd->bi_enet1addr[reg] = s ? simple_strtoul (s, &e, 16) : 0;

if (s)

s = (*e) ? e + 1 : e;

}

#endif

}

devices_init (); /* get the devices list going. 外???初始化定?于common/devices.c

#ifdef CONFIG_CMC_PU2

load_sernum_ethaddr ();

#endif /* CONFIG_CMC_PU2 */

jumptable_init ();

console_init_r (); /* fully init console as a device 后期控制台初始化*/

#if defined(CONFIG_MISC_INIT_R)

/* miscellaneous platform dependent initialisations */

misc_init_r ();

#endif

/* enable exceptions */

enable_interrupts ();

/* Perform network card initialisation if necessary */

#ifdef CONFIG_DRIVER_TI_EMAC

extern void davinci_eth_set_mac_addr (const u_int8_t *addr);

if (getenv ("ethaddr")) {

davinci_eth_set_mac_addr(gd->bd->bi_enetaddr);

}

#endif

#ifdef CONFIG_DRIVER_CS8900

cs8900_get_enetaddr (gd->bd->bi_enetaddr);

#endif

#if defined(CONFIG_DRIVER_SMC91111) || defined (CONFIG_DRIVER_LAN91C96)

if (getenv ("ethaddr")) {

smc_set_mac_addr(gd->bd->bi_enetaddr);

}

#endif /* CONFIG_DRIVER_SMC91111 || CONFIG_DRIVER_LAN91C96 */

/* Initialize from environment */

if ((s = getenv ("loadaddr")) != NULL) {

load_addr = simple_strtoul (s, NULL, 16);

}

#if defined(CONFIG_CMD_NET)

if ((s = getenv ("bootfile")) != NULL) {

copy_filename (BootFile, s, sizeof (BootFile));

}

#endif

#ifdef BOARD_LATE_INIT

board_late_init ();

#endif

#if defined(CONFIG_CMD_NET)

#if defined(CONFIG_NET_MULTI)

puts ("Net: ");

#endif

eth_initialize(gd->bd); //bd中已?IP，MAC已?初始化

#if defined(CONFIG_RESET_PHY_R)

debug ("Reset Ethernet PHY\n");

reset_phy();

#endif

/*by hugerat,phase 1---------------*/

#if defined(CONFIG_rat2440_LED)

S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();

#endif

/*---------------------------------*/

/*by hugerat,phase 1-------------------*/

# if defined(CONFIG_rat2440_LED)

gpio->GPBDAT = 0x0;

//在?入命令提示符之前，四?LED?同?亮起！

#endif

/*-------------------------------------*/

/* main_loop() can return to retry autoboot, if so just run it again. */

for (;;) {

main_loop ();

}

/* NOTREACHED - no way out of command loop except booting */

}

void hang (void)

{

puts ("### ERROR ### Please RESET the board ###\n");

for (;;);

}

#ifdef CONFIG_MODEM_SUPPORT

static inline void mdm_readline(char *buf, int bufsiz);

/* called from main loop (common/main.c) */

extern void dbg(const char *fmt, ...);

int mdm_init (void)

{

char env_str[16];

char *init_str;

int i;

extern char console_buffer[];

extern void enable_putc(void);

extern int hwflow_onoff(int);

enable_putc(); /* enable serial_putc() */

#ifdef CONFIG_HWFLOW

init_str = getenv("mdm_flow_control");

if (init_str && (strcmp(init_str, "rts/cts") == 0))

hwflow_onoff (1);

else

hwflow_onoff(-1);

#endif

for (i = 1;;i++) {

sprintf(env_str, "mdm_init%d", i);

if ((init_str = getenv(env_str)) != NULL) {

serial_puts(init_str);

serial_puts("\n");

for(;;) {

mdm_readline(console_buffer, CFG_CBSIZE);

dbg("ini%d: [%s]", i, console_buffer);

if ((strcmp(console_buffer, "OK") == 0) ||

(strcmp(console_buffer, "ERROR") == 0)) {

dbg("ini%d: cmd done", i);

break;

} else /* in case we are originating call ... */

if (strncmp(console_buffer, "CONNECT", 7) == 0) {

dbg("ini%d: connect", i);

return 0;

}

} else

break; /* no init string - stop modem init */

udelay(100000);

}

udelay(100000);

/* final stage - wait for connect */

for(;i > 1;) { /* if 'i' > 1 - wait for connection

message from modem */

mdm_readline(console_buffer, CFG_CBSIZE);

dbg("ini_f: [%s]", console_buffer);

if (strncmp(console_buffer, "CONNECT", 7) == 0) {

dbg("ini_f: connected");

return 0;

}

return 0;

}

/* 'inline' - We have to do it fast */

static inline void mdm_readline(char *buf, int bufsiz)

{

char c;

char *p;

int n;

n = 0;

p = buf;

for(;;) {

c = serial_getc();

/* dbg("(%c)", c); */

switch(c) {

case '\r':

break;

case '\n':

*p = '\0';

return;

default:

if(n++ > bufsiz) {

*p = '\0';

return; /* sanity check */

}

*p = c;

p++;

break;

}

#endif /* CONFIG_MODEM_SUPPORT */

出處:http://hi.baidu.com/wellalone/blog/item/337364af001368054a36d6f6.html

make 參數

2012-02-01T11:39:00.005+08:00

下面列舉了所有GNU make 3.80版的參數定義。其它Linux版本和產商的make大同小異，不過其它產商的make的具體參數還是請參考各自的產品文檔。

“-m”
    這兩個參數的作用是忽略和其它版本make的兼容性。

“-B”
“–always-make”認為所有的目標都需要更新（重編譯）。

“-C”
“–directory=”
指定讀取makefile的目錄。如果有多個“-C”參數，make的解釋是後面的路徑以前面的作為相對路徑，並以最後的目錄作為被指定目錄。如：“make –C ~hchen/test –C prog”等價於“make –C ~hchen/test/prog”。

輸出make的調試信息。它有幾種不同的級別可供選擇，如果沒有參數，那就是輸出最簡單的調試信息。下面是的取值：
a —— 也就是all，輸出所有的調試信息。（會非常的多）
b —— 也就是basic，只輸出簡單的調試信息。即輸出不需要重編譯的目標。
v —— 也就是verbose，在b選項的級別之上。輸出的信息包括哪個makefile被解析，不需要被重編譯的依賴文件（或是依賴目標）等。
i —— 也就是implicit，輸出所以的隱含規則。
j —— 也就是jobs，輸出執行規則中命令的詳細信息，如命令的PID、返回碼等。
m —— 也就是makefile，輸出make讀取makefile，更新makefile，執行makefile的信息。

“-d”
   相當於“–debug=a”。

“-e”
“–environment-overrides”
指明環境變量的值覆蓋makefile中定義的變量的值。

“-f=”
“–file=”
“–makefile=”
指定需要執行的makefile。

“-h”
“–help”
顯示幫助信息。

“-i”
“–ignore-errors”
在執行時忽略所有的錯誤。

“-I”
“–include-dir=”
   指定一個被包含makefile的搜索目標。可以使用多個“-I”參數來指定多個目錄。

“-j []”
“–jobs[=]”
指同時運行命令的個數。如果沒有這個參數，make運行命令時能運行多少就運行多少。如果有一個以上的“-j”參數，那麼僅最後一個“-j”才是有效的。（注意這個參數在MS-DOS中是無用的）

“-k”
“–keep-going”
出錯也不停止運行。如果生成一個目標失敗了，那麼依賴於其上的目標就不會被執行了。

“-l ”
“–load-average[=“—max-load[=]”
指定make運行命令的負載。

“-n”
“–just-print”
“–dry-run”
“–recon”
僅輸出執行過程中的命令序列，但並不執行。

“-o ”
“–old-file=”
“–assume-old=”
不重新生成的指定的，即使這個目標的依賴文件新於它。“-p”
“–print-data-base”
輸出makefile中的所有數據，包括所有的規則和變量。這個參數會讓一個簡單的makefile都會輸出一堆信息。如果你只是想輸出信息而不想執行makefile，你可以使用“make -qp”命令。如果你想查看執行makefile前的預設變量和規則，你可以使用“make –p –f /dev/null”。這個參數輸出的信息會包含著你的makefile文件的文件名和行號，所以，用這個參數來調試你的makefile會是很有用的，特別是當你的環境變量很複雜的時候。“-q”
“–question”
不運行命令，也不輸出。僅僅是檢查所指定的目標是否需要更新。如果是0則說明要更新，如果是2則說明有錯誤發生。

“-r”
“–no-builtin-rules”
禁止make使用任何隱含規則。

“-R”
“–no-builtin-variabes”
禁止make使用任何作用於變量上的隱含規則。

“-s”
“–silent”
“–quiet”
在命令運行時不輸出命令的輸出。

“-S”
“–no-keep-going”
“–stop”
取消“-k”選項的作用。因為有些時候，make的選項是從環境變量“MAKEFLAGS”中繼承下來的。所以你可以在命令行中使用這個參數來讓環境變量中的“-k”選項失效。

“-t”
“–touch”
相當於UNIX的touch命令，只是把目標的修改日期變成最新的，也就是阻止生成目標的命令運行。

“-v”
“–version”
輸出make程序的版本、版權等關於make的信息。

“-w”
“–print-directory”
輸出運行makefile之前和之後的信息。這個參數對於跟踪嵌套式調用make時很有用。

“–no-print-directory”
   禁止“-w”選項。

“-W ”
“–what-if=”
“–new-file=”
“–assume-file=”
假定目標需要更新，如果和“-n”選項使用，那麼這個參數會輸出該目標更新時的運行動作。如果沒有“-n”那麼就像運行UNIX的“touch”命令一樣，使得的修改時間為當前時間。

“–warn-undefined-variables”
只要make發現有未定義的變量，那麼就輸出警告信息。

出處: http://www.ha97.com/961.html

U-Boot 啟動流程與架構

2012-01-30T17:00:00.006+08:00

u-boot系統啟動流程

大多數bootloader都分為stage1和stage2兩大部分，u-boot也不例外。依賴於CPU體系結構的代碼(如設備初始化代碼等) 通常都放在stage1，且可以用彙編語言來實現，而stage2則通常用C語言來實現，這樣可以實現複雜的功能，而且有更好的可讀性和移植性。

stage1 (start.s代碼結構)

u-boot的stage1代碼通常放在start.s文件中，它用彙編語言寫成，其主要代碼部分如下:(1) 定義入口由於一個可執行的Image必須有一個入口點，並且只能有一個全局入口，通常這個入口放在ROM(Flash) 的0x0地址，因此，必須通知編譯器以使其知道這個入口，該工作可通過修改連接器腳本來完成。(2) 設置異常向量(Exception Vector) 。(3) 設置CPU的速度、時鐘頻率及中斷控制寄存器。　　(4) 初始化內存控制器　　(5) 將ROM中的程序複製到RAM中。　　(6) 初始化堆棧(7) 轉到RAM中執行，該工作可使用指令ldr pc來完成。

stage2 C語言代碼部分

lib_arm/board.c中的start_armboot是C語言開始的函數，也是整個啟動代碼中C語言的主函數，同時還是整個u-boot(armboot) 的主函數，該函數主要完成如下操作:　　(1) 調用一系列的初始化函數。　　(2) 初始化Flash設備。　　(3) 初始化系統內存分配函數。(4) 如果目標系統擁有NAND設備，則初始化NAND設備。(5) 如果目標系統有顯示設備，則初始化該類設備。(6) 初始化相關網絡設備，填寫IP、MAC地址等。(7) 進入命令循環(即整個boot的工作循環) ，接受用戶從串口輸入的命令，然後進行相應的工作。

目錄名稱	說明
board	包含所有已建立完成之開發板，與硬體相關之檔案，比如Makefile和u-boot.lds等都和具體開發板的硬體和地址分配有關。
common	與系統架構無關的檔案，包含環境變數的設定與執行遠端控制台各種命令的處理等。
cpu	CPU相關檔案，其中的子目錄都是以U-Boot所支援的CPU為名，比如有子目錄arm926ejs、mips、mpc8260和nios等，每個特定的子目錄中都包括cpu.c和interrupt.c，start.S。其中cpu.c初始化CPU、設置指令(Instruction) Cache和資料(Data) Cache等；interrupt.c設置系統的各種中斷和異常/特殊事件(Exception)，比如快速中斷、開關中斷、時鐘中斷、軟體中斷、預取中止和未定義指令等；start.S是U-Boot啟動時執行的第一個檔案，它主要是設定系統堆疊(Stack)和工作方式，為進入C程式作好前置作業。
disk	磁碟驅動與分區處理(partition handling)相關的程式碼。
doc	相關說明文件。
drivers	各種硬體設備驅動程式(Device Driver)，比如各種網路卡、支援CFI的Flash、串列埠(Serial Port)和USB等。
dtt	處理與溫度設備相關的控制。
examples	一些應用範例，例如：hello_world.c、sched.c等。
fs	與所支援檔案系統有關之原始程式，U-Boot現在支援cramfs、fat、fdos、jffs2和registerfs。
include	檔頭定義檔(.h)，還有對各種硬體平台支援的組合語言檔(.asm)，定義系統的各種配置，包含軟體與硬體。
lib_xxx	與各種不同架構相關的函式庫或程式碼。(lib_arm、lib_mips、lib_i386、lib_m68k等)。
lib_generic	公用的程式庫(Library)，例如：crc32.c(CRC Check)、zlib.c(壓縮)、string.c(字串處理)等。
net	處理與網絡有關之相關程式，BOOTP協定(Protocol)、TFTP協定、RARP協定和NFS檔案統的實現。
post	提供Power On Self Test功能。
rtc	Real Time Clock驅動程式。
tools	提供建立S-Record或U-Boot映像檔等工具程式。

SVN Commit SOP

2012-01-20T11:48:00.000+08:00

Commands:

svn checkout(co)-> check out project files from SVN server
svn export -> check out project files from SVN server with out SVN files
svn add -> add a file into the commit-list
svn del -> del a file into the commit-list
svn commit -> commit current commit-list

Rules:
1. 若有新增任何檔案, 用svn add將該檔案加入list中.
2. 關於先前已加入list中的檔案, 做了改動並不需要再svn add一次, 系統會自動偵測.
3. 用svn del去刪除任何不再需要的檔案.
4. 執行svn commit後, svn add與del所做的變動才會commit到server上.
5. 重新check out一份新的檔案再commit, 為最保險且不容易失敗的作法.

Steps:
1. svn add <file> (此步驟非必要)
2. svn del <file> (此步驟非必要)
3. svn commit

P.S.

After committing, please checkout again and check if the latest source code in server can competely be built without errors.
DO NOT commit unnecessary files to the server, such as temp files, or the files produced in compiling process.