Q:

Where to specify custom directive dependency. is it the same at controller and directive level?

I have a custom directive defined like this: 
app.directive('tagProfile', ['userService', function(userService) {
    return {
        restrict: 'E',
        scope: {
            mode: '@'
            ,entity: '='
            ,onUpdate: '&'
            ,onCancel: '&'
        },
        templateUrl: '/public/user/tag_profile.html',

        controller: ['$scope', function($scope) {
            $scope.userService = userService
        }],

        link: function(scope, element, attrs) {
        }
    }
}])

Notice that I inject userService in directive, because most of tutorials on custom directive inject dependencies there. I have tried to inject it in controller function and it works as well
    controller: ['$scope', 'userService', function($scope, userService) 

I am most likely to use only controller function, not link function. so userService won't be used in link. Beside that, is injecting in both places the same? or which one is better? 
Also, why is the link function injects scope instead of $scope? and we dont use explicit annotation for minify support? 

A:

I am most likely to use only controller function, not link function. so userService won't be used in link. Beside that, is injecting in both places the same? or which one is better?

If you're not going to utilise the link step, stick to injecting into the controller. If you wanted to utilise the controller and the link step, go for injection at the directive definition. 
There is no difference in which of the two is better or which of the two is recommended as far as I know. 
This is referring to the userService in this case. Injecting $scope into the directive definition, is not something I've ever done so I can't say what sort of side effects that may bring. 
Is it the same?

From the controllers point of view? Yes.
From the linkers point of view? No.

Also, why is the link function injects scope instead of $scope? and we dont use explicit annotation for minify support?

The first parameter to link will always be a $scope, so it doesn't matter what you name it. 
/** 
 * $compileProvider.$get
 * L#6931 in angular.js 
 */
return compile;

function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) {
  /**
   * Redacted code...
   */
  return function publicLinkFn(scope, cloneConnectFn, options) { 

Explicit annotation is not needed for the link function (returned by compile) as it is not prone(or, open) to DI. It's arguments are pre-set.
This would work just as well as being explicit in the naming: 
return {
  link: function (a,b,c) {
    // { a: $scope, b: $element, c: $attrs }
  }
}

tl;dr

Dont inject 'stuff' into the directive if you're only using 'stuff' in the controller. 
link is not open to DI. 

